dspx 1.4.2 → 1.4.8

package/README.md

@@ -11,6 +11,8 @@
 
 A modern DSP library built for Node.js backends processing real-time biosignals, audio streams, and sensor data. Features native C++ filters with full state serialization (to Redis, S3, or any storage backend), enabling seamless processing across service restarts and distributed workers.
 
+[View the benchmarks](https://github.com/A-KGeorge/dspx-benchmark/)
+
 ---
 
 ## ✨ Features
@@ -475,7 +477,7 @@ const clean = notch.process(noisySignal);
 import { createDspPipeline, Convolution } from "dspx";
 const pipeline = createDspPipeline();
 pipeline.addStage(
-  new Convolution({ kernel: OPTIMAL_LOWPASS_COEFFS.cutoff_0_2 })
+  new Convolution({ kernel: OPTIMAL_LOWPASS_COEFFS.cutoff_0_2 }),
 );
 
 // ✅ Zero Python dependency - coefficients ship with the library!
@@ -1661,7 +1663,7 @@ const saveBreaker = new CircuitBreaker(
     timeout: 2000, // Fail if >2s
     errorThresholdPercentage: 50, // Trip after 50% failures
     resetTimeout: 30000, // Try recovery after 30s
-  }
+  },
 );
 
 saveBreaker.fallback(() => {

package/binding.gyp

@@ -93,7 +93,7 @@
             'OTHER_CPLUSPLUSFLAGS+': [ '-msse3', '-mavx', '-mavx2' ]
           }
         }],
-        # Condition for arm64 architecture (Android, iOS, M1/M2 Macs, Tensor G4, etc.)
+        # Condition for arm64 architecture (Android, iOS, M1/M2 Macs, etc.)
         ['target_arch=="arm64"', {
           # ARMv8-a baseline: NEON + FP support (compatible with all ARMv8 CPUs)
           "cflags+": [ "-march=armv8-a+fp+simd" ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dspx",
-  "version": "1.4.2",
+  "version": "1.4.8",
   "description": "High-performance DSP library with native C++ acceleration and Redis state persistence",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,7 +21,7 @@
     "build:ts": "tsc",
     "build:native": "node-gyp rebuild",
     "build": "npm run build:native && npm run build:ts",
-    "prebuildify": "prebuildify --napi --strip --target 18.0.0 --target 20.0.0 --target 22.0.0",
+    "prebuildify": "prebuildify --napi --strip --target 18.0.0 --target 20.0.0 --target 22.0.0 --target 24.0.0",
     "changeset": "changeset",
     "version": "changeset version",
     "publish-packages": "changeset publish"
@@ -33,7 +33,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/A-KGeorge/dspx"
+    "url": "git+https://github.com/A-KGeorge/dspx.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
   "keywords": [
     "dsp",
@@ -47,6 +51,10 @@
   "author": "Alan Kochukalam George",
   "license": "Apache-2.0",
   "type": "module",
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=11.5.1"
+  },
   "dependencies": {
     "cross-env": "^7.0.3",
     "node-addon-api": "^8.5.0",

package/src/native/core/FirFilter.cc

@@ -318,6 +318,19 @@ namespace dsp
         template <typename T>
         std::pair<std::vector<T>, size_t> FirFilter<T>::getState() const
         {
+#if defined(__ARM_NEON) || defined(__aarch64__)
+            if (m_useNeon && m_neonFilter)
+            {
+                // Use NEON filter's linearization on ARM
+                auto [linearState, stateIndex] = m_neonFilter->exportLinearState();
+                std::vector<T> state(linearState.size());
+                for (size_t i = 0; i < linearState.size(); ++i)
+                {
+                    state[i] = static_cast<T>(linearState[i]);
+                }
+                return {state, stateIndex};
+            }
+#endif
             return {m_state, m_stateIndex};
         }
 
@@ -339,6 +352,19 @@ namespace dsp
                 throw std::invalid_argument("stateIndex out of range");
             }
 
+#if defined(__ARM_NEON) || defined(__aarch64__)
+            if (m_useNeon && m_neonFilter)
+            {
+                // Convert to float vector for NEON filter's linearization
+                std::vector<float> floatState(state.size());
+                for (size_t i = 0; i < state.size(); ++i)
+                {
+                    floatState[i] = static_cast<float>(state[i]);
+                }
+                m_neonFilter->importLinearState(floatState, stateIndex);
+                return;
+            }
+#endif
             m_state = state;
             m_stateIndex = stateIndex;
         }

package/src/native/core/FirFilterNeon.h

@@ -227,6 +227,66 @@ namespace dsp::core
             m_samplesProcessed = 0;
         }
 
+        /**
+         * @brief Export state in linear format (oldest->newest) for serialization
+         * @return Pair of linear state vector and state index
+         */
+        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);
+
+            // Un-rotate: copy from oldest->newest into linear array
+            for (size_t i = 0; i < m_bufferSize; ++i)
+            {
+                linearState[i] = state[(oldestPos + 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
+        }
+
+        /**
+         * @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)
+         */
+        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
+            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
+        }
+
         size_t getNumTaps() const { return m_numTaps; }
         size_t getBufferSize() const { return m_bufferSize; }