dspx 1.3.6 → 1.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dspx",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "description": "High-performance DSP library with native C++ acceleration and Redis state persistence",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/native/IDspStage.h

@@ -106,22 +106,14 @@ namespace dsp
          *
          * @param serializer The TOON serializer to write binary data to.
          */
-        virtual void serializeToon(toon::Serializer &serializer) const
-        {
-            // Fallback: throw if not implemented for a specific stage
-            throw std::runtime_error("TOON serialization not implemented for this stage type");
-        }
+        virtual void serializeToon(toon::Serializer &serializer) const = 0;
 
         /**
          * @brief Deserializes internal state from TOON binary format.
          *
          * @param deserializer The TOON deserializer to read binary data from.
          */
-        virtual void deserializeToon(toon::Deserializer &deserializer)
-        {
-            throw std::runtime_error("TOON deserialization not implemented for this stage type");
-        }
-
+        virtual void deserializeToon(toon::Deserializer &deserializer) = 0;
         /**
          * @brief Resets the stage's internal state to initial values.
          */

package/src/native/adapters/ChannelMergeStage.h

@@ -185,6 +185,37 @@ namespace dsp
                 // No state to reset
             }
 
+            void serializeToon(toon::Serializer &serializer) const override
+            {
+                serializer.writeInt32(m_numInputChannels);
+                serializer.writeInt32(static_cast<int>(m_mapping.size()));
+                for (int ch : m_mapping)
+                {
+                    serializer.writeInt32(ch);
+                }
+            }
+
+            void deserializeToon(toon::Deserializer &deserializer) override
+            {
+                int numInputChannels = deserializer.readInt32();
+                int mappingSize = deserializer.readInt32();
+
+                if (numInputChannels != m_numInputChannels || mappingSize != static_cast<int>(m_mapping.size()))
+                {
+                    throw std::runtime_error("ChannelMerge: Configuration mismatch during TOON deserialization");
+                }
+
+                // Verify mapping indices match
+                for (int i = 0; i < mappingSize; ++i)
+                {
+                    int ch = deserializer.readInt32();
+                    if (ch != m_mapping[i])
+                    {
+                        throw std::runtime_error("ChannelMerge: Mapping index mismatch during TOON deserialization");
+                    }
+                }
+            }
+
             int getNumInputChannels() const { return m_numInputChannels; }
             const std::vector<int> &getMapping() const { return m_mapping; }
 

package/src/native/adapters/ChannelSelectStage.h

@@ -177,6 +177,37 @@ namespace dsp
                 // No state to reset
             }
 
+            void serializeToon(toon::Serializer &serializer) const override
+            {
+                serializer.writeInt32(m_numInputChannels);
+                serializer.writeInt32(static_cast<int>(m_channels.size()));
+                for (int ch : m_channels)
+                {
+                    serializer.writeInt32(ch);
+                }
+            }
+
+            void deserializeToon(toon::Deserializer &deserializer) override
+            {
+                int numInputChannels = deserializer.readInt32();
+                int numChannels = deserializer.readInt32();
+
+                if (numInputChannels != m_numInputChannels || numChannels != static_cast<int>(m_channels.size()))
+                {
+                    throw std::runtime_error("ChannelSelect: Configuration mismatch during TOON deserialization");
+                }
+
+                // Verify channel indices match
+                for (int i = 0; i < numChannels; ++i)
+                {
+                    int ch = deserializer.readInt32();
+                    if (ch != m_channels[i])
+                    {
+                        throw std::runtime_error("ChannelSelect: Channel index mismatch during TOON deserialization");
+                    }
+                }
+            }
+
             int getNumInputChannels() const { return m_numInputChannels; }
             const std::vector<int> &getChannels() const { return m_channels; }
 

package/src/native/adapters/ChannelSelectorStage.h

@@ -147,6 +147,23 @@ namespace dsp
                 // No state to reset
             }
 
+            void serializeToon(toon::Serializer &serializer) const override
+            {
+                serializer.writeInt32(m_numInputChannels);
+                serializer.writeInt32(m_numOutputChannels);
+            }
+
+            void deserializeToon(toon::Deserializer &deserializer) override
+            {
+                int numInputChannels = deserializer.readInt32();
+                int numOutputChannels = deserializer.readInt32();
+
+                if (numInputChannels != m_numInputChannels || numOutputChannels != m_numOutputChannels)
+                {
+                    throw std::runtime_error("ChannelSelector: Channel count mismatch during TOON deserialization");
+                }
+            }
+
             int getNumInputChannels() const { return m_numInputChannels; }
             int getNumOutputChannels() const { return m_numOutputChannels; }
 

