even more stuff

core/src/dsp/audio/volume.h

@@ -0,0 +1,93 @@
+#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);
+            level = { -150.0f, -150.0f };
+            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;
+        }
+
+        stereo_t getOutputLevel() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck0(base_type::ctrlMtx);
+            std::lock_guard<std::mutex> lck1(lvlMtx);
+            stereo_t lvl = level;
+            level = { -150.0f, -150.0f };
+            return lvl;
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            level = { -150.0f, -150.0f };
+        }
+
+        inline int process(int count, const stereo_t* in, stereo_t* out) {
+            // Apply volume factor
+            volk_32f_s32f_multiply_32f((float*)out, (float*)in, _muted ? 0.0f : _volume, count * 2);
+
+            // Measure block level
+            stereo_t maxLvl = { 0, 0 };
+            for (int i = 0; i < count; i++) {
+                stereo_t lvl = { fabsf(out[i].l), fabsf(out[i].r) };
+                if (lvl.l > maxLvl.l) { maxLvl.l = lvl.l; }
+                if (lvl.r > maxLvl.r) { maxLvl.r = lvl.r; }
+            }
+            stereo_t maxLvlDB = { 20.0 * log10f(maxLvl.l), 20.0 * log10f(maxLvl.r) };
+
+            // Update max level
+            {
+                std::lock_guard<std::mutex> lck(lvlMtx);
+                if (maxLvlDB.l > level.l) { level.l = maxLvlDB.l; }
+                if (maxLvlDB.r > level.r) { level.r = maxLvlDB.r; }
+            }
+
+            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;
+        std::mutex lvlMtx;
+        stereo_t level;
+
+    };
+}

core/src/dsp/bench/peak_level_meter.h

@@ -0,0 +1,62 @@
+#pragma once
+#include "../sink.h"
+
+namespace dsp::bench {
+    template<class T>
+    class PeakLevelMeter : Sink<T> {
+        using base_type = Sink<T>;
+    public:
+        PeakLevelMeter() {}
+
+        PeakLevelMeter(stream<T>* in) { 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/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

@@ -0,0 +1,239 @@
+#pragma once
+#include "buffer.h"
+
+#define RING_BUF_SZ 1000000
+
+// IMPORTANT: THIS IS TRASH AND MUST BE REWRITTEN IN THE FUTURE
+
+namespace dsp::buffer {
+    template <class T>
+    class RingBuffer {
+    public:
+        RingBuffer() {}
+
+        RingBuffer(int maxLatency) { init(maxLatency); }
+
+        ~RingBuffer() {
+            if (!_init) { return; }
+            buffer::free(_buffer);
+            _init = false;
+        }
+
+        void init(int maxLatency) {
+            size = RING_BUF_SZ;
+            _stopReader = false;
+            _stopWriter = false;
+            this->maxLatency = maxLatency;
+            writec = 0;
+            readc = 0;
+            readable = 0;
+            writable = size;
+            _buffer = buffer::alloc<T>(size);
+            buffer::clear(_buffer, size);
+            _init = true;
+        }
+
+        int read(T* data, int len) {
+            assert(_init);
+            int dataRead = 0;
+            int toRead = 0;
+            while (dataRead < len) {
+                toRead = std::min<int>(waitUntilReadable(), len - dataRead);
+                if (toRead < 0) { return -1; };
+
+                if ((toRead + readc) > size) {
+                    memcpy(&data[dataRead], &_buffer[readc], (size - readc) * sizeof(T));
+                    memcpy(&data[dataRead + (size - readc)], &_buffer[0], (toRead - (size - readc)) * sizeof(T));
+                }
+                else {
+                    memcpy(&data[dataRead], &_buffer[readc], toRead * sizeof(T));
+                }
+
+                dataRead += toRead;
+
+                _readable_mtx.lock();
+                readable -= toRead;
+                _readable_mtx.unlock();
+                _writable_mtx.lock();
+                writable += toRead;
+                _writable_mtx.unlock();
+                readc = (readc + toRead) % size;
+                canWriteVar.notify_one();
+            }
+            return len;
+        }
+
+        int readAndSkip(T* data, int len, int skip) {
+            assert(_init);
+            int dataRead = 0;
+            int toRead = 0;
+            while (dataRead < len) {
+                toRead = std::min<int>(waitUntilReadable(), len - dataRead);
+                if (toRead < 0) { return -1; };
+
+                if ((toRead + readc) > size) {
+                    memcpy(&data[dataRead], &_buffer[readc], (size - readc) * sizeof(T));
+                    memcpy(&data[dataRead + (size - readc)], &_buffer[0], (toRead - (size - readc)) * sizeof(T));
+                }
+                else {
+                    memcpy(&data[dataRead], &_buffer[readc], toRead * sizeof(T));
+                }
+
+                dataRead += toRead;
+
+                _readable_mtx.lock();
+                readable -= toRead;
+                _readable_mtx.unlock();
+                _writable_mtx.lock();
+                writable += toRead;
+                _writable_mtx.unlock();
+                readc = (readc + toRead) % size;
+                canWriteVar.notify_one();
+            }
+            dataRead = 0;
+            while (dataRead < skip) {
+                toRead = std::min<int>(waitUntilReadable(), skip - dataRead);
+                if (toRead < 0) { return -1; };
+
+                dataRead += toRead;
+
+                _readable_mtx.lock();
+                readable -= toRead;
+                _readable_mtx.unlock();
+                _writable_mtx.lock();
+                writable += toRead;
+                _writable_mtx.unlock();
+                readc = (readc + toRead) % size;
+                canWriteVar.notify_one();
+            }
+            return len;
+        }
+
+        int waitUntilReadable() {
+            assert(_init);
+            if (_stopReader) { return -1; }
+            int _r = getReadable();
+            if (_r != 0) { return _r; }
+            std::unique_lock<std::mutex> lck(_readable_mtx);
+            canReadVar.wait(lck, [=]() { return ((this->getReadable(false) > 0) || this->getReadStop()); });
+            if (_stopReader) { return -1; }
+            return getReadable(false);
+        }
+
+        int getReadable(bool lock = true) {
+            assert(_init);
+            if (lock) { _readable_mtx.lock(); };
+            int _r = readable;
+            if (lock) { _readable_mtx.unlock(); };
+            return _r;
+        }
+
+        int write(T* data, int len) {
+            assert(_init);
+            int dataWritten = 0;
+            int toWrite = 0;
+            while (dataWritten < len) {
+                toWrite = std::min<int>(waitUntilwritable(), len - dataWritten);
+                if (toWrite < 0) { return -1; };
+
+                if ((toWrite + writec) > size) {
+                    memcpy(&_buffer[writec], &data[dataWritten], (size - writec) * sizeof(T));
+                    memcpy(&_buffer[0], &data[dataWritten + (size - writec)], (toWrite - (size - writec)) * sizeof(T));
+                }
+                else {
+                    memcpy(&_buffer[writec], &data[dataWritten], toWrite * sizeof(T));
+                }
+
+                dataWritten += toWrite;
+
+                _readable_mtx.lock();
+                readable += toWrite;
+                _readable_mtx.unlock();
+                _writable_mtx.lock();
+                writable -= toWrite;
+                _writable_mtx.unlock();
+                writec = (writec + toWrite) % size;
+
+                canReadVar.notify_one();
+            }
+            return len;
+        }
+
+        int waitUntilwritable() {
+            assert(_init);
+            if (_stopWriter) { return -1; }
+            int _w = getWritable();
+            if (_w != 0) { return _w; }
+            std::unique_lock<std::mutex> lck(_writable_mtx);
+            canWriteVar.wait(lck, [=]() { return ((this->getWritable(false) > 0) || this->getWriteStop()); });
+            if (_stopWriter) { return -1; }
+            return getWritable(false);
+        }
+
+        int getWritable(bool lock = true) {
+            assert(_init);
+            if (lock) { _writable_mtx.lock(); };
+            int _w = writable;
+            if (lock) {
+                _writable_mtx.unlock();
+                _readable_mtx.lock();
+            };
+            int _r = readable;
+            if (lock) { _readable_mtx.unlock(); };
+            return std::max<int>(std::min<int>(_w, maxLatency - _r), 0);
+        }
+
+        void stopReader() {
+            assert(_init);
+            _stopReader = true;
+            canReadVar.notify_one();
+        }
+
+        void stopWriter() {
+            assert(_init);
+            _stopWriter = true;
+            canWriteVar.notify_one();
+        }
+
+        bool getReadStop() {
+            assert(_init);
+            return _stopReader;
+        }
+
+        bool getWriteStop() {
+            assert(_init);
+            return _stopWriter;
+        }
+
+        void clearReadStop() {
+            assert(_init);
+            _stopReader = false;
+        }
+
+        void clearWriteStop() {
+            assert(_init);
+            _stopWriter = false;
+        }
+
+        void setMaxLatency(int maxLatency) {
+            assert(_init);
+            this->maxLatency = maxLatency;
+        }
+
+    private:
+        bool _init = false;
+        T* _buffer;
+        int size;
+        int readc;
+        int writec;
+        int readable;
+        int writable;
+        int maxLatency;
+        bool _stopReader;
+        bool _stopWriter;
+        std::mutex _readable_mtx;
+        std::mutex _writable_mtx;
+        std::condition_variable canReadVar;
+        std::condition_variable canWriteVar;
+    };
+}

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,127 @@
+#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); }
+
+        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);
+            base_type::tempStop();
+            _bandwidth = bandwidth;
+            filterNeeded = (_bandwidth != _outSamplerate);
+            if (filterNeeded) {
+                generateTaps();
+                filter.setTaps(ftaps);
+            }
+            base_type::tempStart();
+        }
+
+        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, xlator.out.writeBuf);
+            if (!filterNeeded) {
+                return resamp.process(count, xlator.out.writeBuf, out);
+            }
+            count = resamp.process(count, xlator.out.writeBuf, resamp.out.writeBuf);
+            filter.process(count, resamp.out.writeBuf, out);
+            return count;
+        }
+
+        int run() {
+            int count = _in->read();
+            if (count < 0) { return -1; }
+
+            int outCount = process(count, _in->readBuf, out.writeBuf);
+
+            // Swap if some data was generated
+            _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);
+            printf("New taps just dropped: %lf %lf %lf\n", 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;
+    };
+}

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/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/dc_blocker.h

