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

#include <oboe/Oboe.h>

class LowLatencyAudioEngine : public oboe::AudioStreamCallback {
public:
    oboe::Result init() {
        oboe::AudioStreamBuilder stream_factory;
        
        stream_factory.setDirection(oboe::Direction::Output)
            ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
            ->setSharingMode(oboe::SharingMode::Exclusive)
            ->setFormat(oboe::AudioFormat::Float)
            ->setChannelCount(oboe::ChannelCount::Stereo)
            ->setFramesPerBurst(48)
            ->setCallback(this);

        return stream_factory.openStream(&audio_stream_);
    }

private:
    oboe::AudioStream* audio_stream_ = nullptr;
};

#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) {
            re

turn 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.

```cpp
#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.