dspx 1.2.4 → 1.3.0

package/src/native/adapters/HilbertEnvelopeStage.h

@@ -31,6 +31,7 @@
 #include "../core/FftEngine.h"
 #include "../utils/CircularBufferArray.h"
 #include "../utils/SimdOps.h"
+#include "../utils/Toon.h"
 #include <vector>
 #include <complex>
 #include <memory>
@@ -199,6 +200,60 @@ namespace dsp::adapters
             }
         }
 
+        inline void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            // Write configuration
+            s.writeInt32(static_cast<int32_t>(m_window_size));
+            s.writeInt32(static_cast<int32_t>(m_hop_size));
+            s.writeInt32(static_cast<int32_t>(m_channel_buffers.size()));
+
+            // Write per-channel state
+            for (size_t i = 0; i < m_channel_buffers.size(); ++i)
+            {
+                std::vector<float> buffer_data = m_channel_buffers[i].toVector();
+                s.writeFloatArray(buffer_data);
+                s.writeInt32(static_cast<int32_t>(m_samples_since_output[i]));
+            }
+        }
+
+        inline void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            // Read configuration
+            int32_t window_size = d.readInt32();
+            int32_t hop_size = d.readInt32();
+
+            if (window_size <= 0 || hop_size <= 0)
+                throw std::runtime_error("Invalid window/hop size in HilbertEnvelopeStage deserialization");
+
+            if (static_cast<size_t>(window_size) != m_window_size || static_cast<size_t>(hop_size) != m_hop_size)
+                throw std::runtime_error("Window/hop size mismatch in HilbertEnvelopeStage deserialization");
+
+            int32_t num_channels = d.readInt32();
+            if (num_channels < 0)
+                throw std::runtime_error("Invalid num_channels in HilbertEnvelopeStage deserialization");
+
+            // Recreate channel buffers
+            m_channel_buffers.clear();
+            m_samples_since_output.clear();
+
+            for (int32_t i = 0; i < num_channels; ++i)
+            {
+                m_channel_buffers.emplace_back(m_window_size);
+                m_samples_since_output.push_back(0);
+            }
+
+            // Restore per-channel state
+            for (int32_t i = 0; i < num_channels; ++i)
+            {
+                std::vector<float> buffer_data = d.readFloatArray();
+                for (float value : buffer_data)
+                {
+                    m_channel_buffers[i].push(value);
+                }
+                m_samples_since_output[i] = static_cast<size_t>(d.readInt32());
+            }
+        }
+
         void reset() override
         {
             for (auto &buffer : m_channel_buffers)

package/src/native/adapters/IntegratorStage.h

@@ -2,6 +2,7 @@
 #define INTEGRATOR_STAGE_H
 
 #include "../IDspStage.h"
+#include "../utils/Toon.h"
 #include <vector>
 #include <cmath>
 #include <stdexcept>
@@ -129,6 +130,20 @@ namespace dsp::adapters
             std::fill(m_prev_output.begin(), m_prev_output.end(), 0.0f);
         }
 
+        void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            s.writeFloat(m_alpha);
+            s.writeInt32(m_num_channels);
+            s.writeFloatArray(m_prev_output);
+        }
+
+        void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            m_alpha = d.readFloat();
+            m_num_channels = d.readInt32();
+            m_prev_output = d.readFloatArray();
+        }
+
         bool isResizing() const override
         {
             return false;

package/src/native/adapters/InterpolatorStage.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "../IDspStage.h"
+#include "../utils/Toon.h"
 #include <vector>
 #include <cmath>
 #include <stdexcept>
@@ -154,6 +155,56 @@ namespace dsp
             }
         }
 
