dspx 0.1.1-alpha.0

package/src/native/core/MovingFftFilter.cc

@@ -0,0 +1,291 @@
+/**
+ * Moving/Batched FFT Filter Implementation with SIMD Optimizations
+ */
+
+#define _USE_MATH_DEFINES
+#include "MovingFftFilter.h"
+#include "../utils/SimdOps.h"
+#include <cmath>
+#include <stdexcept>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+namespace dsp
+{
+    namespace core
+    {
+
+        template <typename T>
+        MovingFftFilter<T>::MovingFftFilter(
+            size_t fftSize,
+            size_t hopSize,
+            FftMode mode,
+            WindowType windowType,
+            bool realInput)
+            : m_fftSize(fftSize), m_hopSize(hopSize == 0 ? fftSize : hopSize), m_mode(mode), m_windowType(windowType), m_realInput(realInput), m_fftEngine(std::make_unique<FftEngine<T>>(fftSize)), m_buffer(fftSize * 2) // Buffer size = 2x FFT size for overlap
+              ,
+              m_sampleCounter(0)
+        {
+            if (fftSize == 0)
+            {
+                throw std::invalid_argument("FFT size must be > 0");
+            }
+
+            if (m_hopSize > fftSize)
+            {
+                throw std::invalid_argument("Hop size cannot exceed FFT size");
+            }
+
+            // Allocate working buffers
+            m_windowedSamples.resize(fftSize);
+
+            size_t spectrumSize = realInput ? m_fftEngine->getHalfSize() : fftSize;
+            m_spectrum.resize(spectrumSize);
+
+            // Initialize window
+            initWindow();
+        }
+
+        template <typename T>
+        bool MovingFftFilter<T>::addSample(T sample, Complex *spectrum)
+        {
+            m_buffer.push(sample);
+
+            bool computed = false;
+
+            if (m_mode == FftMode::Moving)
+            {
+                // Moving mode: compute on every sample when buffer is full
+                if (m_buffer.getCount() >= m_fftSize)
+                {
+                    computeSpectrum(m_spectrum.data());
+
+                    if (spectrum)
+                    {
+                        size_t specSize = getSpectrumSize();
+                        std::copy(m_spectrum.begin(), m_spectrum.begin() + specSize, spectrum);
+                    }
+
+                    computed = true;
+                }
+            }
+            else
+            {
+                // Batched mode: compute every hop samples
+                ++m_sampleCounter;
+
+                if (m_buffer.getCount() >= m_fftSize && m_sampleCounter >= m_hopSize)
+                {
+                    computeSpectrum(m_spectrum.data());
+
+                    if (spectrum)
+                    {
+                        size_t specSize = getSpectrumSize();
+                        std::copy(m_spectrum.begin(), m_spectrum.begin() + specSize, spectrum);
+                    }
+
+                    m_sampleCounter = 0;
+                    computed = true;
+                }
+            }
+
+            return computed;
+        }
+
+        template <typename T>
+        size_t MovingFftFilter<T>::addSamples(
+            const T *samples,
+            size_t count,
+            std::function<void(const Complex *, size_t)> callback)
+        {
+            size_t numSpectra = 0;
+
+            for (size_t i = 0; i < count; ++i)
+            {
+                if (addSample(samples[i], m_spectrum.data()))
+                {
+                    if (callback)
+                    {
+                        callback(m_spectrum.data(), getSpectrumSize());
+                    }
+                    ++numSpectra;
+                }
+            }
+
+            return numSpectra;
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::computeSpectrum(Complex *spectrum)
+        {
+            if (m_buffer.getCount() < m_fftSize)
+            {
+                throw std::runtime_error("Insufficient samples for FFT");
+            }
+
+            // Get latest samples from buffer
+            std::vector<T> allSamples = m_buffer.toVector();
+            std::vector<T> samples(m_fftSize);
+
+            // Extract the last fftSize samples
+            size_t startIdx = allSamples.size() - m_fftSize;
+            for (size_t i = 0; i < m_fftSize; ++i)
+            {
+                samples[i] = allSamples[startIdx + i];
+            }
+
+            // Apply window
+            applyWindow(samples.data(), m_windowedSamples.data());
+
+            // Compute FFT
+            if (m_realInput)
+            {
+                if (m_fftEngine->isPowerOfTwo())
+                {
+                    m_fftEngine->rfft(m_windowedSamples.data(), spectrum);
+                }
+                else
+                {
+                    m_fftEngine->rdft(m_windowedSamples.data(), spectrum);
+                }
+            }
+            else
+            {
+                // Pack real samples as complex
+                std::vector<Complex> complexInput(m_fftSize);
+                for (size_t i = 0; i < m_fftSize; ++i)
+                {
+                    complexInput[i] = Complex(m_windowedSamples[i], 0);
+                }
+
+                if (m_fftEngine->isPowerOfTwo())
+                {
+                    m_fftEngine->fft(complexInput.data(), spectrum);
+                }
+                else
+                {
+                    m_fftEngine->dft(complexInput.data(), spectrum);
+                }
+            }
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::reset()
+        {
+            m_buffer.clear();
+            m_sampleCounter = 0;
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::setWindowType(WindowType type)
+        {
+            m_windowType = type;
+            initWindow();
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::getMagnitudeSpectrum(T *magnitudes)
+        {
+            // MEDIUM WIN: Use SIMD-optimized magnitude calculation from FftEngine
+            m_fftEngine->getMagnitude(m_spectrum.data(), magnitudes, getSpectrumSize());
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::getPowerSpectrum(T *power)
+        {
+            // MEDIUM WIN: Use SIMD-optimized power calculation from FftEngine
+            m_fftEngine->getPower(m_spectrum.data(), power, getSpectrumSize());
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::getPhaseSpectrum(T *phases)
+        {
+            m_fftEngine->getPhase(m_spectrum.data(), phases, getSpectrumSize());
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::getFrequencyBins(T sampleRate, T *frequencies)
+        {
+            size_t specSize = getSpectrumSize();
+            T binWidth = sampleRate / static_cast<T>(m_fftSize);
+
+            for (size_t i = 0; i < specSize; ++i)
+            {
+                frequencies[i] = static_cast<T>(i) * binWidth;
+            }
+        }
+
+        // ========== Private Methods ==========
+
+        template <typename T>
+        void MovingFftFilter<T>::initWindow()
+        {
+            m_window.resize(m_fftSize);
+
+            for (size_t i = 0; i < m_fftSize; ++i)
+            {
+                m_window[i] = getWindowCoefficient(i, m_windowType);
+            }
+        }
+
+        template <typename T>
+        void MovingFftFilter<T>::applyWindow(const T *input, T *output)
+        {
+            // QUICK WIN: SIMD-optimized window application
+            if constexpr (std::is_same_v<T, float>)
+            {
+                dsp::simd::apply_window(input, m_window.data(), output, m_fftSize);
+            }
+            else
+            {
+                // Fallback for double precision
+                for (size_t i = 0; i < m_fftSize; ++i)
+                {
+                    output[i] = input[i] * m_window[i];
+                }
+            }
+        }
+
+        template <typename T>
+        T MovingFftFilter<T>::getWindowCoefficient(size_t n, WindowType type)
+        {
+            if (type == WindowType::None)
+            {
+                return T(1);
+            }
+
+            const T pi = static_cast<T>(M_PI);
+            const T N = static_cast<T>(m_fftSize);
+            const T nf = static_cast<T>(n);
+
+            switch (type)
+            {
+            case WindowType::Hann:
+                // w[n] = 0.5 * (1 - cos(2πn/(N-1)))
+                return T(0.5) * (T(1) - std::cos(T(2) * pi * nf / (N - T(1))));
+
+            case WindowType::Hamming:
+                // w[n] = 0.54 - 0.46 * cos(2πn/(N-1))
+                return T(0.54) - T(0.46) * std::cos(T(2) * pi * nf / (N - T(1)));
+
+            case WindowType::Blackman:
+                // w[n] = 0.42 - 0.5*cos(2πn/(N-1)) + 0.08*cos(4πn/(N-1))
+                return T(0.42) - T(0.5) * std::cos(T(2) * pi * nf / (N - T(1))) + T(0.08) * std::cos(T(4) * pi * nf / (N - T(1)));
+
+            case WindowType::Bartlett:
+                // w[n] = 1 - |2n/(N-1) - 1|
+                return T(1) - std::abs(T(2) * nf / (N - T(1)) - T(1));
+
+            default:
+                return T(1);
+            }
+        }
+
+        // Explicit template instantiations
+        template class MovingFftFilter<float>;
+        template class MovingFftFilter<double>;
+
+    } // namespace core
+} // namespace dsp

package/src/native/core/MovingFftFilter.h

@@ -0,0 +1,203 @@
+/**
+ * Moving/Batched FFT Filter
+ *
+ * Provides sliding-window and batched FFT processing:
+ * - Moving FFT: Updates spectrum as new samples arrive
+ * - Batched FFT: Processes complete frames with configurable overlap
+ * - Zero-padding support
+ * - Windowing functions (Hann, Hamming, Blackman)
+ *
+ * Uses CircularBufferArray for efficient sample buffering
+ */
+
+#ifndef DSP_CORE_MOVING_FFT_FILTER_H
+#define DSP_CORE_MOVING_FFT_FILTER_H
+
+#include "FftEngine.h"
+#include "../utils/CircularBufferArray.h"
+#include <vector>
+#include <functional>
+
+namespace dsp
+{
+    namespace core
+    {
+
+        /**
+         * Window function types
+         */
+        enum class WindowType
+        {
+            None,     // Rectangular (no windowing)
+            Hann,     // Hann window (cosine taper)
+            Hamming,  // Hamming window
+            Blackman, // Blackman window (better sidelobe rejection)
+            Bartlett  // Triangular window
+        };
+
+        /**
+         * FFT processing mode
+         */
+        enum class FftMode
+        {
+            Moving, // Sliding window, updates on every sample
+            Batched // Process complete frames
+        };
+
+        template <typename T = float>
+        class MovingFftFilter
+        {
+        public:
+            using Complex = std::complex<T>;
+
+            /**
+             * Constructor
+             *
+             * @param fftSize FFT size (must be power of 2)
+             * @param hopSize Hop size for batched mode (samples between frames)
+             * @param mode Processing mode (Moving or Batched)
+             * @param windowType Windowing function
+             * @param realInput True for real-input transforms (RFFT/RDFT)
+             */
+            MovingFftFilter(
+                size_t fftSize,
+                size_t hopSize = 0,
+                FftMode mode = FftMode::Batched,
+                WindowType windowType = WindowType::Hann,
+                bool realInput = true);
+
+            ~MovingFftFilter() = default;
+
+            /**
+             * Add sample and optionally compute FFT
+             *
+             * @param sample Input sample
+             * @param spectrum Output spectrum (nullptr if not ready)
+             * @return True if spectrum was computed
+             */
+            bool addSample(T sample, Complex *spectrum);
+
+            /**
+             * Add batch of samples
+             *
+             * @param samples Input samples
+             * @param count Number of samples
+             * @param callback Called for each computed spectrum
+             * @return Number of spectra computed
+             */
+            size_t addSamples(
+                const T *samples,
+                size_t count,
+                std::function<void(const Complex *, size_t)> callback);
+
+            /**
+             * Compute FFT from current buffer (force computation)
+             *
+             * @param spectrum Output spectrum
+             */
+            void computeSpectrum(Complex *spectrum);
+
+            /**
+             * Reset filter state
+             */
+            void reset();
+
+            /**
+             * Get FFT size
+             */
+            size_t getFftSize() const { return m_fftSize; }
+
+            /**
+             * Get spectrum size (N for complex, N/2+1 for real)
+             */
+            size_t getSpectrumSize() const
+            {
+                return m_realInput ? m_fftEngine->getHalfSize() : m_fftSize;
+            }
+
+            /**
+             * Get hop size
+             */
+            size_t getHopSize() const { return m_hopSize; }
+
+            /**
+             * Get current fill level
+             */
+            size_t getFillLevel() const { return m_buffer.getCount(); }
+
+            /**
+             * Check if ready to compute (buffer full)
+             */
+            bool isReady() const { return m_buffer.getCount() >= m_fftSize; }
+
+            /**
+             * Set window function
+             */
+            void setWindowType(WindowType type);
+
+            /**
+             * Get magnitude spectrum
+             */
+            void getMagnitudeSpectrum(T *magnitudes);
+
+            /**
+             * Get power spectrum
+             */
+            void getPowerSpectrum(T *power);
+
+            /**
+             * Get phase spectrum
+             */
+            void getPhaseSpectrum(T *phases);
+
+            /**
+             * Get frequency bins (Hz)
+             *
+             * @param sampleRate Sample rate in Hz
+             * @param frequencies Output array (size = spectrum size)
+             */
+            void getFrequencyBins(T sampleRate, T *frequencies);
+
+        private:
+            size_t m_fftSize;
+            size_t m_hopSize;
+            FftMode m_mode;
+            WindowType m_windowType;
+            bool m_realInput;
+
+            // FFT engine
+            std::unique_ptr<FftEngine<T>> m_fftEngine;
+
+            // Circular buffer for sample accumulation
+            utils::CircularBufferArray<T> m_buffer;
+
+            // Window coefficients
+            std::vector<T> m_window;
+
+            // Working buffers
+            std::vector<T> m_windowedSamples;
+            std::vector<Complex> m_spectrum;
+
+            // Sample counter for hop detection
+            size_t m_sampleCounter;
+
+            /**
+             * Initialize window function
+             */
+            void initWindow();
+
+            /**
+             * Apply window to samples
+             */
+            void applyWindow(const T *input, T *output);
+
+            /**
+             * Compute window function coefficient
+             */
+            T getWindowCoefficient(size_t n, WindowType type);
+        };
+
+    } // namespace core
+} // namespace dsp
+
+#endif // DSP_CORE_MOVING_FFT_FILTER_H

package/src/native/core/MovingVarianceFilter.cc

@@ -0,0 +1,194 @@
+#include "MovingVarianceFilter.h"
+
+using namespace dsp::core;
+
+// -----------------------------------------------------------------------------
+// Constructor
+// -----------------------------------------------------------------------------
+template <typename T>
+MovingVarianceFilter<T>::MovingVarianceFilter(size_t window_size)
+    : buffer(window_size), // Initialize the circular buffer
+      running_sum(0),
+      running_sum_of_squares(0),
+      window_size(window_size)
+{
+    if (window_size == 0)
+    {
+        throw std::invalid_argument("Window size must be greater than 0");
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Time-aware Constructor
+// -----------------------------------------------------------------------------
+template <typename T>
+MovingVarianceFilter<T>::MovingVarianceFilter(size_t window_size, double window_duration_ms)
+    : buffer(window_size, window_duration_ms), // Initialize time-aware circular buffer
+      running_sum(0),
+      running_sum_of_squares(0),
+      window_size(window_size)
+{
+    if (window_size == 0)
+    {
+        throw std::invalid_argument("Window size must be greater than 0");
+    }
+    if (window_duration_ms <= 0.0)
+    {
+        throw std::invalid_argument("Window duration must be greater than 0");
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Method: addSample
+// -----------------------------------------------------------------------------
+template <typename T>
+T MovingVarianceFilter<T>::addSample(T newValue)
+{
+    T oldestValue = 0;
+
+    // If the buffer is full, get the oldest value
+    if (buffer.isFull())
+    {
+        oldestValue = buffer.peek();
+    }
+
+    // Add the new value to the buffer
+    buffer.pushOverwrite(newValue);
+
+    // Update running sums
+    T oldestValueSquared = oldestValue * oldestValue;
+    T newValueSquared = newValue * newValue;
+
+    running_sum = running_sum - oldestValue + newValue;
+    running_sum_of_squares = running_sum_of_squares - oldestValueSquared + newValueSquared;
+
+    // Return the new variance
+    return getVariance();
+}
+
+// -----------------------------------------------------------------------------
+// Method: addSampleWithTimestamp
+// -----------------------------------------------------------------------------
+template <typename T>
+T MovingVarianceFilter<T>::addSampleWithTimestamp(T newValue, double timestamp)
+{
+    // Expire old samples
+    size_t initial_count = buffer.getCount();
+    size_t expired_count = buffer.expireOld(timestamp);
+
+    // Rebuild running statistics if samples were expired
+    if (expired_count > 0)
+    {
+        running_sum = 0;
+        running_sum_of_squares = 0;
+
+        auto remaining = buffer.toVector();
+        for (const auto &value : remaining)
+        {
+            running_sum += value;
+            running_sum_of_squares += value * value;
+        }
+    }
+
+    // Add new sample
+    T oldestValue = 0;
+    if (buffer.isFull())
+    {
+        oldestValue = buffer.peek();
+    }
+
+    buffer.pushOverwriteWithTimestamp(newValue, timestamp);
+
+    // Update running sums
+    T oldestValueSquared = oldestValue * oldestValue;
+    T newValueSquared = newValue * newValue;
+
+    running_sum = running_sum - oldestValue + newValue;
+    running_sum_of_squares = running_sum_of_squares - oldestValueSquared + newValueSquared;
+
+    return getVariance();
+}
+
+// -----------------------------------------------------------------------------
+// Method: getVariance
+// -----------------------------------------------------------------------------
+template <typename T>
+T MovingVarianceFilter<T>::getVariance() const
+{
+    size_t count = buffer.getCount();
+    if (count == 0)
+    {
+        return 0; // Avoid division by zero
+    }
+
+    T countT = static_cast<T>(count);
+
+    // Calculate mean
+    T mean = running_sum / countT;
+
+    // Calculate mean of squares
+    T mean_of_squares = running_sum_of_squares / countT;
+
+    // Variance = E[X^2] - (E[X])^2
+    // Use std::max to prevent negative values from floating point inaccuracies
+    T variance = std::max(static_cast<T>(0), mean_of_squares - (mean * mean));
+
+    return variance;
+}
+
+// -----------------------------------------------------------------------------
+// Method: clear
+// -----------------------------------------------------------------------------
+template <typename T>
+void MovingVarianceFilter<T>::clear()
+{
+    buffer.clear();
+    running_sum = 0;
+    running_sum_of_squares = 0;
+}
+
+// -----------------------------------------------------------------------------
+// Method: isFull
+// -----------------------------------------------------------------------------
+template <typename T>
+bool MovingVarianceFilter<T>::isFull() const noexcept
+{
+    return buffer.isFull();
+}
+
+// -----------------------------------------------------------------------------
+// Method: isTimeAware
+// -----------------------------------------------------------------------------
+template <typename T>
+bool MovingVarianceFilter<T>::isTimeAware() const noexcept
+{
+    return buffer.isTimeAware();
+}
+
+// -----------------------------------------------------------------------------
+// Method: getState
+// -----------------------------------------------------------------------------
+template <typename T>
+std::pair<std::vector<T>, std::pair<T, T>> MovingVarianceFilter<T>::getState() const
+{
+    return {buffer.toVector(), {running_sum, running_sum_of_squares}};
+}
+
+// -----------------------------------------------------------------------------
+// Method: setState
+// -----------------------------------------------------------------------------
+template <typename T>
+void MovingVarianceFilter<T>::setState(const std::vector<T> &bufferData, T sum, T sumOfSquares)
+{
+    buffer.fromVector(bufferData);
+    running_sum = sum;
+    running_sum_of_squares = sumOfSquares;
+}
+
+// Explicit template instantiation for common types
+namespace dsp::core
+{
+    template class MovingVarianceFilter<int>;
+    template class MovingVarianceFilter<float>;
+    template class MovingVarianceFilter<double>;
+}