Fix issue #33, replace zita-resampler with cubic hermite streaming resampler

Author: brummer10

NeuralRack/engine/NeuralModelLoader.cpp

@@ -13,7 +13,7 @@
 namespace neuralrack {
 
 NeuralModelLoader::NeuralModelLoader(std::condition_variable *Sync)
-    : model(nullptr), smp(), SyncWait(Sync) {
+    : model(nullptr), SyncWait(Sync) {
     NeuralAudio::NeuralModel::SetDefaultMaxAudioBufferSize(4096);
     loudness = 0.0;
     nGain = 1.0;
@@ -86,28 +86,12 @@ void NeuralModelLoader::compute(uint32_t count, float *input0, float *output0) {
         memcpy(buf, output0, count*sizeof(float));
 
         if (needResample ) {
-            uint32_t ReCounta = count;
-            if (needResample == 1) {
-                ReCounta = smp.max_out_count(count);
-            } else if (needResample == 2) {
-                ReCounta = static_cast<int>(ceil((count*static_cast<double>(modelSampleRate))/fSampleRate));
-            }
+            int ReCounta = toModel.getOutSize(count);
             float buf1[ReCounta];
             memset(buf1, 0, ReCounta*sizeof(float));
-            if (needResample == 1) {
-                ReCounta = smp.up(count, buf, buf1);
-            } else if (needResample == 2) {
-                smp.down(buf, buf1);
-            } else {
-                memcpy(buf1, buf, ReCounta * sizeof(float));
-            }
+            ReCounta = toModel.resample(buf, buf1, count);
             model->Process(buf1, buf1, ReCounta);
-
-            if (needResample == 1) {
-                smp.down(buf1, buf);
-            } else if (needResample == 2) {
-                smp.up(ReCounta, buf1, buf);
-            }
+            toStream.resample(buf1, buf, ReCounta);
         } else {
             model->Process(buf, buf, count);
         }
@@ -174,12 +158,10 @@ bool NeuralModelLoader::loadModel() {
             }
             modelSampleRate = static_cast<int>(model->GetSampleRate());
             if (modelSampleRate <= 0) modelSampleRate = 48000;
-            if (modelSampleRate > fSampleRate) {
-                smp.setup(fSampleRate, modelSampleRate);
+            if (modelSampleRate != fSampleRate) {
+                toModel.setup(1, 8196, fSampleRate, modelSampleRate);
+                toStream.setup(1, 8196, modelSampleRate, fSampleRate);
                 needResample = 1;
-            } else if (modelSampleRate < fSampleRate) {
-                smp.setup(modelSampleRate, fSampleRate);
-                needResample = 2;
             }
             float* buffer = new float[warmUpSize];
             memset(buffer, 0, warmUpSize * sizeof(float));

NeuralRack/engine/NeuralModelLoader.h

@@ -20,7 +20,7 @@
 
 #include "NeuralModel.h"
 
-#include "gx_resampler.h"
+#include "StreamingResampler.h"
 
 #pragma once
 
@@ -33,7 +33,8 @@ namespace neuralrack {
 class NeuralModelLoader  {
 private:
     NeuralAudio::NeuralModel*       model;
-    gx_resample::FixedRateResampler smp;
+    StreamingResampler              toModel;
+    StreamingResampler              toStream;
 
     std::atomic<bool>               ready;
     std::atomic<bool>               do_ramp;

NeuralRack/engine/StreamingResampler.h

@@ -0,0 +1,114 @@
+/*
+ * StreamingResampler.h
+ *
+ * SPDX-License-Identifier:  BSD-3-Clause
+ *
+ * Copyright (C) 2026 brummer <brummer@web.de>
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <cmath>
+#include <cstring>
+
+
+class StreamingResampler {
+public:
+    StreamingResampler() = default;
+
+    void setup(uint32_t channels, uint32_t maxBlockSize, uint32_t fs_in, uint32_t fs_out) {
+        chan = channels;
+        ratio = double(fs_in) / double(fs_out);
+        bufferSize = maxBlockSize + 8;
+        buffer.resize(bufferSize * chan, 0.0f);
+        reset();
+    }
+
+    void reset() {
+        readPos = 0.0;
+        buffered = 0;
+        std::fill(buffer.begin(), buffer.end(), 0.0f);
+    }
+
+    void setSampleRates(uint32_t fs_in, uint32_t fs_out) {
+        ratio = double(fs_in) / double(fs_out);
+    }
+
+    uint32_t getOutSize(uint32_t inFrames) const {
+        return (uint32_t)std::ceil(inFrames / ratio);
+    }
+
+    uint32_t resample(const float* input, float* output, uint32_t inFrames) {
+        append(input, inFrames);
+        uint32_t outFrames = 0;
+        while (true) {
+            int ip = (int)readPos;
+            if (ip + 2 >= (int)buffered) break;
+            float t = float(readPos - ip);
+
+            for (uint32_t ch = 0; ch < chan; ++ch) {
+                float x0 = sample(ip - 1, ch);
+                float x1 = sample(ip,     ch);
+                float x2 = sample(ip + 1, ch);
+                float x3 = sample(ip + 2, ch);
+                output[outFrames * chan + ch] = hermite(x0, x1, x2, x3, t);
+            }
+            readPos += ratio;
+            ++outFrames;
+        }
+
+        int consumed = (int)readPos;
+
+        if (consumed > 0) {
+            shiftBuffer(consumed);
+            readPos -= consumed;
+        }
+
+        return outFrames;
+    }
+
+private:
+    uint32_t chan = 0;
+    double ratio = 1.0;
+    std::vector<float> buffer;
+    uint32_t bufferSize = 0;
+    uint32_t buffered = 0;
+    double readPos = 0.0;
+
+    void append(const float* input, uint32_t frames) {
+        for (uint32_t i = 0; i < frames; ++i) {
+            for (uint32_t ch = 0; ch < chan; ++ch) {
+                buffer[(buffered + i) * chan + ch] =
+                    input[i * chan + ch];
+            }
+        }
+        buffered += frames;
+    }
+
+    void shiftBuffer(uint32_t frames) {
+        uint32_t remaining = buffered - frames;
+
+        std::memmove(buffer.data(), buffer.data() + frames * chan, remaining * chan * sizeof(float));
+
+        buffered = remaining;
+    }
+
+    inline float sample(int idx, uint32_t ch) const {
+        if (idx < 0) return buffer[ch];
+
+        if ((uint32_t)idx >= buffered)
+            return buffer[(buffered - 1) * chan + ch];
+
+        return buffer[idx * chan + ch];
+    }
+
+    static inline float hermite(float x0, float x1, float x2, float x3, float t) {
+        float c0 = x1;
+        float c1 = 0.5f * (x2 - x0);
+        float c2 = x0 - 2.5f * x1 + 2.0f * x2 - 0.5f * x3;
+        float c3 = 0.5f * (x3 - x0) + 1.5f * (x1 - x2);
+        return ((c3*t + c2)*t + c1)*t + c0;
+    }
+};