dspx 1.2.4 → 1.3.1

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_;

package/src/native/adapters/RlsStage.h

@@ -199,6 +199,82 @@ 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("lambda");
+                s.writeFloat(m_lambda);
+
+                s.writeString("delta");
+                s.writeFloat(m_delta);
+
+                s.writeString("initialized");
+                s.writeBool(m_initialized);
+
+                if (m_initialized && m_filter)
+                {
+                    // Serialize weights
+                    s.writeString("weights");
+                    s.writeFloatArray(m_filter->getWeights());
+
+                    // Serialize inverse covariance matrix
+                    s.writeString("inverseCov");
+                    s.writeFloatArray(m_filter->getInverseCov());
+
+                    // Serialize buffer
+                    const auto &buffer = m_filter->getBuffer();
+                    std::vector<float> bufferData = buffer.toVector();
+                    s.writeString("buffer");
+                    s.writeFloatArray(bufferData);
+                }
+
+                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(); // "lambda"
+                m_lambda = d.readFloat();
+
+                key = d.readString(); // "delta"
+                m_delta = d.readFloat();
+
+                key = d.readString(); // "initialized"
+                m_initialized = d.readBool();
+
+                if (m_initialized)
+                {
+                    // Recreate filter
+                    m_filter = std::make_unique<dsp::core::RlsFilter>(m_numTaps, m_lambda, m_delta);
+
+                    // Restore weights
+                    key = d.readString(); // "weights"
+                    std::vector<float> weights = d.readFloatArray();
+                    m_filter->setWeights(weights);
+
+                    // Restore inverse covariance matrix
+                    key = d.readString(); // "inverseCov"
+                    std::vector<float> inverseCov = d.readFloatArray();
+                    m_filter->setInverseCov(inverseCov);
+
+                    // Restore buffer
+                    key = d.readString(); // "buffer"
+                    std::vector<float> bufferData = d.readFloatArray();
+                    m_filter->setBuffer(bufferData);
+                }
+
+                d.consumeToken(dsp::toon::T_OBJECT_END);
+            }
+
         private:
             void ensureScratchBuffers(size_t samplesPerChannel)
             {

package/src/native/adapters/RmsStage.h

@@ -3,6 +3,7 @@
 #include "../IDspStage.h"
 #include "../core/RmsFilter.h"
 #include "../utils/SimdOps.h"
+#include "../utils/Toon.h"
 #include <vector>
 #include <stdexcept>
 #include <cmath>
@@ -176,6 +177,77 @@ namespace dsp::adapters
             }
         }
 
