plugin: Directly output resampled frames to host within Resample_f32()

In my resample procedure, Resample_f32() will finally output the same
amount of frames as the buffer size. So why not directly specify host
audio buffer as Resample_f32()'s argument "output"?

By directly writing to final audio buffer, intermediate buffers are
no longer required. So I dropped `buffer_after_resample(l|r)`. Time for
copying sample frames is also saved, as the final for-loop is also no
longer needed.

For sanity check, in Resample_f32(), I added a new parameter
`maxOutputSize`, which acts like strncpy() and snprintf(). Just in case
the output buffer size is larger than audio buffer size.

Author: AnClark

plugin/MinatonPlugin.cpp

@@ -131,15 +131,8 @@ void MinatonPlugin::run(const float** inputs, float** outputs, uint32_t frames,
         // Process each channel respectively.
         // Note: The resampler functions are originally designed for interleaved WAV files.
         const int channels = 1;
-        Resample_f32(buffer_before_resample_l, buffer_after_resample_l, 44100, int(fSampleRate), expect_input_size / channels, channels);
-        Resample_f32(buffer_before_resample_r, buffer_after_resample_r, 44100, int(fSampleRate), expect_input_size / channels, channels);
-
-        // NOTICE: Do not use memcpy(). Use for-loop.
-        //         Otherwise the output samples will not be continuous!
-        for (uint32_t x = 0; x < frames; x++) {
-            outputs[0][x] = buffer_after_resample_l[x];
-            outputs[1][x] = buffer_after_resample_r[x];
-        }
+        Resample_f32(buffer_before_resample_l, outputs[0], 44100, int(fSampleRate), expect_input_size / channels, channels, frames);
+        Resample_f32(buffer_before_resample_r, outputs[1], 44100, int(fSampleRate), expect_input_size / channels, channels, frames);
     }
 }
 
@@ -171,25 +164,18 @@ void MinatonPlugin::initResampler(uint32_t bufferSize)
 {
     buffer_before_resample_l = (float*)malloc(sizeof(float) * bufferSize);
     buffer_before_resample_r = (float*)malloc(sizeof(float) * bufferSize);
-    buffer_after_resample_l = (float*)malloc(sizeof(float) * bufferSize);
-    buffer_after_resample_r = (float*)malloc(sizeof(float) * bufferSize);
 }
 
 void MinatonPlugin::reinitResampler(uint32_t bufferSize, uint32_t sampleRate)
 {
     buffer_before_resample_l = (float*)realloc(buffer_before_resample_l, sizeof(float) * bufferSize);
     buffer_before_resample_r = (float*)realloc(buffer_before_resample_r, sizeof(float) * bufferSize);
-
-    buffer_after_resample_l = (float*)realloc(buffer_after_resample_l, sizeof(float) * bufferSize);
-    buffer_after_resample_r = (float*)realloc(buffer_after_resample_r, sizeof(float) * bufferSize);
 }
 
 void MinatonPlugin::cleanupResampler()
 {
     free(buffer_before_resample_l);
     free(buffer_before_resample_r);
-    free(buffer_after_resample_l);
-    free(buffer_after_resample_r);
 }
 
 Plugin* createPlugin()

plugin/MinatonPlugin.h

@@ -24,7 +24,6 @@ class MinatonPlugin : public Plugin {
 
     // Resampler data
     float *buffer_before_resample_l, *buffer_before_resample_r;
-    float *buffer_after_resample_l, *buffer_after_resample_r;
 
 public:
     MinatonPlugin();

vendor/resampler/resampler.cpp

@@ -35,7 +35,7 @@ uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int o
 }
 
 uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int outSampleRate, double inputSize,
-    uint32_t channels)
+    uint32_t channels, uint32_t maxOutputSize)
 {
     if (input == NULL)
         return 0;
@@ -57,6 +57,9 @@ uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int o
     if (output == NULL)
         return outputSize;
 
+    // Prevent out-of-range exceptions
+    outputSize = (outputSize > maxOutputSize) ? maxOutputSize : outputSize;
+
     double stepDist = ((double)inSampleRate / (double)outSampleRate);
     const uint64_t fixedFraction = (1LL << 32);
     const double normFixed = (1.0 / (1LL << 32));

vendor/resampler/resampler.hpp

@@ -20,7 +20,7 @@ uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int o
     uint32_t channels);
 
 uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int outSampleRate, double inputSize,
-    uint32_t channels);
+    uint32_t channels, uint32_t maxOutputSize);
 
 uint64_t Resample_s16(const int16_t* input, int16_t* output, int inSampleRate, int outSampleRate, uint64_t inputSize,
     uint32_t channels);