+        void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            s.writeInt32(interpolationFactor_);
+            s.writeInt32(filterOrder_);
+            s.writeDouble(sampleRate_);
+            s.writeInt32(numChannels_);
+
+            // Serialize state buffers for each channel
+            for (const auto &buf : stateBuffers_)
+            {
+                s.writeFloatArray(buf);
+            }
+
+            // Serialize state indices
+            for (size_t idx : stateIndices_)
+            {
+                s.writeInt32(static_cast<int32_t>(idx));
+            }
+        }
+
+        void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            int32_t factor = d.readInt32();
+            int32_t order = d.readInt32();
+            double sr = d.readDouble();
+            int32_t nCh = d.readInt32();
+
+            if (factor != interpolationFactor_ || order != filterOrder_)
+            {
+                throw std::runtime_error("Interpolator TOON: parameter mismatch");
+            }
+
+            if (nCh != numChannels_)
+            {
+                initializeStateBuffers(nCh);
+            }
+
+            // Deserialize state buffers
+            for (auto &buf : stateBuffers_)
+            {
+                buf = d.readFloatArray();
+            }
+
+            // Deserialize state indices
+            for (size_t &idx : stateIndices_)
+            {
+                idx = static_cast<size_t>(d.readInt32());
+            }
+        }
+
     private:
         int interpolationFactor_;
         int filterOrder_;

package/src/native/adapters/LinearRegressionStage.h

@@ -3,6 +3,7 @@
 
 #include "../IDspStage.h"
 #include "../utils/SimdOps.h"
+#include "../utils/Toon.h"
 #include <vector>
 #include <cmath>
 #include <stdexcept>
@@ -321,6 +322,45 @@ namespace dsp
                 }
             }
 
+            inline void serializeToon(dsp::toon::Serializer &s) const override
+            {
+                // Write configuration
+                s.writeInt32(static_cast<int32_t>(m_windowSize));
+                s.writeInt32(static_cast<int32_t>(m_numChannels));
+
+                // Write per-channel state
+                for (size_t ch = 0; ch < m_numChannels; ++ch)
+                {
+                    s.writeFloatArray(m_buffers[ch]);
+                    s.writeInt32(static_cast<int32_t>(m_writeIndices[ch]));
+                    s.writeInt32(static_cast<int32_t>(m_sampleCounts[ch]));
+                }
+            }
+
+            inline void deserializeToon(dsp::toon::Deserializer &d) override
+            {
+                // Read configuration
+                int32_t windowSize = d.readInt32();
+                if (windowSize < 2)
+                    throw std::runtime_error("Invalid windowSize in LinearRegressionStage deserialization");
+                if (static_cast<size_t>(windowSize) != m_windowSize)
+                    throw std::runtime_error("Window size mismatch in LinearRegressionStage deserialization");
+
+                int32_t numChannels = d.readInt32();
+                if (numChannels < 0)
+                    throw std::runtime_error("Invalid numChannels in LinearRegressionStage deserialization");
+
+                init(static_cast<size_t>(numChannels));
+
+                // Read per-channel state
+                for (size_t ch = 0; ch < m_numChannels; ++ch)
+                {
+                    m_buffers[ch] = d.readFloatArray();
+                    m_writeIndices[ch] = static_cast<size_t>(d.readInt32());
+                    m_sampleCounts[ch] = static_cast<size_t>(d.readInt32());
+                }
+            }
+
             void reset() override
             {
                 for (size_t ch = 0; ch < m_numChannels; ++ch)

package/src/native/adapters/LmsStage.h

@@ -176,6 +176,69 @@ namespace dsp
             }
         }
 
+        void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            s.startObject();
+
+            s.writeString("numTaps");
+            s.writeInt32(static_cast<int32_t>(m_numTaps));
+
+            s.writeString("learningRate");
+            s.writeFloat(m_learningRate);
+
+            s.writeString("normalized");
+            s.writeBool(m_normalized);
+
+            s.writeString("lambda");
+            s.writeFloat(m_lambda);
+
+            s.writeString("initialized");
+            s.writeBool(m_initialized);
+
+            if (m_initialized)
+            {
+                auto weights = m_filter->getWeights(0);
+                s.writeString("weights");
+                s.writeFloatArray(weights);
+            }
+
+            s.endObject();
+        }
+
+        void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            d.consumeToken(dsp::toon::T_OBJECT_START);
+
+            std::string key = d.readString(); // "numTaps"
+            m_numTaps = d.readInt32();
+
+            key = d.readString(); // "learningRate"
+            m_learningRate = d.readFloat();
+
+            key = d.readString(); // "normalized"
+            m_normalized = d.readBool();
+
+            key = d.readString(); // "lambda"
+            m_lambda = d.readFloat();
+
+            key = d.readString(); // "initialized"
+            m_initialized = d.readBool();
+
+            // Recreate filter with restored parameters
+            m_filter = std::make_unique<dsp::core::DifferentiableFilter<float>>(m_numTaps, m_learningRate, m_lambda, m_normalized);
+
+            if (m_initialized)
+            {
+                m_filter->init(1); // Reinitialize filter
+
+                key = d.readString(); // "weights"
+                std::vector<float> weights = d.readFloatArray();
+                m_filter->setWeights(0, weights);
+            }
+
+            d.consumeToken(dsp::toon::T_OBJECT_END);
+        }
+
     private:
         void ensureScratchBuffers(size_t samplesPerChannel)
         {

package/src/native/adapters/MeanAbsoluteValueStage.h

@@ -2,6 +2,7 @@
 
 #include "../IDspStage.h"
 #include "../core/MovingAbsoluteValueFilter.h" // Include the new core filter
+#include "../utils/Toon.h"
 #include <vector>
 #include <stdexcept>
 #include <cmath>
@@ -168,10 +169,85 @@ namespace dsp::adapters
             }
         }
 