@@ -0,0 +1,72 @@
+#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;
+            reset();
+            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/demod/am.h

@@ -0,0 +1,88 @@
+#pragma once
+#include "../processor.h"
+#include "../loop/agc.h"
+
+namespace dsp::demod {
+    class AM : public Processor<dsp::complex_t, float> {
+        using base_type = Processor<dsp::complex_t, float>;
+    public:
+        enum AGCMode {
+            CARRIER,
+            AUDIO,
+        };
+
+        AM() {}
+
+        AM(stream<complex_t>* in, AGCMode agcMode, double agcRate) { init(in, agcMode, agcRate); }
+
+        void init(stream<complex_t>* in, AGCMode agcMode, double agcRate) {
+            _agcMode = agcMode;
+
+            carrierAgc.init(NULL, 1.0, agcRate);
+            audioAgc.init(NULL, 1.0, agcRate);
+            
+            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 setAGCRate(double agcRate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            carrierAgc.setRate(agcRate);
+            audioAgc.setRate(agcRate);
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            carrierAgc.reset();
+            audioAgc.reset();
+            base_type::tempStart();
+        }
+
+        int process(int count, complex_t* in, float* out) {
+            // Apply carrier AGC if needed
+            if (_agcMode == AGCMode::CARRIER) {
+                carrierAgc.process(count, in, carrierAgc.out.writeBuf);
+                in = carrierAgc.out.writeBuf;
+            }
+
+            // Get magnitude of each sample (TODO: use block instead)
+            volk_32fc_magnitude_32f(out, (lv_32fc_t*)in, count);
+
+            // Apply audio AGC if needed
+            if (_agcMode == AGCMode::AUDIO) {
+                audioAgc.process(count, out, 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;
+
+        loop::AGC<complex_t> carrierAgc;
+        loop::AGC<float> audioAgc;
+
+    };
+}

core/src/dsp/demod/broadcast_fm.h

@@ -0,0 +1,156 @@
+#pragma once
+#include "fm.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"
+
+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) { init(in, deviation, samplerate, stereo); }
+
+        ~BroadcastFM() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            buffer::free(lmr);
+            buffer::free(l);
+            buffer::free(r);
+        }
+
+        virtual void init(stream<complex_t>* in, double deviation, double samplerate, bool stereo = true) {
+            _deviation = deviation;
+            _samplerate = samplerate;
+            _stereo = stereo;
+            
+            demod.init(NULL, _deviation, _samplerate);
+            pilotFirTaps = taps::bandPass<complex_t>(18750.0, 19250.0, 3000.0, _samplerate);
+            pilotFir.init(NULL, pilotFirTaps);
+            rtoc.init(NULL);
+            pilotPLL.init(NULL, 0.1/*TODO: adapt to samplerate*/, 0.0, math::freqToOmega(19000.0, _samplerate), math::freqToOmega(18750.0, _samplerate), math::freqToOmega(19250.0, _samplerate));
+            delay.init(NULL, pilotFirTaps.size / 2.0);
+
+            lmr = buffer::alloc<float>(STREAM_BUFFER_SIZE);
+            l = buffer::alloc<float>(STREAM_BUFFER_SIZE);
+            r = buffer::alloc<float>(STREAM_BUFFER_SIZE);
+
+            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);
+            pilotFir.setTaps(pilotFirTaps);
+            pilotPLL.setFrequencyLimits(math::freqToOmega(18750.0, _samplerate), math::freqToOmega(19250.0, _samplerate));
+            pilotPLL.setInitialFreq(math::freqToOmega(19000.0, _samplerate));
+            delay.setDelay(pilotFirTaps.size / 2);
+
+            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 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();
+            delay.reset();
+            base_type::tempStart();
+        }
+
+        inline int process(int count, complex_t* in, stereo_t* out) {
+            // 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);
+
+                // Conjugate PLL output to down convert 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);
+
+                // Convert output back to real for further processing
+                convert::ComplexToReal::process(count, rtoc.out.writeBuf, lmr);
+
+                // 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);
+
+                // Interleave into stereo
+                convert::LRToStereo::process(count, l, r, out);
+            }
+            else {
+                // 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; }
+
+            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 _deviation;
+        double _samplerate;
+        bool _stereo;
+
+        FM demod;
+        tap<complex_t> pilotFirTaps;
+        filter::FIR<complex_t, complex_t> pilotFir;
+        convert::RealToComplex rtoc;
+        loop::PLL pilotPLL;
+        math::Delay<float> delay;
+
+        float* lmr;
+        float* l;
+        float* r;
+        
+    };
+}

