Resample output in real-time when sample rate != 44100

AnClark · AnClark · commit fd07b44c4311 · 2023-02-23T09:32:57.000+08:00
Here I introduce a resampler algorithm created by @cpuimage, which is fast and reliable. MIT licensed. Resampler Principle: to make sure that resampled audio frames can just fill in the whole buffer, without any empty buffer frame.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -98,6 +98,7 @@ dpf_add_plugin (${PROJECT_NAME}
         plugin/MinatonPlugin.cpp
         plugin/MinatonProcess.cpp
         plugin/MinatonParamAccess.cpp
+        vendor/resampler/resampler.cpp
     FILES_UI
         plugin/MinatonUI.cpp
         plugin/MinatonUIHelper.cpp
@@ -110,6 +111,7 @@ target_include_directories (${PROJECT_NAME} PUBLIC
     plugin/
     src/
     ${GENERATED_WAVES_DIR}
+    vendor/resampler
 )
 
 add_dependencies (${PROJECT_NAME}-dsp generate_waves)
diff --git a/plugin/MinatonPlugin.cpp b/plugin/MinatonPlugin.cpp
@@ -2,6 +2,8 @@
 #include "DistrhoPlugin.hpp"
 #include "MinatonParams.h"
 
+#include "resampler.hpp"
+
 START_NAMESPACE_DISTRHO
 
 MinatonPlugin::MinatonPlugin()
@@ -33,11 +35,16 @@ MinatonPlugin::MinatonPlugin()
     fSynthesizer->release_envelope2();
     fSynthesizer->envelope1.level = 0;
     fSynthesizer->envelope2.level = 0;
+
+    // Initialize resample buffer
+    initResampler(getBufferSize());
 }
 
 MinatonPlugin::~MinatonPlugin()
 {
     fSynthesizer->cleanup();
+
+    cleanupResampler();
 }
 
 void MinatonPlugin::initParameter(uint32_t index, Parameter& parameter)
@@ -98,13 +105,91 @@ void MinatonPlugin::run(const float** inputs, float** outputs, uint32_t frames,
         return;
     }
 
