ARM NEON SIMD Intrinsics for Real-Time Audio Processing in Android NDK

ng deterministic timing.

• FramesPerBurst(48): Minimizing the burst size reduces buffer depth. Smaller buffers decrease the time audio data sits in the pipeline before reaching the DAC.
• PerformanceMode::LowLatency: Hints to the OS to prioritize this stream and use faster audio paths.

2. Lock-Free SPSC Ring Buffer with Cache-Line Alignment

The audio callback executes on a real-time priority thread. Any blocking operation, including mutex acquisition, heap allocation, or even logging, causes audible glitches. The boundary between the processing thread and the callback must be a Single-Producer, Single-Consumer (SPSC) lock-free queue.

On ARM Cortex-A architectures, cache lines are 64 bytes. If atomic indices share a cache line with other data, false sharing occurs, causing cache coherency traffic that degrades performance.

#include <array>
#include <atomic>
#include <cstddef>
#include <cstring>

template<typename SampleType, size_t Capacity>
class alignas(64) SPSCAudioQueue {
    std::array<SampleType, Capacity> storage_;
    
    // Align atomics to cache lines to prevent false sharing
    alignas(64) std::atomic<size_t> write_index_{0};
    alignas(64) std::atomic<size_t> read_index_{0};

public:
    bool enqueue(const SampleType* source_data, size_t sample_count) {
        size_t current_write = write_index_.load(std::memory_order_relaxed);
        size_t current_read = read_index_.load(std::memory_order_acquire);
        
        size_t available_space = Capacity - (current_write - current_read);
        if (available_space < sample_count) {
            return false; // Buffer full
        }

        size_t write_offset = current_write % Capacity;
        std::memcpy(&storage_[write_offset], source_data, sample_count * sizeof(SampleType));
        
        write_index_.store(current_write + sample_count, std::memory_order_release);
        return true;
    }

    bool dequeue(SampleType* dest_buffer, size_t sample_count) {
        size_t current_read = read_index_.load(std::memory_order_relaxed);
        size_t current_write = write_index_.load(std::memory_order_acquire);
        
        size_t available_data = current_write - current_read;
        if (available_data < sample_count) {
            return false; // Buffer empty
        }

        size_t read_offset = current_read % Capacity;
        std::memcpy(dest_buffer, &storage_[read_offset], sample_count * sizeof(SampleType));
        
        read_index_.store(current_read + sample_count, std::memory_order_release);
        return true;
    }
};

Architecture Rationale:

• alignas(64): Applied to the class and individual atomic members. This ensures write_index_ and read_index_ occupy distinct cache lines, eliminating false sharing between the producer and consumer cores.
• std::memory_order: Uses acquire/release semantics to ensure visibility of data writes without the overhead of sequential consistency.
• No Mutexes: The lock-free design guarantees O(1) operations with no priority inversion risk.

3. NEON Vectorization for FFT Butterfly Operations

Scalar DSP loops process one sample per iteration. ARM NEON SIMD instructions process four 32-bit floats simultaneously. For FFT butterfly operations, this yields a 3-4x throughput improvement.

The vmlsq_f32 and vmlaq_f32 intrinsics perform fused multiply-subtract and multiply-add operations. On Cortex-A78 and newer cores, these execute in a single cycle, avoiding the latency penalty of separate multiply and add instructions.

#include <arm_neon.h>

void vectorize_fft_stage(float* real_part, float* imag_part,
                         const float* twiddle_real, const float* twiddle_imag,
                         int block_length) {
    // Process 4 samples per iteration
    for (int idx = 0; idx < block_length; idx += 4) {
        // Load 4 floats at once
        float32x4_t r_in = vld1q_f32(&real_part[idx]);
        float32x4_t i_in = vld1q_f32(&imag_part[idx]);
        float32x4_t t_r  = vld1q_f32(&twiddle_real[idx]);
        float32x4_t t_i  = vld1q_f32(&twiddle_imag[idx]);

        // Fused multiply-add/sub: res = (r_in * t_r) - (i_in * t_i)
        float32x4_t res_r = vmlsq_f32(vmulq_f32(r_in, t_r), i_in, t_i);
        
        // Fused multiply-add: res = (r_in * t_i) + (i_in * t_r)
        float32x4_t res_i = vmlaq_f32(vmulq_f32(r_in, t_i), i_in, t_r);

        // Store results
        vst1q_f32(&real_part[idx], res_r);
        vst1q_f32(&imag_part[idx], res_i);
    }
}

Architecture Rationale:

• float32x4_t: NEON vector type holding four 32-bit floats.
• vld1q_f32 / vst1q_f32: Load/store instructions for aligned 128-bit vectors.
• vmlsq_f32 / vmlaq_f32: Fused operations reduce instruction count and latency.
• Target arm64-v8a: NEON is mandatory in ARMv8-A. No runtime feature detection is required.

Pitfall Guide

1. False Sharing in Ring Buffers

Explanation: Failing to align atomic indices to 64-byte boundaries causes write_index_ and read_index_ to reside in the same cache line. When producer and consumer threads update these atomics, the cache line bounces between cores, causing severe performance degradation. Fix: Apply alignas(64) to all atomic members and the buffer structure itself. Verify alignment with static_assert(alignof(SPSCAudioQueue<float, 1024>) >= 64).

2. Defaulting to Shared Mode