package/src/native/adapters/FftStage.cc

@@ -528,6 +528,26 @@ namespace dsp
             m_format = static_cast<OutputFormat>(state.Get("format").As<Napi::Number>().Int32Value());
         }
 
+        void FftStage::serializeToon(toon::Serializer &serializer) const
+        {
+            serializer.writeInt32(static_cast<int32_t>(m_fftSize));
+            serializer.writeInt32(static_cast<int>(m_type));
+            serializer.writeBool(m_forward);
+            serializer.writeInt32(static_cast<int>(m_format));
+        }
+
+        void FftStage::deserializeToon(toon::Deserializer &deserializer)
+        {
+            size_t fftSize = static_cast<size_t>(deserializer.readInt32());
+            {
+                throw std::runtime_error("FFT size mismatch during TOON deserialization");
+            }
+
+            m_type = static_cast<TransformType>(deserializer.readInt32());
+            m_forward = deserializer.readBool();
+            m_format = static_cast<OutputFormat>(deserializer.readInt32());
+        }
+
         FftStage::TransformType FftStage::parseTransformType(const std::string &typeStr)
         {
             if (typeStr == "fft")

package/src/native/adapters/FftStage.h

@@ -77,6 +77,8 @@ namespace dsp
             // State serialization
             Napi::Object serializeState(Napi::Env env) const override;
             void deserializeState(const Napi::Object &state) override;
+            void serializeToon(toon::Serializer &serializer) const override;
+            void deserializeToon(toon::Deserializer &deserializer) override;
 
             // Helper to parse transform type from string
             static TransformType parseTransformType(const std::string &typeStr);

package/src/native/adapters/GscPreprocessorStage.h

@@ -259,6 +259,50 @@ namespace dsp
                 // No internal state to clear (matrices are fixed)
             }
 
+            void serializeToon(toon::Serializer &serializer) const override
+            {
+                serializer.writeInt32(m_numChannels);
+
+                // Serialize steering weights
+                for (int i = 0; i < m_numChannels; ++i)
+                {
+                    serializer.writeFloat(m_steering_weights(i));
+                }
+
+                // Serialize blocking matrix (column-major)
+                const float *matrixData = m_blocking_matrix.data();
+                size_t totalElements = m_numChannels * (m_numChannels - 1);
+                for (size_t i = 0; i < totalElements; ++i)
+                {
+                    serializer.writeFloat(matrixData[i]);
+                }
+            }
+
+            void deserializeToon(toon::Deserializer &deserializer) override
+            {
+                int numChannels = deserializer.readInt32();
+
+                if (numChannels != m_numChannels)
+                {
+                    throw std::runtime_error("GscPreprocessor: Channel count mismatch during TOON deserialization");
+                }
+
+                // Restore steering weights
+                for (int i = 0; i < m_numChannels; ++i)
+                {
+                    m_steering_weights(i) = deserializer.readFloat();
+                }
+
+                // Restore blocking matrix
+                std::vector<float> matrixData(m_numChannels * (m_numChannels - 1));
+                for (size_t i = 0; i < matrixData.size(); ++i)
+                {
+                    matrixData[i] = deserializer.readFloat();
+                }
+                m_blocking_matrix = Eigen::Map<const Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>>(
+                    matrixData.data(), m_numChannels, m_numChannels - 1);
+            }
+
             /**
              * @brief Get number of input channels.
              */

package/src/native/adapters/MatrixTransformStage.h

@@ -238,6 +238,54 @@ namespace dsp
                 // No internal state to clear (matrix and mean are fixed)
             }
 