-    for (unsigned int x = 0; x < frames; x++) {
-        _processAudioFrame(outputs[0], outputs[1], x);
+    // Generate and output audio frames.
+    //   - If sample rate == 44100.0f (default sample rate), output frames as-is.
+    //   - If not, perform a resample on final mix.
+    if (fSampleRate == 44100.0f) {
+        for (unsigned int x = 0; x < frames; x++) {
+            _processAudioFrame(outputs[0], outputs[1], x);
+        }
+    } else {
+        // Resample principle: Fill in the audio buffer with resampled frames.
+        //     For example, audio buffer's size is 512, and target sample rate is 96000 Hz.
+        //     1. Find out an input sample count so that resampler can output just 512 samples.
+        //        Result is 235.2.
+        //     2. Run _processAudioFrame(), and generate 235 samples (decimal is floored).
+        //     3. Run Resample_f32() to resample two channels. It will output 512 samples.
+        //     4. Put the resampled frames to audio buffer.
+        // Based on @cpuimage's resample algorithm.
+
+        const double expect_input_size = getExpectedInputSize(44100.0f, fSampleRate, frames);
+
+        for (uint32_t x = 0; x < expect_input_size; x++) {
+            _processAudioFrame(buffer_before_resample_l, buffer_before_resample_r, x);
+        }
+
+        // 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];
+        }
+    }
+}
+
+void MinatonPlugin::bufferSizeChanged(int newBufferSize)
+{
+    if (fBufferSize != newBufferSize) {
+        d_stderr("[DSP] Buffer size changed: from %d to %d", fBufferSize, newBufferSize);
+
+        fBufferSize = newBufferSize;
+        reinitResampler(fBufferSize, fSampleRate);
+    } else {
+        d_stderr("[DSP] Buffer size changed: same as current value, %d", fBufferSize);
     }
 }
 
 void MinatonPlugin::sampleRateChanged(double newSampleRate)
 {
+    if (fSampleRate != newSampleRate) {
+        d_stderr("[DSP] Sample rate changed: from %f to %f", fSampleRate, newSampleRate);
+
+        fSampleRate = newSampleRate;
+        reinitResampler(fBufferSize, fSampleRate);
+    } else {
+        d_stderr("[DSP] Sample rate changed: same as current value, %f", fSampleRate);
+    }
+}
+
+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()
diff --git a/plugin/MinatonPlugin.h b/plugin/MinatonPlugin.h
@@ -11,6 +11,7 @@ START_NAMESPACE_DISTRHO
 
 class MinatonPlugin : public Plugin {
     double fSampleRate = getSampleRate();
+    double fBufferSize = getBufferSize();
     std::unique_ptr<minaton_synth_dpf> fSynthesizer = std::make_unique<minaton_synth_dpf>();
 
     // Minaton note key data
@@ -21,6 +22,10 @@ class MinatonPlugin : public Plugin {
     int last_note;
     int control_delay;
 
+    // Resampler data
+    float *buffer_before_resample_l, *buffer_before_resample_r;
+    float *buffer_after_resample_l, *buffer_after_resample_r;
+
 public:
     MinatonPlugin();
     ~MinatonPlugin();
@@ -103,6 +108,7 @@ class MinatonPlugin : public Plugin {
     // ----------------------------------------------------------------------------------------------------------------
     // Callbacks (optional)
 
+    void bufferSizeChanged(int newBufferSize);
     void sampleRateChanged(double newSampleRate) override;
 
 private:
@@ -112,6 +118,10 @@ class MinatonPlugin : public Plugin {
     float _obtainSynthParameter(MinatonParamId index) const;
     void _applySynthParameter(MinatonParamId index, float value);
 
+    void initResampler(uint32_t bufferSize);
+    void reinitResampler(uint32_t bufferSize, uint32_t sampleRate);
+    void cleanupResampler();
+
     // ----------------------------------------------------------------------------------------------------------------
     // Processors
 
diff --git a/vendor/resampler/README.md b/vendor/resampler/README.md
@@ -0,0 +1,78 @@
+# resampler
+A Simple and Efficient Audio Resampler Implementation in C. Created by [@cpuimage](https://github.com/cpuimage).
+
+**NOTICE:** This edition has AnClark's extensions dedicated to Minaton-XT:
+
+- `getExpectedInputSize()`: Given a target output buffer size, calculate how many input frames shall we have.
+- `Resample_f32()` variant: Receive float-point value as `inputSize`, because `getExpectedInputSize()` usually returns a float-point value as well.
+
+Example
+=======
+
+```C
+uint64_t Resample_f32(const float *input, float *output, int inSampleRate, int outSampleRate, uint64_t inputSize,
+                      uint32_t channels
+) {
+    if (input == NULL)
+        return 0;
+    uint64_t outputSize = (uint64_t) (inputSize * (double) outSampleRate / (double) inSampleRate);
+    outputSize -= outputSize % channels;
+    if (output == NULL)
+        return outputSize;
+    double stepDist = ((double) inSampleRate / (double) outSampleRate);
+    const uint64_t fixedFraction = (1LL << 32);
+    const double normFixed = (1.0 / (1LL << 32));
+    uint64_t step = ((uint64_t) (stepDist * fixedFraction + 0.5));
+    uint64_t curOffset = 0;
+    for (uint32_t i = 0; i < outputSize; i += 1) {
+        for (uint32_t c = 0; c < channels; c += 1) {
+            *output++ = (float) (input[c] + (input[c + channels] - input[c]) * (
+                    (double) (curOffset >> 32) + ((curOffset & (fixedFraction - 1)) * normFixed)
+            )
+            );
+        }
+        curOffset += step;
+        input += (curOffset >> 32) * channels;
+        curOffset &= (fixedFraction - 1);
+    }
+    return outputSize;
+}
+
+
+uint64_t Resample_s16(const int16_t *input, int16_t *output, int inSampleRate, int outSampleRate, uint64_t inputSize,
+                      uint32_t channels
+) {
+    if (input == NULL)
+        return 0;
+    uint64_t outputSize = (uint64_t) (inputSize * (double) outSampleRate / (double) inSampleRate);
+    outputSize -= outputSize % channels;
+    if (output == NULL)
+        return outputSize;
+    double stepDist = ((double) inSampleRate / (double) outSampleRate);
+    const uint64_t fixedFraction = (1LL << 32);
+    const double normFixed = (1.0 / (1LL << 32));
+    uint64_t step = ((uint64_t) (stepDist * fixedFraction + 0.5));
+    uint64_t curOffset = 0;
+    for (uint32_t i = 0; i < outputSize; i += 1) {
+        for (uint32_t c = 0; c < channels; c += 1) {
+            *output++ = (int16_t) (input[c] + (input[c + channels] - input[c]) * (
+                    (double) (curOffset >> 32) + ((curOffset & (fixedFraction - 1)) * normFixed)
+            )
+            );
+        }
+        curOffset += step;
+        input += (curOffset >> 32) * channels;
+        curOffset &= (fixedFraction - 1);
+    }
+    return outputSize;
+}
+```
+
+
+
+
+# Donating
+
+If you found this project useful, consider buying me (@cpuimage) a coffee:
+
+<a href="https://www.buymeacoffee.com/gaozhihan" target="_blank"><img src="https://img2018.cnblogs.com/blog/824862/201809/824862-20180930223603138-1708589189.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>
diff --git a/vendor/resampler/resampler.cpp b/vendor/resampler/resampler.cpp
@@ -0,0 +1,99 @@
+/*
+ * Simple Resampler
+ * https://github.com/cpuimage/resampler.git
+ *
+ * License: MIT
+ */
+
+#include "resampler.hpp"
+
+#include <stdio.h>
+
+uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int outSampleRate, uint64_t inputSize,
+    uint32_t channels)
+{
+    if (input == NULL)
+        return 0;
+    uint64_t outputSize = (uint64_t)(inputSize * (double)outSampleRate / (double)inSampleRate);
+    outputSize -= outputSize % channels;
+    if (output == NULL)
+        return outputSize;
+    double stepDist = ((double)inSampleRate / (double)outSampleRate);
+    const uint64_t fixedFraction = (1LL << 32);
+    const double normFixed = (1.0 / (1LL << 32));
+    uint64_t step = ((uint64_t)(stepDist * fixedFraction + 0.5));
+    uint64_t curOffset = 0;
+    for (uint32_t i = 0; i < outputSize; i += 1) {
+        for (uint32_t c = 0; c < channels; c += 1) {
+            *output++ = (float)(input[c] + (input[c + channels] - input[c]) * ((double)(curOffset >> 32) + ((curOffset & (fixedFraction - 1)) * normFixed)));
+        }
+        curOffset += step;
+        input += (curOffset >> 32) * channels;
+        curOffset &= (fixedFraction - 1);
+    }
+    return outputSize;
+}
+
+uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int outSampleRate, double inputSize,
+    uint32_t channels)
+{
+    if (input == NULL)
+        return 0;
+
+    /**
+     * POLYFILL:
+     * C/C++ has float decision issues.
+     * For example, (44100.0f / 96000.0f * 512) should equal 235.2, but in C/C++ it equals 235.199997.
+     *
+     * Since audio sample rates are canonical values, calculating input/output buffer size will get
+     * a number with only 1 decimal place. So simply round it.
+     *
+     * NOTICE: inputSize should always be a value calculated by getExpectedInputSize(),
+     *         and make sure you have enough space for output buffer,
+     *         otherwise you may encounter unexpected behaviors (out-of-range, stitches, etc.)!
+     */
+    uint64_t outputSize = (uint64_t)round(inputSize * (double)outSampleRate / (double)inSampleRate);
+    outputSize -= outputSize % channels;
+    if (output == NULL)
+        return outputSize;
+
+    double stepDist = ((double)inSampleRate / (double)outSampleRate);
+    const uint64_t fixedFraction = (1LL << 32);
+    const double normFixed = (1.0 / (1LL << 32));
+    uint64_t step = ((uint64_t)(stepDist * fixedFraction + 0.5));
+    uint64_t curOffset = 0;
+    for (uint32_t i = 0; i < outputSize; i += 1) {
+        for (uint32_t c = 0; c < channels; c += 1) {
+            *output++ = (float)(input[c] + (input[c + channels] - input[c]) * ((double)(curOffset >> 32) + ((curOffset & (fixedFraction - 1)) * normFixed)));
+        }
+        curOffset += step;
+        input += (curOffset >> 32) * channels;
+        curOffset &= (fixedFraction - 1);
+    }
+    return outputSize;
+}
+
+uint64_t Resample_s16(const int16_t* input, int16_t* output, int inSampleRate, int outSampleRate, uint64_t inputSize,
+    uint32_t channels)
+{
+    if (input == NULL)
+        return 0;
+    uint64_t outputSize = (uint64_t)(inputSize * (double)outSampleRate / (double)inSampleRate);
+    outputSize -= outputSize % channels;
+    if (output == NULL)
+        return outputSize;
+    double stepDist = ((double)inSampleRate / (double)outSampleRate);
+    const uint64_t fixedFraction = (1LL << 32);
+    const double normFixed = (1.0 / (1LL << 32));
+    uint64_t step = ((uint64_t)(stepDist * fixedFraction + 0.5));
+    uint64_t curOffset = 0;
+    for (uint32_t i = 0; i < outputSize; i += 1) {
+        for (uint32_t c = 0; c < channels; c += 1) {
+            *output++ = (int16_t)(input[c] + (input[c + channels] - input[c]) * ((double)(curOffset >> 32) + ((curOffset & (fixedFraction - 1)) * normFixed)));
+        }
+        curOffset += step;
+        input += (curOffset >> 32) * channels;
+        curOffset &= (fixedFraction - 1);
+    }
+    return outputSize;
+}
diff --git a/vendor/resampler/resampler.hpp b/vendor/resampler/resampler.hpp
@@ -0,0 +1,26 @@
+/*
+ * Simple Resampler
+ * https://github.com/cpuimage/resampler.git
+ *
+ * License: MIT
+ */
+
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+
+constexpr double getExpectedInputSize(float inSampleRate, float outSampleRate, uint32_t targetOutSize)
+{
+    return (inSampleRate / outSampleRate) * targetOutSize;
+}
+
+uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int outSampleRate, uint64_t inputSize,
+    uint32_t channels);
+
+uint64_t Resample_f32(const float* input, float* output, int inSampleRate, int outSampleRate, double inputSize,
+    uint32_t channels);
+
+uint64_t Resample_s16(const int16_t* input, int16_t* output, int inSampleRate, int outSampleRate, uint64_t inputSize,
+    uint32_t channels);
