Update for using the new pre/postprocess_in/output_channels member

Author: faressc

TODO.md

@@ -9,6 +9,7 @@
 - [ ] Add option to select different model functions
 - [ ] Add option for dynamic input size
 - [ ] Manual inference triggering
+- [ ] Fix TFLite benchmark error
 
 ## How to handle parameters
 

docs/anira-usage.md

@@ -95,7 +95,7 @@ There are also some optional parameters that can be set in the `anira::Inference
 If your model does not require any specific pre- or post-processing, you can use the default `anira::PrePostProcessor`. This is likely to be the case if the input and output shapes of the model are the same, the batchsize is 1, and your model operates in the time domain.
 
 ```cpp
-anira::PrePostProcessor pp_processor;
+anira::PrePostProcessor pp_processor(inference_config);
 ```
 
 If your model requires custom pre- or post-processing, you can inherit from the `anira::PrePostProcessor` class and overwrite the ```pre_process``` and ```post_process``` methods so that they match your model's requirements. In the ```pre_process``` method, we get the input samples from the audio application through an `anira::RingBuffer` and push them into the output buffer, which is an `anira::BufferF`. This output buffer is then used for inference. In the ```post_process``` method we get the input samples through an `anira::BufferF` and push them into the output buffer, which is an `anira::RingBuffer`. The samples from this output buffer are then returned to the audio application by the `anira::InferenceHandler`.
@@ -108,6 +108,8 @@ When your pre- and post-processing requires to access values from the `anira::In
 
 class CustomPrePostProcessor : public anira::PrePostProcessor {
 public:
+    using anira::PrePostProcessor::PrePostProcessor;
+
     virtual void pre_process(anira::RingBuffer& input, anira::BufferF& output, [[maybe_unused]] anira::InferenceBackend current_inference_backend) override {
         pop_samples_from_buffer(input, output, inference_config.get_tensor_output_size()[inference_config.m_index_audio_data[anira::IndexAudioData::Output]], inference_config.get_tensor_input_size()[inference_config.m_index_audio_data[anira::IndexAudioData::Input]]-inference_config.get_tensor_output_size()[inference_config.m_index_audio_data[anira::IndexAudioData::Output]]);
     };
@@ -144,9 +146,9 @@ In your application, you will need to create an instance of the `anira::Inferenc
 // Sample initialization in your application's initialization function
 
 // Default PrePostProcessor
-anira::PrePostProcessor pp_processor;
+anira::PrePostProcessor pp_processor(inference_config);
 // or custom PrePostProcessor
-CustomPrePostProcessor pp_processor;
+CustomPrePostProcessor pp_processor(inference_config);
 
 // Create an InferenceHandler instance
 anira::InferenceHandler inference_handler(pp_processor, inference_config);

docs/benchmark-usage.md

@@ -29,7 +29,7 @@ typedef anira::benchmark::ProcessBlockFixture ProcessBlockFixture;
 anira::InferenceConfig my_inference_config(
     ...
 );
-anira::PrePostProcessor my_pp_processor;
+anira::PrePostProcessor my_pp_processor(my_inference_config);
 
 BENCHMARK_DEFINE_F(ProcessBlockFixture, BM_SIMPLE)(::benchmark::State& state) {
 
@@ -43,7 +43,7 @@ BENCHMARK_DEFINE_F(ProcessBlockFixture, BM_SIMPLE)(::benchmark::State& state) {
     m_inference_handler->set_inference_backend(inference_backend);
 
     // Create a static Buffer instance
-    m_buffer = std::make_unique<anira::Buffer<float>>(my_inference_config.m_num_audio_channels[anira::Input], host_config.m_host_buffer_size);
+    m_buffer = std::make_unique<anira::Buffer<float>>(my_inference_config.get_preprocess_input_channels()[0], host_config.m_host_buffer_size);
 
     // Initialize the repetition
     initialize_repetition(my_inference_config, host_config, inference_backend, true);
@@ -240,7 +240,7 @@ BENCHMARK_DEFINE_F(ProcessBlockFixture, BM_ADVANCED)(::benchmark::State& state)
     // Use state.range(2) to select the inference backend
     m_inference_handler->set_inference_backend(inference_backends[state.range(2)]);
 
-    m_buffer = std::make_unique<anira::Buffer<float>>(inference_config.m_num_audio_channels[anira::Input], host_config.m_host_buffer_size);
+    m_buffer = std::make_unique<anira::Buffer<float>>(inference_config.get_preprocess_input_channels()[0], host_config.m_host_buffer_size);
 
     initialize_repetition(inference_config, host_config, inference_backends[state.range(2)]);
 

examples/benchmark/advanced-benchmark/defineAdvancedBenchmark.cpp

@@ -66,13 +66,11 @@ BENCHMARK_DEFINE_F(ProcessBlockFixture, BM_ADVANCED)(::benchmark::State& state)
     anira::PrePostProcessor *my_pp_processor;
 
     if (state.range(1) == 0) {
-        my_pp_processor = new CNNPrePostProcessor();
-        static_cast<CNNPrePostProcessor*>(my_pp_processor)->m_inference_config = inference_config;
+        my_pp_processor = new CNNPrePostProcessor(inference_config);
     } else if (state.range(1) == 1) {
-        my_pp_processor = new HybridNNPrePostProcessor();
-        static_cast<HybridNNPrePostProcessor*>(my_pp_processor)->m_inference_config = inference_config;
+        my_pp_processor = new HybridNNPrePostProcessor(inference_config);
     } else if (state.range(1) == 2) {
-        my_pp_processor = new anira::PrePostProcessor();
+        my_pp_processor = new anira::PrePostProcessor(inference_config);
     }
 
     ClearCustomProcessor clear_custom_processor(inference_config);
@@ -81,7 +79,7 @@ BENCHMARK_DEFINE_F(ProcessBlockFixture, BM_ADVANCED)(::benchmark::State& state)
     m_inference_handler->prepare(host_config);
     m_inference_handler->set_inference_backend(inference_backends[state.range(2)]);
 
-    m_buffer = std::make_unique<anira::Buffer<float>>(inference_config.m_num_audio_channels[anira::Input], host_config.m_host_buffer_size);
+    m_buffer = std::make_unique<anira::Buffer<float>>(inference_config.get_preprocess_input_channels()[0], host_config.m_host_buffer_size);
 
     initialize_repetition(inference_config, host_config, inference_backends[state.range(2)]);
 

examples/benchmark/cnn-size-benchmark/defineCNNSizeBenchmark.cpp

@@ -60,14 +60,13 @@ BENCHMARK_DEFINE_F(ProcessBlockFixture, BM_CNNSIZE)(::benchmark::State& state) {
 
     anira::PrePostProcessor *my_pp_processor;
 
-    my_pp_processor = new CNNPrePostProcessor();
-    static_cast<CNNPrePostProcessor*>(my_pp_processor)->m_inference_config = inference_config;
+    my_pp_processor = new CNNPrePostProcessor(inference_config);
 
     m_inference_handler = std::make_unique<anira::InferenceHandler>(*my_pp_processor, inference_config);
     m_inference_handler->prepare(host_config);
     m_inference_handler->set_inference_backend(inference_backends[state.range(2)]);
 
-    m_buffer = std::make_unique<anira::Buffer<float>>(inference_config.m_num_audio_channels[anira::Input], host_config.m_host_buffer_size);
+    m_buffer = std::make_unique<anira::Buffer<float>>(inference_config.get_preprocess_input_channels()[0], host_config.m_host_buffer_size);
 
     initialize_repetition(inference_config, host_config, inference_backends[state.range(2)]);
 

examples/benchmark/simple-benchmark/defineSimpleBenchmark.cpp

@@ -28,11 +28,11 @@
 typedef anira::benchmark::ProcessBlockFixture ProcessBlockFixture;
 
 // anira::InferenceConfig my_inference_config = cnn_config;
-// CNNPrePostProcessor my_pp_processor;
+// CNNPrePostProcessor my_pp_processor(my_inference_config);
 anira::InferenceConfig my_inference_config = hybridnn_config;
-HybridNNPrePostProcessor my_pp_processor;
+HybridNNPrePostProcessor my_pp_processor(my_inference_config);
 // anira::InferenceConfig my_inference_config = rnn_config;
-// anira::PrePostProcessor my_pp_processor;
+// anira::PrePostProcessor my_pp_processor(my_inference_config);
 // anira::InferenceConfig my_inference_config = gain_config;
 // anira::PrePostProcessor my_pp_processor(my_inference_config);
 // anira::InferenceConfig my_inference_config = stereo_gain_config;
@@ -48,7 +48,7 @@ BENCHMARK_DEFINE_F(ProcessBlockFixture, BM_SIMPLE)(::benchmark::State& state) {
     m_inference_handler->prepare(host_config);
     m_inference_handler->set_inference_backend(inference_backend);
 
-    m_buffer = std::make_unique<anira::Buffer<float>>(my_inference_config.m_num_audio_channels[anira::Input], host_config.m_host_buffer_size);
+    m_buffer = std::make_unique<anira::Buffer<float>>(my_inference_config.get_preprocess_input_channels()[0], host_config.m_host_buffer_size);
 
     initialize_repetition(my_inference_config, host_config, inference_backend);
 

examples/clap-audio-plugin/anira-clap-demo.cpp

@@ -17,6 +17,7 @@ AniraClapPluginExample::AniraClapPluginExample(const clap_host *host)
                             clap::helpers::CheckingLevel::Maximal>(&m_desc, host),
       m_bypass_processor(m_inference_config),
       m_anira_context(static_cast<int>(std::thread::hardware_concurrency() / 2)),
+      m_pp_processor(m_inference_config),
       m_inference_handler(m_pp_processor, m_inference_config, m_bypass_processor, m_anira_context),
       m_plugin_latency(0)
 {

examples/juce-audio-plugin/PluginProcessor.cpp

@@ -16,12 +16,12 @@ AudioPluginAudioProcessor::AudioPluginAudioProcessor()
         anira_context_config(
             std::thread::hardware_concurrency() / 2 > 0 ? std::thread::hardware_concurrency() / 2 : 1 // Total number of threads
         ),
+        pp_processor(inference_config),
 #if MODEL_TO_USE == 1 || MODEL_TO_USE == 2
         // The bypass_processor is not needed for inference, but for the round trip test to output audio when selecting the CUSTOM backend. It must be customized when default pp_processor is replaced by a custom one.
         bypass_processor(inference_config),
         inference_handler(pp_processor, inference_config, bypass_processor, anira_context_config),
 #elif MODEL_TO_USE == 3 || MODEL_TO_USE == 4 || MODEL_TO_USE == 5
-        pp_processor(inference_config),
         inference_handler(pp_processor, inference_config),
 #endif
         dry_wet_mixer(32768) // 32768 samples of max latency compensation for the dry-wet mixer

extras/models/cnn/CNNPrePostProcessor.h

@@ -7,11 +7,11 @@
 class CNNPrePostProcessor : public anira::PrePostProcessor
 {
 public:
+    using anira::PrePostProcessor::PrePostProcessor;
+
     virtual void pre_process(anira::RingBuffer& input, anira::BufferF& output, [[maybe_unused]] anira::InferenceBackend current_inference_backend) override {
         pop_samples_from_buffer(input, output, m_inference_config.get_tensor_output_size()[m_inference_config.m_index_audio_data[anira::IndexAudioData::Output]], m_inference_config.get_tensor_input_size()[m_inference_config.m_index_audio_data[anira::IndexAudioData::Input]]-m_inference_config.get_tensor_output_size()[m_inference_config.m_index_audio_data[anira::IndexAudioData::Output]]);
     }
-
-    anira::InferenceConfig m_inference_config = cnn_config;
 };
 
 #endif //ANIRA_CNNPREPOSTPROCESSOR_H

extras/models/hybrid-nn/HybridNNPrePostProcessor.h

@@ -7,6 +7,8 @@
 class HybridNNPrePostProcessor : public anira::PrePostProcessor
 {
 public:
+    using anira::PrePostProcessor::PrePostProcessor;
+      
     virtual void pre_process(anira::RingBuffer& input, anira::BufferF& output, [[maybe_unused]] anira::InferenceBackend current_inference_backend) override {
         int64_t num_batches = 0;
         int64_t num_input_samples = 0;
@@ -67,8 +69,6 @@ class HybridNNPrePostProcessor : public anira::PrePostProcessor
             pop_samples_from_buffer(input, output, (size_t) num_output_samples, (size_t) (num_input_samples-num_output_samples), base_index);
         }
     }
-    
-    anira::InferenceConfig m_inference_config = hybridnn_config;
 };
 
 #endif //ANIRA_HYBRIDNNPREPOSTPROCESSOR_H