Implement lowpass filter when down sampling

Author: brummer10

NeuralRack/engine/StreamingResampler.h

@@ -14,12 +14,26 @@
 #include <cstring>
 
 
+/****************************************************************
+ StreamingResampler - cubic hermite resampler with nyquist lowpass in down sampler
+*****************************************************************/
+
 class StreamingResampler {
 public:
     StreamingResampler() = default;
 
     void setup(uint32_t channels, uint32_t maxBlockSize, uint32_t fs_in, uint32_t fs_out) {
         chan = channels;
+
+        downSample = fs_in > fs_out;
+        if (downSample) {
+            lpf.resize(chan);
+            float cutoff = 0.45f * fs_out;
+            for (uint32_t ch = 0; ch < chan; ++ch) {
+                lpf[ch].setup((float)fs_in, cutoff);
+            }
+        }
+
         ratio = double(fs_in) / double(fs_out);
         bufferSize = maxBlockSize + 8;
         buffer.resize(bufferSize * chan, 0.0f);
@@ -30,10 +44,13 @@ class StreamingResampler {
         readPos = 0.0;
         buffered = 0;
         std::fill(buffer.begin(), buffer.end(), 0.0f);
+        for (auto& f : lpf) f.reset();
     }
 
     void setSampleRates(uint32_t fs_in, uint32_t fs_out) {
         ratio = double(fs_in) / double(fs_out);
+        bool useLPF = (fs_in > fs_out);
+        if (useLPF != downSample) setup(chan, bufferSize / chan, fs_in, fs_out);
     }
 
     uint32_t getOutSize(uint32_t inFrames) const {
@@ -70,6 +87,32 @@ class StreamingResampler {
     }
 
 private:
+    struct LPF {
+        float a0, a1, a2, b1, b2;
+        float z1 = 0.0f, z2 = 0.0f;
+
+        void setup(float sampleRate, float cutoff) {
+            float K = std::tan(M_PI * cutoff / sampleRate);
+            float norm = 1.0f / (1.0f + std::sqrt(2.0f)*K + K*K);
+            a0 = K*K * norm;
+            a1 = 2.0f * a0;
+            a2 = a0;
+            b1 = 2.0f * (K*K - 1.0f) * norm;
+            b2 = (1.0f - std::sqrt(2.0f)*K + K*K) * norm;
+        }
+
+        inline float process(float x) {
+            float y = a0*x + z1;
+            z1 = a1*x - b1*y + z2;
+            z2 = a2*x - b2*y;
+            return y;
+        }
+
+        void reset() { z1 = z2 = 0.0f; }
+    };
+
+    std::vector<LPF> lpf;
+    bool downSample = false;
     uint32_t chan = 0;
     double ratio = 1.0;
     std::vector<float> buffer;
@@ -80,8 +123,9 @@ class StreamingResampler {
     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];
+                float s = input[i * chan + ch];
+                if (downSample) s = lpf[ch].process(s);
+                buffer[(buffered + i) * chan + ch] = s;
             }
         }
         buffered += frames;

NeuralRack/gui/widgets.cc

@@ -140,6 +140,29 @@ char* utf8crop(char* dst, const char* src, size_t sizeDest ) {
     return dst;
 }
 
+void utf8crop_middle(char* dst, const char* src, size_t maxLen) {
+    size_t len = strlen(src);
+    if (len < maxLen) {
+        strcpy(dst, src);
+        return;
+    }
+
+    if (maxLen < 5) {
+        utf8crop(dst, src, maxLen);
+        return;
+    }
+
+    size_t left = (maxLen - 3) / 2;
+    size_t right = maxLen - 3 - left;
+    char tmp[256];
+    utf8crop(tmp, src, left + 1);
+    strcpy(dst, tmp);
+    strcat(dst, "...");
+    const char* tail = src + len - right;
+    utf8crop(tmp, tail, right + 1);
+    strcat(dst, tmp);
+}
+
 // draw the EQ and the Noise Gate window
 void draw_eq_window(void *w_, void* user_data) {
     Widget_t *w = (Widget_t*)w_;
@@ -250,9 +273,8 @@ void draw_elem(void *w_, void* user_data) {
         cairo_set_font_size (w->crb, w->app->big_font-3);
         int slen = strlen(basename(m.filename));
 
-        if ((slen - 4) > 38) {
-            utf8crop(label,basename(m.filename), 38);
-            strcat(label,"...");
+        if (slen > 38) {
+            utf8crop_middle(label,basename(m.filename), 38);
             tooltip_set_text(m.filebutton,basename(m.filename));
             m.filebutton->flags |= HAS_TOOLTIP;
         } else {
@@ -323,9 +345,8 @@ void draw_ir_elem(void *w_, void* user_data) {
         cairo_set_font_size (w->crb, w->app->big_font-3);
         int slen = strlen(basename(ps->ir.filename));
 
-        if ((slen - 4) > 36) {
-            utf8crop(label,basename(ps->ir.filename), 36);
-            strcat(label,"...");
+        if (slen > 36) {
+            utf8crop_middle(label,basename(ps->ir.filename), 36);
             tooltip_set_text(ps->ir.filebutton,basename(ps->ir.filename));
             ps->ir.filebutton->flags |= HAS_TOOLTIP;
         } else {
@@ -346,9 +367,8 @@ void draw_ir_elem(void *w_, void* user_data) {
         cairo_set_font_size (w->crb, w->app->big_font-3);
         int slen = strlen(basename(ps->ir1.filename));
 
-        if ((slen - 4) > 36) {
-            utf8crop(label,basename(ps->ir1.filename), 36);
-            strcat(label,"...");
+        if (slen > 36) {
+            utf8crop_middle(label,basename(ps->ir1.filename), 36);
             tooltip_set_text(ps->ir1.filebutton,basename(ps->ir1.filename));
             ps->ir1.filebutton->flags |= HAS_TOOLTIP;
         } else {
@@ -1177,9 +1197,8 @@ void draw_my_combobox(void *w_, void* user_data) {
     int slen = strlen(comboboxlist->list_names[vl]);
     widget_set_scale(w);
 
-    if ((slen - 4) > 45) {
-        utf8crop(label,comboboxlist->list_names[vl], 45);
-        strcat(label,"...");
+    if (slen > 45) {
+        utf8crop_middle(label,comboboxlist->list_names[vl], 45);
         tooltip_set_text(w,comboboxlist->list_names[vl]);
         w->flags |= HAS_TOOLTIP;
     } else {

NeuralRack/lv2/NeuralRack.ttl

@@ -92,6 +92,14 @@ nrack:irfile1
     pg:group nrack:G6_IR_Right ;
     rdfs:range atom:Path .
 
+nrack:eqpos
+    a lv2:Parameter ;
+    rdfs:label "EQ position" ;
+    rdfs:range atom:Int ;
+    lv2:default 1 ;
+    lv2:minimum 0 ;
+    lv2:maximum 2 .
+
 <urn:brummer:neuralrack>
    a lv2:Plugin ,
        lv2:SimulatorPlugin ;
@@ -107,8 +115,8 @@ nrack:irfile1
    opts:supportedOption bufsz:maxBlockLength ;
    lv2:extensionData work:interface ,
                     state:interface ;
-   lv2:minorVersion 2 ;
-   lv2:microVersion 0 ;
+   lv2:minorVersion 3 ;
+   lv2:microVersion 2 ;
 
 guiext:ui <urn:brummer:neuralrack_ui> ;
 
@@ -118,6 +126,8 @@ patch:writable nrack:Neural_Model1 ;
 patch:writable nrack:irfile ;
 patch:writable nrack:irfile1 ;
 
+patch:writable nrack:eqpos;
+
 rdfs:comment """
 Neuralrack is a Neural Model loader with support for *.nam, *.aidax and *.json based model files.
 Neuralrack allow to load up to two model files and run them serial.

README.md

@@ -16,6 +16,7 @@ For Impulse Response File Convolution it use [FFTConvolver](https://github.com/H
 Resampling is done by [Libzita-resampler](https://kokkinizita.linuxaudio.org/linuxaudio/zita-resampler/resampler.html)
 
 NeuralRack emulate a simple guitar effect chain with a pedal, a EQ a Amplifier and a Stereo Cabinet.
+The EQ could be moved by drag and drop to act as a pre or post EQ.
 
 Optional, NeuralRack could run one Model, or the complete process in buffered mode to reduce the dsp load. 
 The resulting latency will be reported to the host so that it could be compensated.