core/src/dsp/demod/fm.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 FM : public Processor<complex_t, float> {
+        using base_type = Processor<complex_t, float>;
+    public:
+        FM() {}
+
+        FM(stream<complex_t>* in, double deviation) { init(in, deviation); }
+
+        FM(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,133 @@
+#pragma once
+#include "../processor.h"
+#include "../channel/frequency_xlator.h" 
+#include "../convert/complex_to_real.h"
+#include "../loop/agc.h"
+
+namespace dsp::demod {
+    class SSB : public Processor<complex_t, float> {
+        using base_type = Processor<complex_t, float>;
+    public:
+        enum Mode {
+            USB,
+            LSB,
+            DSB
+        };
+
+        SSB() {}
+
+        /** Calls the init function
+         */
+        SSB(stream<complex_t>* in, Mode mode, double bandwidth, double samplerate, double agcRate) { init(in, mode, bandwidth, samplerate, agcRate); }
+
+        /** Initialize the SSB/DSB Demodulator
+         *  \param in           Input stream
+         *  \param mode         Demodulation mode, can be USB, LSB or DSB
+         *  \param bandwidth    Bandwidth needed to shift back the IQ correctly
+         *  \param samplerate   Samplerate of the IQ data
+         *  \param agcRate      Speed at which the AGC corrects the audio level. This is NOT automatically scaled to the samplerate.
+         */
+        void init(stream<complex_t>* in, Mode mode, double bandwidth, double samplerate, double agcRate) {
+            _mode = mode;
+            _bandwidth = bandwidth;
+            _samplerate = samplerate;
+            xlator.init(NULL, getTranslation(), _samplerate);
+            agc.init(NULL, 1.0, agcRate);
+            base_type::init(in);
+        }
+
+        /** Set demodulation mode
+         *  \param mode Either USB, LSB or DSB
+         */
+        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();
+        }
+
+        /** Set bandwidth
+         *  \param bandwidth Bandwidth in Hz
+         */
+        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();
+        }
+
+        /** Set samplerate
+         *  \param samplerate Samplerate in Hz
+         */
+        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();
+        }
+
+        /** Set AGC rate
+         *  \param agcRate AGC rate in units per second
+         */
+        void setAGCRate(double agcRate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            agc.setRate(agcRate);
+        }
+
+        /** Process data
+         *  \param count    Number of samples
+         *  \param in       Input buffer
+         *  \param out      Output buffer
+         */
+        int process(int count, const complex_t* in, float* out) {
+            // Move back sideband
+            xlator.process(count, in, xlator.out.writeBuf);
+
+            // Extract the real component
+            convert::ComplexToReal::process(count, xlator.out.writeBuf, out);
+
+            // Apply AGC
+            agc.process(count, out, 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/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 = _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,92 @@
+#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();
+
+            _taps = taps;
+
+            // Reset buffer
+            bufStart = &buffer[_taps.size - 1];
+            buffer::clear<D>(buffer, _taps.size - 1);
+
+            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/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/loop/agc.h

@@ -0,0 +1,81 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::loop {
+    template <class T>
+    class AGC : public Processor<T, T> {
+        using base_type = Processor<T, T>;
+    public:
+        AGC() {}
+
+        AGC(stream<T>* in) { init(in); }
+
+        void init(stream<T>* in, double setPoint, double rate, double initGain = 1.0) {
+            _setPoint = setPoint;
+            _rate = rate;
+            _initGain = initGain;
+            gain = _initGain;
+            base_type::init(in);
+        }
+
+        void setSetPoint(double setPoint) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _setPoint = setPoint;
+        }
+
+        void setRate(double rate) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _rate = rate;
+        }
+
+        void setInitialGain(double initGain) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _initGain = initGain;
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            gain = _initGain;
+        }
+
+        inline int process(int count, T* in, T* out) {
+            for (int i = 0; i < count; i++) {
+                // Scale output by gain
+                out[i] = in[i] * gain;
+
+                // Update gain according to setpoint and rate
+                if constexpr (std::is_same_v<T, complex_t>) {
+                    gain += (_setPoint - out[i].amplitude()) * _rate;
+                }
+                if constexpr (std::is_same_v<T, float>) {
+                    gain += (_setPoint - fabsf(out[i])) * _rate;
+                }
+            }
+            printf("%f\n", gain);
+            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:
+        float _setPoint;
+        float _rate;
+        float _initGain;
+
+        float gain;
+
+    };
+}

core/src/dsp/loop/phase_control_loop.h

@@ -0,0 +1,85 @@
+#pragma once
+#include <math.h>
+#include <assert.h>
+#include "../types.h"
+
+namespace dsp::loop {
+    template<class T>
+    class PhaseControlLoop {
+    public:
+        PhaseControlLoop() {}
+
+        PhaseControlLoop(T alpha, T beta, T phase, T minPhase, T maxPhase, T freq, T minFreq, T maxFreq) {
+            init(alpha, beta, phase, minPhase, maxPhase, freq, minFreq, maxFreq);
+        }
+
+        void init(T alpha, T beta, T phase, T minPhase, T maxPhase, T freq, T minFreq, T maxFreq) {
+            assert(maxPhase > minPhase);
+            assert(maxFreq > minFreq);
+            _alpha = alpha;
+            _beta = beta;
+            this->phase = phase;
+            _minPhase = minPhase;
+            _maxPhase = maxPhase;
+            this->freq = freq;
+            _minFreq = minFreq;
+            _maxFreq = maxFreq;
+
+            phaseDelta = _maxPhase - _minPhase;
+        }
+
+        static inline void criticallyDamped(T bandwidth, T& alpha, T& beta) {
+            T dampningFactor = sqrt(2.0) / 2.0;
+            T denominator = (1.0 + 2.0*dampningFactor*bandwidth + bandwidth*bandwidth);
+            alpha = (4 * dampningFactor * bandwidth) / denominator;
+            beta = (4 * bandwidth * bandwidth) / denominator;
+        }
+
+        void setPhaseLimits(T minPhase, T maxPhase) {
+            assert(maxPhase > minPhase);
+            _minPhase = minPhase;
+            _maxPhase = maxPhase;
+            phaseDelta = _maxPhase - _minPhase;
+            clampPhase();
+        }
+
+        void setFreqLimits(T minFreq, T maxFreq) {
+            assert(maxFreq > minFreq);
+            _minFreq = minFreq;
+            _maxFreq = maxFreq;
+            clampFreq();
+        }
+
+        inline void advance(T error) {
+            // Increment and clamp frequency
+            freq += _beta * error;
+            clampFreq();
+
+            // Increment and clamp phase
+            phase += freq + (_alpha * error);
+            clampPhase();
+        }
+
+        T freq;
+        T phase;
+
+    protected:
+        inline void clampFreq() {
+            if (freq > _maxFreq) { freq = _maxFreq; }
+            else if (freq < _minFreq) { freq = _minFreq; }
+        }
+
+        inline void clampPhase() {
+            while (phase > _maxPhase) { phase -= phaseDelta; }
+            while (phase < _minPhase) { phase += phaseDelta; }
+        }
+
+        T _alpha;
+        T _beta;
+        T _minPhase;
+        T _maxPhase;
+        T _minFreq;
+        T _maxFreq;
+        T phaseDelta;
+    };
+}

core/src/dsp/loop/pll.h

@@ -0,0 +1,80 @@
+#pragma once
+#include "../processor.h"
+#include "../math/norm_phase_diff.h"
+#include "../math/phasor.h"
+#include "phase_control_loop.h"
+
+namespace dsp::loop {
+    class PLL : public Processor<complex_t, complex_t> {
+        using base_type = Processor<complex_t, complex_t>;
+    public:
+        PLL() {}
+
+        PLL(stream<complex_t>* in, double bandwidth, double initPhase = 0.0, double initFreq = 0.0, double minFreq = -FL_M_PI, double maxFreq = FL_M_PI) { init(in, bandwidth, initFreq, initPhase, minFreq, maxFreq); }
+
+        void init(stream<complex_t>* in, double bandwidth, double initPhase = 0.0, double initFreq = 0.0, double minFreq = -FL_M_PI, double maxFreq = FL_M_PI) {
+            _initPhase = initPhase;
+            _initFreq = initFreq;
+
+            // Init phase control loop
+            float alpha, beta;
+            PhaseControlLoop<float>::criticallyDamped(bandwidth, alpha, beta);
+            pcl.init(alpha, beta, initPhase, -FL_M_PI, FL_M_PI, initFreq, minFreq, maxFreq);
+            
+            base_type::init(in);
+        }
+
+        void setInitialPhase(double initPhase) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _initPhase = initPhase;
+        }
+
+        void setInitialFreq(double initFreq) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            _initFreq = initFreq;
+        }
+
+        void setFrequencyLimits(double minFreq, double maxFreq) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            pcl.setFreqLimits(minFreq, maxFreq);
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            pcl.phase = _initPhase;
+            pcl.freq = _initFreq;
+            base_type::tempStart();
+        }
+
+        inline int process(int count, complex_t* in, complex_t* out) {
+            for (int i = 0; i < count; i++) {
+                out[i] = math::phasor(pcl.phase);
+                pcl.advance(math::normPhaseDiff(in[i].phase() - pcl.phase));
+            }
+            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:
+        PhaseControlLoop<float> pcl;
+        float _initPhase;
+        float _initFreq;
+        complex_t lastVCO = { 1.0f, 0.0f };
+
+    };
+}

