Merge pull request #801 from AlexandreRouma/new_dsp

New dsp + code cleanups

.github/workflows/build_all.yml

@@ -87,7 +87,7 @@ jobs:
           run: brew update
 
         - name: Install dependencies
-          run: brew install fftw glfw airspy airspyhf portaudio hackrf rtl-sdr libbladerf codec2 && pip3 install mako zstd
+          run: brew install libusb fftw glfw airspy airspyhf portaudio hackrf rtl-sdr libbladerf codec2 && pip3 install mako zstd
 
         - name: Install volk
           run: git clone --recursive https://github.com/gnuradio/volk && cd volk && mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j3 && sudo make install && cd ../../
@@ -95,18 +95,18 @@ jobs:
         - name: Install SDRplay API
           run: wget https://www.sdrplay.com/software/SDRplay_RSP_API-MacOSX-3.07.3.pkg && sudo installer -pkg SDRplay_RSP_API-MacOSX-3.07.3.pkg -target /
 
-        - name: Install libiio
-          run: git clone https://github.com/analogdevicesinc/libiio && cd libiio && mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j3 && sudo make install && cd ../../
+        # - name: Install libiio
+        #   run: git clone https://github.com/analogdevicesinc/libiio && cd libiio && mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j3 && sudo make install && cd ../../
 
-        - name: Install libad9361
-          run: git clone https://github.com/analogdevicesinc/libad9361-iio && cd libad9361-iio && mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j3 && sudo make install && cd ../../
+        # - name: Install libad9361
+        #   run: git clone https://github.com/analogdevicesinc/libad9361-iio && cd libad9361-iio && mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j3 && sudo make install && cd ../../
 
         - name: Install LimeSuite
           run: git clone https://github.com/myriadrf/LimeSuite && cd LimeSuite && mkdir builddir && cd builddir && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j3 && sudo make install && cd ../../
 
         - name: Prepare CMake
           working-directory: ${{runner.workspace}}/build
-          run: cmake $GITHUB_WORKSPACE -DOPT_BUILD_PLUTOSDR_SOURCE=ON -DOPT_BUILD_SOAPY_SOURCE=OFF -DOPT_BUILD_BLADERF_SOURCE=ON -DOPT_BUILD_SDRPLAY_SOURCE=ON -DOPT_BUILD_LIMESDR_SOURCE=ON -DOPT_BUILD_AUDIO_SINK=OFF -DOPT_BUILD_PORTAUDIO_SINK=ON -DOPT_BUILD_NEW_PORTAUDIO_SINK=ON -DOPT_BUILD_M17_DECODER=ON -DUSE_BUNDLE_DEFAULTS=ON -DCMAKE_BUILD_TYPE=Release
+          run: cmake $GITHUB_WORKSPACE -DOPT_BUILD_PLUTOSDR_SOURCE=OFF -DOPT_BUILD_SOAPY_SOURCE=OFF -DOPT_BUILD_BLADERF_SOURCE=ON -DOPT_BUILD_SDRPLAY_SOURCE=ON -DOPT_BUILD_LIMESDR_SOURCE=ON -DOPT_BUILD_AUDIO_SINK=OFF -DOPT_BUILD_PORTAUDIO_SINK=ON -DOPT_BUILD_NEW_PORTAUDIO_SINK=ON -DOPT_BUILD_M17_DECODER=ON -DUSE_BUNDLE_DEFAULTS=ON -DCMAKE_BUILD_TYPE=Release
 
         - name: Build
           working-directory: ${{runner.workspace}}/build

CMakeLists.txt

@@ -51,7 +51,7 @@ option(OPT_BUILD_NEW_PORTAUDIO_SINK "Build the new PortAudio Sink Module (Depend
 # Decoders
 option(OPT_BUILD_FALCON9_DECODER "Build the falcon9 live decoder (Dependencies: ffplay)" OFF)
 option(OPT_BUILD_KG_SSTV_DECODER "Build the M17 decoder module (no dependencies required)" OFF)
-option(OPT_BUILD_M17_DECODER "Build the M17 decoder module (no dependencies required)" OFF)
+option(OPT_BUILD_M17_DECODER "Build the M17 decoder module (Dependencies: codec2)" OFF)
 option(OPT_BUILD_METEOR_DEMODULATOR "Build the meteor demodulator module (no dependencies required)" ON)
 option(OPT_BUILD_RADIO "Main audio modulation decoder (AM, FM, SSB, etc...)" ON)
 option(OPT_BUILD_WEATHER_SAT_DECODER "Build the HRPT decoder module (no dependencies required)" OFF)

core/backends/glfw/backend.cpp

@@ -112,15 +112,6 @@ namespace backend {
             break;
         }
 
-    #endif
-
-        // Add callback for max/min if GLFW supports it
-    #if (GLFW_VERSION_MAJOR == 3) && (GLFW_VERSION_MINOR >= 3)
-        if (maximized) {
-            glfwMaximizeWindow(window);
-        }
-
-        glfwSetWindowMaximizeCallback(window, maximized_callback);
     #endif
 
         // Load app icon
@@ -164,6 +155,15 @@ namespace backend {
             free(icons[i].pixels);
         }
 
+        // Add callback for max/min if GLFW supports it
+    #if (GLFW_VERSION_MAJOR == 3) && (GLFW_VERSION_MINOR >= 3)
+        if (maximized) {
+            glfwMaximizeWindow(window);
+        }
+
+        glfwSetWindowMaximizeCallback(window, maximized_callback);
+    #endif
+
         // Setup Dear ImGui context
         IMGUI_CHECKVERSION();
         ImGui::CreateContext();

core/src/core.cpp

@@ -42,15 +42,18 @@ namespace core {
         // Forward this to the server
         if (args["server"].b()) { server::setInputSampleRate(samplerate); return; }
         
-        sigpath::signalPath.sourceSampleRate = samplerate;
-        double effectiveSr = samplerate / ((double)(1 << sigpath::signalPath.decimation));
-        // NOTE: Zoom controls won't work
-        spdlog::info("New DSP samplerate: {0} (source samplerate is {1})", effectiveSr, samplerate);
+        // Update IQ frontend input samplerate and get effective samplerate
+        sigpath::iqFrontEnd.setSampleRate(samplerate);
+        double effectiveSr  = sigpath::iqFrontEnd.getEffectiveSamplerate();
+        
+        // Reset zoom
         gui::waterfall.setBandwidth(effectiveSr);
         gui::waterfall.setViewOffset(0);
         gui::waterfall.setViewBandwidth(effectiveSr);
-        sigpath::signalPath.setSampleRate(effectiveSr);
         gui::mainWindow.setViewBandwidthSlider(1.0);
+
+        // Debug logs
+        spdlog::info("New DSP samplerate: {0} (source samplerate is {1})", effectiveSr, samplerate);
     }
 };
 
@@ -114,7 +117,7 @@ int sdrpp_main(int argc, char* argv[]) {
     defConfig["fftHeight"] = 300;
     defConfig["fftRate"] = 20;
     defConfig["fftSize"] = 65536;
-    defConfig["fftWindow"] = 1;
+    defConfig["fftWindow"] = 2;
     defConfig["frequency"] = 100000000.0;
     defConfig["fullWaterfallUpdate"] = false;
     defConfig["max"] = 0.0;
@@ -363,7 +366,7 @@ int sdrpp_main(int argc, char* argv[]) {
     // Terminate backend (TODO: CHECK RETURN VALUE)
     backend::end();
 
-    sigpath::signalPath.stop();
+    sigpath::iqFrontEnd.stop();
 
     core::configManager.disableAutoSave();
     core::configManager.save();

core/src/credits.cpp

@@ -22,6 +22,7 @@ namespace sdrpp_credits {
         "Syne Ardwin (WI9SYN)",
         "Szymon Zakrent",
         "Tobias Mädel",
+        "Youssef Touil",
         "Zimm"
     };
 

core/src/dsp/audio.h

@@ -1,198 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-
-namespace dsp {
-    class MonoToStereo : public generic_block<MonoToStereo> {
-    public:
-        MonoToStereo() {}
-
-        MonoToStereo(stream<float>* in) { init(in); }
-
-        void init(stream<float>* in) {
-            _in = in;
-            generic_block<MonoToStereo>::registerInput(_in);
-            generic_block<MonoToStereo>::registerOutput(&out);
-            generic_block<MonoToStereo>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in) {
-            assert(generic_block<MonoToStereo>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<MonoToStereo>::ctrlMtx);
-            generic_block<MonoToStereo>::tempStop();
-            generic_block<MonoToStereo>::unregisterInput(_in);
-            _in = in;
-            generic_block<MonoToStereo>::registerInput(_in);
-            generic_block<MonoToStereo>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32f_x2_interleave_32fc((lv_32fc_t*)out.writeBuf, _in->readBuf, _in->readBuf, count);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<stereo_t> out;
-
-    private:
-        stream<float>* _in;
-    };
-
-    class ChannelsToStereo : public generic_block<ChannelsToStereo> {
-    public:
-        ChannelsToStereo() {}
-
-        ChannelsToStereo(stream<float>* in_left, stream<float>* in_right) { init(in_left, in_right); }
-
-        void init(stream<float>* in_left, stream<float>* in_right) {
-            _in_left = in_left;
-            _in_right = in_right;
-            nullbuf = new float[STREAM_BUFFER_SIZE];
-            for (int i = 0; i < STREAM_BUFFER_SIZE; i++) { nullbuf[i] = 0; }
-            generic_block<ChannelsToStereo>::registerInput(_in_left);
-            generic_block<ChannelsToStereo>::registerInput(_in_right);
-            generic_block<ChannelsToStereo>::registerOutput(&out);
-            generic_block<ChannelsToStereo>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in_left, stream<float>* in_right) {
-            assert(generic_block<ChannelsToStereo>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ChannelsToStereo>::ctrlMtx);
-            generic_block<ChannelsToStereo>::tempStop();
-            generic_block<ChannelsToStereo>::unregisterInput(_in_left);
-            generic_block<ChannelsToStereo>::unregisterInput(_in_right);
-            _in_left = in_left;
-            _in_right = in_right;
-            generic_block<ChannelsToStereo>::registerInput(_in_left);
-            generic_block<ChannelsToStereo>::registerInput(_in_right);
-            generic_block<ChannelsToStereo>::tempStart();
-        }
-
-        int run() {
-            int count_l = _in_left->read();
-            if (count_l < 0) { return -1; }
-            int count_r = _in_right->read();
-            if (count_r < 0) { return -1; }
-
-            if (count_l != count_r) {
-                spdlog::warn("ChannelsToStereo block size mismatch");
-            }
-
-            volk_32f_x2_interleave_32fc((lv_32fc_t*)out.writeBuf, _in_left->readBuf, _in_right->readBuf, count_l);
-
-            _in_left->flush();
-            _in_right->flush();
-            if (!out.swap(count_l)) { return -1; }
-            return count_l;
-        }
-
-        stream<stereo_t> out;
-
-    private:
-        stream<float>* _in_left;
-        stream<float>* _in_right;
-
-        float* nullbuf;
-    };
-
-    class StereoToMono : public generic_block<StereoToMono> {
-    public:
-        StereoToMono() {}
-
-        StereoToMono(stream<stereo_t>* in) { init(in); }
-
-        ~StereoToMono() {
-            if (!generic_block<StereoToMono>::_block_init) { return; }
-            generic_block<StereoToMono>::stop();
-            delete[] l_buf;
-            delete[] r_buf;
-            generic_block<StereoToMono>::_block_init = false;
-        }
-
-        void init(stream<stereo_t>* in) {
-            _in = in;
-            l_buf = new float[STREAM_BUFFER_SIZE];
-            r_buf = new float[STREAM_BUFFER_SIZE];
-            generic_block<StereoToMono>::registerInput(_in);
-            generic_block<StereoToMono>::registerOutput(&out);
-            generic_block<StereoToMono>::_block_init = true;
-        }
-
-        void setInput(stream<stereo_t>* in) {
-            assert(generic_block<StereoToMono>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<StereoToMono>::ctrlMtx);
-            generic_block<StereoToMono>::tempStop();
-            generic_block<StereoToMono>::unregisterInput(_in);
-            _in = in;
-            generic_block<StereoToMono>::registerInput(_in);
-            generic_block<StereoToMono>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            for (int i = 0; i < count; i++) {
-                out.writeBuf[i] = (_in->readBuf[i].l + _in->readBuf[i].r) * 0.5f;
-            }
-
-            _in->flush();
-
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        float *l_buf, *r_buf;
-        stream<stereo_t>* _in;
-    };
-
-    class StereoToChannels : public generic_block<StereoToChannels> {
-    public:
-        StereoToChannels() {}
-
-        StereoToChannels(stream<stereo_t>* in) { init(in); }
-
-        void init(stream<stereo_t>* in) {
-            _in = in;
-            generic_block<StereoToChannels>::registerInput(_in);
-            generic_block<StereoToChannels>::registerOutput(&out_left);
-            generic_block<StereoToChannels>::registerOutput(&out_right);
-            generic_block<StereoToChannels>::_block_init = true;
-        }
-
-        void setInput(stream<stereo_t>* in) {
-            assert(generic_block<StereoToChannels>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<StereoToChannels>::ctrlMtx);
-            generic_block<StereoToChannels>::tempStop();
-            generic_block<StereoToChannels>::unregisterInput(_in);
-            _in = in;
-            generic_block<StereoToChannels>::registerInput(_in);
-            generic_block<StereoToChannels>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32fc_deinterleave_32f_x2(out_left.writeBuf, out_right.writeBuf, (lv_32fc_t*)_in->readBuf, count);
-
-            _in->flush();
-            if (!out_left.swap(count)) { return -1; }
-            if (!out_right.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out_left;
-        stream<float> out_right;
-
-    private:
-        stream<stereo_t>* _in;
-    };
-}

core/src/dsp/audio/volume.h

@@ -0,0 +1,58 @@
+#pragma once
+#include "../processor.h"
+
+// TODO: This block is useless and weird, get rid of it
+namespace dsp::audio {
+    class Volume : public Processor<stereo_t, stereo_t> {
+        using base_type = Processor<stereo_t, stereo_t>;
+    public:
+        Volume() {}
+
+        Volume(stream<stereo_t>* in, double volume, bool muted) { init(in, volume, muted); }
+
+        void init(stream<stereo_t>* in, double volume, bool muted) {
+            _volume = powf(volume, 2);
+            _muted = muted;
+            base_type::init(in);
+        }
+
+        void setVolume(double volume) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _volume = powf(volume, 2);
+        }
+
+        void setMuted(bool muted) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _muted = muted;
+        }
+
+        bool getMuted() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            return _muted;
+        }
+
+        inline int process(int count, const stereo_t* in, stereo_t* out) {
+            volk_32f_s32f_multiply_32f((float*)out, (float*)in, _muted ? 0.0f : _volume, count * 2);
+            return count;
+        }
+
+        virtual int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    private:
+        float _volume;
+        bool _muted;
+
+    };
+}

core/src/dsp/bench/peak_level_meter.h

@@ -0,0 +1,72 @@
+#pragma once
+#include "../sink.h"
+
+namespace dsp::bench {
+    template<class T>
+    class PeakLevelMeter : public Sink<T> {
+        using base_type = Sink<T>;
+    public:
+        PeakLevelMeter() {}
+
+        PeakLevelMeter(stream<T>* in) { init(in); }
+
+        void init(stream<T>* in) {
+            if constexpr (std::is_same_v<T, float>) {
+                level = 0.0f;
+            }
+            if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
+                level = { 0.0f, 0.0f };
+            }
+            base_type::init(in);
+        }
+
+        T getLevel() {
+            return level;
+        }
+
+        void resetLevel() {
+            assert(base_type::_block_init);
+            if constexpr (std::is_same_v<T, float>) {
+                level = 0.0f;
+            }
+            if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
+                level = { 0.0f, 0.0f };
+            }
+        }
+
+        int process(int count, T* in) {
+            for (int i = 0; i < count; i++) {
+                if constexpr (std::is_same_v<T, float>) {
+                    float lvl = fabsf(in[i]);
+                    if (lvl > level) { level = lvl; }
+                }
+                if constexpr (std::is_same_v<T, complex_t>) {
+                    float lvlre = fabsf(in[i].re);
+                    float lvlim = fabsf(in[i].im);
+                    if (lvlre > level.re) { level.re = lvlre; }
+                    if (lvlim > level.im) { level.im = lvlim; }
+                }
+                if constexpr (std::is_same_v<T, stereo_t>) {
+                    float lvll = fabsf(in[i].l);
+                    float lvlr = fabsf(in[i].r);
+                    if (lvll > level.l) { level.l = lvll; }
+                    if (lvlr > level.r) { level.r = lvlr; }
+                }
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf);
+
+            base_type::_in->flush();
+            return count;
+        }
+
+    protected:
+        T level;
+    };
+}

core/src/dsp/bench/speed_tester.h

@@ -0,0 +1,105 @@
+#pragma once
+#include <thread>
+#include <assert.h>
+#include "../stream.h"
+#include "../types.h"
+
+namespace dsp::bench {
+    template<class I,  class O>
+    class SpeedTester {
+    public:
+        SpeedTester() {}
+
+        SpeedTester(stream<I>* in, stream<O>* out) { init(in, out); }
+
+        void init(stream<I>* in, stream<O>* out) {
+            _in = in;
+            _out = out;
+            _init = true;
+        }
+
+        void setInput(stream<I>* in) {
+            assert(_init);
+            _in = in;
+        }
+
+        void setOutput(stream<O>* out) {
+            assert(_init);
+            _out = out;
+        }
+
+        double benchmark(int durationMs, int bufferSize) {
+            assert(_init);
+
+            // Allocate and fill buffer
+            inCount = bufferSize;
+            randBuf = buffer::alloc<I>(inCount);
+            for (int i = 0; i < inCount; i++) {
+                if constexpr (std::is_same_v<I, complex_t>) {
+                    randBuf[i].re = (2.0f * (float)rand() / (float)RAND_MAX) - 1.0f;
+                    randBuf[i].im = (2.0f * (float)rand() / (float)RAND_MAX) - 1.0f;
+                }
+                else if constexpr (std::is_same_v<I, float>) {
+                    randBuf[i] = (2.0f * (float)rand() / (float)RAND_MAX) - 1.0f;
+                }
+                else {
+                    randBuf[i] = rand();
+                }
+            }
+
+            // Run test
+            start();
+            std::this_thread::sleep_for(std::chrono::milliseconds(durationMs));
+            stop();
+            buffer::free(randBuf);
+            return (double)sampCount * 1000.0 / (double)durationMs;
+        }
+
+    protected:
+        void start() {
+            if (running) { return; }
+            running = true;
+            sampCount = 0;
+            wthr = std::thread(&SpeedTester::writeWorker, this);
+            rthr = std::thread(&SpeedTester::readWorker, this);
+        }
+
+        void stop() {
+            if (!running) { return; }
+            running = false;
+            _in->stopWriter();
+            _out->stopReader();
+            if (wthr.joinable()) { wthr.join(); }
+            if (rthr.joinable()) { rthr.join(); }
+            _in->clearWriteStop();
+            _out->clearReadStop();
+        }
+
+        void writeWorker() {
+            while (true) {
+                memcpy(_in->writeBuf, randBuf, inCount * sizeof(I));
+                if (!_in->swap(inCount)) { return; }
+                sampCount += inCount;
+            }
+        }
+
+        void readWorker() {
+            while (true) {
+                int count = _out->read();
+                _out->flush();
+                if (count < 0) { return; }
+            }
+        }
+
+        bool _init = false;
+        bool running = false;
+        int inCount;
+        stream<I>* _in;
+        stream<O>* _out;
+        I* randBuf;
+        std::thread wthr;
+        std::thread rthr;
+        uint64_t sampCount;
+
+    };
+}

core/src/dsp/block.h

@@ -1,29 +1,24 @@
 #pragma once
-#include <stdio.h>
-#include <dsp/stream.h>
-#include <dsp/types.h>
+#include <assert.h>
 #include <thread>
 #include <vector>
 #include <algorithm>
-
-#include <spdlog/spdlog.h>
+#include "stream.h"
+#include "types.h"
 
 namespace dsp {
-
-    class generic_unnamed_block {
+    class generic_block {
     public:
         virtual void start() {}
         virtual void stop() {}
-        virtual int calcOutSize(int inSize) { return inSize; }
         virtual int run() { return -1; }
     };
 
-    template <class BLOCK>
-    class generic_block : public generic_unnamed_block {
+    class block : public generic_block {
     public:
         virtual void init() {}
 
-        virtual ~generic_block() {
+        virtual ~block() {
             if (!_block_init) { return; }
             stop();
             _block_init = false;
@@ -31,7 +26,7 @@ namespace dsp {
 
         virtual void start() {
             assert(_block_init);
-            std::lock_guard<std::mutex> lck(ctrlMtx);
+            std::lock_guard<std::recursive_mutex> lck(ctrlMtx);
             if (running) {
                 return;
             }
@@ -41,7 +36,7 @@ namespace dsp {
 
         virtual void stop() {
             assert(_block_init);
-            std::lock_guard<std::mutex> lck(ctrlMtx);
+            std::lock_guard<std::recursive_mutex> lck(ctrlMtx);
             if (!running) {
                 return;
             }
@@ -51,6 +46,7 @@ namespace dsp {
 
         void tempStart() {
             assert(_block_init);
+            if (!tempStopDepth || --tempStopDepth) { return; }
             if (tempStopped) {
                 doStart();
                 tempStopped = false;
@@ -59,26 +55,45 @@ namespace dsp {
 
         void tempStop() {
             assert(_block_init);
+            if (tempStopDepth++) { return; }
             if (running && !tempStopped) {
                 doStop();
                 tempStopped = true;
             }
         }
 
-        virtual int calcOutSize(int inSize) {
-            assert(_block_init);
-            return inSize;
-        }
-
         virtual int run() = 0;
 
-        friend BLOCK;
-
-    private:
+    protected:
         void workerLoop() {
             while (run() >= 0) {}
         }
 
+        virtual void doStart() {
+            workerThread = std::thread(&block::workerLoop, this);
+        }
+
+        virtual void doStop() {
+            for (auto& in : inputs) {
+                in->stopReader();
+            }
+            for (auto& out : outputs) {
+                out->stopWriter();
+            }
+
+            // TODO: Make sure this isn't needed, I don't know why it stops
+            if (workerThread.joinable()) {
+                workerThread.join();
+            }
+
+            for (auto& in : inputs) {
+                in->clearReadStop();
+            }
+            for (auto& out : outputs) {
+                out->clearWriteStop();
+            }
+        }
+    
         void acquire() {
             ctrlMtx.lock();
         }
@@ -103,125 +118,16 @@ namespace dsp {
             outputs.erase(std::remove(outputs.begin(), outputs.end(), outStream), outputs.end());
         }
 
-        virtual void doStart() {
-            workerThread = std::thread(&generic_block<BLOCK>::workerLoop, this);
-        }
-
-        virtual void doStop() {
-            for (auto& in : inputs) {
-                in->stopReader();
-            }
-            for (auto& out : outputs) {
-                out->stopWriter();
-            }
-
-            // TODO: Make sure this isn't needed, I don't know why it stops
-            if (workerThread.joinable()) {
-                workerThread.join();
-            }
-
-            for (auto& in : inputs) {
-                in->clearReadStop();
-            }
-            for (auto& out : outputs) {
-                out->clearWriteStop();
-            }
-        }
-
-    protected:
         bool _block_init = false;
 
-        std::mutex ctrlMtx;
+        std::recursive_mutex ctrlMtx;
 
         std::vector<untyped_stream*> inputs;
         std::vector<untyped_stream*> outputs;
 
         bool running = false;
         bool tempStopped = false;
+        int tempStopDepth = 0;
         std::thread workerThread;
     };
-
-    template <class BLOCK>
-    class generic_hier_block {
-    public:
-        virtual void init() {}
-
-        virtual ~generic_hier_block() {
-            if (!_block_init) { return; }
-            stop();
-            _block_init = false;
-        }
-
-        virtual void start() {
-            assert(_block_init);
-            std::lock_guard<std::mutex> lck(ctrlMtx);
-            if (running) {
-                return;
-            }
-            running = true;
-            doStart();
-        }
-
-        virtual void stop() {
-            assert(_block_init);
-            std::lock_guard<std::mutex> lck(ctrlMtx);
-            if (!running) {
-                return;
-            }
-            doStop();
-            running = false;
-        }
-
-        void tempStart() {
-            assert(_block_init);
-            if (tempStopped) {
-                doStart();
-                tempStopped = false;
-            }
-        }
-
-        void tempStop() {
-            assert(_block_init);
-            if (running && !tempStopped) {
-                doStop();
-                tempStopped = true;
-            }
-        }
-
-        virtual int calcOutSize(int inSize) {
-            assert(_block_init);
-            return inSize;
-        }
-
-        friend BLOCK;
-
-    private:
-        void registerBlock(generic_unnamed_block* block) {
-            blocks.push_back(block);
-        }
-
-        void unregisterBlock(generic_unnamed_block* block) {
-            blocks.erase(std::remove(blocks.begin(), blocks.end(), block), blocks.end());
-        }
-
-        virtual void doStart() {
-            for (auto& block : blocks) {
-                block->start();
-            }
-        }
-
-        virtual void doStop() {
-            for (auto& block : blocks) {
-                block->stop();
-            }
-        }
-
-        std::vector<generic_unnamed_block*> blocks;
-        bool tempStopped = false;
-        bool running = false;
-
-    protected:
-        bool _block_init = false;
-        std::mutex ctrlMtx;
-    };
 }

core/src/dsp/buffer/buffer.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <volk/volk.h>
+
+namespace dsp::buffer {
+    template<class T>
+    inline T* alloc(int count) {
+        return (T*)volk_malloc(count * sizeof(T), volk_get_alignment());
+    }
+
+    template<class T>
+    inline void clear(T* buffer, int count, int offset = 0) {
+        memset(&buffer[offset], 0, count * sizeof(T));
+    }
+
+    inline void free(void* buffer) {
+        volk_free(buffer);
+    }
+}

core/src/dsp/buffer/frame_buffer.h

@@ -0,0 +1,136 @@
+#pragma once
+#include "../block.h"
+#define TEST_BUFFER_SIZE 32
+
+// IMPORTANT: THIS IS TRASH AND MUST BE REWRITTEN IN THE FUTURE
+
+namespace dsp::buffer {
+    template <class T>
+    class SampleFrameBuffer : public block {
+        using base_type = block;
+    public:
+        SampleFrameBuffer() {}
+
+        SampleFrameBuffer(stream<T>* in) { init(in); }
+
+        ~SampleFrameBuffer() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            for (int i = 0; i < TEST_BUFFER_SIZE; i++) {
+                buffer::free(buffers[i]);
+            }
+        }
+
+        void init(stream<T>* in) {
+            _in = in;
+
+            for (int i = 0; i < TEST_BUFFER_SIZE; i++) {
+                buffers[i] = buffer::alloc<T>(STREAM_BUFFER_SIZE);
+            }
+
+            base_type::registerInput(in);
+            base_type::registerOutput(&out);
+            base_type::_block_init = true;
+        }
+
+        void setInput(stream<T>* in) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            base_type::unregisterInput(_in);
+            _in = in;
+            base_type::registerInput(_in);
+            base_type::tempStart();
+        }
+
+        void flush() {
+            std::unique_lock lck(bufMtx);
+            readCur = writeCur;
+        }
+
+        int run() {
+            // Wait for data
+            int count = _in->read();
+            if (count < 0) { return -1; }
+
+            if (bypass) {
+                memcpy(out.writeBuf, _in->readBuf, count * sizeof(T));
+                _in->flush();
+                if (!out.swap(count)) { return -1; }
+                return count;
+            }
+
+            // Push it on the ring buffer
+            {
+                std::lock_guard<std::mutex> lck(bufMtx);
+                memcpy(buffers[writeCur], _in->readBuf, count * sizeof(T));
+                sizes[writeCur] = count;
+                writeCur++;
+                writeCur = ((writeCur) % TEST_BUFFER_SIZE);
+
+                // if (((writeCur - readCur + TEST_BUFFER_SIZE) % TEST_BUFFER_SIZE) >= (TEST_BUFFER_SIZE-2)) {
+                //     spdlog::warn("Overflow");
+                // }
+            }
+            cnd.notify_all();
+            _in->flush();
+            return count;
+        }
+
+        void worker() {
+            while (true) {
+                // Wait for data
+                std::unique_lock lck(bufMtx);
+                cnd.wait(lck, [this]() { return (((writeCur - readCur + TEST_BUFFER_SIZE) % TEST_BUFFER_SIZE) > 0) || stopWorker; });
+                if (stopWorker) { break; }
+
+                // Write one to output buffer and unlock in preparation to swap buffers
+                int count = sizes[readCur];
+                memcpy(out.writeBuf, buffers[readCur], count * sizeof(T));
+                readCur++;
+                readCur = ((readCur) % TEST_BUFFER_SIZE);
+                lck.unlock();
+
+                // Swap
+                if (!out.swap(count)) { break; }
+            }
+        }
+
+        stream<T> out;
+
+        int writeCur = 0;
+        int readCur = 0;
+
+        bool bypass = false;
+
+    private:
+        void doStart() {
+            base_type::workerThread = std::thread(&SampleFrameBuffer<T>::workerLoop, this);
+            readWorkerThread = std::thread(&SampleFrameBuffer<T>::worker, this);
+        }
+
+        void doStop() {
+            _in->stopReader();
+            out.stopWriter();
+            stopWorker = true;
+            cnd.notify_all();
+
+            if (base_type::workerThread.joinable()) { base_type::workerThread.join(); }
+            if (readWorkerThread.joinable()) { readWorkerThread.join(); }
+
+            _in->clearReadStop();
+            out.clearWriteStop();
+            stopWorker = false;
+        }
+
+        stream<T>* _in;
+
+        std::thread readWorkerThread;
+        std::mutex bufMtx;
+        std::condition_variable cnd;
+        T* buffers[TEST_BUFFER_SIZE];
+        int sizes[TEST_BUFFER_SIZE];
+
+        bool stopWorker = false;
+    };
+}

core/src/dsp/buffer/packer.h

@@ -0,0 +1,69 @@
+#include "../block.h"
+
+
+namespace dsp::buffer {
+    template <class T>
+    class Packer : public block {
+    public:
+        Packer() {}
+
+        Packer(stream<T>* in, int count) { init(in, count); }
+
+        void init(stream<T>* in, int count) {
+            _in = in;
+            samples = count;
+            block::registerInput(_in);
+            block::registerOutput(&out);
+            block::_block_init = true;
+        }
+
+        void setInput(stream<T>* in) {
+            assert(block::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(block::ctrlMtx);
+            block::tempStop();
+            block::unregisterInput(_in);
+            _in = in;
+            block::registerInput(_in);
+            block::tempStart();
+        }
+
+        void setSampleCount(int count) {
+            assert(block::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(block::ctrlMtx);
+            block::tempStop();
+            samples = count;
+            block::tempStart();
+        }
+
+        int run() {
+            int count = _in->read();
+            if (count < 0) {
+                read = 0;
+                return -1;
+            }
+
+            for (int i = 0; i < count; i++) {
+                out.writeBuf[read++] = _in->readBuf[i];
+                if (read >= samples) {
+                    read = 0;
+                    if (!out.swap(samples)) {
+                        _in->flush();
+                        read = 0;
+                        return -1;
+                    }
+                }
+            }
+
+            _in->flush();
+
+            return count;
+        }
+
+        stream<T> out;
+
+    private:
+        int samples = 1;
+        int read = 0;
+        stream<T>* _in;
+    };
+}

core/src/dsp/buffer/reshaper.h

@@ -0,0 +1,137 @@
+#pragma once
+#include "../block.h"
+#include "ring_buffer.h"
+
+// IMPORTANT: THIS IS TRASH AND MUST BE REWRITTEN IN THE FUTURE
+
+namespace dsp::buffer {
+    // NOTE: I'm not proud of this, it's BAD and just taken from the previous DSP, but it works...
+    template <class T>
+    class Reshaper : public block {
+        using base_type = block;
+    public:
+        Reshaper() {}
+
+        Reshaper(stream<T>* in, int keep, int skip) { init(in, keep, skip); }
+
+        // NOTE: For some reason, the base class destructor doesn't get called.... this is a temporary fix I guess
+        // I also don't check for _block_init for the exact sample reason, something's weird
+        ~Reshaper() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+        }
+
+        void init(stream<T>* in, int keep, int skip) {
+            _in = in;
+            _keep = keep;
+            _skip = skip;
+            ringBuf.init(keep * 2);
+            base_type::registerInput(_in);
+            base_type::registerOutput(&out);
+            base_type::_block_init = true;
+        }
+
+        void setInput(stream<T>* in) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            base_type::unregisterInput(_in);
+            _in = in;
+            base_type::registerInput(_in);
+            base_type::tempStart();
+        }
+
+        void setKeep(int keep) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _keep = keep;
+            ringBuf.setMaxLatency(keep * 2);
+            base_type::tempStart();
+        }
+
+        void setSkip(int skip) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _skip = skip;
+            base_type::tempStart();
+        }
+
+        int run() {
+            int count = _in->read();
+            if (count < 0) { return -1; }
+            ringBuf.write(_in->readBuf, count);
+            _in->flush();
+            return count;
+        }
+
+        stream<T> out;
+
+    private:
+        void doStart() override {
+            workThread = std::thread(&Reshaper<T>::loop, this);
+            bufferWorkerThread = std::thread(&Reshaper<T>::bufferWorker, this);
+        }
+
+        void loop() {
+            while (run() >= 0)
+                ;
+        }
+
+        void doStop() override {
+            _in->stopReader();
+            ringBuf.stopReader();
+            out.stopWriter();
+            ringBuf.stopWriter();
+
+            if (workThread.joinable()) {
+                workThread.join();
+            }
+            if (bufferWorkerThread.joinable()) {
+                bufferWorkerThread.join();
+            }
+
+            _in->clearReadStop();
+            ringBuf.clearReadStop();
+            out.clearWriteStop();
+            ringBuf.clearWriteStop();
+        }
+
+        void bufferWorker() {
+            T* buf = new T[_keep];
+            bool delay = _skip < 0;
+
+            int readCount = std::min<int>(_keep + _skip, _keep);
+            int skip = std::max<int>(_skip, 0);
+            int delaySize = (-_skip) * sizeof(T);
+            int delayCount = (-_skip);
+
+            T* start = &buf[std::max<int>(-_skip, 0)];
+            T* delayStart = &buf[_keep + _skip];
+
+            while (true) {
+                if (delay) {
+                    memmove(buf, delayStart, delaySize);
+                    if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
+                        for (int i = 0; i < delayCount; i++) {
+                            buf[i].re /= 10.0f;
+                            buf[i].im /= 10.0f;
+                        }
+                    }
+                }
+                if (ringBuf.readAndSkip(start, readCount, skip) < 0) { break; };
+                memcpy(out.writeBuf, buf, _keep * sizeof(T));
+                if (!out.swap(_keep)) { break; }
+            }
+            delete[] buf;
+        }
+
+        stream<T>* _in;
+        int _outBlockSize;
+        RingBuffer<T> ringBuf;
+        std::thread bufferWorkerThread;
+        std::thread workThread;
+        int _keep, _skip;
+    };
+}

core/src/dsp/buffer/ring_buffer.h

@@ -1,10 +1,11 @@
 #pragma once
-#include <dsp/block.h>
-#include <string.h>
+#include "buffer.h"
 
 #define RING_BUF_SZ 1000000
 
-namespace dsp {
+// IMPORTANT: THIS IS TRASH AND MUST BE REWRITTEN IN THE FUTURE
+
+namespace dsp::buffer {
     template <class T>
     class RingBuffer {
     public:
@@ -14,13 +15,12 @@ namespace dsp {
 
         ~RingBuffer() {
             if (!_init) { return; }
-            delete _buffer;
+            buffer::free(_buffer);
             _init = false;
         }
 
         void init(int maxLatency) {
             size = RING_BUF_SZ;
-            _buffer = new T[size];
             _stopReader = false;
             _stopWriter = false;
             this->maxLatency = maxLatency;
@@ -28,7 +28,8 @@ namespace dsp {
             readc = 0;
             readable = 0;
             writable = size;
-            memset(_buffer, 0, size * sizeof(T));
+            _buffer = buffer::alloc<T>(size);
+            buffer::clear(_buffer, size);
             _init = true;
         }
 
@@ -235,126 +236,4 @@ namespace dsp {
         std::condition_variable canReadVar;
         std::condition_variable canWriteVar;
     };
-
-#define TEST_BUFFER_SIZE 32
-
-    template <class T>
-    class SampleFrameBuffer : public generic_block<SampleFrameBuffer<T>> {
-    public:
-        SampleFrameBuffer() {}
-
-        SampleFrameBuffer(stream<T>* in) { init(in); }
-
-        void init(stream<T>* in) {
-            _in = in;
-
-            for (int i = 0; i < TEST_BUFFER_SIZE; i++) {
-                buffers[i] = new T[STREAM_BUFFER_SIZE];
-            }
-
-            generic_block<SampleFrameBuffer<T>>::registerInput(in);
-            generic_block<SampleFrameBuffer<T>>::registerOutput(&out);
-            generic_block<SampleFrameBuffer<T>>::_block_init = true;
-        }
-
-        void setInput(stream<T>* in) {
-            assert(generic_block<SampleFrameBuffer<T>>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<SampleFrameBuffer<T>>::ctrlMtx);
-            generic_block<SampleFrameBuffer<T>>::tempStop();
-            generic_block<SampleFrameBuffer<T>>::unregisterInput(_in);
-            _in = in;
-            generic_block<SampleFrameBuffer<T>>::registerInput(_in);
-            generic_block<SampleFrameBuffer<T>>::tempStart();
-        }
-
-        void flush() {
-            std::unique_lock lck(bufMtx);
-            readCur = writeCur;
-        }
-
-        int run() {
-            // Wait for data
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            if (bypass) {
-                memcpy(out.writeBuf, _in->readBuf, count * sizeof(T));
-                _in->flush();
-                if (!out.swap(count)) { return -1; }
-                return count;
-            }
-
-            // Push it on the ring buffer
-            {
-                std::lock_guard<std::mutex> lck(bufMtx);
-                memcpy(buffers[writeCur], _in->readBuf, count * sizeof(T));
-                sizes[writeCur] = count;
-                writeCur++;
-                writeCur = ((writeCur) % TEST_BUFFER_SIZE);
-
-                // if (((writeCur - readCur + TEST_BUFFER_SIZE) % TEST_BUFFER_SIZE) >= (TEST_BUFFER_SIZE-2)) {
-                //     spdlog::warn("Overflow");
-                // }
-            }
-            cnd.notify_all();
-            _in->flush();
-            return count;
-        }
-
-        void worker() {
-            while (true) {
-                // Wait for data
-                std::unique_lock lck(bufMtx);
-                cnd.wait(lck, [this]() { return (((writeCur - readCur + TEST_BUFFER_SIZE) % TEST_BUFFER_SIZE) > 0) || stopWorker; });
-                if (stopWorker) { break; }
-
-                // Write one to output buffer and unlock in preparation to swap buffers
-                int count = sizes[readCur];
-                memcpy(out.writeBuf, buffers[readCur], count * sizeof(T));
-                readCur++;
-                readCur = ((readCur) % TEST_BUFFER_SIZE);
-                lck.unlock();
-
-                // Swap
-                if (!out.swap(count)) { break; }
-            }
-        }
-
-        stream<T> out;
-
-        int writeCur = 0;
-        int readCur = 0;
-
-        bool bypass = false;
-
-    private:
-        void doStart() {
-            generic_block<SampleFrameBuffer<T>>::workerThread = std::thread(&generic_block<SampleFrameBuffer<T>>::workerLoop, this);
-            readWorkerThread = std::thread(&SampleFrameBuffer<T>::worker, this);
-        }
-
-        void doStop() {
-            _in->stopReader();
-            out.stopWriter();
-            stopWorker = true;
-            cnd.notify_all();
-
-            if (generic_block<SampleFrameBuffer<T>>::workerThread.joinable()) { generic_block<SampleFrameBuffer<T>>::workerThread.join(); }
-            if (readWorkerThread.joinable()) { readWorkerThread.join(); }
-
-            _in->clearReadStop();
-            out.clearWriteStop();
-            stopWorker = false;
-        }
-
-        stream<T>* _in;
-
-        std::thread readWorkerThread;
-        std::mutex bufMtx;
-        std::condition_variable cnd;
-        T* buffers[TEST_BUFFER_SIZE];
-        int sizes[TEST_BUFFER_SIZE];
-
-        bool stopWorker = false;
-    };
-};
+}

core/src/dsp/chain.h

@@ -1,209 +1,193 @@
 #pragma once
-#include <dsp/stream.h>
-#include <type_traits>
 #include <vector>
-#include <utils/event.h>
+#include <map>
+#include "processor.h"
 
 namespace dsp {
-    template <class T>
-    class ChainLinkAny {
+    template<class T>
+    class chain {
     public:
-        virtual ~ChainLinkAny() {}
-        virtual void setInput(stream<T>* stream) = 0;
-        virtual stream<T>* getOutput() = 0;
-        virtual void start() = 0;
-        virtual void stop() = 0;
-        bool enabled = false;
-    };
+        chain() {}
 
-    template <class BLOCK, class T>
-    class ChainLink : public ChainLinkAny<T> {
-    public:
-        ~ChainLink() {}
+        chain(stream<T>* in) { init(in); }
 
-        void setInput(stream<T>* stream) {
-            block.setInput(stream);
+        void init(stream<T>* in) {
+            _in = in;
+            out = _in;
         }
 
-        stream<T>* getOutput() {
-            return &block.out;
+        template<typename Func>
+        void setInput(stream<T>* in, Func onOutputChange) {
+            _in = in;
+            for (auto& ln : links) {
+                if (states[ln]) {
+                    ln->setInput(_in);
+                    return;
+                }
+            }
+            out = _in;
+            onOutputChange(out);
+        }
+        
+        void addBlock(Processor<T, T>* block, bool enabled) {
+            // Check if block is already part of the chain
+            if (blockExists(block)) {
+                throw std::runtime_error("[chain] Tried to add a block that is already part of the chain");
+            }
+
+            // Add to the list
+            links.push_back(block);
+            states[block] = false;
+
+            // Enable if needed
+            if (enabled) { enableBlock(block, [](stream<T>* out){}); }
+        }
+
+        template<typename Func>
+        void removeBlock(Processor<T, T>* block, Func onOutputChange) {
+            // Check if block is part of the chain
+            if (!blockExists(block)) {
+                throw std::runtime_error("[chain] Tried to remove a block that is not part of the chain");
+            }
+
+            // Disable the block
+            disableBlock(block, onOutputChange);
+        
+            // Remove block from the list
+            states.erase(block);
+            links.erase(std::find(links.begin(), links.end(), block));
+        }
+
+        template<typename Func>
+        void enableBlock(Processor<T, T>* block, Func onOutputChange) {
+            // Check that the block is part of the chain
+            if (!blockExists(block)) {
+                throw std::runtime_error("[chain] Tried to enable a block that isn't part of the chain");
+            }
+            
+            // If already enable, don't do anything
+            if (states[block]) { return; }
+
+            // Gather blocks before and after the block to enable
+            Processor<T, T>* before = blockBefore(block);
+            Processor<T, T>* after = blockAfter(block);
+
+            // Update input of next block or output
+            if (after) {
+                after->setInput(&block->out);
+            }
+            else {
+                out = &block->out;
+                onOutputChange(out);
+            }
+
+            // Set input of the new block
+            block->setInput(before ? &before->out : _in);
+
+            // Start new block
+            if (running) { block->start(); }
+            states[block] = true;
+        }
+
+        template<typename Func>
+        void disableBlock(Processor<T, T>* block, Func onOutputChange) {
+            // Check that the block is part of the chain
+            if (!blockExists(block)) {
+                throw std::runtime_error("[chain] Tried to enable a block that isn't part of the chain");
+            }
+            
+            // If already disabled, don't do anything
+            if (!states[block]) { return; }
+
+            // Stop disabled block
+            block->stop();
+            states[block] = false;
+
+            // Gather blocks before and after the block to disable
+            Processor<T, T>* before = blockBefore(block);
+            Processor<T, T>* after = blockAfter(block);
+
+            // Update input of next block or output
+            if (after) {
+                after->setInput(before ? &before->out : _in);
+            }
+            else {
+                out = before ? &before->out : _in;
+                onOutputChange(out);
+            }
+        }
+
+        template<typename Func>
+        void setBlockEnabled(Processor<T, T>* block, bool enabled, Func onOutputChange) {
+            if (enabled) {
+                enableBlock(block, onOutputChange);
+            }
+            else {
+                disableBlock(block, onOutputChange);
+            }
+        }
+
+        template<typename Func>
+        void enableAllBlocks(Func onOutputChange) {
+            for (auto& ln : links) {
+                enableBlock(ln, onOutputChange);
+            }
+        }
+
+        template<typename Func>
+        void disableAllBlocks(Func onOutputChange) {
+            for (auto& ln : links) {
+                disableBlock(ln, onOutputChange);
+            }
         }
 
         void start() {
-            block.start();
-        }
-
-        void stop() {
-            block.stop();
-        }
-
-        BLOCK block;
-    };
-
-    template <class T>
-    class Chain {
-    public:
-        Chain() {}
-
-        Chain(stream<T>* input, EventHandler<stream<T>*>* outputChangedHandler) {
-            init(input, outputChangedHandler);
-        }
-
-        void init(stream<T>* input, EventHandler<stream<T>*>* outputChangedHandler) {
-            _input = input;
-            onOutputChanged.bindHandler(outputChangedHandler);
-        }
-
-        void add(ChainLinkAny<T>* link) {
-            // Check that link exists
-            if (std::find(links.begin(), links.end(), link) != links.end()) {
-                spdlog::error("Could not add new link to the chain, link already in the chain");
-                return;
-            }
-
-            // Assert that the link is stopped and disabled
-            link->stop();
-            link->enabled = false;
-
-            // Add new link to the list
-            links.push_back(link);
-        }
-
-        void enable(ChainLinkAny<T>* link) {
-            // Check that link exists and locate it
-            auto lnit = std::find(links.begin(), links.end(), link);
-            if (lnit == links.end()) {
-                spdlog::error("Could not enable link");
-                return;
-            }
-            // Enable the link
-            link->enabled = true;
-
-            // Find input
-            stream<T>* input = _input;
-            for (auto i = links.begin(); i < lnit; i++) {
-                if (!(*i)->enabled) { continue; }
-                input = (*i)->getOutput();
-            }
-
-            // Find next block
-            ChainLinkAny<T>* nextLink = NULL;
-            for (auto i = ++lnit; i < links.end(); i++) {
-                if (!(*i)->enabled) { continue; }
-                nextLink = *i;
-                break;
-            }
-
-            if (nextLink) {
-                // If a next block exists, change its input
-                nextLink->setInput(link->getOutput());
-            }
-            else {
-                // If there are no next blocks, change output of outside reader
-                onOutputChanged.emit(link->getOutput());
-            }
-
-            // Set input of newly enabled link
-            link->setInput(input);
-
-            // If running, start everything
-            if (running) { start(); }
-        }
-
-        void disable(ChainLinkAny<T>* link) {
-            // Check that link exists and locate it
-            auto lnit = std::find(links.begin(), links.end(), link);
-            if (lnit == links.end()) {
-                spdlog::error("Could not disable link");
-                return;
-            }
-
-            // Stop and disable link
-            link->stop();
-            link->enabled = false;
-
-            // Find its input
-            stream<T>* input = _input;
-            for (auto i = links.begin(); i < lnit; i++) {
-                if (!(*i)->enabled) { continue; }
-                input = (*i)->getOutput();
-            }
-
-            // Find next block
-            ChainLinkAny<T>* nextLink = NULL;
-            for (auto i = ++lnit; i < links.end(); i++) {
-                if (!(*i)->enabled) { continue; }
-                nextLink = *i;
-                break;
-            }
-
-            if (nextLink) {
-                // If a next block exists, change its input
-                nextLink->setInput(input);
-            }
-            else {
-                // If there are no next blocks, change output of outside reader
-                onOutputChanged.emit(input);
-            }
-        }
-
-        void disableAll() {
+            if (running) { return; }
             for (auto& ln : links) {
-                disable(ln);
+                if (!states[ln]) { continue; }
+                ln->start();
             }
-        }
-
-        void setState(ChainLinkAny<T>* link, bool enabled) {
-            enabled ? enable(link) : disable(link);
-        }
-
-        void setInput(stream<T>* input) {
-            _input = input;
-
-            // Set input of first enabled link
-            for (auto& ln : links) {
-                if (!ln->enabled) { continue; }
-                ln->setInput(_input);
-                return;
-            }
-
-            // No block found, this means nothing is enabled
-            onOutputChanged.emit(_input);
-        }
-
-        stream<T>* getOutput() {
-            stream<T>* lastOutput = _input;
-            for (auto& ln : links) {
-                if (!ln->enabled) { continue; }
-                lastOutput = ln->getOutput();
-            }
-            return lastOutput;
-        }
-
-        void start() {
             running = true;
-            for (auto& ln : links) {
-                if (ln->enabled) {
-                    ln->start();
-                }
-                else {
-                    ln->stop();
-                }
-            }
         }
 
         void stop() {
-            running = false;
+            if (!running) { return; }
             for (auto& ln : links) {
+                if (!states[ln]) { continue; }
                 ln->stop();
             }
+            running = false;
         }
 
-        Event<stream<T>*> onOutputChanged;
+        stream<T>* out;
 
     private:
-        stream<T>* _input;
-        std::vector<ChainLinkAny<T>*> links;
+        Processor<T, T>* blockBefore(Processor<T, T>* block) {
+            for (auto& ln : links) {
+                if (ln == block) { return NULL; }
+                if (states[ln]) { return ln; }
+            }
+        }
+
+        Processor<T, T>* blockAfter(Processor<T, T>* block) {
+            bool blockFound = false;
+            for (auto& ln : links) {
+                if (ln == block) {
+                    blockFound = true;
+                    continue;
+                }
+                if (states[ln] && blockFound) { return ln; }
+            }
+            return NULL;
+        }
+
+        bool blockExists(Processor<T, T>* block) {
+            return states.find(block) != states.end();
+        }
+
+        stream<T>* _in;
+        std::vector<Processor<T, T>*> links;
+        std::map<Processor<T, T>*, bool> states;
         bool running = false;
     };
 }

core/src/dsp/channel/frequency_xlator.h

@@ -0,0 +1,63 @@
+#pragma once
+#include "../processor.h"
+#include "../math/freq_to_omega.h"
+
+namespace dsp::channel {
+    class FrequencyXlator : public Processor<complex_t, complex_t> {
+        using base_type = Processor<complex_t, complex_t>;
+    public:
+        FrequencyXlator() {}
+
+        FrequencyXlator(stream<complex_t>* in, double offset) { init(in, offset); }
+
+        FrequencyXlator(stream<complex_t>* in, double offset, double samplerate) { init(in, offset, samplerate); }
+
+        void init(stream<complex_t>* in, double offset) {
+            phase = lv_cmake(1.0f, 0.0f);
+            phaseDelta = lv_cmake(cos(offset), sin(offset));
+            base_type::init(in);
+        }
+
+        void init(stream<complex_t>* in, double offset, double samplerate) {
+            init(in, math::freqToOmega(offset, samplerate));
+        }
+
+        void setOffset(double offset) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            phaseDelta = lv_cmake(cos(offset), sin(offset));
+        }
+
+        void setOffset(double offset, double samplerate) {
+            setOffset(math::freqToOmega(offset, samplerate));
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            tempStop();
+            phase = lv_cmake(1.0f, 0.0f);
+            tempStart();
+        }
+
+        inline int process(int count, const complex_t* in, complex_t* out) {
+            volk_32fc_s32fc_x2_rotator_32fc((lv_32fc_t*)out, (lv_32fc_t*)in, phaseDelta, &phase, count);
+            return count;
+        }
+
+        virtual int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        lv_32fc_t phase;
+        lv_32fc_t phaseDelta;
+    };
+}

core/src/dsp/channel/rx_vfo.h

@@ -0,0 +1,136 @@
+#pragma once
+#include "frequency_xlator.h"
+#include "../multirate/rational_resampler.h"
+
+namespace dsp::channel {
+    class RxVFO : public Processor<complex_t, complex_t> {
+        using base_type = Processor<complex_t, complex_t>;
+    public:
+        RxVFO() {}
+
+        RxVFO(stream<complex_t>* in, double inSamplerate, double outSamplerate, double bandwidth, double offset) { init(in, inSamplerate, outSamplerate, bandwidth, offset); }
+
+        ~RxVFO() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            taps::free(ftaps);
+        }
+
+        void init(stream<complex_t>* in, double inSamplerate, double outSamplerate, double bandwidth, double offset) {
+            _inSamplerate = inSamplerate;
+            _outSamplerate = outSamplerate;
+            _bandwidth = bandwidth;
+            _offset = offset;
+            filterNeeded = (_bandwidth != _outSamplerate);
+            ftaps.taps = NULL;
+
+            xlator.init(NULL, -_offset, _inSamplerate);
+            resamp.init(NULL, _inSamplerate, _outSamplerate);
+            generateTaps();
+            filter.init(NULL, ftaps);
+
+            base_type::init(in);
+        }
+
+        void setInSamplerate(double inSamplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _inSamplerate = inSamplerate;
+            xlator.setOffset(-_offset, _inSamplerate);
+            resamp.setInSamplerate(_inSamplerate);
+            base_type::tempStart();
+        }
+
+        void setOutSamplerate(double outSamplerate, double bandwidth) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _outSamplerate = outSamplerate;
+            _bandwidth = bandwidth;
+            filterNeeded = (_bandwidth != _outSamplerate);
+            resamp.setOutSamplerate(_outSamplerate);
+            if (filterNeeded) {
+                generateTaps();
+                filter.setTaps(ftaps);
+            }
+            base_type::tempStart();
+        }
+
+        void setBandwidth(double bandwidth) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            std::lock_guard<std::mutex> lck2(filterMtx);
+            _bandwidth = bandwidth;
+            filterNeeded = (_bandwidth != _outSamplerate);
+            if (filterNeeded) {
+                generateTaps();
+                filter.setTaps(ftaps);
+            }
+        }
+
+        void setOffset(double offset) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _offset = offset;
+            xlator.setOffset(-_offset, _inSamplerate);
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            xlator.reset();
+            resamp.reset();
+            filter.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const complex_t* in, complex_t* out) {
+            xlator.process(count, in, out);
+            if (!filterNeeded) {
+                return resamp.process(count, out, out);
+            }
+            count = resamp.process(count, out, out);
+            {
+                std::lock_guard<std::mutex> lck(filterMtx);
+                filter.process(count, out, out);
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        void generateTaps() {
+            taps::free(ftaps);
+            double filterWidth = _bandwidth / 2.0;
+            ftaps = taps::lowPass(filterWidth, filterWidth * 0.1, _outSamplerate);
+        }
+
+        FrequencyXlator xlator;
+        multirate::RationalResampler<complex_t> resamp;
+        filter::FIR<complex_t, float> filter;
+        tap<float> ftaps;
+        bool filterNeeded;
+
+        double _inSamplerate;
+        double _outSamplerate;
+        double _bandwidth;
+        double _offset;
+
+        std::mutex filterMtx;
+    };
+}

core/src/dsp/clock_recovery.h

@@ -1,255 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <dsp/utils/macros.h>
-#include <dsp/interpolation_taps.h>
-
-namespace dsp {
-    class EdgeTrigClockRecovery : public generic_block<EdgeTrigClockRecovery> {
-    public:
-        EdgeTrigClockRecovery() {}
-
-        EdgeTrigClockRecovery(stream<float>* in, int omega) { init(in, omega); }
-
-        void init(stream<float>* in, int omega) {
-            _in = in;
-            samplesPerSymbol = omega;
-            generic_block<EdgeTrigClockRecovery>::registerInput(_in);
-            generic_block<EdgeTrigClockRecovery>::registerOutput(&out);
-            generic_block<EdgeTrigClockRecovery>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in) {
-            assert(generic_block<EdgeTrigClockRecovery>::_block_init);
-            generic_block<EdgeTrigClockRecovery>::tempStop();
-            generic_block<EdgeTrigClockRecovery>::unregisterInput(_in);
-            _in = in;
-            generic_block<EdgeTrigClockRecovery>::registerInput(_in);
-            generic_block<EdgeTrigClockRecovery>::tempStart();
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            int outCount = 0;
-
-            for (int i = 0; i < count; i++) {
-                if (DSP_SIGN(lastVal) != DSP_SIGN(_in->readBuf[i])) {
-                    counter = samplesPerSymbol / 2;
-                    lastVal = _in->readBuf[i];
-                    continue;
-                }
-
-                if (counter >= samplesPerSymbol) {
-                    counter = 0;
-                    out.writeBuf[outCount] = _in->readBuf[i];
-                    outCount++;
-                }
-                else {
-                    counter++;
-                }
-
-                lastVal = _in->readBuf[i];
-            }
-
-            _in->flush();
-            if (outCount > 0 && !out.swap(outCount)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        int count;
-        int samplesPerSymbol = 1;
-        int counter = 0;
-        float lastVal = 0;
-        stream<float>* _in;
-    };
-
-    template <class T>
-    class MMClockRecovery : public generic_block<MMClockRecovery<T>> {
-    public:
-        MMClockRecovery() {}
-
-        MMClockRecovery(stream<T>* in, float omega, float gainOmega, float muGain, float omegaRelLimit) {
-            init(in, omega, gainOmega, muGain, omegaRelLimit);
-        }
-
-        void init(stream<T>* in, float omega, float gainOmega, float muGain, float omegaRelLimit) {
-            _in = in;
-            _omega = omega;
-            _muGain = muGain;
-            _gainOmega = gainOmega;
-            _omegaRelLimit = omegaRelLimit;
-
-            omegaMin = _omega - (_omega * _omegaRelLimit);
-            omegaMax = _omega + (_omega * _omegaRelLimit);
-            _dynOmega = _omega;
-
-            memset(delay, 0, 1024 * sizeof(T));
-
-            generic_block<MMClockRecovery<T>>::registerInput(_in);
-            generic_block<MMClockRecovery<T>>::registerOutput(&out);
-            generic_block<MMClockRecovery<T>>::_block_init = true;
-        }
-
-        void setOmega(float omega, float omegaRelLimit) {
-            assert(generic_block<MMClockRecovery<T>>::_block_init);
-            generic_block<MMClockRecovery<T>>::tempStop();
-            omegaMin = _omega - (_omega * _omegaRelLimit);
-            omegaMax = _omega + (_omega * _omegaRelLimit);
-            _omega = omega;
-            _dynOmega = _omega;
-            generic_block<MMClockRecovery<T>>::tempStart();
-        }
-
-        void setGains(float omegaGain, float muGain) {
-            assert(generic_block<MMClockRecovery<T>>::_block_init);
-            generic_block<MMClockRecovery<T>>::tempStop();
-            _gainOmega = omegaGain;
-            _muGain = muGain;
-            generic_block<MMClockRecovery<T>>::tempStart();
-        }
-
-        void setOmegaRelLimit(float omegaRelLimit) {
-            assert(generic_block<MMClockRecovery<T>>::_block_init);
-            generic_block<MMClockRecovery<T>>::tempStop();
-            _omegaRelLimit = omegaRelLimit;
-            omegaMin = _omega - (_omega * _omegaRelLimit);
-            omegaMax = _omega + (_omega * _omegaRelLimit);
-            generic_block<MMClockRecovery<T>>::tempStart();
-        }
-
-        void setInput(stream<T>* in) {
-            assert(generic_block<MMClockRecovery<T>>::_block_init);
-            generic_block<MMClockRecovery<T>>::tempStop();
-            generic_block<MMClockRecovery<T>>::unregisterInput(_in);
-            _in = in;
-            generic_block<MMClockRecovery<T>>::registerInput(_in);
-            generic_block<MMClockRecovery<T>>::tempStart();
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            int outCount = 0;
-            float outVal;
-            float phaseError;
-            float roundedStep;
-            int maxOut = 2.0f * _omega * (float)count;
-
-            // Copy the first 7 values to the delay buffer for fast computing
-            memcpy(&delay[7], _in->readBuf, 7 * sizeof(T));
-
-            int i = nextOffset;
-            for (; i < count && outCount < maxOut;) {
-
-                if constexpr (std::is_same_v<T, float>) {
-                    // Calculate output value
-                    // If we still need to use the old values, calculate using delay buf
-                    // Otherwise, use normal buffer
-                    if (i < 7) {
-                        volk_32f_x2_dot_prod_32f(&outVal, &delay[i], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
-                    }
-                    else {
-                        volk_32f_x2_dot_prod_32f(&outVal, &_in->readBuf[i - 7], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
-                    }
-                    out.writeBuf[outCount++] = outVal;
-
-                    // Cursed phase detect approximation (don't ask me how this approximation works)
-                    phaseError = (DSP_STEP(lastOutput) * outVal) - (lastOutput * DSP_STEP(outVal));
-                    lastOutput = outVal;
-                }
-                if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
-                    // Propagate delay
-                    _p_2T = _p_1T;
-                    _p_1T = _p_0T;
-
-                    _c_2T = _c_1T;
-                    _c_1T = _c_0T;
-
-                    // Perform interpolation the same way as for float values
-                    if (i < 7) {
-                        volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&_p_0T, (lv_32fc_t*)&delay[i], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
-                    }
-                    else {
-                        volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&_p_0T, (lv_32fc_t*)&_in->readBuf[i - 7], INTERP_TAPS[(int)roundf(_mu * 128.0f)], 8);
-                    }
-                    out.writeBuf[outCount++] = _p_0T;
-
-                    // Slice output value
-                    _c_0T = DSP_STEP_CPLX(_p_0T);
-
-                    // Cursed math to calculate the phase error
-                    phaseError = (((_p_0T - _p_2T) * _c_1T.conj()) - ((_c_0T - _c_2T) * _p_1T.conj())).re;
-                }
-
-                // Clamp phase error
-                if (phaseError > 1.0f) { phaseError = 1.0f; }
-                if (phaseError < -1.0f) { phaseError = -1.0f; }
-
-                // Adjust the symbol rate using the phase error approximation and clamp
-                // TODO: Branchless clamp
-                _dynOmega = _dynOmega + (_gainOmega * phaseError);
-                if (_dynOmega > omegaMax) { _dynOmega = omegaMax; }
-                else if (_dynOmega < omegaMin) {
-                    _dynOmega = omegaMin;
-                }
-
-                // Adjust the symbol phase according to the phase error approximation
-                // It will now contain the phase delta needed to jump to the next symbol
-                // Rounded step will contain the rounded number of symbols
-                _mu = _mu + _dynOmega + (_muGain * phaseError);
-                roundedStep = floor(_mu);
-
-                // Step to where the next symbol should be, and check for bogus input
-                i += (int)roundedStep;
-                if (i < 0) { i = 0; }
-
-                // Now that we've stepped to the next symbol, keep only the offset inside the symbol
-                _mu -= roundedStep;
-            }
-
-            nextOffset = i - count;
-
-            // Save the last 7 values for the next round
-            memcpy(delay, &_in->readBuf[count - 7], 7 * sizeof(T));
-
-            _in->flush();
-            if (outCount > 0 && !out.swap(outCount)) { return -1; }
-            return count;
-        }
-
-        stream<T> out;
-
-    private:
-        int count;
-
-        // Delay buffer
-        T delay[1024];
-        int nextOffset = 0;
-
-        // Configuration
-        float _omega = 1.0f;
-        float _muGain = 1.0f;
-        float _gainOmega = 0.001f;
-        float _omegaRelLimit = 0.005;
-
-        // Precalculated values
-        float omegaMin = _omega + (_omega * _omegaRelLimit);
-        float omegaMax = _omega + (_omega * _omegaRelLimit);
-
-        // Runtime adjusted
-        float _dynOmega = _omega;
-        float _mu = 0.5f;
-        float lastOutput = 0.0f;
-
-        // Cursed complex stuff
-        complex_t _p_0T = { 0, 0 }, _p_1T = { 0, 0 }, _p_2T = { 0, 0 };
-        complex_t _c_0T = { 0, 0 }, _c_1T = { 0, 0 }, _c_2T = { 0, 0 };
-
-        stream<T>* _in;
-    };
-}

core/src/dsp/clock_recovery/fd.h

@@ -0,0 +1,189 @@
+#pragma once
+#include "../processor.h"
+#include "../loop/phase_control_loop.h"
+#include "../taps/windowed_sinc.h"
+#include "../multirate/polyphase_bank.h"
+#include "../math/step.h"
+
+namespace dsp::clock_recovery {
+    class FD : public Processor<float, float> {
+        using base_type = Processor<float, float> ;
+    public:
+        FD() {}
+
+        FD(stream<float>* in, double omega, double omegaGain, double muGain, double omegaRelLimit, int interpPhaseCount = 128, int interpTapCount = 8) { init(in, omega, omegaGain, muGain, omegaRelLimit, interpPhaseCount, interpTapCount); }
+
+        ~FD() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            dsp::multirate::freePolyphaseBank(interpBank);
+            buffer::free(buffer);
+        }
+
+        void init(stream<float>* in, double omega, double omegaGain, double muGain, double omegaRelLimit, int interpPhaseCount = 128, int interpTapCount = 8) {
+            _omega = omega;
+            _omegaGain = omegaGain;
+            _muGain = muGain;
+            _omegaRelLimit = omegaRelLimit;
+            _interpPhaseCount = interpPhaseCount;
+            _interpTapCount = interpTapCount;
+
+            pcl.init(_muGain, _omegaGain, 0.0, 0.0, 1.0, _omega, _omega * (1.0 - omegaRelLimit), _omega * (1.0 + omegaRelLimit));
+            generateInterpTaps();
+            buffer = buffer::alloc<float>(STREAM_BUFFER_SIZE + _interpTapCount);
+            bufStart = &buffer[_interpTapCount - 1];
+        
+            base_type::init(in);
+        }
+
+        void setOmega(double omega) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _omega = omega;
+            offset = 0;
+            pcl.phase = 0.0f;
+            pcl.freq = _omega;
+            pcl.setFreqLimits(_omega * (1.0 - _omegaRelLimit), _omega * (1.0 + _omegaRelLimit));
+            base_type::tempStart();
+        }
+
+        void setOmegaGain(double omegaGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _omegaGain = omegaGain;
+            pcl.setCoefficients(_muGain, _omegaGain);
+        }
+
+        void setMuGain(double muGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _muGain = muGain;
+            pcl.setCoefficients(_muGain, _omegaGain);
+        }
+
+        void setOmegaRelLimit(double omegaRelLimit) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _omegaRelLimit = omegaRelLimit;
+            pcl.setFreqLimits(_omega * (1.0 - _omegaRelLimit), _omega * (1.0 + _omegaRelLimit));
+        }
+
+        void setInterpParams(int interpPhaseCount, int interpTapCount) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _interpPhaseCount = interpPhaseCount;
+            _interpTapCount = interpTapCount;
+            dsp::multirate::freePolyphaseBank(interpBank);
+            buffer::free(buffer);
+            generateInterpTaps();
+            buffer = buffer::alloc<float>(STREAM_BUFFER_SIZE + _interpTapCount);
+            bufStart = &buffer[_interpTapCount - 1];
+            base_type::tempStart();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            offset = 0;
+            pcl.phase = 0.0f;
+            pcl.freq = _omega;
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const float* in, float* out) {
+            // Copy data to work buffer
+            memcpy(bufStart, in, count * sizeof(float));
+
+            // Process all samples
+            int outCount = 0;
+            while (offset < count) {
+                float error;
+                float outVal;
+                float dfdt;
+
+                // Calculate new output value
+                int phase = std::clamp<int>(floorf(pcl.phase * (float)_interpPhaseCount), 0, _interpPhaseCount - 1);
+                volk_32f_x2_dot_prod_32f(&outVal, &buffer[offset], interpBank.phases[phase], _interpTapCount);
+                out[outCount++] = outVal;
+
+                // Calculate derivative of the signal
+                if (phase == 0) {
+                    float fT1;
+                    volk_32f_x2_dot_prod_32f(&fT1, &buffer[offset], interpBank.phases[phase+1], _interpTapCount);
+                    dfdt = fT1 - outVal;
+                }
+                else if (phase == _interpPhaseCount - 1) {
+                    float fT_1;
+                    volk_32f_x2_dot_prod_32f(&fT_1, &buffer[offset], interpBank.phases[phase-1], _interpTapCount);
+                    dfdt = outVal - fT_1;
+                }
+                else {
+                    float fT_1;
+                    float fT1;
+                    volk_32f_x2_dot_prod_32f(&fT_1, &buffer[offset], interpBank.phases[phase-1], _interpTapCount);
+                    volk_32f_x2_dot_prod_32f(&fT1, &buffer[offset], interpBank.phases[phase+1], _interpTapCount);
+                    dfdt = (fT1 - fT_1) * 0.5f;
+                }
+                
+                // Calculate error
+                error = dfdt * math::step(outVal);
+
+                // Clamp symbol phase error
+                if (error > 1.0f) { error = 1.0f; }
+                if (error < -1.0f) { error = -1.0f; }
+
+                // Advance symbol offset and phase
+                pcl.advance(error);
+                float delta = floorf(pcl.phase);
+                offset += delta;
+                pcl.phase -= delta;
+            }
+            offset -= count;
+
+            // Update delay buffer
+            memmove(buffer, &buffer[count], (_interpTapCount - 1) * sizeof(float));
+
+            return outCount;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+        loop::PhaseControlLoop<float, false> pcl;
+
+    protected:
+        void generateInterpTaps() {
+            double bw = 0.5 / (double)_interpPhaseCount;
+            dsp::tap<float> lp = dsp::taps::windowedSinc<float>(_interpPhaseCount * _interpTapCount, dsp::math::freqToOmega(bw, 1.0), dsp::window::nuttall, _interpPhaseCount);
+            interpBank = dsp::multirate::buildPolyphaseBank<float>(_interpPhaseCount, lp);
+            taps::free(lp);
+        }
+
+        dsp::multirate::PolyphaseBank<float> interpBank;
+
+        double _omega;
+        double _omegaGain;
+        double _muGain;
+        double _omegaRelLimit;
+        int _interpPhaseCount;
+        int _interpTapCount;
+
+        int offset = 0;
+        float* buffer;
+        float* bufStart;
+    };
+}

core/src/dsp/clock_recovery/mm.h

@@ -0,0 +1,199 @@
+#pragma once
+#include "../processor.h"
+#include "../loop/phase_control_loop.h"
+#include "../taps/windowed_sinc.h"
+#include "../multirate/polyphase_bank.h"
+#include "../math/step.h"
+
+namespace dsp::clock_recovery {
+    template<class T>
+    class MM : public Processor<T, T> {
+        using base_type = Processor<T, T> ;
+    public:
+        MM() {}
+
+        MM(stream<T>* in, double omega, double omegaGain, double muGain, double omegaRelLimit, int interpPhaseCount = 128, int interpTapCount = 8) { init(in, omega, omegaGain, muGain, omegaRelLimit, interpPhaseCount, interpTapCount); }
+
+        ~MM() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            dsp::multirate::freePolyphaseBank(interpBank);
+            buffer::free(buffer);
+        }
+
+        void init(stream<T>* in, double omega, double omegaGain, double muGain, double omegaRelLimit, int interpPhaseCount = 128, int interpTapCount = 8) {
+            _omega = omega;
+            _omegaGain = omegaGain;
+            _muGain = muGain;
+            _omegaRelLimit = omegaRelLimit;
+            _interpPhaseCount = interpPhaseCount;
+            _interpTapCount = interpTapCount;
+
+            pcl.init(_muGain, _omegaGain, 0.0, 0.0, 1.0, _omega, _omega * (1.0 - omegaRelLimit), _omega * (1.0 + omegaRelLimit));
+            generateInterpTaps();
+            buffer = buffer::alloc<T>(STREAM_BUFFER_SIZE + _interpTapCount);
+            bufStart = &buffer[_interpTapCount - 1];
+        
+            base_type::init(in);
+        }
+
+        void setOmega(double omega) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _omega = omega;
+            offset = 0;
+            pcl.phase = 0.0f;
+            pcl.freq = _omega;
+            pcl.setFreqLimits(_omega * (1.0 - _omegaRelLimit), _omega * (1.0 + _omegaRelLimit));
+            base_type::tempStart();
+        }
+
+        void setOmegaGain(double omegaGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _omegaGain = omegaGain;
+            pcl.setCoefficients(_muGain, _omegaGain);
+        }
+
+        void setMuGain(double muGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _muGain = muGain;
+            pcl.setCoefficients(_muGain, _omegaGain);
+        }
+
+        void setOmegaRelLimit(double omegaRelLimit) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _omegaRelLimit = omegaRelLimit;
+            pcl.setFreqLimits(_omega * (1.0 - _omegaRelLimit), _omega * (1.0 + _omegaRelLimit));
+        }
+
+        void setInterpParams(int interpPhaseCount, int interpTapCount) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _interpPhaseCount = interpPhaseCount;
+            _interpTapCount = interpTapCount;
+            dsp::multirate::freePolyphaseBank(interpBank);
+            buffer::free(buffer);
+            generateInterpTaps();
+            buffer = buffer::alloc<T>(STREAM_BUFFER_SIZE + _interpTapCount);
+            bufStart = &buffer[_interpTapCount - 1];
+            base_type::tempStart();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            offset = 0;
+            pcl.phase = 0.0f;
+            pcl.freq = _omega;
+            lastOut = 0.0f;
+            _p_0T = { 0.0f, 0.0f }; _p_1T = { 0.0f, 0.0f }; _p_2T = { 0.0f, 0.0f };
+            _c_0T = { 0.0f, 0.0f }; _c_1T = { 0.0f, 0.0f }; _c_2T = { 0.0f, 0.0f };
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const T* in, T* out) {
+            // Copy data to work buffer
+            memcpy(bufStart, in, count * sizeof(T));
+
+            // Process all samples
+            int outCount = 0;
+            while (offset < count) {
+                float error;
+                T outVal;
+
+                // Calculate new output value
+                int phase = std::clamp<int>(floorf(pcl.phase * (float)_interpPhaseCount), 0, _interpPhaseCount - 1);
+                if constexpr (std::is_same_v<T, float>) {
+                    volk_32f_x2_dot_prod_32f(&outVal, &buffer[offset], interpBank.phases[phase], _interpTapCount);
+                }
+                if constexpr (std::is_same_v<T, complex_t>) {
+                    volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&outVal, (lv_32fc_t*)&buffer[offset], interpBank.phases[phase], _interpTapCount);
+                }
+                out[outCount++] = outVal;
+
+                // Calculate symbol phase error
+                if constexpr (std::is_same_v<T, float>) {
+                    error = (math::step(lastOut) * outVal) - (lastOut * math::step(outVal));
+                    lastOut = outVal;
+                }
+                if constexpr (std::is_same_v<T, complex_t>) {
+                    // Propagate delay
+                    _p_2T = _p_1T;
+                    _p_1T = _p_0T;
+                    _c_2T = _c_1T;
+                    _c_1T = _c_0T;
+
+                    // Update the T0 values
+                    _p_0T = outVal;
+                    _c_0T = math::step(outVal);
+
+                    // Error
+                    error = (((_p_0T - _p_2T) * _c_1T.conj()) - ((_c_0T - _c_2T) * _p_1T.conj())).re;
+                }
+
+                // Clamp symbol phase error
+                if (error > 1.0f) { error = 1.0f; }
+                if (error < -1.0f) { error = -1.0f; }
+
+                // Advance symbol offset and phase
+                pcl.advance(error);
+                float delta = floorf(pcl.phase);
+                offset += delta;
+                pcl.phase -= delta;
+            }
+            offset -= count;
+
+            // Update delay buffer
+            memmove(buffer, &buffer[count], (_interpTapCount - 1) * sizeof(T));
+
+            return outCount;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        void generateInterpTaps() {
+            double bw = 0.5 / (double)_interpPhaseCount;
+            dsp::tap<float> lp = dsp::taps::windowedSinc<float>(_interpPhaseCount * _interpTapCount, dsp::math::freqToOmega(bw, 1.0), dsp::window::nuttall, _interpPhaseCount);
+            interpBank = dsp::multirate::buildPolyphaseBank<float>(_interpPhaseCount, lp);
+            taps::free(lp);
+        }
+
+        dsp::multirate::PolyphaseBank<float> interpBank;
+        loop::PhaseControlLoop<float, false> pcl;
+
+        double _omega;
+        double _omegaGain;
+        double _muGain;
+        double _omegaRelLimit;
+        int _interpPhaseCount;
+        int _interpTapCount;
+
+        // Previous output storage
+        float lastOut = 0.0f;
+        complex_t _p_0T = { 0.0f, 0.0f }, _p_1T = { 0.0f, 0.0f }, _p_2T = { 0.0f, 0.0f };
+        complex_t _c_0T = { 0.0f, 0.0f }, _c_1T = { 0.0f, 0.0f }, _c_2T = { 0.0f, 0.0f };
+
+        int offset = 0;
+        T* buffer;
+        T* bufStart;
+    };
+}

core/src/dsp/compression.h

@@ -1,160 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-
-namespace dsp {
-    enum PCMType {
-        PCM_TYPE_I8,
-        PCM_TYPE_I16,
-        PCM_TYPE_F32
-    };
-
-    class DynamicRangeCompressor : public generic_block<DynamicRangeCompressor> {
-    public:
-        DynamicRangeCompressor() {}
-
-        DynamicRangeCompressor(stream<complex_t>* in, PCMType pcmType) {
-            init(in, pcmType);
-        }
-
-        void init(stream<complex_t>* in, PCMType pcmType) {
-            _in = in;
-            _pcmType = pcmType;
-
-            out.setBufferSize((sizeof(dsp::complex_t) * STREAM_BUFFER_SIZE) + 8);
-
-            generic_block<DynamicRangeCompressor>::registerInput(_in);
-            generic_block<DynamicRangeCompressor>::registerOutput(&out);
-            generic_block<DynamicRangeCompressor>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<DynamicRangeCompressor>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<DynamicRangeCompressor>::ctrlMtx);
-            generic_block<DynamicRangeCompressor>::tempStop();
-            generic_block<DynamicRangeCompressor>::unregisterInput(_in);
-            _in = in;
-            generic_block<DynamicRangeCompressor>::registerInput(_in);
-            generic_block<DynamicRangeCompressor>::tempStart();
-        }
-
-        void setPCMType(PCMType pcmType) {
-            assert(generic_block<DynamicRangeCompressor>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<DynamicRangeCompressor>::ctrlMtx);
-            _pcmType = pcmType;
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-            PCMType type = _pcmType;
-
-            uint16_t* compressionType = (uint16_t*)out.writeBuf;
-            uint16_t* sampleType = (uint16_t*)&out.writeBuf[2];
-            float* scaler = (float*)&out.writeBuf[4];
-            void* dataBuf = &out.writeBuf[8];
-
-            // Write options and leave blank space for compression
-            *compressionType = 0;
-            *sampleType = type;
-
-            // If type is float32, no compression is needed
-            if (type == PCM_TYPE_F32) {
-                *scaler = 0;
-                memcpy(dataBuf, _in->readBuf, count * sizeof(complex_t));
-                _in->flush();
-                if (!out.swap(8 + (count * sizeof(complex_t)))) { return -1; }
-                return count;
-            }
-
-            // Find maximum value
-            uint32_t maxIdx;
-            volk_32f_index_max_32u(&maxIdx, (float*)_in->readBuf, count * 2);
-            float maxVal = ((float*)_in->readBuf)[maxIdx];
-            *scaler = maxVal;
-
-            // Convert to the right type and send it out (sign bit determines pcm type)
-            if (type == PCM_TYPE_I8) {
-                volk_32f_s32f_convert_8i((int8_t*)dataBuf, (float*)_in->readBuf, 128.0f / maxVal, count * 2);
-                _in->flush();
-                if (!out.swap(8 + (count * sizeof(int8_t) * 2))) { return -1; }
-            }
-            else if (type == PCM_TYPE_I16) {
-                volk_32f_s32f_convert_16i((int16_t*)dataBuf, (float*)_in->readBuf, 32768.0f / maxVal, count * 2);
-                _in->flush();
-                if (!out.swap(8 + (count * sizeof(int16_t) * 2))) { return -1; }
-            }
-            else {
-                _in->flush();
-            }
-
-            return count;
-        }
-
-        stream<uint8_t> out;
-
-    private:
-        stream<complex_t>* _in;
-        PCMType _pcmType;
-    };
-
-    class DynamicRangeDecompressor : public generic_block<DynamicRangeDecompressor> {
-    public:
-        DynamicRangeDecompressor() {}
-
-        DynamicRangeDecompressor(stream<uint8_t>* in) { init(in); }
-
-        void init(stream<uint8_t>* in) {
-            _in = in;
-            generic_block<DynamicRangeDecompressor>::registerInput(_in);
-            generic_block<DynamicRangeDecompressor>::registerOutput(&out);
-            generic_block<DynamicRangeDecompressor>::_block_init = true;
-        }
-
-        void setInput(stream<uint8_t>* in) {
-            assert(generic_block<DynamicRangeDecompressor>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<DynamicRangeDecompressor>::ctrlMtx);
-            generic_block<DynamicRangeDecompressor>::tempStop();
-            generic_block<DynamicRangeDecompressor>::unregisterInput(_in);
-            _in = in;
-            generic_block<DynamicRangeDecompressor>::registerInput(_in);
-            generic_block<DynamicRangeDecompressor>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            uint16_t sampleType = *(uint16_t*)&_in->readBuf[2];
-            float scaler = *(float*)&_in->readBuf[4];
-            void* dataBuf = &_in->readBuf[8];
-
-            if (sampleType == PCM_TYPE_F32) {
-                memcpy(out.writeBuf, dataBuf, count - 8);
-                _in->flush();
-                if (!out.swap((count - 8) / sizeof(complex_t))) { return -1; }
-            }
-            else if (sampleType == PCM_TYPE_I16) {
-                int outCount = (count - 8) / (sizeof(int16_t) * 2);
-                volk_16i_s32f_convert_32f((float*)out.writeBuf, (int16_t*)dataBuf, 32768.0f / scaler, outCount * 2);
-                _in->flush();
-                if (!out.swap(outCount)) { return -1; }
-            }
-            else if (sampleType == PCM_TYPE_I8) {
-                int outCount = (count - 8) / (sizeof(int8_t) * 2);
-                volk_8i_s32f_convert_32f((float*)out.writeBuf, (int8_t*)dataBuf, 128.0f / scaler, outCount * 2);
-                _in->flush();
-                if (!out.swap(outCount)) { return -1; }
-            }
-            else {
-                _in->flush();
-            }
-
-            return count;
-        }
-
-        stream<complex_t> out;
-
-    private:
-        stream<uint8_t>* _in;
-    };
-}

core/src/dsp/compression/pcm_type.h

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace dsp::compression {
+    enum PCMType {
+        PCM_TYPE_I8,
+        PCM_TYPE_I16,
+        PCM_TYPE_F32
+    };
+}

core/src/dsp/compression/sample_stream_compressor.h

@@ -0,0 +1,79 @@
+#pragma once
+#include "../processor.h"
+#include "pcm_type.h"
+
+namespace dsp::compression {
+    class SampleStreamCompressor : public Processor<complex_t, uint8_t> {
+        using base_type = Processor<complex_t, uint8_t>;
+    public:
+        SampleStreamCompressor() {}
+
+        SampleStreamCompressor(stream<complex_t>* in, PCMType pcmType) { init(in, pcmType); }
+
+        void init(stream<complex_t>* in, PCMType pcmType) {
+            _pcmType = pcmType;
+            base_type::init(in);
+        }
+
+        void setPCMType(PCMType pcmType) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _pcmType = pcmType;
+            base_type::tempStart();
+        }
+
+        inline static int process(int count, PCMType pcmType, const complex_t* in, uint8_t* out) {
+            uint16_t* compressionType = (uint16_t*)out;
+            uint16_t* sampleType = (uint16_t*)&out[2];
+            float* scaler = (float*)&out[4];
+            void* dataBuf = &out[8];
+
+            // Write options and leave blank space for compression
+            *compressionType = 0;
+            *sampleType = pcmType;
+
+            // If type is float32, no compression is needed
+            if (pcmType == PCMType::PCM_TYPE_F32) {
+                *scaler = 0;
+                memcpy(dataBuf, in, count * sizeof(complex_t));
+                return count;
+            }
+
+            // Find maximum value
+            uint32_t maxIdx;
+            volk_32f_index_max_32u(&maxIdx, (float*)in, count * 2);
+            float maxVal = ((float*)in)[maxIdx];
+            *scaler = maxVal;
+
+            // Convert to the right type and send it out (sign bit determines pcm type)
+            if (pcmType == PCMType::PCM_TYPE_I8) {
+                volk_32f_s32f_convert_8i((int8_t*)dataBuf, (float*)in, 128.0f / maxVal, count * 2);
+                return 8 + (count * sizeof(int8_t) * 2);
+            }
+            else if (pcmType == PCMType::PCM_TYPE_I16) {
+                volk_32f_s32f_convert_16i((int16_t*)dataBuf, (float*)in, 32768.0f / maxVal, count * 2);
+                return 8 + (count * sizeof(int16_t) * 2);
+            }
+
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, _pcmType, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        PCMType _pcmType;
+    };
+}

core/src/dsp/compression/sample_stream_decompressor.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "../processor.h"
+#include "pcm_type.h"
+
+namespace dsp::compression {
+    class SampleStreamDecompressor : public Processor<uint8_t, complex_t> {
+        using base_type = Processor<uint8_t, complex_t>;
+    public:
+        SampleStreamDecompressor() {}
+
+        SampleStreamDecompressor(stream<uint8_t>* in) { base_type::init(in); }
+
+        inline int process(int count, const uint8_t* in, complex_t* out) {
+            uint16_t sampleType = *(uint16_t*)&in[2];
+            float scaler = *(float*)&in[4];
+            const void* dataBuf = &in[8];
+
+            if (sampleType == PCMType::PCM_TYPE_F32) {
+                memcpy(out, dataBuf, count - 8);
+                return (count - 8) / sizeof(complex_t);
+            }
+            else if (sampleType == PCMType::PCM_TYPE_I16) {
+                int outCount = (count - 8) / (sizeof(int16_t) * 2);
+                volk_16i_s32f_convert_32f((float*)out, (int16_t*)dataBuf, 32768.0f / scaler, outCount * 2);
+                return outCount;
+            }
+            else if (sampleType == PCMType::PCM_TYPE_I8) {
+                int outCount = (count - 8) / (sizeof(int8_t) * 2);
+                volk_8i_s32f_convert_32f((float*)out, (int8_t*)dataBuf, 128.0f / scaler, outCount * 2);
+                return outCount;
+            }
+            
+            return 0;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+    };
+}

core/src/dsp/conversion.h

@@ -1,337 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-
-namespace dsp {
-    class ComplexToStereo : public generic_block<ComplexToStereo> {
-    public:
-        ComplexToStereo() {}
-
-        ComplexToStereo(stream<complex_t>* in) { init(in); }
-
-        static_assert(sizeof(complex_t) == sizeof(stereo_t));
-
-        void init(stream<complex_t>* in) {
-            _in = in;
-            generic_block<ComplexToStereo>::registerInput(_in);
-            generic_block<ComplexToStereo>::registerOutput(&out);
-            generic_block<ComplexToStereo>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<ComplexToStereo>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ComplexToStereo>::ctrlMtx);
-            generic_block<ComplexToStereo>::tempStop();
-            generic_block<ComplexToStereo>::unregisterInput(_in);
-            _in = in;
-            generic_block<ComplexToStereo>::registerInput(_in);
-            generic_block<ComplexToStereo>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<stereo_t> out;
-
-    private:
-        stream<complex_t>* _in;
-    };
-
-    class ComplexToReal : public generic_block<ComplexToReal> {
-    public:
-        ComplexToReal() {}
-
-        ComplexToReal(stream<complex_t>* in) { init(in); }
-
-        void init(stream<complex_t>* in) {
-            _in = in;
-            generic_block<ComplexToReal>::registerInput(_in);
-            generic_block<ComplexToReal>::registerOutput(&out);
-            generic_block<ComplexToReal>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<ComplexToReal>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ComplexToReal>::ctrlMtx);
-            generic_block<ComplexToReal>::tempStop();
-            generic_block<ComplexToReal>::unregisterInput(_in);
-            _in = in;
-            generic_block<ComplexToReal>::registerInput(_in);
-            generic_block<ComplexToReal>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32fc_deinterleave_real_32f(out.writeBuf, (lv_32fc_t*)_in->readBuf, count);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        stream<complex_t>* _in;
-    };
-
-    class ComplexToImag : public generic_block<ComplexToImag> {
-    public:
-        ComplexToImag() {}
-
-        ComplexToImag(stream<complex_t>* in) { init(in); }
-
-        void init(stream<complex_t>* in) {
-            _in = in;
-            generic_block<ComplexToImag>::registerInput(_in);
-            generic_block<ComplexToImag>::registerOutput(&out);
-            generic_block<ComplexToImag>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<ComplexToImag>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ComplexToImag>::ctrlMtx);
-            generic_block<ComplexToImag>::tempStop();
-            generic_block<ComplexToImag>::unregisterInput(_in);
-            _in = in;
-            generic_block<ComplexToImag>::registerInput(_in);
-            generic_block<ComplexToImag>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32fc_deinterleave_imag_32f(out.writeBuf, (lv_32fc_t*)_in->readBuf, count);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        stream<complex_t>* _in;
-    };
-
-
-    class RealToComplex : public generic_block<RealToComplex> {
-    public:
-        RealToComplex() {}
-
-        RealToComplex(stream<float>* in) { init(in); }
-
-        ~RealToComplex() {
-            if (!generic_block<RealToComplex>::_block_init) { return; }
-            generic_block<RealToComplex>::stop();
-            delete[] nullBuffer;
-            generic_block<RealToComplex>::_block_init = false;
-        }
-
-        void init(stream<float>* in) {
-            _in = in;
-            nullBuffer = new float[STREAM_BUFFER_SIZE];
-            memset(nullBuffer, 0, STREAM_BUFFER_SIZE * sizeof(float));
-            generic_block<RealToComplex>::registerInput(_in);
-            generic_block<RealToComplex>::registerOutput(&out);
-            generic_block<RealToComplex>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in) {
-            assert(generic_block<RealToComplex>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<RealToComplex>::ctrlMtx);
-            generic_block<RealToComplex>::tempStop();
-            generic_block<RealToComplex>::unregisterInput(_in);
-            _in = in;
-            generic_block<RealToComplex>::registerInput(_in);
-            generic_block<RealToComplex>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32f_x2_interleave_32fc((lv_32fc_t*)out.writeBuf, _in->readBuf, nullBuffer, count);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<complex_t> out;
-
-    private:
-        float* nullBuffer;
-        stream<float>* _in;
-    };
-
-    class Int16CToComplex : public generic_block<Int16CToComplex> {
-    public:
-        Int16CToComplex() {}
-
-        Int16CToComplex(stream<int16_t>* in) { init(in); }
-
-        void init(stream<int16_t>* in) {
-            _in = in;
-            generic_block<Int16CToComplex>::registerInput(_in);
-            generic_block<Int16CToComplex>::registerOutput(&out);
-            generic_block<Int16CToComplex>::_block_init = true;
-        }
-
-        void setInput(stream<int16_t>* in) {
-            assert(generic_block<Int16CToComplex>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<Int16CToComplex>::ctrlMtx);
-            generic_block<Int16CToComplex>::tempStop();
-            generic_block<Int16CToComplex>::unregisterInput(_in);
-            _in = in;
-            generic_block<Int16CToComplex>::registerInput(_in);
-            generic_block<Int16CToComplex>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_16i_s32f_convert_32f((float*)out.writeBuf, _in->readBuf, 32768.0f, count * 2);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<complex_t> out;
-
-    private:
-        stream<int16_t>* _in;
-    };
-
-    class ComplexToInt16C : public generic_block<ComplexToInt16C> {
-    public:
-        ComplexToInt16C() {}
-
-        ComplexToInt16C(stream<complex_t>* in) { init(in); }
-
-        void init(stream<complex_t>* in) {
-            _in = in;
-            generic_block<ComplexToInt16C>::registerInput(_in);
-            generic_block<ComplexToInt16C>::registerOutput(&out);
-            generic_block<ComplexToInt16C>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<ComplexToInt16C>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ComplexToInt16C>::ctrlMtx);
-            generic_block<ComplexToInt16C>::tempStop();
-            generic_block<ComplexToInt16C>::unregisterInput(_in);
-            _in = in;
-            generic_block<ComplexToInt16C>::registerInput(_in);
-            generic_block<ComplexToInt16C>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32f_s32f_convert_16i(out.writeBuf, (float*)_in->readBuf, 32768.0f, count * 2);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<int16_t> out;
-
-    private:
-        stream<complex_t>* _in;
-    };
-
-    class Int16ToFloat : public generic_block<Int16ToFloat> {
-    public:
-        Int16ToFloat() {}
-
-        Int16ToFloat(stream<int16_t>* in) { init(in); }
-
-        void init(stream<int16_t>* in) {
-            _in = in;
-            generic_block<Int16ToFloat>::registerInput(_in);
-            generic_block<Int16ToFloat>::registerOutput(&out);
-            generic_block<Int16ToFloat>::_block_init = true;
-        }
-
-        void setInput(stream<int16_t>* in) {
-            assert(generic_block<Int16ToFloat>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<Int16ToFloat>::ctrlMtx);
-            generic_block<Int16ToFloat>::tempStop();
-            generic_block<Int16ToFloat>::unregisterInput(_in);
-            _in = in;
-            generic_block<Int16ToFloat>::registerInput(_in);
-            generic_block<Int16ToFloat>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_16i_s32f_convert_32f(out.writeBuf, _in->readBuf, 32768.0f, count);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        stream<int16_t>* _in;
-    };
-
-    class FloatToInt16 : public generic_block<FloatToInt16> {
-    public:
-        FloatToInt16() {}
-
-        FloatToInt16(stream<float>* in) { init(in); }
-
-        void init(stream<float>* in) {
-            _in = in;
-            generic_block<FloatToInt16>::registerInput(_in);
-            generic_block<FloatToInt16>::registerOutput(&out);
-            generic_block<FloatToInt16>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in) {
-            assert(generic_block<FloatToInt16>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FloatToInt16>::ctrlMtx);
-            generic_block<FloatToInt16>::tempStop();
-            generic_block<FloatToInt16>::unregisterInput(_in);
-            _in = in;
-            generic_block<FloatToInt16>::registerInput(_in);
-            generic_block<FloatToInt16>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32f_s32f_convert_16i(out.writeBuf, _in->readBuf, 32768.0f, count);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<int16_t> out;
-
-    private:
-        stream<float>* _in;
-    };
-}

core/src/dsp/convert/complex_to_real.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::convert {
+    class ComplexToReal : public Processor<complex_t, float> {
+        using base_type = Processor<complex_t, float>;
+    public:
+        ComplexToReal() {}
+
+        ComplexToReal(stream<complex_t>* in) { init(in); }
+
+        void init(stream<complex_t>* in) { base_type::init(in); }
+
+        inline static int process(int count, const complex_t* in, float* out) {
+            volk_32fc_deinterleave_real_32f(out, (lv_32fc_t*)in, count);
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+    };
+}

core/src/dsp/convert/complex_to_stereo.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::convert {
+    class ComplexToStereo : public Processor<complex_t, stereo_t> {
+        using base_type = Processor<complex_t, stereo_t>;
+    public:
+        ComplexToStereo() {}
+
+        ComplexToStereo(stream<complex_t>* in) { init(in); }
+
+        void init(stream<complex_t>* in) { base_type::init(in); }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            memcpy(base_type::out.writeBuf, base_type::_in->readBuf, count * sizeof(complex_t));
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+    };
+}

core/src/dsp/convert/l_r_to_stereo.h

@@ -0,0 +1,44 @@
+#pragma once
+#include "../operator.h"
+
+namespace dsp::convert {
+    class LRToStereo : public Operator<float, float, stereo_t> {
+        using base_type = Operator<float, float, stereo_t>;
+    public:
+        LRToStereo() {}
+
+        LRToStereo(stream<float>* l, stream<float>* r) { init(l, r); }
+
+        void init(stream<float>* l, stream<float>* r) { base_type::init(l, r); }
+
+        void setInputs(stream<float>* l, stream<float>* r) { base_type::setInputs(l, r); }
+
+        void setInputL(stream<float>* l) { base_type::setInputA(l); }
+
+        void setInputR(stream<float>* r) { base_type::setInputB(r); }
+        
+        static inline int process(int count, const float* l, const float* r, stereo_t* out) {
+            volk_32f_x2_interleave_32fc((lv_32fc_t*)out, l, r, count);
+            return count;
+        }
+
+        int run() {
+            int a_count = base_type::_a->read();
+            if (a_count < 0) { return -1; }
+            int b_count = base_type::_b->read();
+            if (b_count < 0) { return -1; }
+            if (a_count != b_count) {
+                base_type::_a->flush();
+                base_type::_b->flush();
+                return 0;
+            }
+
+            process(a_count, base_type::_a->readBuf, base_type::_b->readBuf, base_type::out.writeBuf);
+
+            base_type::_a->flush();
+            base_type::_b->flush();
+            if (!base_type::out.swap(a_count)) { return -1; }
+            return a_count;
+        }
+    };
+}

core/src/dsp/convert/mono_to_stereo.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::convert {
+    class MonoToStereo : public Processor<float, stereo_t> {
+        using base_type = Processor<float, stereo_t>;
+    public:
+        MonoToStereo() {}
+
+        MonoToStereo(stream<float>* in) { base_type::init(in); }
+        
+        inline static int process(int count, const float* in, stereo_t* out) {
+            volk_32f_x2_interleave_32fc((lv_32fc_t*)out, in, in, count);
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+    };
+}

core/src/dsp/convert/real_to_complex.h

@@ -0,0 +1,44 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::convert {
+    class RealToComplex : public Processor<float, complex_t> {
+        using base_type = Processor<float, complex_t>;
+    public:
+        RealToComplex() {}
+
+        RealToComplex(stream<float>* in) { init(in); }
+
+        ~RealToComplex() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            buffer::free(nullBuf);
+        }
+
+        void init(stream<float>* in) {
+            nullBuf = buffer::alloc<float>(STREAM_BUFFER_SIZE);
+            buffer::clear(nullBuf, STREAM_BUFFER_SIZE);
+            base_type::init(in);
+        }
+
+        inline int process(int count, const float* in, complex_t* out) {
+            volk_32f_x2_interleave_32fc((lv_32fc_t*)out, in, nullBuf, count);
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    private:
+        float* nullBuf;
+
+    };
+}

core/src/dsp/convert/stereo_to_mono.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::convert {
+    class StereoToMono : public Processor<stereo_t, float> {
+        using base_type = Processor<stereo_t, float>;
+    public:
+        StereoToMono() {}
+
+        StereoToMono(stream<stereo_t>* in) { base_type::init(in); }
+        
+        inline int process(int count, const stereo_t* in, float* out) {
+            for (int i = 0; i < count; i++) {
+                out[i] = (in[i].l + in[i].r) / 2.0f;
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+    };
+}

core/src/dsp/correction.h

@@ -1,142 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <dsp/stream.h>
-#include <dsp/types.h>
-#include <dsp/window.h>
-
-namespace dsp {
-    class IQCorrector : public generic_block<IQCorrector> {
-    public:
-        IQCorrector() {}
-
-        IQCorrector(stream<complex_t>* in, float rate) { init(in, rate); }
-
-        void init(stream<complex_t>* in, float rate) {
-            _in = in;
-            correctionRate = rate;
-            offset.re = 0;
-            offset.im = 0;
-            generic_block<IQCorrector>::registerInput(_in);
-            generic_block<IQCorrector>::registerOutput(&out);
-            generic_block<IQCorrector>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<IQCorrector>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<IQCorrector>::ctrlMtx);
-            generic_block<IQCorrector>::tempStop();
-            generic_block<IQCorrector>::unregisterInput(_in);
-            _in = in;
-            generic_block<IQCorrector>::registerInput(_in);
-            generic_block<IQCorrector>::tempStart();
-        }
-
-        void setCorrectionRate(float rate) {
-            correctionRate = rate;
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            if (bypass) {
-                memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
-
-                _in->flush();
-
-                if (!out.swap(count)) { return -1; }
-
-                return count;
-            }
-
-            for (int i = 0; i < count; i++) {
-                out.writeBuf[i] = _in->readBuf[i] - offset;
-                offset = offset + (out.writeBuf[i] * correctionRate);
-            }
-
-            _in->flush();
-
-            if (!out.swap(count)) { return -1; }
-
-            return count;
-        }
-
-        stream<complex_t> out;
-
-        // TEMPORARY FOR DEBUG PURPOSES
-        bool bypass = false;
-        complex_t offset;
-
-    private:
-        stream<complex_t>* _in;
-        float correctionRate = 0.00001;
-    };
-
-    class DCBlocker : public generic_block<DCBlocker> {
-    public:
-        DCBlocker() {}
-
-        DCBlocker(stream<float>* in, float rate) { init(in, rate); }
-
-        void init(stream<float>* in, float rate) {
-            _in = in;
-            correctionRate = rate;
-            offset = 0;
-            generic_block<DCBlocker>::registerInput(_in);
-            generic_block<DCBlocker>::registerOutput(&out);
-            generic_block<DCBlocker>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in) {
-            assert(generic_block<DCBlocker>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<DCBlocker>::ctrlMtx);
-            generic_block<DCBlocker>::tempStop();
-            generic_block<DCBlocker>::unregisterInput(_in);
-            _in = in;
-            generic_block<DCBlocker>::registerInput(_in);
-            generic_block<DCBlocker>::tempStart();
-        }
-
-        void setCorrectionRate(float rate) {
-            correctionRate = rate;
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            if (bypass) {
-                memcpy(out.writeBuf, _in->readBuf, count * sizeof(complex_t));
-
-                _in->flush();
-
-                if (!out.swap(count)) { return -1; }
-
-                return count;
-            }
-
-            for (int i = 0; i < count; i++) {
-                out.writeBuf[i] = _in->readBuf[i] - offset;
-                offset = offset + (out.writeBuf[i] * correctionRate);
-            }
-
-            _in->flush();
-
-            if (!out.swap(count)) { return -1; }
-
-            return count;
-        }
-
-        stream<float> out;
-
-        // TEMPORARY FOR DEBUG PURPOSES
-        bool bypass = false;
-        float offset;
-
-    private:
-        stream<float>* _in;
-        float correctionRate = 0.00001;
-    };
-
-
-}

core/src/dsp/correction/dc_blocker.h

@@ -0,0 +1,77 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::correction {
+    template<class T>
+    class DCBlocker : public Processor<T, T> {
+        using base_type = Processor<T, T>;
+    public:
+        DCBlocker() {}
+
+        DCBlocker(stream<T>* in, double rate) { init(in, rate); }
+
+        DCBlocker(stream<T>* in, double rate, double samplerate) { init(in, rate, samplerate); }
+
+        void init(stream<T>* in, double rate) {
+            _rate = rate;
+            if constexpr (std::is_same_v<T, float>) {
+                offset = 0.0f;
+            }
+            if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
+                offset = { 0.0f, 0.0f };
+            }
+            base_type::init(in);
+        }
+
+        void init(stream<T>* in, double rate, double samplerate) {
+            init(in, rate / samplerate);
+        }
+
+        void setRate(double rate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _rate = rate;
+        }
+
+        void setRate(double rate, double samplerate)  {
+            setRate(rate / samplerate);
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            if constexpr (std::is_same_v<T, float>) {
+                offset = 0.0f;
+            }
+            if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
+                offset = { 0.0f, 0.0f };
+            }
+            base_type::tempStart();
+        }
+
+        // TODO: Add back the const
+        int process(int count, T* in, T* out) {
+            for (int i = 0; i < count; i++) {
+                out[i] = in[i] - offset;
+                offset += out[i] * _rate;
+            }
+            return count;
+        }
+
+        virtual int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        float _rate;
+        T offset;
+    };
+}

core/src/dsp/decimation.h

@@ -1,106 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <dsp/stream.h>
-#include <dsp/types.h>
-#include <dsp/window.h>
-
-namespace dsp {
-    template <class T>
-    class HalfDecimator : public generic_block<HalfDecimator<T>> {
-    public:
-        HalfDecimator() {}
-
-        HalfDecimator(stream<T>* in, dsp::filter_window::generic_window* window) { init(in, window); }
-
-        ~HalfDecimator() {
-            if (!generic_block<HalfDecimator<T>>::_block_init) { return; }
-            generic_block<HalfDecimator<T>>::stop();
-            volk_free(buffer);
-            volk_free(taps);
-            generic_block<HalfDecimator<T>>::_block_init = false;
-        }
-
-        void init(stream<T>* in, dsp::filter_window::generic_window* window) {
-            _in = in;
-
-            tapCount = window->getTapCount();
-            taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
-            window->createTaps(taps, tapCount);
-
-            buffer = (T*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(T) * 2, volk_get_alignment());
-            bufStart = &buffer[tapCount];
-            generic_block<HalfDecimator<T>>::registerInput(_in);
-            generic_block<HalfDecimator<T>>::registerOutput(&out);
-            generic_block<HalfDecimator<T>>::_block_init = true;
-        }
-
-        void setInput(stream<T>* in) {
-            assert(generic_block<HalfDecimator<T>>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<HalfDecimator<T>>::ctrlMtx);
-            generic_block<HalfDecimator<T>>::tempStop();
-            generic_block<HalfDecimator<T>>::unregisterInput(_in);
-            _in = in;
-            generic_block<HalfDecimator<T>>::registerInput(_in);
-            generic_block<HalfDecimator<T>>::tempStart();
-        }
-
-        void updateWindow(dsp::filter_window::generic_window* window) {
-            assert(generic_block<HalfDecimator<T>>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<HalfDecimator<T>>::ctrlMtx);
-            std::lock_guard<std::mutex> lck2(bufMtx);
-            _window = window;
-            volk_free(taps);
-            tapCount = window->getTapCount();
-            taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
-            bufStart = &buffer[tapCount];
-            window->createTaps(taps, tapCount);
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            memcpy(bufStart, _in->readBuf, count * sizeof(T));
-            _in->flush();
-
-            int inIndex = _inIndex;
-            int outIndex = 0;
-            if constexpr (std::is_same_v<T, float>) {
-                while (inIndex < count) {
-                    volk_32f_x2_dot_prod_32f((float*)&out.writeBuf[outIndex], (float*)&buffer[inIndex + 1], taps, tapCount);
-                    inIndex += 2;
-                    outIndex++;
-                }
-            }
-            if constexpr (std::is_same_v<T, complex_t>) {
-                while (inIndex < count) {
-                    volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&out.writeBuf[outIndex], (lv_32fc_t*)&buffer[inIndex + 1], taps, tapCount);
-                    inIndex += 2;
-                    outIndex++;
-                }
-            }
-            _inIndex = inIndex - count;
-
-            if (!out.swap(outIndex)) { return -1; }
-
-            memmove(buffer, &buffer[count], tapCount * sizeof(T));
-
-
-            return count;
-        }
-
-        stream<T> out;
-
-    private:
-        stream<T>* _in;
-
-        dsp::filter_window::generic_window* _window;
-        std::mutex bufMtx;
-
-        T* bufStart;
-        T* buffer;
-        int tapCount;
-        float* taps;
-        int _inIndex = 0;
-    };
-}

core/src/dsp/deframing.h

@@ -1,414 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <inttypes.h>
-
-#define DSP_SIGN(n) ((n) >= 0)
-#define DSP_STEP(n) (((n) > 0.0f) ? 1.0f : -1.0f)
-
-namespace dsp {
-    class Deframer : public generic_block<Deframer> {
-    public:
-        Deframer() {}
-
-        Deframer(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) { init(in, frameLen, syncWord, syncLen); }
-
-        ~Deframer() {
-            if (!generic_block<Deframer>::_block_init) { return; }
-            generic_block<Deframer>::stop();
-            generic_block<Deframer>::_block_init = false;
-        }
-
-        void init(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) {
-            _in = in;
-            _frameLen = frameLen;
-            _syncword = new uint8_t[syncLen];
-            _syncLen = syncLen;
-            memcpy(_syncword, syncWord, syncLen);
-
-            buffer = new uint8_t[STREAM_BUFFER_SIZE + syncLen];
-            memset(buffer, 0, syncLen);
-            bufferStart = buffer + syncLen;
-
-            generic_block<Deframer>::registerInput(_in);
-            generic_block<Deframer>::registerOutput(&out);
-            generic_block<Deframer>::_block_init = true;
-        }
-
-        void setInput(stream<uint8_t>* in) {
-            assert(generic_block<Deframer>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<Deframer>::ctrlMtx);
-            generic_block<Deframer>::tempStop();
-            generic_block<Deframer>::unregisterInput(_in);
-            _in = in;
-            generic_block<Deframer>::registerInput(_in);
-            generic_block<Deframer>::tempStart();
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            // Copy data into work buffer
-            memcpy(bufferStart, _in->readBuf, count - 1);
-
-            // Iterate through all symbols
-            for (int i = 0; i < count;) {
-
-                // If already in the process of reading bits
-                if (bitsRead >= 0) {
-                    if ((bitsRead % 8) == 0) { out.writeBuf[bitsRead / 8] = 0; }
-                    out.writeBuf[bitsRead / 8] |= (buffer[i] << (7 - (bitsRead % 8)));
-                    i++;
-                    bitsRead++;
-
-                    if (bitsRead >= _frameLen) {
-                        if (!out.swap((bitsRead / 8) + ((bitsRead % 8) > 0))) { return -1; }
-                        bitsRead = -1;
-                        if (allowSequential) { nextBitIsStartOfFrame = true; }
-                    }
-
-                    continue;
-                }
-
-                // Else, check for a header
-                else if (memcmp(buffer + i, _syncword, _syncLen) == 0) {
-                    bitsRead = 0;
-                    //printf("Frame found!\n");
-                    badFrameCount = 0;
-                    continue;
-                }
-                else if (nextBitIsStartOfFrame) {
-                    nextBitIsStartOfFrame = false;
-
-                    // try to save
-                    if (badFrameCount < 5) {
-                        badFrameCount++;
-                        //printf("Frame found!\n");
-                        bitsRead = 0;
-                        continue;
-                    }
-                }
-
-                else {
-                    i++;
-                }
-
-                nextBitIsStartOfFrame = false;
-            }
-
-            // Keep last _syncLen4 symbols
-            memcpy(buffer, &_in->readBuf[count - _syncLen], _syncLen);
-
-            //printf("Block processed\n");
-            callcount++;
-
-            _in->flush();
-            return count;
-        }
-
-        bool allowSequential = true;
-
-        stream<uint8_t> out;
-
-    private:
-        uint8_t* buffer;
-        uint8_t* bufferStart;
-        uint8_t* _syncword;
-        int count;
-        int _frameLen;
-        int _syncLen;
-        int bitsRead = -1;
-
-        int badFrameCount = 5;
-        bool nextBitIsStartOfFrame = false;
-
-        int callcount = 0;
-
-        stream<uint8_t>* _in;
-    };
-
-    inline int MachesterHammingDistance(float* data, uint8_t* syncBits, int n) {
-        int dist = 0;
-        for (int i = 0; i < n; i++) {
-            if ((data[(2 * i) + 1] > data[2 * i]) != syncBits[i]) { dist++; }
-        }
-        return dist;
-    }
-
-    inline int HammingDistance(uint8_t* data, uint8_t* syncBits, int n) {
-        int dist = 0;
-        for (int i = 0; i < n; i++) {
-            if (data[i] != syncBits[i]) { dist++; }
-        }
-        return dist;
-    }
-
-    class ManchesterDeframer : public generic_block<ManchesterDeframer> {
-    public:
-        ManchesterDeframer() {}
-
-        ManchesterDeframer(stream<float>* in, int frameLen, uint8_t* syncWord, int syncLen) { init(in, frameLen, syncWord, syncLen); }
-
-        void init(stream<float>* in, int frameLen, uint8_t* syncWord, int syncLen) {
-            _in = in;
-            _frameLen = frameLen;
-            _syncword = new uint8_t[syncLen];
-            _syncLen = syncLen;
-            memcpy(_syncword, syncWord, syncLen);
-
-            buffer = new float[STREAM_BUFFER_SIZE + (syncLen * 2)];
-            memset(buffer, 0, syncLen * 2 * sizeof(float));
-            bufferStart = &buffer[syncLen * 2];
-
-            generic_block<ManchesterDeframer>::registerInput(_in);
-            generic_block<ManchesterDeframer>::registerOutput(&out);
-            generic_block<ManchesterDeframer>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in) {
-            assert(generic_block<ManchesterDeframer>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ManchesterDeframer>::ctrlMtx);
-            generic_block<ManchesterDeframer>::tempStop();
-            generic_block<ManchesterDeframer>::unregisterInput(_in);
-            _in = in;
-            generic_block<ManchesterDeframer>::registerInput(_in);
-            generic_block<ManchesterDeframer>::tempStart();
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            int readable;
-
-            // Copy data into work buffer
-            memcpy(bufferStart, _in->readBuf, (count - 1) * sizeof(float));
-
-            // Iterate through all symbols
-            for (int i = 0; i < count;) {
-
-                // If already in the process of reading bits
-                if (bitsRead >= 0) {
-                    readable = std::min<int>(count - i, _frameLen - bitsRead);
-                    memcpy(&out.writeBuf[bitsRead], &buffer[i], readable * sizeof(float));
-                    bitsRead += readable;
-                    i += readable;
-                    if (bitsRead >= _frameLen) {
-                        out.swap(_frameLen);
-                        bitsRead = -1;
-                    }
-                    continue;
-                }
-
-                // Else, check for a header
-                if (MachesterHammingDistance(&buffer[i], _syncword, _syncLen) <= 2) {
-                    bitsRead = 0;
-                    continue;
-                }
-
-                i++;
-            }
-
-            // Keep last _syncLen symbols
-            memcpy(buffer, &_in->readBuf[count - (_syncLen * 2)], _syncLen * 2 * sizeof(float));
-
-            _in->flush();
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        float* buffer;
-        float* bufferStart;
-        uint8_t* _syncword;
-        int count;
-        int _frameLen;
-        int _syncLen;
-        int bitsRead = -1;
-
-        stream<float>* _in;
-    };
-
-    class SymbolDeframer : public generic_block<SymbolDeframer> {
-    public:
-        SymbolDeframer() {}
-
-        SymbolDeframer(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) { init(in, frameLen, syncWord, syncLen); }
-
-        void init(stream<uint8_t>* in, int frameLen, uint8_t* syncWord, int syncLen) {
-            _in = in;
-            _frameLen = frameLen;
-            _syncword = new uint8_t[syncLen];
-            _syncLen = syncLen;
-            memcpy(_syncword, syncWord, syncLen);
-
-            buffer = new uint8_t[STREAM_BUFFER_SIZE + syncLen];
-            memset(buffer, 0, syncLen);
-            bufferStart = &buffer[syncLen];
-
-            generic_block<SymbolDeframer>::registerInput(_in);
-            generic_block<SymbolDeframer>::registerOutput(&out);
-            generic_block<SymbolDeframer>::_block_init = true;
-        }
-
-        void setInput(stream<uint8_t>* in) {
-            assert(generic_block<SymbolDeframer>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<SymbolDeframer>::ctrlMtx);
-            generic_block<SymbolDeframer>::tempStop();
-            generic_block<SymbolDeframer>::unregisterInput(_in);
-            _in = in;
-            generic_block<SymbolDeframer>::registerInput(_in);
-            generic_block<SymbolDeframer>::tempStart();
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            int readable;
-
-            // Copy data into work buffer
-            memcpy(bufferStart, _in->readBuf, count - 1);
-
-            // Iterate through all symbols
-            for (int i = 0; i < count;) {
-
-                // If already in the process of reading bits
-                if (bitsRead >= 0) {
-                    readable = std::min<int>(count - i, _frameLen - bitsRead);
-                    memcpy(&out.writeBuf[bitsRead], &buffer[i], readable);
-                    bitsRead += readable;
-                    i += readable;
-                    if (bitsRead >= _frameLen) {
-                        out.swap(_frameLen);
-                        bitsRead = -1;
-                    }
-                    continue;
-                }
-
-                // Else, check for a header
-                if (HammingDistance(&buffer[i], _syncword, _syncLen) <= 2) {
-                    bitsRead = 0;
-                    continue;
-                }
-
-                i++;
-            }
-
-            // Keep last _syncLen symbols
-            memcpy(buffer, &_in->readBuf[count - _syncLen], _syncLen);
-
-            _in->flush();
-            return count;
-        }
-
-        stream<uint8_t> out;
-
-    private:
-        uint8_t* buffer;
-        uint8_t* bufferStart;
-        uint8_t* _syncword;
-        int count;
-        int _frameLen;
-        int _syncLen;
-        int bitsRead = -1;
-
-        stream<uint8_t>* _in;
-    };
-
-    class ManchesterDecoder : public generic_block<ManchesterDecoder> {
-    public:
-        ManchesterDecoder() {}
-
-        ManchesterDecoder(stream<float>* in, bool inverted) { init(in, inverted); }
-
-        void init(stream<float>* in, bool inverted) {
-            _in = in;
-            _inverted = inverted;
-            generic_block<ManchesterDecoder>::registerInput(_in);
-            generic_block<ManchesterDecoder>::registerOutput(&out);
-            generic_block<ManchesterDecoder>::_block_init = true;
-        }
-
-        void setInput(stream<float>* in) {
-            assert(generic_block<ManchesterDecoder>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ManchesterDecoder>::ctrlMtx);
-            generic_block<ManchesterDecoder>::tempStop();
-            generic_block<ManchesterDecoder>::unregisterInput(_in);
-            _in = in;
-            generic_block<ManchesterDecoder>::registerInput(_in);
-            generic_block<ManchesterDecoder>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            if (_inverted) {
-                for (int i = 0; i < count; i += 2) {
-                    out.writeBuf[i / 2] = (_in->readBuf[i + 1] < _in->readBuf[i]);
-                }
-            }
-            else {
-                for (int i = 0; i < count; i += 2) {
-                    out.writeBuf[i / 2] = (_in->readBuf[i + 1] > _in->readBuf[i]);
-                }
-            }
-
-            _in->flush();
-            out.swap(count / 2);
-            return count;
-        }
-
-        stream<uint8_t> out;
-
-    private:
-        stream<float>* _in;
-        bool _inverted;
-    };
-
-    class BitPacker : public generic_block<BitPacker> {
-    public:
-        BitPacker() {}
-
-        BitPacker(stream<uint8_t>* in) { init(in); }
-
-        void init(stream<uint8_t>* in) {
-            _in = in;
-
-            generic_block<BitPacker>::registerInput(_in);
-            generic_block<BitPacker>::registerOutput(&out);
-            generic_block<BitPacker>::_block_init = true;
-        }
-
-        void setInput(stream<uint8_t>* in) {
-            assert(generic_block<BitPacker>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<BitPacker>::ctrlMtx);
-            generic_block<BitPacker>::tempStop();
-            generic_block<BitPacker>::unregisterInput(_in);
-            _in = in;
-            generic_block<BitPacker>::registerInput(_in);
-            generic_block<BitPacker>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            for (int i = 0; i < count; i++) {
-                if ((i % 8) == 0) { out.writeBuf[i / 8] = 0; }
-                out.writeBuf[i / 8] |= (_in->readBuf[i] & 1) << (7 - (i % 8));
-            }
-
-            _in->flush();
-            out.swap((count / 8) + (((count % 8) == 0) ? 0 : 1));
-            return count;
-        }
-
-        stream<uint8_t> out;
-
-    private:
-        stream<uint8_t>* _in;
-    };
-}

core/src/dsp/demod/am.h

@@ -0,0 +1,160 @@
+#pragma once
+#include "../processor.h"
+#include "../loop/agc.h"
+#include "../correction/dc_blocker.h"
+#include "../convert/mono_to_stereo.h"
+#include "../filter/fir.h"
+#include "../taps/low_pass.h"
+
+namespace dsp::demod {
+    template <class T>
+    class AM : public Processor<dsp::complex_t, T> {
+        using base_type = Processor<dsp::complex_t, T>;
+    public:
+        enum AGCMode {
+            CARRIER,
+            AUDIO,
+        };
+
+        AM() {}
+
+        AM(stream<complex_t>* in, AGCMode agcMode, double bandwidth, double agcAttack, double agcDecay, double dcBlockRate, double samplerate) { init(in, agcMode, bandwidth, agcAttack, agcDecay, dcBlockRate, samplerate); }
+
+        ~AM() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            taps::free(lpfTaps);
+        }
+
+        void init(stream<complex_t>* in, AGCMode agcMode, double bandwidth, double agcAttack, double agcDecay, double dcBlockRate, double samplerate) {
+            _agcMode = agcMode;
+            _bandwidth = bandwidth;
+            _samplerate = samplerate;
+
+            carrierAgc.init(NULL, 1.0, agcAttack, agcDecay, 10e6, 10.0, INFINITY);
+            audioAgc.init(NULL, 1.0, agcAttack, agcDecay, 10e6, 10.0, INFINITY);
+            dcBlock.init(NULL, dcBlockRate);
+            lpfTaps = taps::lowPass(bandwidth / 2.0, (bandwidth / 2.0) * 0.1, samplerate);
+            lpf.init(NULL, lpfTaps);
+
+            if constexpr (std::is_same_v<T, float>) {
+                audioAgc.out.free();
+            }
+            dcBlock.out.free();
+            lpf.out.free();
+            
+            base_type::init(in);
+        }
+
+        void setAGCMode(AGCMode agcMode) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _agcMode = agcMode;
+            reset();
+            base_type::tempStart();
+        }
+
+        void setBandwidth(double bandwidth) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            if (bandwidth == _bandwidth) { return; }
+            _bandwidth = bandwidth;
+            std::lock_guard<std::mutex> lck2(lpfMtx);
+            taps::free(lpfTaps);
+            lpfTaps = taps::lowPass(_bandwidth / 2.0, (_bandwidth / 2.0) * 0.1, _samplerate);
+            lpf.setTaps(lpfTaps);
+        }
+
+        void setAGCAttack(double attack) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            carrierAgc.setAttack(attack);
+            audioAgc.setAttack(attack);
+        }
+
+        void setAGCDecay(double decay) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            carrierAgc.setDecay(decay);
+            audioAgc.setDecay(decay);
+        }
+
+        void setDCBlockRate(double rate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            dcBlock.setRate(rate);
+        }
+
+        // TODO: Implement setSamplerate
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            carrierAgc.reset();
+            audioAgc.reset();
+            dcBlock.reset();
+            base_type::tempStart();
+        }
+
+        int process(int count, complex_t* in, T* out) {
+            // Apply carrier AGC if needed
+            if (_agcMode == AGCMode::CARRIER) {
+                carrierAgc.process(count, in, carrierAgc.out.writeBuf);
+                in = carrierAgc.out.writeBuf;
+            }
+
+            if constexpr (std::is_same_v<T, float>) {
+                volk_32fc_magnitude_32f(out, (lv_32fc_t*)in, count);
+                dcBlock.process(count, out, out);
+                if (_agcMode == AGCMode::AUDIO) {
+                    audioAgc.process(count, out, out);
+                }
+                {
+                    std::lock_guard<std::mutex> lck(lpfMtx);
+                    lpf.process(count, out, out);
+                }
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                volk_32fc_magnitude_32f(audioAgc.out.writeBuf, (lv_32fc_t*)in, count);
+                dcBlock.process(count, audioAgc.out.writeBuf, audioAgc.out.writeBuf);
+                if (_agcMode == AGCMode::AUDIO) {
+                    audioAgc.process(count, audioAgc.out.writeBuf, audioAgc.out.writeBuf);
+                }
+                {
+                    std::lock_guard<std::mutex> lck(lpfMtx);
+                    lpf.process(count, audioAgc.out.writeBuf, audioAgc.out.writeBuf);
+                }
+                convert::MonoToStereo::process(count, audioAgc.out.writeBuf, out);
+            }
+
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        AGCMode _agcMode;
+
+        double _samplerate;
+        double _bandwidth;
+
+        loop::AGC<complex_t> carrierAgc;
+        loop::AGC<float> audioAgc;
+        correction::DCBlocker<float> dcBlock;
+        tap<float> lpfTaps;
+        filter::FIR<float, float> lpf;
+        std::mutex lpfMtx;
+
+    };
+}

core/src/dsp/demod/broadcast_fm.h

@@ -0,0 +1,269 @@
+#pragma once
+#include "quadrature.h"
+#include "../taps/low_pass.h"
+#include "../taps/band_pass.h"
+#include "../filter/fir.h"
+#include "../loop/pll.h"
+#include "../convert/l_r_to_stereo.h"
+#include "../convert/real_to_complex.h"
+#include "../convert/complex_to_real.h"
+#include "../math/conjugate.h"
+#include "../math/delay.h"
+#include "../math/multiply.h"
+#include "../math/add.h"
+#include "../math/subtract.h"
+#include "../multirate/rational_resampler.h"
+
+namespace dsp::demod {
+    class BroadcastFM : public Processor<complex_t, stereo_t> {
+        using base_type = Processor<complex_t, stereo_t>;
+    public:
+        BroadcastFM() {}
+
+        BroadcastFM(stream<complex_t>* in, double deviation, double samplerate, bool stereo = true, bool lowPass = true, bool rdsOut = false) { init(in, deviation, samplerate, stereo, lowPass); }
+
+        ~BroadcastFM() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            buffer::free(lmr);
+            buffer::free(l);
+            buffer::free(r);
+            taps::free(pilotFirTaps);
+            taps::free(audioFirTaps);
+        }
+
+        virtual void init(stream<complex_t>* in, double deviation, double samplerate, bool stereo = true, bool lowPass = true, bool rdsOut = false) {
+            _deviation = deviation;
+            _samplerate = samplerate;
+            _stereo = stereo;
+            _lowPass = lowPass;
+            _rdsOut = rdsOut;
+            
+            demod.init(NULL, _deviation, _samplerate);
+            pilotFirTaps = taps::bandPass<complex_t>(18750.0, 19250.0, 3000.0, _samplerate, true);
+            pilotFir.init(NULL, pilotFirTaps);
+            rtoc.init(NULL);
+            pilotPLL.init(NULL, 25000.0 / _samplerate, 0.0, math::freqToOmega(19000.0, _samplerate), math::freqToOmega(18750.0, _samplerate), math::freqToOmega(19250.0, _samplerate));
+            lprDelay.init(NULL, ((pilotFirTaps.size - 1) / 2) + 1);
+            lmrDelay.init(NULL, ((pilotFirTaps.size - 1) / 2) + 1);
+            audioFirTaps = taps::lowPass(15000.0, 4000.0, _samplerate);
+            alFir.init(NULL, audioFirTaps);
+            arFir.init(NULL, audioFirTaps);
+            rdsResamp.init(NULL, samplerate, 5000.0);
+
+            lmr = buffer::alloc<float>(STREAM_BUFFER_SIZE);
+            l = buffer::alloc<float>(STREAM_BUFFER_SIZE);
+            r = buffer::alloc<float>(STREAM_BUFFER_SIZE);
+
+            lprDelay.out.free();
+            lmrDelay.out.free();
+            arFir.out.free();
+            alFir.out.free();
+            rdsResamp.out.free();
+
+            base_type::init(in);
+        }
+
+        void setDeviation(double deviation) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _deviation = deviation;
+            demod.setDeviation(_deviation, _samplerate);
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _samplerate = samplerate;
+
+            demod.setDeviation(_deviation, _samplerate);
+            taps::free(pilotFirTaps);
+            pilotFirTaps = taps::bandPass<complex_t>(18750.0, 19250.0, 3000.0, samplerate, true);
+            pilotFir.setTaps(pilotFirTaps);
+            
+            pilotPLL.setFrequencyLimits(math::freqToOmega(18750.0, _samplerate), math::freqToOmega(19250.0, _samplerate));
+            pilotPLL.setInitialFreq(math::freqToOmega(19000.0, _samplerate));
+            lprDelay.setDelay(((pilotFirTaps.size - 1) / 2) + 1);
+            lmrDelay.setDelay(((pilotFirTaps.size - 1) / 2) + 1);
+
+            taps::free(audioFirTaps);
+            audioFirTaps = taps::lowPass(15000.0, 4000.0, _samplerate);
+            alFir.setTaps(audioFirTaps);
+            arFir.setTaps(audioFirTaps);
+
+            rdsResamp.setInSamplerate(samplerate);
+
+            reset();
+            base_type::tempStart();
+        }
+
+        void setStereo(bool stereo) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _stereo = stereo;
+            reset();
+            base_type::tempStart();
+        }
+
+        void setLowPass(bool lowPass) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _lowPass = lowPass;
+            reset();
+            base_type::tempStart();
+        }
+
+        void setRDSOut(bool rdsOut) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _rdsOut = rdsOut;
+            reset();
+            base_type::tempStart();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            demod.reset();
+            pilotFir.reset();
+            pilotPLL.reset();
+            lprDelay.reset();
+            lmrDelay.reset();
+            alFir.reset();
+            arFir.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, complex_t* in, stereo_t* out, int& rdsOutCount, float* rdsout = NULL) {
+            // Demodulate
+            demod.process(count, in, demod.out.writeBuf);
+            if (_stereo) {
+                // Convert to complex
+                rtoc.process(count, demod.out.writeBuf, rtoc.out.writeBuf);
+
+                // Filter out pilot and run through PLL
+                pilotFir.process(count, rtoc.out.writeBuf, pilotFir.out.writeBuf);
+                pilotPLL.process(count, pilotFir.out.writeBuf, pilotPLL.out.writeBuf);
+
+                // Delay
+                lprDelay.process(count, demod.out.writeBuf, demod.out.writeBuf);
+                lmrDelay.process(count, rtoc.out.writeBuf, rtoc.out.writeBuf);
+                
+                // conjugate PLL output to down convert twice the L-R signal
+                math::Conjugate::process(count, pilotPLL.out.writeBuf, pilotPLL.out.writeBuf);
+                math::Multiply<dsp::complex_t>::process(count, rtoc.out.writeBuf, pilotPLL.out.writeBuf, rtoc.out.writeBuf);
+                math::Multiply<dsp::complex_t>::process(count, rtoc.out.writeBuf, pilotPLL.out.writeBuf, rtoc.out.writeBuf);
+
+                // Do RDS demod
+                if (_rdsOut) {
+                    // Since the PLL output is no longer needed after this, use it as the output
+                    math::Multiply<dsp::complex_t>::process(count, rtoc.out.writeBuf, pilotPLL.out.writeBuf, pilotPLL.out.writeBuf);
+                    convert::ComplexToReal::process(count, pilotPLL.out.writeBuf, rdsout);
+                    volk_32f_s32f_multiply_32f(rdsout, rdsout, 100.0, count);
+                    rdsOutCount = rdsResamp.process(count, rdsout, rdsout);
+                }
+
+                // Convert output back to real for further processing
+                convert::ComplexToReal::process(count, rtoc.out.writeBuf, lmr);
+
+                // Amplify by 2x
+                volk_32f_s32f_multiply_32f(lmr, lmr, 2.0f, count);
+
+                // Do L = (L+R) + (L-R), R = (L+R) - (L-R)
+                math::Add<float>::process(count, demod.out.writeBuf, lmr, l);
+                math::Subtract<float>::process(count, demod.out.writeBuf, lmr, r);
+
+                // Filter if needed
+                if (_lowPass) {
+                    alFir.process(count, l, l);
+                    arFir.process(count, r, r);
+                }
+
+                // Interleave into stereo
+                convert::LRToStereo::process(count, l, r, out);
+            }
+            else {
+                // Process RDS if needed. Note: find a way to not have to copy half the code from the stereo demod
+                if (_rdsOut) {
+                    // Convert to complex
+                    rtoc.process(count, demod.out.writeBuf, rtoc.out.writeBuf);
+
+                    // Filter out pilot and run through PLL
+                    pilotFir.process(count, rtoc.out.writeBuf, pilotFir.out.writeBuf);
+                    pilotPLL.process(count, pilotFir.out.writeBuf, pilotPLL.out.writeBuf);
+
+                    // Delay
+                    lprDelay.process(count, demod.out.writeBuf, demod.out.writeBuf);
+                    lmrDelay.process(count, rtoc.out.writeBuf, rtoc.out.writeBuf);
+                    
+                    // conjugate PLL output to down convert twice the L-R signal
+                    math::Conjugate::process(count, pilotPLL.out.writeBuf, pilotPLL.out.writeBuf);
+                    math::Multiply<dsp::complex_t>::process(count, rtoc.out.writeBuf, pilotPLL.out.writeBuf, rtoc.out.writeBuf);
+                    math::Multiply<dsp::complex_t>::process(count, rtoc.out.writeBuf, pilotPLL.out.writeBuf, rtoc.out.writeBuf);
+
+                    // Since the PLL output is no longer needed after this, use it as the output
+                    math::Multiply<dsp::complex_t>::process(count, rtoc.out.writeBuf, pilotPLL.out.writeBuf, pilotPLL.out.writeBuf);
+                    convert::ComplexToReal::process(count, pilotPLL.out.writeBuf, rdsout);
+                    volk_32f_s32f_multiply_32f(rdsout, rdsout, 100.0, count);
+                    rdsOutCount = rdsResamp.process(count, rdsout, rdsout);
+                }
+
+                // Filter if needed
+                if (_lowPass) {
+                    alFir.process(count, demod.out.writeBuf, demod.out.writeBuf);
+                }
+
+                // Interleave raw MPX to stereo
+                convert::LRToStereo::process(count, demod.out.writeBuf, demod.out.writeBuf, out);
+            }
+
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int rdsOutCount = 0;
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf, rdsOutCount, rdsOut.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            if (rdsOutCount && _rdsOut) {
+                if (!rdsOut.swap(rdsOutCount)) { return -1; }
+            }
+            return count;
+        }
+
+        stream<float> rdsOut;
+
+    protected:
+        double _deviation;
+        double _samplerate;
+        bool _stereo;
+        bool _lowPass;
+        bool _rdsOut;
+
+        Quadrature demod;
+        tap<complex_t> pilotFirTaps;
+        filter::FIR<complex_t, complex_t> pilotFir;
+        convert::RealToComplex rtoc;
+        loop::PLL pilotPLL;
+        math::Delay<float> lprDelay;
+        math::Delay<complex_t> lmrDelay;
+        tap<float> audioFirTaps;
+        filter::FIR<float, float> arFir;
+        filter::FIR<float, float> alFir;
+        multirate::RationalResampler<float> rdsResamp;
+
+        float* lmr;
+        float* l;
+        float* r;
+        
+    };
+}

core/src/dsp/demod/cw.h

@@ -0,0 +1,90 @@
+#pragma once
+#include "../processor.h"
+#include "../channel/frequency_xlator.h"
+#include "../convert/complex_to_real.h"
+#include "../loop/agc.h"
+#include "../convert/mono_to_stereo.h"
+
+namespace dsp::demod {
+    template <class T>
+    class CW : public Processor<complex_t, T> {
+        using base_type = Processor<complex_t, T>;
+    public:
+        CW() {}
+        
+        CW(stream<complex_t>* in, double tone, double agcAttack, double agcDecay, double samplerate) { init(in, tone, agcAttack, agcDecay, samplerate); }
+
+        void init(stream<complex_t>* in, double tone, double agcAttack, double agcDecay, double samplerate) {
+            _tone = tone;
+            _samplerate = samplerate;
+            
+            xlator.init(NULL, tone, samplerate);
+            agc.init(NULL, 1.0, agcAttack, agcDecay, 10e6, 10.0, INFINITY);
+
+            if constexpr (std::is_same_v<T, float>) {
+                agc.out.free();
+            }
+
+            base_type::init(in);
+        }
+
+        void setTone(double tone) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _tone = tone;
+            xlator.setOffset(_tone, _samplerate);
+        }
+
+        void setAGCAttack(double attack) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            agc.setAttack(attack);
+        }
+
+        void setAGCDecay(double decay) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            agc.setDecay(decay);
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _samplerate = samplerate;
+            xlator.setOffset(_tone, _samplerate);
+        }
+
+        inline int process(int count, const complex_t* in, T* out) {
+            xlator.process(count, in, xlator.out.writeBuf);
+            if constexpr (std::is_same_v<T, float>) {
+                dsp::convert::ComplexToReal::process(count, xlator.out.writeBuf, out);
+                agc.process(count, out, out);
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                dsp::convert::ComplexToReal::process(count, xlator.out.writeBuf, agc.out.writeBuf);
+                agc.process(count, agc.out.writeBuf, agc.out.writeBuf);
+                convert::MonoToStereo::process(count, agc.out.writeBuf, out);
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    private:
+        double _tone;
+        double _samplerate;
+
+        dsp::channel::FrequencyXlator xlator;
+        dsp::loop::AGC<float> agc;
+
+    };
+}

core/src/dsp/demod/fm.h

@@ -0,0 +1,121 @@
+#pragma once
+#include "../processor.h"
+#include "quadrature.h"
+#include "../filter/fir.h"
+#include "../taps/low_pass.h"
+#include "../convert/mono_to_stereo.h"
+
+namespace dsp::demod {
+    template <class T>
+    class FM : public dsp::Processor<dsp::complex_t, T> {
+        using base_type = dsp::Processor<dsp::complex_t, T>;
+    public:
+        FM() {}
+
+        FM(dsp::stream<dsp::complex_t>* in, double samplerate, double bandwidth, bool lowPass) { init(in, samplerate, bandwidth, lowPass); }
+
+        ~FM() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            dsp::taps::free(lpfTaps);
+        }
+
+        void init(dsp::stream<dsp::complex_t>* in, double samplerate, double bandwidth, bool lowPass) {
+            _samplerate = samplerate;
+            _bandwidth = bandwidth;
+            _lowPass = lowPass;
+
+            demod.init(NULL, bandwidth / 2.0, _samplerate);
+            lpfTaps = dsp::taps::lowPass(_bandwidth / 2.0, (_bandwidth / 2.0) * 0.1, _samplerate);
+            lpf.init(NULL, lpfTaps);
+
+            if constexpr (std::is_same_v<T, float>) {
+                demod.out.free();
+            }
+            lpf.out.free();
+
+            base_type::init(in);
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _samplerate = samplerate;
+            demod.setDeviation(_bandwidth / 2.0, _samplerate);
+            dsp::taps::free(lpfTaps);
+            lpfTaps = dsp::taps::lowPass(_bandwidth / 2.0, (_bandwidth / 2.0) * 0.1, _samplerate);
+            lpf.setTaps(lpfTaps);
+            base_type::tempStart();
+        }
+
+        void setBandwidth(double bandwidth) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            if (bandwidth == _bandwidth) { return; }
+            _bandwidth = bandwidth;
+            std::lock_guard<std::mutex> lck2(lpfMtx);
+            demod.setDeviation(_bandwidth / 2.0, _samplerate);
+            dsp::taps::free(lpfTaps);
+            lpfTaps = dsp::taps::lowPass(_bandwidth / 2, (_bandwidth / 2) * 0.1, _samplerate);
+            lpf.setTaps(lpfTaps);
+        }
+
+        void setLowPass(bool lowPass) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            std::lock_guard<std::mutex> lck2(lpfMtx);
+            _lowPass = lowPass;
+            lpf.reset();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            demod.reset();
+            lpf.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, dsp::complex_t* in, T* out) {
+            if constexpr (std::is_same_v<T, float>) {
+                demod.process(count, in, out);
+                if (_lowPass) {
+                    std::lock_guard<std::mutex> lck(lpfMtx);
+                    lpf.process(count, out, out);
+                }
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                demod.process(count, in, demod.out.writeBuf);
+                if (_lowPass) {
+                    std::lock_guard<std::mutex> lck(lpfMtx);
+                    lpf.process(count, demod.out.writeBuf, demod.out.writeBuf);
+                }
+                convert::MonoToStereo::process(count, demod.out.writeBuf, out);
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    private:
+        double _samplerate;
+        double _bandwidth;
+        bool _lowPass;
+
+        Quadrature demod;
+        tap<float> lpfTaps;
+        filter::FIR<float, float> lpf;
+        std::mutex lpfMtx;
+    };
+}

core/src/dsp/demod/gfsk.h

@@ -0,0 +1,162 @@
+#pragma once
+#include "quadrature.h"
+#include "../taps/root_raised_cosine.h"
+#include "../filter/fir.h"
+#include "../clock_recovery/mm.h"
+
+namespace dsp::demod {
+    // Note: I don't like how this demodulator reuses 90% of the code from the PSK demod. Same will be for the PM demod...
+    class GFSK : public Processor<complex_t, float> {
+        using base_type = Processor<complex_t, float>;
+    public:
+        GFSK() {}
+
+        GFSK(stream<complex_t>* in, double symbolrate, double samplerate, double deviation, int rrcTapCount, double rrcBeta, double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            init(in, symbolrate, samplerate, deviation, rrcTapCount, rrcBeta, omegaGain, muGain);
+        }
+
+        ~GFSK() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            taps::free(rrcTaps);
+        }
+
+        void init(stream<complex_t>* in, double symbolrate, double samplerate, double deviation, int rrcTapCount, double rrcBeta, double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            _symbolrate = symbolrate;
+            _samplerate = samplerate;
+            _deviation = deviation;
+            _rrcTapCount = rrcTapCount;
+            _rrcBeta = rrcBeta;
+            
+            demod.init(NULL, _deviation, _samplerate);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.init(NULL, rrcTaps);
+            recov.init(NULL, _samplerate / _symbolrate,  omegaGain, muGain, omegaRelLimit);
+
+            demod.out.free();
+            rrc.out.free();
+            recov.out.free();
+
+            base_type::init(in);
+        }
+
+        void setSymbolrate(double symbolrate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _symbolrate = symbolrate;
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.setTaps(rrcTaps);
+            recov.setOmega(_samplerate / _symbolrate);
+            base_type::tempStart();
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _samplerate = samplerate;
+            demod.setDeviation(_deviation, _samplerate);
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.setTaps(rrcTaps);
+            recov.setOmega(_samplerate / _symbolrate);
+            base_type::tempStart();
+        }
+
+        void setDeviation(double deviation) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _deviation = deviation;
+            demod.setDeviation(_deviation, _samplerate);
+        }
+
+        void setRRCParams(int rrcTapCount, double rrcBeta) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _rrcTapCount = rrcTapCount;
+            _rrcBeta = rrcBeta;
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            base_type::tempStart();
+        }
+
+        void setRRCTapCount(int rrcTapCount) {
+            setRRCParams(rrcTapCount, _rrcBeta);
+        }
+
+        void setRRCBeta(int rrcBeta) {
+            setRRCParams(_rrcTapCount, rrcBeta);
+        }
+
+        void setMMParams(double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaGain(omegaGain);
+            recov.setMuGain(muGain);
+            recov.setOmegaRelLimit(omegaRelLimit);
+        }
+
+        void setOmegaGain(double omegaGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaGain(omegaGain);
+        }
+
+        void setMuGain(double muGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setMuGain(muGain);
+        }
+
+        void setOmegaRelLimit(double omegaRelLimit) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaRelLimit(omegaRelLimit);
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            demod.reset();
+            rrc.reset();
+            recov.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, complex_t* in, float* out) {
+            demod.process(count, in, out);
+            rrc.process(count, out, out);
+            return recov.process(count, out, out);
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        double _symbolrate;
+        double _samplerate;
+        double _deviation;
+        int _rrcTapCount;
+        double _rrcBeta;
+
+        Quadrature demod;
+        tap<float> rrcTaps;
+        filter::FIR<float, float> rrc;
+        clock_recovery::MM<float> recov;
+    };
+}

core/src/dsp/demod/gmsk.h

@@ -0,0 +1,162 @@
+#pragma once
+#include "quadrature.h"
+#include "../taps/root_raised_cosine.h"
+#include "../filter/fir.h"
+#include "../clock_recovery/mm.h"
+
+namespace dsp::demod {
+    // Note: I don't like how this demodulator reuses 90% of the code from the PSK demod. Same will be for the PM demod...
+    class GMSK : public Processor<complex_t, float> {
+        using base_type = Processor<complex_t, float>;
+    public:
+        GMSK() {}
+
+        GMSK(stream<complex_t>* in, double symbolrate, double samplerate, double deviation, int rrcTapCount, double rrcBeta, double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            init(in, symbolrate, samplerate, deviation, rrcTapCount, rrcBeta, omegaGain, muGain);
+        }
+
+        ~GMSK() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            taps::free(rrcTaps);
+        }
+
+        void init(stream<complex_t>* in, double symbolrate, double samplerate, double deviation, int rrcTapCount, double rrcBeta, double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            _symbolrate = symbolrate;
+            _samplerate = samplerate;
+            _deviation = deviation;
+            _rrcTapCount = rrcTapCount;
+            _rrcBeta = rrcBeta;
+            
+            demod.init(NULL, _deviation, _samplerate);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.init(NULL, rrcTaps);
+            recov.init(NULL, _samplerate / _symbolrate,  omegaGain, muGain, omegaRelLimit);
+
+            demod.out.free();
+            rrc.out.free();
+            recov.out.free();
+
+            base_type::init(in);
+        }
+
+        void setSymbolrate(double symbolrate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _symbolrate = symbolrate;
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.setTaps(rrcTaps);
+            recov.setOmega(_samplerate / _symbolrate);
+            base_type::tempStart();
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _samplerate = samplerate;
+            demod.setDeviation(_deviation, _samplerate);
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.setTaps(rrcTaps);
+            recov.setOmega(_samplerate / _symbolrate);
+            base_type::tempStart();
+        }
+
+        void setDeviation(double deviation) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _deviation = deviation;
+            demod.setDeviation(_deviation, _samplerate);
+        }
+
+        void setRRCParams(int rrcTapCount, double rrcBeta) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _rrcTapCount = rrcTapCount;
+            _rrcBeta = rrcBeta;
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            base_type::tempStart();
+        }
+
+        void setRRCTapCount(int rrcTapCount) {
+            setRRCParams(rrcTapCount, _rrcBeta);
+        }
+
+        void setRRCBeta(int rrcBeta) {
+            setRRCParams(_rrcTapCount, rrcBeta);
+        }
+
+        void setMMParams(double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaGain(omegaGain);
+            recov.setMuGain(muGain);
+            recov.setOmegaRelLimit(omegaRelLimit);
+        }
+
+        void setOmegaGain(double omegaGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaGain(omegaGain);
+        }
+
+        void setMuGain(double muGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setMuGain(muGain);
+        }
+
+        void setOmegaRelLimit(double omegaRelLimit) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaRelLimit(omegaRelLimit);
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            demod.reset();
+            rrc.reset();
+            recov.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, complex_t* in, float* out) {
+            demod.process(count, in, out);
+            rrc.process(count, out, out);
+            return recov.process(count, out, out);
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        double _symbolrate;
+        double _samplerate;
+        double _deviation;
+        int _rrcTapCount;
+        double _rrcBeta;
+
+        Quadrature demod;
+        tap<float> rrcTaps;
+        filter::FIR<float, float> rrc;
+        clock_recovery::MM<float> recov;
+    };
+}

core/src/dsp/demod/narrow_fm.h

@@ -0,0 +1,114 @@
+#pragma once
+#include "../processor.h"
+#include "fm.h"
+#include "../filter/fir.h"
+#include "../taps/low_pass.h"
+#include "../convert/mono_to_stereo.h"
+
+namespace dsp::demod {
+    template <class T>
+    class NarrowFM : public dsp::Processor<dsp::complex_t, T> {
+        using base_type = dsp::Processor<dsp::complex_t, T>;
+    public:
+        NarrowFM() {}
+
+        NarrowFM(dsp::stream<dsp::complex_t>* in, double samplerate, double bandwidth, bool lowPass) { init(in, samplerate, bandwidth, lowPass); }
+
+        ~NarrowFM() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            dsp::taps::free(lpfTaps);
+        }
+
+        void init(dsp::stream<dsp::complex_t>* in, double samplerate, double bandwidth, bool lowPass) {
+            _samplerate = samplerate;
+            _bandwidth = bandwidth;
+            _lowPass = lowPass;
+
+            demod.init(NULL, bandwidth / 2.0, _samplerate);
+            lpfTaps = dsp::taps::lowPass(_bandwidth / 2, (_bandwidth / 2) * 0.1, _samplerate);
+            lpf.init(NULL, lpfTaps);
+
+            if constexpr (std::is_same_v<T, float>) {
+                demod.out.free();
+            }
+            lpf.out.free();
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _samplerate = samplerate;
+            demod.setDeviation(_bandwidth / 2.0, _samplerate);
+            dsp::taps::free(lpfTaps);
+            lpfTaps = dsp::taps::lowPass(_bandwidth / 2, (_bandwidth / 2) * 0.1, _samplerate);
+            lpf.setTaps(lpfTaps);
+            base_type::tempStart();
+        }
+
+        void setBandwidth(double bandwidth) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            if (bandwidth == _bandwidth) { return; }
+            _bandwidth = bandwidth;
+            demod.setDeviation(_bandwidth / 2.0, _samplerate);
+            dsp::taps::free(lpfTaps);
+            lpfTaps = dsp::taps::lowPass(_bandwidth / 2, (_bandwidth / 2) * 0.1, _samplerate);
+            lpf.setTaps(lpfTaps);
+        }
+
+        void setLowPass(bool lowPass) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _lowPass = lowPass;
+            lpf.reset();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            demod.reset();
+            lpf.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, dsp::complex_t* in, float* out) {
+            if constexpr (std::is_same_v<T, float>) {
+                demod.process(count, in, out);
+                if (_lowPass) {
+                    lpf.process(count, out, out);
+                }
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                demod.process(count, in, demod.out.writeBuf);
+                if (_lowPass) {
+                    lpf.process(count, demod.out.writeBuf, demod.out.writeBuf);
+                }
+                convert::MonoToStereo::process(count, demod.out.writeBuf, out);
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    private:
+        double _samplerate;
+        double _bandwidth;
+        bool _lowPass;
+
+        dsp::demod::FM demod;
+        dsp::tap<float> lpfTaps;
+        dsp::filter::FIR<float, float> lpf;
+    };
+}

core/src/dsp/demod/psk.h

@@ -0,0 +1,170 @@
+#pragma once
+#include "../taps/root_raised_cosine.h"
+#include "../filter/fir.h"
+#include "../loop/fast_agc.h"
+#include "../loop/costas.h"
+#include "../clock_recovery/mm.h"
+
+namespace dsp::demod {
+    template<int ORDER>
+    class PSK : public Processor<complex_t, complex_t> {
+        using base_type = Processor<complex_t, complex_t>;
+    public:
+        PSK() {}
+
+        PSK(stream<complex_t>* in, double symbolrate, double samplerate, int rrcTapCount, double rrcBeta, double agcRate, double costasBandwidth, double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            init(in, symbolrate, samplerate, rrcTapCount, rrcBeta, agcRate, costasBandwidth, omegaGain, muGain);
+        }
+
+        ~PSK() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            taps::free(rrcTaps);
+        }
+
+        void init(stream<complex_t>* in, double symbolrate, double samplerate, int rrcTapCount, double rrcBeta, double agcRate, double costasBandwidth, double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            _symbolrate = symbolrate;
+            _samplerate = samplerate;
+            _rrcTapCount = rrcTapCount;
+            _rrcBeta = rrcBeta;
+            
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.init(NULL, rrcTaps);
+            agc.init(NULL, 1.0, 10e6, agcRate);
+            costas.init(NULL, costasBandwidth);
+            recov.init(NULL, _samplerate / _symbolrate,  omegaGain, muGain, omegaRelLimit);
+
+            rrc.out.free();
+            agc.out.free();
+            costas.out.free();
+            recov.out.free();
+
+            base_type::init(in);
+        }
+
+        void setSymbolrate(double symbolrate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _symbolrate = symbolrate;
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.setTaps(rrcTaps);
+            recov.setOmega(_samplerate / _symbolrate);
+            base_type::tempStart();
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _samplerate = samplerate;
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            rrc.setTaps(rrcTaps);
+            recov.setOmega(_samplerate / _symbolrate);
+            base_type::tempStart();
+        }
+
+        void setRRCParams(int rrcTapCount, double rrcBeta) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _rrcTapCount = rrcTapCount;
+            _rrcBeta = rrcBeta;
+            taps::free(rrcTaps);
+            rrcTaps = taps::rootRaisedCosine<float>(_rrcTapCount, _rrcBeta, _symbolrate, _samplerate);
+            base_type::tempStart();
+        }
+
+        void setRRCTapCount(int rrcTapCount) {
+            setRRCParams(rrcTapCount, _rrcBeta);
+        }
+
+        void setRRCBeta(int rrcBeta) {
+            setRRCParams(_rrcTapCount, rrcBeta);
+        }
+
+        void setAGCRate(double agcRate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            agc.setRate(agcRate);
+        }
+
+        void setCostasBandwidth(double bandwidth) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            costas.setBandwidth(bandwidth);
+        }
+
+        void setMMParams(double omegaGain, double muGain, double omegaRelLimit = 0.01) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaGain(omegaGain);
+            recov.setMuGain(muGain);
+            recov.setOmegaRelLimit(omegaRelLimit);
+        }
+
+        void setOmegaGain(double omegaGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaGain(omegaGain);
+        }
+
+        void setMuGain(double muGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setMuGain(muGain);
+        }
+
+        void setOmegaRelLimit(double omegaRelLimit) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            recov.setOmegaRelLimit(omegaRelLimit);
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            rrc.reset();
+            agc.reset();
+            costas.reset();
+            recov.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const complex_t* in, complex_t* out) {
+            rrc.process(count, in, out);
+            agc.process(count, out, out);
+            costas.process(count, out, out);
+            return recov.process(count, out, out);
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        double _symbolrate;
+        double _samplerate;
+        int _rrcTapCount;
+        double _rrcBeta;
+
+        tap<float> rrcTaps;
+        filter::FIR<complex_t, float> rrc;
+        loop::FastAGC<complex_t> agc;
+        loop::Costas<ORDER> costas;
+        clock_recovery::MM<complex_t> recov;
+    };
+}

core/src/dsp/demod/quadrature.h

@@ -0,0 +1,69 @@
+#pragma once
+#include "../processor.h"
+#include "../math/fast_atan2.h"
+#include "../math/freq_to_omega.h"
+#include "../math/norm_phase_diff.h"
+
+namespace dsp::demod {
+    class Quadrature : public Processor<complex_t, float> {
+        using base_type = Processor<complex_t, float>;
+    public:
+        Quadrature() {}
+
+        Quadrature(stream<complex_t>* in, double deviation) { init(in, deviation); }
+
+        Quadrature(stream<complex_t>* in, double deviation, double samplerate) { init(in, deviation, samplerate); }
+
+        
+        virtual void init(stream<complex_t>* in, double deviation) {
+            _invDeviation = 1.0 / deviation;
+            base_type::init(in);
+        }
+
+        virtual void init(stream<complex_t>* in, double deviation, double samplerate) {
+            init(in, math::freqToOmega(deviation, samplerate));
+        }
+
+        void setDeviation(double deviation) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _invDeviation = 1.0 / deviation;
+        }
+
+        void setDeviation(double deviation, double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _invDeviation = 1.0 / math::freqToOmega(deviation, samplerate);
+        }
+
+        inline int process(int count, complex_t* in, float* out) {
+            for (int i = 0; i < count; i++) {
+                float cphase = in[i].phase();
+                out[i] = math::normPhaseDiff(cphase - phase) * _invDeviation;
+                phase = cphase;
+            }
+            return count;
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            phase = 0.0f;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        float _invDeviation;
+        float phase = 0.0f;
+    };
+}

core/src/dsp/demod/ssb.h

@@ -0,0 +1,125 @@
+#pragma once
+#include "../processor.h"
+#include "../channel/frequency_xlator.h" 
+#include "../convert/complex_to_real.h"
+#include "../loop/agc.h"
+#include "../convert/mono_to_stereo.h"
+
+namespace dsp::demod {
+    template <class T>
+    class SSB : public Processor<complex_t, T> {
+        using base_type = Processor<complex_t, T>;
+    public:
+        enum Mode {
+            USB,
+            LSB,
+            DSB
+        };
+
+        SSB() {}
+
+        SSB(stream<complex_t>* in, Mode mode, double bandwidth, double samplerate, double agcAttack, double agcDecay) { init(in, mode, bandwidth, samplerate, agcAttack, agcDecay); }
+
+        void init(stream<complex_t>* in, Mode mode, double bandwidth, double samplerate, double agcAttack, double agcDecay) {
+            _mode = mode;
+            _bandwidth = bandwidth;
+            _samplerate = samplerate;
+
+            xlator.init(NULL, getTranslation(), _samplerate);
+            agc.init(NULL, 1.0, agcAttack, agcDecay, 10e6, 10.0, INFINITY);
+
+            if constexpr (std::is_same_v<T, float>) {
+                agc.out.free();
+            }
+
+            base_type::init(in);
+        }
+
+        void setMode(Mode mode) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _mode = mode;
+            xlator.setOffset(getTranslation(), _samplerate);
+            base_type::tempStart();
+        }
+
+        void setBandwidth(double bandwidth) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _bandwidth = bandwidth;
+            xlator.setOffset(getTranslation(), _samplerate);
+            base_type::tempStart();
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _samplerate = samplerate;
+            xlator.setOffset(getTranslation(), _samplerate);
+            base_type::tempStart();
+        }
+
+        void setAGCAttack(double attack) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            agc.setAttack(attack);
+        }
+
+        void setAGCDecay(double decay) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            agc.setDecay(decay);
+        }
+
+        int process(int count, const complex_t* in, T* out) {
+            // Move back sideband
+            xlator.process(count, in, xlator.out.writeBuf);
+
+            if constexpr (std::is_same_v<T, float>) {
+                convert::ComplexToReal::process(count, xlator.out.writeBuf, out);
+                agc.process(count, out, out);
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                convert::ComplexToReal::process(count, xlator.out.writeBuf, agc.out.writeBuf);
+                agc.process(count, agc.out.writeBuf, agc.out.writeBuf);
+                convert::MonoToStereo::process(count, agc.out.writeBuf, out);
+            }
+
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        double getTranslation() {
+            if (_mode == Mode::USB) {
+                return _bandwidth / 2.0;
+            }
+            else if (_mode == Mode::LSB) {
+                return -_bandwidth / 2.0;
+            }
+            else if (_mode == Mode::DSB) {
+                return 0.0;
+            }
+        }
+
+        Mode _mode;
+        double _bandwidth;
+        double _samplerate;
+        channel::FrequencyXlator xlator;
+        loop::AGC<float> agc;
+
+    };
+};

core/src/dsp/demodulator.h

@@ -1,834 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <volk/volk.h>
-#include <dsp/filter.h>
-#include <dsp/processing.h>
-#include <dsp/routing.h>
-#include <spdlog/spdlog.h>
-#include <dsp/pll.h>
-#include <dsp/clock_recovery.h>
-#include <dsp/math.h>
-#include <dsp/conversion.h>
-#include <dsp/audio.h>
-#include <dsp/stereo_fm.h>
-#include <dsp/correction.h>
-
-#define FAST_ATAN2_COEF1 FL_M_PI / 4.0f
-#define FAST_ATAN2_COEF2 3.0f * FAST_ATAN2_COEF1
-
-inline float fast_arctan2(float y, float x) {
-    float abs_y = fabsf(y);
-    float r, angle;
-    if (x == 0.0f && y == 0.0f) { return 0.0f; }
-    if (x >= 0.0f) {
-        r = (x - abs_y) / (x + abs_y);
-        angle = FAST_ATAN2_COEF1 - FAST_ATAN2_COEF1 * r;
-    }
-    else {
-        r = (x + abs_y) / (abs_y - x);
-        angle = FAST_ATAN2_COEF2 - FAST_ATAN2_COEF1 * r;
-    }
-    if (y < 0.0f) {
-        return -angle;
-    }
-    return angle;
-}
-
-namespace dsp {
-    class FloatFMDemod : public generic_block<FloatFMDemod> {
-    public:
-        FloatFMDemod() {}
-
-        FloatFMDemod(stream<complex_t>* in, float sampleRate, float deviation) { init(in, sampleRate, deviation); }
-
-        void init(stream<complex_t>* in, float sampleRate, float deviation) {
-            _in = in;
-            _sampleRate = sampleRate;
-            _deviation = deviation;
-            phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
-            generic_block<FloatFMDemod>::registerInput(_in);
-            generic_block<FloatFMDemod>::registerOutput(&out);
-            generic_block<FloatFMDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<FloatFMDemod>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FloatFMDemod>::ctrlMtx);
-            generic_block<FloatFMDemod>::tempStop();
-            generic_block<FloatFMDemod>::unregisterInput(_in);
-            _in = in;
-            generic_block<FloatFMDemod>::registerInput(_in);
-            generic_block<FloatFMDemod>::tempStart();
-        }
-
-        void setSampleRate(float sampleRate) {
-            assert(generic_block<FloatFMDemod>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FloatFMDemod>::ctrlMtx);
-            generic_block<FloatFMDemod>::tempStop();
-            _sampleRate = sampleRate;
-            phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
-            generic_block<FloatFMDemod>::tempStart();
-        }
-
-        float getSampleRate() {
-            assert(generic_block<FloatFMDemod>::_block_init);
-            return _sampleRate;
-        }
-
-        void setDeviation(float deviation) {
-            assert(generic_block<FloatFMDemod>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FloatFMDemod>::ctrlMtx);
-            generic_block<FloatFMDemod>::tempStop();
-            _deviation = deviation;
-            phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
-            generic_block<FloatFMDemod>::tempStart();
-        }
-
-        float getDeviation() {
-            assert(generic_block<FloatFMDemod>::_block_init);
-            return _deviation;
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            // This is somehow faster than volk...
-            float diff, currentPhase;
-            for (int i = 0; i < count; i++) {
-                currentPhase = fast_arctan2(_in->readBuf[i].im, _in->readBuf[i].re);
-                diff = currentPhase - phase;
-                if (diff > 3.1415926535f) { diff -= 2 * 3.1415926535f; }
-                else if (diff <= -3.1415926535f) {
-                    diff += 2 * 3.1415926535f;
-                }
-                out.writeBuf[i] = diff / phasorSpeed;
-                phase = currentPhase;
-            }
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        float phase = 0;
-        float phasorSpeed, _sampleRate, _deviation;
-        stream<complex_t>* _in;
-    };
-
-    class FMDemod : public generic_block<FMDemod> {
-    public:
-        FMDemod() {}
-
-        FMDemod(stream<complex_t>* in, float sampleRate, float deviation) { init(in, sampleRate, deviation); }
-
-        void init(stream<complex_t>* in, float sampleRate, float deviation) {
-            _in = in;
-            _sampleRate = sampleRate;
-            _deviation = deviation;
-            phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
-            generic_block<FMDemod>::registerInput(_in);
-            generic_block<FMDemod>::registerOutput(&out);
-            generic_block<FMDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<FMDemod>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FMDemod>::ctrlMtx);
-            generic_block<FMDemod>::tempStop();
-            generic_block<FMDemod>::unregisterInput(_in);
-            _in = in;
-            generic_block<FMDemod>::registerInput(_in);
-            generic_block<FMDemod>::tempStart();
-        }
-
-        void setSampleRate(float sampleRate) {
-            assert(generic_block<FMDemod>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FMDemod>::ctrlMtx);
-            generic_block<FMDemod>::tempStop();
-            _sampleRate = sampleRate;
-            phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
-            generic_block<FMDemod>::tempStart();
-        }
-
-        float getSampleRate() {
-            assert(generic_block<FMDemod>::_block_init);
-            return _sampleRate;
-        }
-
-        void setDeviation(float deviation) {
-            assert(generic_block<FMDemod>::_block_init);
-            _deviation = deviation;
-            phasorSpeed = (2 * FL_M_PI) / (_sampleRate / _deviation);
-        }
-
-        float getDeviation() {
-            assert(generic_block<FMDemod>::_block_init);
-            return _deviation;
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            // This is somehow faster than volk...
-
-            float diff, currentPhase;
-            for (int i = 0; i < count; i++) {
-                currentPhase = fast_arctan2(_in->readBuf[i].im, _in->readBuf[i].re);
-                diff = currentPhase - phase;
-                if (diff > 3.1415926535f) { diff -= 2 * 3.1415926535f; }
-                else if (diff <= -3.1415926535f) {
-                    diff += 2 * 3.1415926535f;
-                }
-                out.writeBuf[i].l = diff / phasorSpeed;
-                out.writeBuf[i].r = diff / phasorSpeed;
-                phase = currentPhase;
-            }
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<stereo_t> out;
-
-    private:
-        float phase = 0;
-        float phasorSpeed, _sampleRate, _deviation;
-        stream<complex_t>* _in;
-    };
-
-    class AMDemod : public generic_block<AMDemod> {
-    public:
-        AMDemod() {}
-
-        AMDemod(stream<complex_t>* in) { init(in); }
-
-        void init(stream<complex_t>* in) {
-            _in = in;
-            generic_block<AMDemod>::registerInput(_in);
-            generic_block<AMDemod>::registerOutput(&out);
-            generic_block<AMDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<AMDemod>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<AMDemod>::ctrlMtx);
-            generic_block<AMDemod>::tempStop();
-            generic_block<AMDemod>::unregisterInput(_in);
-            _in = in;
-            generic_block<AMDemod>::registerInput(_in);
-            generic_block<AMDemod>::tempStart();
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32fc_magnitude_32f(out.writeBuf, (lv_32fc_t*)_in->readBuf, count);
-
-            _in->flush();
-
-            for (int i = 0; i < count; i++) {
-                out.writeBuf[i] -= avg;
-                avg += out.writeBuf[i] * 10e-4;
-            }
-
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        stream<complex_t>* _in;
-        float avg = 0;
-    };
-
-    class SSBDemod : public generic_block<SSBDemod> {
-    public:
-        SSBDemod() {}
-
-        SSBDemod(stream<complex_t>* in, float sampleRate, float bandWidth, int mode) { init(in, sampleRate, bandWidth, mode); }
-
-        ~SSBDemod() {
-            if (!generic_block<SSBDemod>::_block_init) { return; }
-            generic_block<SSBDemod>::stop();
-            delete[] buffer;
-            generic_block<SSBDemod>::_block_init = false;
-        }
-
-        enum {
-            MODE_USB,
-            MODE_LSB,
-            MODE_DSB
-        };
-
-        void init(stream<complex_t>* in, float sampleRate, float bandWidth, int mode) {
-            _in = in;
-            _sampleRate = sampleRate;
-            _bandWidth = bandWidth;
-            _mode = mode;
-            phase = lv_cmake(1.0f, 0.0f);
-            switch (_mode) {
-            case MODE_USB:
-                phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_LSB:
-                phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_DSB:
-                phaseDelta = lv_cmake(1.0f, 0.0f);
-                break;
-            }
-            buffer = new lv_32fc_t[STREAM_BUFFER_SIZE];
-            generic_block<SSBDemod>::registerInput(_in);
-            generic_block<SSBDemod>::registerOutput(&out);
-            generic_block<SSBDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<SSBDemod>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<SSBDemod>::ctrlMtx);
-            generic_block<SSBDemod>::tempStop();
-            generic_block<SSBDemod>::unregisterInput(_in);
-            _in = in;
-            generic_block<SSBDemod>::registerInput(_in);
-            generic_block<SSBDemod>::tempStart();
-        }
-
-        void setSampleRate(float sampleRate) {
-            assert(generic_block<SSBDemod>::_block_init);
-            _sampleRate = sampleRate;
-            switch (_mode) {
-            case MODE_USB:
-                phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_LSB:
-                phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_DSB:
-                phaseDelta = lv_cmake(1.0f, 0.0f);
-                break;
-            }
-        }
-
-        void setBandWidth(float bandWidth) {
-            assert(generic_block<SSBDemod>::_block_init);
-            _bandWidth = bandWidth;
-            switch (_mode) {
-            case MODE_USB:
-                phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_LSB:
-                phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_DSB:
-                phaseDelta = lv_cmake(1.0f, 0.0f);
-                break;
-            }
-        }
-
-        void setMode(int mode) {
-            assert(generic_block<SSBDemod>::_block_init);
-            _mode = mode;
-            switch (_mode) {
-            case MODE_USB:
-                phaseDelta = lv_cmake(std::cos((_bandWidth / _sampleRate) * FL_M_PI), std::sin((_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_LSB:
-                phaseDelta = lv_cmake(std::cos(-(_bandWidth / _sampleRate) * FL_M_PI), std::sin(-(_bandWidth / _sampleRate) * FL_M_PI));
-                break;
-            case MODE_DSB:
-                phaseDelta = lv_cmake(1.0f, 0.0f);
-                break;
-            }
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            volk_32fc_s32fc_x2_rotator_32fc(buffer, (lv_32fc_t*)_in->readBuf, phaseDelta, &phase, count);
-            volk_32fc_deinterleave_real_32f(out.writeBuf, buffer, count);
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        stream<float> out;
-
-    private:
-        int _mode;
-        float _sampleRate, _bandWidth;
-        stream<complex_t>* _in;
-        lv_32fc_t* buffer;
-        lv_32fc_t phase;
-        lv_32fc_t phaseDelta;
-    };
-
-    class FSKDemod : public generic_hier_block<FSKDemod> {
-    public:
-        FSKDemod() {}
-
-        FSKDemod(stream<complex_t>* input, float sampleRate, float deviation, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            init(input, sampleRate, deviation, baudRate, omegaGain, muGain, omegaRelLimit);
-        }
-
-        void init(stream<complex_t>* input, float sampleRate, float deviation, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            _sampleRate = sampleRate;
-            _deviation = deviation;
-            _baudRate = baudRate;
-            _omegaGain = omegaGain;
-            _muGain = muGain;
-            _omegaRelLimit = omegaRelLimit;
-
-            demod.init(input, _sampleRate, _deviation);
-            recov.init(&demod.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
-            out = &recov.out;
-
-            generic_hier_block<FSKDemod>::registerBlock(&demod);
-            generic_hier_block<FSKDemod>::registerBlock(&recov);
-            generic_hier_block<FSKDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* input) {
-            assert((generic_hier_block<FSKDemod>::_block_init));
-            demod.setInput(input);
-        }
-
-        void setSampleRate(float sampleRate) {
-            assert(generic_hier_block<FSKDemod>::_block_init);
-            generic_hier_block<FSKDemod>::tempStop();
-            _sampleRate = sampleRate;
-            demod.setSampleRate(_sampleRate);
-            recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
-            generic_hier_block<FSKDemod>::tempStart();
-        }
-
-        void setDeviation(float deviation) {
-            assert(generic_hier_block<FSKDemod>::_block_init);
-            _deviation = deviation;
-            demod.setDeviation(deviation);
-        }
-
-        void setBaudRate(float baudRate, float omegaRelLimit) {
-            assert(generic_hier_block<FSKDemod>::_block_init);
-            _baudRate = baudRate;
-            _omegaRelLimit = omegaRelLimit;
-            recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
-        }
-
-        void setMMGains(float omegaGain, float myGain) {
-            assert(generic_hier_block<FSKDemod>::_block_init);
-            _omegaGain = omegaGain;
-            _muGain = myGain;
-            recov.setGains(_omegaGain, _muGain);
-        }
-
-        void setOmegaRelLimit(float omegaRelLimit) {
-            assert(generic_hier_block<FSKDemod>::_block_init);
-            _omegaRelLimit = omegaRelLimit;
-            recov.setOmegaRelLimit(_omegaRelLimit);
-        }
-
-        stream<float>* out = NULL;
-
-    private:
-        FloatFMDemod demod;
-        MMClockRecovery<float> recov;
-
-        float _sampleRate;
-        float _deviation;
-        float _baudRate;
-        float _omegaGain;
-        float _muGain;
-        float _omegaRelLimit;
-    };
-
-    class GFSKDemod : public generic_hier_block<GFSKDemod> {
-    public:
-        GFSKDemod() {}
-
-        GFSKDemod(stream<complex_t>* input, float sampleRate, float deviation, float rrcAlpha, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            init(input, sampleRate, deviation, rrcAlpha, baudRate, omegaGain, muGain, omegaRelLimit);
-        }
-
-        void init(stream<complex_t>* input, float sampleRate, float deviation, float rrcAlpha, float baudRate, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            _sampleRate = sampleRate;
-            _deviation = deviation;
-            _rrcAlpha = rrcAlpha;
-            _baudRate = baudRate;
-            _omegaGain = omegaGain;
-            _muGain = muGain;
-            _omegaRelLimit = omegaRelLimit;
-
-            demod.init(input, _sampleRate, _deviation);
-            rrc.init(31, _sampleRate, _baudRate, _rrcAlpha);
-            fir.init(&demod.out, &rrc);
-            recov.init(&fir.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
-            out = &recov.out;
-
-            generic_hier_block<GFSKDemod>::registerBlock(&demod);
-            generic_hier_block<GFSKDemod>::registerBlock(&fir);
-            generic_hier_block<GFSKDemod>::registerBlock(&recov);
-            generic_hier_block<GFSKDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* input) {
-            assert((generic_hier_block<GFSKDemod>::_block_init));
-            demod.setInput(input);
-        }
-
-        void setSampleRate(float sampleRate) {
-            assert(generic_hier_block<GFSKDemod>::_block_init);
-            generic_hier_block<GFSKDemod>::tempStop();
-            _sampleRate = sampleRate;
-            demod.setSampleRate(_sampleRate);
-            recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
-            rrc.setSampleRate(_sampleRate);
-            fir.updateWindow(&rrc);
-            generic_hier_block<GFSKDemod>::tempStart();
-        }
-
-        void setDeviation(float deviation) {
-            assert(generic_hier_block<GFSKDemod>::_block_init);
-            _deviation = deviation;
-            demod.setDeviation(deviation);
-        }
-
-        void setRRCAlpha(float rrcAlpha) {
-            assert(generic_hier_block<GFSKDemod>::_block_init);
-            _rrcAlpha = rrcAlpha;
-            rrc.setAlpha(_rrcAlpha);
-            fir.updateWindow(&rrc);
-        }
-
-        void setBaudRate(float baudRate, float omegaRelLimit) {
-            assert(generic_hier_block<GFSKDemod>::_block_init);
-            _baudRate = baudRate;
-            _omegaRelLimit = omegaRelLimit;
-            generic_hier_block<GFSKDemod>::tempStop();
-            recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
-            rrc.setBaudRate(_baudRate);
-            fir.updateWindow(&rrc);
-            generic_hier_block<GFSKDemod>::tempStart();
-        }
-
-        void setMMGains(float omegaGain, float myGain) {
-            assert(generic_hier_block<GFSKDemod>::_block_init);
-            _omegaGain = omegaGain;
-            _muGain = myGain;
-            recov.setGains(_omegaGain, _muGain);
-        }
-
-        void setOmegaRelLimit(float omegaRelLimit) {
-            assert(generic_hier_block<GFSKDemod>::_block_init);
-            _omegaRelLimit = omegaRelLimit;
-            recov.setOmegaRelLimit(_omegaRelLimit);
-        }
-
-        stream<float>* out = NULL;
-
-    private:
-        FloatFMDemod demod;
-        RRCTaps rrc;
-        FIR<float> fir;
-        MMClockRecovery<float> recov;
-
-        float _sampleRate;
-        float _deviation;
-        float _rrcAlpha;
-        float _baudRate;
-        float _omegaGain;
-        float _muGain;
-        float _omegaRelLimit;
-    };
-
-    template <int ORDER, bool OFFSET>
-    class PSKDemod : public generic_hier_block<PSKDemod<ORDER, OFFSET>> {
-    public:
-        PSKDemod() {}
-
-        PSKDemod(stream<complex_t>* input, float sampleRate, float baudRate, int RRCTapCount = 31, float RRCAlpha = 0.32f, float agcRate = 10e-4, float costasLoopBw = 0.004f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            init(input, sampleRate, baudRate, RRCTapCount, RRCAlpha, agcRate, costasLoopBw, omegaGain, muGain, omegaRelLimit);
-        }
-
-        void init(stream<complex_t>* input, float sampleRate, float baudRate, int RRCTapCount = 31, float RRCAlpha = 0.32f, float agcRate = 10e-4, float costasLoopBw = 0.004f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            _RRCTapCount = RRCTapCount;
-            _RRCAlpha = RRCAlpha;
-            _sampleRate = sampleRate;
-            _agcRate = agcRate;
-            _costasLoopBw = costasLoopBw;
-            _baudRate = baudRate;
-            _omegaGain = omegaGain;
-            _muGain = muGain;
-            _omegaRelLimit = omegaRelLimit;
-
-            agc.init(input, 1.0f, 65535, _agcRate);
-            taps.init(_RRCTapCount, _sampleRate, _baudRate, _RRCAlpha);
-            rrc.init(&agc.out, &taps);
-            demod.init(&rrc.out, _costasLoopBw);
-
-            generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&agc);
-            generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&rrc);
-            generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&demod);
-
-            if constexpr (OFFSET) {
-                delay.init(&demod.out);
-                recov.init(&delay.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
-                generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&delay);
-            }
-            else {
-                recov.init(&demod.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
-            }
-
-            generic_hier_block<PSKDemod<ORDER, OFFSET>>::registerBlock(&recov);
-
-            out = &recov.out;
-
-            generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* input) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            agc.setInput(input);
-        }
-
-        void setSampleRate(float sampleRate) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            _sampleRate = sampleRate;
-            rrc.tempStop();
-            recov.tempStop();
-            taps.setSampleRate(_sampleRate);
-            rrc.updateWindow(&taps);
-            recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
-            rrc.tempStart();
-            recov.tempStart();
-        }
-
-        void setBaudRate(float baudRate) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            _baudRate = baudRate;
-            rrc.tempStop();
-            recov.tempStop();
-            taps.setBaudRate(_baudRate);
-            rrc.updateWindow(&taps);
-            recov.setOmega(_sampleRate / _baudRate, _omegaRelLimit);
-            rrc.tempStart();
-            recov.tempStart();
-        }
-
-        void setRRCParams(int RRCTapCount, float RRCAlpha) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            _RRCTapCount = RRCTapCount;
-            _RRCAlpha = RRCAlpha;
-            taps.setTapCount(_RRCTapCount);
-            taps.setAlpha(RRCAlpha);
-            rrc.updateWindow(&taps);
-        }
-
-        void setAgcRate(float agcRate) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            _agcRate = agcRate;
-            agc.setRate(_agcRate);
-        }
-
-        void setCostasLoopBw(float costasLoopBw) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            _costasLoopBw = costasLoopBw;
-            demod.setLoopBandwidth(_costasLoopBw);
-        }
-
-        void setMMGains(float omegaGain, float myGain) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            _omegaGain = omegaGain;
-            _muGain = myGain;
-            recov.setGains(_omegaGain, _muGain);
-        }
-
-        void setOmegaRelLimit(float omegaRelLimit) {
-            assert((generic_hier_block<PSKDemod<ORDER, OFFSET>>::_block_init));
-            _omegaRelLimit = omegaRelLimit;
-            recov.setOmegaRelLimit(_omegaRelLimit);
-        }
-
-        stream<complex_t>* out = NULL;
-
-    private:
-        dsp::ComplexAGC agc;
-        dsp::RRCTaps taps;
-        dsp::FIR<dsp::complex_t> rrc;
-        CostasLoop<ORDER> demod;
-        DelayImag delay;
-        MMClockRecovery<dsp::complex_t> recov;
-
-        int _RRCTapCount;
-        float _RRCAlpha;
-        float _sampleRate;
-        float _agcRate;
-        float _baudRate;
-        float _costasLoopBw;
-        float _omegaGain;
-        float _muGain;
-        float _omegaRelLimit;
-    };
-
-    class PMDemod : public generic_hier_block<PMDemod> {
-    public:
-        PMDemod() {}
-
-        PMDemod(stream<complex_t>* input, float sampleRate, float baudRate, float agcRate = 0.02e-3f, float pllLoopBandwidth = (0.06f * 0.06f) / 4.0f, int rrcTapCount = 31, float rrcAlpha = 0.6f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            init(input, sampleRate, baudRate, agcRate, pllLoopBandwidth, rrcTapCount, rrcAlpha, omegaGain, muGain, omegaRelLimit);
-        }
-
-        void init(stream<complex_t>* input, float sampleRate, float baudRate, float agcRate = 0.02e-3f, float pllLoopBandwidth = (0.06f * 0.06f) / 4.0f, int rrcTapCount = 31, float rrcAlpha = 0.6f, float omegaGain = (0.01 * 0.01) / 4, float muGain = 0.01f, float omegaRelLimit = 0.005f) {
-            _sampleRate = sampleRate;
-            _baudRate = baudRate;
-            _agcRate = agcRate;
-            _pllLoopBandwidth = pllLoopBandwidth;
-            _rrcTapCount = rrcTapCount;
-            _rrcAlpha = rrcAlpha;
-            _omegaGain = omegaGain;
-            _muGain = muGain;
-            _omegaRelLimit = omegaRelLimit;
-
-            agc.init(input, 1.0f, 65535, _agcRate);
-            pll.init(&agc.out, _pllLoopBandwidth);
-            rrcwin.init(_rrcTapCount, _sampleRate, _baudRate, _rrcAlpha);
-            rrc.init(&pll.out, &rrcwin);
-            recov.init(&rrc.out, _sampleRate / _baudRate, _omegaGain, _muGain, _omegaRelLimit);
-
-            out = &recov.out;
-
-            generic_hier_block<PMDemod>::registerBlock(&agc);
-            generic_hier_block<PMDemod>::registerBlock(&pll);
-            generic_hier_block<PMDemod>::registerBlock(&rrc);
-            generic_hier_block<PMDemod>::registerBlock(&recov);
-            generic_hier_block<PMDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* input) {
-            assert(generic_hier_block<PMDemod>::_block_init);
-            agc.setInput(input);
-        }
-
-        void setAgcRate(float agcRate) {
-            assert(generic_hier_block<PMDemod>::_block_init);
-            _agcRate = agcRate;
-            agc.setRate(_agcRate);
-        }
-
-        void setPllLoopBandwidth(float pllLoopBandwidth) {
-            assert(generic_hier_block<PMDemod>::_block_init);
-            _pllLoopBandwidth = pllLoopBandwidth;
-            pll.setLoopBandwidth(_pllLoopBandwidth);
-        }
-
-        void setRRCParams(int rrcTapCount, float rrcAlpha) {
-            assert(generic_hier_block<PMDemod>::_block_init);
-            _rrcTapCount = rrcTapCount;
-            _rrcAlpha = rrcAlpha;
-            rrcwin.setTapCount(_rrcTapCount);
-            rrcwin.setAlpha(_rrcAlpha);
-            rrc.updateWindow(&rrcwin);
-        }
-
-        void setMMGains(float omegaGain, float muGain) {
-            assert(generic_hier_block<PMDemod>::_block_init);
-            _omegaGain = omegaGain;
-            _muGain = muGain;
-            recov.setGains(_omegaGain, _muGain);
-        }
-
-        void setOmegaRelLimit(float omegaRelLimit) {
-            assert(generic_hier_block<PMDemod>::_block_init);
-            _omegaRelLimit = omegaRelLimit;
-            recov.setOmegaRelLimit(_omegaRelLimit);
-        }
-
-        stream<float>* out = NULL;
-
-    private:
-        dsp::ComplexAGC agc;
-        dsp::CarrierTrackingPLL<float> pll;
-        dsp::RRCTaps rrcwin;
-        dsp::FIR<float> rrc;
-        dsp::MMClockRecovery<float> recov;
-
-        float _sampleRate;
-        float _baudRate;
-        float _agcRate;
-        float _pllLoopBandwidth;
-        int _rrcTapCount;
-        float _rrcAlpha;
-        float _omegaGain;
-        float _muGain;
-        float _omegaRelLimit;
-    };
-
-    class StereoFMDemod : public generic_hier_block<StereoFMDemod> {
-    public:
-        StereoFMDemod() {}
-
-        StereoFMDemod(stream<complex_t>* input, float sampleRate, float deviation) {
-            init(input, sampleRate, deviation);
-        }
-
-        void init(stream<complex_t>* input, float sampleRate, float deviation) {
-            _sampleRate = sampleRate;
-
-            PilotFirWin.init(18750, 19250, 3000, _sampleRate);
-
-            demod.init(input, _sampleRate, deviation);
-
-            r2c.init(&demod.out);
-
-            pilotFilter.init(&r2c.out, &PilotFirWin);
-
-            demux.init(&pilotFilter.dataOut, &pilotFilter.pilotOut, 0.1f);
-
-            recon.init(&demux.AplusBOut, &demux.AminusBOut);
-
-            out = &recon.out;
-
-            generic_hier_block<StereoFMDemod>::registerBlock(&demod);
-            generic_hier_block<StereoFMDemod>::registerBlock(&r2c);
-            generic_hier_block<StereoFMDemod>::registerBlock(&pilotFilter);
-            generic_hier_block<StereoFMDemod>::registerBlock(&demux);
-            generic_hier_block<StereoFMDemod>::registerBlock(&recon);
-            generic_hier_block<StereoFMDemod>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* input) {
-            assert(generic_hier_block<StereoFMDemod>::_block_init);
-            demod.setInput(input);
-        }
-
-        void setDeviation(float deviation) {
-            demod.setDeviation(deviation);
-        }
-
-        stream<stereo_t>* out = NULL;
-
-    private:
-        filter_window::BandPassBlackmanWindow PilotFirWin;
-
-        FloatFMDemod demod;
-
-        RealToComplex r2c;
-
-        FMStereoDemuxPilotFilter pilotFilter;
-
-        FMStereoDemux demux;
-
-        FMStereoReconstruct recon;
-
-        float _sampleRate;
-    };
-}

core/src/dsp/digital/binary_slicer.h

@@ -0,0 +1,31 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::digital {
+    class BinarySlicer : public Processor<float, uint8_t> {
+        using base_type = Processor<float, uint8_t>;
+    public:
+        BinarySlicer() {}
+
+        BinarySlicer(stream<float> *in) { base_type::init(in); }
+
+        static inline int process(int count, const float* in, uint8_t* out) {
+            // TODO: Switch to volk
+            for (int i = 0; i < count; i++) {
+                out[i] = in[i] > 0.0f;
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+    };
+}

core/src/dsp/digital/differentia_decoder.h

@@ -0,0 +1,64 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::digital {
+    class DifferentialDecoder : public Processor<uint8_t, uint8_t> {
+        using base_type = Processor<uint8_t, uint8_t>;
+    public:
+        DifferentialDecoder() {}
+
+        DifferentialDecoder(stream<uint8_t> *in) { base_type::init(in); }
+
+        void init(stream<uint8_t> *in, uint8_t modulus, uint8_t initSym = 0) {
+            _modulus = modulus;
+            _initSym = initSym;
+
+            last = _initSym;
+
+            base_type::init(in);
+        }
+
+        void setModulus(uint8_t modulus) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _modulus = modulus;
+        }
+
+        void setInitSym(uint8_t initSym) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _initSym = initSym;
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            last = _initSym;
+            base_type::tempStart();
+        }
+        
+        inline int process(int count, const uint8_t* in, uint8_t* out) {
+            for (int i = 0; i < count; i++) {
+                out[i] = (in[i] - last) % _modulus;
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        uint8_t last;
+        uint8_t _initSym;
+        uint8_t _modulus;
+    };
+}

core/src/dsp/digital/differential_decoder.h

@@ -0,0 +1,65 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::digital {
+    class DifferentialDecoder : public Processor<uint8_t, uint8_t> {
+        using base_type = Processor<uint8_t, uint8_t>;
+    public:
+        DifferentialDecoder() {}
+
+        DifferentialDecoder(stream<uint8_t> *in) { base_type::init(in); }
+
+        void init(stream<uint8_t> *in, uint8_t modulus, uint8_t initSym = 0) {
+            _modulus = modulus;
+            _initSym = initSym;
+
+            last = _initSym;
+
+            base_type::init(in);
+        }
+
+        void setModulus(uint8_t modulus) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _modulus = modulus;
+        }
+
+        void setInitSym(uint8_t initSym) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _initSym = initSym;
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            last = _initSym;
+            base_type::tempStart();
+        }
+        
+        inline int process(int count, const uint8_t* in, uint8_t* out) {
+            for (int i = 0; i < count; i++) {
+                out[i] = (in[i] - last + _modulus) % _modulus;
+                last = in[i];
+            }
+            return count;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        uint8_t last;
+        uint8_t _initSym;
+        uint8_t _modulus;
+    };
+}

core/src/dsp/digital/manchester_decoder.h

@@ -0,0 +1,47 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::digital {
+    class ManchesterDecoder : public Processor<uint8_t, uint8_t> {
+        using base_type = Processor<uint8_t, uint8_t>;
+    public:
+        ManchesterDecoder() {}
+
+        ManchesterDecoder(stream<uint8_t> *in) { base_type::init(in); }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            offset = 0;
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const uint8_t* in, uint8_t* out) {
+            // TODO: NOT THIS BULLSHIT
+            int outCount = 0;
+            for (; offset < count; offset += 2) {
+                out[outCount++] = in[offset];
+            }
+            offset -= count;
+            return outCount;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        int offset = 0;
+    };
+}

core/src/dsp/falcon_fec.h

@@ -1,147 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <inttypes.h>
-
-// WTF???
-extern "C" {
-#include <correct.h>
-}
-
-const uint8_t toDB[] = {
-    0x00, 0x7b, 0xaf, 0xd4, 0x99, 0xe2, 0x36, 0x4d, 0xfa, 0x81, 0x55, 0x2e, 0x63, 0x18, 0xcc, 0xb7, 0x86, 0xfd, 0x29, 0x52, 0x1f,
-    0x64, 0xb0, 0xcb, 0x7c, 0x07, 0xd3, 0xa8, 0xe5, 0x9e, 0x4a, 0x31, 0xec, 0x97, 0x43, 0x38, 0x75, 0x0e, 0xda, 0xa1, 0x16, 0x6d, 0xb9, 0xc2, 0x8f, 0xf4,
-    0x20, 0x5b, 0x6a, 0x11, 0xc5, 0xbe, 0xf3, 0x88, 0x5c, 0x27, 0x90, 0xeb, 0x3f, 0x44, 0x09, 0x72, 0xa6, 0xdd, 0xef, 0x94, 0x40, 0x3b, 0x76, 0x0d, 0xd9,
-    0xa2, 0x15, 0x6e, 0xba, 0xc1, 0x8c, 0xf7, 0x23, 0x58, 0x69, 0x12, 0xc6, 0xbd, 0xf0, 0x8b, 0x5f, 0x24, 0x93, 0xe8, 0x3c, 0x47, 0x0a, 0x71, 0xa5, 0xde,
-    0x03, 0x78, 0xac, 0xd7, 0x9a, 0xe1, 0x35, 0x4e, 0xf9, 0x82, 0x56, 0x2d, 0x60, 0x1b, 0xcf, 0xb4, 0x85, 0xfe, 0x2a, 0x51, 0x1c, 0x67, 0xb3, 0xc8, 0x7f,
-    0x04, 0xd0, 0xab, 0xe6, 0x9d, 0x49, 0x32, 0x8d, 0xf6, 0x22, 0x59, 0x14, 0x6f, 0xbb, 0xc0, 0x77, 0x0c, 0xd8, 0xa3, 0xee, 0x95, 0x41, 0x3a, 0x0b, 0x70,
-    0xa4, 0xdf, 0x92, 0xe9, 0x3d, 0x46, 0xf1, 0x8a, 0x5e, 0x25, 0x68, 0x13, 0xc7, 0xbc, 0x61, 0x1a, 0xce, 0xb5, 0xf8, 0x83, 0x57, 0x2c, 0x9b, 0xe0, 0x34,
-    0x4f, 0x02, 0x79, 0xad, 0xd6, 0xe7, 0x9c, 0x48, 0x33, 0x7e, 0x05, 0xd1, 0xaa, 0x1d, 0x66, 0xb2, 0xc9, 0x84, 0xff, 0x2b, 0x50, 0x62, 0x19, 0xcd, 0xb6,
-    0xfb, 0x80, 0x54, 0x2f, 0x98, 0xe3, 0x37, 0x4c, 0x01, 0x7a, 0xae, 0xd5, 0xe4, 0x9f, 0x4b, 0x30, 0x7d, 0x06, 0xd2, 0xa9, 0x1e, 0x65, 0xb1, 0xca, 0x87,
-    0xfc, 0x28, 0x53, 0x8e, 0xf5, 0x21, 0x5a, 0x17, 0x6c, 0xb8, 0xc3, 0x74, 0x0f, 0xdb, 0xa0, 0xed, 0x96, 0x42, 0x39, 0x08, 0x73, 0xa7, 0xdc, 0x91, 0xea,
-    0x3e, 0x45, 0xf2, 0x89, 0x5d, 0x26, 0x6b, 0x10, 0xc4, 0xbf
-};
-
-const uint8_t fromDB[] = {
-    0x00, 0xcc, 0xac, 0x60, 0x79, 0xb5, 0xd5, 0x19, 0xf0, 0x3c, 0x5c, 0x90, 0x89, 0x45, 0x25, 0xe9, 0xfd, 0x31, 0x51, 0x9d,
-    0x84, 0x48, 0x28, 0xe4, 0x0d, 0xc1, 0xa1, 0x6d, 0x74, 0xb8, 0xd8, 0x14, 0x2e, 0xe2, 0x82, 0x4e, 0x57, 0x9b, 0xfb, 0x37, 0xde, 0x12, 0x72, 0xbe, 0xa7,
-    0x6b, 0x0b, 0xc7, 0xd3, 0x1f, 0x7f, 0xb3, 0xaa, 0x66, 0x06, 0xca, 0x23, 0xef, 0x8f, 0x43, 0x5a, 0x96, 0xf6, 0x3a, 0x42, 0x8e, 0xee, 0x22, 0x3b, 0xf7,
-    0x97, 0x5b, 0xb2, 0x7e, 0x1e, 0xd2, 0xcb, 0x07, 0x67, 0xab, 0xbf, 0x73, 0x13, 0xdf, 0xc6, 0x0a, 0x6a, 0xa6, 0x4f, 0x83, 0xe3, 0x2f, 0x36, 0xfa, 0x9a,
-    0x56, 0x6c, 0xa0, 0xc0, 0x0c, 0x15, 0xd9, 0xb9, 0x75, 0x9c, 0x50, 0x30, 0xfc, 0xe5, 0x29, 0x49, 0x85, 0x91, 0x5d, 0x3d, 0xf1, 0xe8, 0x24, 0x44, 0x88,
-    0x61, 0xad, 0xcd, 0x01, 0x18, 0xd4, 0xb4, 0x78, 0xc5, 0x09, 0x69, 0xa5, 0xbc, 0x70, 0x10, 0xdc, 0x35, 0xf9, 0x99, 0x55, 0x4c, 0x80, 0xe0, 0x2c, 0x38,
-    0xf4, 0x94, 0x58, 0x41, 0x8d, 0xed, 0x21, 0xc8, 0x04, 0x64, 0xa8, 0xb1, 0x7d, 0x1d, 0xd1, 0xeb, 0x27, 0x47, 0x8b, 0x92, 0x5e, 0x3e, 0xf2, 0x1b, 0xd7,
-    0xb7, 0x7b, 0x62, 0xae, 0xce, 0x02, 0x16, 0xda, 0xba, 0x76, 0x6f, 0xa3, 0xc3, 0x0f, 0xe6, 0x2a, 0x4a, 0x86, 0x9f, 0x53, 0x33, 0xff, 0x87, 0x4b, 0x2b,
-    0xe7, 0xfe, 0x32, 0x52, 0x9e, 0x77, 0xbb, 0xdb, 0x17, 0x0e, 0xc2, 0xa2, 0x6e, 0x7a, 0xb6, 0xd6, 0x1a, 0x03, 0xcf, 0xaf, 0x63, 0x8a, 0x46, 0x26, 0xea,
-    0xf3, 0x3f, 0x5f, 0x93, 0xa9, 0x65, 0x05, 0xc9, 0xd0, 0x1c, 0x7c, 0xb0, 0x59, 0x95, 0xf5, 0x39, 0x20, 0xec, 0x8c, 0x40, 0x54, 0x98, 0xf8, 0x34, 0x2d,
-    0xe1, 0x81, 0x4d, 0xa4, 0x68, 0x08, 0xc4, 0xdd, 0x11, 0x71, 0xbd
-};
-
-const uint8_t randVals[] = {
-    0xFF, 0x48, 0x0E, 0xC0, 0x9A, 0x0D, 0x70, 0xBC, 0x8E, 0x2C, 0x93, 0xAD, 0xA7, 0xB7, 0x46, 0xCE,
-    0x5A, 0x97, 0x7D, 0xCC, 0x32, 0xA2, 0xBF, 0x3E, 0x0A, 0x10, 0xF1, 0x88, 0x94, 0xCD, 0xEA, 0xB1,
-    0xFE, 0x90, 0x1D, 0x81, 0x34, 0x1A, 0xE1, 0x79, 0x1C, 0x59, 0x27, 0x5B, 0x4F, 0x6E, 0x8D, 0x9C,
-    0xB5, 0x2E, 0xFB, 0x98, 0x65, 0x45, 0x7E, 0x7C, 0x14, 0x21, 0xE3, 0x11, 0x29, 0x9B, 0xD5, 0x63,
-    0xFD, 0x20, 0x3B, 0x02, 0x68, 0x35, 0xC2, 0xF2, 0x38, 0xB2, 0x4E, 0xB6, 0x9E, 0xDD, 0x1B, 0x39,
-    0x6A, 0x5D, 0xF7, 0x30, 0xCA, 0x8A, 0xFC, 0xF8, 0x28, 0x43, 0xC6, 0x22, 0x53, 0x37, 0xAA, 0xC7,
-    0xFA, 0x40, 0x76, 0x04, 0xD0, 0x6B, 0x85, 0xE4, 0x71, 0x64, 0x9D, 0x6D, 0x3D, 0xBA, 0x36, 0x72,
-    0xD4, 0xBB, 0xEE, 0x61, 0x95, 0x15, 0xF9, 0xF0, 0x50, 0x87, 0x8C, 0x44, 0xA6, 0x6F, 0x55, 0x8F,
-    0xF4, 0x80, 0xEC, 0x09, 0xA0, 0xD7, 0x0B, 0xC8, 0xE2, 0xC9, 0x3A, 0xDA, 0x7B, 0x74, 0x6C, 0xE5,
-    0xA9, 0x77, 0xDC, 0xC3, 0x2A, 0x2B, 0xF3, 0xE0, 0xA1, 0x0F, 0x18, 0x89, 0x4C, 0xDE, 0xAB, 0x1F,
-    0xE9, 0x01, 0xD8, 0x13, 0x41, 0xAE, 0x17, 0x91, 0xC5, 0x92, 0x75, 0xB4, 0xF6, 0xE8, 0xD9, 0xCB,
-    0x52, 0xEF, 0xB9, 0x86, 0x54, 0x57, 0xE7, 0xC1, 0x42, 0x1E, 0x31, 0x12, 0x99, 0xBD, 0x56, 0x3F,
-    0xD2, 0x03, 0xB0, 0x26, 0x83, 0x5C, 0x2F, 0x23, 0x8B, 0x24, 0xEB, 0x69, 0xED, 0xD1, 0xB3, 0x96,
-    0xA5, 0xDF, 0x73, 0x0C, 0xA8, 0xAF, 0xCF, 0x82, 0x84, 0x3C, 0x62, 0x25, 0x33, 0x7A, 0xAC, 0x7F,
-    0xA4, 0x07, 0x60, 0x4D, 0x06, 0xB8, 0x5E, 0x47, 0x16, 0x49, 0xD6, 0xD3, 0xDB, 0xA3, 0x67, 0x2D,
-    0x4B, 0xBE, 0xE6, 0x19, 0x51, 0x5F, 0x9F, 0x05, 0x08, 0x78, 0xC4, 0x4A, 0x66, 0xF5, 0x58
-};
-
-namespace dsp {
-    class FalconRS : public generic_block<FalconRS> {
-    public:
-        FalconRS() {}
-
-        FalconRS(stream<uint8_t>* in) { init(in); }
-
-        void init(stream<uint8_t>* in) {
-            _in = in;
-
-            for (int i = 0; i < 5; i++) { memset(buffers[i], 0, 255); }
-            for (int i = 0; i < 5; i++) { memset(outBuffers[i], 0, 255); }
-            rs = correct_reed_solomon_create(correct_rs_primitive_polynomial_ccsds, 120, 11, 16);
-            if (rs == NULL) { printf("Error creating the reed solomon decoder\n"); }
-
-            generic_block<FalconRS>::registerInput(_in);
-            generic_block<FalconRS>::registerOutput(&out);
-            generic_block<FalconRS>::_block_init = true;
-        }
-
-        void setInput(stream<uint8_t>* in) {
-            assert(generic_block<FalconRS>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FalconRS>::ctrlMtx);
-            generic_block<FalconRS>::tempStop();
-            generic_block<FalconRS>::unregisterInput(_in);
-            _in = in;
-            generic_block<FalconRS>::registerInput(_in);
-            generic_block<FalconRS>::tempStart();
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            uint8_t* data = _in->readBuf + 4;
-
-            // Deinterleave
-            for (int i = 0; i < 255 * 5; i++) {
-                buffers[i % 5][i / 5] = fromDB[data[i]];
-            }
-
-            // Reed the solomon :weary:
-            int result = 0;
-            result = correct_reed_solomon_decode(rs, buffers[0], 255, outBuffers[0]);
-            if (result == -1) {
-                _in->flush();
-                return count;
-            }
-            result = correct_reed_solomon_decode(rs, buffers[1], 255, outBuffers[1]);
-            if (result == -1) {
-                _in->flush();
-                return count;
-            }
-            result = correct_reed_solomon_decode(rs, buffers[2], 255, outBuffers[2]);
-            if (result == -1) {
-                _in->flush();
-                return count;
-            }
-            result = correct_reed_solomon_decode(rs, buffers[3], 255, outBuffers[3]);
-            if (result == -1) {
-                _in->flush();
-                return count;
-            }
-            result = correct_reed_solomon_decode(rs, buffers[4], 255, outBuffers[4]);
-            if (result == -1) {
-                _in->flush();
-                return count;
-            }
-
-            // Reinterleave
-            for (int i = 0; i < 255 * 5; i++) {
-                out.writeBuf[i] = toDB[outBuffers[i % 5][i / 5]] ^ randVals[i % 255];
-            }
-
-            out.swap(255 * 5);
-
-            _in->flush();
-            return count;
-        }
-
-        stream<uint8_t> out;
-
-    private:
-        int count;
-        uint8_t buffers[5][255];
-        uint8_t outBuffers[5][255];
-        correct_reed_solomon* rs;
-
-        stream<uint8_t>* _in;
-    };
-}

core/src/dsp/falcon_packet.h

@@ -1,125 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <inttypes.h>
-
-namespace dsp {
-    struct FalconFrameHeader {
-        uint32_t counter;
-        uint16_t packet;
-    };
-
-    class FalconPacketSync : public generic_block<FalconPacketSync> {
-    public:
-        FalconPacketSync() {}
-
-        FalconPacketSync(stream<uint8_t>* in) { init(in); }
-
-        void init(stream<uint8_t>* in) {
-            _in = in;
-
-            generic_block<FalconPacketSync>::registerInput(_in);
-            generic_block<FalconPacketSync>::registerOutput(&out);
-            generic_block<FalconPacketSync>::_block_init = true;
-        }
-
-        void setInput(stream<uint8_t>* in) {
-            assert(generic_block<FalconPacketSync>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FalconPacketSync>::ctrlMtx);
-            generic_block<FalconPacketSync>::tempStop();
-            generic_block<FalconPacketSync>::unregisterInput(_in);
-            _in = in;
-            generic_block<FalconPacketSync>::registerInput(_in);
-            generic_block<FalconPacketSync>::tempStart();
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            // Parse frame header
-            FalconFrameHeader header;
-            header.packet = (_in->readBuf[3] | ((_in->readBuf[2] & 0b111) << 8));
-            header.counter = ((_in->readBuf[2] >> 3) | (_in->readBuf[1] << 5) | ((_in->readBuf[0] & 0b111111) << 13));
-
-            // Pointer to the data aera of the frame
-            uint8_t* data = _in->readBuf + 4;
-            int dataLen = 1191;
-
-            // If a frame was missed, cancel reading the current packet
-            if (lastCounter + 1 != header.counter) {
-                packetRead = -1;
-            }
-            lastCounter = header.counter;
-
-            // If frame is just a continuation of a single packet, save it
-            // If we're not currently reading a packet
-            if (header.packet == 2047 && packetRead >= 0) {
-                memcpy(packet + packetRead, data, dataLen);
-                packetRead += dataLen;
-                _in->flush();
-                printf("Wow, all data\n");
-                return count;
-            }
-            else if (header.packet == 2047) {
-                printf("Wow, all data\n");
-                _in->flush();
-                return count;
-            }
-
-            // Finish reading the last package and send it
-            if (packetRead >= 0) {
-                memcpy(packet + packetRead, data, header.packet);
-                memcpy(out.writeBuf, packet, packetRead + header.packet);
-                out.swap(packetRead + header.packet);
-                packetRead = -1;
-            }
-
-            // Iterate through every packet of the frame
-            for (int i = header.packet; i < dataLen;) {
-                // First, check if we can read the header. If not, save and wait for next frame
-                if (dataLen - i < 4) {
-                    packetRead = dataLen - i;
-                    memcpy(packet, &data[i], packetRead);
-                    break;
-                }
-
-                // Extract packet length
-                uint16_t length = (((data[i] & 0b1111) << 8) | data[i + 1]) + 2;
-
-                // Check if it's not an invalid zero length packet
-                if (length <= 2) {
-                    packetRead = -1;
-                    break;
-                }
-
-                uint64_t pktId = ((uint64_t)data[i + 2] << 56) | ((uint64_t)data[i + 3] << 48) | ((uint64_t)data[i + 4] << 40) | ((uint64_t)data[i + 5] << 32) | ((uint64_t)data[i + 6] << 24) | ((uint64_t)data[i + 7] << 16) | ((uint64_t)data[i + 8] << 8) | data[i + 9];
-
-                // If the packet doesn't fit the frame, save and go to next frame
-                if (dataLen - i < length) {
-                    packetRead = dataLen - i;
-                    memcpy(packet, &data[i], packetRead);
-                    break;
-                }
-
-                // Here, the package fits fully, read it and jump to the next
-                memcpy(out.writeBuf, &data[i], length);
-                out.swap(length);
-                i += length;
-            }
-
-            _in->flush();
-            return count;
-        }
-
-        stream<uint8_t> out;
-
-    private:
-        int count;
-        uint32_t lastCounter = 0;
-
-        int packetRead = -1;
-        uint8_t packet[0x4008];
-
-        stream<uint8_t>* _in;
-    };
-}

core/src/dsp/filter.h

@@ -1,269 +0,0 @@
-#pragma once
-#include <dsp/block.h>
-#include <dsp/window.h>
-#include <string.h>
-
-namespace dsp {
-
-    template <class T>
-    class FIR : public generic_block<FIR<T>> {
-    public:
-        FIR() {}
-
-        FIR(stream<T>* in, dsp::filter_window::generic_window* window) { init(in, window); }
-
-        ~FIR() {
-            if (!generic_block<FIR<T>>::_block_init) { return; }
-            generic_block<FIR<T>>::stop();
-            volk_free(buffer);
-            volk_free(taps);
-            generic_block<FIR<T>>::_block_init = false;
-        }
-
-        void init(stream<T>* in, dsp::filter_window::generic_window* window) {
-            _in = in;
-
-            tapCount = window->getTapCount();
-            taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
-            window->createTaps(taps, tapCount);
-
-            buffer = (T*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(T) * 2, volk_get_alignment());
-            bufStart = &buffer[tapCount];
-            generic_block<FIR<T>>::registerInput(_in);
-            generic_block<FIR<T>>::registerOutput(&out);
-            generic_block<FIR<T>>::_block_init = true;
-        }
-
-        void setInput(stream<T>* in) {
-            assert(generic_block<FIR<T>>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FIR<T>>::ctrlMtx);
-            generic_block<FIR<T>>::tempStop();
-            generic_block<FIR<T>>::unregisterInput(_in);
-            _in = in;
-            generic_block<FIR<T>>::registerInput(_in);
-            generic_block<FIR<T>>::tempStart();
-        }
-
-        void updateWindow(dsp::filter_window::generic_window* window) {
-            assert(generic_block<FIR<T>>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<FIR<T>>::ctrlMtx);
-            _window = window;
-            volk_free(taps);
-            tapCount = window->getTapCount();
-            taps = (float*)volk_malloc(tapCount * sizeof(float), volk_get_alignment());
-            bufStart = &buffer[tapCount];
-            window->createTaps(taps, tapCount);
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            generic_block<FIR<T>>::ctrlMtx.lock();
-
-            memcpy(bufStart, _in->readBuf, count * sizeof(T));
-            _in->flush();
-
-            if constexpr (std::is_same_v<T, float>) {
-                for (int i = 0; i < count; i++) {
-                    volk_32f_x2_dot_prod_32f((float*)&out.writeBuf[i], (float*)&buffer[i + 1], taps, tapCount);
-                }
-            }
-            if constexpr (std::is_same_v<T, complex_t>) {
-                for (int i = 0; i < count; i++) {
-                    volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&out.writeBuf[i], (lv_32fc_t*)&buffer[i + 1], taps, tapCount);
-                }
-            }
-
-            if (!out.swap(count)) { return -1; }
-
-            memmove(buffer, &buffer[count], tapCount * sizeof(T));
-
-            generic_block<FIR<T>>::ctrlMtx.unlock();
-
-            return count;
-        }
-
-        stream<T> out;
-
-    private:
-        stream<T>* _in;
-
-        dsp::filter_window::generic_window* _window;
-
-        T* bufStart;
-        T* buffer;
-        int tapCount;
-        float* taps;
-    };
-
-    class ComplexFIR : public generic_block<ComplexFIR> {
-    public:
-        ComplexFIR() {}
-
-        ComplexFIR(stream<complex_t>* in, dsp::filter_window::generic_complex_window* window) { init(in, window); }
-
-        ~ComplexFIR() {
-            if (!generic_block<ComplexFIR>::_block_init) { return; }
-            generic_block<ComplexFIR>::stop();
-            volk_free(buffer);
-            volk_free(taps);
-            generic_block<ComplexFIR>::_block_init = false;
-        }
-
-        void init(stream<complex_t>* in, dsp::filter_window::generic_complex_window* window) {
-            _in = in;
-
-            tapCount = window->getTapCount();
-            taps = (complex_t*)volk_malloc(tapCount * sizeof(complex_t), volk_get_alignment());
-            window->createTaps(taps, tapCount);
-
-            buffer = (complex_t*)volk_malloc(STREAM_BUFFER_SIZE * sizeof(complex_t) * 2, volk_get_alignment());
-            bufStart = &buffer[tapCount];
-            generic_block<ComplexFIR>::registerInput(_in);
-            generic_block<ComplexFIR>::registerOutput(&out);
-            generic_block<ComplexFIR>::_block_init = true;
-        }
-
-        void setInput(stream<complex_t>* in) {
-            assert(generic_block<ComplexFIR>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ComplexFIR>::ctrlMtx);
-            generic_block<ComplexFIR>::tempStop();
-            generic_block<ComplexFIR>::unregisterInput(_in);
-            _in = in;
-            generic_block<ComplexFIR>::registerInput(_in);
-            generic_block<ComplexFIR>::tempStart();
-        }
-
-        void updateWindow(dsp::filter_window::generic_complex_window* window) {
-            assert(generic_block<ComplexFIR>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<ComplexFIR>::ctrlMtx);
-            _window = window;
-            volk_free(taps);
-            tapCount = window->getTapCount();
-            taps = (complex_t*)volk_malloc(tapCount * sizeof(complex_t), volk_get_alignment());
-            bufStart = &buffer[tapCount];
-            window->createTaps(taps, tapCount);
-        }
-
-        int run() {
-            int count = _in->read();
-            if (count < 0) { return -1; }
-
-            generic_block<ComplexFIR>::ctrlMtx.lock();
-
-            memcpy(bufStart, _in->readBuf, count * sizeof(complex_t));
-            _in->flush();
-
-            for (int i = 0; i < count; i++) {
-                volk_32fc_x2_dot_prod_32fc((lv_32fc_t*)&out.writeBuf[i], (lv_32fc_t*)&buffer[i + 1], (lv_32fc_t*)taps, tapCount);
-            }
-
-            if (!out.swap(count)) { return -1; }
-
-            memmove(buffer, &buffer[count], tapCount * sizeof(complex_t));
-
-            generic_block<ComplexFIR>::ctrlMtx.unlock();
-
-            return count;
-        }
-
-        stream<complex_t> out;
-
-    private:
-        stream<complex_t>* _in;
-
-        dsp::filter_window::generic_complex_window* _window;
-
-        complex_t* bufStart;
-        complex_t* buffer;
-        int tapCount;
-        complex_t* taps;
-    };
-
-    class BFMDeemp : public generic_block<BFMDeemp> {
-    public:
-        BFMDeemp() {}
-
-        BFMDeemp(stream<stereo_t>* in, float sampleRate, float tau) { init(in, sampleRate, tau); }
-
-        void init(stream<stereo_t>* in, float sampleRate, float tau) {
-            _in = in;
-            _sampleRate = sampleRate;
-            _tau = tau;
-            float dt = 1.0f / _sampleRate;
-            alpha = dt / (_tau + dt);
-            generic_block<BFMDeemp>::registerInput(_in);
-            generic_block<BFMDeemp>::registerOutput(&out);
-            generic_block<BFMDeemp>::_block_init = true;
-        }
-
-        void setInput(stream<stereo_t>* in) {
-            assert(generic_block<BFMDeemp>::_block_init);
-            std::lock_guard<std::mutex> lck(generic_block<BFMDeemp>::ctrlMtx);
-            generic_block<BFMDeemp>::tempStop();
-            generic_block<BFMDeemp>::unregisterInput(_in);
-            _in = in;
-            generic_block<BFMDeemp>::registerInput(_in);
-            generic_block<BFMDeemp>::tempStart();
-        }
-
-        void setSampleRate(float sampleRate) {
-            assert(generic_block<BFMDeemp>::_block_init);
-            _sampleRate = sampleRate;
-            float dt = 1.0f / _sampleRate;
-            alpha = dt / (_tau + dt);
-        }
-
-        void setTau(float tau) {
-            assert(generic_block<BFMDeemp>::_block_init);
-            _tau = tau;
-            float dt = 1.0f / _sampleRate;
-            alpha = dt / (_tau + dt);
-        }
-
-        int run() {
-            count = _in->read();
-            if (count < 0) { return -1; }
-
-            if (bypass) {
-                memcpy(out.writeBuf, _in->readBuf, count * sizeof(stereo_t));
-                _in->flush();
-                if (!out.swap(count)) { return -1; }
-                return count;
-            }
-
-            if (isnan(lastOutL)) {
-                lastOutL = 0.0f;
-            }
-            if (isnan(lastOutR)) {
-                lastOutR = 0.0f;
-            }
-            out.writeBuf[0].l = (alpha * _in->readBuf[0].l) + ((1 - alpha) * lastOutL);
-            out.writeBuf[0].r = (alpha * _in->readBuf[0].r) + ((1 - alpha) * lastOutR);
-            for (int i = 1; i < count; i++) {
-                out.writeBuf[i].l = (alpha * _in->readBuf[i].l) + ((1 - alpha) * out.writeBuf[i - 1].l);
-                out.writeBuf[i].r = (alpha * _in->readBuf[i].r) + ((1 - alpha) * out.writeBuf[i - 1].r);
-            }
-            lastOutL = out.writeBuf[count - 1].l;
-            lastOutR = out.writeBuf[count - 1].r;
-
-            _in->flush();
-            if (!out.swap(count)) { return -1; }
-            return count;
-        }
-
-        bool bypass = false;
-
-        stream<stereo_t> out;
-
-    private:
-        int count;
-        float lastOutL = 0.0f;
-        float lastOutR = 0.0f;
-        float alpha;
-        float _tau;
-        float _sampleRate;
-        stream<stereo_t>* _in;
-    };
-}

core/src/dsp/filter/decimating_fir.h

@@ -0,0 +1,88 @@
+#pragma once
+#include "fir.h"
+
+namespace dsp::filter {
+    template <class D, class T>
+    class DecimatingFIR : public FIR<D, T> {
+        using base_type = FIR<D, T>;
+    public:
+        DecimatingFIR() {}
+
+        DecimatingFIR(stream<D>* in, tap<T>& taps, int decimation) { init(in, taps, decimation); }
+
+        void init(stream<D>* in, tap<T>& taps, int decimation) {
+            _decimation = decimation;
+            base_type::init(in, taps);
+        }
+
+        void setTaps(tap<T>& taps) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            offset = 0;
+            base_type::setTaps(taps);
+            base_type::tempStart();
+        }
+
+        void setDecimation(int decimation) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _decimation = decimation;
+            offset = 0;
+            base_type::tempStart();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            offset = 0;
+            base_type::reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const D* in, D* out) {
+            // Copy data to work buffer
+            memcpy(base_type::bufStart, in, count * sizeof(D));
+
+            // Do convolution
+            int outCount = 0;
+            for (; offset < count; offset += _decimation) {
+                if constexpr (std::is_same_v<D, float> && std::is_same_v<T, float>) {
+                    volk_32f_x2_dot_prod_32f(&out[outCount++], &base_type::buffer[offset], base_type::_taps.taps, base_type::_taps.size);
+                }
+                if constexpr ((std::is_same_v<D, complex_t> || std::is_same_v<D, stereo_t>) && std::is_same_v<T, float>) {
+                    volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&out[outCount++], (lv_32fc_t*)&base_type::buffer[offset], base_type::_taps.taps, base_type::_taps.size);
+                }
+                if constexpr ((std::is_same_v<D, complex_t> || std::is_same_v<D, stereo_t>) && std::is_same_v<T, complex_t>) {
+                    volk_32fc_x2_dot_prod_32fc((lv_32fc_t*)&out[outCount++], (lv_32fc_t*)&base_type::buffer[offset], (lv_32fc_t*)base_type::_taps.taps, base_type::_taps.size);
+                }
+            }
+            offset -= count;
+
+            // Move unused data
+            memmove(base_type::buffer, &base_type::buffer[count], (base_type::_taps.size - 1) * sizeof(D));
+
+            return outCount;
+        }
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            // Swap if some data was generated
+            base_type::_in->flush();
+            if (outCount) {
+                if (!base_type::out.swap(outCount)) { return -1; }
+            }
+            return outCount;
+        }
+
+    protected:
+        int _decimation;
+        int offset = 0;
+    };
+}

core/src/dsp/filter/deephasis.h

@@ -0,0 +1,102 @@
+#pragma once
+#include "../processor.h"
+
+
+namespace dsp::filter {
+    template<class T>
+    class Deemphasis : public Processor<T, T> {
+        using base_type = Processor<T, T>;
+    public:
+        Deemphasis() {}
+
+        Deemphasis(stream<T>* in, double tau, double samplerate) {}
+
+        void init(stream<T>* in, double tau, double samplerate) {
+            _tau = tau;
+            _samplerate = samplerate;
+
+            updateAlpha();
+
+            // Initialize state
+            if constexpr (std::is_same_v<T, float>) {
+                lastOut = 0;
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                lastOut = { 0, 0 };
+            }
+
+            base_type::init(in);
+        }
+
+        void setTau(double tau) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _tau = tau;
+            updateAlpha();
+        }
+
+        void setSamplerate(double samplerate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _samplerate = samplerate;
+            updateAlpha();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            if constexpr (std::is_same_v<T, float>) {
+                lastOut = 0;
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                lastOut = { 0, 0 };
+            }
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const T* in, T* out) {
+            if constexpr (std::is_same_v<T, float>) {
+                out[0] = (alpha * in[0]) + ((1 - alpha) * lastOut);
+                for (int i = 1; i < count; i++) {
+                    out[i] = (alpha * in[i]) + ((1 - alpha) * out[i - 1]);
+                }
+                lastOut = out[count - 1];
+            }
+            if constexpr (std::is_same_v<T, stereo_t>) {
+                out[0].l = (alpha * in[0].l) + ((1 - alpha) * lastOut.l);
+                out[0].r = (alpha * in[0].r) + ((1 - alpha) * lastOut.r);
+                for (int i = 1; i < count; i++) {
+                    out[i].l = (alpha * in[i].l) + ((1 - alpha) * out[i - 1].l);
+                    out[i].r = (alpha * in[i].r) + ((1 - alpha) * out[i - 1].r);
+                }
+                lastOut.l = out[count - 1].l;
+                lastOut.r = out[count - 1].r;
+            }
+            return count;
+        }
+
+        //DEFAULT_PROC_RUN();
+
+        int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    private:
+        void updateAlpha() {
+            float dt = 1.0f / _samplerate;
+            alpha = dt / (_tau + dt);
+        }
+
+        double _tau;
+        double _samplerate;
+
+        float alpha;
+        T lastOut;
+    };
+}

core/src/dsp/filter/fir.h

@@ -0,0 +1,101 @@
+#pragma once
+#include "../processor.h"
+#include "../taps/tap.h"
+
+namespace dsp::filter {
+    template <class D, class T>
+    class FIR : public Processor<D, D> {
+        using base_type = Processor<D, D>;
+    public:
+        FIR() {}
+
+        FIR(stream<D>* in, tap<T>& taps) { init(in, taps); }
+
+        ~FIR() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            buffer::free(buffer);
+        }
+
+        virtual void init(stream<D>* in, tap<T>& taps) {
+            _taps = taps;
+
+            // Allocate and clear buffer
+            buffer = buffer::alloc<D>(STREAM_BUFFER_SIZE + 64000);
+            bufStart = &buffer[_taps.size - 1];
+            buffer::clear<D>(buffer, _taps.size - 1);
+
+            base_type::init(in);
+        }
+
+        virtual void setTaps(tap<T>& taps) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+
+            int oldTC = _taps.size;
+            _taps = taps;
+
+            // Update start of buffer
+            bufStart = &buffer[_taps.size - 1];
+
+            // Move existing data to make transition seemless
+            if (_taps.size < oldTC) {
+                memcpy(buffer, &buffer[oldTC - _taps.size], (_taps.size - 1) * sizeof(D));
+            }
+            else if (_taps.size > oldTC) {
+                memcpy(&buffer[_taps.size - oldTC], buffer, (oldTC - 1) * sizeof(D));
+                buffer::clear<D>(buffer, _taps.size - oldTC);
+            }
+            
+            base_type::tempStart();
+        }
+
+        virtual void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            buffer::clear<D>(buffer, _taps.size - 1);
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const D* in, D* out) {
+            // Copy data to work buffer
+            memcpy(bufStart, in, count * sizeof(D));
+            
+            // Do convolution
+            for (int i = 0; i < count; i++) {
+                if constexpr (std::is_same_v<D, float> && std::is_same_v<T, float>) {
+                    volk_32f_x2_dot_prod_32f(&out[i], &buffer[i], _taps.taps, _taps.size);
+                }
+                if constexpr ((std::is_same_v<D, complex_t> || std::is_same_v<D, stereo_t>) && std::is_same_v<T, float>) {
+                    volk_32fc_32f_dot_prod_32fc((lv_32fc_t*)&out[i], (lv_32fc_t*)&buffer[i], _taps.taps, _taps.size);
+                }
+                if constexpr ((std::is_same_v<D, complex_t> || std::is_same_v<D, stereo_t>) && std::is_same_v<T, complex_t>) {
+                    volk_32fc_x2_dot_prod_32fc((lv_32fc_t*)&out[i], (lv_32fc_t*)&buffer[i], (lv_32fc_t*)_taps.taps, _taps.size);
+                }
+            }
+
+            // Move unused data
+            memmove(buffer, &buffer[count], (_taps.size - 1) * sizeof(D));
+
+            return count;
+        }
+
+        virtual int run() {
+            int count = base_type::_in->read();
+            if (count < 0) { return -1; }
+
+            process(count, base_type::_in->readBuf, base_type::out.writeBuf);
+
+            base_type::_in->flush();
+            if (!base_type::out.swap(count)) { return -1; }
+            return count;
+        }
+
+    protected:
+        tap<T> _taps;
+        D* buffer;
+        D* bufStart;
+    };
+}

core/src/dsp/firdec/firdec_plans.h

@@ -1,208 +0,0 @@
-#pragma once
-#include "taps/fir_2_2.h"
-#include "taps/fir_4_4.h"
-#include "taps/fir_8_4.h"
-#include "taps/fir_16_8.h"
-#include "taps/fir_32_16.h"
-#include "taps/fir_64_32.h"
-#include "taps/fir_128_32.h"
-#include "taps/fir_256_64.h"
-#include "taps/fir_512_128.h"
-#include "taps/fir_1024_128.h"
-#include "taps/fir_2048_128.h"
-
-namespace dsp {
-    namespace firdec {
-        struct stage {
-            unsigned int decimation;
-            unsigned int tapcount;
-            const float* taps;
-        };
-
-        const unsigned int plan_2_len = 1;
-        const stage plan_2[] = {
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_4_len = 1;
-        const stage plan_4[] = {
-            { 4, fir_4_4_len, fir_4_4_taps }
-        };
-
-        const unsigned int plan_8_len = 2;
-        const stage plan_8[] = {
-            { 4, fir_8_4_len, fir_8_4_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_16_len = 2;
-        const stage plan_16[] = {
-            { 8, fir_16_8_len, fir_16_8_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_32_len = 2;
-        const stage plan_32[] = {
-            { 16, fir_32_16_len, fir_32_16_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_64_len = 2;
-        const stage plan_64[] = {
-            { 32, fir_64_32_len, fir_64_32_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_128_len = 2;
-        const stage plan_128[] = {
-            { 32, fir_128_32_len, fir_128_32_taps },
-            { 4, fir_4_4_len, fir_4_4_taps }
-        };
-
-        const unsigned int plan_256_len = 2;
-        const stage plan_256[] = {
-            { 64, fir_256_64_len, fir_256_64_taps },
-            { 4, fir_4_4_len, fir_4_4_taps }
-        };
-
-        const unsigned int plan_512_len = 2;
-        const stage plan_512[] = {
-            { 128, fir_512_128_len, fir_512_128_taps },
-            { 4, fir_4_4_len, fir_4_4_taps }
-        };
-
-        const unsigned int plan_1024_len = 3;
-        const stage plan_1024[] = {
-            { 128, fir_1024_128_len, fir_1024_128_taps },
-            { 4, fir_8_4_len, fir_8_4_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_2048_len = 3;
-        const stage plan_2048[] = {
-            { 128, fir_2048_128_len, fir_2048_128_taps },
-            { 8, fir_16_8_len, fir_16_8_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_4096_len = 3;
-        const stage plan_4096[] = {
-            { 128, fir_2048_128_len, fir_2048_128_taps },
-            { 16, fir_32_16_len, fir_32_16_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        const unsigned int plan_8192_len = 3;
-        const stage plan_8192[] = {
-            { 128, fir_2048_128_len, fir_2048_128_taps },
-            { 32, fir_64_32_len, fir_64_32_taps },
-            { 2, fir_2_2_len, fir_2_2_taps }
-        };
-
-        struct plan {
-            unsigned int stageCount;
-            const stage* stages;
-        };
-
-        const unsigned int plans_len = 13;
-        const plan plans[] {
-            { plan_2_len, plan_2 },
-            { plan_4_len, plan_4 },
-            { plan_8_len, plan_8 },
-            { plan_16_len, plan_16 },
-            { plan_32_len, plan_32 },
-            { plan_64_len, plan_64 },
-            { plan_128_len, plan_128 },
-            { plan_256_len, plan_256 },
-            { plan_512_len, plan_512 },
-            { plan_1024_len, plan_1024 },
-            { plan_2048_len, plan_2048 },
-            { plan_4096_len, plan_4096 },
-            { plan_8192_len, plan_8192 },
-        };
-    }
-}
-
-/*
-
-Desired ratio:  2
-<====== BEST ======>
-Stage  0 :  2 : 2  ( 69  taps)
-<==================>  4.5464  
-
-Desired ratio:  4
-<====== BEST ======>
-Stage  0 :  4 : 4  ( 139  taps)
-<==================>  4.0912  
-
-Desired ratio:  8
-<====== BEST ======>
-Stage  0 :  8 : 4  ( 32  taps)
-Stage  1 :  2 : 2  ( 69  taps)
-<==================>  2.5073
-
-Desired ratio:  16
-<====== BEST ======>
-Stage  0 :  16 : 8  ( 64  taps)
-Stage  1 :  2 : 2  ( 69  taps)
-<==================>  1.417775
-
-Desired ratio:  32
-<====== BEST ======>
-Stage  0 :  32 : 16  ( 128  taps)
-Stage  1 :  2 : 2  ( 69  taps)
-<==================>  0.897
-
-Desired ratio:  64
-<====== BEST ======>
-Stage  0 :  64 : 32  ( 254  taps)
-Stage  1 :  2 : 2  ( 69  taps)
-<==================>  0.6991562499999999
-
-Desired ratio:  128
-<====== BEST ======>
-Stage  0 :  128 : 32  ( 180  taps)
-Stage  1 :  4 : 4  ( 139  taps)
-<==================>  0.61851875
-
-Desired ratio:  256
-<====== BEST ======>
-Stage  0 :  256 : 64  ( 356  taps)
-Stage  1 :  4 : 4  ( 139  taps)
-<==================>  0.4696125
-
-Desired ratio:  512
-<====== BEST ======>
-Stage  0 :  512 : 128  ( 711  taps)
-Stage  1 :  4 : 4  ( 139  taps)
-<==================>  0.38787734375
-
-Desired ratio:  1024
-<====== BEST ======>
-Stage  0 :  1024 : 128  ( 565  taps)
-Stage  1 :  8 : 4  ( 32  taps)
-Stage  2 :  2 : 2  ( 69  taps)
-<==================>  0.30618515625
-
-Desired ratio:  2048
-<====== BEST ======>
-Stage  0 :  2048 : 128  ( 514  taps)
-Stage  1 :  16 : 8  ( 64  taps)
-Stage  2 :  2 : 2  ( 69  taps)
-<==================>  0.2665748046875
-
-Desired ratio:  4096
-<====== BEST ======>
-Stage  0 :  2048 : 128  ( 514  taps)
-Stage  1 :  32 : 16  ( 128  taps)
-Stage  2 :  2 : 2  ( 69  taps)
-<==================>  0.26250625
-
-Desired ratio:  8192
-<====== BEST ======>
-Stage  0 :  2048 : 128  ( 514  taps)
-Stage  1 :  64 : 32  ( 254  taps)
-Stage  2 :  2 : 2  ( 69  taps)
-<==================>  0.260960595703125
-
-*/

core/src/dsp/firdec/taps/fir_1024_128.h

@@ -1,579 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_1024_128_len = 565;
-        const float fir_1024_128_taps[] = {
-            -0.0000004327587f,
-            0.0000026997780f,
-            0.0000011158244f,
-            0.0000009851064f,
-            0.0000010818484f,
-            0.0000012233487f,
-            0.0000013829611f,
-            0.0000015574122f,
-            0.0000017469545f,
-            0.0000019523988f,
-            0.0000021746708f,
-            0.0000024147452f,
-            0.0000026736369f,
-            0.0000029524002f,
-            0.0000032521294f,
-            0.0000035739593f,
-            0.0000039190664f,
-            0.0000042886691f,
-            0.0000046840291f,
-            0.0000051064513f,
-            0.0000055572854f,
-            0.0000060379258f,
-            0.0000065498127f,
-            0.0000070944329f,
-            0.0000076733199f,
-            0.0000082880550f,
-            0.0000089402676f,
-            0.0000096316359f,
-            0.0000103638874f,
-            0.0000111387995f,
-            0.0000119581996f,
-            0.0000128239662f,
-            0.0000137380287f,
-            0.0000147023683f,
-            0.0000157190179f,
-            0.0000167900628f,
-            0.0000179176408f,
-            0.0000191039423f,
-            0.0000203512110f,
-            0.0000216617435f,
-            0.0000230378899f,
-            0.0000244820535f,
-            0.0000259966913f,
-            0.0000275843135f,
-            0.0000292474837f,
-            0.0000309888191f,
-            0.0000328109897f,
-            0.0000347167188f,
-            0.0000367087824f,
-            0.0000387900088f,
-            0.0000409632787f,
-            0.0000432315243f,
-            0.0000455977293f,
-            0.0000480649281f,
-            0.0000506362055f,
-            0.0000533146957f,
-            0.0000561035822f,
-            0.0000590060964f,
-            0.0000620255175f,
-            0.0000651651712f,
-            0.0000684284288f,
-            0.0000718187066f,
-            0.0000753394644f,
-            0.0000789942048f,
-            0.0000827864719f,
-            0.0000867198500f,
-            0.0000907979625f,
-            0.0000950244704f,
-            0.0000994030710f,
-            0.0001039374965f,
-            0.0001086315122f,
-            0.0001134889152f,
-            0.0001185135326f,
-            0.0001237092199f,
-            0.0001290798590f,
-            0.0001346293565f,
-            0.0001403616418f,
-            0.0001462806650f,
-            0.0001523903952f,
-            0.0001586948179f,
-            0.0001651979332f,
-            0.0001719037534f,
-            0.0001788163010f,
-            0.0001859396059f,
-            0.0001932777035f,
-            0.0002008346317f,
-            0.0002086144290f,
-            0.0002166211315f,
-            0.0002248587702f,
-            0.0002333313688f,
-            0.0002420429405f,
-            0.0002509974854f,
-            0.0002601989878f,
-            0.0002696514131f,
-            0.0002793587049f,
-            0.0002893247820f,
-            0.0002995535358f,
-            0.0003100488266f,
-            0.0003208144809f,
-            0.0003318542882f,
-            0.0003431719977f,
-            0.0003547713152f,
-            0.0003666559000f,
-            0.0003788293613f,
-            0.0003912952551f,
-            0.0004040570809f,
-            0.0004171182782f,
-            0.0004304822235f,
-            0.0004441522261f,
-            0.0004581315258f,
-            0.0004724232886f,
-            0.0004870306035f,
-            0.0005019564795f,
-            0.0005172038413f,
-            0.0005327755266f,
-            0.0005486742825f,
-            0.0005649027617f,
-            0.0005814635194f,
-            0.0005983590097f,
-            0.0006155915822f,
-            0.0006331634787f,
-            0.0006510768296f,
-            0.0006693336508f,
-            0.0006879358399f,
-            0.0007068851735f,
-            0.0007261833032f,
-            0.0007458317529f,
-            0.0007658319153f,
-            0.0007861850487f,
-            0.0008068922738f,
-            0.0008279545709f,
-            0.0008493727764f,
-            0.0008711475801f,
-            0.0008932795221f,
-            0.0009157689899f,
-            0.0009386162156f,
-            0.0009618212732f,
-            0.0009853840755f,
-            0.0010093043719f,
-            0.0010335817458f,
-            0.0010582156116f,
-            0.0010832052129f,
-            0.0011085496198f,
-            0.0011342477266f,
-            0.0011602982499f,
-            0.0011866997262f,
-            0.0012134505102f,
-            0.0012405487727f,
-            0.0012679924989f,
-            0.0012957794865f,
-            0.0013239073445f,
-            0.0013523734912f,
-            0.0013811751533f,
-            0.0014103093644f,
-            0.0014397729637f,
-            0.0014695625952f,
-            0.0014996747065f,
-            0.0015301055485f,
-            0.0015608511740f,
-            0.0015919074376f,
-            0.0016232699954f,
-            0.0016549343039f,
-            0.0016868956210f,
-            0.0017191490046f,
-            0.0017516893140f,
-            0.0017845112089f,
-            0.0018176091508f,
-            0.0018509774026f,
-            0.0018846100298f,
-            0.0019185009010f,
-            0.0019526436887f,
-            0.0019870318707f,
-            0.0020216587307f,
-            0.0020565173602f,
-            0.0020916006596f,
-            0.0021269013399f,
-            0.0021624119242f,
-            0.0021981247499f,
-            0.0022340319707f,
-            0.0022701255585f,
-            0.0023063973058f,
-            0.0023428388283f,
-            0.0023794415672f,
-            0.0024161967921f,
-            0.0024530956039f,
-            0.0024901289377f,
-            0.0025272875658f,
-            0.0025645621012f,
-            0.0026019430011f,
-            0.0026394205698f,
-            0.0026769849632f,
-            0.0027146261921f,
-            0.0027523341262f,
-            0.0027900984982f,
-            0.0028279089079f,
-            0.0028657548267f,
-            0.0029036256018f,
-            0.0029415104608f,
-            0.0029793985165f,
-            0.0030172787713f,
-            0.0030551401225f,
-            0.0030929713673f,
-            0.0031307612072f,
-            0.0031684982542f,
-            0.0032061710353f,
-            0.0032437679982f,
-            0.0032812775168f,
-            0.0033186878969f,
-            0.0033559873813f,
-            0.0033931641562f,
-            0.0034302063567f,
-            0.0034671020727f,
-            0.0035038393549f,
-            0.0035404062207f,
-            0.0035767906605f,
-            0.0036129806440f,
-            0.0036489641257f,
-            0.0036847290520f,
-            0.0037202633668f,
-            0.0037555550186f,
-            0.0037905919660f,
-            0.0038253621849f,
-            0.0038598536743f,
-            0.0038940544635f,
-            0.0039279526178f,
-            0.0039615362454f,
-            0.0039947935041f,
-            0.0040277126075f,
-            0.0040602818315f,
-            0.0040924895211f,
-            0.0041243240966f,
-            0.0041557740604f,
-            0.0041868280032f,
-            0.0042174746106f,
-            0.0042477026695f,
-            0.0042775010745f,
-            0.0043068588342f,
-            0.0043357650775f,
-            0.0043642090601f,
-            0.0043921801703f,
-            0.0044196679357f,
-            0.0044466620287f,
-            0.0044731522730f,
-            0.0044991286493f,
-            0.0045245813014f,
-            0.0045495005417f,
-            0.0045738768574f,
-            0.0045977009155f,
-            0.0046209635689f,
-            0.0046436558617f,
-            0.0046657690344f,
-            0.0046872945291f,
-            0.0047082239951f,
-            0.0047285492933f,
-            0.0047482625015f,
-            0.0047673559190f,
-            0.0047858220715f,
-            0.0048036537152f,
-            0.0048208438417f,
-            0.0048373856818f,
-            0.0048532727100f,
-            0.0048684986482f,
-            0.0048830574697f,
-            0.0048969434029f,
-            0.0049101509346f,
-            0.0049226748137f,
-            0.0049345100543f,
-            0.0049456519385f,
-            0.0049560960197f,
-            0.0049658381254f,
-            0.0049748743591f,
-            0.0049832011036f,
-            0.0049908150224f,
-            0.0049977130625f,
-            0.0050038924557f,
-            0.0050093507207f,
-            0.0050140856644f,
-            0.0050180953834f,
-            0.0050213782651f,
-            0.0050239329888f,
-            0.0050257585263f,
-            0.0050268541429f,
-            0.0050272193974f,
-            0.0050268541429f,
-            0.0050257585263f,
-            0.0050239329888f,
-            0.0050213782651f,
-            0.0050180953834f,
-            0.0050140856644f,
-            0.0050093507207f,
-            0.0050038924557f,
-            0.0049977130625f,
-            0.0049908150224f,
-            0.0049832011036f,
-            0.0049748743591f,
-            0.0049658381254f,
-            0.0049560960197f,
-            0.0049456519385f,
-            0.0049345100543f,
-            0.0049226748137f,
-            0.0049101509346f,
-            0.0048969434029f,
-            0.0048830574697f,
-            0.0048684986482f,
-            0.0048532727100f,
-            0.0048373856818f,
-            0.0048208438417f,
-            0.0048036537152f,
-            0.0047858220715f,
-            0.0047673559190f,
-            0.0047482625015f,
-            0.0047285492933f,
-            0.0047082239951f,
-            0.0046872945291f,
-            0.0046657690344f,
-            0.0046436558617f,
-            0.0046209635689f,
-            0.0045977009155f,
-            0.0045738768574f,
-            0.0045495005417f,
-            0.0045245813014f,
-            0.0044991286493f,
-            0.0044731522730f,
-            0.0044466620287f,
-            0.0044196679357f,
-            0.0043921801703f,
-            0.0043642090601f,
-            0.0043357650775f,
-            0.0043068588342f,
-            0.0042775010745f,
-            0.0042477026695f,
-            0.0042174746106f,
-            0.0041868280032f,
-            0.0041557740604f,
-            0.0041243240966f,
-            0.0040924895211f,
-            0.0040602818315f,
-            0.0040277126075f,
-            0.0039947935041f,
-            0.0039615362454f,
-            0.0039279526178f,
-            0.0038940544635f,
-            0.0038598536743f,
-            0.0038253621849f,
-            0.0037905919660f,
-            0.0037555550186f,
-            0.0037202633668f,
-            0.0036847290520f,
-            0.0036489641257f,
-            0.0036129806440f,
-            0.0035767906605f,
-            0.0035404062207f,
-            0.0035038393549f,
-            0.0034671020727f,
-            0.0034302063567f,
-            0.0033931641562f,
-            0.0033559873813f,
-            0.0033186878969f,
-            0.0032812775168f,
-            0.0032437679982f,
-            0.0032061710353f,
-            0.0031684982542f,
-            0.0031307612072f,
-            0.0030929713673f,
-            0.0030551401225f,
-            0.0030172787713f,
-            0.0029793985165f,
-            0.0029415104608f,
-            0.0029036256018f,
-            0.0028657548267f,
-            0.0028279089079f,
-            0.0027900984982f,
-            0.0027523341262f,
-            0.0027146261921f,
-            0.0026769849632f,
-            0.0026394205698f,
-            0.0026019430011f,
-            0.0025645621012f,
-            0.0025272875658f,
-            0.0024901289377f,
-            0.0024530956039f,
-            0.0024161967921f,
-            0.0023794415672f,
-            0.0023428388283f,
-            0.0023063973058f,
-            0.0022701255585f,
-            0.0022340319707f,
-            0.0021981247499f,
-            0.0021624119242f,
-            0.0021269013399f,
-            0.0020916006596f,
-            0.0020565173602f,
-            0.0020216587307f,
-            0.0019870318707f,
-            0.0019526436887f,
-            0.0019185009010f,
-            0.0018846100298f,
-            0.0018509774026f,
-            0.0018176091508f,
-            0.0017845112089f,
-            0.0017516893140f,
-            0.0017191490046f,
-            0.0016868956210f,
-            0.0016549343039f,
-            0.0016232699954f,
-            0.0015919074376f,
-            0.0015608511740f,
-            0.0015301055485f,
-            0.0014996747065f,
-            0.0014695625952f,
-            0.0014397729637f,
-            0.0014103093644f,
-            0.0013811751533f,
-            0.0013523734912f,
-            0.0013239073445f,
-            0.0012957794865f,
-            0.0012679924989f,
-            0.0012405487727f,
-            0.0012134505102f,
-            0.0011866997262f,
-            0.0011602982499f,
-            0.0011342477266f,
-            0.0011085496198f,
-            0.0010832052129f,
-            0.0010582156116f,
-            0.0010335817458f,
-            0.0010093043719f,
-            0.0009853840755f,
-            0.0009618212732f,
-            0.0009386162156f,
-            0.0009157689899f,
-            0.0008932795221f,
-            0.0008711475801f,
-            0.0008493727764f,
-            0.0008279545709f,
-            0.0008068922738f,
-            0.0007861850487f,
-            0.0007658319153f,
-            0.0007458317529f,
-            0.0007261833032f,
-            0.0007068851735f,
-            0.0006879358399f,
-            0.0006693336508f,
-            0.0006510768296f,
-            0.0006331634787f,
-            0.0006155915822f,
-            0.0005983590097f,
-            0.0005814635194f,
-            0.0005649027617f,
-            0.0005486742825f,
-            0.0005327755266f,
-            0.0005172038413f,
-            0.0005019564795f,
-            0.0004870306035f,
-            0.0004724232886f,
-            0.0004581315258f,
-            0.0004441522261f,
-            0.0004304822235f,
-            0.0004171182782f,
-            0.0004040570809f,
-            0.0003912952551f,
-            0.0003788293613f,
-            0.0003666559000f,
-            0.0003547713152f,
-            0.0003431719977f,
-            0.0003318542882f,
-            0.0003208144809f,
-            0.0003100488266f,
-            0.0002995535358f,
-            0.0002893247820f,
-            0.0002793587049f,
-            0.0002696514131f,
-            0.0002601989878f,
-            0.0002509974854f,
-            0.0002420429405f,
-            0.0002333313688f,
-            0.0002248587702f,
-            0.0002166211315f,
-            0.0002086144290f,
-            0.0002008346317f,
-            0.0001932777035f,
-            0.0001859396059f,
-            0.0001788163010f,
-            0.0001719037534f,
-            0.0001651979332f,
-            0.0001586948179f,
-            0.0001523903952f,
-            0.0001462806650f,
-            0.0001403616418f,
-            0.0001346293565f,
-            0.0001290798590f,
-            0.0001237092199f,
-            0.0001185135326f,
-            0.0001134889152f,
-            0.0001086315122f,
-            0.0001039374965f,
-            0.0000994030710f,
-            0.0000950244704f,
-            0.0000907979625f,
-            0.0000867198500f,
-            0.0000827864719f,
-            0.0000789942048f,
-            0.0000753394644f,
-            0.0000718187066f,
-            0.0000684284288f,
-            0.0000651651712f,
-            0.0000620255175f,
-            0.0000590060964f,
-            0.0000561035822f,
-            0.0000533146957f,
-            0.0000506362055f,
-            0.0000480649281f,
-            0.0000455977293f,
-            0.0000432315243f,
-            0.0000409632787f,
-            0.0000387900088f,
-            0.0000367087824f,
-            0.0000347167188f,
-            0.0000328109897f,
-            0.0000309888191f,
-            0.0000292474837f,
-            0.0000275843135f,
-            0.0000259966913f,
-            0.0000244820535f,
-            0.0000230378899f,
-            0.0000216617435f,
-            0.0000203512110f,
-            0.0000191039423f,
-            0.0000179176408f,
-            0.0000167900628f,
-            0.0000157190179f,
-            0.0000147023683f,
-            0.0000137380287f,
-            0.0000128239662f,
-            0.0000119581996f,
-            0.0000111387995f,
-            0.0000103638874f,
-            0.0000096316359f,
-            0.0000089402676f,
-            0.0000082880550f,
-            0.0000076733199f,
-            0.0000070944329f,
-            0.0000065498127f,
-            0.0000060379258f,
-            0.0000055572854f,
-            0.0000051064513f,
-            0.0000046840291f,
-            0.0000042886691f,
-            0.0000039190664f,
-            0.0000035739593f,
-            0.0000032521294f,
-            0.0000029524002f,
-            0.0000026736369f,
-            0.0000024147452f,
-            0.0000021746708f,
-            0.0000019523988f,
-            0.0000017469545f,
-            0.0000015574122f,
-            0.0000013829611f,
-            0.0000012233487f,
-            0.0000010818484f,
-            0.0000009851064f,
-            0.0000011158244f,
-            0.0000026997780f,
-            -0.0000004327587f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_1024_32.h

@@ -1,141 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_1024_32_len = 127;
-        const float fir_1024_32_taps[] = {
-            0.0000088623347f,
-            0.0000103966907f,
-            0.0000163498386f,
-            0.0000244235766f,
-            0.0000351129776f,
-            0.0000489833599f,
-            0.0000666735323f,
-            0.0000888982223f,
-            0.0001164495403f,
-            0.0001501973386f,
-            0.0001910883324f,
-            0.0002401438579f,
-            0.0002984561609f,
-            0.0003671831240f,
-            0.0004475413632f,
-            0.0005407976486f,
-            0.0006482586323f,
-            0.0007712588932f,
-            0.0009111473429f,
-            0.0010692720689f,
-            0.0012469637247f,
-            0.0014455176106f,
-            0.0016661746238f,
-            0.0019101012879f,
-            0.0021783691022f,
-            0.0024719334814f,
-            0.0027916125787f,
-            0.0031380663077f,
-            0.0035117758952f,
-            0.0039130243058f,
-            0.0043418778893f,
-            0.0047981695968f,
-            0.0052814841081f,
-            0.0057911451996f,
-            0.0063262056615f,
-            0.0068854400478f,
-            0.0074673405131f,
-            0.0080701159494f,
-            0.0086916945938f,
-            0.0093297302355f,
-            0.0099816120904f,
-            0.0106444783655f,
-            0.0113152334735f,
-            0.0119905688011f,
-            0.0126669868781f,
-            0.0133408287327f,
-            0.0140083041674f,
-            0.0146655246349f,
-            0.0153085383440f,
-            0.0159333671827f,
-            0.0165360450080f,
-            0.0171126568203f,
-            0.0176593783140f,
-            0.0181725152845f,
-            0.0186485423586f,
-            0.0190841405193f,
-            0.0194762329058f,
-            0.0198220183835f,
-            0.0201190024112f,
-            0.0203650247621f,
-            0.0205582836996f,
-            0.0206973562585f,
-            0.0207812143359f,
-            0.0208092363555f,
-            0.0207812143359f,
-            0.0206973562585f,
-            0.0205582836996f,
-            0.0203650247621f,
-            0.0201190024112f,
-            0.0198220183835f,
-            0.0194762329058f,
-            0.0190841405193f,
-            0.0186485423586f,
-            0.0181725152845f,
-            0.0176593783140f,
-            0.0171126568203f,
-            0.0165360450080f,
-            0.0159333671827f,
-            0.0153085383440f,
-            0.0146655246349f,
-            0.0140083041674f,
-            0.0133408287327f,
-            0.0126669868781f,
-            0.0119905688011f,
-            0.0113152334735f,
-            0.0106444783655f,
-            0.0099816120904f,
-            0.0093297302355f,
-            0.0086916945938f,
-            0.0080701159494f,
-            0.0074673405131f,
-            0.0068854400478f,
-            0.0063262056615f,
-            0.0057911451996f,
-            0.0052814841081f,
-            0.0047981695968f,
-            0.0043418778893f,
-            0.0039130243058f,
-            0.0035117758952f,
-            0.0031380663077f,
-            0.0027916125787f,
-            0.0024719334814f,
-            0.0021783691022f,
-            0.0019101012879f,
-            0.0016661746238f,
-            0.0014455176106f,
-            0.0012469637247f,
-            0.0010692720689f,
-            0.0009111473429f,
-            0.0007712588932f,
-            0.0006482586323f,
-            0.0005407976486f,
-            0.0004475413632f,
-            0.0003671831240f,
-            0.0002984561609f,
-            0.0002401438579f,
-            0.0001910883324f,
-            0.0001501973386f,
-            0.0001164495403f,
-            0.0000888982223f,
-            0.0000666735323f,
-            0.0000489833599f,
-            0.0000351129776f,
-            0.0000244235766f,
-            0.0000163498386f,
-            0.0000103966907f,
-            0.0000088623347f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_1024_64.h

@@ -1,319 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_1024_64_len = 305;
-        const float fir_1024_64_taps[] = {
-            -0.0000003266961f,
-            0.0000005644686f,
-            0.0000005207559f,
-            0.0000006201056f,
-            0.0000007969193f,
-            0.0000010314179f,
-            0.0000013207983f,
-            0.0000016688347f,
-            0.0000020821477f,
-            0.0000025688841f,
-            0.0000031382689f,
-            0.0000038004715f,
-            0.0000045665874f,
-            0.0000054486602f,
-            0.0000064597188f,
-            0.0000076138203f,
-            0.0000089260936f,
-            0.0000104127838f,
-            0.0000120912955f,
-            0.0000139802356f,
-            0.0000160994544f,
-            0.0000184700853f,
-            0.0000211145831f,
-            0.0000240567590f,
-            0.0000273218150f,
-            0.0000309363737f,
-            0.0000349285069f,
-            0.0000393277598f,
-            0.0000441651722f,
-            0.0000494732958f,
-            0.0000552862073f,
-            0.0000616395176f,
-            0.0000685703757f,
-            0.0000761174680f,
-            0.0000843210124f,
-            0.0000932227473f,
-            0.0001028659142f,
-            0.0001132952349f,
-            0.0001245568823f,
-            0.0001366984450f,
-            0.0001497688854f,
-            0.0001638184908f,
-            0.0001788988175f,
-            0.0001950626288f,
-            0.0002123638243f,
-            0.0002308573636f,
-            0.0002505991815f,
-            0.0002716460964f,
-            0.0002940557114f,
-            0.0003178863073f,
-            0.0003431967298f,
-            0.0003700462674f,
-            0.0003984945244f,
-            0.0004286012850f,
-            0.0004604263715f,
-            0.0004940294961f,
-            0.0005294701054f,
-            0.0005668072195f,
-            0.0006060992649f,
-            0.0006474039021f,
-            0.0006907778476f,
-            0.0007362766917f,
-            0.0007839547115f,
-            0.0008338646804f,
-            0.0008860576734f,
-            0.0009405828709f,
-            0.0009974873584f,
-            0.0010568159258f,
-            0.0011186108652f,
-            0.0011829117671f,
-            0.0012497553185f,
-            0.0013191750998f,
-            0.0013912013845f,
-            0.0014658609399f,
-            0.0015431768319f,
-            0.0016231682316f,
-            0.0017058502277f,
-            0.0017912336426f,
-            0.0018793248552f,
-            0.0019701256291f,
-            0.0020636329490f,
-            0.0021598388638f,
-            0.0022587303394f,
-            0.0023602891198f,
-            0.0024644915987f,
-            0.0025713087020f,
-            0.0026807057805f,
-            0.0027926425160f,
-            0.0029070728383f,
-            0.0030239448570f,
-            0.0031432008054f,
-            0.0032647769995f,
-            0.0033886038113f,
-            0.0035146056570f,
-            0.0036427010010f,
-            0.0037728023754f,
-            0.0039048164157f,
-            0.0040386439125f,
-            0.0041741798805f,
-            0.0043113136430f,
-            0.0044499289348f,
-            0.0045899040199f,
-            0.0047311118279f,
-            0.0048734201058f,
-            0.0050166915869f,
-            0.0051607841763f,
-            0.0053055511521f,
-            0.0054508413827f,
-            0.0055964995596f,
-            0.0057423664451f,
-            0.0058882791347f,
-            0.0060340713337f,
-            0.0061795736469f,
-            0.0063246138814f,
-            0.0064690173614f,
-            0.0066126072545f,
-            0.0067552049086f,
-            0.0068966301982f,
-            0.0070367018801f,
-            0.0071752379566f,
-            0.0073120560462f,
-            0.0074469737596f,
-            0.0075798090815f,
-            0.0077103807554f,
-            0.0078385086722f,
-            0.0079640142599f,
-            0.0080867208743f,
-            0.0082064541886f,
-            0.0083230425826f,
-            0.0084363175276f,
-            0.0085461139687f,
-            0.0086522707012f,
-            0.0087546307414f,
-            0.0088530416894f,
-            0.0089473560847f,
-            0.0090374317506f,
-            0.0091231321298f,
-            0.0092043266071f,
-            0.0092808908203f,
-            0.0093527069569f,
-            0.0094196640373f,
-            0.0094816581810f,
-            0.0095385928587f,
-            0.0095903791253f,
-            0.0096369358365f,
-            0.0096781898465f,
-            0.0097140761868f,
-            0.0097445382248f,
-            0.0097695278031f,
-            0.0097890053575f,
-            0.0098029400143f,
-            0.0098113096665f,
-            0.0098141010281f,
-            0.0098113096665f,
-            0.0098029400143f,
-            0.0097890053575f,
-            0.0097695278031f,
-            0.0097445382248f,
-            0.0097140761868f,
-            0.0096781898465f,
-            0.0096369358365f,
-            0.0095903791253f,
-            0.0095385928587f,
-            0.0094816581810f,
-            0.0094196640373f,
-            0.0093527069569f,
-            0.0092808908203f,
-            0.0092043266071f,
-            0.0091231321298f,
-            0.0090374317506f,
-            0.0089473560847f,
-            0.0088530416894f,
-            0.0087546307414f,
-            0.0086522707012f,
-            0.0085461139687f,
-            0.0084363175276f,
-            0.0083230425826f,
-            0.0082064541886f,
-            0.0080867208743f,
-            0.0079640142599f,
-            0.0078385086722f,
-            0.0077103807554f,
-            0.0075798090815f,
-            0.0074469737596f,
-            0.0073120560462f,
-            0.0071752379566f,
-            0.0070367018801f,
-            0.0068966301982f,
-            0.0067552049086f,
-            0.0066126072545f,
-            0.0064690173614f,
-            0.0063246138814f,
-            0.0061795736469f,
-            0.0060340713337f,
-            0.0058882791347f,
-            0.0057423664451f,
-            0.0055964995596f,
-            0.0054508413827f,
-            0.0053055511521f,
-            0.0051607841763f,
-            0.0050166915869f,
-            0.0048734201058f,
-            0.0047311118279f,
-            0.0045899040199f,
-            0.0044499289348f,
-            0.0043113136430f,
-            0.0041741798805f,
-            0.0040386439125f,
-            0.0039048164157f,
-            0.0037728023754f,
-            0.0036427010010f,
-            0.0035146056570f,
-            0.0033886038113f,
-            0.0032647769995f,
-            0.0031432008054f,
-            0.0030239448570f,
-            0.0029070728383f,
-            0.0027926425160f,
-            0.0026807057805f,
-            0.0025713087020f,
-            0.0024644915987f,
-            0.0023602891198f,
-            0.0022587303394f,
-            0.0021598388638f,
-            0.0020636329490f,
-            0.0019701256291f,
-            0.0018793248552f,
-            0.0017912336426f,
-            0.0017058502277f,
-            0.0016231682316f,
-            0.0015431768319f,
-            0.0014658609399f,
-            0.0013912013845f,
-            0.0013191750998f,
-            0.0012497553185f,
-            0.0011829117671f,
-            0.0011186108652f,
-            0.0010568159258f,
-            0.0009974873584f,
-            0.0009405828709f,
-            0.0008860576734f,
-            0.0008338646804f,
-            0.0007839547115f,
-            0.0007362766917f,
-            0.0006907778476f,
-            0.0006474039021f,
-            0.0006060992649f,
-            0.0005668072195f,
-            0.0005294701054f,
-            0.0004940294961f,
-            0.0004604263715f,
-            0.0004286012850f,
-            0.0003984945244f,
-            0.0003700462674f,
-            0.0003431967298f,
-            0.0003178863073f,
-            0.0002940557114f,
-            0.0002716460964f,
-            0.0002505991815f,
-            0.0002308573636f,
-            0.0002123638243f,
-            0.0001950626288f,
-            0.0001788988175f,
-            0.0001638184908f,
-            0.0001497688854f,
-            0.0001366984450f,
-            0.0001245568823f,
-            0.0001132952349f,
-            0.0001028659142f,
-            0.0000932227473f,
-            0.0000843210124f,
-            0.0000761174680f,
-            0.0000685703757f,
-            0.0000616395176f,
-            0.0000552862073f,
-            0.0000494732958f,
-            0.0000441651722f,
-            0.0000393277598f,
-            0.0000349285069f,
-            0.0000309363737f,
-            0.0000273218150f,
-            0.0000240567590f,
-            0.0000211145831f,
-            0.0000184700853f,
-            0.0000160994544f,
-            0.0000139802356f,
-            0.0000120912955f,
-            0.0000104127838f,
-            0.0000089260936f,
-            0.0000076138203f,
-            0.0000064597188f,
-            0.0000054486602f,
-            0.0000045665874f,
-            0.0000038004715f,
-            0.0000031382689f,
-            0.0000025688841f,
-            0.0000020821477f,
-            0.0000016688347f,
-            0.0000013207983f,
-            0.0000010314179f,
-            0.0000007969193f,
-            0.0000006201056f,
-            0.0000005207559f,
-            0.0000005644686f,
-            -0.0000003266961f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_128_16.h

@@ -1,85 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_128_16_len = 71;
-        const float fir_128_16_taps[] = {
-            0.0000064694540f,
-            0.0000182067578f,
-            0.0000368085722f,
-            0.0000719935366f,
-            0.0001252867548f,
-            0.0002081925226f,
-            0.0003273131837f,
-            0.0004962053053f,
-            0.0007259672049f,
-            0.0010324295967f,
-            0.0014300214273f,
-            0.0019359256876f,
-            0.0025658768245f,
-            0.0033363360449f,
-            0.0042614372892f,
-            0.0053539132757f,
-            0.0066227902827f,
-            0.0080736193595f,
-            0.0097067738877f,
-            0.0115174330954f,
-            0.0134944842883f,
-            0.0156206149876f,
-            0.0178718768069f,
-            0.0202181371097f,
-            0.0226233377697f,
-            0.0250464274976f,
-            0.0274422678072f,
-            0.0297630224211f,
-            0.0319595549880f,
-            0.0339831151557f,
-            0.0357869729439f,
-            0.0373281403598f,
-            0.0385689282047f,
-            0.0394784014454f,
-            0.0400335473450f,
-            0.0402201936432f,
-            0.0400335473450f,
-            0.0394784014454f,
-            0.0385689282047f,
-            0.0373281403598f,
-            0.0357869729439f,
-            0.0339831151557f,
-            0.0319595549880f,
-            0.0297630224211f,
-            0.0274422678072f,
-            0.0250464274976f,
-            0.0226233377697f,
-            0.0202181371097f,
-            0.0178718768069f,
-            0.0156206149876f,
-            0.0134944842883f,
-            0.0115174330954f,
-            0.0097067738877f,
-            0.0080736193595f,
-            0.0066227902827f,
-            0.0053539132757f,
-            0.0042614372892f,
-            0.0033363360449f,
-            0.0025658768245f,
-            0.0019359256876f,
-            0.0014300214273f,
-            0.0010324295967f,
-            0.0007259672049f,
-            0.0004962053053f,
-            0.0003273131837f,
-            0.0002081925226f,
-            0.0001252867548f,
-            0.0000719935366f,
-            0.0000368085722f,
-            0.0000182067578f,
-            0.0000064694540f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_128_32.h

@@ -1,194 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_128_32_len = 180;
-        const float fir_128_32_taps[] = {
-            -0.0000073470522f,
-            -0.0000069110271f,
-            -0.0000100675012f,
-            -0.0000140912235f,
-            -0.0000191269472f,
-            -0.0000253238429f,
-            -0.0000328428415f,
-            -0.0000418456044f,
-            -0.0000525009779f,
-            -0.0000649731010f,
-            -0.0000794269134f,
-            -0.0000960153923f,
-            -0.0001148841160f,
-            -0.0001361576878f,
-            -0.0001599434282f,
-            -0.0001863171187f,
-            -0.0002153259738f,
-            -0.0002469739186f,
-            -0.0002812240728f,
-            -0.0003179838558f,
-            -0.0003571072928f,
-            -0.0003983803151f,
-            -0.0004415232676f,
-            -0.0004861768325f,
-            -0.0005319051695f,
-            -0.0005781829346f,
-            -0.0006243995153f,
-            -0.0006698476317f,
-            -0.0007137291329f,
-            -0.0007551456568f,
-            -0.0007931064250f,
-            -0.0008265213926f,
-            -0.0008542114175f,
-            -0.0008749042532f,
-            -0.0008872473744f,
-            -0.0008898070530f,
-            -0.0008810839958f,
-            -0.0008595156045f,
-            -0.0008234944283f,
-            -0.0007713735444f,
-            -0.0007014876566f,
-            -0.0006121613543f,
-            -0.0005017325051f,
-            -0.0003685629664f,
-            -0.0002110637384f,
-            -0.0000277075239f,
-            0.0001829450626f,
-            0.0004222318502f,
-            0.0006913626978f,
-            0.0009914056595f,
-            0.0013232613264f,
-            0.0016876497890f,
-            0.0020850867621f,
-            0.0025158723705f,
-            0.0029800700983f,
-            0.0034774984108f,
-            0.0040077135249f,
-            0.0045700048063f,
-            0.0051633822546f,
-            0.0057865764825f,
-            0.0064380316487f,
-            0.0071159106399f,
-            0.0078180939705f,
-            0.0085421905540f,
-            0.0092855428368f,
-            0.0100452432731f,
-            0.0108181456753f,
-            0.0116008872163f,
-            0.0123899056779f,
-            0.0131814665052f,
-            0.0139716853391f,
-            0.0147565593567f,
-            0.0155319941959f,
-            0.0162938385551f,
-            0.0170379143753f,
-            0.0177600534535f,
-            0.0184561295564f,
-            0.0191220956422f,
-            0.0197540164501f,
-            0.0203481048339f,
-            0.0209007533176f,
-            0.0214085680250f,
-            0.0218683977139f,
-            0.0222773638505f,
-            0.0226328857338f,
-            0.0229327054015f,
-            0.0231749076307f,
-            0.0233579385724f,
-            0.0234806196554f,
-            0.0235421591137f,
-            0.0235421591137f,
-            0.0234806196554f,
-            0.0233579385724f,
-            0.0231749076307f,
-            0.0229327054015f,
-            0.0226328857338f,
-            0.0222773638505f,
-            0.0218683977139f,
-            0.0214085680250f,
-            0.0209007533176f,
-            0.0203481048339f,
-            0.0197540164501f,
-            0.0191220956422f,
-            0.0184561295564f,
-            0.0177600534535f,
-            0.0170379143753f,
-            0.0162938385551f,
-            0.0155319941959f,
-            0.0147565593567f,
-            0.0139716853391f,
-            0.0131814665052f,
-            0.0123899056779f,
-            0.0116008872163f,
-            0.0108181456753f,
-            0.0100452432731f,
-            0.0092855428368f,
-            0.0085421905540f,
-            0.0078180939705f,
-            0.0071159106399f,
-            0.0064380316487f,
-            0.0057865764825f,
-            0.0051633822546f,
-            0.0045700048063f,
-            0.0040077135249f,
-            0.0034774984108f,
-            0.0029800700983f,
-            0.0025158723705f,
-            0.0020850867621f,
-            0.0016876497890f,
-            0.0013232613264f,
-            0.0009914056595f,
-            0.0006913626978f,
-            0.0004222318502f,
-            0.0001829450626f,
-            -0.0000277075239f,
-            -0.0002110637384f,
-            -0.0003685629664f,
-            -0.0005017325051f,
-            -0.0006121613543f,
-            -0.0007014876566f,
-            -0.0007713735444f,
-            -0.0008234944283f,
-            -0.0008595156045f,
-            -0.0008810839958f,
-            -0.0008898070530f,
-            -0.0008872473744f,
-            -0.0008749042532f,
-            -0.0008542114175f,
-            -0.0008265213926f,
-            -0.0007931064250f,
-            -0.0007551456568f,
-            -0.0007137291329f,
-            -0.0006698476317f,
-            -0.0006243995153f,
-            -0.0005781829346f,
-            -0.0005319051695f,
-            -0.0004861768325f,
-            -0.0004415232676f,
-            -0.0003983803151f,
-            -0.0003571072928f,
-            -0.0003179838558f,
-            -0.0002812240728f,
-            -0.0002469739186f,
-            -0.0002153259738f,
-            -0.0001863171187f,
-            -0.0001599434282f,
-            -0.0001361576878f,
-            -0.0001148841160f,
-            -0.0000960153923f,
-            -0.0000794269134f,
-            -0.0000649731010f,
-            -0.0000525009779f,
-            -0.0000418456044f,
-            -0.0000328428415f,
-            -0.0000253238429f,
-            -0.0000191269472f,
-            -0.0000140912235f,
-            -0.0000100675012f,
-            -0.0000069110271f,
-            -0.0000073470522f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_128_4.h

@@ -1,30 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_128_4_len = 16;
-        const float fir_128_4_taps[] = {
-            0.0003502294673f,
-            0.0025622621714f,
-            0.0100604175711f,
-            0.0274832811630f,
-            0.0576540582560f,
-            0.0975667617613f,
-            0.1368722747794f,
-            0.1615718864375f,
-            0.1615718864375f,
-            0.1368722747794f,
-            0.0975667617613f,
-            0.0576540582560f,
-            0.0274832811630f,
-            0.0100604175711f,
-            0.0025622621714f,
-            0.0003502294673f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_128_64.h

@@ -1,521 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_128_64_len = 507;
-        const float fir_128_64_taps[] = {
-            0.0000059328143f,
-            0.0000021865747f,
-            0.0000025830027f,
-            0.0000030222125f,
-            0.0000035067628f,
-            0.0000040392284f,
-            0.0000046221895f,
-            0.0000052582199f,
-            0.0000059498747f,
-            0.0000066996765f,
-            0.0000075101016f,
-            0.0000083835652f,
-            0.0000093224054f,
-            0.0000103288670f,
-            0.0000114050841f,
-            0.0000125530626f,
-            0.0000137746613f,
-            0.0000150715728f,
-            0.0000164453038f,
-            0.0000178971548f,
-            0.0000194281990f,
-            0.0000210392611f,
-            0.0000227308957f,
-            0.0000245033648f,
-            0.0000263566159f,
-            0.0000282902593f,
-            0.0000303035451f,
-            0.0000323953405f,
-            0.0000345641075f,
-            0.0000368078793f,
-            0.0000391242389f,
-            0.0000415102957f,
-            0.0000439626648f,
-            0.0000464774447f,
-            0.0000490501970f,
-            0.0000516759262f,
-            0.0000543490601f,
-            0.0000570634318f,
-            0.0000598122618f,
-            0.0000625881417f,
-            0.0000653830194f,
-            0.0000681881850f,
-            0.0000709942585f,
-            0.0000737911790f,
-            0.0000765681960f,
-            0.0000793138614f,
-            0.0000820160247f,
-            0.0000846618292f,
-            0.0000872377109f,
-            0.0000897293998f,
-            0.0000921219225f,
-            0.0000943996085f,
-            0.0000965460984f,
-            0.0000985443543f,
-            0.0001003766741f,
-            0.0001020247075f,
-            0.0001034694753f,
-            0.0001046913914f,
-            0.0001056702886f,
-            0.0001063854463f,
-            0.0001068156220f,
-            0.0001069390861f,
-            0.0001067336594f,
-            0.0001061767539f,
-            0.0001052454174f,
-            0.0001039163805f,
-            0.0001021661074f,
-            0.0000999708498f,
-            0.0000973067041f,
-            0.0000941496711f,
-            0.0000904757201f,
-            0.0000862608548f,
-            0.0000814811826f,
-            0.0000761129878f,
-            0.0000701328055f,
-            0.0000635175006f,
-            0.0000562443479f,
-            0.0000482911149f,
-            0.0000396361475f,
-            0.0000302584574f,
-            0.0000201378119f,
-            0.0000092548251f,
-            -0.0000024089487f,
-            -0.0000148709202f,
-            -0.0000281473694f,
-            -0.0000422533485f,
-            -0.0000572025836f,
-            -0.0000730073769f,
-            -0.0000896785070f,
-            -0.0001072251303f,
-            -0.0001256546823f,
-            -0.0001449727787f,
-            -0.0001651831180f,
-            -0.0001862873844f,
-            -0.0002082851526f,
-            -0.0002311737938f,
-            -0.0002549483834f,
-            -0.0002796016114f,
-            -0.0003051236947f,
-            -0.0003315022928f,
-            -0.0003587224261f,
-            -0.0003867663977f,
-            -0.0004156137196f,
-            -0.0004452410417f,
-            -0.0004756220865f,
-            -0.0005067275876f,
-            -0.0005385252334f,
-            -0.0005709796161f,
-            -0.0006040521866f,
-            -0.0006377012146f,
-            -0.0006718817554f,
-            -0.0007065456227f,
-            -0.0007416413688f,
-            -0.0007771142706f,
-            -0.0008129063239f,
-            -0.0008489562441f,
-            -0.0008851994755f,
-            -0.0009215682077f,
-            -0.0009579914002f,
-            -0.0009943948149f,
-            -0.0010307010577f,
-            -0.0010668296278f,
-            -0.0011026969756f,
-            -0.0011382165698f,
-            -0.0011732989726f,
-            -0.0012078519242f,
-            -0.0012417804357f,
-            -0.0012749868911f,
-            -0.0013073711584f,
-            -0.0013388307085f,
-            -0.0013692607440f,
-            -0.0013985543359f,
-            -0.0014266025695f,
-            -0.0014532946976f,
-            -0.0014785183035f,
-            -0.0015021594706f,
-            -0.0015241029610f,
-            -0.0015442324013f,
-            -0.0015624304759f,
-            -0.0015785791272f,
-            -0.0015925597630f,
-            -0.0016042534706f,
-            -0.0016135412362f,
-            -0.0016203041714f,
-            -0.0016244237439f,
-            -0.0016257820138f,
-            -0.0016242618751f,
-            -0.0016197472998f,
-            -0.0016121235873f,
-            -0.0016012776158f,
-            -0.0015870980974f,
-            -0.0015694758340f,
-            -0.0015483039764f,
-            -0.0015234782833f,
-            -0.0014948973813f,
-            -0.0014624630249f,
-            -0.0014260803553f,
-            -0.0013856581588f,
-            -0.0013411091226f,
-            -0.0012923500886f,
-            -0.0012393023038f,
-            -0.0011818916675f,
-            -0.0011200489733f,
-            -0.0010537101473f,
-            -0.0009828164799f,
-            -0.0009073148519f,
-            -0.0008271579535f,
-            -0.0007423044962f,
-            -0.0006527194165f,
-            -0.0005583740715f,
-            -0.0004592464247f,
-            -0.0003553212224f,
-            -0.0002465901604f,
-            -0.0001330520388f,
-            -0.0000147129070f,
-            0.0001084138051f,
-            0.0002363071656f,
-            0.0003689386344f,
-            0.0005062719681f,
-            0.0006482631397f,
-            0.0007948602715f,
-            0.0009460035829f,
-            0.0011016253518f,
-            0.0012616498923f,
-            0.0014259935461f,
-            0.0015945646903f,
-            0.0017672637604f,
-            0.0019439832887f,
-            0.0021246079593f,
-            0.0023090146782f,
-            0.0024970726603f,
-            0.0026886435316f,
-            0.0028835814481f,
-            0.0030817332298f,
-            0.0032829385117f,
-            0.0034870299096f,
-            0.0036938332018f,
-            0.0039031675262f,
-            0.0041148455925f,
-            0.0043286739091f,
-            0.0045444530249f,
-            0.0047619777845f,
-            0.0049810375985f,
-            0.0052014167253f,
-            0.0054228945678f,
-            0.0056452459812f,
-            0.0058682415926f,
-            0.0060916481332f,
-            0.0063152287796f,
-            0.0065387435067f,
-            0.0067619494488f,
-            0.0069846012704f,
-            0.0072064515449f,
-            0.0074272511403f,
-            0.0076467496121f,
-            0.0078646956013f,
-            0.0080808372388f,
-            0.0082949225525f,
-            0.0085066998790f,
-            0.0087159182778f,
-            0.0089223279466f,
-            0.0091256806387f,
-            0.0093257300791f,
-            0.0095222323814f,
-            0.0097149464619f,
-            0.0099036344516f,
-            0.0100880621047f,
-            0.0102679992034f,
-            0.0104432199569f,
-            0.0106135033952f,
-            0.0107786337550f,
-            0.0109384008597f,
-            0.0110926004890f,
-            0.0112410347414f,
-            0.0113835123847f,
-            0.0115198491970f,
-            0.0116498682958f,
-            0.0117734004551f,
-            0.0118902844090f,
-            0.0120003671424f,
-            0.0121035041671f,
-            0.0121995597832f,
-            0.0122884073249f,
-            0.0123699293904f,
-            0.0124440180558f,
-            0.0125105750712f,
-            0.0125695120403f,
-            0.0126207505817f,
-            0.0126642224718f,
-            0.0126998697703f,
-            0.0127276449258f,
-            0.0127475108633f,
-            0.0127594410518f,
-            0.0127634195532f,
-            0.0127594410518f,
-            0.0127475108633f,
-            0.0127276449258f,
-            0.0126998697703f,
-            0.0126642224718f,
-            0.0126207505817f,
-            0.0125695120403f,
-            0.0125105750712f,
-            0.0124440180558f,
-            0.0123699293904f,
-            0.0122884073249f,
-            0.0121995597832f,
-            0.0121035041671f,
-            0.0120003671424f,
-            0.0118902844090f,
-            0.0117734004551f,
-            0.0116498682958f,
-            0.0115198491970f,
-            0.0113835123847f,
-            0.0112410347414f,
-            0.0110926004890f,
-            0.0109384008597f,
-            0.0107786337550f,
-            0.0106135033952f,
-            0.0104432199569f,
-            0.0102679992034f,
-            0.0100880621047f,
-            0.0099036344516f,
-            0.0097149464619f,
-            0.0095222323814f,
-            0.0093257300791f,
-            0.0091256806387f,
-            0.0089223279466f,
-            0.0087159182778f,
-            0.0085066998790f,
-            0.0082949225525f,
-            0.0080808372388f,
-            0.0078646956013f,
-            0.0076467496121f,
-            0.0074272511403f,
-            0.0072064515449f,
-            0.0069846012704f,
-            0.0067619494488f,
-            0.0065387435067f,
-            0.0063152287796f,
-            0.0060916481332f,
-            0.0058682415926f,
-            0.0056452459812f,
-            0.0054228945678f,
-            0.0052014167253f,
-            0.0049810375985f,
-            0.0047619777845f,
-            0.0045444530249f,
-            0.0043286739091f,
-            0.0041148455925f,
-            0.0039031675262f,
-            0.0036938332018f,
-            0.0034870299096f,
-            0.0032829385117f,
-            0.0030817332298f,
-            0.0028835814481f,
-            0.0026886435316f,
-            0.0024970726603f,
-            0.0023090146782f,
-            0.0021246079593f,
-            0.0019439832887f,
-            0.0017672637604f,
-            0.0015945646903f,
-            0.0014259935461f,
-            0.0012616498923f,
-            0.0011016253518f,
-            0.0009460035829f,
-            0.0007948602715f,
-            0.0006482631397f,
-            0.0005062719681f,
-            0.0003689386344f,
-            0.0002363071656f,
-            0.0001084138051f,
-            -0.0000147129070f,
-            -0.0001330520388f,
-            -0.0002465901604f,
-            -0.0003553212224f,
-            -0.0004592464247f,
-            -0.0005583740715f,
-            -0.0006527194165f,
-            -0.0007423044962f,
-            -0.0008271579535f,
-            -0.0009073148519f,
-            -0.0009828164799f,
-            -0.0010537101473f,
-            -0.0011200489733f,
-            -0.0011818916675f,
-            -0.0012393023038f,
-            -0.0012923500886f,
-            -0.0013411091226f,
-            -0.0013856581588f,
-            -0.0014260803553f,
-            -0.0014624630249f,
-            -0.0014948973813f,
-            -0.0015234782833f,
-            -0.0015483039764f,
-            -0.0015694758340f,
-            -0.0015870980974f,
-            -0.0016012776158f,
-            -0.0016121235873f,
-            -0.0016197472998f,
-            -0.0016242618751f,
-            -0.0016257820138f,
-            -0.0016244237439f,
-            -0.0016203041714f,
-            -0.0016135412362f,
-            -0.0016042534706f,
-            -0.0015925597630f,
-            -0.0015785791272f,
-            -0.0015624304759f,
-            -0.0015442324013f,
-            -0.0015241029610f,
-            -0.0015021594706f,
-            -0.0014785183035f,
-            -0.0014532946976f,
-            -0.0014266025695f,
-            -0.0013985543359f,
-            -0.0013692607440f,
-            -0.0013388307085f,
-            -0.0013073711584f,
-            -0.0012749868911f,
-            -0.0012417804357f,
-            -0.0012078519242f,
-            -0.0011732989726f,
-            -0.0011382165698f,
-            -0.0011026969756f,
-            -0.0010668296278f,
-            -0.0010307010577f,
-            -0.0009943948149f,
-            -0.0009579914002f,
-            -0.0009215682077f,
-            -0.0008851994755f,
-            -0.0008489562441f,
-            -0.0008129063239f,
-            -0.0007771142706f,
-            -0.0007416413688f,
-            -0.0007065456227f,
-            -0.0006718817554f,
-            -0.0006377012146f,
-            -0.0006040521866f,
-            -0.0005709796161f,
-            -0.0005385252334f,
-            -0.0005067275876f,
-            -0.0004756220865f,
-            -0.0004452410417f,
-            -0.0004156137196f,
-            -0.0003867663977f,
-            -0.0003587224261f,
-            -0.0003315022928f,
-            -0.0003051236947f,
-            -0.0002796016114f,
-            -0.0002549483834f,
-            -0.0002311737938f,
-            -0.0002082851526f,
-            -0.0001862873844f,
-            -0.0001651831180f,
-            -0.0001449727787f,
-            -0.0001256546823f,
-            -0.0001072251303f,
-            -0.0000896785070f,
-            -0.0000730073769f,
-            -0.0000572025836f,
-            -0.0000422533485f,
-            -0.0000281473694f,
-            -0.0000148709202f,
-            -0.0000024089487f,
-            0.0000092548251f,
-            0.0000201378119f,
-            0.0000302584574f,
-            0.0000396361475f,
-            0.0000482911149f,
-            0.0000562443479f,
-            0.0000635175006f,
-            0.0000701328055f,
-            0.0000761129878f,
-            0.0000814811826f,
-            0.0000862608548f,
-            0.0000904757201f,
-            0.0000941496711f,
-            0.0000973067041f,
-            0.0000999708498f,
-            0.0001021661074f,
-            0.0001039163805f,
-            0.0001052454174f,
-            0.0001061767539f,
-            0.0001067336594f,
-            0.0001069390861f,
-            0.0001068156220f,
-            0.0001063854463f,
-            0.0001056702886f,
-            0.0001046913914f,
-            0.0001034694753f,
-            0.0001020247075f,
-            0.0001003766741f,
-            0.0000985443543f,
-            0.0000965460984f,
-            0.0000943996085f,
-            0.0000921219225f,
-            0.0000897293998f,
-            0.0000872377109f,
-            0.0000846618292f,
-            0.0000820160247f,
-            0.0000793138614f,
-            0.0000765681960f,
-            0.0000737911790f,
-            0.0000709942585f,
-            0.0000681881850f,
-            0.0000653830194f,
-            0.0000625881417f,
-            0.0000598122618f,
-            0.0000570634318f,
-            0.0000543490601f,
-            0.0000516759262f,
-            0.0000490501970f,
-            0.0000464774447f,
-            0.0000439626648f,
-            0.0000415102957f,
-            0.0000391242389f,
-            0.0000368078793f,
-            0.0000345641075f,
-            0.0000323953405f,
-            0.0000303035451f,
-            0.0000282902593f,
-            0.0000263566159f,
-            0.0000245033648f,
-            0.0000227308957f,
-            0.0000210392611f,
-            0.0000194281990f,
-            0.0000178971548f,
-            0.0000164453038f,
-            0.0000150715728f,
-            0.0000137746613f,
-            0.0000125530626f,
-            0.0000114050841f,
-            0.0000103288670f,
-            0.0000093224054f,
-            0.0000083835652f,
-            0.0000075101016f,
-            0.0000066996765f,
-            0.0000059498747f,
-            0.0000052582199f,
-            0.0000046221895f,
-            0.0000040392284f,
-            0.0000035067628f,
-            0.0000030222125f,
-            0.0000025830027f,
-            0.0000021865747f,
-            0.0000059328143f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_128_8.h

@@ -1,47 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_128_8_len = 33;
-        const float fir_128_8_taps[] = {
-            0.0000402645396f,
-            0.0001776497260f,
-            0.0005328099895f,
-            0.0012889952275f,
-            0.0026955140465f,
-            0.0050490564879f,
-            0.0086535181818f,
-            0.0137600626254f,
-            0.0204960424230f,
-            0.0287971941582f,
-            0.0383605456257f,
-            0.0486341848839f,
-            0.0588539901422f,
-            0.0681275795918f,
-            0.0755543850679f,
-            0.0803608914008f,
-            0.0820245881555f,
-            0.0803608914008f,
-            0.0755543850679f,
-            0.0681275795918f,
-            0.0588539901422f,
-            0.0486341848839f,
-            0.0383605456257f,
-            0.0287971941582f,
-            0.0204960424230f,
-            0.0137600626254f,
-            0.0086535181818f,
-            0.0050490564879f,
-            0.0026955140465f,
-            0.0012889952275f,
-            0.0005328099895f,
-            0.0001776497260f,
-            0.0000402645396f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_16_16.h

@@ -1,566 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_16_16_len = 552;
-        const float fir_16_16_taps[] = {
-            0.0000083199827f,
-            0.0000084881676f,
-            0.0000125885567f,
-            0.0000177804634f,
-            0.0000241852833f,
-            0.0000319042337f,
-            0.0000410140885f,
-            0.0000515556971f,
-            0.0000635293624f,
-            0.0000768836058f,
-            0.0000915114120f,
-            0.0001072405937f,
-            0.0001238323243f,
-            0.0001409745652f,
-            0.0001582843174f,
-            0.0001753054713f,
-            0.0001915159849f,
-            0.0002063311677f,
-            0.0002191165223f,
-            0.0002291968856f,
-            0.0002358749754f,
-            0.0002384460258f,
-            0.0002362212252f,
-            0.0002285465848f,
-            0.0002148295414f,
-            0.0001945599050f,
-            0.0001673370635f,
-            0.0001328901081f,
-            0.0000911024573f,
-            0.0000420277999f,
-            -0.0000140913087f,
-            -0.0000768150927f,
-            -0.0001454972457f,
-            -0.0002192871274f,
-            -0.0002971322962f,
-            -0.0003777932686f,
-            -0.0004598592590f,
-            -0.0005417761096f,
-            -0.0006218750188f,
-            -0.0006984125260f,
-            -0.0007696102015f,
-            -0.0008337037348f,
-            -0.0008889897559f,
-            -0.0009338793741f,
-            -0.0009669467668f,
-            -0.0009869812183f,
-            -0.0009930311084f,
-            -0.0009844478476f,
-            -0.0009609186466f,
-            -0.0009224959242f,
-            -0.0008696128718f,
-            -0.0008030930096f,
-            -0.0007241441121f,
-            -0.0006343445666f,
-            -0.0005356135898f,
-            -0.0004301737349f,
-            -0.0003204982716f,
-            -0.0002092522968f,
-            -0.0000992213271f,
-            0.0000067633979f,
-            0.0001059080771f,
-            0.0001955385388f,
-            0.0002731857749f,
-            0.0003366654366f,
-            0.0003841550469f,
-            0.0004142599400f,
-            0.0004260714830f,
-            0.0004192093552f,
-            0.0003938516106f,
-            0.0003507454223f,
-            0.0002912027367f,
-            0.0002170751467f,
-            0.0001307129555f,
-            0.0000349043239f,
-            -0.0000671996814f,
-            -0.0001721766401f,
-            -0.0002764343270f,
-            -0.0003763233051f,
-            -0.0004682533995f,
-            -0.0005488139662f,
-            -0.0006148906121f,
-            -0.0006637776003f,
-            -0.0006932789118f,
-            -0.0007017970554f,
-            -0.0006884034538f,
-            -0.0006528899123f,
-            -0.0005957963722f,
-            -0.0005184153646f,
-            -0.0004227701586f,
-            -0.0003115682847f,
-            -0.0001881294675f,
-            -0.0000562910721f,
-            0.0000797078370f,
-            0.0002153593731f,
-            0.0003460336990f,
-            0.0004671344133f,
-            0.0005742581225f,
-            0.0006633522280f,
-            0.0007308658562f,
-            0.0007738881585f,
-            0.0007902689274f,
-            0.0007787167083f,
-            0.0007388701444f,
-            0.0006713394034f,
-            0.0005777148960f,
-            0.0004605423719f,
-            0.0003232635598f,
-            0.0001701240020f,
-            0.0000060494092f,
-            -0.0001635052308f,
-            -0.0003327304257f,
-            -0.0004956543392f,
-            -0.0006463473881f,
-            -0.0007791311572f,
-            -0.0008887858391f,
-            -0.0009707473406f,
-            -0.0010212883637f,
-            -0.0010376748928f,
-            -0.0010182935142f,
-            -0.0009627423256f,
-            -0.0008718829334f,
-            -0.0007478485121f,
-            -0.0005940082363f,
-            -0.0004148858953f,
-            -0.0002160362179f,
-            -0.0000038797853f,
-            0.0002144967369f,
-            0.0004315713068f,
-            0.0006396386805f,
-            0.0008310780982f,
-            0.0009986251377f,
-            0.0011356405836f,
-            0.0012363642899f,
-            0.0012961469552f,
-            0.0013116484677f,
-            0.0012809971563f,
-            0.0012039006285f,
-            0.0010817051861f,
-            0.0009173976585f,
-            0.0007155502328f,
-            0.0004822060361f,
-            0.0002247101187f,
-            -0.0000485122542f,
-            -0.0003282213579f,
-            -0.0006046670924f,
-            -0.0008679194122f,
-            -0.0011082164816f,
-            -0.0013163164160f,
-            -0.0014838424648f,
-            -0.0016036069166f,
-            -0.0016699037326f,
-            -0.0016787563734f,
-            -0.0016281127287f,
-            -0.0015179765142f,
-            -0.0013504705242f,
-            -0.0011298254200f,
-            -0.0008622940855f,
-            -0.0005559904445f,
-            -0.0002206579656f,
-            0.0001326278146f,
-            0.0004918125002f,
-            0.0008442625446f,
-            0.0011771971009f,
-            0.0014781391329f,
-            0.0017353688983f,
-            0.0019383651103f,
-            0.0020782164138f,
-            0.0021479888549f,
-            0.0021430337774f,
-            0.0020612244406f,
-            0.0019031097610f,
-            0.0016719780803f,
-            0.0013738250803f,
-            0.0010172247913f,
-            0.0006131045972f,
-            0.0001744298610f,
-            -0.0002841939575f,
-            -0.0007469896914f,
-            -0.0011975333012f,
-            -0.0016193180225f,
-            -0.0019963392576f,
-            -0.0023136800202f,
-            -0.0025580762604f,
-            -0.0027184414762f,
-            -0.0027863306535f,
-            -0.0027563254360f,
-            -0.0026263241476f,
-            -0.0023977237973f,
-            -0.0020754837838f,
-            -0.0016680658389f,
-            -0.0011872477991f,
-            -0.0006478144405f,
-            -0.0000671315905f,
-            0.0005353843889f,
-            0.0011388873506f,
-            0.0017217924441f,
-            0.0022625165854f,
-            0.0027402428016f,
-            0.0031356836285f,
-            0.0034318155224f,
-            0.0036145589782f,
-            0.0036733773953f,
-            0.0036017725718f,
-            0.0033976546025f,
-            0.0030635707180f,
-            0.0026067787615f,
-            0.0020391592667f,
-            0.0013769620179f,
-            0.0006403921219f,
-            -0.0001469573694f,
-            -0.0009588099622f,
-            -0.0017670296747f,
-            -0.0025425381258f,
-            -0.0032562984671f,
-            -0.0038803325839f,
-            -0.0043887399877f,
-            -0.0047586814357f,
-            -0.0049712946658f,
-            -0.0050125064331f,
-            -0.0048737118489f,
-            -0.0045522909896f,
-            -0.0040519418186f,
-            -0.0033828092770f,
-            -0.0025614012271f,
-            -0.0016102839965f,
-            -0.0005575620934f,
-            0.0005638508289f,
-            0.0017171507753f,
-            0.0028627309673f,
-            0.0039594061171f,
-            0.0049657407264f,
-            0.0058414394672f,
-            0.0065487591885f,
-            0.0070538953140f,
-            0.0073282995418f,
-            0.0073498818543f,
-            0.0071040568482f,
-            0.0065845934106f,
-            0.0057942364555f,
-            0.0047450710480f,
-            0.0034586110723f,
-            0.0019655981535f,
-            0.0003055096637f,
-            -0.0014742207991f,
-            -0.0033192537092f,
-            -0.0051696434604f,
-            -0.0069613540836f,
-            -0.0086279538448f,
-            -0.0101024412833f,
-            -0.0113191540820f,
-            -0.0122157045903f,
-            -0.0127348875124f,
-            -0.0128265011561f,
-            -0.0124490285360f,
-            -0.0115711241461f,
-            -0.0101728602554f,
-            -0.0082466894895f,
-            -0.0057980911592f,
-            -0.0028458744398f,
-            0.0005778759911f,
-            0.0044282188570f,
-            0.0086481335451f,
-            0.0131696415938f,
-            0.0179152456807f,
-            0.0227996521306f,
-            0.0277317322133f,
-            0.0326166721023f,
-            0.0373582535356f,
-            0.0418612046008f,
-            0.0460335559188f,
-            0.0497889382248f,
-            0.0530487572435f,
-            0.0557441859425f,
-            0.0578179180988f,
-            0.0592256344327f,
-            0.0599371398233f,
-            0.0599371398233f,
-            0.0592256344327f,
-            0.0578179180988f,
-            0.0557441859425f,
-            0.0530487572435f,
-            0.0497889382248f,
-            0.0460335559188f,
-            0.0418612046008f,
-            0.0373582535356f,
-            0.0326166721023f,
-            0.0277317322133f,
-            0.0227996521306f,
-            0.0179152456807f,
-            0.0131696415938f,
-            0.0086481335451f,
-            0.0044282188570f,
-            0.0005778759911f,
-            -0.0028458744398f,
-            -0.0057980911592f,
-            -0.0082466894895f,
-            -0.0101728602554f,
-            -0.0115711241461f,
-            -0.0124490285360f,
-            -0.0128265011561f,
-            -0.0127348875124f,
-            -0.0122157045903f,
-            -0.0113191540820f,
-            -0.0101024412833f,
-            -0.0086279538448f,
-            -0.0069613540836f,
-            -0.0051696434604f,
-            -0.0033192537092f,
-            -0.0014742207991f,
-            0.0003055096637f,
-            0.0019655981535f,
-            0.0034586110723f,
-            0.0047450710480f,
-            0.0057942364555f,
-            0.0065845934106f,
-            0.0071040568482f,
-            0.0073498818543f,
-            0.0073282995418f,
-            0.0070538953140f,
-            0.0065487591885f,
-            0.0058414394672f,
-            0.0049657407264f,
-            0.0039594061171f,
-            0.0028627309673f,
-            0.0017171507753f,
-            0.0005638508289f,
-            -0.0005575620934f,
-            -0.0016102839965f,
-            -0.0025614012271f,
-            -0.0033828092770f,
-            -0.0040519418186f,
-            -0.0045522909896f,
-            -0.0048737118489f,
-            -0.0050125064331f,
-            -0.0049712946658f,
-            -0.0047586814357f,
-            -0.0043887399877f,
-            -0.0038803325839f,
-            -0.0032562984671f,
-            -0.0025425381258f,
-            -0.0017670296747f,
-            -0.0009588099622f,
-            -0.0001469573694f,
-            0.0006403921219f,
-            0.0013769620179f,
-            0.0020391592667f,
-            0.0026067787615f,
-            0.0030635707180f,
-            0.0033976546025f,
-            0.0036017725718f,
-            0.0036733773953f,
-            0.0036145589782f,
-            0.0034318155224f,
-            0.0031356836285f,
-            0.0027402428016f,
-            0.0022625165854f,
-            0.0017217924441f,
-            0.0011388873506f,
-            0.0005353843889f,
-            -0.0000671315905f,
-            -0.0006478144405f,
-            -0.0011872477991f,
-            -0.0016680658389f,
-            -0.0020754837838f,
-            -0.0023977237973f,
-            -0.0026263241476f,
-            -0.0027563254360f,
-            -0.0027863306535f,
-            -0.0027184414762f,
-            -0.0025580762604f,
-            -0.0023136800202f,
-            -0.0019963392576f,
-            -0.0016193180225f,
-            -0.0011975333012f,
-            -0.0007469896914f,
-            -0.0002841939575f,
-            0.0001744298610f,
-            0.0006131045972f,
-            0.0010172247913f,
-            0.0013738250803f,
-            0.0016719780803f,
-            0.0019031097610f,
-            0.0020612244406f,
-            0.0021430337774f,
-            0.0021479888549f,
-            0.0020782164138f,
-            0.0019383651103f,
-            0.0017353688983f,
-            0.0014781391329f,
-            0.0011771971009f,
-            0.0008442625446f,
-            0.0004918125002f,
-            0.0001326278146f,
-            -0.0002206579656f,
-            -0.0005559904445f,
-            -0.0008622940855f,
-            -0.0011298254200f,
-            -0.0013504705242f,
-            -0.0015179765142f,
-            -0.0016281127287f,
-            -0.0016787563734f,
-            -0.0016699037326f,
-            -0.0016036069166f,
-            -0.0014838424648f,
-            -0.0013163164160f,
-            -0.0011082164816f,
-            -0.0008679194122f,
-            -0.0006046670924f,
-            -0.0003282213579f,
-            -0.0000485122542f,
-            0.0002247101187f,
-            0.0004822060361f,
-            0.0007155502328f,
-            0.0009173976585f,
-            0.0010817051861f,
-            0.0012039006285f,
-            0.0012809971563f,
-            0.0013116484677f,
-            0.0012961469552f,
-            0.0012363642899f,
-            0.0011356405836f,
-            0.0009986251377f,
-            0.0008310780982f,
-            0.0006396386805f,
-            0.0004315713068f,
-            0.0002144967369f,
-            -0.0000038797853f,
-            -0.0002160362179f,
-            -0.0004148858953f,
-            -0.0005940082363f,
-            -0.0007478485121f,
-            -0.0008718829334f,
-            -0.0009627423256f,
-            -0.0010182935142f,
-            -0.0010376748928f,
-            -0.0010212883637f,
-            -0.0009707473406f,
-            -0.0008887858391f,
-            -0.0007791311572f,
-            -0.0006463473881f,
-            -0.0004956543392f,
-            -0.0003327304257f,
-            -0.0001635052308f,
-            0.0000060494092f,
-            0.0001701240020f,
-            0.0003232635598f,
-            0.0004605423719f,
-            0.0005777148960f,
-            0.0006713394034f,
-            0.0007388701444f,
-            0.0007787167083f,
-            0.0007902689274f,
-            0.0007738881585f,
-            0.0007308658562f,
-            0.0006633522280f,
-            0.0005742581225f,
-            0.0004671344133f,
-            0.0003460336990f,
-            0.0002153593731f,
-            0.0000797078370f,
-            -0.0000562910721f,
-            -0.0001881294675f,
-            -0.0003115682847f,
-            -0.0004227701586f,
-            -0.0005184153646f,
-            -0.0005957963722f,
-            -0.0006528899123f,
-            -0.0006884034538f,
-            -0.0007017970554f,
-            -0.0006932789118f,
-            -0.0006637776003f,
-            -0.0006148906121f,
-            -0.0005488139662f,
-            -0.0004682533995f,
-            -0.0003763233051f,
-            -0.0002764343270f,
-            -0.0001721766401f,
-            -0.0000671996814f,
-            0.0000349043239f,
-            0.0001307129555f,
-            0.0002170751467f,
-            0.0002912027367f,
-            0.0003507454223f,
-            0.0003938516106f,
-            0.0004192093552f,
-            0.0004260714830f,
-            0.0004142599400f,
-            0.0003841550469f,
-            0.0003366654366f,
-            0.0002731857749f,
-            0.0001955385388f,
-            0.0001059080771f,
-            0.0000067633979f,
-            -0.0000992213271f,
-            -0.0002092522968f,
-            -0.0003204982716f,
-            -0.0004301737349f,
-            -0.0005356135898f,
-            -0.0006343445666f,
-            -0.0007241441121f,
-            -0.0008030930096f,
-            -0.0008696128718f,
-            -0.0009224959242f,
-            -0.0009609186466f,
-            -0.0009844478476f,
-            -0.0009930311084f,
-            -0.0009869812183f,
-            -0.0009669467668f,
-            -0.0009338793741f,
-            -0.0008889897559f,
-            -0.0008337037348f,
-            -0.0007696102015f,
-            -0.0006984125260f,
-            -0.0006218750188f,
-            -0.0005417761096f,
-            -0.0004598592590f,
-            -0.0003777932686f,
-            -0.0002971322962f,
-            -0.0002192871274f,
-            -0.0001454972457f,
-            -0.0000768150927f,
-            -0.0000140913087f,
-            0.0000420277999f,
-            0.0000911024573f,
-            0.0001328901081f,
-            0.0001673370635f,
-            0.0001945599050f,
-            0.0002148295414f,
-            0.0002285465848f,
-            0.0002362212252f,
-            0.0002384460258f,
-            0.0002358749754f,
-            0.0002291968856f,
-            0.0002191165223f,
-            0.0002063311677f,
-            0.0001915159849f,
-            0.0001753054713f,
-            0.0001582843174f,
-            0.0001409745652f,
-            0.0001238323243f,
-            0.0001072405937f,
-            0.0000915114120f,
-            0.0000768836058f,
-            0.0000635293624f,
-            0.0000515556971f,
-            0.0000410140885f,
-            0.0000319042337f,
-            0.0000241852833f,
-            0.0000177804634f,
-            0.0000125885567f,
-            0.0000084881676f,
-            0.0000083199827f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_16_2.h

@@ -1,20 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_16_2_len = 6;
-        const float fir_16_2_taps[] = {
-            0.0314633937131f,
-            0.1579813285983f,
-            0.3165763689208f,
-            0.3165763689208f,
-            0.1579813285983f,
-            0.0314633937131f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_16_4.h

@@ -1,36 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_16_4_len = 22;
-        const float fir_16_4_taps[] = {
-            -0.0002023708919f,
-            -0.0011062368313f,
-            -0.0032163920847f,
-            -0.0059942384543f,
-            -0.0065224236296f,
-            0.0007775124540f,
-            0.0220383093327f,
-            0.0596819563778f,
-            0.1084838507550f,
-            0.1553460280327f,
-            0.1842685402388f,
-            0.1842685402388f,
-            0.1553460280327f,
-            0.1084838507550f,
-            0.0596819563778f,
-            0.0220383093327f,
-            0.0007775124540f,
-            -0.0065224236296f,
-            -0.0059942384543f,
-            -0.0032163920847f,
-            -0.0011062368313f,
-            -0.0002023708919f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_16_8.h

@@ -1,78 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_16_8_len = 64;
-        const float fir_16_8_taps[] = {
-            0.0000212056278f,
-            0.0000592989663f,
-            0.0001311135234f,
-            0.0002438111297f,
-            0.0003985063745f,
-            0.0005834891258f,
-            0.0007686964633f,
-            0.0009019314371f,
-            0.0009086374568f,
-            0.0006969087115f,
-            0.0001688400440f,
-            -0.0007617044022f,
-            -0.0021461871891f,
-            -0.0039761281907f,
-            -0.0061595555220f,
-            -0.0085040839445f,
-            -0.0107115695084f,
-            -0.0123883739229f,
-            -0.0130733894948f,
-            -0.0122833118289f,
-            -0.0095715783432f,
-            -0.0045944308163f,
-            0.0028247220059f,
-            0.0126425561455f,
-            0.0245641604270f,
-            0.0380398062836f,
-            0.0522939777968f,
-            0.0663859606669f,
-            0.0792964905438f,
-            0.0900306798861f,
-            0.0977244326410f,
-            0.1017403886275f,
-            0.1017403886275f,
-            0.0977244326410f,
-            0.0900306798861f,
-            0.0792964905438f,
-            0.0663859606669f,
-            0.0522939777968f,
-            0.0380398062836f,
-            0.0245641604270f,
-            0.0126425561455f,
-            0.0028247220059f,
-            -0.0045944308163f,
-            -0.0095715783432f,
-            -0.0122833118289f,
-            -0.0130733894948f,
-            -0.0123883739229f,
-            -0.0107115695084f,
-            -0.0085040839445f,
-            -0.0061595555220f,
-            -0.0039761281907f,
-            -0.0021461871891f,
-            -0.0007617044022f,
-            0.0001688400440f,
-            0.0006969087115f,
-            0.0009086374568f,
-            0.0009019314371f,
-            0.0007686964633f,
-            0.0005834891258f,
-            0.0003985063745f,
-            0.0002438111297f,
-            0.0001311135234f,
-            0.0000592989663f,
-            0.0000212056278f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_2048_128.h

@@ -1,528 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_2048_128_len = 514;
-        const float fir_2048_128_taps[] = {
-            0.0000056977543f,
-            0.0000016519060f,
-            0.0000018900898f,
-            0.0000021498690f,
-            0.0000024330160f,
-            0.0000027405173f,
-            0.0000030742515f,
-            0.0000034353223f,
-            0.0000038257163f,
-            0.0000042466607f,
-            0.0000047002521f,
-            0.0000051878472f,
-            0.0000057116542f,
-            0.0000062731650f,
-            0.0000068747009f,
-            0.0000075178944f,
-            0.0000082051812f,
-            0.0000089383392f,
-            0.0000097199199f,
-            0.0000105518511f,
-            0.0000114368007f,
-            0.0000123768507f,
-            0.0000133747862f,
-            0.0000144328464f,
-            0.0000155539344f,
-            0.0000167404496f,
-            0.0000179954131f,
-            0.0000193213868f,
-            0.0000207215097f,
-            0.0000221985076f,
-            0.0000237556374f,
-            0.0000253957896f,
-            0.0000271223379f,
-            0.0000289383380f,
-            0.0000308472794f,
-            0.0000328523820f,
-            0.0000349572499f,
-            0.0000371652659f,
-            0.0000394801467f,
-            0.0000419054357f,
-            0.0000444449599f,
-            0.0000471024204f,
-            0.0000498817519f,
-            0.0000527868089f,
-            0.0000558216304f,
-            0.0000589902202f,
-            0.0000622967176f,
-            0.0000657452697f,
-            0.0000693401121f,
-            0.0000730855287f,
-            0.0000769858465f,
-            0.0000810454789f,
-            0.0000852688387f,
-            0.0000896604605f,
-            0.0000942248370f,
-            0.0000989666149f,
-            0.0001038903598f,
-            0.0001090008210f,
-            0.0001143026296f,
-            0.0001198006263f,
-            0.0001254994998f,
-            0.0001314041710f,
-            0.0001375193773f,
-            0.0001438501072f,
-            0.0001504011376f,
-            0.0001571775115f,
-            0.0001641840351f,
-            0.0001714257921f,
-            0.0001789076072f,
-            0.0001866345903f,
-            0.0001946115730f,
-            0.0002028436762f,
-            0.0002113357263f,
-            0.0002200928393f,
-            0.0002291198237f,
-            0.0002384217741f,
-            0.0002480034673f,
-            0.0002578699598f,
-            0.0002680259827f,
-            0.0002784765367f,
-            0.0002892262923f,
-            0.0003002801771f,
-            0.0003116427850f,
-            0.0003233189523f,
-            0.0003353131809f,
-            0.0003476301967f,
-            0.0003602743932f,
-            0.0003732503673f,
-            0.0003865623868f,
-            0.0004002149008f,
-            0.0004142120341f,
-            0.0004285580685f,
-            0.0004432569680f,
-            0.0004583128281f,
-            0.0004737294337f,
-            0.0004895106749f,
-            0.0005056601389f,
-            0.0005221814910f,
-            0.0005390781024f,
-            0.0005563533944f,
-            0.0005740105034f,
-            0.0005920525879f,
-            0.0006104825303f,
-            0.0006293032077f,
-            0.0006485172300f,
-            0.0006681271742f,
-            0.0006881353590f,
-            0.0007085440434f,
-            0.0007293552362f,
-            0.0007505708607f,
-            0.0007721925977f,
-            0.0007942220177f,
-            0.0008166604553f,
-            0.0008395091117f,
-            0.0008627689581f,
-            0.0008864408102f,
-            0.0009105252585f,
-            0.0009350227185f,
-            0.0009599333834f,
-            0.0009852572538f,
-            0.0010109941099f,
-            0.0010371435239f,
-            0.0010637048482f,
-            0.0010906772135f,
-            0.0011180595302f,
-            0.0011458504759f,
-            0.0011740485059f,
-            0.0012026518338f,
-            0.0012316584473f,
-            0.0012610660863f,
-            0.0012908722603f,
-            0.0013210742267f,
-            0.0013516690064f,
-            0.0013826533670f,
-            0.0014140238326f,
-            0.0014457766743f,
-            0.0014779079120f,
-            0.0015104133153f,
-            0.0015432883942f,
-            0.0015765284129f,
-            0.0016101283668f,
-            0.0016440830124f,
-            0.0016783868277f,
-            0.0017130340602f,
-            0.0017480186691f,
-            0.0017833343933f,
-            0.0018189746732f,
-            0.0018549327411f,
-            0.0018912015203f,
-            0.0019277737394f,
-            0.0019646418086f,
-            0.0020017979573f,
-            0.0020392340874f,
-            0.0020769419357f,
-            0.0021149129027f,
-            0.0021531382398f,
-            0.0021916088550f,
-            0.0022303155238f,
-            0.0022692486717f,
-            0.0023083986089f,
-            0.0023477552904f,
-            0.0023873085737f,
-            0.0024270479569f,
-            0.0024669628584f,
-            0.0025070423351f,
-            0.0025472753813f,
-            0.0025876506298f,
-            0.0026281566678f,
-            0.0026687817225f,
-            0.0027095139925f,
-            0.0027503413194f,
-            0.0027912515330f,
-            0.0028322321111f,
-            0.0028732705358f,
-            0.0029143539447f,
-            0.0029554694944f,
-            0.0029966040069f,
-            0.0030377443376f,
-            0.0030788770187f,
-            0.0031199886295f,
-            0.0031610654399f,
-            0.0032020937793f,
-            0.0032430596841f,
-            0.0032839492614f,
-            0.0033247483433f,
-            0.0033654428438f,
-            0.0034060184215f,
-            0.0034464608266f,
-            0.0034867555758f,
-            0.0035268882866f,
-            0.0035668443662f,
-            0.0036066093308f,
-            0.0036461685116f,
-            0.0036855073558f,
-            0.0037246111522f,
-            0.0037634653125f,
-            0.0038020551175f,
-            0.0038403659769f,
-            0.0038783831984f,
-            0.0039160922239f,
-            0.0039534784232f,
-            0.0039905273052f,
-            0.0040272243371f,
-            0.0040635551298f,
-            0.0040995052831f,
-            0.0041350605451f,
-            0.0041702066839f,
-            0.0042049296200f,
-            0.0042392153249f,
-            0.0042730499268f,
-            0.0043064196357f,
-            0.0043393108225f,
-            0.0043717099704f,
-            0.0044036037280f,
-            0.0044349788856f,
-            0.0044658224039f,
-            0.0044961214142f,
-            0.0045258632233f,
-            0.0045550353360f,
-            0.0045836254386f,
-            0.0046116214419f,
-            0.0046390114441f,
-            0.0046657837931f,
-            0.0046919270308f,
-            0.0047174299722f,
-            0.0047422816340f,
-            0.0047664713274f,
-            0.0047899885734f,
-            0.0048128232074f,
-            0.0048349652830f,
-            0.0048564051867f,
-            0.0048771335320f,
-            0.0048971412812f,
-            0.0049164196340f,
-            0.0049349601525f,
-            0.0049527546463f,
-            0.0049697952998f,
-            0.0049860745555f,
-            0.0050015852406f,
-            0.0050163204516f,
-            0.0050302736774f,
-            0.0050434386878f,
-            0.0050558096508f,
-            0.0050673810271f,
-            0.0050781476793f,
-            0.0050881047743f,
-            0.0050972478830f,
-            0.0051055728926f,
-            0.0051130760938f,
-            0.0051197541055f,
-            0.0051256039484f,
-            0.0051306229828f,
-            0.0051348089672f,
-            0.0051381600106f,
-            0.0051406746155f,
-            0.0051423516450f,
-            0.0051431903494f,
-            0.0051431903494f,
-            0.0051423516450f,
-            0.0051406746155f,
-            0.0051381600106f,
-            0.0051348089672f,
-            0.0051306229828f,
-            0.0051256039484f,
-            0.0051197541055f,
-            0.0051130760938f,
-            0.0051055728926f,
-            0.0050972478830f,
-            0.0050881047743f,
-            0.0050781476793f,
-            0.0050673810271f,
-            0.0050558096508f,
-            0.0050434386878f,
-            0.0050302736774f,
-            0.0050163204516f,
-            0.0050015852406f,
-            0.0049860745555f,
-            0.0049697952998f,
-            0.0049527546463f,
-            0.0049349601525f,
-            0.0049164196340f,
-            0.0048971412812f,
-            0.0048771335320f,
-            0.0048564051867f,
-            0.0048349652830f,
-            0.0048128232074f,
-            0.0047899885734f,
-            0.0047664713274f,
-            0.0047422816340f,
-            0.0047174299722f,
-            0.0046919270308f,
-            0.0046657837931f,
-            0.0046390114441f,
-            0.0046116214419f,
-            0.0045836254386f,
-            0.0045550353360f,
-            0.0045258632233f,
-            0.0044961214142f,
-            0.0044658224039f,
-            0.0044349788856f,
-            0.0044036037280f,
-            0.0043717099704f,
-            0.0043393108225f,
-            0.0043064196357f,
-            0.0042730499268f,
-            0.0042392153249f,
-            0.0042049296200f,
-            0.0041702066839f,
-            0.0041350605451f,
-            0.0040995052831f,
-            0.0040635551298f,
-            0.0040272243371f,
-            0.0039905273052f,
-            0.0039534784232f,
-            0.0039160922239f,
-            0.0038783831984f,
-            0.0038403659769f,
-            0.0038020551175f,
-            0.0037634653125f,
-            0.0037246111522f,
-            0.0036855073558f,
-            0.0036461685116f,
-            0.0036066093308f,
-            0.0035668443662f,
-            0.0035268882866f,
-            0.0034867555758f,
-            0.0034464608266f,
-            0.0034060184215f,
-            0.0033654428438f,
-            0.0033247483433f,
-            0.0032839492614f,
-            0.0032430596841f,
-            0.0032020937793f,
-            0.0031610654399f,
-            0.0031199886295f,
-            0.0030788770187f,
-            0.0030377443376f,
-            0.0029966040069f,
-            0.0029554694944f,
-            0.0029143539447f,
-            0.0028732705358f,
-            0.0028322321111f,
-            0.0027912515330f,
-            0.0027503413194f,
-            0.0027095139925f,
-            0.0026687817225f,
-            0.0026281566678f,
-            0.0025876506298f,
-            0.0025472753813f,
-            0.0025070423351f,
-            0.0024669628584f,
-            0.0024270479569f,
-            0.0023873085737f,
-            0.0023477552904f,
-            0.0023083986089f,
-            0.0022692486717f,
-            0.0022303155238f,
-            0.0021916088550f,
-            0.0021531382398f,
-            0.0021149129027f,
-            0.0020769419357f,
-            0.0020392340874f,
-            0.0020017979573f,
-            0.0019646418086f,
-            0.0019277737394f,
-            0.0018912015203f,
-            0.0018549327411f,
-            0.0018189746732f,
-            0.0017833343933f,
-            0.0017480186691f,
-            0.0017130340602f,
-            0.0016783868277f,
-            0.0016440830124f,
-            0.0016101283668f,
-            0.0015765284129f,
-            0.0015432883942f,
-            0.0015104133153f,
-            0.0014779079120f,
-            0.0014457766743f,
-            0.0014140238326f,
-            0.0013826533670f,
-            0.0013516690064f,
-            0.0013210742267f,
-            0.0012908722603f,
-            0.0012610660863f,
-            0.0012316584473f,
-            0.0012026518338f,
-            0.0011740485059f,
-            0.0011458504759f,
-            0.0011180595302f,
-            0.0010906772135f,
-            0.0010637048482f,
-            0.0010371435239f,
-            0.0010109941099f,
-            0.0009852572538f,
-            0.0009599333834f,
-            0.0009350227185f,
-            0.0009105252585f,
-            0.0008864408102f,
-            0.0008627689581f,
-            0.0008395091117f,
-            0.0008166604553f,
-            0.0007942220177f,
-            0.0007721925977f,
-            0.0007505708607f,
-            0.0007293552362f,
-            0.0007085440434f,
-            0.0006881353590f,
-            0.0006681271742f,
-            0.0006485172300f,
-            0.0006293032077f,
-            0.0006104825303f,
-            0.0005920525879f,
-            0.0005740105034f,
-            0.0005563533944f,
-            0.0005390781024f,
-            0.0005221814910f,
-            0.0005056601389f,
-            0.0004895106749f,
-            0.0004737294337f,
-            0.0004583128281f,
-            0.0004432569680f,
-            0.0004285580685f,
-            0.0004142120341f,
-            0.0004002149008f,
-            0.0003865623868f,
-            0.0003732503673f,
-            0.0003602743932f,
-            0.0003476301967f,
-            0.0003353131809f,
-            0.0003233189523f,
-            0.0003116427850f,
-            0.0003002801771f,
-            0.0002892262923f,
-            0.0002784765367f,
-            0.0002680259827f,
-            0.0002578699598f,
-            0.0002480034673f,
-            0.0002384217741f,
-            0.0002291198237f,
-            0.0002200928393f,
-            0.0002113357263f,
-            0.0002028436762f,
-            0.0001946115730f,
-            0.0001866345903f,
-            0.0001789076072f,
-            0.0001714257921f,
-            0.0001641840351f,
-            0.0001571775115f,
-            0.0001504011376f,
-            0.0001438501072f,
-            0.0001375193773f,
-            0.0001314041710f,
-            0.0001254994998f,
-            0.0001198006263f,
-            0.0001143026296f,
-            0.0001090008210f,
-            0.0001038903598f,
-            0.0000989666149f,
-            0.0000942248370f,
-            0.0000896604605f,
-            0.0000852688387f,
-            0.0000810454789f,
-            0.0000769858465f,
-            0.0000730855287f,
-            0.0000693401121f,
-            0.0000657452697f,
-            0.0000622967176f,
-            0.0000589902202f,
-            0.0000558216304f,
-            0.0000527868089f,
-            0.0000498817519f,
-            0.0000471024204f,
-            0.0000444449599f,
-            0.0000419054357f,
-            0.0000394801467f,
-            0.0000371652659f,
-            0.0000349572499f,
-            0.0000328523820f,
-            0.0000308472794f,
-            0.0000289383380f,
-            0.0000271223379f,
-            0.0000253957896f,
-            0.0000237556374f,
-            0.0000221985076f,
-            0.0000207215097f,
-            0.0000193213868f,
-            0.0000179954131f,
-            0.0000167404496f,
-            0.0000155539344f,
-            0.0000144328464f,
-            0.0000133747862f,
-            0.0000123768507f,
-            0.0000114368007f,
-            0.0000105518511f,
-            0.0000097199199f,
-            0.0000089383392f,
-            0.0000082051812f,
-            0.0000075178944f,
-            0.0000068747009f,
-            0.0000062731650f,
-            0.0000057116542f,
-            0.0000051878472f,
-            0.0000047002521f,
-            0.0000042466607f,
-            0.0000038257163f,
-            0.0000034353223f,
-            0.0000030742515f,
-            0.0000027405173f,
-            0.0000024330160f,
-            0.0000021498690f,
-            0.0000018900898f,
-            0.0000016519060f,
-            0.0000056977543f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_2048_64.h

@@ -1,267 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_2048_64_len = 253;
-        const float fir_2048_64_taps[] = {
-            0.0000066902983f,
-            0.0000039334795f,
-            0.0000050760344f,
-            0.0000064280051f,
-            0.0000080150883f,
-            0.0000098649890f,
-            0.0000120074887f,
-            0.0000144745098f,
-            0.0000173001750f,
-            0.0000205208620f,
-            0.0000241752518f,
-            0.0000283043713f,
-            0.0000329516280f,
-            0.0000381628381f,
-            0.0000439862461f,
-            0.0000504725357f,
-            0.0000576748313f,
-            0.0000656486906f,
-            0.0000744520862f,
-            0.0000841453767f,
-            0.0000947912669f,
-            0.0001064547563f,
-            0.0001192030760f,
-            0.0001331056125f,
-            0.0001482338200f,
-            0.0001646611193f,
-            0.0001824627837f,
-            0.0002017158118f,
-            0.0002224987872f,
-            0.0002448917247f,
-            0.0002689759031f,
-            0.0002948336849f,
-            0.0003225483233f,
-            0.0003522037550f,
-            0.0003838843823f,
-            0.0004176748409f,
-            0.0004536597574f,
-            0.0004919234940f,
-            0.0005325498835f,
-            0.0005756219531f,
-            0.0006212216387f,
-            0.0006694294907f,
-            0.0007203243711f,
-            0.0007739831434f,
-            0.0008304803565f,
-            0.0008898879232f,
-            0.0009522747932f,
-            0.0010177066247f,
-            0.0010862454523f,
-            0.0011579493544f,
-            0.0012328721212f,
-            0.0013110629237f,
-            0.0013925659858f,
-            0.0014774202601f,
-            0.0015656591097f,
-            0.0016573099965f,
-            0.0017523941775f,
-            0.0018509264108f,
-            0.0019529146726f,
-            0.0020583598864f,
-            0.0021672556657f,
-            0.0022795880718f,
-            0.0023953353879f,
-            0.0025144679106f,
-            0.0026369477603f,
-            0.0027627287116f,
-            0.0028917560447f,
-            0.0030239664192f,
-            0.0031592877711f,
-            0.0032976392339f,
-            0.0034389310850f,
-            0.0035830647179f,
-            0.0037299326406f,
-            0.0038794185025f,
-            0.0040313971475f,
-            0.0041857346968f,
-            0.0043422886590f,
-            0.0045009080704f,
-            0.0046614336629f,
-            0.0048236980620f,
-            0.0049875260128f,
-            0.0051527346356f,
-            0.0053191337090f,
-            0.0054865259818f,
-            0.0056547075111f,
-            0.0058234680287f,
-            0.0059925913320f,
-            0.0061618557011f,
-            0.0063310343392f,
-            0.0064998958364f,
-            0.0066682046550f,
-            0.0068357216352f,
-            0.0070022045210f,
-            0.0071674085013f,
-            0.0073310867697f,
-            0.0074929910962f,
-            0.0076528724136f,
-            0.0078104814129f,
-            0.0079655691490f,
-            0.0081178876519f,
-            0.0082671905449f,
-            0.0084132336638f,
-            0.0085557756782f,
-            0.0086945787115f,
-            0.0088294089578f,
-            0.0089600372929f,
-            0.0090862398788f,
-            0.0092077987584f,
-            0.0093245024384f,
-            0.0094361464590f,
-            0.0095425339481f,
-            0.0096434761582f,
-            0.0097387929827f,
-            0.0098283134530f,
-            0.0099118762107f,
-            0.0099893299564f,
-            0.0100605338714f,
-            0.0101253580118f,
-            0.0101836836737f,
-            0.0102354037271f,
-            0.0102804229187f,
-            0.0103186581413f,
-            0.0103500386692f,
-            0.0103745063596f,
-            0.0103920158177f,
-            0.0104025345256f,
-            0.0104060429356f,
-            0.0104025345256f,
-            0.0103920158177f,
-            0.0103745063596f,
-            0.0103500386692f,
-            0.0103186581413f,
-            0.0102804229187f,
-            0.0102354037271f,
-            0.0101836836737f,
-            0.0101253580118f,
-            0.0100605338714f,
-            0.0099893299564f,
-            0.0099118762107f,
-            0.0098283134530f,
-            0.0097387929827f,
-            0.0096434761582f,
-            0.0095425339481f,
-            0.0094361464590f,
-            0.0093245024384f,
-            0.0092077987584f,
-            0.0090862398788f,
-            0.0089600372929f,
-            0.0088294089578f,
-            0.0086945787115f,
-            0.0085557756782f,
-            0.0084132336638f,
-            0.0082671905449f,
-            0.0081178876519f,
-            0.0079655691490f,
-            0.0078104814129f,
-            0.0076528724136f,
-            0.0074929910962f,
-            0.0073310867697f,
-            0.0071674085013f,
-            0.0070022045210f,
-            0.0068357216352f,
-            0.0066682046550f,
-            0.0064998958364f,
-            0.0063310343392f,
-            0.0061618557011f,
-            0.0059925913320f,
-            0.0058234680287f,
-            0.0056547075111f,
-            0.0054865259818f,
-            0.0053191337090f,
-            0.0051527346356f,
-            0.0049875260128f,
-            0.0048236980620f,
-            0.0046614336629f,
-            0.0045009080704f,
-            0.0043422886590f,
-            0.0041857346968f,
-            0.0040313971475f,
-            0.0038794185025f,
-            0.0037299326406f,
-            0.0035830647179f,
-            0.0034389310850f,
-            0.0032976392339f,
-            0.0031592877711f,
-            0.0030239664192f,
-            0.0028917560447f,
-            0.0027627287116f,
-            0.0026369477603f,
-            0.0025144679106f,
-            0.0023953353879f,
-            0.0022795880718f,
-            0.0021672556657f,
-            0.0020583598864f,
-            0.0019529146726f,
-            0.0018509264108f,
-            0.0017523941775f,
-            0.0016573099965f,
-            0.0015656591097f,
-            0.0014774202601f,
-            0.0013925659858f,
-            0.0013110629237f,
-            0.0012328721212f,
-            0.0011579493544f,
-            0.0010862454523f,
-            0.0010177066247f,
-            0.0009522747932f,
-            0.0008898879232f,
-            0.0008304803565f,
-            0.0007739831434f,
-            0.0007203243711f,
-            0.0006694294907f,
-            0.0006212216387f,
-            0.0005756219531f,
-            0.0005325498835f,
-            0.0004919234940f,
-            0.0004536597574f,
-            0.0004176748409f,
-            0.0003838843823f,
-            0.0003522037550f,
-            0.0003225483233f,
-            0.0002948336849f,
-            0.0002689759031f,
-            0.0002448917247f,
-            0.0002224987872f,
-            0.0002017158118f,
-            0.0001824627837f,
-            0.0001646611193f,
-            0.0001482338200f,
-            0.0001331056125f,
-            0.0001192030760f,
-            0.0001064547563f,
-            0.0000947912669f,
-            0.0000841453767f,
-            0.0000744520862f,
-            0.0000656486906f,
-            0.0000576748313f,
-            0.0000504725357f,
-            0.0000439862461f,
-            0.0000381628381f,
-            0.0000329516280f,
-            0.0000283043713f,
-            0.0000241752518f,
-            0.0000205208620f,
-            0.0000173001750f,
-            0.0000144745098f,
-            0.0000120074887f,
-            0.0000098649890f,
-            0.0000080150883f,
-            0.0000064280051f,
-            0.0000050760344f,
-            0.0000039334795f,
-            0.0000066902983f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_256_16.h

@@ -1,90 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_256_16_len = 76;
-        const float fir_256_16_taps[] = {
-            0.0000015142320f,
-            0.0000056182880f,
-            0.0000124498946f,
-            0.0000260499212f,
-            0.0000484430498f,
-            0.0000846870575f,
-            0.0001399358873f,
-            0.0002214698093f,
-            0.0003376597827f,
-            0.0004986987881f,
-            0.0007161460168f,
-            0.0010030447437f,
-            0.0013735255533f,
-            0.0018425379543f,
-            0.0024253148288f,
-            0.0031368140196f,
-            0.0039910067755f,
-            0.0050001228341f,
-            0.0061738297617f,
-            0.0075184160910f,
-            0.0090360019122f,
-            0.0107238349685f,
-            0.0125737121967f,
-            0.0145715758254f,
-            0.0166973209914f,
-            0.0189248478075f,
-            0.0212223774387f,
-            0.0235530403051f,
-            0.0258757292104f,
-            0.0281461957951f,
-            0.0303183537669f,
-            0.0323457392931f,
-            0.0341830677768f,
-            0.0357878183250f,
-            0.0371217728573f,
-            0.0381524365951f,
-            0.0388542706370f,
-            0.0392096753967f,
-            0.0392096753967f,
-            0.0388542706370f,
-            0.0381524365951f,
-            0.0371217728573f,
-            0.0357878183250f,
-            0.0341830677768f,
-            0.0323457392931f,
-            0.0303183537669f,
-            0.0281461957951f,
-            0.0258757292104f,
-            0.0235530403051f,
-            0.0212223774387f,
-            0.0189248478075f,
-            0.0166973209914f,
-            0.0145715758254f,
-            0.0125737121967f,
-            0.0107238349685f,
-            0.0090360019122f,
-            0.0075184160910f,
-            0.0061738297617f,
-            0.0050001228341f,
-            0.0039910067755f,
-            0.0031368140196f,
-            0.0024253148288f,
-            0.0018425379543f,
-            0.0013735255533f,
-            0.0010030447437f,
-            0.0007161460168f,
-            0.0004986987881f,
-            0.0003376597827f,
-            0.0002214698093f,
-            0.0001399358873f,
-            0.0000846870575f,
-            0.0000484430498f,
-            0.0000260499212f,
-            0.0000124498946f,
-            0.0000056182880f,
-            0.0000015142320f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_256_32.h

@@ -1,156 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_256_32_len = 142;
-        const float fir_256_32_taps[] = {
-            0.0000017688668f,
-            0.0000059240292f,
-            0.0000063419158f,
-            0.0000109315134f,
-            0.0000155620383f,
-            0.0000222451938f,
-            0.0000306499257f,
-            0.0000414255079f,
-            0.0000549053491f,
-            0.0000716171275f,
-            0.0000920857379f,
-            0.0001169121085f,
-            0.0001467432458f,
-            0.0001822838505f,
-            0.0002242905946f,
-            0.0002735720047f,
-            0.0003309848921f,
-            0.0003974308010f,
-            0.0004738510608f,
-            0.0005612209568f,
-            0.0006605427983f,
-            0.0007728379742f,
-            0.0008991379865f,
-            0.0010404745144f,
-            0.0011978685639f,
-            0.0013723187831f,
-            0.0015647890362f,
-            0.0017761953523f,
-            0.0020073923789f,
-            0.0022591594875f,
-            0.0025321866931f,
-            0.0028270605623f,
-            0.0031442502958f,
-            0.0034840941781f,
-            0.0038467865966f,
-            0.0042323658308f,
-            0.0046407028156f,
-            0.0050714910778f,
-            0.0055242380402f,
-            0.0059982578748f,
-            0.0064926660779f,
-            0.0070063759201f,
-            0.0075380969064f,
-            0.0080863353601f,
-            0.0086493972198f,
-            0.0092253931090f,
-            0.0098122457142f,
-            0.0104076994722f,
-            0.0110093325391f,
-            0.0116145709801f,
-            0.0122207050884f,
-            0.0128249077089f,
-            0.0134242544118f,
-            0.0140157453332f,
-            0.0145963284712f,
-            0.0151629242012f,
-            0.0157124507544f,
-            0.0162418503801f,
-            0.0167481159032f,
-            0.0172283173722f,
-            0.0176796284881f,
-            0.0180993525027f,
-            0.0184849472748f,
-            0.0188340491797f,
-            0.0191444955798f,
-            0.0194143455756f,
-            0.0196418987797f,
-            0.0198257118761f,
-            0.0199646127554f,
-            0.0200577120472f,
-            0.0201044119003f,
-            0.0201044119003f,
-            0.0200577120472f,
-            0.0199646127554f,
-            0.0198257118761f,
-            0.0196418987797f,
-            0.0194143455756f,
-            0.0191444955798f,
-            0.0188340491797f,
-            0.0184849472748f,
-            0.0180993525027f,
-            0.0176796284881f,
-            0.0172283173722f,
-            0.0167481159032f,
-            0.0162418503801f,
-            0.0157124507544f,
-            0.0151629242012f,
-            0.0145963284712f,
-            0.0140157453332f,
-            0.0134242544118f,
-            0.0128249077089f,
-            0.0122207050884f,
-            0.0116145709801f,
-            0.0110093325391f,
-            0.0104076994722f,
-            0.0098122457142f,
-            0.0092253931090f,
-            0.0086493972198f,
-            0.0080863353601f,
-            0.0075380969064f,
-            0.0070063759201f,
-            0.0064926660779f,
-            0.0059982578748f,
-            0.0055242380402f,
-            0.0050714910778f,
-            0.0046407028156f,
-            0.0042323658308f,
-            0.0038467865966f,
-            0.0034840941781f,
-            0.0031442502958f,
-            0.0028270605623f,
-            0.0025321866931f,
-            0.0022591594875f,
-            0.0020073923789f,
-            0.0017761953523f,
-            0.0015647890362f,
-            0.0013723187831f,
-            0.0011978685639f,
-            0.0010404745144f,
-            0.0008991379865f,
-            0.0007728379742f,
-            0.0006605427983f,
-            0.0005612209568f,
-            0.0004738510608f,
-            0.0003974308010f,
-            0.0003309848921f,
-            0.0002735720047f,
-            0.0002242905946f,
-            0.0001822838505f,
-            0.0001467432458f,
-            0.0001169121085f,
-            0.0000920857379f,
-            0.0000716171275f,
-            0.0000549053491f,
-            0.0000414255079f,
-            0.0000306499257f,
-            0.0000222451938f,
-            0.0000155620383f,
-            0.0000109315134f,
-            0.0000063419158f,
-            0.0000059240292f,
-            0.0000017688668f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_256_64.h

@@ -1,370 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_256_64_len = 356;
-        const float fir_256_64_taps[] = {
-            -0.0000062681742f,
-            -0.0000029140762f,
-            -0.0000035815110f,
-            -0.0000043422553f,
-            -0.0000052049053f,
-            -0.0000061772939f,
-            -0.0000072686109f,
-            -0.0000084872485f,
-            -0.0000098429063f,
-            -0.0000113444414f,
-            -0.0000130019541f,
-            -0.0000148246460f,
-            -0.0000168228827f,
-            -0.0000190060632f,
-            -0.0000213846550f,
-            -0.0000239680794f,
-            -0.0000267667146f,
-            -0.0000297898005f,
-            -0.0000330474067f,
-            -0.0000365483596f,
-            -0.0000403021726f,
-            -0.0000443169994f,
-            -0.0000486015224f,
-            -0.0000531629366f,
-            -0.0000580087933f,
-            -0.0000631450183f,
-            -0.0000685777077f,
-            -0.0000743111852f,
-            -0.0000803497472f,
-            -0.0000866957632f,
-            -0.0000933513680f,
-            -0.0001003166088f,
-            -0.0001075910834f,
-            -0.0001151721377f,
-            -0.0001230564481f,
-            -0.0001312382737f,
-            -0.0001397109815f,
-            -0.0001484653574f,
-            -0.0001574910729f,
-            -0.0001667750594f,
-            -0.0001763029154f,
-            -0.0001860573478f,
-            -0.0001960195192f,
-            -0.0002061675607f,
-            -0.0002164778583f,
-            -0.0002269236408f,
-            -0.0002374762065f,
-            -0.0002481035885f,
-            -0.0002587717224f,
-            -0.0002694431931f,
-            -0.0002800783421f,
-            -0.0002906341007f,
-            -0.0003010650378f,
-            -0.0003113222805f,
-            -0.0003213545042f,
-            -0.0003311069438f,
-            -0.0003405223259f,
-            -0.0003495399742f,
-            -0.0003580966832f,
-            -0.0003661259202f,
-            -0.0003735586428f,
-            -0.0003803225975f,
-            -0.0003863430819f,
-            -0.0003915423426f,
-            -0.0003958402819f,
-            -0.0003991539556f,
-            -0.0004013982252f,
-            -0.0004024853566f,
-            -0.0004023256179f,
-            -0.0004008269786f,
-            -0.0003978956543f,
-            -0.0003934359050f,
-            -0.0003873505277f,
-            -0.0003795407527f,
-            -0.0003699066836f,
-            -0.0003583472905f,
-            -0.0003447607977f,
-            -0.0003290447712f,
-            -0.0003110964540f,
-            -0.0002908129452f,
-            -0.0002680914824f,
-            -0.0002428297099f,
-            -0.0002149259070f,
-            -0.0001842793414f,
-            -0.0001507904431f,
-            -0.0001143612390f,
-            -0.0000748954712f,
-            -0.0000322991074f,
-            0.0000135195964f,
-            0.0000626495149f,
-            0.0001151766480f,
-            0.0001711834750f,
-            0.0002307490067f,
-            0.0002939480814f,
-            0.0003608514761f,
-            0.0004315251498f,
-            0.0005060304153f,
-            0.0005844231367f,
-            0.0006667539631f,
-            0.0007530674871f,
-            0.0008434025410f,
-            0.0009377913237f,
-            0.0010362597605f,
-            0.0011388266053f,
-            0.0012455038652f,
-            0.0013562958844f,
-            0.0014711998354f,
-            0.0015902047905f,
-            0.0017132922802f,
-            0.0018404353607f,
-            0.0019715992373f,
-            0.0021067403358f,
-            0.0022458069916f,
-            0.0023887385299f,
-            0.0025354660208f,
-            0.0026859113741f,
-            0.0028399881592f,
-            0.0029976007211f,
-            0.0031586450629f,
-            0.0033230079887f,
-            0.0034905680464f,
-            0.0036611947020f,
-            0.0038347493416f,
-            0.0040110844803f,
-            0.0041900448203f,
-            0.0043714664990f,
-            0.0045551781983f,
-            0.0047410004367f,
-            0.0049287467249f,
-            0.0051182229035f,
-            0.0053092283419f,
-            0.0055015553224f,
-            0.0056949902776f,
-            0.0058893132225f,
-            0.0060842990234f,
-            0.0062797168802f,
-            0.0064753316199f,
-            0.0066709032288f,
-            0.0068661881644f,
-            0.0070609389367f,
-            0.0072549054317f,
-            0.0074478345403f,
-            0.0076394714860f,
-            0.0078295595003f,
-            0.0080178411460f,
-            0.0082040580375f,
-            0.0083879521517f,
-            0.0085692655900f,
-            0.0087477418693f,
-            0.0089231257234f,
-            0.0090951643643f,
-            0.0092636073201f,
-            0.0094282076595f,
-            0.0095887218614f,
-            0.0097449109950f,
-            0.0098965406177f,
-            0.0100433819014f,
-            0.0101852115568f,
-            0.0103218128967f,
-            0.0104529757832f,
-            0.0105784976211f,
-            0.0106981833229f,
-            0.0108118462264f,
-            0.0109193080737f,
-            0.0110203998455f,
-            0.0111149617515f,
-            0.0112028439747f,
-            0.0112839066704f,
-            0.0113580206147f,
-            0.0114250672088f,
-            0.0114849390277f,
-            0.0115375398269f,
-            0.0115827849866f,
-            0.0116206015194f,
-            0.0116509284062f,
-            0.0116737166029f,
-            0.0116889292662f,
-            0.0116965417578f,
-            0.0116965417578f,
-            0.0116889292662f,
-            0.0116737166029f,
-            0.0116509284062f,
-            0.0116206015194f,
-            0.0115827849866f,
-            0.0115375398269f,
-            0.0114849390277f,
-            0.0114250672088f,
-            0.0113580206147f,
-            0.0112839066704f,
-            0.0112028439747f,
-            0.0111149617515f,
-            0.0110203998455f,
-            0.0109193080737f,
-            0.0108118462264f,
-            0.0106981833229f,
-            0.0105784976211f,
-            0.0104529757832f,
-            0.0103218128967f,
-            0.0101852115568f,
-            0.0100433819014f,
-            0.0098965406177f,
-            0.0097449109950f,
-            0.0095887218614f,
-            0.0094282076595f,
-            0.0092636073201f,
-            0.0090951643643f,
-            0.0089231257234f,
-            0.0087477418693f,
-            0.0085692655900f,
-            0.0083879521517f,
-            0.0082040580375f,
-            0.0080178411460f,
-            0.0078295595003f,
-            0.0076394714860f,
-            0.0074478345403f,
-            0.0072549054317f,
-            0.0070609389367f,
-            0.0068661881644f,
-            0.0066709032288f,
-            0.0064753316199f,
-            0.0062797168802f,
-            0.0060842990234f,
-            0.0058893132225f,
-            0.0056949902776f,
-            0.0055015553224f,
-            0.0053092283419f,
-            0.0051182229035f,
-            0.0049287467249f,
-            0.0047410004367f,
-            0.0045551781983f,
-            0.0043714664990f,
-            0.0041900448203f,
-            0.0040110844803f,
-            0.0038347493416f,
-            0.0036611947020f,
-            0.0034905680464f,
-            0.0033230079887f,
-            0.0031586450629f,
-            0.0029976007211f,
-            0.0028399881592f,
-            0.0026859113741f,
-            0.0025354660208f,
-            0.0023887385299f,
-            0.0022458069916f,
-            0.0021067403358f,
-            0.0019715992373f,
-            0.0018404353607f,
-            0.0017132922802f,
-            0.0015902047905f,
-            0.0014711998354f,
-            0.0013562958844f,
-            0.0012455038652f,
-            0.0011388266053f,
-            0.0010362597605f,
-            0.0009377913237f,
-            0.0008434025410f,
-            0.0007530674871f,
-            0.0006667539631f,
-            0.0005844231367f,
-            0.0005060304153f,
-            0.0004315251498f,
-            0.0003608514761f,
-            0.0002939480814f,
-            0.0002307490067f,
-            0.0001711834750f,
-            0.0001151766480f,
-            0.0000626495149f,
-            0.0000135195964f,
-            -0.0000322991074f,
-            -0.0000748954712f,
-            -0.0001143612390f,
-            -0.0001507904431f,
-            -0.0001842793414f,
-            -0.0002149259070f,
-            -0.0002428297099f,
-            -0.0002680914824f,
-            -0.0002908129452f,
-            -0.0003110964540f,
-            -0.0003290447712f,
-            -0.0003447607977f,
-            -0.0003583472905f,
-            -0.0003699066836f,
-            -0.0003795407527f,
-            -0.0003873505277f,
-            -0.0003934359050f,
-            -0.0003978956543f,
-            -0.0004008269786f,
-            -0.0004023256179f,
-            -0.0004024853566f,
-            -0.0004013982252f,
-            -0.0003991539556f,
-            -0.0003958402819f,
-            -0.0003915423426f,
-            -0.0003863430819f,
-            -0.0003803225975f,
-            -0.0003735586428f,
-            -0.0003661259202f,
-            -0.0003580966832f,
-            -0.0003495399742f,
-            -0.0003405223259f,
-            -0.0003311069438f,
-            -0.0003213545042f,
-            -0.0003113222805f,
-            -0.0003010650378f,
-            -0.0002906341007f,
-            -0.0002800783421f,
-            -0.0002694431931f,
-            -0.0002587717224f,
-            -0.0002481035885f,
-            -0.0002374762065f,
-            -0.0002269236408f,
-            -0.0002164778583f,
-            -0.0002061675607f,
-            -0.0001960195192f,
-            -0.0001860573478f,
-            -0.0001763029154f,
-            -0.0001667750594f,
-            -0.0001574910729f,
-            -0.0001484653574f,
-            -0.0001397109815f,
-            -0.0001312382737f,
-            -0.0001230564481f,
-            -0.0001151721377f,
-            -0.0001075910834f,
-            -0.0001003166088f,
-            -0.0000933513680f,
-            -0.0000866957632f,
-            -0.0000803497472f,
-            -0.0000743111852f,
-            -0.0000685777077f,
-            -0.0000631450183f,
-            -0.0000580087933f,
-            -0.0000531629366f,
-            -0.0000486015224f,
-            -0.0000443169994f,
-            -0.0000403021726f,
-            -0.0000365483596f,
-            -0.0000330474067f,
-            -0.0000297898005f,
-            -0.0000267667146f,
-            -0.0000239680794f,
-            -0.0000213846550f,
-            -0.0000190060632f,
-            -0.0000168228827f,
-            -0.0000148246460f,
-            -0.0000130019541f,
-            -0.0000113444414f,
-            -0.0000098429063f,
-            -0.0000084872485f,
-            -0.0000072686109f,
-            -0.0000061772939f,
-            -0.0000052049053f,
-            -0.0000043422553f,
-            -0.0000035815110f,
-            -0.0000029140762f,
-            -0.0000062681742f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_256_8.h

@@ -1,46 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_256_8_len = 32;
-        const float fir_256_8_taps[] = {
-            0.0000481199958f,
-            0.0002120253977f,
-            0.0006339322060f,
-            0.0015268611634f,
-            0.0031751774844f,
-            0.0059080996632f,
-            0.0100482128498f,
-            0.0158389158363f,
-            0.0233630301033f,
-            0.0324710705948f,
-            0.0427398820012f,
-            0.0534789041603f,
-            0.0637922520572f,
-            0.0726919132761f,
-            0.0792439704433f,
-            0.0827196815814f,
-            0.0827196815814f,
-            0.0792439704433f,
-            0.0726919132761f,
-            0.0637922520572f,
-            0.0534789041603f,
-            0.0427398820012f,
-            0.0324710705948f,
-            0.0233630301033f,
-            0.0158389158363f,
-            0.0100482128498f,
-            0.0059080996632f,
-            0.0031751774844f,
-            0.0015268611634f,
-            0.0006339322060f,
-            0.0002120253977f,
-            0.0000481199958f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_2_2.h

@@ -1,83 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_2_2_len = 69;
-        const float fir_2_2_taps[] = {
-            0.0004006336249f,
-            0.0020755985056f,
-            0.0048563649567f,
-            0.0059790166982f,
-            0.0026229226079f,
-            -0.0027182591526f,
-            -0.0033815336714f,
-            0.0016386385398f,
-            0.0040818147060f,
-            -0.0009840292282f,
-            -0.0051209884701f,
-            0.0001774409073f,
-            0.0064258526620f,
-            0.0010093516023f,
-            -0.0079128279100f,
-            -0.0027137006752f,
-            0.0095093112574f,
-            0.0050706357235f,
-            -0.0111540204771f,
-            -0.0082460599199f,
-            0.0127857167873f,
-            0.0124879068372f,
-            -0.0143474523867f,
-            -0.0182057708485f,
-            0.0157818585768f,
-            0.0261723747167f,
-            -0.0170376434096f,
-            -0.0380514893049f,
-            0.0180670706247f,
-            0.0582124126716f,
-            -0.0188323041841f,
-            -0.1027724866049f,
-            0.0193031650356f,
-            0.3171894887336f,
-            0.4805375200904f,
-            0.3171894887336f,
-            0.0193031650356f,
-            -0.1027724866049f,
-            -0.0188323041841f,
-            0.0582124126716f,
-            0.0180670706247f,
-            -0.0380514893049f,
-            -0.0170376434096f,
-            0.0261723747167f,
-            0.0157818585768f,
-            -0.0182057708485f,
-            -0.0143474523867f,
-            0.0124879068372f,
-            0.0127857167873f,
-            -0.0082460599199f,
-            -0.0111540204771f,
-            0.0050706357235f,
-            0.0095093112574f,
-            -0.0027137006752f,
-            -0.0079128279100f,
-            0.0010093516023f,
-            0.0064258526620f,
-            0.0001774409073f,
-            -0.0051209884701f,
-            -0.0009840292282f,
-            0.0040818147060f,
-            0.0016386385398f,
-            -0.0033815336714f,
-            -0.0027182591526f,
-            0.0026229226079f,
-            0.0059790166982f,
-            0.0048563649567f,
-            0.0020755985056f,
-            0.0004006336249f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_32_16.h

@@ -1,142 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_32_16_len = 128;
-        const float fir_32_16_taps[] = {
-            0.0000099342222f,
-            0.0000146490348f,
-            0.0000247646101f,
-            0.0000387541309f,
-            0.0000572736657f,
-            0.0000808761926f,
-            0.0001099349979f,
-            0.0001445574213f,
-            0.0001844922748f,
-            0.0002290353727f,
-            0.0002769386619f,
-            0.0003263293316f,
-            0.0003746459569f,
-            0.0004185990900f,
-            0.0004541637106f,
-            0.0004766105134f,
-            0.0004805821127f,
-            0.0004602188681f,
-            0.0004093371919f,
-            0.0003216609257f,
-            0.0001911037388f,
-            0.0000120976033f,
-            -0.0002200406423f,
-            -0.0005087156694f,
-            -0.0008556468821f,
-            -0.0012604649511f,
-            -0.0017203301735f,
-            -0.0022295925790f,
-            -0.0027795143093f,
-            -0.0033580744939f,
-            -0.0039498755635f,
-            -0.0045361676357f,
-            -0.0050950043052f,
-            -0.0056015389258f,
-            -0.0060284654152f,
-            -0.0063466019019f,
-            -0.0065256093963f,
-            -0.0065348313327f,
-            -0.0063442336013f,
-            -0.0059254188348f,
-            -0.0052526835481f,
-            -0.0043040825207f,
-            -0.0030624618152f,
-            -0.0015164202550f,
-            0.0003388408046f,
-            0.0025008178935f,
-            0.0049591911398f,
-            0.0076955253725f,
-            0.0106832101994f,
-            0.0138876548446f,
-            0.0172667447174f,
-            0.0207715571925f,
-            0.0243473242916f,
-            0.0279346202686f,
-            0.0314707429314f,
-            0.0348912492894f,
-            0.0381315991625f,
-            0.0411288550641f,
-            0.0438233832299f,
-            0.0461604993011f,
-            0.0480920029752f,
-            0.0495775489259f,
-            0.0505858063661f,
-            0.0510953666101f,
-            0.0510953666101f,
-            0.0505858063661f,
-            0.0495775489259f,
-            0.0480920029752f,
-            0.0461604993011f,
-            0.0438233832299f,
-            0.0411288550641f,
-            0.0381315991625f,
-            0.0348912492894f,
-            0.0314707429314f,
-            0.0279346202686f,
-            0.0243473242916f,
-            0.0207715571925f,
-            0.0172667447174f,
-            0.0138876548446f,
-            0.0106832101994f,
-            0.0076955253725f,
-            0.0049591911398f,
-            0.0025008178935f,
-            0.0003388408046f,
-            -0.0015164202550f,
-            -0.0030624618152f,
-            -0.0043040825207f,
-            -0.0052526835481f,
-            -0.0059254188348f,
-            -0.0063442336013f,
-            -0.0065348313327f,
-            -0.0065256093963f,
-            -0.0063466019019f,
-            -0.0060284654152f,
-            -0.0056015389258f,
-            -0.0050950043052f,
-            -0.0045361676357f,
-            -0.0039498755635f,
-            -0.0033580744939f,
-            -0.0027795143093f,
-            -0.0022295925790f,
-            -0.0017203301735f,
-            -0.0012604649511f,
-            -0.0008556468821f,
-            -0.0005087156694f,
-            -0.0002200406423f,
-            0.0000120976033f,
-            0.0001911037388f,
-            0.0003216609257f,
-            0.0004093371919f,
-            0.0004602188681f,
-            0.0004805821127f,
-            0.0004766105134f,
-            0.0004541637106f,
-            0.0004185990900f,
-            0.0003746459569f,
-            0.0003263293316f,
-            0.0002769386619f,
-            0.0002290353727f,
-            0.0001844922748f,
-            0.0001445574213f,
-            0.0001099349979f,
-            0.0000808761926f,
-            0.0000572736657f,
-            0.0000387541309f,
-            0.0000247646101f,
-            0.0000146490348f,
-            0.0000099342222f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_32_2.h

@@ -1,20 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_32_2_len = 6;
-        const float fir_32_2_taps[] = {
-            0.0303426484663f,
-            0.1557222116669f,
-            0.3154225044548f,
-            0.3154225044548f,
-            0.1557222116669f,
-            0.0303426484663f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_32_4.h

@@ -1,31 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_32_4_len = 17;
-        const float fir_32_4_taps[] = {
-            0.0002602343386f,
-            0.0019197560804f,
-            0.0076270554566f,
-            0.0212647832351f,
-            0.0459374309886f,
-            0.0808345515056f,
-            0.1191594258092f,
-            0.1495554802033f,
-            0.1611781123721f,
-            0.1495554802033f,
-            0.1191594258092f,
-            0.0808345515056f,
-            0.0459374309886f,
-            0.0212647832351f,
-            0.0076270554566f,
-            0.0019197560804f,
-            0.0002602343386f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_32_8.h

@@ -1,59 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_32_8_len = 45;
-        const float fir_32_8_taps[] = {
-            -0.0000309582228f,
-            -0.0001079580167f,
-            -0.0002728448293f,
-            -0.0005651806741f,
-            -0.0010146553103f,
-            -0.0016201042973f,
-            -0.0023253502129f,
-            -0.0029961993139f,
-            -0.0034054389929f,
-            -0.0032331082459f,
-            -0.0020878393215f,
-            0.0004484139474f,
-            0.0047549865150f,
-            0.0110947837587f,
-            0.0195373899494f,
-            0.0298988087157f,
-            0.0417130694495f,
-            0.0542467727184f,
-            0.0665603957204f,
-            0.0776111715593f,
-            0.0863835049898f,
-            0.0920262381310f,
-            0.0939733024676f,
-            0.0920262381310f,
-            0.0863835049898f,
-            0.0776111715593f,
-            0.0665603957204f,
-            0.0542467727184f,
-            0.0417130694495f,
-            0.0298988087157f,
-            0.0195373899494f,
-            0.0110947837587f,
-            0.0047549865150f,
-            0.0004484139474f,
-            -0.0020878393215f,
-            -0.0032331082459f,
-            -0.0034054389929f,
-            -0.0029961993139f,
-            -0.0023253502129f,
-            -0.0016201042973f,
-            -0.0010146553103f,
-            -0.0005651806741f,
-            -0.0002728448293f,
-            -0.0001079580167f,
-            -0.0000309582228f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_4096_128.h

@@ -1,701 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_4096_128_len = 687;
-        const float fir_4096_128_taps[] = {
-            -0.0000001853079f,
-            -0.0000000346264f,
-            -0.0000000376411f,
-            -0.0000000406683f,
-            -0.0000000436847f,
-            -0.0000000466640f,
-            -0.0000000495767f,
-            -0.0000000523896f,
-            -0.0000000550661f,
-            -0.0000000575654f,
-            -0.0000000598428f,
-            -0.0000000618489f,
-            -0.0000000635299f,
-            -0.0000000648269f,
-            -0.0000000656757f,
-            -0.0000000660068f,
-            -0.0000000657448f,
-            -0.0000000648081f,
-            -0.0000000631089f,
-            -0.0000000605524f,
-            -0.0000000570369f,
-            -0.0000000524531f,
-            -0.0000000466841f,
-            -0.0000000396046f,
-            -0.0000000310810f,
-            -0.0000000209706f,
-            -0.0000000091215f,
-            0.0000000046280f,
-            0.0000000204496f,
-            0.0000000385257f,
-            0.0000000590497f,
-            0.0000000822264f,
-            0.0000001082725f,
-            0.0000001374170f,
-            0.0000001699018f,
-            0.0000002059821f,
-            0.0000002459268f,
-            0.0000002900194f,
-            0.0000003385579f,
-            0.0000003918557f,
-            0.0000004502420f,
-            0.0000005140626f,
-            0.0000005836800f,
-            0.0000006594741f,
-            0.0000007418430f,
-            0.0000008312033f,
-            0.0000009279907f,
-            0.0000010326607f,
-            0.0000011456888f,
-            0.0000012675717f,
-            0.0000013988273f,
-            0.0000015399957f,
-            0.0000016916395f,
-            0.0000018543446f,
-            0.0000020287205f,
-            0.0000022154015f,
-            0.0000024150466f,
-            0.0000026283404f,
-            0.0000028559940f,
-            0.0000030987450f,
-            0.0000033573588f,
-            0.0000036326283f,
-            0.0000039253756f,
-            0.0000042364515f,
-            0.0000045667370f,
-            0.0000049171433f,
-            0.0000052886125f,
-            0.0000056821186f,
-            0.0000060986673f,
-            0.0000065392974f,
-            0.0000070050805f,
-            0.0000074971223f,
-            0.0000080165629f,
-            0.0000085645769f,
-            0.0000091423747f,
-            0.0000097512023f,
-            0.0000103923421f,
-            0.0000110671135f,
-            0.0000117768730f,
-            0.0000125230151f,
-            0.0000133069722f,
-            0.0000141302156f,
-            0.0000149942554f,
-            0.0000159006412f,
-            0.0000168509623f,
-            0.0000178468480f,
-            0.0000188899682f,
-            0.0000199820332f,
-            0.0000211247945f,
-            0.0000223200446f,
-            0.0000235696176f,
-            0.0000248753891f,
-            0.0000262392764f,
-            0.0000276632389f,
-            0.0000291492778f,
-            0.0000306994366f,
-            0.0000323158008f,
-            0.0000340004981f,
-            0.0000357556983f,
-            0.0000375836134f,
-            0.0000394864972f,
-            0.0000414666457f,
-            0.0000435263962f,
-            0.0000456681279f,
-            0.0000478942611f,
-            0.0000502072572f,
-            0.0000526096182f,
-            0.0000551038867f,
-            0.0000576926449f,
-            0.0000603785150f,
-            0.0000631641580f,
-            0.0000660522733f,
-            0.0000690455987f,
-            0.0000721469091f,
-            0.0000753590162f,
-            0.0000786847678f,
-            0.0000821270469f,
-            0.0000856887711f,
-            0.0000893728917f,
-            0.0000931823927f,
-            0.0000971202902f,
-            0.0001011896310f,
-            0.0001053934918f,
-            0.0001097349782f,
-            0.0001142172235f,
-            0.0001188433875f,
-            0.0001236166552f,
-            0.0001285402359f,
-            0.0001336173613f,
-            0.0001388512848f,
-            0.0001442452795f,
-            0.0001498026371f,
-            0.0001555266664f,
-            0.0001614206914f,
-            0.0001674880501f,
-            0.0001737320925f,
-            0.0001801561792f,
-            0.0001867636795f,
-            0.0001935579694f,
-            0.0002005424304f,
-            0.0002077204468f,
-            0.0002150954042f,
-            0.0002226706877f,
-            0.0002304496792f,
-            0.0002384357564f,
-            0.0002466322894f,
-            0.0002550426396f,
-            0.0002636701572f,
-            0.0002725181784f,
-            0.0002815900242f,
-            0.0002908889972f,
-            0.0003004183794f,
-            0.0003101814303f,
-            0.0003201813839f,
-            0.0003304214468f,
-            0.0003409047951f,
-            0.0003516345723f,
-            0.0003626138868f,
-            0.0003738458092f,
-            0.0003853333694f,
-            0.0003970795547f,
-            0.0004090873065f,
-            0.0004213595178f,
-            0.0004338990308f,
-            0.0004467086339f,
-            0.0004597910591f,
-            0.0004731489791f,
-            0.0004867850049f,
-            0.0005007016827f,
-            0.0005149014913f,
-            0.0005293868393f,
-            0.0005441600623f,
-            0.0005592234204f,
-            0.0005745790947f,
-            0.0005902291855f,
-            0.0006061757086f,
-            0.0006224205933f,
-            0.0006389656791f,
-            0.0006558127133f,
-            0.0006729633479f,
-            0.0006904191373f,
-            0.0007081815354f,
-            0.0007262518929f,
-            0.0007446314546f,
-            0.0007633213568f,
-            0.0007823226250f,
-            0.0008016361709f,
-            0.0008212627897f,
-            0.0008412031585f,
-            0.0008614578327f,
-            0.0008820272443f,
-            0.0009029116994f,
-            0.0009241113755f,
-            0.0009456263198f,
-            0.0009674564462f,
-            0.0009896015337f,
-            0.0010120612242f,
-            0.0010348350198f,
-            0.0010579222817f,
-            0.0010813222275f,
-            0.0011050339296f,
-            0.0011290563132f,
-            0.0011533881548f,
-            0.0011780280801f,
-            0.0012029745628f,
-            0.0012282259227f,
-            0.0012537803242f,
-            0.0012796357754f,
-            0.0013057901260f,
-            0.0013322410668f,
-            0.0013589861279f,
-            0.0013860226783f,
-            0.0014133479243f,
-            0.0014409589089f,
-            0.0014688525111f,
-            0.0014970254450f,
-            0.0015254742592f,
-            0.0015541953364f,
-            0.0015831848930f,
-            0.0016124389787f,
-            0.0016419534764f,
-            0.0016717241017f,
-            0.0017017464036f,
-            0.0017320157641f,
-            0.0017625273983f,
-            0.0017932763553f,
-            0.0018242575180f,
-            0.0018554656041f,
-            0.0018868951663f,
-            0.0019185405936f,
-            0.0019503961118f,
-            0.0019824557844f,
-            0.0020147135141f,
-            0.0020471630437f,
-            0.0020797979574f,
-            0.0021126116823f,
-            0.0021455974903f,
-            0.0021787484991f,
-            0.0022120576745f,
-            0.0022455178321f,
-            0.0022791216394f,
-            0.0023128616177f,
-            0.0023467301445f,
-            0.0023807194560f,
-            0.0024148216493f,
-            0.0024490286850f,
-            0.0024833323899f,
-            0.0025177244601f,
-            0.0025521964633f,
-            0.0025867398422f,
-            0.0026213459177f,
-            0.0026560058918f,
-            0.0026907108512f,
-            0.0027254517703f,
-            0.0027602195153f,
-            0.0027950048475f,
-            0.0028297984269f,
-            0.0028645908163f,
-            0.0028993724850f,
-            0.0029341338127f,
-            0.0029688650939f,
-            0.0030035565421f,
-            0.0030381982934f,
-            0.0030727804117f,
-            0.0031072928924f,
-            0.0031417256676f,
-            0.0031760686099f,
-            0.0032103115375f,
-            0.0032444442190f,
-            0.0032784563779f,
-            0.0033123376974f,
-            0.0033460778257f,
-            0.0033796663804f,
-            0.0034130929541f,
-            0.0034463471189f,
-            0.0034794184319f,
-            0.0035122964401f,
-            0.0035449706860f,
-            0.0035774307122f,
-            0.0036096660671f,
-            0.0036416663102f,
-            0.0036734210173f,
-            0.0037049197858f,
-            0.0037361522402f,
-            0.0037671080372f,
-            0.0037977768717f,
-            0.0038281484815f,
-            0.0038582126530f,
-            0.0038879592268f,
-            0.0039173781029f,
-            0.0039464592460f,
-            0.0039751926911f,
-            0.0040035685488f,
-            0.0040315770105f,
-            0.0040592083542f,
-            0.0040864529492f,
-            0.0041133012618f,
-            0.0041397438603f,
-            0.0041657714205f,
-            0.0041913747306f,
-            0.0042165446965f,
-            0.0042412723466f,
-            0.0042655488373f,
-            0.0042893654574f,
-            0.0043127136335f,
-            0.0043355849347f,
-            0.0043579710770f,
-            0.0043798639286f,
-            0.0044012555142f,
-            0.0044221380197f,
-            0.0044425037963f,
-            0.0044623453655f,
-            0.0044816554230f,
-            0.0045004268430f,
-            0.0045186526821f,
-            0.0045363261840f,
-            0.0045534407824f,
-            0.0045699901059f,
-            0.0045859679809f,
-            0.0046013684356f,
-            0.0046161857032f,
-            0.0046304142258f,
-            0.0046440486570f,
-            0.0046570838656f,
-            0.0046695149383f,
-            0.0046813371826f,
-            0.0046925461296f,
-            0.0047031375370f,
-            0.0047131073910f,
-            0.0047224519091f,
-            0.0047311675420f,
-            0.0047392509762f,
-            0.0047466991355f,
-            0.0047535091831f,
-            0.0047596785231f,
-            0.0047652048022f,
-            0.0047700859110f,
-            0.0047743199853f,
-            0.0047779054073f,
-            0.0047808408063f,
-            0.0047831250597f,
-            0.0047847572939f,
-            0.0047857368844f,
-            0.0047860634562f,
-            0.0047857368844f,
-            0.0047847572939f,
-            0.0047831250597f,
-            0.0047808408063f,
-            0.0047779054073f,
-            0.0047743199853f,
-            0.0047700859110f,
-            0.0047652048022f,
-            0.0047596785231f,
-            0.0047535091831f,
-            0.0047466991355f,
-            0.0047392509762f,
-            0.0047311675420f,
-            0.0047224519091f,
-            0.0047131073910f,
-            0.0047031375370f,
-            0.0046925461296f,
-            0.0046813371826f,
-            0.0046695149383f,
-            0.0046570838656f,
-            0.0046440486570f,
-            0.0046304142258f,
-            0.0046161857032f,
-            0.0046013684356f,
-            0.0045859679809f,
-            0.0045699901059f,
-            0.0045534407824f,
-            0.0045363261840f,
-            0.0045186526821f,
-            0.0045004268430f,
-            0.0044816554230f,
-            0.0044623453655f,
-            0.0044425037963f,
-            0.0044221380197f,
-            0.0044012555142f,
-            0.0043798639286f,
-            0.0043579710770f,
-            0.0043355849347f,
-            0.0043127136335f,
-            0.0042893654574f,
-            0.0042655488373f,
-            0.0042412723466f,
-            0.0042165446965f,
-            0.0041913747306f,
-            0.0041657714205f,
-            0.0041397438603f,
-            0.0041133012618f,
-            0.0040864529492f,
-            0.0040592083542f,
-            0.0040315770105f,
-            0.0040035685488f,
-            0.0039751926911f,
-            0.0039464592460f,
-            0.0039173781029f,
-            0.0038879592268f,
-            0.0038582126530f,
-            0.0038281484815f,
-            0.0037977768717f,
-            0.0037671080372f,
-            0.0037361522402f,
-            0.0037049197858f,
-            0.0036734210173f,
-            0.0036416663102f,
-            0.0036096660671f,
-            0.0035774307122f,
-            0.0035449706860f,
-            0.0035122964401f,
-            0.0034794184319f,
-            0.0034463471189f,
-            0.0034130929541f,
-            0.0033796663804f,
-            0.0033460778257f,
-            0.0033123376974f,
-            0.0032784563779f,
-            0.0032444442190f,
-            0.0032103115375f,
-            0.0031760686099f,
-            0.0031417256676f,
-            0.0031072928924f,
-            0.0030727804117f,
-            0.0030381982934f,
-            0.0030035565421f,
-            0.0029688650939f,
-            0.0029341338127f,
-            0.0028993724850f,
-            0.0028645908163f,
-            0.0028297984269f,
-            0.0027950048475f,
-            0.0027602195153f,
-            0.0027254517703f,
-            0.0026907108512f,
-            0.0026560058918f,
-            0.0026213459177f,
-            0.0025867398422f,
-            0.0025521964633f,
-            0.0025177244601f,
-            0.0024833323899f,
-            0.0024490286850f,
-            0.0024148216493f,
-            0.0023807194560f,
-            0.0023467301445f,
-            0.0023128616177f,
-            0.0022791216394f,
-            0.0022455178321f,
-            0.0022120576745f,
-            0.0021787484991f,
-            0.0021455974903f,
-            0.0021126116823f,
-            0.0020797979574f,
-            0.0020471630437f,
-            0.0020147135141f,
-            0.0019824557844f,
-            0.0019503961118f,
-            0.0019185405936f,
-            0.0018868951663f,
-            0.0018554656041f,
-            0.0018242575180f,
-            0.0017932763553f,
-            0.0017625273983f,
-            0.0017320157641f,
-            0.0017017464036f,
-            0.0016717241017f,
-            0.0016419534764f,
-            0.0016124389787f,
-            0.0015831848930f,
-            0.0015541953364f,
-            0.0015254742592f,
-            0.0014970254450f,
-            0.0014688525111f,
-            0.0014409589089f,
-            0.0014133479243f,
-            0.0013860226783f,
-            0.0013589861279f,
-            0.0013322410668f,
-            0.0013057901260f,
-            0.0012796357754f,
-            0.0012537803242f,
-            0.0012282259227f,
-            0.0012029745628f,
-            0.0011780280801f,
-            0.0011533881548f,
-            0.0011290563132f,
-            0.0011050339296f,
-            0.0010813222275f,
-            0.0010579222817f,
-            0.0010348350198f,
-            0.0010120612242f,
-            0.0009896015337f,
-            0.0009674564462f,
-            0.0009456263198f,
-            0.0009241113755f,
-            0.0009029116994f,
-            0.0008820272443f,
-            0.0008614578327f,
-            0.0008412031585f,
-            0.0008212627897f,
-            0.0008016361709f,
-            0.0007823226250f,
-            0.0007633213568f,
-            0.0007446314546f,
-            0.0007262518929f,
-            0.0007081815354f,
-            0.0006904191373f,
-            0.0006729633479f,
-            0.0006558127133f,
-            0.0006389656791f,
-            0.0006224205933f,
-            0.0006061757086f,
-            0.0005902291855f,
-            0.0005745790947f,
-            0.0005592234204f,
-            0.0005441600623f,
-            0.0005293868393f,
-            0.0005149014913f,
-            0.0005007016827f,
-            0.0004867850049f,
-            0.0004731489791f,
-            0.0004597910591f,
-            0.0004467086339f,
-            0.0004338990308f,
-            0.0004213595178f,
-            0.0004090873065f,
-            0.0003970795547f,
-            0.0003853333694f,
-            0.0003738458092f,
-            0.0003626138868f,
-            0.0003516345723f,
-            0.0003409047951f,
-            0.0003304214468f,
-            0.0003201813839f,
-            0.0003101814303f,
-            0.0003004183794f,
-            0.0002908889972f,
-            0.0002815900242f,
-            0.0002725181784f,
-            0.0002636701572f,
-            0.0002550426396f,
-            0.0002466322894f,
-            0.0002384357564f,
-            0.0002304496792f,
-            0.0002226706877f,
-            0.0002150954042f,
-            0.0002077204468f,
-            0.0002005424304f,
-            0.0001935579694f,
-            0.0001867636795f,
-            0.0001801561792f,
-            0.0001737320925f,
-            0.0001674880501f,
-            0.0001614206914f,
-            0.0001555266664f,
-            0.0001498026371f,
-            0.0001442452795f,
-            0.0001388512848f,
-            0.0001336173613f,
-            0.0001285402359f,
-            0.0001236166552f,
-            0.0001188433875f,
-            0.0001142172235f,
-            0.0001097349782f,
-            0.0001053934918f,
-            0.0001011896310f,
-            0.0000971202902f,
-            0.0000931823927f,
-            0.0000893728917f,
-            0.0000856887711f,
-            0.0000821270469f,
-            0.0000786847678f,
-            0.0000753590162f,
-            0.0000721469091f,
-            0.0000690455987f,
-            0.0000660522733f,
-            0.0000631641580f,
-            0.0000603785150f,
-            0.0000576926449f,
-            0.0000551038867f,
-            0.0000526096182f,
-            0.0000502072572f,
-            0.0000478942611f,
-            0.0000456681279f,
-            0.0000435263962f,
-            0.0000414666457f,
-            0.0000394864972f,
-            0.0000375836134f,
-            0.0000357556983f,
-            0.0000340004981f,
-            0.0000323158008f,
-            0.0000306994366f,
-            0.0000291492778f,
-            0.0000276632389f,
-            0.0000262392764f,
-            0.0000248753891f,
-            0.0000235696176f,
-            0.0000223200446f,
-            0.0000211247945f,
-            0.0000199820332f,
-            0.0000188899682f,
-            0.0000178468480f,
-            0.0000168509623f,
-            0.0000159006412f,
-            0.0000149942554f,
-            0.0000141302156f,
-            0.0000133069722f,
-            0.0000125230151f,
-            0.0000117768730f,
-            0.0000110671135f,
-            0.0000103923421f,
-            0.0000097512023f,
-            0.0000091423747f,
-            0.0000085645769f,
-            0.0000080165629f,
-            0.0000074971223f,
-            0.0000070050805f,
-            0.0000065392974f,
-            0.0000060986673f,
-            0.0000056821186f,
-            0.0000052886125f,
-            0.0000049171433f,
-            0.0000045667370f,
-            0.0000042364515f,
-            0.0000039253756f,
-            0.0000036326283f,
-            0.0000033573588f,
-            0.0000030987450f,
-            0.0000028559940f,
-            0.0000026283404f,
-            0.0000024150466f,
-            0.0000022154015f,
-            0.0000020287205f,
-            0.0000018543446f,
-            0.0000016916395f,
-            0.0000015399957f,
-            0.0000013988273f,
-            0.0000012675717f,
-            0.0000011456888f,
-            0.0000010326607f,
-            0.0000009279907f,
-            0.0000008312033f,
-            0.0000007418430f,
-            0.0000006594741f,
-            0.0000005836800f,
-            0.0000005140626f,
-            0.0000004502420f,
-            0.0000003918557f,
-            0.0000003385579f,
-            0.0000002900194f,
-            0.0000002459268f,
-            0.0000002059821f,
-            0.0000001699018f,
-            0.0000001374170f,
-            0.0000001082725f,
-            0.0000000822264f,
-            0.0000000590497f,
-            0.0000000385257f,
-            0.0000000204496f,
-            0.0000000046280f,
-            -0.0000000091215f,
-            -0.0000000209706f,
-            -0.0000000310810f,
-            -0.0000000396046f,
-            -0.0000000466841f,
-            -0.0000000524531f,
-            -0.0000000570369f,
-            -0.0000000605524f,
-            -0.0000000631089f,
-            -0.0000000648081f,
-            -0.0000000657448f,
-            -0.0000000660068f,
-            -0.0000000656757f,
-            -0.0000000648269f,
-            -0.0000000635299f,
-            -0.0000000618489f,
-            -0.0000000598428f,
-            -0.0000000575654f,
-            -0.0000000550661f,
-            -0.0000000523896f,
-            -0.0000000495767f,
-            -0.0000000466640f,
-            -0.0000000436847f,
-            -0.0000000406683f,
-            -0.0000000376411f,
-            -0.0000000346264f,
-            -0.0000001853079f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_4_2.h

@@ -1,29 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_4_2_len = 15;
-        const float fir_4_2_taps[] = {
-            0.0021282968604f,
-            0.0076473554450f,
-            0.0006460703751f,
-            -0.0368053147543f,
-            -0.0516552094180f,
-            0.0659607033051f,
-            0.2951835298658f,
-            0.4189947458581f,
-            0.2951835298658f,
-            0.0659607033051f,
-            -0.0516552094180f,
-            -0.0368053147543f,
-            0.0006460703751f,
-            0.0076473554450f,
-            0.0021282968604f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_4_4.h

@@ -1,153 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_4_4_len = 139;
-        const float fir_4_4_taps[] = {
-            0.0000421670468f,
-            0.0001624808733f,
-            0.0004134748309f,
-            0.0008154887363f,
-            0.0013234848969f,
-            0.0018039325195f,
-            0.0020508055942f,
-            0.0018514767578f,
-            0.0010883586950f,
-            -0.0001655988021f,
-            -0.0016128396844f,
-            -0.0027991727988f,
-            -0.0032807371963f,
-            -0.0028309298807f,
-            -0.0015892963679f,
-            -0.0000601423367f,
-            0.0010721577127f,
-            0.0012520595571f,
-            0.0003467812959f,
-            -0.0012334913120f,
-            -0.0026828654998f,
-            -0.0031783401077f,
-            -0.0023201194397f,
-            -0.0004020929064f,
-            0.0016614376925f,
-            0.0027617271233f,
-            0.0021869815035f,
-            0.0000713073547f,
-            -0.0025708936840f,
-            -0.0043015122742f,
-            -0.0040150945520f,
-            -0.0016068800323f,
-            0.0018386741176f,
-            0.0045100483540f,
-            0.0048045475259f,
-            0.0022668636218f,
-            -0.0020047039996f,
-            -0.0057855488980f,
-            -0.0068496560241f,
-            -0.0042397202795f,
-            0.0010243185376f,
-            0.0062751930360f,
-            0.0085115122341f,
-            0.0060706031243f,
-            -0.0002476114409f,
-            -0.0073175117999f,
-            -0.0111703368494f,
-            -0.0091526981761f,
-            -0.0016211575907f,
-            0.0078514356977f,
-            0.0140732387192f,
-            0.0129726920823f,
-            0.0040874732850f,
-            -0.0086349542834f,
-            -0.0184139640743f,
-            -0.0190500116861f,
-            -0.0085456264258f,
-            0.0090399664680f,
-            0.0247932831806f,
-            0.0290341811985f,
-            0.0165603631688f,
-            -0.0095223462745f,
-            -0.0375695624710f,
-            -0.0514111407319f,
-            -0.0372217902165f,
-            0.0096794936561f,
-            0.0812862136678f,
-            0.1585522999585f,
-            0.2179171693939f,
-            0.2401648350457f,
-            0.2179171693939f,
-            0.1585522999585f,
-            0.0812862136678f,
-            0.0096794936561f,
-            -0.0372217902165f,
-            -0.0514111407319f,
-            -0.0375695624710f,
-            -0.0095223462745f,
-            0.0165603631688f,
-            0.0290341811985f,
-            0.0247932831806f,
-            0.0090399664680f,
-            -0.0085456264258f,
-            -0.0190500116861f,
-            -0.0184139640743f,
-            -0.0086349542834f,
-            0.0040874732850f,
-            0.0129726920823f,
-            0.0140732387192f,
-            0.0078514356977f,
-            -0.0016211575907f,
-            -0.0091526981761f,
-            -0.0111703368494f,
-            -0.0073175117999f,
-            -0.0002476114409f,
-            0.0060706031243f,
-            0.0085115122341f,
-            0.0062751930360f,
-            0.0010243185376f,
-            -0.0042397202795f,
-            -0.0068496560241f,
-            -0.0057855488980f,
-            -0.0020047039996f,
-            0.0022668636218f,
-            0.0048045475259f,
-            0.0045100483540f,
-            0.0018386741176f,
-            -0.0016068800323f,
-            -0.0040150945520f,
-            -0.0043015122742f,
-            -0.0025708936840f,
-            0.0000713073547f,
-            0.0021869815035f,
-            0.0027617271233f,
-            0.0016614376925f,
-            -0.0004020929064f,
-            -0.0023201194397f,
-            -0.0031783401077f,
-            -0.0026828654998f,
-            -0.0012334913120f,
-            0.0003467812959f,
-            0.0012520595571f,
-            0.0010721577127f,
-            -0.0000601423367f,
-            -0.0015892963679f,
-            -0.0028309298807f,
-            -0.0032807371963f,
-            -0.0027991727988f,
-            -0.0016128396844f,
-            -0.0001655988021f,
-            0.0010883586950f,
-            0.0018514767578f,
-            0.0020508055942f,
-            0.0018039325195f,
-            0.0013234848969f,
-            0.0008154887363f,
-            0.0004134748309f,
-            0.0001624808733f,
-            0.0000421670468f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_512_128.h

@@ -1,725 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_512_128_len = 711;
-        const float fir_512_128_taps[] = {
-            -0.0000055896992f,
-            -0.0000013001543f,
-            -0.0000014502329f,
-            -0.0000016110215f,
-            -0.0000017829984f,
-            -0.0000019666521f,
-            -0.0000021624812f,
-            -0.0000023709942f,
-            -0.0000025927091f,
-            -0.0000028281532f,
-            -0.0000030778629f,
-            -0.0000033423834f,
-            -0.0000036222682f,
-            -0.0000039180789f,
-            -0.0000042303847f,
-            -0.0000045597620f,
-            -0.0000049067942f,
-            -0.0000052720710f,
-            -0.0000056561877f,
-            -0.0000060597452f,
-            -0.0000064833493f,
-            -0.0000069276099f,
-            -0.0000073931405f,
-            -0.0000078805577f,
-            -0.0000083904807f,
-            -0.0000089235302f,
-            -0.0000094803279f,
-            -0.0000100614958f,
-            -0.0000106676557f,
-            -0.0000112994278f,
-            -0.0000119574304f,
-            -0.0000126422788f,
-            -0.0000133545848f,
-            -0.0000140949552f,
-            -0.0000148639914f,
-            -0.0000156622882f,
-            -0.0000164904329f,
-            -0.0000173490044f,
-            -0.0000182385717f,
-            -0.0000191596936f,
-            -0.0000201129171f,
-            -0.0000210987761f,
-            -0.0000221177911f,
-            -0.0000231704670f,
-            -0.0000242572927f,
-            -0.0000253787397f,
-            -0.0000265352606f,
-            -0.0000277272881f,
-            -0.0000289552338f,
-            -0.0000302194865f,
-            -0.0000315204114f,
-            -0.0000328583485f,
-            -0.0000342336112f,
-            -0.0000356464850f,
-            -0.0000370972263f,
-            -0.0000385860605f,
-            -0.0000401131811f,
-            -0.0000416787480f,
-            -0.0000432828861f,
-            -0.0000449256839f,
-            -0.0000466071919f,
-            -0.0000483274213f,
-            -0.0000500863422f,
-            -0.0000518838825f,
-            -0.0000537199261f,
-            -0.0000555943117f,
-            -0.0000575068307f,
-            -0.0000594572265f,
-            -0.0000614451922f,
-            -0.0000634703697f,
-            -0.0000655323476f,
-            -0.0000676306604f,
-            -0.0000697647864f,
-            -0.0000719341464f,
-            -0.0000741381022f,
-            -0.0000763759553f,
-            -0.0000786469450f,
-            -0.0000809502475f,
-            -0.0000832849740f,
-            -0.0000856501695f,
-            -0.0000880448112f,
-            -0.0000904678075f,
-            -0.0000929179961f,
-            -0.0000953941432f,
-            -0.0000978949415f,
-            -0.0001004190099f,
-            -0.0001029648911f,
-            -0.0001055310512f,
-            -0.0001081158783f,
-            -0.0001107176810f,
-            -0.0001133346877f,
-            -0.0001159650452f,
-            -0.0001186068179f,
-            -0.0001212579865f,
-            -0.0001239164473f,
-            -0.0001265800111f,
-            -0.0001292464023f,
-            -0.0001319132583f,
-            -0.0001345781284f,
-            -0.0001372384734f,
-            -0.0001398916645f,
-            -0.0001425349833f,
-            -0.0001451656204f,
-            -0.0001477806759f,
-            -0.0001503771580f,
-            -0.0001529519831f,
-            -0.0001555019757f,
-            -0.0001580238676f,
-            -0.0001605142982f,
-            -0.0001629698139f,
-            -0.0001653868686f,
-            -0.0001677618232f,
-            -0.0001700909463f,
-            -0.0001723704138f,
-            -0.0001745963094f,
-            -0.0001767646249f,
-            -0.0001788712607f,
-            -0.0001809120262f,
-            -0.0001828826403f,
-            -0.0001847787321f,
-            -0.0001865958418f,
-            -0.0001883294212f,
-            -0.0001899748350f,
-            -0.0001915273613f,
-            -0.0001929821931f,
-            -0.0001943344392f,
-            -0.0001955791256f,
-            -0.0001967111968f,
-            -0.0001977255172f,
-            -0.0001986168726f,
-            -0.0001993799720f,
-            -0.0002000094489f,
-            -0.0002004998634f,
-            -0.0002008457042f,
-            -0.0002010413902f,
-            -0.0002010812729f,
-            -0.0002009596382f,
-            -0.0002006707090f,
-            -0.0002002086476f,
-            -0.0001995675575f,
-            -0.0001987414866f,
-            -0.0001977244297f,
-            -0.0001965103308f,
-            -0.0001950930862f,
-            -0.0001934665474f,
-            -0.0001916245241f,
-            -0.0001895607869f,
-            -0.0001872690707f,
-            -0.0001847430782f,
-            -0.0001819764827f,
-            -0.0001789629316f,
-            -0.0001756960501f,
-            -0.0001721694447f,
-            -0.0001683767065f,
-            -0.0001643114154f,
-            -0.0001599671433f,
-            -0.0001553374586f,
-            -0.0001504159297f,
-            -0.0001451961290f,
-            -0.0001396716370f,
-            -0.0001338360466f,
-            -0.0001276829672f,
-            -0.0001212060287f,
-            -0.0001143988861f,
-            -0.0001072552238f,
-            -0.0000997687600f,
-            -0.0000919332511f,
-            -0.0000837424964f,
-            -0.0000751903422f,
-            -0.0000662706872f,
-            -0.0000569774862f,
-            -0.0000473047557f,
-            -0.0000372465778f,
-            -0.0000267971056f,
-            -0.0000159505676f,
-            -0.0000047012723f,
-            0.0000069563861f,
-            0.0000190279240f,
-            0.0000315187628f,
-            0.0000444342241f,
-            0.0000577795252f,
-            0.0000715597739f,
-            0.0000857799638f,
-            0.0001004449692f,
-            0.0001155595405f,
-            0.0001311282992f,
-            0.0001471557332f,
-            0.0001636461917f,
-            0.0001806038808f,
-            0.0001980328584f,
-            0.0002159370295f,
-            0.0002343201416f,
-            0.0002531857801f,
-            0.0002725373634f,
-            0.0002923781387f,
-            0.0003127111768f,
-            0.0003335393686f,
-            0.0003548654197f,
-            0.0003766918469f,
-            0.0003990209730f,
-            0.0004218549234f,
-            0.0004451956214f,
-            0.0004690447845f,
-            0.0004934039201f,
-            0.0005182743216f,
-            0.0005436570649f,
-            0.0005695530043f,
-            0.0005959627692f,
-            0.0006228867602f,
-            0.0006503251459f,
-            0.0006782778596f,
-            0.0007067445959f,
-            0.0007357248078f,
-            0.0007652177037f,
-            0.0007952222443f,
-            0.0008257371403f,
-            0.0008567608492f,
-            0.0008882915736f,
-            0.0009203272580f,
-            0.0009528655873f,
-            0.0009859039843f,
-            0.0010194396081f,
-            0.0010534693522f,
-            0.0010879898425f,
-            0.0011229974367f,
-            0.0011584882220f,
-            0.0011944580146f,
-            0.0012309023586f,
-            0.0012678165250f,
-            0.0013051955110f,
-            0.0013430340397f,
-            0.0013813265595f,
-            0.0014200672442f,
-            0.0014592499929f,
-            0.0014988684300f,
-            0.0015389159058f,
-            0.0015793854968f,
-            0.0016202700068f,
-            0.0016615619670f,
-            0.0017032536381f,
-            0.0017453370105f,
-            0.0017878038064f,
-            0.0018306454814f,
-            0.0018738532257f,
-            0.0019174179666f,
-            0.0019613303706f,
-            0.0020055808454f,
-            0.0020501595428f,
-            0.0020950563610f,
-            0.0021402609477f,
-            0.0021857627034f,
-            0.0022315507840f,
-            0.0022776141047f,
-            0.0023239413434f,
-            0.0023705209447f,
-            0.0024173411233f,
-            0.0024643898688f,
-            0.0025116549495f,
-            0.0025591239169f,
-            0.0026067841107f,
-            0.0026546226632f,
-            0.0027026265043f,
-            0.0027507823669f,
-            0.0027990767918f,
-            0.0028474961335f,
-            0.0028960265655f,
-            0.0029446540864f,
-            0.0029933645254f,
-            0.0030421435486f,
-            0.0030909766650f,
-            0.0031398492332f,
-            0.0031887464674f,
-            0.0032376534443f,
-            0.0032865551097f,
-            0.0033354362854f,
-            0.0033842816762f,
-            0.0034330758769f,
-            0.0034818033796f,
-            0.0035304485810f,
-            0.0035789957896f,
-            0.0036274292338f,
-            0.0036757330686f,
-            0.0037238913843f,
-            0.0037718882136f,
-            0.0038197075396f,
-            0.0038673333040f,
-            0.0039147494150f,
-            0.0039619397550f,
-            0.0040088881896f,
-            0.0040555785748f,
-            0.0041019947660f,
-            0.0041481206260f,
-            0.0041939400332f,
-            0.0042394368905f,
-            0.0042845951330f,
-            0.0043293987369f,
-            0.0043738317277f,
-            0.0044178781890f,
-            0.0044615222704f,
-            0.0045047481964f,
-            0.0045475402748f,
-            0.0045898829050f,
-            0.0046317605863f,
-            0.0046731579268f,
-            0.0047140596512f,
-            0.0047544506094f,
-            0.0047943157851f,
-            0.0048336403032f,
-            0.0048724094390f,
-            0.0049106086256f,
-            0.0049482234626f,
-            0.0049852397233f,
-            0.0050216433634f,
-            0.0050574205286f,
-            0.0050925575621f,
-            0.0051270410128f,
-            0.0051608576423f,
-            0.0051939944329f,
-            0.0052264385945f,
-            0.0052581775725f,
-            0.0052891990541f,
-            0.0053194909762f,
-            0.0053490415314f,
-            0.0053778391756f,
-            0.0054058726342f,
-            0.0054331309083f,
-            0.0054596032817f,
-            0.0054852793266f,
-            0.0055101489098f,
-            0.0055342021983f,
-            0.0055574296655f,
-            0.0055798220963f,
-            0.0056013705925f,
-            0.0056220665783f,
-            0.0056419018048f,
-            0.0056608683553f,
-            0.0056789586495f,
-            0.0056961654483f,
-            0.0057124818576f,
-            0.0057279013330f,
-            0.0057424176828f,
-            0.0057560250723f,
-            0.0057687180271f,
-            0.0057804914360f,
-            0.0057913405542f,
-            0.0058012610063f,
-            0.0058102487887f,
-            0.0058183002716f,
-            0.0058254122019f,
-            0.0058315817045f,
-            0.0058368062842f,
-            0.0058410838272f,
-            0.0058444126023f,
-            0.0058467912620f,
-            0.0058482188432f,
-            0.0058486947679f,
-            0.0058482188432f,
-            0.0058467912620f,
-            0.0058444126023f,
-            0.0058410838272f,
-            0.0058368062842f,
-            0.0058315817045f,
-            0.0058254122019f,
-            0.0058183002716f,
-            0.0058102487887f,
-            0.0058012610063f,
-            0.0057913405542f,
-            0.0057804914360f,
-            0.0057687180271f,
-            0.0057560250723f,
-            0.0057424176828f,
-            0.0057279013330f,
-            0.0057124818576f,
-            0.0056961654483f,
-            0.0056789586495f,
-            0.0056608683553f,
-            0.0056419018048f,
-            0.0056220665783f,
-            0.0056013705925f,
-            0.0055798220963f,
-            0.0055574296655f,
-            0.0055342021983f,
-            0.0055101489098f,
-            0.0054852793266f,
-            0.0054596032817f,
-            0.0054331309083f,
-            0.0054058726342f,
-            0.0053778391756f,
-            0.0053490415314f,
-            0.0053194909762f,
-            0.0052891990541f,
-            0.0052581775725f,
-            0.0052264385945f,
-            0.0051939944329f,
-            0.0051608576423f,
-            0.0051270410128f,
-            0.0050925575621f,
-            0.0050574205286f,
-            0.0050216433634f,
-            0.0049852397233f,
-            0.0049482234626f,
-            0.0049106086256f,
-            0.0048724094390f,
-            0.0048336403032f,
-            0.0047943157851f,
-            0.0047544506094f,
-            0.0047140596512f,
-            0.0046731579268f,
-            0.0046317605863f,
-            0.0045898829050f,
-            0.0045475402748f,
-            0.0045047481964f,
-            0.0044615222704f,
-            0.0044178781890f,
-            0.0043738317277f,
-            0.0043293987369f,
-            0.0042845951330f,
-            0.0042394368905f,
-            0.0041939400332f,
-            0.0041481206260f,
-            0.0041019947660f,
-            0.0040555785748f,
-            0.0040088881896f,
-            0.0039619397550f,
-            0.0039147494150f,
-            0.0038673333040f,
-            0.0038197075396f,
-            0.0037718882136f,
-            0.0037238913843f,
-            0.0036757330686f,
-            0.0036274292338f,
-            0.0035789957896f,
-            0.0035304485810f,
-            0.0034818033796f,
-            0.0034330758769f,
-            0.0033842816762f,
-            0.0033354362854f,
-            0.0032865551097f,
-            0.0032376534443f,
-            0.0031887464674f,
-            0.0031398492332f,
-            0.0030909766650f,
-            0.0030421435486f,
-            0.0029933645254f,
-            0.0029446540864f,
-            0.0028960265655f,
-            0.0028474961335f,
-            0.0027990767918f,
-            0.0027507823669f,
-            0.0027026265043f,
-            0.0026546226632f,
-            0.0026067841107f,
-            0.0025591239169f,
-            0.0025116549495f,
-            0.0024643898688f,
-            0.0024173411233f,
-            0.0023705209447f,
-            0.0023239413434f,
-            0.0022776141047f,
-            0.0022315507840f,
-            0.0021857627034f,
-            0.0021402609477f,
-            0.0020950563610f,
-            0.0020501595428f,
-            0.0020055808454f,
-            0.0019613303706f,
-            0.0019174179666f,
-            0.0018738532257f,
-            0.0018306454814f,
-            0.0017878038064f,
-            0.0017453370105f,
-            0.0017032536381f,
-            0.0016615619670f,
-            0.0016202700068f,
-            0.0015793854968f,
-            0.0015389159058f,
-            0.0014988684300f,
-            0.0014592499929f,
-            0.0014200672442f,
-            0.0013813265595f,
-            0.0013430340397f,
-            0.0013051955110f,
-            0.0012678165250f,
-            0.0012309023586f,
-            0.0011944580146f,
-            0.0011584882220f,
-            0.0011229974367f,
-            0.0010879898425f,
-            0.0010534693522f,
-            0.0010194396081f,
-            0.0009859039843f,
-            0.0009528655873f,
-            0.0009203272580f,
-            0.0008882915736f,
-            0.0008567608492f,
-            0.0008257371403f,
-            0.0007952222443f,
-            0.0007652177037f,
-            0.0007357248078f,
-            0.0007067445959f,
-            0.0006782778596f,
-            0.0006503251459f,
-            0.0006228867602f,
-            0.0005959627692f,
-            0.0005695530043f,
-            0.0005436570649f,
-            0.0005182743216f,
-            0.0004934039201f,
-            0.0004690447845f,
-            0.0004451956214f,
-            0.0004218549234f,
-            0.0003990209730f,
-            0.0003766918469f,
-            0.0003548654197f,
-            0.0003335393686f,
-            0.0003127111768f,
-            0.0002923781387f,
-            0.0002725373634f,
-            0.0002531857801f,
-            0.0002343201416f,
-            0.0002159370295f,
-            0.0001980328584f,
-            0.0001806038808f,
-            0.0001636461917f,
-            0.0001471557332f,
-            0.0001311282992f,
-            0.0001155595405f,
-            0.0001004449692f,
-            0.0000857799638f,
-            0.0000715597739f,
-            0.0000577795252f,
-            0.0000444342241f,
-            0.0000315187628f,
-            0.0000190279240f,
-            0.0000069563861f,
-            -0.0000047012723f,
-            -0.0000159505676f,
-            -0.0000267971056f,
-            -0.0000372465778f,
-            -0.0000473047557f,
-            -0.0000569774862f,
-            -0.0000662706872f,
-            -0.0000751903422f,
-            -0.0000837424964f,
-            -0.0000919332511f,
-            -0.0000997687600f,
-            -0.0001072552238f,
-            -0.0001143988861f,
-            -0.0001212060287f,
-            -0.0001276829672f,
-            -0.0001338360466f,
-            -0.0001396716370f,
-            -0.0001451961290f,
-            -0.0001504159297f,
-            -0.0001553374586f,
-            -0.0001599671433f,
-            -0.0001643114154f,
-            -0.0001683767065f,
-            -0.0001721694447f,
-            -0.0001756960501f,
-            -0.0001789629316f,
-            -0.0001819764827f,
-            -0.0001847430782f,
-            -0.0001872690707f,
-            -0.0001895607869f,
-            -0.0001916245241f,
-            -0.0001934665474f,
-            -0.0001950930862f,
-            -0.0001965103308f,
-            -0.0001977244297f,
-            -0.0001987414866f,
-            -0.0001995675575f,
-            -0.0002002086476f,
-            -0.0002006707090f,
-            -0.0002009596382f,
-            -0.0002010812729f,
-            -0.0002010413902f,
-            -0.0002008457042f,
-            -0.0002004998634f,
-            -0.0002000094489f,
-            -0.0001993799720f,
-            -0.0001986168726f,
-            -0.0001977255172f,
-            -0.0001967111968f,
-            -0.0001955791256f,
-            -0.0001943344392f,
-            -0.0001929821931f,
-            -0.0001915273613f,
-            -0.0001899748350f,
-            -0.0001883294212f,
-            -0.0001865958418f,
-            -0.0001847787321f,
-            -0.0001828826403f,
-            -0.0001809120262f,
-            -0.0001788712607f,
-            -0.0001767646249f,
-            -0.0001745963094f,
-            -0.0001723704138f,
-            -0.0001700909463f,
-            -0.0001677618232f,
-            -0.0001653868686f,
-            -0.0001629698139f,
-            -0.0001605142982f,
-            -0.0001580238676f,
-            -0.0001555019757f,
-            -0.0001529519831f,
-            -0.0001503771580f,
-            -0.0001477806759f,
-            -0.0001451656204f,
-            -0.0001425349833f,
-            -0.0001398916645f,
-            -0.0001372384734f,
-            -0.0001345781284f,
-            -0.0001319132583f,
-            -0.0001292464023f,
-            -0.0001265800111f,
-            -0.0001239164473f,
-            -0.0001212579865f,
-            -0.0001186068179f,
-            -0.0001159650452f,
-            -0.0001133346877f,
-            -0.0001107176810f,
-            -0.0001081158783f,
-            -0.0001055310512f,
-            -0.0001029648911f,
-            -0.0001004190099f,
-            -0.0000978949415f,
-            -0.0000953941432f,
-            -0.0000929179961f,
-            -0.0000904678075f,
-            -0.0000880448112f,
-            -0.0000856501695f,
-            -0.0000832849740f,
-            -0.0000809502475f,
-            -0.0000786469450f,
-            -0.0000763759553f,
-            -0.0000741381022f,
-            -0.0000719341464f,
-            -0.0000697647864f,
-            -0.0000676306604f,
-            -0.0000655323476f,
-            -0.0000634703697f,
-            -0.0000614451922f,
-            -0.0000594572265f,
-            -0.0000575068307f,
-            -0.0000555943117f,
-            -0.0000537199261f,
-            -0.0000518838825f,
-            -0.0000500863422f,
-            -0.0000483274213f,
-            -0.0000466071919f,
-            -0.0000449256839f,
-            -0.0000432828861f,
-            -0.0000416787480f,
-            -0.0000401131811f,
-            -0.0000385860605f,
-            -0.0000370972263f,
-            -0.0000356464850f,
-            -0.0000342336112f,
-            -0.0000328583485f,
-            -0.0000315204114f,
-            -0.0000302194865f,
-            -0.0000289552338f,
-            -0.0000277272881f,
-            -0.0000265352606f,
-            -0.0000253787397f,
-            -0.0000242572927f,
-            -0.0000231704670f,
-            -0.0000221177911f,
-            -0.0000210987761f,
-            -0.0000201129171f,
-            -0.0000191596936f,
-            -0.0000182385717f,
-            -0.0000173490044f,
-            -0.0000164904329f,
-            -0.0000156622882f,
-            -0.0000148639914f,
-            -0.0000140949552f,
-            -0.0000133545848f,
-            -0.0000126422788f,
-            -0.0000119574304f,
-            -0.0000112994278f,
-            -0.0000106676557f,
-            -0.0000100614958f,
-            -0.0000094803279f,
-            -0.0000089235302f,
-            -0.0000083904807f,
-            -0.0000078805577f,
-            -0.0000073931405f,
-            -0.0000069276099f,
-            -0.0000064833493f,
-            -0.0000060597452f,
-            -0.0000056561877f,
-            -0.0000052720710f,
-            -0.0000049067942f,
-            -0.0000045597620f,
-            -0.0000042303847f,
-            -0.0000039180789f,
-            -0.0000036222682f,
-            -0.0000033423834f,
-            -0.0000030778629f,
-            -0.0000028281532f,
-            -0.0000025927091f,
-            -0.0000023709942f,
-            -0.0000021624812f,
-            -0.0000019666521f,
-            -0.0000017829984f,
-            -0.0000016110215f,
-            -0.0000014502329f,
-            -0.0000013001543f,
-            -0.0000055896992f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_512_16.h

@@ -1,78 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_512_16_len = 64;
-        const float fir_512_16_taps[] = {
-            0.0000151940580f,
-            0.0000353162294f,
-            0.0000744053215f,
-            0.0001396086425f,
-            0.0002418195104f,
-            0.0003943662769f,
-            0.0006129837252f,
-            0.0009156126139f,
-            0.0013220032816f,
-            0.0018531099165f,
-            0.0025302756637f,
-            0.0033742244254f,
-            0.0044038919853f,
-            0.0056351456882f,
-            0.0070794569573f,
-            0.0087426030278f,
-            0.0106234821202f,
-            0.0127131288122f,
-            0.0149940128678f,
-            0.0174396949525f,
-            0.0200148967258f,
-            0.0226760214362f,
-            0.0253721355820f,
-            0.0280463940126f,
-            0.0306378619753f,
-            0.0330836601043f,
-            0.0353213343016f,
-            0.0372913337462f,
-            0.0389394684890f,
-            0.0402192143245f,
-            0.0410937374123f,
-            0.0415375243532f,
-            0.0415375243532f,
-            0.0410937374123f,
-            0.0402192143245f,
-            0.0389394684890f,
-            0.0372913337462f,
-            0.0353213343016f,
-            0.0330836601043f,
-            0.0306378619753f,
-            0.0280463940126f,
-            0.0253721355820f,
-            0.0226760214362f,
-            0.0200148967258f,
-            0.0174396949525f,
-            0.0149940128678f,
-            0.0127131288122f,
-            0.0106234821202f,
-            0.0087426030278f,
-            0.0070794569573f,
-            0.0056351456882f,
-            0.0044038919853f,
-            0.0033742244254f,
-            0.0025302756637f,
-            0.0018531099165f,
-            0.0013220032816f,
-            0.0009156126139f,
-            0.0006129837252f,
-            0.0003943662769f,
-            0.0002418195104f,
-            0.0001396086425f,
-            0.0000744053215f,
-            0.0000353162294f,
-            0.0000151940580f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_512_32.h

@@ -1,165 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_512_32_len = 151;
-        const float fir_512_32_taps[] = {
-            0.0000009251202f,
-            0.0000018465197f,
-            0.0000024464700f,
-            0.0000043159736f,
-            0.0000061801355f,
-            0.0000092195926f,
-            0.0000128748733f,
-            0.0000179050798f,
-            0.0000241667435f,
-            0.0000322353329f,
-            0.0000422298191f,
-            0.0000546726009f,
-            0.0000698676453f,
-            0.0000883565591f,
-            0.0001105894638f,
-            0.0001371665649f,
-            0.0001686634471f,
-            0.0002057583064f,
-            0.0002491382743f,
-            0.0002995652579f,
-            0.0003578243175f,
-            0.0004247560835f,
-            0.0005012264845f,
-            0.0005881405242f,
-            0.0006864223881f,
-            0.0007970184354f,
-            0.0009208819280f,
-            0.0010589694866f,
-            0.0012122275138f,
-            0.0013815845184f,
-            0.0015679378702f,
-            0.0017721434865f,
-            0.0019950024469f,
-            0.0022372491131f,
-            0.0024995376582f,
-            0.0027824295157f,
-            0.0030863801975f,
-            0.0034117269055f,
-            0.0037586762067f,
-            0.0041272926196f,
-            0.0045174878173f,
-            0.0049290109819f,
-            0.0053614402367f,
-            0.0058141755168f,
-            0.0062864329037f,
-            0.0067772406753f,
-            0.0072854371318f,
-            0.0078096703652f,
-            0.0083484000282f,
-            0.0088999012000f,
-            0.0094622703727f,
-            0.0100334335903f,
-            0.0106111567180f,
-            0.0111930578078f,
-            0.0117766214851f,
-            0.0123592152594f,
-            0.0129381076271f,
-            0.0135104878117f,
-            0.0140734869548f,
-            0.0146242005530f,
-            0.0151597119088f,
-            0.0156771163460f,
-            0.0161735459270f,
-            0.0166461943912f,
-            0.0170923420315f,
-            0.0175093802160f,
-            0.0178948352652f,
-            0.0182463913957f,
-            0.0185619124518f,
-            0.0188394621562f,
-            0.0190773226296f,
-            0.0192740109449f,
-            0.0194282935085f,
-            0.0195391980867f,
-            0.0196060233225f,
-            0.0196283456221f,
-            0.0196060233225f,
-            0.0195391980867f,
-            0.0194282935085f,
-            0.0192740109449f,
-            0.0190773226296f,
-            0.0188394621562f,
-            0.0185619124518f,
-            0.0182463913957f,
-            0.0178948352652f,
-            0.0175093802160f,
-            0.0170923420315f,
-            0.0166461943912f,
-            0.0161735459270f,
-            0.0156771163460f,
-            0.0151597119088f,
-            0.0146242005530f,
-            0.0140734869548f,
-            0.0135104878117f,
-            0.0129381076271f,
-            0.0123592152594f,
-            0.0117766214851f,
-            0.0111930578078f,
-            0.0106111567180f,
-            0.0100334335903f,
-            0.0094622703727f,
-            0.0088999012000f,
-            0.0083484000282f,
-            0.0078096703652f,
-            0.0072854371318f,
-            0.0067772406753f,
-            0.0062864329037f,
-            0.0058141755168f,
-            0.0053614402367f,
-            0.0049290109819f,
-            0.0045174878173f,
-            0.0041272926196f,
-            0.0037586762067f,
-            0.0034117269055f,
-            0.0030863801975f,
-            0.0027824295157f,
-            0.0024995376582f,
-            0.0022372491131f,
-            0.0019950024469f,
-            0.0017721434865f,
-            0.0015679378702f,
-            0.0013815845184f,
-            0.0012122275138f,
-            0.0010589694866f,
-            0.0009208819280f,
-            0.0007970184354f,
-            0.0006864223881f,
-            0.0005881405242f,
-            0.0005012264845f,
-            0.0004247560835f,
-            0.0003578243175f,
-            0.0002995652579f,
-            0.0002491382743f,
-            0.0002057583064f,
-            0.0001686634471f,
-            0.0001371665649f,
-            0.0001105894638f,
-            0.0000883565591f,
-            0.0000698676453f,
-            0.0000546726009f,
-            0.0000422298191f,
-            0.0000322353329f,
-            0.0000241667435f,
-            0.0000179050798f,
-            0.0000128748733f,
-            0.0000092195926f,
-            0.0000061801355f,
-            0.0000043159736f,
-            0.0000024464700f,
-            0.0000018465197f,
-            0.0000009251202f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_512_64.h

@@ -1,298 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_512_64_len = 284;
-        const float fir_512_64_taps[] = {
-            -0.0000003515813f,
-            0.0000031171026f,
-            0.0000020524162f,
-            0.0000024542289f,
-            0.0000031065207f,
-            0.0000038930134f,
-            0.0000048162506f,
-            0.0000058895006f,
-            0.0000071310597f,
-            0.0000085581431f,
-            0.0000101918418f,
-            0.0000120521359f,
-            0.0000141629532f,
-            0.0000165472024f,
-            0.0000192318152f,
-            0.0000222427880f,
-            0.0000256102026f,
-            0.0000293632777f,
-            0.0000335353640f,
-            0.0000381590070f,
-            0.0000432709128f,
-            0.0000489070228f,
-            0.0000551074473f,
-            0.0000619115526f,
-            0.0000693628586f,
-            0.0000775041409f,
-            0.0000863822872f,
-            0.0000960434161f,
-            0.0001065376894f,
-            0.0001179144487f,
-            0.0001302269805f,
-            0.0001435276713f,
-            0.0001578727234f,
-            0.0001733173295f,
-            0.0001899203366f,
-            0.0002077394422f,
-            0.0002268358025f,
-            0.0002472692536f,
-            0.0002691028607f,
-            0.0002923981667f,
-            0.0003172196808f,
-            0.0003436301558f,
-            0.0003716950150f,
-            0.0004014776616f,
-            0.0004330438412f,
-            0.0004664569860f,
-            0.0005017825128f,
-            0.0005390832050f,
-            0.0005784234446f,
-            0.0006198646358f,
-            0.0006634693699f,
-            0.0007092968953f,
-            0.0007574072145f,
-            0.0008078566037f,
-            0.0008607016429f,
-            0.0009159947893f,
-            0.0009737883402f,
-            0.0010341300646f,
-            0.0010970670999f,
-            0.0011626416466f,
-            0.0012308947989f,
-            0.0013018623072f,
-            0.0013755783437f,
-            0.0014520713385f,
-            0.0015313676803f,
-            0.0016134876310f,
-            0.0016984489635f,
-            0.0017862629594f,
-            0.0018769379853f,
-            0.0019704755784f,
-            0.0020668739631f,
-            0.0021661242292f,
-            0.0022682137899f,
-            0.0023731226581f,
-            0.0024808268465f,
-            0.0025912947466f,
-            0.0027044904730f,
-            0.0028203703485f,
-            0.0029388861938f,
-            0.0030599819237f,
-            0.0031835967820f,
-            0.0033096620532f,
-            0.0034381042430f,
-            0.0035688419092f,
-            0.0037017887878f,
-            0.0038368507462f,
-            0.0039739288549f,
-            0.0041129164657f,
-            0.0042537022285f,
-            0.0043961672967f,
-            0.0045401882879f,
-            0.0046856346183f,
-            0.0048323714068f,
-            0.0049802569384f,
-            0.0051291455099f,
-            0.0052788850244f,
-            0.0054293197749f,
-            0.0055802881698f,
-            0.0057316254533f,
-            0.0058831615603f,
-            0.0060347237702f,
-            0.0061861346909f,
-            0.0063372148423f,
-            0.0064877807676f,
-            0.0066376475425f,
-            0.0067866270121f,
-            0.0069345302214f,
-            0.0070811657753f,
-            0.0072263421851f,
-            0.0073698663497f,
-            0.0075115458128f,
-            0.0076511873613f,
-            0.0077885991889f,
-            0.0079235896075f,
-            0.0080559691125f,
-            0.0081855492031f,
-            0.0083121443425f,
-            0.0084355708848f,
-            0.0085556489242f,
-            0.0086722013236f,
-            0.0087850554475f,
-            0.0088940422881f,
-            0.0089989980770f,
-            0.0090997635037f,
-            0.0091961852010f,
-            0.0092881150520f,
-            0.0093754115438f,
-            0.0094579391596f,
-            0.0095355695951f,
-            0.0096081812323f,
-            0.0096756602138f,
-            0.0097378999951f,
-            0.0097948022733f,
-            0.0098462766138f,
-            0.0098922412299f,
-            0.0099326226814f,
-            0.0099673565022f,
-            0.0099963869681f,
-            0.0100196675703f,
-            0.0100371608503f,
-            0.0100488387168f,
-            0.0100546823476f,
-            0.0100546823476f,
-            0.0100488387168f,
-            0.0100371608503f,
-            0.0100196675703f,
-            0.0099963869681f,
-            0.0099673565022f,
-            0.0099326226814f,
-            0.0098922412299f,
-            0.0098462766138f,
-            0.0097948022733f,
-            0.0097378999951f,
-            0.0096756602138f,
-            0.0096081812323f,
-            0.0095355695951f,
-            0.0094579391596f,
-            0.0093754115438f,
-            0.0092881150520f,
-            0.0091961852010f,
-            0.0090997635037f,
-            0.0089989980770f,
-            0.0088940422881f,
-            0.0087850554475f,
-            0.0086722013236f,
-            0.0085556489242f,
-            0.0084355708848f,
-            0.0083121443425f,
-            0.0081855492031f,
-            0.0080559691125f,
-            0.0079235896075f,
-            0.0077885991889f,
-            0.0076511873613f,
-            0.0075115458128f,
-            0.0073698663497f,
-            0.0072263421851f,
-            0.0070811657753f,
-            0.0069345302214f,
-            0.0067866270121f,
-            0.0066376475425f,
-            0.0064877807676f,
-            0.0063372148423f,
-            0.0061861346909f,
-            0.0060347237702f,
-            0.0058831615603f,
-            0.0057316254533f,
-            0.0055802881698f,
-            0.0054293197749f,
-            0.0052788850244f,
-            0.0051291455099f,
-            0.0049802569384f,
-            0.0048323714068f,
-            0.0046856346183f,
-            0.0045401882879f,
-            0.0043961672967f,
-            0.0042537022285f,
-            0.0041129164657f,
-            0.0039739288549f,
-            0.0038368507462f,
-            0.0037017887878f,
-            0.0035688419092f,
-            0.0034381042430f,
-            0.0033096620532f,
-            0.0031835967820f,
-            0.0030599819237f,
-            0.0029388861938f,
-            0.0028203703485f,
-            0.0027044904730f,
-            0.0025912947466f,
-            0.0024808268465f,
-            0.0023731226581f,
-            0.0022682137899f,
-            0.0021661242292f,
-            0.0020668739631f,
-            0.0019704755784f,
-            0.0018769379853f,
-            0.0017862629594f,
-            0.0016984489635f,
-            0.0016134876310f,
-            0.0015313676803f,
-            0.0014520713385f,
-            0.0013755783437f,
-            0.0013018623072f,
-            0.0012308947989f,
-            0.0011626416466f,
-            0.0010970670999f,
-            0.0010341300646f,
-            0.0009737883402f,
-            0.0009159947893f,
-            0.0008607016429f,
-            0.0008078566037f,
-            0.0007574072145f,
-            0.0007092968953f,
-            0.0006634693699f,
-            0.0006198646358f,
-            0.0005784234446f,
-            0.0005390832050f,
-            0.0005017825128f,
-            0.0004664569860f,
-            0.0004330438412f,
-            0.0004014776616f,
-            0.0003716950150f,
-            0.0003436301558f,
-            0.0003172196808f,
-            0.0002923981667f,
-            0.0002691028607f,
-            0.0002472692536f,
-            0.0002268358025f,
-            0.0002077394422f,
-            0.0001899203366f,
-            0.0001733173295f,
-            0.0001578727234f,
-            0.0001435276713f,
-            0.0001302269805f,
-            0.0001179144487f,
-            0.0001065376894f,
-            0.0000960434161f,
-            0.0000863822872f,
-            0.0000775041409f,
-            0.0000693628586f,
-            0.0000619115526f,
-            0.0000551074473f,
-            0.0000489070228f,
-            0.0000432709128f,
-            0.0000381590070f,
-            0.0000335353640f,
-            0.0000293632777f,
-            0.0000256102026f,
-            0.0000222427880f,
-            0.0000192318152f,
-            0.0000165472024f,
-            0.0000141629532f,
-            0.0000120521359f,
-            0.0000101918418f,
-            0.0000085581431f,
-            0.0000071310597f,
-            0.0000058895006f,
-            0.0000048162506f,
-            0.0000038930134f,
-            0.0000031065207f,
-            0.0000024542289f,
-            0.0000020524162f,
-            0.0000031171026f,
-            -0.0000003515813f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_64_16.h

@@ -1,104 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_64_16_len = 90;
-        const float fir_64_16_taps[] = {
-            -0.0000120522386f,
-            -0.0000222544605f,
-            -0.0000415800824f,
-            -0.0000705601980f,
-            -0.0001117597283f,
-            -0.0001677821532f,
-            -0.0002410541699f,
-            -0.0003335536910f,
-            -0.0004464864558f,
-            -0.0005799214861f,
-            -0.0007324007475f,
-            -0.0009005433028f,
-            -0.0010786685830f,
-            -0.0012584667286f,
-            -0.0014287458994f,
-            -0.0015752866570f,
-            -0.0016808317559f,
-            -0.0017252357928f,
-            -0.0016857931470f,
-            -0.0015377546562f,
-            -0.0012550337974f,
-            -0.0008110922394f,
-            -0.0001799830654f,
-            0.0006624815809f,
-            0.0017374824702f,
-            0.0030619182176f,
-            0.0046471635731f,
-            0.0064979256976f,
-            0.0086112639295f,
-            0.0109758357695f,
-            0.0135714252753f,
-            0.0163687998961f,
-            0.0193299283477f,
-            0.0224085760310f,
-            0.0255512765146f,
-            0.0286986586848f,
-            0.0317870903592f,
-            0.0347505815535f,
-            0.0375228752484f,
-            0.0400396413686f,
-            0.0422406815901f,
-            0.0440720490748f,
-            0.0454879886598f,
-            0.0464526093979f,
-            0.0469412124342f,
-            0.0469412124342f,
-            0.0464526093979f,
-            0.0454879886598f,
-            0.0440720490748f,
-            0.0422406815901f,
-            0.0400396413686f,
-            0.0375228752484f,
-            0.0347505815535f,
-            0.0317870903592f,
-            0.0286986586848f,
-            0.0255512765146f,
-            0.0224085760310f,
-            0.0193299283477f,
-            0.0163687998961f,
-            0.0135714252753f,
-            0.0109758357695f,
-            0.0086112639295f,
-            0.0064979256976f,
-            0.0046471635731f,
-            0.0030619182176f,
-            0.0017374824702f,
-            0.0006624815809f,
-            -0.0001799830654f,
-            -0.0008110922394f,
-            -0.0012550337974f,
-            -0.0015377546562f,
-            -0.0016857931470f,
-            -0.0017252357928f,
-            -0.0016808317559f,
-            -0.0015752866570f,
-            -0.0014287458994f,
-            -0.0012584667286f,
-            -0.0010786685830f,
-            -0.0009005433028f,
-            -0.0007324007475f,
-            -0.0005799214861f,
-            -0.0004464864558f,
-            -0.0003335536910f,
-            -0.0002410541699f,
-            -0.0001677821532f,
-            -0.0001117597283f,
-            -0.0000705601980f,
-            -0.0000415800824f,
-            -0.0000222544605f,
-            -0.0000120522386f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_64_2.h

@@ -1,18 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_64_2_len = 4;
-        const float fir_64_2_taps[] = {
-            0.1238512125230f,
-            0.3713298898913f,
-            0.3713298898913f,
-            0.1238512125230f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_64_32.h

@@ -1,268 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_64_32_len = 254;
-        const float fir_64_32_taps[] = {
-            0.0000071177827f,
-            0.0000052360330f,
-            0.0000070999389f,
-            0.0000093491421f,
-            0.0000120258010f,
-            0.0000151698657f,
-            0.0000188213706f,
-            0.0000230162819f,
-            0.0000277885900f,
-            0.0000331659761f,
-            0.0000391717261f,
-            0.0000458202516f,
-            0.0000531188652f,
-            0.0000610632073f,
-            0.0000696389402f,
-            0.0000788171514f,
-            0.0000885560397f,
-            0.0000987963809f,
-            0.0001094632965f,
-            0.0001204618823f,
-            0.0001316791619f,
-            0.0001429799890f,
-            0.0001542092968f,
-            0.0001651883918f,
-            0.0001757176133f,
-            0.0001855731360f,
-            0.0001945101517f,
-            0.0002022602911f,
-            0.0002085354301f,
-            0.0002130258290f,
-            0.0002154046469f,
-            0.0002153268755f,
-            0.0002124346213f,
-            0.0002063568823f,
-            0.0001967156262f,
-            0.0001831264229f,
-            0.0001652053085f,
-            0.0001425702458f,
-            0.0001148487208f,
-            0.0000816799586f,
-            0.0000427231519f,
-            -0.0000023396876f,
-            -0.0000537950170f,
-            -0.0001118944427f,
-            -0.0001768457191f,
-            -0.0002488091749f,
-            -0.0003278886589f,
-            -0.0004141279672f,
-            -0.0005075020096f,
-            -0.0006079135226f,
-            -0.0007151847604f,
-            -0.0008290548018f,
-            -0.0009491720834f,
-            -0.0010750926197f,
-            -0.0012062737004f,
-            -0.0013420733382f,
-            -0.0014817454403f,
-            -0.0016244407789f,
-            -0.0017692039202f,
-            -0.0019149759766f,
-            -0.0020605935333f,
-            -0.0022047933917f,
-            -0.0023462136721f,
-            -0.0024834006928f,
-            -0.0026148123580f,
-            -0.0027388272354f,
-            -0.0028537502533f,
-            -0.0029578239527f,
-            -0.0030492364244f,
-            -0.0031261346152f,
-            -0.0031866343375f,
-            -0.0032288354106f,
-            -0.0032508334770f,
-            -0.0032507366611f,
-            -0.0032266788309f,
-            -0.0031768373662f,
-            -0.0030994474167f,
-            -0.0029928202893f,
-            -0.0028553581802f,
-            -0.0026855726253f,
-            -0.0024820991257f,
-            -0.0022437150570f,
-            -0.0019693535723f,
-            -0.0016581203414f,
-            -0.0013093061003f,
-            -0.0009224015920f,
-            -0.0004971081448f,
-            -0.0000333502105f,
-            0.0004687166063f,
-            0.0010086959640f,
-            0.0015859458172f,
-            0.0021995722597f,
-            0.0028484280438f,
-            0.0035311102220f,
-            0.0042459624638f,
-            0.0049910767459f,
-            0.0057642996479f,
-            0.0065632382031f,
-            0.0073852702104f,
-            0.0082275542093f,
-            0.0090870436937f,
-            0.0099605010219f,
-            0.0108445152647f,
-            0.0117355197089f,
-            0.0126298129235f,
-            0.0135235793719f,
-            0.0144129131434f,
-            0.0152938410591f,
-            0.0161623483955f,
-            0.0170144037611f,
-            0.0178459860423f,
-            0.0186531102422f,
-            0.0194318548104f,
-            0.0201783875831f,
-            0.0208889926181f,
-            0.0215600953536f,
-            0.0221882880668f,
-            0.0227703533794f,
-            0.0233032874883f,
-            0.0237843211931f,
-            0.0242109401088f,
-            0.0245809024718f,
-            0.0248922556389f,
-            0.0251433500349f,
-            0.0253328513679f,
-            0.0254597502167f,
-            0.0255233695354f,
-            0.0255233695354f,
-            0.0254597502167f,
-            0.0253328513679f,
-            0.0251433500349f,
-            0.0248922556389f,
-            0.0245809024718f,
-            0.0242109401088f,
-            0.0237843211931f,
-            0.0233032874883f,
-            0.0227703533794f,
-            0.0221882880668f,
-            0.0215600953536f,
-            0.0208889926181f,
-            0.0201783875831f,
-            0.0194318548104f,
-            0.0186531102422f,
-            0.0178459860423f,
-            0.0170144037611f,
-            0.0161623483955f,
-            0.0152938410591f,
-            0.0144129131434f,
-            0.0135235793719f,
-            0.0126298129235f,
-            0.0117355197089f,
-            0.0108445152647f,
-            0.0099605010219f,
-            0.0090870436937f,
-            0.0082275542093f,
-            0.0073852702104f,
-            0.0065632382031f,
-            0.0057642996479f,
-            0.0049910767459f,
-            0.0042459624638f,
-            0.0035311102220f,
-            0.0028484280438f,
-            0.0021995722597f,
-            0.0015859458172f,
-            0.0010086959640f,
-            0.0004687166063f,
-            -0.0000333502105f,
-            -0.0004971081448f,
-            -0.0009224015920f,
-            -0.0013093061003f,
-            -0.0016581203414f,
-            -0.0019693535723f,
-            -0.0022437150570f,
-            -0.0024820991257f,
-            -0.0026855726253f,
-            -0.0028553581802f,
-            -0.0029928202893f,
-            -0.0030994474167f,
-            -0.0031768373662f,
-            -0.0032266788309f,
-            -0.0032507366611f,
-            -0.0032508334770f,
-            -0.0032288354106f,
-            -0.0031866343375f,
-            -0.0031261346152f,
-            -0.0030492364244f,
-            -0.0029578239527f,
-            -0.0028537502533f,
-            -0.0027388272354f,
-            -0.0026148123580f,
-            -0.0024834006928f,
-            -0.0023462136721f,
-            -0.0022047933917f,
-            -0.0020605935333f,
-            -0.0019149759766f,
-            -0.0017692039202f,
-            -0.0016244407789f,
-            -0.0014817454403f,
-            -0.0013420733382f,
-            -0.0012062737004f,
-            -0.0010750926197f,
-            -0.0009491720834f,
-            -0.0008290548018f,
-            -0.0007151847604f,
-            -0.0006079135226f,
-            -0.0005075020096f,
-            -0.0004141279672f,
-            -0.0003278886589f,
-            -0.0002488091749f,
-            -0.0001768457191f,
-            -0.0001118944427f,
-            -0.0000537950170f,
-            -0.0000023396876f,
-            0.0000427231519f,
-            0.0000816799586f,
-            0.0001148487208f,
-            0.0001425702458f,
-            0.0001652053085f,
-            0.0001831264229f,
-            0.0001967156262f,
-            0.0002063568823f,
-            0.0002124346213f,
-            0.0002153268755f,
-            0.0002154046469f,
-            0.0002130258290f,
-            0.0002085354301f,
-            0.0002022602911f,
-            0.0001945101517f,
-            0.0001855731360f,
-            0.0001757176133f,
-            0.0001651883918f,
-            0.0001542092968f,
-            0.0001429799890f,
-            0.0001316791619f,
-            0.0001204618823f,
-            0.0001094632965f,
-            0.0000987963809f,
-            0.0000885560397f,
-            0.0000788171514f,
-            0.0000696389402f,
-            0.0000610632073f,
-            0.0000531188652f,
-            0.0000458202516f,
-            0.0000391717261f,
-            0.0000331659761f,
-            0.0000277885900f,
-            0.0000230162819f,
-            0.0000188213706f,
-            0.0000151698657f,
-            0.0000120258010f,
-            0.0000093491421f,
-            0.0000070999389f,
-            0.0000052360330f,
-            0.0000071177827f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_64_4.h

@@ -1,33 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_64_4_len = 19;
-        const float fir_64_4_taps[] = {
-            0.0000429609248f,
-            0.0004765567633f,
-            0.0024957623882f,
-            0.0086502620997f,
-            0.0224930555988f,
-            0.0467176748088f,
-            0.0803238710382f,
-            0.1168174685032f,
-            0.1455785879790f,
-            0.1565458506682f,
-            0.1455785879790f,
-            0.1168174685032f,
-            0.0803238710382f,
-            0.0467176748088f,
-            0.0224930555988f,
-            0.0086502620997f,
-            0.0024957623882f,
-            0.0004765567633f,
-            0.0000429609248f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_64_8.h

@@ -1,50 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_64_8_len = 36;
-        const float fir_64_8_taps[] = {
-            0.0000128128011f,
-            0.0000776899411f,
-            0.0002545373360f,
-            0.0006610024251f,
-            0.0014604787010f,
-            0.0028714653290f,
-            0.0051457499501f,
-            0.0085388881542f,
-            0.0132623498958f,
-            0.0194293686660f,
-            0.0270017805237f,
-            0.0357514664485f,
-            0.0452474908137f,
-            0.0548772985184f,
-            0.0639035753681f,
-            0.0715509180316f,
-            0.0771091525773f,
-            0.0800353323941f,
-            0.0800353323941f,
-            0.0771091525773f,
-            0.0715509180316f,
-            0.0639035753681f,
-            0.0548772985184f,
-            0.0452474908137f,
-            0.0357514664485f,
-            0.0270017805237f,
-            0.0194293686660f,
-            0.0132623498958f,
-            0.0085388881542f,
-            0.0051457499501f,
-            0.0028714653290f,
-            0.0014604787010f,
-            0.0006610024251f,
-            0.0002545373360f,
-            0.0000776899411f,
-            0.0000128128011f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_8_2.h

@@ -1,23 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_8_2_len = 9;
-        const float fir_8_2_taps[] = {
-            -0.0096855460565f,
-            -0.0196926482904f,
-            0.0627645107767f,
-            0.2740445488509f,
-            0.4025398240918f,
-            0.2740445488509f,
-            0.0627645107767f,
-            -0.0196926482904f,
-            -0.0096855460565f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_8_4.h

@@ -1,46 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_8_4_len = 32;
-        const float fir_8_4_taps[] = {
-            0.0000925825278f,
-            0.0004344995834f,
-            0.0011434673031f,
-            0.0019921953877f,
-            0.0021069453084f,
-            0.0000218242037f,
-            -0.0055687125738f,
-            -0.0144165472383f,
-            -0.0233747474180f,
-            -0.0262097913981f,
-            -0.0154074590383f,
-            0.0142533246733f,
-            0.0619133245834f,
-            0.1188703177504f,
-            0.1704338338746f,
-            0.2011522624092f,
-            0.2011522624092f,
-            0.1704338338746f,
-            0.1188703177504f,
-            0.0619133245834f,
-            0.0142533246733f,
-            -0.0154074590383f,
-            -0.0262097913981f,
-            -0.0233747474180f,
-            -0.0144165472383f,
-            -0.0055687125738f,
-            0.0000218242037f,
-            0.0021069453084f,
-            0.0019921953877f,
-            0.0011434673031f,
-            0.0004344995834f,
-            0.0000925825278f,
-        };
-    }
-}

core/src/dsp/firdec/taps/fir_8_8.h

@@ -1,294 +0,0 @@
-#pragma once
-
-/*
-    This file was auto-generated by Ryzerth's magic optimized FIR script.
-    DO NOT EDIT MANUALLY!!!
-*/
-
-namespace dsp {
-    namespace firdec {
-        const unsigned int fir_8_8_len = 280;
-        const float fir_8_8_taps[] = {
-            0.0000052994842f,
-            0.0000236531982f,
-            0.0000454431541f,
-            0.0000866606150f,
-            0.0001454681461f,
-            0.0002276460304f,
-            0.0003345911923f,
-            0.0004668904560f,
-            0.0006220183860f,
-            0.0007944666281f,
-            0.0009753045793f,
-            0.0011524547932f,
-            0.0013112968761f,
-            0.0014357836468f,
-            0.0015099531702f,
-            0.0015197416085f,
-            0.0014549038561f,
-            0.0013108132368f,
-            0.0010898828479f,
-            0.0008023617978f,
-            0.0004663041298f,
-            0.0001065892726f,
-            -0.0002470172936f,
-            -0.0005626469270f,
-            -0.0008097088243f,
-            -0.0009625110041f,
-            -0.0010036852815f,
-            -0.0009269528060f,
-            -0.0007387999373f,
-            -0.0004587307896f,
-            -0.0001179165349f,
-            0.0002437426033f,
-            0.0005819117379f,
-            0.0008530352611f,
-            0.0010198667279f,
-            0.0010566109951f,
-            0.0009529624621f,
-            0.0007164088602f,
-            0.0003723511050f,
-            -0.0000381502360f,
-            -0.0004628817408f,
-            -0.0008447972550f,
-            -0.0011294256831f,
-            -0.0012724326538f,
-            -0.0012463078782f,
-            -0.0010451923796f,
-            -0.0006870442177f,
-            -0.0002126532093f,
-            0.0003185796904f,
-            0.0008357346058f,
-            0.0012655423999f,
-            0.0015424876979f,
-            0.0016184879319f,
-            0.0014707552431f,
-            0.0011066080375f,
-            0.0005643461992f,
-            -0.0000901977407f,
-            -0.0007712304481f,
-            -0.0013838905368f,
-            -0.0018371322225f,
-            -0.0020568961991f,
-            -0.0019977090699f,
-            -0.0016509537671f,
-            -0.0010484135134f,
-            -0.0002602767483f,
-            0.0006124690999f,
-            0.0014505273627f,
-            0.0021321900783f,
-            0.0025505844320f,
-            0.0026298818820f,
-            0.0023380802069f,
-            0.0016943083615f,
-            0.0007692604372f,
-            -0.0003217361360f,
-            -0.0014324858797f,
-            -0.0024049762894f,
-            -0.0030913100580f,
-            -0.0033755493545f,
-            -0.0031923301613f,
-            -0.0025393728936f,
-            -0.0014817135720f,
-            -0.0001465338471f,
-            0.0012912514887f,
-            0.0026311543404f,
-            0.0036743211895f,
-            0.0042521988692f,
-            0.0042526374291f,
-            0.0036395284429f,
-            0.0024627622943f,
-            0.0008564752688f,
-            -0.0009748928184f,
-            -0.0027814968415f,
-            -0.0043010655579f,
-            -0.0052957555102f,
-            -0.0055878599029f,
-            -0.0050892037537f,
-            -0.0038196329489f,
-            -0.0019112679623f,
-            0.0004029949855f,
-            0.0028161150389f,
-            0.0049858689474f,
-            0.0065814235194f,
-            0.0073314238254f,
-            0.0070669002384f,
-            0.0057525958483f,
-            0.0035015266976f,
-            0.0005695959447f,
-            -0.0026703422489f,
-            -0.0057727554561f,
-            -0.0082771418381f,
-            -0.0097720954139f,
-            -0.0099573040630f,
-            -0.0086947790176f,
-            -0.0060415019273f,
-            -0.0022576736745f,
-            0.0022123488358f,
-            0.0067858745476f,
-            0.0108103047042f,
-            0.0136467461009f,
-            0.0147589153736f,
-            0.0137961123447f,
-            0.0106590975496f,
-            0.0055392102924f,
-            -0.0010761158185f,
-            -0.0084344441235f,
-            -0.0155846252876f,
-            -0.0214724302300f,
-            -0.0250557443256f,
-            -0.0254266556205f,
-            -0.0219263229678f,
-            -0.0142387338262f,
-            -0.0024513843925f,
-            0.0129256469755f,
-            0.0309861862491f,
-            0.0504987785185f,
-            0.0700154216583f,
-            0.0880072662488f,
-            0.1030129814746f,
-            0.1137837576738f,
-            0.1194090364685f,
-            0.1194090364685f,
-            0.1137837576738f,
-            0.1030129814746f,
-            0.0880072662488f,
-            0.0700154216583f,
-            0.0504987785185f,
-            0.0309861862491f,
-            0.0129256469755f,
-            -0.0024513843925f,
-            -0.0142387338262f,
-            -0.0219263229678f,
-            -0.0254266556205f,
-            -0.0250557443256f,
-            -0.0214724302300f,
-            -0.0155846252876f,
-            -0.0084344441235f,
-            -0.0010761158185f,
-            0.0055392102924f,
-            0.0106590975496f,
-            0.0137961123447f,
-            0.0147589153736f,
-            0.0136467461009f,
-            0.0108103047042f,
-            0.0067858745476f,
-            0.0022123488358f,
-            -0.0022576736745f,
-            -0.0060415019273f,
-            -0.0086947790176f,
-            -0.0099573040630f,
-            -0.0097720954139f,
-            -0.0082771418381f,
-            -0.0057727554561f,
-            -0.0026703422489f,
-            0.0005695959447f,
-            0.0035015266976f,
-            0.0057525958483f,
-            0.0070669002384f,
-            0.0073314238254f,
-            0.0065814235194f,
-            0.0049858689474f,
-            0.0028161150389f,
-            0.0004029949855f,
-            -0.0019112679623f,
-            -0.0038196329489f,
-            -0.0050892037537f,
-            -0.0055878599029f,
-            -0.0052957555102f,
-            -0.0043010655579f,
-            -0.0027814968415f,
-            -0.0009748928184f,
-            0.0008564752688f,
-            0.0024627622943f,
-            0.0036395284429f,
-            0.0042526374291f,
-            0.0042521988692f,
-            0.0036743211895f,
-            0.0026311543404f,
-            0.0012912514887f,
-            -0.0001465338471f,
-            -0.0014817135720f,
-            -0.0025393728936f,
-            -0.0031923301613f,
-            -0.0033755493545f,
-            -0.0030913100580f,
-            -0.0024049762894f,
-            -0.0014324858797f,
-            -0.0003217361360f,
-            0.0007692604372f,
-            0.0016943083615f,
-            0.0023380802069f,
-            0.0026298818820f,
-            0.0025505844320f,
-            0.0021321900783f,
-            0.0014505273627f,
-            0.0006124690999f,
-            -0.0002602767483f,
-            -0.0010484135134f,
-            -0.0016509537671f,
-            -0.0019977090699f,
-            -0.0020568961991f,
-            -0.0018371322225f,
-            -0.0013838905368f,
-            -0.0007712304481f,
-            -0.0000901977407f,
-            0.0005643461992f,
-            0.0011066080375f,
-            0.0014707552431f,
-            0.0016184879319f,
-            0.0015424876979f,
-            0.0012655423999f,
-            0.0008357346058f,
-            0.0003185796904f,
-            -0.0002126532093f,
-            -0.0006870442177f,
-            -0.0010451923796f,
-            -0.0012463078782f,
-            -0.0012724326538f,
-            -0.0011294256831f,
-            -0.0008447972550f,
-            -0.0004628817408f,
-            -0.0000381502360f,
-            0.0003723511050f,
-            0.0007164088602f,
-            0.0009529624621f,
-            0.0010566109951f,
-            0.0010198667279f,
-            0.0008530352611f,
-            0.0005819117379f,
-            0.0002437426033f,
-            -0.0001179165349f,
-            -0.0004587307896f,
-            -0.0007387999373f,
-            -0.0009269528060f,
-            -0.0010036852815f,
-            -0.0009625110041f,
-            -0.0008097088243f,
-            -0.0005626469270f,
-            -0.0002470172936f,
-            0.0001065892726f,
-            0.0004663041298f,
-            0.0008023617978f,
-            0.0010898828479f,
-            0.0013108132368f,
-            0.0014549038561f,
-            0.0015197416085f,
-            0.0015099531702f,
-            0.0014357836468f,
-            0.0013112968761f,
-            0.0011524547932f,
-            0.0009753045793f,
-            0.0007944666281f,
-            0.0006220183860f,
-            0.0004668904560f,
-            0.0003345911923f,
-            0.0002276460304f,
-            0.0001454681461f,
-            0.0000866606150f,
-            0.0000454431541f,
-            0.0000236531982f,
-            0.0000052994842f,
-        };
-    }
-}

core/src/dsp/hier_block.h

@@ -0,0 +1,83 @@
+#pragma once
+#include "block.h"
+
+namespace dsp {
+    class hier_block : public generic_block {
+    public:
+        virtual void init() {}
+
+        virtual ~hier_block() {
+            if (!_block_init) { return; }
+            stop();
+            _block_init = false;
+        }
+
+        virtual void start() {
+            assert(_block_init);
+            std::lock_guard<std::recursive_mutex> lck(ctrlMtx);
+            if (running) {
+                return;
+            }
+            running = true;
+            doStart();
+        }
+
+        virtual void stop() {
+            assert(_block_init);
+            std::lock_guard<std::recursive_mutex> lck(ctrlMtx);
+            if (!running) {
+                return;
+            }
+            doStop();
+            running = false;
+        }
+
+        void tempStart() {
+            assert(_block_init);
+            if (!tempStopDepth || --tempStopDepth) { return; }
+            if (tempStopped) {
+                doStart();
+                tempStopped = false;
+            }
+        }
+
+        void tempStop() {
+            assert(_block_init);
+            if (tempStopDepth++) { return; }
+            if (running && !tempStopped) {
+                doStop();
+                tempStopped = true;
+            }
+        }
+
+    private:
+        virtual void doStart() {
+            for (auto& block : blocks) {
+                block->start();
+            }
+        }
+
+        virtual void doStop() {
+            for (auto& block : blocks) {
+                block->stop();
+            }
+        }
+
+        std::vector<generic_block*> blocks;
+        bool tempStopped = false;
+        bool running = false;
+        int tempStopDepth = 0;
+
+    protected:
+        void registerBlock(generic_block* block) {
+            blocks.push_back(block);
+        }
+
+        void unregisterBlock(generic_block* block) {
+            blocks.erase(std::remove(blocks.begin(), blocks.end(), block), blocks.end());
+        }
+
+        bool _block_init = false;
+        std::recursive_mutex ctrlMtx;
+    };
+}

core/src/dsp/interpolation_taps.h

@@ -1,136 +0,0 @@
-#pragma once
-
-const int INTERP_TAP_COUNT = 8;
-const int INTERP_STEPS = 128;
-
-const float INTERP_TAPS[INTERP_STEPS + 1][INTERP_TAP_COUNT] = {
-    { 0.00000e+00, 0.00000e+00, 0.00000e+00, 1.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00 },
-    { -1.98993e-04, 1.24642e-03, -5.41054e-03, 9.98534e-01, 7.89295e-03, -2.76968e-03, 8.53777e-04, -1.54700e-04 },
-    { -3.96391e-04, 2.47942e-03, -1.07209e-02, 9.96891e-01, 1.58840e-02, -5.55134e-03, 1.70888e-03, -3.09412e-04 },
-    { -5.92100e-04, 3.69852e-03, -1.59305e-02, 9.95074e-01, 2.39714e-02, -8.34364e-03, 2.56486e-03, -4.64053e-04 },
-    { -7.86031e-04, 4.90322e-03, -2.10389e-02, 9.93082e-01, 3.21531e-02, -1.11453e-02, 3.42130e-03, -6.18544e-04 },
-    { -9.78093e-04, 6.09305e-03, -2.60456e-02, 9.90917e-01, 4.04274e-02, -1.39548e-02, 4.27773e-03, -7.72802e-04 },
-    { -1.16820e-03, 7.26755e-03, -3.09503e-02, 9.88580e-01, 4.87921e-02, -1.67710e-02, 5.13372e-03, -9.26747e-04 },
-    { -1.35627e-03, 8.42626e-03, -3.57525e-02, 9.86071e-01, 5.72454e-02, -1.95925e-02, 5.98883e-03, -1.08030e-03 },
-    { -1.54221e-03, 9.56876e-03, -4.04519e-02, 9.83392e-01, 6.57852e-02, -2.24178e-02, 6.84261e-03, -1.23337e-03 },
-    { -1.72594e-03, 1.06946e-02, -4.50483e-02, 9.80543e-01, 7.44095e-02, -2.52457e-02, 7.69462e-03, -1.38589e-03 },
-    { -1.90738e-03, 1.18034e-02, -4.95412e-02, 9.77526e-01, 8.31162e-02, -2.80746e-02, 8.54441e-03, -1.53777e-03 },
-    { -2.08645e-03, 1.28947e-02, -5.39305e-02, 9.74342e-01, 9.19033e-02, -3.09033e-02, 9.39154e-03, -1.68894e-03 },
-    { -2.26307e-03, 1.39681e-02, -5.82159e-02, 9.70992e-01, 1.00769e-01, -3.37303e-02, 1.02356e-02, -1.83931e-03 },
-    { -2.43718e-03, 1.50233e-02, -6.23972e-02, 9.67477e-01, 1.09710e-01, -3.65541e-02, 1.10760e-02, -1.98880e-03 },
-    { -2.60868e-03, 1.60599e-02, -6.64743e-02, 9.63798e-01, 1.18725e-01, -3.93735e-02, 1.19125e-02, -2.13733e-03 },
-    { -2.77751e-03, 1.70776e-02, -7.04471e-02, 9.59958e-01, 1.27812e-01, -4.21869e-02, 1.27445e-02, -2.28483e-03 },
-    { -2.94361e-03, 1.80759e-02, -7.43154e-02, 9.55956e-01, 1.36968e-01, -4.49929e-02, 1.35716e-02, -2.43121e-03 },
-    { -3.10689e-03, 1.90545e-02, -7.80792e-02, 9.51795e-01, 1.46192e-01, -4.77900e-02, 1.43934e-02, -2.57640e-03 },
-    { -3.26730e-03, 2.00132e-02, -8.17385e-02, 9.47477e-01, 1.55480e-01, -5.05770e-02, 1.52095e-02, -2.72032e-03 },
-    { -3.42477e-03, 2.09516e-02, -8.52933e-02, 9.43001e-01, 1.64831e-01, -5.33522e-02, 1.60193e-02, -2.86289e-03 },
-    { -3.57923e-03, 2.18695e-02, -8.87435e-02, 9.38371e-01, 1.74242e-01, -5.61142e-02, 1.68225e-02, -3.00403e-03 },
-    { -3.73062e-03, 2.27664e-02, -9.20893e-02, 9.33586e-01, 1.83711e-01, -5.88617e-02, 1.76185e-02, -3.14367e-03 },
-    { -3.87888e-03, 2.36423e-02, -9.53307e-02, 9.28650e-01, 1.93236e-01, -6.15931e-02, 1.84071e-02, -3.28174e-03 },
-    { -4.02397e-03, 2.44967e-02, -9.84679e-02, 9.23564e-01, 2.02814e-01, -6.43069e-02, 1.91877e-02, -3.41815e-03 },
-    { -4.16581e-03, 2.53295e-02, -1.01501e-01, 9.18329e-01, 2.12443e-01, -6.70018e-02, 1.99599e-02, -3.55283e-03 },
-    { -4.30435e-03, 2.61404e-02, -1.04430e-01, 9.12947e-01, 2.22120e-01, -6.96762e-02, 2.07233e-02, -3.68570e-03 },
-    { -4.43955e-03, 2.69293e-02, -1.07256e-01, 9.07420e-01, 2.31843e-01, -7.23286e-02, 2.14774e-02, -3.81671e-03 },
-    { -4.57135e-03, 2.76957e-02, -1.09978e-01, 9.01749e-01, 2.41609e-01, -7.49577e-02, 2.22218e-02, -3.94576e-03 },
-    { -4.69970e-03, 2.84397e-02, -1.12597e-01, 8.95936e-01, 2.51417e-01, -7.75620e-02, 2.29562e-02, -4.07279e-03 },
-    { -4.82456e-03, 2.91609e-02, -1.15113e-01, 8.89984e-01, 2.61263e-01, -8.01399e-02, 2.36801e-02, -4.19774e-03 },
-    { -4.94589e-03, 2.98593e-02, -1.17526e-01, 8.83893e-01, 2.71144e-01, -8.26900e-02, 2.43930e-02, -4.32052e-03 },
-    { -5.06363e-03, 3.05345e-02, -1.19837e-01, 8.77666e-01, 2.81060e-01, -8.52109e-02, 2.50946e-02, -4.44107e-03 },
-    { -5.17776e-03, 3.11866e-02, -1.22047e-01, 8.71305e-01, 2.91006e-01, -8.77011e-02, 2.57844e-02, -4.55932e-03 },
-    { -5.28823e-03, 3.18153e-02, -1.24154e-01, 8.64812e-01, 3.00980e-01, -9.01591e-02, 2.64621e-02, -4.67520e-03 },
-    { -5.39500e-03, 3.24205e-02, -1.26161e-01, 8.58189e-01, 3.10980e-01, -9.25834e-02, 2.71272e-02, -4.78866e-03 },
-    { -5.49804e-03, 3.30021e-02, -1.28068e-01, 8.51437e-01, 3.21004e-01, -9.49727e-02, 2.77794e-02, -4.89961e-03 },
-    { -5.59731e-03, 3.35600e-02, -1.29874e-01, 8.44559e-01, 3.31048e-01, -9.73254e-02, 2.84182e-02, -5.00800e-03 },
-    { -5.69280e-03, 3.40940e-02, -1.31581e-01, 8.37557e-01, 3.41109e-01, -9.96402e-02, 2.90433e-02, -5.11376e-03 },
-    { -5.78446e-03, 3.46042e-02, -1.33189e-01, 8.30432e-01, 3.51186e-01, -1.01915e-01, 2.96543e-02, -5.21683e-03 },
-    { -5.87227e-03, 3.50903e-02, -1.34699e-01, 8.23188e-01, 3.61276e-01, -1.04150e-01, 3.02507e-02, -5.31716e-03 },
-    { -5.95620e-03, 3.55525e-02, -1.36111e-01, 8.15826e-01, 3.71376e-01, -1.06342e-01, 3.08323e-02, -5.41467e-03 },
-    { -6.03624e-03, 3.59905e-02, -1.37426e-01, 8.08348e-01, 3.81484e-01, -1.08490e-01, 3.13987e-02, -5.50931e-03 },
-    { -6.11236e-03, 3.64044e-02, -1.38644e-01, 8.00757e-01, 3.91596e-01, -1.10593e-01, 3.19495e-02, -5.60103e-03 },
-    { -6.18454e-03, 3.67941e-02, -1.39767e-01, 7.93055e-01, 4.01710e-01, -1.12650e-01, 3.24843e-02, -5.68976e-03 },
-    { -6.25277e-03, 3.71596e-02, -1.40794e-01, 7.85244e-01, 4.11823e-01, -1.14659e-01, 3.30027e-02, -5.77544e-03 },
-    { -6.31703e-03, 3.75010e-02, -1.41727e-01, 7.77327e-01, 4.21934e-01, -1.16618e-01, 3.35046e-02, -5.85804e-03 },
-    { -6.37730e-03, 3.78182e-02, -1.42566e-01, 7.69305e-01, 4.32038e-01, -1.18526e-01, 3.39894e-02, -5.93749e-03 },
-    { -6.43358e-03, 3.81111e-02, -1.43313e-01, 7.61181e-01, 4.42134e-01, -1.20382e-01, 3.44568e-02, -6.01374e-03 },
-    { -6.48585e-03, 3.83800e-02, -1.43968e-01, 7.52958e-01, 4.52218e-01, -1.22185e-01, 3.49066e-02, -6.08674e-03 },
-    { -6.53412e-03, 3.86247e-02, -1.44531e-01, 7.44637e-01, 4.62289e-01, -1.23933e-01, 3.53384e-02, -6.15644e-03 },
-    { -6.57836e-03, 3.88454e-02, -1.45004e-01, 7.36222e-01, 4.72342e-01, -1.25624e-01, 3.57519e-02, -6.22280e-03 },
-    { -6.61859e-03, 3.90420e-02, -1.45387e-01, 7.27714e-01, 4.82377e-01, -1.27258e-01, 3.61468e-02, -6.28577e-03 },
-    { -6.65479e-03, 3.92147e-02, -1.45682e-01, 7.19116e-01, 4.92389e-01, -1.28832e-01, 3.65227e-02, -6.34530e-03 },
-    { -6.68698e-03, 3.93636e-02, -1.45889e-01, 7.10431e-01, 5.02377e-01, -1.30347e-01, 3.68795e-02, -6.40135e-03 },
-    { -6.71514e-03, 3.94886e-02, -1.46009e-01, 7.01661e-01, 5.12337e-01, -1.31800e-01, 3.72167e-02, -6.45388e-03 },
-    { -6.73929e-03, 3.95900e-02, -1.46043e-01, 6.92808e-01, 5.22267e-01, -1.33190e-01, 3.75341e-02, -6.50285e-03 },
-    { -6.75943e-03, 3.96678e-02, -1.45993e-01, 6.83875e-01, 5.32164e-01, -1.34515e-01, 3.78315e-02, -6.54823e-03 },
-    { -6.77557e-03, 3.97222e-02, -1.45859e-01, 6.74865e-01, 5.42025e-01, -1.35775e-01, 3.81085e-02, -6.58996e-03 },
-    { -6.78771e-03, 3.97532e-02, -1.45641e-01, 6.65779e-01, 5.51849e-01, -1.36969e-01, 3.83650e-02, -6.62802e-03 },
-    { -6.79588e-03, 3.97610e-02, -1.45343e-01, 6.56621e-01, 5.61631e-01, -1.38094e-01, 3.86006e-02, -6.66238e-03 },
-    { -6.80007e-03, 3.97458e-02, -1.44963e-01, 6.47394e-01, 5.71370e-01, -1.39150e-01, 3.88151e-02, -6.69300e-03 },
-    { -6.80032e-03, 3.97077e-02, -1.44503e-01, 6.38099e-01, 5.81063e-01, -1.40136e-01, 3.90083e-02, -6.71985e-03 },
-    { -6.79662e-03, 3.96469e-02, -1.43965e-01, 6.28739e-01, 5.90706e-01, -1.41050e-01, 3.91800e-02, -6.74291e-03 },
-    { -6.78902e-03, 3.95635e-02, -1.43350e-01, 6.19318e-01, 6.00298e-01, -1.41891e-01, 3.93299e-02, -6.76214e-03 },
-    { -6.77751e-03, 3.94578e-02, -1.42658e-01, 6.09836e-01, 6.09836e-01, -1.42658e-01, 3.94578e-02, -6.77751e-03 },
-    { -6.76214e-03, 3.93299e-02, -1.41891e-01, 6.00298e-01, 6.19318e-01, -1.43350e-01, 3.95635e-02, -6.78902e-03 },
-    { -6.74291e-03, 3.91800e-02, -1.41050e-01, 5.90706e-01, 6.28739e-01, -1.43965e-01, 3.96469e-02, -6.79662e-03 },
-    { -6.71985e-03, 3.90083e-02, -1.40136e-01, 5.81063e-01, 6.38099e-01, -1.44503e-01, 3.97077e-02, -6.80032e-03 },
-    { -6.69300e-03, 3.88151e-02, -1.39150e-01, 5.71370e-01, 6.47394e-01, -1.44963e-01, 3.97458e-02, -6.80007e-03 },
-    { -6.66238e-03, 3.86006e-02, -1.38094e-01, 5.61631e-01, 6.56621e-01, -1.45343e-01, 3.97610e-02, -6.79588e-03 },
-    { -6.62802e-03, 3.83650e-02, -1.36969e-01, 5.51849e-01, 6.65779e-01, -1.45641e-01, 3.97532e-02, -6.78771e-03 },
-    { -6.58996e-03, 3.81085e-02, -1.35775e-01, 5.42025e-01, 6.74865e-01, -1.45859e-01, 3.97222e-02, -6.77557e-03 },
-    { -6.54823e-03, 3.78315e-02, -1.34515e-01, 5.32164e-01, 6.83875e-01, -1.45993e-01, 3.96678e-02, -6.75943e-03 },
-    { -6.50285e-03, 3.75341e-02, -1.33190e-01, 5.22267e-01, 6.92808e-01, -1.46043e-01, 3.95900e-02, -6.73929e-03 },
-    { -6.45388e-03, 3.72167e-02, -1.31800e-01, 5.12337e-01, 7.01661e-01, -1.46009e-01, 3.94886e-02, -6.71514e-03 },
-    { -6.40135e-03, 3.68795e-02, -1.30347e-01, 5.02377e-01, 7.10431e-01, -1.45889e-01, 3.93636e-02, -6.68698e-03 },
-    { -6.34530e-03, 3.65227e-02, -1.28832e-01, 4.92389e-01, 7.19116e-01, -1.45682e-01, 3.92147e-02, -6.65479e-03 },
-    { -6.28577e-03, 3.61468e-02, -1.27258e-01, 4.82377e-01, 7.27714e-01, -1.45387e-01, 3.90420e-02, -6.61859e-03 },
-    { -6.22280e-03, 3.57519e-02, -1.25624e-01, 4.72342e-01, 7.36222e-01, -1.45004e-01, 3.88454e-02, -6.57836e-03 },
-    { -6.15644e-03, 3.53384e-02, -1.23933e-01, 4.62289e-01, 7.44637e-01, -1.44531e-01, 3.86247e-02, -6.53412e-03 },
-    { -6.08674e-03, 3.49066e-02, -1.22185e-01, 4.52218e-01, 7.52958e-01, -1.43968e-01, 3.83800e-02, -6.48585e-03 },
-    { -6.01374e-03, 3.44568e-02, -1.20382e-01, 4.42134e-01, 7.61181e-01, -1.43313e-01, 3.81111e-02, -6.43358e-03 },
-    { -5.93749e-03, 3.39894e-02, -1.18526e-01, 4.32038e-01, 7.69305e-01, -1.42566e-01, 3.78182e-02, -6.37730e-03 },
-    { -5.85804e-03, 3.35046e-02, -1.16618e-01, 4.21934e-01, 7.77327e-01, -1.41727e-01, 3.75010e-02, -6.31703e-03 },
-    { -5.77544e-03, 3.30027e-02, -1.14659e-01, 4.11823e-01, 7.85244e-01, -1.40794e-01, 3.71596e-02, -6.25277e-03 },
-    { -5.68976e-03, 3.24843e-02, -1.12650e-01, 4.01710e-01, 7.93055e-01, -1.39767e-01, 3.67941e-02, -6.18454e-03 },
-    { -5.60103e-03, 3.19495e-02, -1.10593e-01, 3.91596e-01, 8.00757e-01, -1.38644e-01, 3.64044e-02, -6.11236e-03 },
-    { -5.50931e-03, 3.13987e-02, -1.08490e-01, 3.81484e-01, 8.08348e-01, -1.37426e-01, 3.59905e-02, -6.03624e-03 },
-    { -5.41467e-03, 3.08323e-02, -1.06342e-01, 3.71376e-01, 8.15826e-01, -1.36111e-01, 3.55525e-02, -5.95620e-03 },
-    { -5.31716e-03, 3.02507e-02, -1.04150e-01, 3.61276e-01, 8.23188e-01, -1.34699e-01, 3.50903e-02, -5.87227e-03 },
-    { -5.21683e-03, 2.96543e-02, -1.01915e-01, 3.51186e-01, 8.30432e-01, -1.33189e-01, 3.46042e-02, -5.78446e-03 },
-    { -5.11376e-03, 2.90433e-02, -9.96402e-02, 3.41109e-01, 8.37557e-01, -1.31581e-01, 3.40940e-02, -5.69280e-03 },
-    { -5.00800e-03, 2.84182e-02, -9.73254e-02, 3.31048e-01, 8.44559e-01, -1.29874e-01, 3.35600e-02, -5.59731e-03 },
-    { -4.89961e-03, 2.77794e-02, -9.49727e-02, 3.21004e-01, 8.51437e-01, -1.28068e-01, 3.30021e-02, -5.49804e-03 },
-    { -4.78866e-03, 2.71272e-02, -9.25834e-02, 3.10980e-01, 8.58189e-01, -1.26161e-01, 3.24205e-02, -5.39500e-03 },
-    { -4.67520e-03, 2.64621e-02, -9.01591e-02, 3.00980e-01, 8.64812e-01, -1.24154e-01, 3.18153e-02, -5.28823e-03 },
-    { -4.55932e-03, 2.57844e-02, -8.77011e-02, 2.91006e-01, 8.71305e-01, -1.22047e-01, 3.11866e-02, -5.17776e-03 },
-    { -4.44107e-03, 2.50946e-02, -8.52109e-02, 2.81060e-01, 8.77666e-01, -1.19837e-01, 3.05345e-02, -5.06363e-03 },
-    { -4.32052e-03, 2.43930e-02, -8.26900e-02, 2.71144e-01, 8.83893e-01, -1.17526e-01, 2.98593e-02, -4.94589e-03 },
-    { -4.19774e-03, 2.36801e-02, -8.01399e-02, 2.61263e-01, 8.89984e-01, -1.15113e-01, 2.91609e-02, -4.82456e-03 },
-    { -4.07279e-03, 2.29562e-02, -7.75620e-02, 2.51417e-01, 8.95936e-01, -1.12597e-01, 2.84397e-02, -4.69970e-03 },
-    { -3.94576e-03, 2.22218e-02, -7.49577e-02, 2.41609e-01, 9.01749e-01, -1.09978e-01, 2.76957e-02, -4.57135e-03 },
-    { -3.81671e-03, 2.14774e-02, -7.23286e-02, 2.31843e-01, 9.07420e-01, -1.07256e-01, 2.69293e-02, -4.43955e-03 },
-    { -3.68570e-03, 2.07233e-02, -6.96762e-02, 2.22120e-01, 9.12947e-01, -1.04430e-01, 2.61404e-02, -4.30435e-03 },
-    { -3.55283e-03, 1.99599e-02, -6.70018e-02, 2.12443e-01, 9.18329e-01, -1.01501e-01, 2.53295e-02, -4.16581e-03 },
-    { -3.41815e-03, 1.91877e-02, -6.43069e-02, 2.02814e-01, 9.23564e-01, -9.84679e-02, 2.44967e-02, -4.02397e-03 },
-    { -3.28174e-03, 1.84071e-02, -6.15931e-02, 1.93236e-01, 9.28650e-01, -9.53307e-02, 2.36423e-02, -3.87888e-03 },
-    { -3.14367e-03, 1.76185e-02, -5.88617e-02, 1.83711e-01, 9.33586e-01, -9.20893e-02, 2.27664e-02, -3.73062e-03 },
-    { -3.00403e-03, 1.68225e-02, -5.61142e-02, 1.74242e-01, 9.38371e-01, -8.87435e-02, 2.18695e-02, -3.57923e-03 },
-    { -2.86289e-03, 1.60193e-02, -5.33522e-02, 1.64831e-01, 9.43001e-01, -8.52933e-02, 2.09516e-02, -3.42477e-03 },
-    { -2.72032e-03, 1.52095e-02, -5.05770e-02, 1.55480e-01, 9.47477e-01, -8.17385e-02, 2.00132e-02, -3.26730e-03 },
-    { -2.57640e-03, 1.43934e-02, -4.77900e-02, 1.46192e-01, 9.51795e-01, -7.80792e-02, 1.90545e-02, -3.10689e-03 },
-    { -2.43121e-03, 1.35716e-02, -4.49929e-02, 1.36968e-01, 9.55956e-01, -7.43154e-02, 1.80759e-02, -2.94361e-03 },
-    { -2.28483e-03, 1.27445e-02, -4.21869e-02, 1.27812e-01, 9.59958e-01, -7.04471e-02, 1.70776e-02, -2.77751e-03 },
-    { -2.13733e-03, 1.19125e-02, -3.93735e-02, 1.18725e-01, 9.63798e-01, -6.64743e-02, 1.60599e-02, -2.60868e-03 },
-    { -1.98880e-03, 1.10760e-02, -3.65541e-02, 1.09710e-01, 9.67477e-01, -6.23972e-02, 1.50233e-02, -2.43718e-03 },
-    { -1.83931e-03, 1.02356e-02, -3.37303e-02, 1.00769e-01, 9.70992e-01, -5.82159e-02, 1.39681e-02, -2.26307e-03 },
-    { -1.68894e-03, 9.39154e-03, -3.09033e-02, 9.19033e-02, 9.74342e-01, -5.39305e-02, 1.28947e-02, -2.08645e-03 },
-    { -1.53777e-03, 8.54441e-03, -2.80746e-02, 8.31162e-02, 9.77526e-01, -4.95412e-02, 1.18034e-02, -1.90738e-03 },
-    { -1.38589e-03, 7.69462e-03, -2.52457e-02, 7.44095e-02, 9.80543e-01, -4.50483e-02, 1.06946e-02, -1.72594e-03 },
-    { -1.23337e-03, 6.84261e-03, -2.24178e-02, 6.57852e-02, 9.83392e-01, -4.04519e-02, 9.56876e-03, -1.54221e-03 },
-    { -1.08030e-03, 5.98883e-03, -1.95925e-02, 5.72454e-02, 9.86071e-01, -3.57525e-02, 8.42626e-03, -1.35627e-03 },
-    { -9.26747e-04, 5.13372e-03, -1.67710e-02, 4.87921e-02, 9.88580e-01, -3.09503e-02, 7.26755e-03, -1.16820e-03 },
-    { -7.72802e-04, 4.27773e-03, -1.39548e-02, 4.04274e-02, 9.90917e-01, -2.60456e-02, 6.09305e-03, -9.78093e-04 },
-    { -6.18544e-04, 3.42130e-03, -1.11453e-02, 3.21531e-02, 9.93082e-01, -2.10389e-02, 4.90322e-03, -7.86031e-04 },
-    { -4.64053e-04, 2.56486e-03, -8.34364e-03, 2.39714e-02, 9.95074e-01, -1.59305e-02, 3.69852e-03, -5.92100e-04 },
-    { -3.09412e-04, 1.70888e-03, -5.55134e-03, 1.58840e-02, 9.96891e-01, -1.07209e-02, 2.47942e-03, -3.96391e-04 },
-    { -1.54700e-04, 8.53777e-04, -2.76968e-03, 7.89295e-03, 9.98534e-01, -5.41054e-03, 1.24642e-03, -1.98993e-04 },
-    { 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 1.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00 },
-};