+        inline void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            // Write mode
+            s.writeInt32(static_cast<int32_t>(m_mode));
+
+            // Write configuration parameters
+            s.writeInt32(static_cast<int32_t>(m_window_size));
+            s.writeFloat(static_cast<float>(m_window_duration_ms));
+            s.writeBool(m_is_initialized);
+
+            // Write number of channels and filter states
+            s.writeInt32(static_cast<int32_t>(m_filters.size()));
+
+            // For Moving mode, serialize each filter's state
+            if (m_mode == MavMode::Moving)
+            {
+                for (const auto &filter : m_filters)
+                {
+                    auto [bufferData, runningSum] = filter.getState();
+                    s.writeFloatArray(bufferData);
+                    s.writeFloat(runningSum);
+                }
+            }
+        }
+
+        inline void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            // Read mode
+            int32_t mode_int = d.readInt32();
+            if (mode_int < 0 || mode_int > 1)
+                throw std::runtime_error("Invalid mode in MeanAbsoluteValueStage deserialization");
+            m_mode = static_cast<MavMode>(mode_int);
+
+            // Read configuration parameters
+            int32_t window_size = d.readInt32();
+            if (window_size < 0)
+                throw std::runtime_error("Invalid window_size in MeanAbsoluteValueStage deserialization");
+            m_window_size = static_cast<size_t>(window_size);
+
+            m_window_duration_ms = static_cast<double>(d.readFloat());
+            m_is_initialized = d.readBool();
+
+            // Read number of channels
+            int32_t num_channels = d.readInt32();
+            if (num_channels < 0)
+                throw std::runtime_error("Invalid num_channels in MeanAbsoluteValueStage deserialization");
+
+            // Reconstruct filters
+            m_filters.clear();
+
+            if (m_mode == MavMode::Moving)
+            {
+                for (int32_t i = 0; i < num_channels; ++i)
+                {
+                    // Read buffer data
+                    std::vector<float> bufferData = d.readFloatArray();
+
+                    // Read running sum
+                    float runningSum = d.readFloat();
+
+                    // Create filter and restore state
+                    if (m_window_duration_ms > 0.0)
+                    {
+                        m_filters.emplace_back(m_window_size, m_window_duration_ms);
+                    }
+                    else
+                    {
+                        m_filters.emplace_back(m_window_size);
+                    }
+                    m_filters.back().setState(bufferData, runningSum);
+                }
+            }
+        }
+
         // Reset all filters to initial state
         void reset() override
         {
             for (auto &filter : m_filters)
+
             {
                 filter.clear();
             }

package/src/native/adapters/MovingAverageStage.h

@@ -177,6 +177,125 @@ namespace dsp::adapters
             }
         }
 
