dspx 1.3.0 → 1.3.2

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

package/src/native/core/IirFilter.cc

@@ -71,8 +71,9 @@ namespace dsp
             for (size_t i = 1; i < m_b_coeffs.size(); ++i)
             {
                 // x_state stores x[n-1], x[n-2], ..., x[n-M]
-                // Read backwards: x[n-i] is at position (m_x_index - (i-1)) & m_x_mask
-                size_t idx = (m_x_index - (i - 1)) & m_x_mask;
+                // Read backwards: x[n-i] is at position (m_x_index + m_x_mask + 1 - (i-1)) & m_x_mask
+                // Adding buffer size before subtraction prevents underflow
+                size_t idx = (m_x_index + m_x_mask + 1 - (i - 1)) & m_x_mask;
                 output += m_b_coeffs[i] * m_x_state[idx];
             }
 
@@ -80,8 +81,9 @@ namespace dsp
             for (size_t i = 0; i < m_a_coeffs.size(); ++i)
             {
                 // y_state stores y[n-1], y[n-2], ..., y[n-N]
-                // Read backwards: y[n-(i+1)] is at position (m_y_index - i) & m_y_mask
-                size_t idx = (m_y_index - i) & m_y_mask;
+                // Read backwards: y[n-(i+1)] is at position (m_y_index + m_y_mask + 1 - i) & m_y_mask
+                // Adding buffer size before subtraction prevents underflow
+                size_t idx = (m_y_index + m_y_mask + 1 - i) & m_y_mask;
                 output -= m_a_coeffs[i] * m_y_state[idx];
             }
 
@@ -131,14 +133,14 @@ namespace dsp
                     T y = m_b_coeffs[0] * input[n];
                     for (size_t i = 1; i < m_b_coeffs.size(); ++i)
                     {
-                        size_t idx = (x_idx - (i - 1)) & x_mask;
+                        size_t idx = (x_idx + x_mask + 1 - (i - 1)) & x_mask;
                         y += m_b_coeffs[i] * x_temp[idx];
                     }
 
                     // Feedback
                     for (size_t i = 0; i < m_a_coeffs.size(); ++i)
                     {
-                        size_t idx = (y_idx - i) & y_mask;
+                        size_t idx = (y_idx + y_mask + 1 - i) & y_mask;
                         y -= m_a_coeffs[i] * y_temp[idx];
                     }
 
@@ -162,14 +164,14 @@ namespace dsp
                     T y = m_b_coeffs[0] * input[n];
                     for (size_t i = 1; i < m_b_coeffs.size(); ++i)
                     {
-                        size_t idx = (m_x_index - (i - 1)) & m_x_mask;
+                        size_t idx = (m_x_index + m_x_mask + 1 - (i - 1)) & m_x_mask;
                         y += m_b_coeffs[i] * m_x_state[idx];
                     }
 
                     // Feedback
                     for (size_t i = 0; i < m_a_coeffs.size(); ++i)
                     {
-                        size_t idx = (m_y_index - i) & m_y_mask;
+                        size_t idx = (m_y_index + m_y_mask + 1 - i) & m_y_mask;
                         y -= m_a_coeffs[i] * m_y_state[idx];
                     }
 

package/src/native/utils/SimdOps.h

@@ -1362,4 +1362,71 @@ namespace dsp::simd
     }
 
     // SIMD_X86 removed since SIMD_SSE3 covers it for most of the modern devices
+    /**
+     * @brief Apply square (x^2) in-place.
+     * Essential for Pan-Tompkins QRS detection to amplify signal peaks.
+     * @param buffer Input/output buffer (modified in-place)
+     * @param size Number of elements
+     */
+    inline void square_inplace(float *buffer, size_t size)
+    {
+#if defined(SIMD_AVX2)
+        const size_t simd_width = 8;
+        const size_t simd_count = size / simd_width;
+        const size_t simd_end = simd_count * simd_width;
+
+        for (size_t i = 0; i < simd_end; i += simd_width)
+        {
+            __m256 values = _mm256_loadu_ps(&buffer[i]);
+            __m256 result = _mm256_mul_ps(values, values); // x * x
+            _mm256_storeu_ps(&buffer[i], result);
+        }
+
+        for (size_t i = simd_end; i < size; ++i)
+        {
+            buffer[i] = buffer[i] * buffer[i];
+        }
+
+#elif defined(SIMD_SSE2)
+        const size_t simd_width = 4;
+        const size_t simd_count = size / simd_width;
+        const size_t simd_end = simd_count * simd_width;
+
+        for (size_t i = 0; i < simd_end; i += simd_width)
+        {
+            __m128 values = _mm_loadu_ps(&buffer[i]);
+            __m128 result = _mm_mul_ps(values, values);
+            _mm_storeu_ps(&buffer[i], result);
+        }
+
+        for (size_t i = simd_end; i < size; ++i)
+        {
+            buffer[i] = buffer[i] * buffer[i];
+        }
+
+#elif defined(SIMD_NEON)
+        const size_t simd_width = 4;
+        const size_t simd_count = size / simd_width;
+        const size_t simd_end = simd_count * simd_width;
+
+        for (size_t i = 0; i < simd_end; i += simd_width)
+        {
+            float32x4_t values = vld1q_f32(&buffer[i]);
+            float32x4_t result = vmulq_f32(values, values);
+            vst1q_f32(&buffer[i], result);
+        }
+
+        for (size_t i = simd_end; i < size; ++i)
+        {
+            buffer[i] = buffer[i] * buffer[i];
+        }
+
+#else
+        // Scalar fallback
+        for (size_t i = 0; i < size; ++i)
+        {
+            buffer[i] = buffer[i] * buffer[i];
+        }
+#endif
+    }
 } // namespace dsp::simd