dspx 1.4.8 → 1.4.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dspx",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "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/core/FirFilter.cc

@@ -342,19 +342,19 @@ namespace dsp
                 throw std::runtime_error("setState() requires stateful mode");
             }
 
-            // Validate size - must match the power-of-2 buffer size, not coefficient count
-            if (state.size() != m_state.size())
-            {
-                throw std::invalid_argument("state size must match internal buffer size");
-            }
-            if (stateIndex >= state.size() && !state.empty())
-            {
-                throw std::invalid_argument("stateIndex out of range");
-            }
-
 #if defined(__ARM_NEON) || defined(__aarch64__)
             if (m_useNeon && m_neonFilter)
             {
+                // Validate against NEON buffer size on ARM
+                if (state.size() != m_neonFilter->getBufferSize())
+                {
+                    throw std::invalid_argument("state size must match internal buffer size");
+                }
+                if (stateIndex >= state.size() && !state.empty())
+                {
+                    throw std::invalid_argument("stateIndex out of range");
+                }
+
                 // Convert to float vector for NEON filter's linearization
                 std::vector<float> floatState(state.size());
                 for (size_t i = 0; i < state.size(); ++i)
@@ -365,6 +365,17 @@ namespace dsp
                 return;
             }
 #endif
+
+            // Validate size - must match the power-of-2 buffer size, not coefficient count
+            if (state.size() != m_state.size())
+            {
+                throw std::invalid_argument("state size must match internal buffer size");
+            }
+            if (stateIndex >= state.size() && !state.empty())
+            {
+                throw std::invalid_argument("stateIndex out of range");
+            }
+
             m_state = state;
             m_stateIndex = stateIndex;
         }

package/src/native/core/FirFilterNeon.h

@@ -233,58 +233,52 @@ namespace dsp::core
          */
         std::pair<std::vector<float>, size_t> exportLinearState() const
         {
-#if defined(__ARM_NEON) || defined(__aarch64__)
             const float *state = getState();
             std::vector<float> linearState(m_bufferSize, 0.0f);
 
-            // Calculate oldest sample position in circular buffer
-            size_t oldestPos = (m_head >= m_numTaps - 1)
-                                   ? m_head - (m_numTaps - 1)
-                                   : m_head + m_bufferSize - (m_numTaps - 1);
+            // Extract the circular buffer into linear format (oldest->newest)
+            // m_head points to the position of the most recent sample
+            // The convolution reads from (m_head - numTaps + 1), which is the oldest sample position
+
+            // Calculate the read start position (oldest valid sample)
+            size_t readStart = (m_head + m_bufferSize - m_numTaps + 1) & m_headMask;
 
-            // Un-rotate: copy from oldest->newest into linear array
+            // Copy samples in order: oldest->newest into linear positions [0..bufferSize-1]
             for (size_t i = 0; i < m_bufferSize; ++i)
             {
-                linearState[i] = state[(oldestPos + i) & m_headMask];
+                linearState[i] = state[(readStart + i) & m_headMask];
             }
 
-            return {linearState, m_numTaps - 1};
-#else
-            // Scalar path: state is already linear
-            const float *state = getState();
-            std::vector<float> linearState(state, state + m_bufferSize);
-            return {linearState, m_head};
-#endif
+            // Return 0 as stateIndex to indicate the next write should go to position 0
+            // (overwriting the oldest sample in the linear layout)
+            return {linearState, 0};
         }
 
         /**
          * @brief Import state from linear format (oldest->newest) after deserialization
          * @param linearState Linear state vector (oldest->newest)
-         * @param stateIndex State index (number of valid samples - 1)
+         * @param stateIndex State index (must be 0 for linear layout)
          */
         void importLinearState(const std::vector<float> &linearState, size_t stateIndex)
         {
-#if defined(__ARM_NEON) || defined(__aarch64__)
             float *state = getState();
 
-            // Copy linear state into circular buffer
+            // Copy the linear state directly into the circular buffer starting at position 0
+            // This creates a "linearized" layout where oldest is at 0, newest at numTaps-1
             for (size_t i = 0; i < m_bufferSize && i < linearState.size(); ++i)
             {
                 state[i] = linearState[i];
                 state[i + m_bufferSize] = linearState[i]; // Guard zone
             }
 
-            // Set head to point where newest sample will be written
-            m_head = stateIndex;
-#else
-            // Scalar path: direct copy
-            float *state = getState();
-            for (size_t i = 0; i < m_bufferSize && i < linearState.size(); ++i)
-            {
-                state[i] = linearState[i];
-            }
-            m_head = stateIndex;
-#endif
+            // Set m_head to point to the newest sample (last valid position)
+            // After import: oldest=0, newest=(numTaps-1)
+            // m_head should point to position (numTaps - 1)
+            // Next write will go to position numTaps, which is correct
+            m_head = (m_numTaps > 0) ? (m_numTaps - 1) : 0;
+
+            // Mark buffer as filled so we don't return zeros during transient phase
+            m_samplesProcessed = m_numTaps;
         }
 
         size_t getNumTaps() const { return m_numTaps; }