core/src/dsp/math/add.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "../operator.h"
+
+namespace dsp::math {
+    template <class T>
+    class Add : public Operator<T, T, T> {
+        using base_type = Operator<T, T, T>;
+    public:
+        Add() {}
+
+        Add(stream<T>* a, stream<T>* b) { base_type::init(a, b); }
+
+        static inline int process(int count, const T* a, const T*b, T* out) {
+            if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
+                volk_32f_x2_add_32f((float*)out, (float*)a, (float*)b, count * 2);
+            }
+            else {
+                volk_32f_x2_add_32f(out, a, b, 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/math/conjugate.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::math {
+    class Conjugate : public Processor<complex_t, complex_t> {
+        using base_type = Processor<complex_t, complex_t>;
+    public:
+        Conjugate() {}
+
+        Conjugate(stream<complex_t>* in) { base_type::init(in); }
+
+        inline static int process(int count, const complex_t* in, complex_t* out) {
+            volk_32fc_conjugate_32fc((lv_32fc_t*)out, (lv_32fc_t*)in, 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;
+        }
+    };
+}

core/src/dsp/math/constants.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#define DB_M_PI     3.14159265358979323846
+#define FL_M_PI     3.1415926535f
+
+#define DB_M_SQRT2  1.4142135623730951
+#define FL_M_SQRT2  1.4142135623f

core/src/dsp/math/delay.h

@@ -0,0 +1,76 @@
+#pragma once
+#include "../processor.h"
+
+namespace dsp::math {
+    template<class T>
+    class Delay : public Processor<T, T> {
+        using base_type = Processor<T, T>;
+    public:
+        Delay() {}
+
+        Delay(stream<T>* in, int delay) { init(in, delay); }
+
+        ~Delay() {
+            if (!base_type::_block_init) { return; }
+            base_type::stop();
+            buffer::free(buffer);
+        }
+
+        void init(stream<T>* in, int delay) {
+            _delay = delay;
+
+            buffer = buffer::alloc<float>(STREAM_BUFFER_SIZE + 64000);
+            bufStart = &buffer[_delay];
+            buffer::clear(buffer, _delay);
+
+            base_type::init(in);
+        }
+
+        void setDelay(int delay) {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            _delay = delay;
+            bufStart = &buffer[_delay];
+            reset();
+            base_type::tempStart();
+        }
+
+        void reset() {
+            assert(base_type::_block_init);
+            std::lock_guard<std::recursive_mutex> lck(base_type::ctrlMtx);
+            base_type::tempStop();
+            buffer::clear(buffer, _delay);
+            base_type::tempStart();
+        }
+
+        inline int process(int count, const T* in, T* out) {
+            // Copy data into delay buffer
+            memcpy(bufStart, in, count * sizeof(T));
+
+            // Copy data out of the delay buffer
+            memcpy(out, buffer, count * sizeof(T));
+
+            // Move end of the delay buffer to the front
+            memmove(buffer, &buffer[count], _delay * sizeof(T));
+
+            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:
+        int _delay;
+        T* buffer;
+        T* bufStart;
+    };
+}

core/src/dsp/math/fast_atan2.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <math.h>
+#include "constants.h"
+
+#define FAST_ATAN2_COEF1 FL_M_PI / 4.0f
+#define FAST_ATAN2_COEF2 3.0f * FAST_ATAN2_COEF1
+
+namespace dsp::math {
+    inline float fastAtan2(float x, float y) {
+        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;
+    }
+}

core/src/dsp/math/freq_to_omega.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <math.h>
+#include "constants.h"
+
+namespace dsp::math {
+    inline double freqToOmega(double freq, double samplerate) {
+        return 2.0 * DB_M_PI * (freq / samplerate);
+    }
+}

core/src/dsp/math/multiply.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "../operator.h"
+
+namespace dsp::math {
+    template <class T>
+    class Multiply : public Operator<T, T, T> {
+        using base_type = Operator<T, T, T>;
+    public:
+        Multiply() {}
+
+        Multiply(stream<T>* a, stream<T>* b) { base_type::init(a, b); }
+
+        inline static int process(int count, const T* a, const T* b, T* out) {
+            if constexpr (std::is_same_v<T, complex_t>) {
+                volk_32fc_x2_multiply_32fc((lv_32fc_t*)out, (lv_32fc_t*)a, (lv_32fc_t*)b, count);
+            }
+            else {
+                volk_32f_x2_multiply_32f(out, a, b, 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/math/norm_phase_diff.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "constants.h"
+
+namespace dsp::math {
+    template<class T>
+    T normPhaseDiff(T diff) {
+        if (diff > FL_M_PI) { diff -= 2.0f * FL_M_PI; }
+        else if (diff <= -FL_M_PI) { diff += 2.0f * FL_M_PI; }
+        return diff;
+    }
+}

core/src/dsp/math/phasor.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <math.h>
+#include "../types.h"
+
+namespace dsp::math {
+    inline complex_t phasor(float x) {
+        complex_t cplx = { cosf(x), sinf(x) };
+        return cplx;
+    }
+}

core/src/dsp/math/sinc.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <math.h>
+
+namespace dsp::math {
+    inline double sinc(double x) {
+        return (x == 0.0) ? 1.0 : (sin(x) / x);
+    }
+}

core/src/dsp/math/subtract.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "../operator.h"
+
+namespace dsp::math {
+    template <class T>
+    class Subtract : public Operator<T, T, T> {
+        using base_type = Operator<T, T, T>;
+    public:
+        Subtract() {}
+
+        Subtract(stream<T>* a, stream<T>* b) { init(a, b); }
+
+        inline static int process(int count, const T* a, const T* b, T* out) {
+            if constexpr (std::is_same_v<T, complex_t> || std::is_same_v<T, stereo_t>) {
+                volk_32f_x2_subtract_32f((float*)out, (float*)a, (float*)b, count * 2);
+            }
+            else {
+                volk_32f_x2_subtract_32f(out, a, b, 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/multirate/.old_decim/plans.h

@@ -0,0 +1,206 @@
+#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::multirate::decim {
+    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/multirate/.old_decim/taps/fir_1024_128.h

@@ -0,0 +1,577 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_1024_32.h

@@ -0,0 +1,139 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_1024_64.h

@@ -0,0 +1,317 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_128_16.h

@@ -0,0 +1,83 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_128_32.h

@@ -0,0 +1,192 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_128_4.h

@@ -0,0 +1,28 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_128_64.h

@@ -0,0 +1,519 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_128_8.h

@@ -0,0 +1,45 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_16_16.h

@@ -0,0 +1,564 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_16_2.h

@@ -0,0 +1,18 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_16_4.h

@@ -0,0 +1,34 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_16_8.h

@@ -0,0 +1,76 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_2048_128.h

@@ -0,0 +1,526 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_2048_64.h

@@ -0,0 +1,265 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_256_16.h

@@ -0,0 +1,88 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_256_32.h

@@ -0,0 +1,154 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_256_64.h

@@ -0,0 +1,368 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_256_8.h

@@ -0,0 +1,44 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_2_2.h

@@ -0,0 +1,81 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_32_16.h

@@ -0,0 +1,140 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_32_2.h

@@ -0,0 +1,18 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_32_4.h

@@ -0,0 +1,29 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_32_8.h

@@ -0,0 +1,57 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_4096_128.h

@@ -0,0 +1,699 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_4_2.h

@@ -0,0 +1,27 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_4_4.h

@@ -0,0 +1,151 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_512_128.h

@@ -0,0 +1,723 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_512_16.h

@@ -0,0 +1,76 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_512_32.h

@@ -0,0 +1,163 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_512_64.h

@@ -0,0 +1,296 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_64_16.h

@@ -0,0 +1,102 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_64_2.h

@@ -0,0 +1,16 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_64_32.h

@@ -0,0 +1,266 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_64_4.h

@@ -0,0 +1,31 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_64_8.h

@@ -0,0 +1,48 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_8_2.h

@@ -0,0 +1,21 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_8_4.h

@@ -0,0 +1,44 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/.old_decim/taps/fir_8_8.h

@@ -0,0 +1,292 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/plans.h

@@ -0,0 +1,138 @@
+#pragma once
+#include "taps/fir_1024_64.h"
+#include "taps/fir_128_16.h"
+#include "taps/fir_16_8.h"
+#include "taps/fir_2048_64.h"
+#include "taps/fir_256_32.h"
+#include "taps/fir_2_2.h"
+#include "taps/fir_32_8.h"
+#include "taps/fir_4096_64.h"
+#include "taps/fir_4_2.h"
+#include "taps/fir_512_32.h"
+#include "taps/fir_64_8.h"
+#include "taps/fir_8192_128.h"
+#include "taps/fir_8_4.h"
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    struct stage {
+        unsigned int decimation;
+        unsigned int tapcount;
+        const float* taps;
+    };
+
+    struct plan {
+        unsigned int stageCount;
+        const stage* stages;
+    };
+
+    const unsigned int plan_1024_len = 3;
+    const stage plan_1024[] = {
+        { 64, fir_1024_64_len, fir_1024_64_taps },
+        { 8, fir_16_8_len, fir_16_8_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_128_len = 3;
+    const stage plan_128[] = {
+        { 16, fir_128_16_len, fir_128_16_taps },
+        { 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_2_len = 1;
+    const stage plan_2[] = {
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_2048_len = 4;
+    const stage plan_2048[] = {
+        { 64, fir_2048_64_len, fir_2048_64_taps },
+        { 8, fir_32_8_len, fir_32_8_taps },
+        { 2, fir_4_2_len, fir_4_2_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_256_len = 3;
+    const stage plan_256[] = {
+        { 32, fir_256_32_len, fir_256_32_taps },
+        { 4, fir_8_4_len, fir_8_4_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_32_len = 3;
+    const stage plan_32[] = {
+        { 8, fir_32_8_len, fir_32_8_taps },
+        { 2, fir_4_2_len, fir_4_2_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_4_len = 2;
+    const stage plan_4[] = {
+        { 2, fir_4_2_len, fir_4_2_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_4096_len = 4;
+    const stage plan_4096[] = {
+        { 64, fir_4096_64_len, fir_4096_64_taps },
+        { 8, fir_64_8_len, fir_64_8_taps },
+        { 4, fir_8_4_len, fir_8_4_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_512_len = 3;
+    const stage plan_512[] = {
+        { 32, fir_512_32_len, fir_512_32_taps },
+        { 8, fir_16_8_len, fir_16_8_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    const unsigned int plan_64_len = 3;
+    const stage plan_64[] = {
+        { 8, fir_64_8_len, fir_64_8_taps },
+        { 4, fir_8_4_len, fir_8_4_taps },
+        { 2, fir_2_2_len, fir_2_2_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_8192_len = 4;
+    const stage plan_8192[] = {
+        { 128, fir_8192_128_len, fir_8192_128_taps },
+        { 8, fir_64_8_len, fir_64_8_taps },
+        { 4, fir_8_4_len, fir_8_4_taps },
+        { 2, fir_2_2_len, fir_2_2_taps },
+    };
+
+    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 },
+    };
+}

core/src/dsp/multirate/decim/taps/fir_1024_128.h

@@ -0,0 +1,577 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_1024_32.h

@@ -0,0 +1,139 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_1024_64.h

@@ -0,0 +1,269 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    const unsigned int fir_1024_64_len = 257;
+    const float fir_1024_64_taps[] = {
+        0.000006462031529,
+        0.000003762409463,
+        0.000004844873785,
+        0.000006123946040,
+        0.000007623557621,
+        0.000009369500189,
+        0.000011389489511,
+        0.000013713225713,
+        0.000016372450007,
+        0.000019400995965,
+        0.000022834836357,
+        0.000026712124166,
+        0.000031073227314,
+        0.000035960757034,
+        0.000041419588684,
+        0.000047496875380,
+        0.000054242053050,
+        0.000061706837053,
+        0.000069945209697,
+        0.000079013398311,
+        0.000088969843345,
+        0.000099875155888,
+        0.000111792065160,
+        0.000124785354321,
+        0.000138921785260,
+        0.000154270012137,
+        0.000170900482798,
+        0.000188885328279,
+        0.000208298240660,
+        0.000229214338496,
+        0.000251710020027,
+        0.000275862804808,
+        0.000301751162750,
+        0.000329454331625,
+        0.000359052122812,
+        0.000390624715628,
+        0.000424252440518,
+        0.000460015551653,
+        0.000497993989069,
+        0.000538267130868,
+        0.000580913536707,
+        0.000626010681838,
+        0.000673634683977,
+        0.000723860022294,
+        0.000776759250136,
+        0.000832402702294,
+        0.000890858197110,
+        0.000952190735149,
+        0.001016462194703,
+        0.001083731025617,
+        0.001154051942217,
+        0.001227475616900,
+        0.001304048374716,
+        0.001383811890755,
+        0.001466802891491,
+        0.001553052860930,
+        0.001642587753007,
+        0.001735427711423,
+        0.001831586798359,
+        0.001931072732585,
+        0.002033886639476,
+        0.002140022812541,
+        0.002249468489330,
+        0.002362203641302,
+        0.002478200780155,
+        0.002597424780897,
+        0.002719832722953,
+        0.002845373750630,
+        0.002973988953416,
+        0.003105611267477,
+        0.003240165399026,
+        0.003377567770453,
+        0.003517726489639,
+        0.003660541344023,
+        0.003805903818490,
+        0.003953697139430,
+        0.004103796343600,
+        0.004256068373481,
+        0.004410372198649,
+        0.004566558963662,
+        0.004724472161982,
+        0.004883947836741,
+        0.005044814807351,
+        0.005206894922255,
+        0.005370003337046,
+        0.005533948818282,
+        0.005698534071229,
+        0.005863556091925,
+        0.006028806542319,
+        0.006194072147902,
+        0.006359135116484,
+        0.006523773577483,
+        0.006687762040265,
+        0.006850871870724,
+        0.007012871784157,
+        0.007173528353865,
+        0.007332606533364,
+        0.007489870190776,
+        0.007645082654370,
+        0.007798007266777,
+        0.007948407946740,
+        0.008096049756555,
+        0.008240699473269,
+        0.008382126161983,
+        0.008520101749207,
+        0.008654401594640,
+        0.008784805059577,
+        0.008911096069443,
+        0.009033063669314,
+        0.009150502570440,
+        0.009263213685289,
+        0.009371004650260,
+        0.009473690333377,
+        0.009571093325806,
+        0.009663044415454,
+        0.009749383040556,
+        0.009829957722201,
+        0.009904626474092,
+        0.009973257187859,
+        0.010035727993149,
+        0.010091927590538,
+        0.010141755556416,
+        0.010185122619096,
+        0.010221950904489,
+        0.010252174150955,
+        0.010275737892470,
+        0.010292599609103,
+        0.010302728845123,
+        0.010306107293174,
+        0.010302728845123,
+        0.010292599609103,
+        0.010275737892470,
+        0.010252174150955,
+        0.010221950904489,
+        0.010185122619096,
+        0.010141755556416,
+        0.010091927590538,
+        0.010035727993149,
+        0.009973257187859,
+        0.009904626474092,
+        0.009829957722201,
+        0.009749383040556,
+        0.009663044415454,
+        0.009571093325806,
+        0.009473690333377,
+        0.009371004650260,
+        0.009263213685289,
+        0.009150502570440,
+        0.009033063669314,
+        0.008911096069443,
+        0.008784805059577,
+        0.008654401594640,
+        0.008520101749207,
+        0.008382126161983,
+        0.008240699473269,
+        0.008096049756555,
+        0.007948407946740,
+        0.007798007266777,
+        0.007645082654370,
+        0.007489870190776,
+        0.007332606533364,
+        0.007173528353865,
+        0.007012871784157,
+        0.006850871870724,
+        0.006687762040265,
+        0.006523773577483,
+        0.006359135116484,
+        0.006194072147902,
+        0.006028806542319,
+        0.005863556091925,
+        0.005698534071229,
+        0.005533948818282,
+        0.005370003337046,
+        0.005206894922255,
+        0.005044814807351,
+        0.004883947836741,
+        0.004724472161982,
+        0.004566558963662,
+        0.004410372198649,
+        0.004256068373481,
+        0.004103796343600,
+        0.003953697139430,
+        0.003805903818490,
+        0.003660541344023,
+        0.003517726489639,
+        0.003377567770453,
+        0.003240165399026,
+        0.003105611267477,
+        0.002973988953416,
+        0.002845373750630,
+        0.002719832722953,
+        0.002597424780897,
+        0.002478200780155,
+        0.002362203641302,
+        0.002249468489330,
+        0.002140022812541,
+        0.002033886639476,
+        0.001931072732585,
+        0.001831586798359,
+        0.001735427711423,
+        0.001642587753007,
+        0.001553052860930,
+        0.001466802891491,
+        0.001383811890755,
+        0.001304048374716,
+        0.001227475616900,
+        0.001154051942217,
+        0.001083731025617,
+        0.001016462194703,
+        0.000952190735149,
+        0.000890858197110,
+        0.000832402702294,
+        0.000776759250136,
+        0.000723860022294,
+        0.000673634683977,
+        0.000626010681838,
+        0.000580913536707,
+        0.000538267130868,
+        0.000497993989069,
+        0.000460015551653,
+        0.000424252440518,
+        0.000390624715628,
+        0.000359052122812,
+        0.000329454331625,
+        0.000301751162750,
+        0.000275862804808,
+        0.000251710020027,
+        0.000229214338496,
+        0.000208298240660,
+        0.000188885328279,
+        0.000170900482798,
+        0.000154270012137,
+        0.000138921785260,
+        0.000124785354321,
+        0.000111792065160,
+        0.000099875155888,
+        0.000088969843345,
+        0.000079013398311,
+        0.000069945209697,
+        0.000061706837053,
+        0.000054242053050,
+        0.000047496875380,
+        0.000041419588684,
+        0.000035960757034,
+        0.000031073227314,
+        0.000026712124166,
+        0.000022834836357,
+        0.000019400995965,
+        0.000016372450007,
+        0.000013713225713,
+        0.000011389489511,
+        0.000009369500189,
+        0.000007623557621,
+        0.000006123946040,
+        0.000004844873785,
+        0.000003762409463,
+        0.000006462031529,
+    };
+}

core/src/dsp/multirate/decim/taps/fir_128_16.h

@@ -0,0 +1,84 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    const unsigned int fir_128_16_len = 72;
+    const float fir_128_16_taps[] = {
+        0.000003688211243,
+        0.000013660745184,
+        0.000027864244875,
+        0.000056024595736,
+        0.000099948148808,
+        0.000168552197041,
+        0.000269382284025,
+        0.000413325712010,
+        0.000612084815649,
+        0.000879405538662,
+        0.001230104825804,
+        0.001680092905716,
+        0.002245658820654,
+        0.002942957882659,
+        0.003787212583021,
+        0.004791922493325,
+        0.005967969572298,
+        0.007322738536994,
+        0.008859256322921,
+        0.010575423925694,
+        0.012463379308760,
+        0.014509046778473,
+        0.016691912242846,
+        0.018985060458242,
+        0.021355495646189,
+        0.023764754477139,
+        0.026169804021396,
+        0.028524201614471,
+        0.030779477612194,
+        0.032886687871454,
+        0.034798070863046,
+        0.036468735790737,
+        0.037858303447209,
+        0.038932421304764,
+        0.039664078609141,
+        0.040034655893826,
+        0.040034655893826,
+        0.039664078609141,
+        0.038932421304764,
+        0.037858303447209,
+        0.036468735790737,
+        0.034798070863046,
+        0.032886687871454,
+        0.030779477612194,
+        0.028524201614471,
+        0.026169804021396,
+        0.023764754477139,
+        0.021355495646189,
+        0.018985060458242,
+        0.016691912242846,
+        0.014509046778473,
+        0.012463379308760,
+        0.010575423925694,
+        0.008859256322921,
+        0.007322738536994,
+        0.005967969572298,
+        0.004791922493325,
+        0.003787212583021,
+        0.002942957882659,
+        0.002245658820654,
+        0.001680092905716,
+        0.001230104825804,
+        0.000879405538662,
+        0.000612084815649,
+        0.000413325712010,
+        0.000269382284025,
+        0.000168552197041,
+        0.000099948148808,
+        0.000056024595736,
+        0.000027864244875,
+        0.000013660745184,
+        0.000003688211243,
+    };
+}

core/src/dsp/multirate/decim/taps/fir_128_32.h

@@ -0,0 +1,192 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_128_4.h

@@ -0,0 +1,28 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_128_64.h

@@ -0,0 +1,519 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_128_8.h

@@ -0,0 +1,45 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_16_16.h

@@ -0,0 +1,564 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_16_2.h

@@ -0,0 +1,18 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_16_4.h

@@ -0,0 +1,34 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_16_8.h

@@ -0,0 +1,66 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    const unsigned int fir_16_8_len = 54;
+    const float fir_16_8_taps[] = {
+        -0.000010549050011,
+        -0.000061489537039,
+        -0.000169592150226,
+        -0.000389171926135,
+        -0.000769975911674,
+        -0.001370854592385,
+        -0.002239650734147,
+        -0.003399889102518,
+        -0.004830705343877,
+        -0.006448446354249,
+        -0.008091855414668,
+        -0.009515841436220,
+        -0.010397441921856,
+        -0.010356613271974,
+        -0.008992201469341,
+        -0.005930787518203,
+        -0.000883278427221,
+        0.006298245739840,
+        0.015572308400311,
+        0.026677311102094,
+        0.039125595948408,
+        0.052226522148894,
+        0.065138644768753,
+        0.076946519590666,
+        0.086753453366436,
+        0.093778448420600,
+        0.097444265291570,
+        0.097444265291570,
+        0.093778448420600,
+        0.086753453366436,
+        0.076946519590666,
+        0.065138644768753,
+        0.052226522148894,
+        0.039125595948408,
+        0.026677311102094,
+        0.015572308400311,
+        0.006298245739840,
+        -0.000883278427221,
+        -0.005930787518203,
+        -0.008992201469341,
+        -0.010356613271974,
+        -0.010397441921856,
+        -0.009515841436220,
+        -0.008091855414668,
+        -0.006448446354249,
+        -0.004830705343877,
+        -0.003399889102518,
+        -0.002239650734147,
+        -0.001370854592385,
+        -0.000769975911674,
+        -0.000389171926135,
+        -0.000169592150226,
+        -0.000061489537039,
+        -0.000010549050011,
+    };
+}

core/src/dsp/multirate/decim/taps/fir_2048_128.h

@@ -0,0 +1,526 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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/multirate/decim/taps/fir_2048_64.h

@@ -0,0 +1,341 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    const unsigned int fir_2048_64_len = 329;
+    const float fir_2048_64_taps[] = {
+        0.000000000199668,
+        0.000000205043166,
+        0.000000156335587,
+        0.000000215541606,
+        0.000000289043906,
+        0.000000379397653,
+        0.000000489366234,
+        0.000000622040059,
+        0.000000780862872,
+        0.000000969659261,
+        0.000001192663259,
+        0.000001454547981,
+        0.000001760456262,
+        0.000002116032238,
+        0.000002527453817,
+        0.000003001465946,
+        0.000003545414625,
+        0.000004167281561,
+        0.000004875719359,
+        0.000005680087172,
+        0.000006590486661,
+        0.000007617798168,
+        0.000008773716957,
+        0.000010070789376,
+        0.000011522448815,
+        0.000013143051261,
+        0.000014947910332,
+        0.000016953331574,
+        0.000019176645863,
+        0.000021636241718,
+        0.000024351596326,
+        0.000027343305093,
+        0.000030633109489,
+        0.000034243923000,
+        0.000038199854973,
+        0.000042526232102,
+        0.000047249617395,
+        0.000052397826336,
+        0.000057999940064,
+        0.000064086315335,
+        0.000070688591034,
+        0.000077839691045,
+        0.000085573823231,
+        0.000093926474339,
+        0.000102934400627,
+        0.000112635613980,
+        0.000123069363379,
+        0.000134276111489,
+        0.000146297506226,
+        0.000159176347141,
+        0.000172956546458,
+        0.000187683084638,
+        0.000203401960366,
+        0.000220160134836,
+        0.000238005470250,
+        0.000256986662475,
+        0.000277153167800,
+        0.000298555123757,
+        0.000321243264012,
+        0.000345268827318,
+        0.000370683460586,
+        0.000397539116108,
+        0.000425887943051,
+        0.000455782173269,
+        0.000487274001624,
+        0.000520415460934,
+        0.000555258291741,
+        0.000591853807104,
+        0.000630252752645,
+        0.000670505162114,
+        0.000712660208750,
+        0.000756766052737,
+        0.000802869685119,
+        0.000851016768484,
+        0.000901251474847,
+        0.000953616321094,
+        0.001008152002452,
+        0.001064897224391,
+        0.001123888533469,
+        0.001185160147570,
+        0.001248743786063,
+        0.001314668500389,
+        0.001382960505628,
+        0.001453643013568,
+        0.001526736067868,
+        0.001602256381861,
+        0.001680217179590,
+        0.001760628040646,
+        0.001843494749418,
+        0.001928819149316,
+        0.002016599002583,
+        0.002106827856267,
+        0.002199494914939,
+        0.002294584920730,
+        0.002392078041256,
+        0.002491949765985,
+        0.002594170811576,
+        0.002698707036722,
+        0.002805519367007,
+        0.002914563730244,
+        0.003025791002763,
+        0.003139146967090,
+        0.003254572281416,
+        0.003372002461236,
+        0.003491367873501,
+        0.003612593743601,
+        0.003735600175462,
+        0.003860302184972,
+        0.003986609746975,
+        0.004114427855956,
+        0.004243656600570,
+        0.004374191252069,
+        0.004505922366671,
+        0.004638735901866,
+        0.004772513346579,
+        0.004907131865119,
+        0.005042464454740,
+        0.005178380116639,
+        0.005314744040122,
+        0.005451417799686,
+        0.005588259564642,
+        0.005725124320935,
+        0.005861864104709,
+        0.005998328247162,
+        0.006134363630171,
+        0.006269814952126,
+        0.006404525003407,
+        0.006538334950818,
+        0.006671084630359,
+        0.006802612847587,
+        0.006932757684861,
+        0.007061356814659,
+        0.007188247818209,
+        0.007313268508566,
+        0.007436257257322,
+        0.007557053324043,
+        0.007675497187571,
+        0.007791430878266,
+        0.007904698310281,
+        0.008015145612939,
+        0.008122621460286,
+        0.008226977397872,
+        0.008328068165838,
+        0.008425752017374,
+        0.008519891031616,
+        0.008610351420080,
+        0.008697003825729,
+        0.008779723613781,
+        0.008858391153404,
+        0.008932892089457,
+        0.009003117603448,
+        0.009068964662954,
+        0.009130336258703,
+        0.009187141628648,
+        0.009239296468318,
+        0.009286723126810,
+        0.009329350787828,
+        0.009367115635223,
+        0.009399961002488,
+        0.009427837505799,
+        0.009450703160140,
+        0.009468523478197,
+        0.009481271551679,
+        0.009488928114839,
+        0.009491481589983,
+        0.009488928114839,
+        0.009481271551679,
+        0.009468523478197,
+        0.009450703160140,
+        0.009427837505799,
+        0.009399961002488,
+        0.009367115635223,
+        0.009329350787828,
+        0.009286723126810,
+        0.009239296468318,
+        0.009187141628648,
+        0.009130336258703,
+        0.009068964662954,
+        0.009003117603448,
+        0.008932892089457,
+        0.008858391153404,
+        0.008779723613781,
+        0.008697003825729,
+        0.008610351420080,
+        0.008519891031616,
+        0.008425752017374,
+        0.008328068165838,
+        0.008226977397872,
+        0.008122621460286,
+        0.008015145612939,
+        0.007904698310281,
+        0.007791430878266,
+        0.007675497187571,
+        0.007557053324043,
+        0.007436257257322,
+        0.007313268508566,
+        0.007188247818209,
+        0.007061356814659,
+        0.006932757684861,
+        0.006802612847587,
+        0.006671084630359,
+        0.006538334950818,
+        0.006404525003407,
+        0.006269814952126,
+        0.006134363630171,
+        0.005998328247162,
+        0.005861864104709,
+        0.005725124320935,
+        0.005588259564642,
+        0.005451417799686,
+        0.005314744040122,
+        0.005178380116639,
+        0.005042464454740,
+        0.004907131865119,
+        0.004772513346579,
+        0.004638735901866,
+        0.004505922366671,
+        0.004374191252069,
+        0.004243656600570,
+        0.004114427855956,
+        0.003986609746975,
+        0.003860302184972,
+        0.003735600175462,
+        0.003612593743601,
+        0.003491367873501,
+        0.003372002461236,
+        0.003254572281416,
+        0.003139146967090,
+        0.003025791002763,
+        0.002914563730244,
+        0.002805519367007,
+        0.002698707036722,
+        0.002594170811576,
+        0.002491949765985,
+        0.002392078041256,
+        0.002294584920730,
+        0.002199494914939,
+        0.002106827856267,
+        0.002016599002583,
+        0.001928819149316,
+        0.001843494749418,
+        0.001760628040646,
+        0.001680217179590,
+        0.001602256381861,
+        0.001526736067868,
+        0.001453643013568,
+        0.001382960505628,
+        0.001314668500389,
+        0.001248743786063,
+        0.001185160147570,
+        0.001123888533469,
+        0.001064897224391,
+        0.001008152002452,
+        0.000953616321094,
+        0.000901251474847,
+        0.000851016768484,
+        0.000802869685119,
+        0.000756766052737,
+        0.000712660208750,
+        0.000670505162114,
+        0.000630252752645,
+        0.000591853807104,
+        0.000555258291741,
+        0.000520415460934,
+        0.000487274001624,
+        0.000455782173269,
+        0.000425887943051,
+        0.000397539116108,
+        0.000370683460586,
+        0.000345268827318,
+        0.000321243264012,
+        0.000298555123757,
+        0.000277153167800,
+        0.000256986662475,
+        0.000238005470250,
+        0.000220160134836,
+        0.000203401960366,
+        0.000187683084638,
+        0.000172956546458,
+        0.000159176347141,
+        0.000146297506226,
+        0.000134276111489,
+        0.000123069363379,
+        0.000112635613980,
+        0.000102934400627,
+        0.000093926474339,
+        0.000085573823231,
+        0.000077839691045,
+        0.000070688591034,
+        0.000064086315335,
+        0.000057999940064,
+        0.000052397826336,
+        0.000047249617395,
+        0.000042526232102,
+        0.000038199854973,
+        0.000034243923000,
+        0.000030633109489,
+        0.000027343305093,
+        0.000024351596326,
+        0.000021636241718,
+        0.000019176645863,
+        0.000016953331574,
+        0.000014947910332,
+        0.000013143051261,
+        0.000011522448815,
+        0.000010070789376,
+        0.000008773716957,
+        0.000007617798168,
+        0.000006590486661,
+        0.000005680087172,
+        0.000004875719359,
+        0.000004167281561,
+        0.000003545414625,
+        0.000003001465946,
+        0.000002527453817,
+        0.000002116032238,
+        0.000001760456262,
+        0.000001454547981,
+        0.000001192663259,
+        0.000000969659261,
+        0.000000780862872,
+        0.000000622040059,
+        0.000000489366234,
+        0.000000379397653,
+        0.000000289043906,
+        0.000000215541606,
+        0.000000156335587,
+        0.000000205043166,
+        0.000000000199668,
+    };
+}

core/src/dsp/multirate/decim/taps/fir_256_16.h

@@ -0,0 +1,88 @@
+#pragma once
+
+/*
+    This file was auto-generated by Ryzerth's magic optimized FIR script.
+    DO NOT EDIT MANUALLY!!!
+*/
+
+namespace dsp::multirate::decim {
+    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,
+    };
+}