+            void serializeToon(toon::Serializer &serializer) const override
+            {
+                serializer.writeString(m_transformType);
+                serializer.writeInt32(m_numChannels);
+                serializer.writeInt32(m_numComponents);
+
+                // Serialize mean vector
+                for (int i = 0; i < m_numChannels; ++i)
+                {
+                    serializer.writeFloat(m_mean(i));
+                }
+
+                // Serialize transformation matrix (column-major)
+                const float *matrixData = m_matrix.data();
+                size_t totalElements = m_numChannels * m_numComponents;
+                for (size_t i = 0; i < totalElements; ++i)
+                {
+                    serializer.writeFloat(matrixData[i]);
+                }
+            }
+
+            void deserializeToon(toon::Deserializer &deserializer) override
+            {
+                std::string transformType = deserializer.readString();
+                int numChannels = deserializer.readInt32();
+                int numComponents = deserializer.readInt32();
+
+                if (numChannels != m_numChannels || numComponents != m_numComponents)
+                {
+                    throw std::runtime_error("MatrixTransform: Dimension mismatch during TOON deserialization");
+                }
+
+                // Restore mean vector
+                for (int i = 0; i < m_numChannels; ++i)
+                {
+                    m_mean(i) = deserializer.readFloat();
+                }
+
+                // Restore transformation matrix
+                std::vector<float> matrixData(m_numChannels * m_numComponents);
+                for (size_t i = 0; i < matrixData.size(); ++i)
+                {
+                    matrixData[i] = deserializer.readFloat();
+                }
+                m_matrix = Eigen::Map<const Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>>(
+                    matrixData.data(), m_numChannels, m_numComponents);
+            }
+
             /**
              * @brief Get number of input channels.
              */

package/src/native/adapters/MelSpectrogramStage.h

@@ -202,6 +202,39 @@ namespace dsp::adapters
             // Stateless - no reset needed
         }
 
+        void serializeToon(toon::Serializer &serializer) const override
+        {
+            serializer.writeInt32(static_cast<int32_t>(m_numBins));
+            serializer.writeInt32(static_cast<int32_t>(m_numMelBands));
+
+            // Serialize filterbank matrix (row-major)
+            for (size_t i = 0; i < m_numMelBands; ++i)
+            {
+                for (size_t j = 0; j < m_numBins; ++j)
+                {
+                    serializer.writeFloat(m_filterbank(i, j));
+                }
+            }
+        }
+
+        void deserializeToon(toon::Deserializer &deserializer) override
+        {
+            size_t numBins = static_cast<size_t>(deserializer.readInt32());
+            size_t numMelBands = static_cast<size_t>(deserializer.readInt32());
+            {
+                throw std::runtime_error("MelSpectrogram: Dimension mismatch during TOON deserialization");
+            }
+
+            // Restore filterbank matrix
+            for (size_t i = 0; i < m_numMelBands; ++i)
+            {
+                for (size_t j = 0; j < m_numBins; ++j)
+                {
+                    m_filterbank(i, j) = deserializer.readFloat();
+                }
+            }
+        }
+
     private:
         size_t m_numBins;             // Number of input frequency bins
         size_t m_numMelBands;         // Number of output Mel bands

package/src/native/adapters/MfccStage.h

@@ -202,6 +202,28 @@ namespace dsp::adapters
             // Stateless - no reset needed
         }
 
+        void serializeToon(toon::Serializer &serializer) const override
+        {
+            serializer.writeInt32(static_cast<int32_t>(m_numMelBands));
+            serializer.writeInt32(static_cast<int32_t>(m_numCoefficients));
+            serializer.writeBool(m_useLogEnergy);
+            serializer.writeFloat(m_lifterCoefficient);
+        }
+
+        void deserializeToon(toon::Deserializer &deserializer) override
+        {
+            size_t numMelBands = static_cast<size_t>(deserializer.readInt32());
+            size_t numCoefficients = static_cast<size_t>(deserializer.readInt32());
+
+            if (numMelBands != m_numMelBands || numCoefficients != m_numCoefficients)
+            {
+                throw std::runtime_error("MFCC: Dimension mismatch during TOON deserialization");
+            }
+
+            deserializer.readBool();  // useLogEnergy
+            deserializer.readFloat(); // lifterCoefficient
+        }
+
     private:
         size_t m_numMelBands;      // Number of input Mel bands
         size_t m_numCoefficients;  // Number of MFCC coefficients to output

package/src/native/adapters/WaveletTransformStage.h

@@ -94,6 +94,22 @@ namespace dsp::adapters
             // Stateless - nothing to reset
         }
 
+        void serializeToon(toon::Serializer &serializer) const override
+        {
+            serializer.writeString(m_wavelet_name);
+            serializer.writeInt32(static_cast<int32_t>(m_filter_length));
+        }
+
+        void deserializeToon(toon::Deserializer &deserializer) override
+        {
+            std::string loaded_name = deserializer.readString();
+            if (loaded_name != m_wavelet_name)
+            {
+                throw std::runtime_error("Wavelet name mismatch during TOON deserialization");
+            }
+            deserializer.readInt32(); // filter_length (just validate it matches)
+        }
+
     private:
         /**
          * Apply symmetric padding (reflect about edge)