rewrote DSP

src/dsp/correction.h

@@ -0,0 +1,63 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+
+namespace dsp {
+    class DCBiasRemover {
+    public:
+        DCBiasRemover() {
+            
+        }
+
+        DCBiasRemover(stream<complex_t>* input, int bufferSize) : output(bufferSize * 2) {
+            _in = input;
+            _bufferSize = bufferSize;
+            bypass = false;
+        }
+
+        void init(stream<complex_t>* input, int bufferSize) {
+            output.init(bufferSize * 2);
+            _in = input;
+            _bufferSize = bufferSize;
+            bypass = false;
+        }
+
+        void start() {
+            _workerThread = std::thread(_worker, this);
+        }
+
+        stream<complex_t> output;
+        bool bypass;
+
+    private:
+        static void _worker(DCBiasRemover* _this) {
+            complex_t* buf = new complex_t[_this->_bufferSize];
+            float ibias = 0.0f;
+            float qbias = 0.0f;
+            while (true) {
+                _this->_in->read(buf, _this->_bufferSize);
+                if (_this->bypass) {
+                    _this->output.write(buf, _this->_bufferSize);
+                    continue;
+                }
+                for (int i = 0; i < _this->_bufferSize; i++) {
+                    ibias += buf[i].i;
+                    qbias += buf[i].q;
+                }
+                ibias /= _this->_bufferSize;
+                qbias /= _this->_bufferSize;
+                for (int i = 0; i < _this->_bufferSize; i++) {
+                    buf[i].i -= ibias;
+                    buf[i].q -= qbias;
+                }
+                _this->output.write(buf, _this->_bufferSize);
+            }
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+    };
+};

src/dsp/demodulator.h

@@ -0,0 +1,198 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+
+/*
+    TODO:
+        - Add a sample rate ajustment function to all demodulators
+*/
+
+#define FAST_ATAN2_COEF1 3.1415926535f / 4.0f
+#define FAST_ATAN2_COEF2 3.0f * FAST_ATAN2_COEF1
+
+inline float fast_arctan2(float y, float x) {
+   float abs_y = fabs(y)+1e-10;
+   float r, angle;
+   if (x>=0)
+   {
+      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) {
+       return -angle;
+   }
+   return angle;
+}
+
+namespace dsp {
+    class FMDemodulator {
+    public:
+        FMDemodulator() {
+            
+        }
+
+        FMDemodulator(stream<complex_t>* in, float deviation, long sampleRate, int blockSize) : output(blockSize * 2) {
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+            _phase = 0.0f;
+            _phasorSpeed = (2 * 3.1415926535) / (sampleRate / deviation);
+        }
+
+        void init(stream<complex_t>* in, float deviation, long sampleRate, int blockSize) {
+            output.init(blockSize * 2);
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+            _phase = 0.0f;
+            _phasorSpeed = (2 * 3.1415926535) / (sampleRate / deviation);
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            running = false;
+            _input->clearReadStop();
+            output.clearWriteStop();
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(_blockSize * 2);
+        }
+
+        stream<float> output;
+
+    private:
+        static void _worker(FMDemodulator* _this) {
+            complex_t* inBuf = new complex_t[_this->_blockSize];
+            float* outBuf = new float[_this->_blockSize];
+            float diff = 0;
+            float currentPhase = 0;
+            while (true) {
+                if (_this->_input->read(inBuf, _this->_blockSize) < 0) { return; };
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    currentPhase = fast_arctan2(inBuf[i].i, inBuf[i].q);
+                    diff = currentPhase - _this->_phase;
+                    if (diff > 3.1415926535f)        { diff -= 2 * 3.1415926535f; }
+                    else if (diff <= -3.1415926535f) { diff += 2 * 3.1415926535f; }
+                    outBuf[i] = diff / _this->_phasorSpeed;
+                    _this->_phase = currentPhase;
+                }
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { return; };
+            }
+        }
+
+        stream<complex_t>* _input;
+        bool running;
+        int _blockSize;
+        float _phase;
+        float _phasorSpeed;
+        std::thread _workerThread;
+    };
+
+
+    class AMDemodulator {
+    public:
+        AMDemodulator() {
+            
+        }
+
+        AMDemodulator(stream<complex_t>* in, int blockSize) : output(blockSize * 2) {
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<complex_t>* in, int blockSize) {
+            output.init(blockSize * 2);
+            running = false;
+            _input = in;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            running = false;
+            _input->clearReadStop();
+            output.clearWriteStop();
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(_blockSize * 2);
+        }
+
+        stream<float> output;
+
+    private:
+        static void _worker(AMDemodulator* _this) {
+            complex_t* inBuf = new complex_t[_this->_blockSize];
+            float* outBuf = new float[_this->_blockSize];
+            float min, max, amp;
+            while (true) {
+                if (_this->_input->read(inBuf, _this->_blockSize) < 0) { break; };
+                min = INFINITY;
+                max = 0.0f;
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    outBuf[i] = sqrt((inBuf[i].i*inBuf[i].i) + (inBuf[i].q*inBuf[i].q));
+                    if (outBuf[i] < min) {
+                        min = outBuf[i];
+                    }
+                    if (outBuf[i] > max) {
+                        max = outBuf[i];
+                    }
+                }
+                amp = (max - min);
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    outBuf[i] = (outBuf[i] - min) / (max - min);
+                }
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<complex_t>* _input;
+        bool running;
+        int _blockSize;
+        std::thread _workerThread;
+    };
+};

