Added basic RDS support, no error correction yet

core/src/dsp/digital/binary_slicer.h

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

core/src/dsp/digital/differentia_decoder.h

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

core/src/dsp/digital/differential_decoder.h

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

core/src/dsp/digital/manchester_decoder.h

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