Enhanced MoogFilter with ARM NEON SIMD optimization capabilities. More...
#include <NeonMoogFilter.h>
Public Member Functions | |
| void | processBlockSIMD (const float *input, float *output, int numSamples) |
| Process audio buffer using ARM NEON SIMD optimization. | |
| Public Member Functions inherited from MoogFilter | |
| MoogFilter (float sr) | |
| Construct empirically-tuned Moog filter. | |
| void | setCutoff (float frequency) |
| Set filter cutoff frequency with automatic coefficient update. | |
| void | setResonance (float r) |
| Set filter resonance with automatic coefficient update. | |
| float | process (float input) |
| Process single audio sample through filter. | |
| void | processBlock (const float *input, float *output, int numSamples) |
| Process block of audio samples efficiently. | |
| void | reset () |
| Reset filter state for clean initialization. | |
| float | getCutoff () const |
| Get current cutoff frequency setting. | |
| float | getResonance () const |
| Get current resonance setting. | |
| MoogFilter (float sr=44100.0f) | |
| void | setCutoff (float frequency) |
| void | setResonance (float r) |
| void | updateCoefficients () |
| float | process (float input) |
| void | processBlock (const float *input, float *output, int numSamples) |
| void | reset () |
| float | getCutoff () const |
| float | getResonance () const |
| MoogFilter (float sr=44100.0f) | |
| Construct hybrid Moog filter with adaptive optimization. | |
| void | setCutoff (float frequency) |
| Set cutoff frequency with empirical coefficient calculation. | |
| void | setResonance (float r) |
| Set resonance with empirically-tuned feedback calculation. | |
| void | updateCoefficients () |
| Update all filter coefficients when parameters change. | |
| float | process (float input) |
| Process single sample using scalar optimization. | |
| void | processBlock (const float *input, float *output, int numSamples) |
| Process audio buffer using scalar block optimization. | |
| void | processBlockSIMD (const float *input, float *output, int numSamples) |
| Process audio buffer using ARM NEON SIMD optimization. | |
| void | reset () |
| Reset all filter state for clean initialization. | |
| float | getCutoff () const |
| Get current cutoff frequency setting. | |
| float | getResonance () const |
| Get current resonance setting. | |
| MoogFilter (float sr=44100.0f) | |
| void | setCutoff (float frequency) |
| void | setResonance (float r) |
| void | updateCoefficients () |
| float | process (float input) |
| void | processBlock (const float *input, float *output, int numSamples) |
| void | reset () |
| float | getCutoff () const |
| float | getResonance () const |
Private Member Functions | |
| float32x4_t | fastTanhSIMD (float32x4_t x) |
| SIMD version of fast tanh approximation. | |
| float32x4_t | neon_divide_f32 (float32x4_t num, float32x4_t den) |
| Efficient vector division using Newton-Raphson approximation. | |
Detailed Description
Enhanced MoogFilter with ARM NEON SIMD optimization capabilities.
Hybrid scalar/SIMD Moog filter with empirical tuning and NEON optimization.
Extends the base empirically-tuned MoogFilter class with vectorized processing methods that leverage ARM NEON instructions for improved performance in multichannel and batch processing scenarios.
)
This class extends the empirically-tuned MoogFilter with ARM NEON SIMD capabilities, providing both traditional scalar processing and optimized vectorized batch processing for different application scenarios.
@processing_modes
- process(): Single-sample scalar processing with fast tanh
- processBlock(): Traditional buffer processing with scalar operations
- processBlockSIMD(): Vectorized buffer processing with NEON optimization
@optimization_techniques
- Fast tanh approximation: Rational function for scalar processing
- SIMD tanh vectorization: Parallel nonlinear processing
- Efficient division: Newton-Raphson approximation for vector division
- Memory optimization: Aligned access patterns for vector operations
- Hybrid processing: Seamless scalar/vector mode switching
@applications
- Real-time audio effects with adaptive optimization
- Mobile audio processing requiring power efficiency
- DAW plugins with efficient buffer processing
- Embedded audio systems with ARM processors
- Live performance applications requiring minimal latency
Member Function Documentation
◆ fastTanhSIMD()
|
inlineprivate |
SIMD version of fast tanh approximation.
- Parameters
-
x Vector of four input values
- Returns
- Vector of four tanh-approximated outputs
Implements vectorized rational function approximation of tanh using ARM NEON instructions for parallel nonlinear processing.
@algorithm f(x) = x(27 + x²)/(27 + 9x²) for each vector lane @accuracy Within ±0.03 error for range [-4, 4] @performance ~4x faster than scalar tanh for aligned data
◆ neon_divide_f32()
|
inlineprivate |
Efficient vector division using Newton-Raphson approximation.
- Parameters
-
num Numerator vector den Denominator vector
- Returns
- Division result vector (num/den)
Implements fast vector division using ARM NEON reciprocal estimate with Newton-Raphson refinement for improved accuracy.
@algorithm
- Initial reciprocal estimate using vrecpeq_f32
- Newton-Raphson refinement: x₁ = x₀(2 - d·x₀)
- Optional second refinement for higher precision
- Final multiplication: result = num × (1/den)
@accuracy Approximately 24-bit precision after refinement @performance Significantly faster than scalar division
◆ processBlockSIMD()
| void NeonMoogFilter::processBlockSIMD | ( | const float * | input, |
| float * | output, | ||
| int | numSamples ) |
Process audio buffer using ARM NEON SIMD optimization.
- Parameters
-
input Input audio buffer output Output audio buffer numSamples Number of samples to process
Implements vectorized buffer processing using ARM NEON instructions to process multiple samples simultaneously while maintaining filter state continuity and exact algorithmic behavior.
@vectorization_strategy
- Process 4 samples at a time using NEON float32x4_t vectors
- Vectorize tanh approximation for parallel nonlinear processing
- Maintain state continuity through careful lane management
- Handle non-aligned buffer sizes with scalar fallback
- Optimize memory access patterns for cache efficiency
@performance_benefits
- Theoretical 4x speedup for aligned buffer processing
- Practical 2.5-3x improvement accounting for overhead
- Reduced memory bandwidth through vectorized operations
- Improved power efficiency on ARM processors
- Lower CPU utilization for equivalent processing throughput
The documentation for this class was generated from the following file:
- DEV/NeonMoogFilter.h
