OMNi — THE FREE DAW

pub struct AudioQueue {
    sender: crossbeam_channel::Sender<AudioCommand>,
    receiver: crossbeam_channel::Receiver<AudioCommand>,
}

impl AudioQueue {
    // Called on the audio thread — zero alloc, zero locks
    pub fn process_commands(&self, state: &mut AudioThreadState) {
        while let Ok(cmd) = self.receiver.try_recv() {
            match cmd {
                AudioCommand::SetParam(id, val) => {
                    state.set_parameter(id, val);
                },
                AudioCommand::TriggerNote(note) => {
                    state.trigger_voice(note);
                },
            }
        }
    }
}

pub struct SpinBarrier {
    counter: AtomicUsize,
    target: usize,
}

impl SpinBarrier {
    // Spin-wait prevents OS thread sleeping
    pub fn wait(&self) {
        let mut spins = 0;
        while self.counter.load(Ordering::Acquire) < self.target {
            if spins < 1000 {
                std::hint::spin_loop();
                spins += 1;
            } else {
                std::thread::yield_now();
                spins = 0;
            }
        }
    }
}

pub struct SandboxedPlugin {
    ipc_channel: IpcConnection,
    shared_memory: MmapMut,
}

impl SandboxedPlugin {
    pub fn process_block(&mut self, input: &[f32], output: &mut [f32]) {
        self.shared_memory.write_input(input);
        self.ipc_channel.send(IpcSignal::ProcessBlock);
        // Wait for signal from sandboxed process
        self.ipc_channel.wait_for_signal(IpcSignal::ProcessComplete);
        self.shared_memory.read_output(output);
    }
}

pub fn configure_realtime_thread() {
    // 1. Lock memory pages against swap
    #[cfg(target_os = "linux")]
    unsafe {
        libc::mlockall(libc::MCL_CURRENT | libc::MCL_FUTURE);
    }

    // 2. Configure MXCSR register (FTZ + DAZ)
    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    unsafe {
        use std::arch::x86_64::*;
        let mxcsr = _mm_getcsr();
        _mm_setcsr(mxcsr | 0x8040);
    }
}