+        // TOON Binary Serialization - CRITICAL OPTIMIZATION for large buffers
+        void serializeToon(dsp::toon::Serializer &serializer) const override
+        {
+            serializer.startObject();
+
+            // 1. Mode
+            serializer.writeString("mode");
+            serializer.writeString((m_mode == AverageMode::Moving) ? "moving" : "batch");
+
+            if (m_mode == AverageMode::Moving)
+            {
+                // 2. Config
+                serializer.writeString("windowSize");
+                serializer.writeInt32(static_cast<int32_t>(m_window_size));
+
+                serializer.writeString("windowDuration");
+                serializer.writeDouble(m_window_duration_ms);
+
+                serializer.writeString("initialized");
+                serializer.writeBool(m_is_initialized);
+
+                // 3. Channels - Zero-copy-like binary arrays
+                serializer.writeString("channels");
+                serializer.startArray();
+
+                for (const auto &filter : m_filters)
+                {
+                    auto [bufferData, runningSum] = filter.getState();
+
+                    serializer.startObject();
+
+                    // CRITICAL: Direct binary copy of float buffer (not text!)
+                    serializer.writeString("buffer");
+                    serializer.writeFloatArray(bufferData);
+
+                    serializer.writeString("sum");
+                    serializer.writeFloat(runningSum);
+
+                    serializer.endObject();
+                }
+                serializer.endArray();
+            }
+
+            serializer.endObject();
+        }
+
+        // TOON Binary Deserialization - CRITICAL OPTIMIZATION for large buffers
+        void deserializeToon(dsp::toon::Deserializer &deserializer) override
+        {
+            deserializer.consumeToken(dsp::toon::T_OBJECT_START);
+
+            // 1. Mode
+            std::string key = deserializer.readString(); // "mode"
+            std::string modeStr = deserializer.readString();
+
+            AverageMode newMode = (modeStr == "moving") ? AverageMode::Moving : AverageMode::Batch;
+            if (newMode != m_mode)
+            {
+                throw std::runtime_error("MovingAverage mode mismatch during TOON deserialization");
+            }
+
+            if (modeStr == "moving")
+            {
+                // 2. Config
+                key = deserializer.readString(); // "windowSize"
+                int32_t windowSize = deserializer.readInt32();
+
+                key = deserializer.readString(); // "windowDuration"
+                double windowDuration = deserializer.readDouble();
+
+                key = deserializer.readString(); // "initialized"
+                bool initialized = deserializer.readBool();
+
+                // Validate window size
+                if (windowSize != static_cast<int32_t>(m_window_size))
+                {
+                    throw std::runtime_error("MovingAverage window size mismatch during TOON deserialization");
+                }
+
+                m_window_duration_ms = windowDuration;
+                m_is_initialized = initialized;
+
+                // 3. Channels
+                key = deserializer.readString(); // "channels"
+                deserializer.consumeToken(dsp::toon::T_ARRAY_START);
+
+                m_filters.clear();
+
+                while (deserializer.peekToken() != dsp::toon::T_ARRAY_END)
+                {
+                    deserializer.consumeToken(dsp::toon::T_OBJECT_START);
+
+                    // Buffer - CRITICAL: Direct binary memcpy (not parsing text!)
+                    deserializer.readString(); // "buffer"
+                    std::vector<float> bufferData = deserializer.readFloatArray();
+
+                    // Sum
+                    deserializer.readString(); // "sum"
+                    float runningSum = deserializer.readFloat();
+
+                    // Reconstruct filter with time-aware support
+                    if (m_window_duration_ms > 0.0)
+                    {
+                        m_filters.emplace_back(m_window_size, m_window_duration_ms);
+                    }
+                    else
+                    {
+                        m_filters.emplace_back(m_window_size);
+                    }
+                    m_filters.back().setState(bufferData, runningSum);
+
+                    deserializer.consumeToken(dsp::toon::T_OBJECT_END);
+                }
+                deserializer.consumeToken(dsp::toon::T_ARRAY_END);
+            }
+
+            deserializer.consumeToken(dsp::toon::T_OBJECT_END);
+        }
+
     private:
         /**
          * @brief Statelessly calculates the average for each channel

package/src/native/adapters/PeakDetectionStage.h

@@ -2,6 +2,7 @@
 
 #include "../IDspStage.h"
 #include "../core/PeakDetection.h"
+#include "../utils/Toon.h"
 #include <cmath>
 #include <stdexcept>
 #include <string>
@@ -143,6 +144,58 @@ namespace dsp::adapters
             }
         }
 
+        inline void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            // Write configuration
+            s.writeFloat(m_threshold);
+            s.writeInt32(m_num_channels);
+            s.writeString(m_mode);
+            s.writeString(m_domain);
+            s.writeInt32(m_windowSize);
+            s.writeInt32(m_minPeakDistance);
+
+            // Write state (only for moving mode)
+            if (m_mode == "moving" && !m_prev_sample.empty())
+            {
+                s.writeFloatArray(m_prev_sample);
+                s.writeFloatArray(m_prev_prev_sample);
+
+                // Write peakCooldown as int array (convert to float array)
+                std::vector<float> cooldown_float(m_peakCooldown.begin(), m_peakCooldown.end());
+                s.writeFloatArray(cooldown_float);
+            }
+            else
+            {
+                // Write empty arrays
+                s.writeFloatArray(std::vector<float>());
+                s.writeFloatArray(std::vector<float>());
+                s.writeFloatArray(std::vector<float>());
+            }
+        }
+
+        inline void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            // Read configuration
+            m_threshold = d.readFloat();
+            m_num_channels = d.readInt32();
+            m_mode = d.readString();
+            m_domain = d.readString();
+            m_windowSize = d.readInt32();
+            m_minPeakDistance = d.readInt32();
+
+            // Read state arrays
+            m_prev_sample = d.readFloatArray();
+            m_prev_prev_sample = d.readFloatArray();
+
+            // Read peakCooldown (convert from float array to int)
+            std::vector<float> cooldown_float = d.readFloatArray();
+            m_peakCooldown.clear();
+            for (float val : cooldown_float)
+            {
+                m_peakCooldown.push_back(static_cast<int>(val));
+            }
+        }
+
         void reset() override
         {
             std::fill(m_prev_sample.begin(), m_prev_sample.end(), 0.0f);

package/src/native/adapters/RectifyStage.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "../IDspStage.h"
 #include "../utils/SimdOps.h"
+#include "../utils/Toon.h"
 #include <cmath>
 #include <stdexcept>
 
@@ -80,6 +81,19 @@ namespace dsp::adapters
                 throw std::runtime_error("Invalid rectify mode");
         }
 
+        inline void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            s.writeInt32(static_cast<int32_t>(m_mode));
+        }
+
+        inline void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            int32_t mode_int = d.readInt32();
+            if (mode_int < 0 || mode_int > 1)
+                throw std::runtime_error("Invalid mode in RectifyStage deserialization");
+            m_mode = static_cast<RectifyMode>(mode_int);
+        }
+
         void reset() override {} // No internal buffers
 
     private:

package/src/native/adapters/ResamplerStage.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "../IDspStage.h"
+#include "../utils/Toon.h"
 #include <vector>
 #include <cmath>
 #include <stdexcept>
@@ -187,6 +188,72 @@ namespace dsp
             }
         }
 
+        void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            s.writeInt32(upFactor_);
+            s.writeInt32(downFactor_);
+            s.writeInt32(filterOrder_);
+            s.writeDouble(sampleRate_);
+            s.writeInt32(numChannels_);
+            s.writeInt32(static_cast<int32_t>(phaseAccumulator_));
+
+            // Serialize state buffers for each channel
+            for (const auto &buf : stateBuffers_)
+            {
+                s.writeFloatArray(buf);
+            }
+
+            // Serialize state indices
+            for (size_t idx : stateIndices_)
+            {
+                s.writeInt32(static_cast<int32_t>(idx));
+            }
+
+            // Serialize phase accumulators
+            for (size_t pa : phaseAccumulators_)
+            {
+                s.writeInt32(static_cast<int32_t>(pa));
+            }
+        }
+
+        void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            int32_t upF = d.readInt32();
+            int32_t downF = d.readInt32();
+            int32_t order = d.readInt32();
+            double sr = d.readDouble();
+            int32_t nCh = d.readInt32();
+            phaseAccumulator_ = static_cast<size_t>(d.readInt32());
+
+            if (upF != upFactor_ || downF != downFactor_ || order != filterOrder_)
+            {
+                throw std::runtime_error("Resampler TOON: parameter mismatch");
+            }
+
+            if (nCh != numChannels_)
+            {
+                initializeStateBuffers(nCh);
+            }
+
+            // Deserialize state buffers
+            for (auto &buf : stateBuffers_)
+            {
+                buf = d.readFloatArray();
+            }
+
+            // Deserialize state indices
+            for (size_t &idx : stateIndices_)
+            {
+                idx = static_cast<size_t>(d.readInt32());
+            }
+
+            // Deserialize phase accumulators
+            for (size_t &pa : phaseAccumulators_)
+            {
+                pa = static_cast<size_t>(d.readInt32());
+            }
+        }
+
     private:
         int upFactor_;
         int downFactor_;