Explanation: Oboe defaults to SharingMode::Shared, which routes audio through the Android mixer. This adds 5-15ms of latency and introduces jitter from other audio sources. Fix: Explicitly set setSharingMode(oboe::SharingMode::Exclusive). Accept that exclusive mode prevents mixing with other apps; this is the trade-off for deterministic latency.

3. Relying on Compiler Auto-Vectorization

Explanation: NDK toolchains vary in their ability to auto-vectorize complex DSP loops. Trusting the compiler often results in scalar code in release builds, leading to unpredictable performance. Fix: Use explicit NEON intrinsics for critical paths like FFT butterflies. Intrinsics provide deterministic throughput and allow fine-grained control over instruction selection.

4. Blocking Operations in the Callback

Explanation: The audio callback runs at real-time priority. Calling malloc, locking a mutex, or writing to logcat can block the thread, causing buffer underruns and audible clicks. Fix: Pre-allocate all memory. Use lock-free queues for data transfer. Disable logging in the callback path. Profile with Simpleperf to detect hidden blocking calls.

5. Retaining 32-bit ABI Support

Explanation: Supporting armeabi-v7a forces the build system to include legacy code paths and prevents optimization for modern 64-bit architectures. NEON performance characteristics differ significantly between 32-bit and 64-bit ARM. Fix: Drop armeabi-v7a support. Target arm64-v8a exclusively. This simplifies the build, reduces APK size, and ensures access to the latest SIMD optimizations.

6. Neglecting Hardware Profiling

Explanation: Emulators do not accurately represent audio latency or NEON performance. Optimizations validated only on emulators often fail on physical devices due to different cache hierarchies and audio HAL implementations. Fix: Profile exclusively on physical ARM64 devices. Use Simpleperf to analyze CPU cycles and cache misses. Measure latency using hardware loopback or timestamp analysis.

7. Misaligned Memory Access

Explanation: NEON load/store instructions perform best with aligned memory. Unaligned accesses can incur penalties or fault on certain architectures. Fix: Ensure audio buffers and twiddle tables are aligned to 16-byte boundaries. Use alignas(16) for static arrays and aligned allocators for dynamic buffers.

Production Bundle

Action Checklist

• Configure Exclusive Mode: Set SharingMode::Exclusive in the Oboe builder to bypass the mixer.
• Minimize Burst Size: Set FramesPerBurst to the lowest stable value (e.g., 48) to reduce buffer depth.
• Align Ring Buffer Atomics: Apply alignas(64) to std::atomic members in the SPSC queue to prevent false sharing.
• Vectorize DSP Kernels: Replace scalar FFT loops with NEON intrinsics using vmlsq_f32 and vmlaq_f32.
• Target arm64-v8a: Remove armeabi-v7a from CMAKE_ANDROID_ARCH_ABI to focus on 64-bit optimizations.
• Pre-allocate Memory: Allocate all buffers and queues before starting the audio stream.
• Profile on Hardware: Validate latency and CPU usage on physical devices using Simpleperf.
• Disable Callback Logging: Remove all log calls from the audio callback path to prevent blocking.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Real-time Synthesis / Monitoring	Oboe Exclusive + NEON SIMD	Requires sub-10ms latency and high throughput. Exclusive mode eliminates mixer jitter; NEON ensures DSP completes within callback window.	High development effort; requires native C++ and NEON expertise.
Background Music Player	Oboe Shared + Scalar C++	Latency requirements are relaxed. Shared mode allows mixing with notifications and calls. Scalar code is simpler to maintain.	Low effort; standard Oboe usage.
Voice Chat / VoIP	Oboe Exclusive + NEON	Low latency is critical for natural conversation. Echo cancellation and noise suppression benefit from SIMD acceleration.	Medium effort; requires careful buffer management.
Legacy Device Support	Oboe Shared + Scalar	Older devices may not support exclusive mode reliably. Scalar code ensures compatibility across all ARMv7 and ARMv8 devices.	Higher latency; broader compatibility.

Configuration Template

Use this CMake configuration to ensure optimal build settings for low-latency audio on Android.

cmake_minimum_required(VERSION 3.22.1)
project(AudioEngineNative LANGUAGES CXX)

# Target only 64-bit ARM
set(CMAKE_ANDROID_ARCH_ABI arm64-v8a)

# Optimization flags
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -ftree-vectorize -ffast-math")

# NEON is mandatory on arm64-v8a; no runtime detection needed
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8-a+simd")

# Oboe dependency
find_package(oboe REQUIRED CONFIG)

add_library(audio_engine SHARED
    src/AudioEngine.cpp
    src/SPSCQueue.cpp
    src/NEON_DSP.cpp
)

target_link_libraries(audio_engine
    oboe::oboe
    log
    android
)

Quick Start Guide

1. Add Oboe Dependency: Include Oboe in your build.gradle and link it in CMake.
2. Initialize Exclusive Stream: Create an AudioStreamBuilder, set SharingMode::Exclusive, and open the stream.
3. Implement Lock-Free Queue: Instantiate SPSCAudioQueue with alignas(64) atomics. Connect your processing thread to the producer side and the callback to the consumer side.
4. Vectorize Critical Loops: Identify DSP hotspots (e.g., FFT, filtering) and rewrite them using NEON intrinsics. Ensure data alignment matches NEON requirements.
5. Profile and Iterate: Build and deploy to a physical device. Measure latency and CPU usage. Adjust burst size and optimize NEON code until latency stabilizes below 10ms.