Low-Latency Audio Stream Processing & Zero-Allocation DSP

The Strict Latency Deadlines of Audio DSP

In PRAXIS (a voice-to-code multi-agent platform), incoming raw audio must be ingested from microphones or WebRTC streams, framed, and transformed into frequency-domain features with under 10 milliseconds of latency. Missing a single audio buffer callback triggers audible crackling (buffer underrun).

The Golden Rules of Real-Time Audio Threads

Inside the OS audio callback thread, code must NEVER:

1. Allocate or free heap memory (malloc, Box::new, Vec::push)
2. Acquire blocking locks or mutexes (std::sync::Mutex)
3. Perform disk or network I/O

use std::sync::atomic::{AtomicUsize, Ordering};
use std::cell::UnsafeCell;

pub struct RealTimeAudioRing {
    // UnsafeCell provides sound interior mutability for lock-free buffers
    samples: Box<[UnsafeCell]>,
    write_pos: AtomicUsize,
    read_pos: AtomicUsize,
}

unsafe impl Sync for RealTimeAudioRing {}

impl RealTimeAudioRing {
    // Called strictly from the high-priority OS audio thread
    pub fn write_samples(&self, input: &[f32]) -> usize {
        let mut written = 0;
        let mut wp = self.write_pos.load(Ordering::Relaxed);
        let rp = self.read_pos.load(Ordering::Acquire);

        while written < input.len() && wp.wrapping_sub(rp) < self.samples.len() {
            let idx = wp % self.samples.len();
            // Sound: write_pos and read_pos guarantee no concurrent reader at idx
            unsafe {
                *self.samples[idx].get() = input[written];
            }
            wp = wp.wrapping_add(1);
            written += 1;
        }

        self.write_pos.store(wp, Ordering::Release);
        written
    }
}