+        void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            // Serialize mode
+            s.writeString(m_mode == RmsMode::Moving ? "moving" : "batch");
+
+            if (m_mode == RmsMode::Moving)
+            {
+                // Serialize window configuration
+                s.writeInt32(static_cast<int32_t>(m_window_size));
+                s.writeDouble(m_window_duration_ms);
+                s.writeBool(m_is_initialized);
+
+                // Serialize filter states
+                s.writeInt32(static_cast<int32_t>(m_filters.size()));
+                for (const auto &filter : m_filters)
+                {
+                    auto [bufferData, runningSumOfSquares] = filter.getState();
+                    s.writeFloatArray(bufferData); // CRITICAL: Direct binary copy
+                    s.writeFloat(runningSumOfSquares);
+                }
+            }
+        }
+
+        void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            // Deserialize and validate mode
+            std::string modeStr = d.readString();
+            RmsMode newMode = (modeStr == "moving") ? RmsMode::Moving : RmsMode::Batch;
+
+            if (newMode != m_mode)
+            {
+                throw std::runtime_error("RMS TOON load: mode mismatch");
+            }
+
+            if (m_mode == RmsMode::Moving)
+            {
+                // Deserialize window configuration
+                int32_t windowSize = d.readInt32();
+                if (windowSize != static_cast<int32_t>(m_window_size))
+                {
+                    throw std::runtime_error("RMS TOON load: window size mismatch");
+                }
+
+                m_window_duration_ms = d.readDouble(); // restore duration
+                m_is_initialized = d.readBool();       // restore init flag
+
+                // Deserialize filter states
+                int32_t numChannels = d.readInt32();
+                m_filters.clear();
+                for (int32_t i = 0; i < numChannels; ++i)
+                {
+                    // Create filter with correct window size (time-aware detection happens at runtime)
+                    // preserve time-aware vs size-based based on restored flags
+                    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);
+                    }
+
+                    // Restore state
+                    std::vector<float> bufferData = d.readFloatArray();
+                    float runningSumOfSquares = d.readFloat();
+
+                    m_filters[i].setState(bufferData, runningSumOfSquares);
+                }
+            }
+        }
+
     private:
         /**
          * @brief Statelessly calculates the RMS for each channel

package/src/native/adapters/SnrStage.h

@@ -185,6 +185,51 @@ namespace dsp::adapters
             m_initialized = true;
         }
 
+        inline void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            // Write window size
+            s.writeInt32(static_cast<int32_t>(m_window_size));
+
+            // Get and write signal RMS filter state
+            auto signal_state = m_signal_rms.getState();
+            const auto &signal_buffer = signal_state.first;
+            float signal_sum = signal_state.second;
+
+            s.writeFloatArray(signal_buffer);
+            s.writeFloat(signal_sum);
+
+            // Get and write noise RMS filter state
+            auto noise_state = m_noise_rms.getState();
+            const auto &noise_buffer = noise_state.first;
+            float noise_sum = noise_state.second;
+
+            s.writeFloatArray(noise_buffer);
+            s.writeFloat(noise_sum);
+        }
+
+        inline void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            // Read and validate window size
+            int32_t window_size = d.readInt32();
+            if (window_size <= 0)
+                throw std::runtime_error("Invalid window_size in SnrStage deserialization");
+            m_window_size = static_cast<size_t>(window_size);
+
+            // Read signal RMS filter state
+            std::vector<float> signal_buffer = d.readFloatArray();
+            float signal_sum = d.readFloat();
+
+            // Read noise RMS filter state
+            std::vector<float> noise_buffer = d.readFloatArray();
+            float noise_sum = d.readFloat();
+
+            // Restore state to RMS filters
+            m_signal_rms.setState(signal_buffer, signal_sum);
+            m_noise_rms.setState(noise_buffer, noise_sum);
+
+            m_initialized = true;
+        }
+
         void reset() override
         {
             m_signal_rms.clear();

package/src/native/adapters/SquareStage.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "../IDspStage.h"
+#include "../utils/Toon.h"
+#include "../utils/SimdOps.h"
+#include <stdexcept>
+#include <string>
+#include <cmath>
+
+namespace dsp::adapters
+{
+    /**
+     * @brief Square Stage - Computes element-wise squaring of a signal.
+     *
+     * Implements: y[n] = x[n]^2
+     *
+     * **Use Cases:**
+     * - Energy calculation (signal power)
+     * - Non-linear signal transformation
+     * - Envelope detection
+     * - Part of Pan-Tompkins QRS detection algorithm
+     *
+     * **Note:** Squaring amplifies large values and suppresses small ones.
+     * This stage is stateless - no mode selection needed.
+     */
+    class SquareStage : public IDspStage
+    {
+    public:
+        SquareStage()
+        {
+            // No parameters needed - stateless operation
+        }
+
+        const char *getType() const override
+        {
+            return "square";
+        }
+
+        void process(float *buffer, size_t numSamples, int numChannels, const float *timestamps = nullptr) override
+        {
+            // Stateless squaring operation
+            dsp::simd::square_inplace(buffer, numSamples);
+        }
+
+        Napi::Object serializeState(Napi::Env env) const override
+        {
+            Napi::Object state = Napi::Object::New(env);
+            // No state to serialize - squaring is stateless
+            return state;
+        }
+
+        void deserializeState(const Napi::Object &state) override
+        {
+            // No state to deserialize
+        }
+
+        void reset() override
+        {
+            // No state to reset
+        }
+
+        void serializeToon(dsp::toon::Serializer &s) const override
+        {
+            // No state to serialize
+        }
+
+        void deserializeToon(dsp::toon::Deserializer &d) override
+        {
+            // No state to deserialize
+        }
+
+        bool isResizing() const override { return false; }
+
+    private:
+        // No member variables - stateless operation
+    };
+
+} // namespace dsp::adapters