src/dsp/filter.h

@@ -0,0 +1,361 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+#include <dsp/math.h>
+
+#define GET_FROM_RIGHT_BUF(buffer, delayLine, delayLineSz, n) (((n) < 0) ? delayLine[(delayLineSz) + (n)] : buffer[(n)])
+
+namespace dsp {
+    inline void BlackmanWindow(std::vector<float>& taps, float sampleRate, float cutoff, float transWidth) {
+        taps.clear();
+        float fc = cutoff / sampleRate;
+        int _M = 4.0f / (transWidth / sampleRate);
+        if (_M % 2 == 0) { _M++; }
+        float M = _M;
+        float sum = 0.0f;
+        for (int i = 0; i < _M; i++) {
+            float val = (sin(2.0f * M_PI * fc * ((float)i - (M / 2))) / ((float)i - (M / 2))) * (0.42f - (0.5f * cos(2.0f * M_PI / M)) + (0.8f * cos(4.0f * M_PI / M)));
+            taps.push_back(val);
+            sum += val;
+        }
+        for (int i = 0; i < M; i++) {
+            taps[i] /= sum;
+        }
+    }
+
+    class DecimatingFIRFilter {
+    public:
+        DecimatingFIRFilter() {
+            
+        }
+
+        DecimatingFIRFilter(stream<complex_t>* input, std::vector<float> taps, int blockSize, float decim) : output(blockSize * 2) {
+            output.init(blockSize * 2);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new complex_t[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i].i = 0.0f;
+                delayBuf[i].q = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void init(stream<complex_t>* input, std::vector<float>& taps, int blockSize, float decim) {
+            output.init(blockSize * 2);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new complex_t[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i].i = 0.0f;
+                delayBuf[i].q = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+        
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setTaps(std::vector<float>& taps) {
+            if (running) {
+                return;
+            }
+            _tapCount = taps.size();
+            printf("[%d]\n", _tapCount);
+            delete[] _taps;
+            delete[] delayBuf;
+            _taps = new float[_tapCount];
+            delayBuf = new complex_t[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+        }
+
+        void setInput(stream<complex_t>* input) {
+            if (running) {
+                return;
+            }
+            _in = input;
+        }
+
+        void setDecimation(float decimation) {
+            if (running) {
+                return;
+            }
+            _decim = decimation;
+            output.setMaxLatency((_blockSize * 2) / _decim);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency((_blockSize * 2) / _decim);
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(DecimatingFIRFilter* _this) {
+            int outputSize = _this->_blockSize / _this->_decim;
+            complex_t* inBuf = new complex_t[_this->_blockSize];
+            complex_t* outBuf = new complex_t[outputSize];
+            float tap = 0.0f;
+            int delayOff;
+            void* delayStart = &inBuf[_this->_blockSize - (_this->_tapCount - 1)];
+            int delaySize = (_this->_tapCount - 1) * sizeof(complex_t);
+
+            int blockSize = _this->_blockSize;
+            int outBufferLength = outputSize * sizeof(complex_t);
+            int tapCount = _this->_tapCount;
+            int decim = _this->_decim;
+            complex_t* delayBuf = _this->delayBuf;
+            int id = 0;
+
+            while (true) {
+                if (_this->_in->read(inBuf, blockSize) < 0) { break; };
+                memset(outBuf, 0, outBufferLength);
+                
+                for (int t = 0; t < tapCount; t++) {
+                    tap = _this->_taps[t];
+                    if (tap == 0.0f) {
+                        continue;
+                    }
+
+                    delayOff = tapCount - t;
+                    id = 0;
+
+                    for (int i = 0; i < blockSize; i += decim) {
+                        if (i < t) {
+                            outBuf[id].i += tap * delayBuf[delayOff + i].i;
+                            outBuf[id].q += tap * delayBuf[delayOff + i].q;
+                            id++;
+                            continue;
+                        }
+                        outBuf[id].i += tap * inBuf[i - t].i;
+                        outBuf[id].q += tap * inBuf[i - t].q;
+                        id++;
+                    }
+                }
+                memcpy(delayBuf, delayStart, delaySize);
+                if (_this->output.write(outBuf, outputSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<complex_t>* _in;
+        complex_t* delayBuf;
+        int _blockSize;
+        int _tapCount = 0;
+        float _decim;
+        std::thread _workerThread;
+        float* _taps;
+        bool running;
+    };
+
+
+    class FloatDecimatingFIRFilter {
+    public:
+        FloatDecimatingFIRFilter() {
+            
+        }
+
+        FloatDecimatingFIRFilter(stream<float>* input, std::vector<float> taps, int blockSize, float decim) : output(blockSize * 2) {
+            output.init(blockSize * 2);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new float[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i] = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void init(stream<float>* input, std::vector<float>& taps, int blockSize, float decim) {
+            output.init(blockSize * 2);
+            _in = input;
+            _blockSize = blockSize;
+            _tapCount = taps.size();
+            delayBuf = new float[_tapCount];
+
+            _taps = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+
+            _decim = decim;
+
+            for (int i = 0; i < _tapCount; i++) {
+                delayBuf[i] = 0.0f;
+            }
+
+            running = false;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+        
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _in->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _in->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setTaps(std::vector<float>& taps) {
+            if (running) {
+                return;
+            }
+            _tapCount = taps.size();
+            delete[] _taps;
+            delete[] delayBuf;
+            _taps = new float[_tapCount];
+            delayBuf = new float[_tapCount];
+            for (int i = 0; i < _tapCount; i++) {
+                _taps[i] = taps[i];
+            }
+        }
+
+        void setInput(stream<float>* input) {
+            if (running) {
+                return;
+            }
+            _in = input;
+        }
+
+        void setDecimation(float decimation) {
+            if (running) {
+                return;
+            }
+            _decim = decimation;
+            output.setMaxLatency((_blockSize * 2) / _decim);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency((_blockSize * 2) / _decim);
+        }
+
+        stream<float> output;
+
+    private:
+        static void _worker(FloatDecimatingFIRFilter* _this) {
+            int outputSize = _this->_blockSize / _this->_decim;
+            float* inBuf = new float[_this->_blockSize];
+            float* outBuf = new float[outputSize];
+            float tap = 0.0f;
+            int delayOff;
+            void* delayStart = &inBuf[_this->_blockSize - (_this->_tapCount - 1)];
+            int delaySize = (_this->_tapCount - 1) * sizeof(float);
+
+            int blockSize = _this->_blockSize;
+            int outBufferLength = outputSize * sizeof(complex_t);
+            int tapCount = _this->_tapCount;
+            int decim = _this->_decim;
+            float* delayBuf = _this->delayBuf;
+            int id = 0;
+
+            while (true) {
+                if (_this->_in->read(inBuf, blockSize) < 0) { break; };
+                memset(outBuf, 0, outBufferLength);
+                
+                for (int t = 0; t < tapCount; t++) {
+                    tap = _this->_taps[t];
+                    if (tap == 0.0f) {
+                        continue;
+                    }
+
+                    delayOff = tapCount - t;
+                    id = 0;
+
+                    for (int i = 0; i < blockSize; i += decim) {
+                        if (i < t) {
+                            outBuf[id] += tap * delayBuf[delayOff + i];
+                            id++;
+                            continue;
+                        }
+                        outBuf[id] += tap * inBuf[i - t];
+                        id++;
+                    }
+                }
+                memcpy(delayBuf, delayStart, delaySize);
+                if (_this->output.write(outBuf, outputSize) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<float>* _in;
+        float* delayBuf;
+        int _blockSize;
+        int _tapCount = 0;
+        float _decim;
+        std::thread _workerThread;
+        float* _taps;
+        bool running;
+    };
+};

src/dsp/math.h

@@ -0,0 +1,85 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <volk.h>
+
+#ifndef M_PI
+#define M_PI    3.1415926535f
+#endif
+
+namespace dsp {
+    class Multiplier {
+    public:
+        Multiplier() {
+            
+        }
+
+        Multiplier(stream<complex_t>* a, stream<complex_t>* b, int blockSize) : output(blockSize * 2) {
+            _a = a;
+            _b = b;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<complex_t>* a, stream<complex_t>* b, int blockSize) {
+            output.init(blockSize * 2);
+            _a = a;
+            _b = b;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            running = true;
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _a->stopReader();
+            _b->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            running = false;
+            _a->clearReadStop();
+            _b->clearReadStop();
+            output.clearWriteStop();
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(Multiplier* _this) {
+            complex_t* aBuf = (complex_t*)volk_malloc(sizeof(complex_t) * _this->_blockSize, volk_get_alignment());
+            complex_t* bBuf = (complex_t*)volk_malloc(sizeof(complex_t) * _this->_blockSize, volk_get_alignment());
+            complex_t* outBuf = (complex_t*)volk_malloc(sizeof(complex_t) * _this->_blockSize, volk_get_alignment());
+            while (true) {
+                if (_this->_a->read(aBuf, _this->_blockSize) < 0) { break; };
+                if (_this->_b->read(bBuf, _this->_blockSize) < 0) { break; };
+                volk_32fc_x2_multiply_32fc((lv_32fc_t*)outBuf, (lv_32fc_t*)aBuf, (lv_32fc_t*)bBuf, _this->_blockSize);
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+            }
+            volk_free(aBuf);
+            volk_free(bBuf);
+            volk_free(outBuf);
+        }
+
+        stream<complex_t>* _a;
+        stream<complex_t>* _b;
+        int _blockSize;
+        bool running = false;
+        std::thread _workerThread;
+    };
+};

src/dsp/resampling.h

@@ -0,0 +1,425 @@
+#pragma once
+#include <thread>
+#include <dsp/filter.h>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <numeric>
+
+
+namespace dsp {
+    template <class T>
+    class Interpolator {
+    public:
+        Interpolator() {
+            
+        }
+
+        Interpolator(stream<T>* in, float interpolation, int blockSize) : output(blockSize * interpolation * 2) {
+            _input = in;
+            _interpolation = interpolation;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<T>* in, float interpolation, int blockSize) {
+            output.init(blockSize * 2);
+            _input = in;
+            _interpolation = interpolation;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _input->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setInterpolation(float interpolation) {
+            if (running) {
+                return;
+            }
+            _interpolation = interpolation;
+            output.setMaxLatency(_blockSize * _interpolation * 2);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(_blockSize * _interpolation * 2);
+        }
+
+        void setInput(stream<T>* input) {
+            if (running) {
+                return;
+            }
+            _input = input;
+        }
+
+        stream<T> output;
+
+    private:
+        static void _worker(Interpolator<T>* _this) {
+            T* inBuf = new T[_this->_blockSize];
+            T* outBuf = new T[_this->_blockSize * _this->_interpolation];
+            int outCount = _this->_blockSize * _this->_interpolation;
+            while (true) {
+                if (_this->_input->read(inBuf, _this->_blockSize) < 0) { break; };
+                for (int i = 0; i < outCount; i++) {
+                    outBuf[i] = inBuf[(int)((float)i / _this->_interpolation)];
+                }
+                if (_this->output.write(outBuf, outCount) < 0) { break; };
+            }
+            delete[] inBuf;
+            delete[] outBuf;
+        }
+
+        stream<T>* _input;
+        int _blockSize;
+        float _interpolation;
+        std::thread _workerThread;
+        bool running = false;
+    };
+
+    class BlockDecimator {
+    public:
+        BlockDecimator() {
+            
+        }
+
+        BlockDecimator(stream<complex_t>* in, int skip, int blockSize) : output(blockSize * 2) {
+            _input = in;
+            _skip = skip;
+            _blockSize = blockSize;
+        }
+
+        void init(stream<complex_t>* in, int skip, int blockSize) {
+            output.init(blockSize * 2);
+            _input = in;
+            _skip = skip;
+            _blockSize = blockSize;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            _input->stopReader();
+            output.stopWriter();
+            _workerThread.join();
+            _input->clearReadStop();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+            output.setMaxLatency(blockSize * 2);
+        }
+
+        void setSkip(int skip) {
+            if (running) {
+                return;
+            }
+            _skip = skip;
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(BlockDecimator* _this) {
+            complex_t* buf = new complex_t[_this->_blockSize];
+            while (true) {
+                _this->_input->readAndSkip(buf, _this->_blockSize, _this->_skip);
+                _this->output.write(buf, _this->_blockSize);
+            }
+        }
+
+        stream<complex_t>* _input;
+        int _blockSize;
+        int _skip;
+        std::thread _workerThread;
+        bool running = false;
+    };
+
+    class Resampler {
+    public:
+        Resampler() {
+
+        }
+
+        void init(stream<complex_t>* in, float inputSampleRate, float outputSampleRate, float bandWidth, int blockSize) {
+            _input = in;
+            _outputSampleRate = outputSampleRate;
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+            _blockSize = blockSize;
+            output = &decim.output;
+
+            dsp::BlackmanWindow(_taps, inputSampleRate * _interp, outputSampleRate / 2.0f, outputSampleRate / 2.0f);
+
+            interp.init(in, _interp, blockSize);
+            if (_interp == 1) {
+                decim.init(in, _taps, blockSize, _decim);
+            }
+            else {
+                decim.init(&interp.output, _taps, blockSize * _interp, _decim);
+            }
+        }
+
+        void start() {
+            if (_interp != 1) {
+                interp.start();
+            }
+            decim.start();
+            running = true;
+        }
+
+        void stop() {
+            interp.stop();
+            decim.stop();
+            running = false;
+        }
+
+        void setInputSampleRate(float inputSampleRate, int blockSize = -1) {
+            stop();
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)_outputSampleRate);
+            _interp = _outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+
+            dsp::BlackmanWindow(_taps, inputSampleRate * _interp, _outputSampleRate / 2.0f, _outputSampleRate / 2.0f);
+            decim.setTaps(_taps);
+
+            interp.setInterpolation(_interp);
+            decim.setDecimation(_decim);
+            if (blockSize > 0) {
+                _blockSize = blockSize;
+                interp.setBlockSize(_blockSize);
+            }
+            decim.setBlockSize(_blockSize * _interp);
+
+            if (_interp == 1) {
+                decim.setInput(_input);
+            }
+            else {
+                decim.setInput(&interp.output);
+                interp.start();
+            }
+            start();
+        }
+
+        void setOutputSampleRate(float outputSampleRate) {
+            stop();
+            _outputSampleRate = outputSampleRate;
+            int _gcd = std::gcd((int)_inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = _inputSampleRate / _gcd;
+
+            dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, outputSampleRate / 2.0f, outputSampleRate / 2.0f);
+            decim.setTaps(_taps);
+
+            interp.setInterpolation(_interp);
+            decim.setDecimation(_decim);
+            decim.setBlockSize(_blockSize * _interp);
+
+            if (_interp == 1) {
+                decim.setInput(_input);
+            }
+            else {
+                decim.setInput(&interp.output);
+            }
+            start();
+        }
+
+        void setBlockSize(int blockSize) {
+            stop();
+            _blockSize = blockSize;
+            interp.setBlockSize(_blockSize);
+            decim.setBlockSize(_blockSize * _interp);
+            start();
+        }
+
+        void setInput(stream<complex_t>* input) {
+            if (running) {
+                return;
+            }
+            _input = input;
+            interp.setInput(_input);
+            if (_interp == 1) {
+                decim.setInput(_input);
+            }
+        }
+
+        stream<complex_t>* output;
+
+    private:
+        Interpolator<complex_t> interp;
+        DecimatingFIRFilter decim;
+        stream<complex_t>* _input;
+
+        std::vector<float> _taps;
+        int _interp;
+        int _decim;
+        float _outputSampleRate;
+        float _inputSampleRate;
+        float _blockSize;
+        bool running = false;
+    };
+
+
+
+    class FloatResampler {
+    public:
+        FloatResampler() {
+
+        }
+
+        void init(stream<float>* in, float inputSampleRate, float outputSampleRate, float bandWidth, int blockSize) {
+            _input = in;
+            _outputSampleRate = outputSampleRate;
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+            _blockSize = blockSize;
+            output = &decim.output;
+
+            dsp::BlackmanWindow(_taps, inputSampleRate * _interp, outputSampleRate / 2.0f, outputSampleRate / 2.0f);
+
+            interp.init(in, _interp, blockSize);
+            if (_interp == 1) {
+                decim.init(in, _taps, blockSize, _decim);
+            }
+            else {
+                decim.init(&interp.output, _taps, blockSize * _interp, _decim);
+            }
+        }
+
+        void start() {
+            if (_interp != 1) {
+                interp.start();
+            }
+            decim.start();
+            running = true;
+        }
+
+        void stop() {
+            interp.stop();
+            decim.stop();
+            running = false;
+        }
+
+        void setInputSampleRate(float inputSampleRate, int blockSize = -1) {
+            stop();
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)_outputSampleRate);
+            _interp = _outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+
+            dsp::BlackmanWindow(_taps, inputSampleRate * _interp, _outputSampleRate / 2.0f, _outputSampleRate / 2.0f);
+            decim.setTaps(_taps);
+
+            interp.setInterpolation(_interp);
+            decim.setDecimation(_decim);
+            if (blockSize > 0) {
+                _blockSize = blockSize;
+                interp.setBlockSize(_blockSize);
+            }
+            decim.setBlockSize(_blockSize * _interp);
+
+            if (_interp == 1) {
+                decim.setInput(_input);
+            }
+            else {
+                decim.setInput(&interp.output);
+            }
+            start();
+        }
+
+        void setOutputSampleRate(float outputSampleRate) {
+            stop();
+            _outputSampleRate = outputSampleRate;
+            int _gcd = std::gcd((int)_inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = _inputSampleRate / _gcd;
+
+            dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, outputSampleRate / 2.0f, outputSampleRate / 2.0f);
+            decim.setTaps(_taps);
+
+            interp.setInterpolation(_interp);
+            decim.setDecimation(_decim);
+            decim.setBlockSize(_blockSize * _interp);
+
+            if (_interp == 1) {
+                decim.setInput(_input);
+            }
+            else {
+                decim.setInput(&interp.output);
+            }
+            start();
+        }
+
+        void setBlockSize(int blockSize) {
+            stop();
+            _blockSize = blockSize;
+            interp.setBlockSize(_blockSize);
+            decim.setBlockSize(_blockSize * _interp);
+            start();
+        }
+
+        void setInput(stream<float>* input) {
+            if (running) {
+                return;
+            }
+            _input = input;
+            interp.setInput(_input);
+            if (_interp == 1) {
+                decim.setInput(_input);
+            }
+        }
+
+        stream<float>* output;
+
+    private:
+        Interpolator<float> interp;
+        FloatDecimatingFIRFilter decim;
+        stream<float>* _input;
+
+        std::vector<float> _taps;
+        int _interp;
+        int _decim;
+        float _outputSampleRate;
+        float _inputSampleRate;
+        float _blockSize;
+        bool running = false;
+    };
+    
+    
+};

src/dsp/routing.h

@@ -0,0 +1,49 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+
+namespace dsp {
+    class Splitter {
+    public:
+        Splitter() {
+            
+        }
+
+        Splitter(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+            output_a.init(bufferSize);
+            output_b.init(bufferSize);
+        }
+
+        void init(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+            output_a.init(bufferSize);
+            output_b.init(bufferSize);
+        }
+
+        void start() {
+            _workerThread = std::thread(_worker, this);
+        }
+
+        stream<complex_t> output_a;
+        stream<complex_t> output_b;
+
+    private:
+        static void _worker(Splitter* _this) {
+            complex_t* buf = new complex_t[_this->_bufferSize];
+            while (true) {
+                _this->_in->read(buf, _this->_bufferSize);
+                _this->output_a.write(buf, _this->_bufferSize);
+                _this->output_b.write(buf, _this->_bufferSize);
+            }
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+    };
+};

src/dsp/sink.h

@@ -0,0 +1,118 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <vector>
+
+namespace dsp {
+    class HandlerSink {
+    public:
+        HandlerSink() {
+            
+        }
+
+        HandlerSink(stream<complex_t>* input, complex_t* buffer, int bufferSize, void handler(complex_t*)) {
+            _in = input;
+            _bufferSize = bufferSize;
+            _buffer = buffer;
+            _handler = handler;
+        }
+
+        void init(stream<complex_t>* input, complex_t* buffer, int bufferSize, void handler(complex_t*)) {
+            _in = input;
+            _bufferSize = bufferSize;
+            _buffer = buffer;
+            _handler = handler;
+        }
+
+        void start() {
+            _workerThread = std::thread(_worker, this);
+        }
+
+        bool bypass;
+
+    private:
+        static void _worker(HandlerSink* _this) {
+            while (true) {
+                _this->_in->read(_this->_buffer, _this->_bufferSize);
+                _this->_handler(_this->_buffer);
+            }
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        complex_t* _buffer;
+        std::thread _workerThread;
+        void (*_handler)(complex_t*);
+    };
+
+    class NullSink {
+    public:
+        NullSink() {
+            
+        }
+
+        NullSink(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void init(stream<complex_t>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void start() {
+            _workerThread = std::thread(_worker, this);
+        }
+
+        bool bypass;
+
+    private:
+        static void _worker(NullSink* _this) {
+            complex_t* buf = new complex_t[_this->_bufferSize];
+            while (true) {
+                _this->_in->read(buf, _this->_bufferSize);
+            }
+        }
+
+        stream<complex_t>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+    };
+
+    class FloatNullSink {
+    public:
+        FloatNullSink() {
+            
+        }
+
+        FloatNullSink(stream<float>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void init(stream<float>* input, int bufferSize) {
+            _in = input;
+            _bufferSize = bufferSize;
+        }
+
+        void start() {
+            _workerThread = std::thread(_worker, this);
+        }
+
+        bool bypass;
+
+    private:
+        static void _worker(FloatNullSink* _this) {
+            float* buf = new float[_this->_bufferSize];
+            while (true) {
+                _this->_in->read(buf, _this->_bufferSize);
+            }
+        }
+
+        stream<float>* _in;
+        int _bufferSize;
+        std::thread _workerThread;
+    };
+};

src/dsp/source.h

@@ -0,0 +1,82 @@
+#pragma once
+#include <thread>
+#include <dsp/stream.h>
+#include <dsp/types.h>
+#include <volk.h>
+
+namespace dsp {
+    class SineSource {
+    public:
+        SineSource() {
+            
+        }
+
+        SineSource(float frequency, long sampleRate, int blockSize) : output(blockSize * 2) {
+            _blockSize = blockSize;
+            _sampleRate = sampleRate;
+            _phasorSpeed = (2 * 3.1415926535) / (sampleRate / frequency);
+            _phase = 0;
+        }
+
+        void init(float frequency, long sampleRate, int blockSize) {
+            output.init(blockSize * 2);
+            _sampleRate = sampleRate;
+            _blockSize = blockSize;
+            _phasorSpeed = (2 * 3.1415926535) / (sampleRate / frequency);
+            _phase = 0;
+        }
+
+        void start() {
+            if (running) {
+                return;
+            }
+            _workerThread = std::thread(_worker, this);
+            running = true;
+        }
+
+        void stop() {
+            if (!running) {
+                return;
+            }
+            output.stopWriter();
+            _workerThread.join();
+            output.clearWriteStop();
+            running = false;
+        }
+
+        void setFrequency(float frequency) {
+            _phasorSpeed = (2 * 3.1415926535) / (_sampleRate / frequency);
+        }
+
+        void setBlockSize(int blockSize) {
+            if (running) {
+                return;
+            }
+            _blockSize = blockSize;
+        }
+
+        stream<complex_t> output;
+
+    private:
+        static void _worker(SineSource* _this) {
+            complex_t* outBuf = new complex_t[_this->_blockSize];
+            while (true) {
+                for (int i = 0; i < _this->_blockSize; i++) {
+                    _this->_phase += _this->_phasorSpeed;
+                    outBuf[i].i = sin(_this->_phase);
+                    outBuf[i].q = cos(_this->_phase);
+                }
+                _this->_phase = fmodf(_this->_phase, 2.0f * 3.1415926535);
+                if (_this->output.write(outBuf, _this->_blockSize) < 0) { break; };
+            }
+            delete[] outBuf;
+        }
+
+        int _blockSize;
+        float _phasorSpeed;
+        float _phase;
+        long _sampleRate;
+        std::thread _workerThread;
+        bool running = false;
+    };
+};

src/dsp/stream.h

@@ -0,0 +1,222 @@
+#pragma once
+#include <condition_variable>
+#include <algorithm>
+#include <math.h>
+
+#define STREAM_BUF_SZ   1000000
+
+namespace dsp {
+    template <class T>
+    class stream {
+    public:
+        stream() {
+
+        }
+
+        stream(int maxLatency) {
+            size = STREAM_BUF_SZ;
+            _buffer = new T[size];
+            _stopReader = false;
+            _stopWriter = false;
+            this->maxLatency = maxLatency;
+            writec = 0;
+            readc = size - 1;
+        }
+
+        void init(int maxLatency) {
+            size = STREAM_BUF_SZ;
+            _buffer = new T[size];
+            _stopReader = false;
+            _stopWriter = false;
+            this->maxLatency = maxLatency;
+            writec = 0;
+            readc = size - 1;
+        }
+
+        int read(T* data, int len) {
+            int dataRead = 0;
+            while (dataRead < len) {
+                int canRead = waitUntilReadable();
+                if (canRead < 0) {
+                    if (_stopReader) {
+                        printf("Stop reader set");
+                    }
+                    else {
+                        printf("Stop not set");
+                    }
+                    clearReadStop();
+                    return -1;
+                }
+                int toRead = std::min(canRead, len - dataRead);
+
+                int len1 = (toRead >= (size - readc) ? (size - readc) : (toRead));
+                memcpy(&data[dataRead], &_buffer[readc], len1 * sizeof(T));
+                if (len1 < toRead) {
+                    memcpy(&data[dataRead + len1], _buffer, (toRead - len1) * sizeof(T));
+                }
+
+                dataRead += toRead;
+                readc_mtx.lock();
+                readc = (readc + toRead) % size;
+                readc_mtx.unlock();
+                canWriteVar.notify_one();
+            }
+            return len;
+        }
+
+        int readAndSkip(T* data, int len, int skip) {
+            int dataRead = 0;
+            while (dataRead < len) {
+                int canRead = waitUntilReadable();
+                if (canRead < 0) {
+                    clearReadStop();
+                    return -1;
+                }
+                int toRead = std::min(canRead, len - dataRead);
+
+                int len1 = (toRead >= (size - readc) ? (size - readc) : (toRead));
+                memcpy(&data[dataRead], &_buffer[readc], len1 * sizeof(T));
+                if (len1 < toRead) {
+                    memcpy(&data[dataRead + len1], _buffer, (toRead - len1) * sizeof(T));
+                }
+
+                dataRead += toRead;
+                readc_mtx.lock();
+                readc = (readc + toRead) % size;
+                readc_mtx.unlock();
+                canWriteVar.notify_one();
+            }
+
+            // Skip
+
+            dataRead = 0;
+            while (dataRead < skip) {
+                int canRead = waitUntilReadable();
+                int toRead = std::min(canRead, skip - dataRead);
+
+                dataRead += toRead;
+                readc_mtx.lock();
+                readc = (readc + toRead) % size;
+                readc_mtx.unlock();
+                canWriteVar.notify_one();
+            }
+            return len;
+        }
+
+        int waitUntilReadable() {
+            int canRead = readable();
+            if (canRead > 0) {
+                return canRead;
+            }
+            std::unique_lock<std::mutex> lck(writec_mtx);
+            canReadVar.wait(lck, [=](){ return ((this->readable(false) > 0) || this->getReadStop()); });
+            if (this->getReadStop()) {
+                return -1;
+            }
+            return this->readable(false);
+        }
+
+        int readable(bool lock = true) {
+            if (lock) { writec_mtx.lock(); }
+            int _wc = writec;
+            if (lock) { writec_mtx.unlock(); }
+            int readable = (_wc - readc) % this->size;
+            if (_wc < readc) {
+                readable = (this->size + readable);
+            }
+            return readable - 1;
+        }
+
+        int write(T* data, int len) {
+            int dataWrite = 0;
+            while (dataWrite < len) {
+                int canWrite = waitUntilWriteable();
+                if (canWrite < 0) {
+                    clearWriteStop();
+                    return -1;
+                }
+                int toWrite = std::min(canWrite, len - dataWrite);
+
+                int len1 = (toWrite >= (size - writec) ? (size - writec) : (toWrite));
+                memcpy(&_buffer[writec], &data[dataWrite], len1 * sizeof(T));
+                if (len1 < toWrite) {
+                    memcpy(_buffer, &data[dataWrite + len1], (toWrite - len1) * sizeof(T));
+                }
+
+                dataWrite += toWrite;
+                writec_mtx.lock();
+                writec = (writec + toWrite) % size;
+                writec_mtx.unlock();
+                canReadVar.notify_one();
+            }
+            return len;
+        }
+
+        int waitUntilWriteable() {
+            int canWrite = writeable();
+            if (canWrite > 0) {
+                return canWrite;
+            }
+            std::unique_lock<std::mutex> lck(readc_mtx);
+            canWriteVar.wait(lck, [=](){ return ((this->writeable(false) > 0) || this->getWriteStop()); });
+            if (this->getWriteStop()) {
+                return -1;
+            }
+            return this->writeable(false);
+        }
+
+        int writeable(bool lock = true) {
+            if (lock) { readc_mtx.lock(); }
+            int _rc = readc;
+            if (lock) { readc_mtx.unlock(); }
+            int writeable = (_rc - writec) % this->size;
+            if (_rc < writec) {
+                writeable = (this->size + writeable);
+            }
+            return std::min<float>(writeable - 1, maxLatency - readable(false) - 1);
+        }
+
+        void stopReader() {
+            _stopReader = true;
+            canReadVar.notify_one();
+        }
+
+        void stopWriter() {
+            _stopWriter = true;
+            canWriteVar.notify_one();
+        }
+
+        bool getReadStop() {
+            return _stopReader;
+        }
+
+        bool getWriteStop() {
+            return _stopWriter;
+        }
+
+        void clearReadStop() {
+            _stopReader = false;
+        }
+
+        void clearWriteStop() {
+            _stopWriter = false;
+        }
+
+        void setMaxLatency(int maxLatency) {
+            this->maxLatency = maxLatency;
+        }
+
+    private:
+        T* _buffer;
+        int size;
+        int readc;
+        int writec;
+        int maxLatency;
+        bool _stopReader;
+        bool _stopWriter;
+        std::mutex readc_mtx;
+        std::mutex writec_mtx;
+        std::condition_variable canReadVar;
+        std::condition_variable canWriteVar;
+    };
+};

src/dsp/types.h

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace dsp {
+    struct complex_t {
+        float q;
+        float i;
+    };
+};

src/dsp/vfo.h

@@ -0,0 +1,158 @@
+#pragma once
+#include <dsp/source.h>
+#include <dsp/math.h>
+#include <dsp/resampling.h>
+#include <dsp/filter.h>
+
+namespace dsp {
+    class VFO {
+    public:
+        VFO() {
+
+        }
+
+        void init(stream<complex_t>* in, float inputSampleRate, float outputSampleRate, float bandWidth, float offset, int blockSize) {
+            _input = in;
+            _outputSampleRate = outputSampleRate;
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+            _bandWidth = bandWidth;
+            _blockSize = blockSize;
+            output = &decim.output;
+
+            dsp::BlackmanWindow(_taps, inputSampleRate * _interp, bandWidth / 2.0f, bandWidth / 2.0f);
+
+            lo.init(offset, inputSampleRate, blockSize);
+            mixer.init(in, &lo.output, blockSize);
+            interp.init(&mixer.output, _interp, blockSize);
+            if (_interp == 1) {
+                decim.init(&mixer.output, _taps, blockSize, _decim);
+            }
+            else {
+                decim.init(&interp.output, _taps, blockSize * _interp, _decim);
+            }
+        }
+
+        void start() {
+            lo.start();
+            mixer.start();
+            if (_interp != 1) {
+                printf("UH OH INTERPOLATOR STARTED :/\n");
+                interp.start();
+            }
+            decim.start();
+        }
+
+        void stop() {
+            lo.stop();
+            mixer.stop();
+            interp.stop();
+            decim.stop();
+        }
+
+        void setInputSampleRate(float inputSampleRate, int blockSize = -1) {
+            interp.stop();
+            decim.stop();
+
+            _inputSampleRate = inputSampleRate;
+            int _gcd = std::gcd((int)inputSampleRate, (int)_outputSampleRate);
+            _interp = _outputSampleRate / _gcd;
+            _decim = inputSampleRate / _gcd;
+
+            dsp::BlackmanWindow(_taps, inputSampleRate * _interp, _bandWidth / 2.0f, _bandWidth / 2.0f);
+
+            interp.setInterpolation(_interp);
+            decim.setDecimation(_decim);
+            if (blockSize > 0) {
+                lo.stop();
+                mixer.stop();
+                _blockSize = blockSize;
+                lo.setBlockSize(_blockSize);
+                mixer.setBlockSize(_blockSize);
+                interp.setBlockSize(_blockSize);
+                lo.start();
+                mixer.start();
+            }
+            decim.setBlockSize(_blockSize * _interp);
+
+            if (_interp == 1) {
+                decim.setInput(&mixer.output);
+            }
+            else {
+                decim.setInput(&interp.output);
+                interp.start();
+            }
+            decim.start();
+        }
+
+        void setOutputSampleRate(float outputSampleRate, float bandWidth = -1) {
+            interp.stop();
+            decim.stop();
+
+            if (bandWidth > 0) {
+                _bandWidth = bandWidth;
+            }
+            
+            _outputSampleRate = outputSampleRate;
+            int _gcd = std::gcd((int)_inputSampleRate, (int)outputSampleRate);
+            _interp = outputSampleRate / _gcd;
+            _decim = _inputSampleRate / _gcd;
+
+            dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, _bandWidth / 2.0f, _bandWidth / 2.0f);
+            decim.setTaps(_taps);
+
+            interp.setInterpolation(_interp);
+            decim.setDecimation(_decim);
+            decim.setBlockSize(_blockSize * _interp);
+
+            if (_interp == 1) {
+                decim.setInput(&mixer.output);
+            }
+            else {
+                decim.setInput(&interp.output);
+                interp.start();
+            }
+            decim.start();
+        }
+
+        void setBandwidth(float bandWidth) {
+            decim.stop();
+            dsp::BlackmanWindow(_taps, _inputSampleRate * _interp, _bandWidth / 2.0f, _bandWidth / 2.0f);
+            decim.setTaps(_taps);
+            decim.start();
+        }
+
+        void setOffset(float offset) {
+            lo.setFrequency(-offset);
+        }
+
+        void setBlockSize(int blockSize) {
+            stop();
+            _blockSize = blockSize;
+            lo.setBlockSize(_blockSize);
+            mixer.setBlockSize(_blockSize);
+            interp.setBlockSize(_blockSize);
+            decim.setBlockSize(_blockSize * _interp);
+            start();
+        }
+
+        stream<complex_t>* output;
+
+    private:
+        SineSource lo;
+        Multiplier mixer;
+        Interpolator<complex_t> interp;
+        DecimatingFIRFilter decim;
+        stream<complex_t>* _input;
+
+        std::vector<float> _taps;
+        int _interp;
+        int _decim;
+        float _outputSampleRate;
+        float _inputSampleRate;
+        float _bandWidth;
+        float _blockSize;
+    };
+};