79f9ff1596
E2E crypto handshake: - Client/relay handshake via SignalMessage (CallOffer/CallAnswer) - X25519 ephemeral key exchange with Ed25519 identity signatures - Integration tests proving bidirectional encrypt/decrypt Codec2 integration: - Pure Rust codec2 crate (v0.3) — no C bindings needed - MODE_3200 (160 samples/20ms, 8 bytes) and MODE_1200 (320 samples/40ms, 6 bytes) - 11 new tests including encode/decode roundtrip and adaptive switching Relay forwarding: - Bidirectional client → remote forwarding with pipeline processing - CLI args: --listen, --remote - Periodic stats logging, clean shutdown via tokio::select! Benchmark tool (wzp-bench): - Codec roundtrip, FEC recovery, crypto throughput, full pipeline benchmarks - Sine wave PCM generator for realistic testing Audio I/O (cpal): - AudioCapture (microphone) and AudioPlayback (speakers) at 48kHz mono - CLI --live mode: mic → encode → send / recv → decode → speakers 120 tests passing, 0 failures. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
342 lines
13 KiB
Rust
342 lines
13 KiB
Rust
//! Real audio I/O via `cpal` — microphone capture and speaker playback.
|
|
//!
|
|
//! Both structs use 48 kHz, mono, i16 format to match the WarzonePhone codec
|
|
//! pipeline. Frames are 960 samples (20 ms at 48 kHz).
|
|
//!
|
|
//! The cpal `Stream` type is not `Send`, so each struct spawns a dedicated OS
|
|
//! thread that owns the stream. The public API exposes only `Send + Sync`
|
|
//! channel handles.
|
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::mpsc;
|
|
use std::sync::Arc;
|
|
|
|
use anyhow::{anyhow, Context};
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
use cpal::{SampleFormat, SampleRate, StreamConfig};
|
|
use tracing::{info, warn};
|
|
|
|
/// Number of samples per 20 ms frame at 48 kHz mono.
|
|
pub const FRAME_SAMPLES: usize = 960;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// AudioCapture
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Captures microphone input and yields 960-sample PCM frames.
|
|
///
|
|
/// The cpal stream lives on a dedicated OS thread; this handle is `Send + Sync`.
|
|
pub struct AudioCapture {
|
|
rx: mpsc::Receiver<Vec<i16>>,
|
|
running: Arc<AtomicBool>,
|
|
}
|
|
|
|
impl AudioCapture {
|
|
/// Create and start capturing from the default input device at 48 kHz mono.
|
|
pub fn start() -> Result<Self, anyhow::Error> {
|
|
let (tx, rx) = mpsc::sync_channel::<Vec<i16>>(64);
|
|
let running = Arc::new(AtomicBool::new(true));
|
|
let running_clone = running.clone();
|
|
|
|
let (init_tx, init_rx) = mpsc::sync_channel::<Result<(), String>>(1);
|
|
|
|
std::thread::Builder::new()
|
|
.name("wzp-audio-capture".into())
|
|
.spawn(move || {
|
|
let result = (|| -> Result<(), anyhow::Error> {
|
|
let host = cpal::default_host();
|
|
let device = host
|
|
.default_input_device()
|
|
.ok_or_else(|| anyhow!("no default input audio device found"))?;
|
|
|
|
info!(device = %device.name().unwrap_or_default(), "using input device");
|
|
|
|
let config = StreamConfig {
|
|
channels: 1,
|
|
sample_rate: SampleRate(48_000),
|
|
buffer_size: cpal::BufferSize::Default,
|
|
};
|
|
|
|
let use_f32 = !supports_i16_input(&device)?;
|
|
|
|
let buf = Arc::new(std::sync::Mutex::new(
|
|
Vec::<i16>::with_capacity(FRAME_SAMPLES),
|
|
));
|
|
let err_cb = |e: cpal::StreamError| {
|
|
warn!("input stream error: {e}");
|
|
};
|
|
|
|
let stream = if use_f32 {
|
|
let buf = buf.clone();
|
|
let tx = tx.clone();
|
|
let running = running_clone.clone();
|
|
device.build_input_stream(
|
|
&config,
|
|
move |data: &[f32], _: &cpal::InputCallbackInfo| {
|
|
if !running.load(Ordering::Relaxed) {
|
|
return;
|
|
}
|
|
let mut lock = buf.lock().unwrap();
|
|
for &s in data {
|
|
lock.push(f32_to_i16(s));
|
|
if lock.len() == FRAME_SAMPLES {
|
|
let frame = lock.drain(..).collect();
|
|
let _ = tx.try_send(frame);
|
|
}
|
|
}
|
|
},
|
|
err_cb,
|
|
None,
|
|
)?
|
|
} else {
|
|
let buf = buf.clone();
|
|
let tx = tx.clone();
|
|
let running = running_clone.clone();
|
|
device.build_input_stream(
|
|
&config,
|
|
move |data: &[i16], _: &cpal::InputCallbackInfo| {
|
|
if !running.load(Ordering::Relaxed) {
|
|
return;
|
|
}
|
|
let mut lock = buf.lock().unwrap();
|
|
for &s in data {
|
|
lock.push(s);
|
|
if lock.len() == FRAME_SAMPLES {
|
|
let frame = lock.drain(..).collect();
|
|
let _ = tx.try_send(frame);
|
|
}
|
|
}
|
|
},
|
|
err_cb,
|
|
None,
|
|
)?
|
|
};
|
|
|
|
stream.play().context("failed to start input stream")?;
|
|
|
|
// Signal success to the caller before parking.
|
|
let _ = init_tx.send(Ok(()));
|
|
|
|
// Keep stream alive until stopped.
|
|
while running_clone.load(Ordering::Relaxed) {
|
|
std::thread::park_timeout(std::time::Duration::from_millis(200));
|
|
}
|
|
drop(stream);
|
|
Ok(())
|
|
})();
|
|
|
|
if let Err(e) = result {
|
|
let _ = init_tx.send(Err(e.to_string()));
|
|
}
|
|
})?;
|
|
|
|
init_rx
|
|
.recv()
|
|
.map_err(|_| anyhow!("capture thread exited before signaling"))?
|
|
.map_err(|e| anyhow!("{e}"))?;
|
|
|
|
Ok(Self { rx, running })
|
|
}
|
|
|
|
/// Read the next frame of 960 PCM samples (blocking until available).
|
|
///
|
|
/// Returns `None` when the stream has been stopped or the channel is
|
|
/// disconnected.
|
|
pub fn read_frame(&self) -> Option<Vec<i16>> {
|
|
self.rx.recv().ok()
|
|
}
|
|
|
|
/// Stop capturing.
|
|
pub fn stop(&self) {
|
|
self.running.store(false, Ordering::Relaxed);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// AudioPlayback
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Plays PCM frames through the default output device at 48 kHz mono.
|
|
///
|
|
/// The cpal stream lives on a dedicated OS thread; this handle is `Send + Sync`.
|
|
pub struct AudioPlayback {
|
|
tx: mpsc::SyncSender<Vec<i16>>,
|
|
running: Arc<AtomicBool>,
|
|
}
|
|
|
|
impl AudioPlayback {
|
|
/// Create and start playback on the default output device at 48 kHz mono.
|
|
pub fn start() -> Result<Self, anyhow::Error> {
|
|
let (tx, rx) = mpsc::sync_channel::<Vec<i16>>(64);
|
|
let running = Arc::new(AtomicBool::new(true));
|
|
let running_clone = running.clone();
|
|
|
|
let (init_tx, init_rx) = mpsc::sync_channel::<Result<(), String>>(1);
|
|
|
|
std::thread::Builder::new()
|
|
.name("wzp-audio-playback".into())
|
|
.spawn(move || {
|
|
let result = (|| -> Result<(), anyhow::Error> {
|
|
let host = cpal::default_host();
|
|
let device = host
|
|
.default_output_device()
|
|
.ok_or_else(|| anyhow!("no default output audio device found"))?;
|
|
|
|
info!(device = %device.name().unwrap_or_default(), "using output device");
|
|
|
|
let config = StreamConfig {
|
|
channels: 1,
|
|
sample_rate: SampleRate(48_000),
|
|
buffer_size: cpal::BufferSize::Default,
|
|
};
|
|
|
|
let use_f32 = !supports_i16_output(&device)?;
|
|
|
|
// Shared ring of samples the cpal callback drains from.
|
|
let ring = Arc::new(std::sync::Mutex::new(
|
|
std::collections::VecDeque::<i16>::with_capacity(FRAME_SAMPLES * 8),
|
|
));
|
|
|
|
// Background drainer: moves frames from the mpsc channel into the ring.
|
|
{
|
|
let ring = ring.clone();
|
|
let running = running_clone.clone();
|
|
std::thread::Builder::new()
|
|
.name("wzp-playback-drain".into())
|
|
.spawn(move || {
|
|
while running.load(Ordering::Relaxed) {
|
|
match rx.recv_timeout(std::time::Duration::from_millis(100)) {
|
|
Ok(frame) => {
|
|
let mut lock = ring.lock().unwrap();
|
|
lock.extend(frame);
|
|
while lock.len() > FRAME_SAMPLES * 16 {
|
|
lock.pop_front();
|
|
}
|
|
}
|
|
Err(mpsc::RecvTimeoutError::Timeout) => {}
|
|
Err(mpsc::RecvTimeoutError::Disconnected) => break,
|
|
}
|
|
}
|
|
})?;
|
|
}
|
|
|
|
let err_cb = |e: cpal::StreamError| {
|
|
warn!("output stream error: {e}");
|
|
};
|
|
|
|
let stream = if use_f32 {
|
|
let ring = ring.clone();
|
|
device.build_output_stream(
|
|
&config,
|
|
move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
|
|
let mut lock = ring.lock().unwrap();
|
|
for sample in data.iter_mut() {
|
|
*sample = match lock.pop_front() {
|
|
Some(s) => i16_to_f32(s),
|
|
None => 0.0,
|
|
};
|
|
}
|
|
},
|
|
err_cb,
|
|
None,
|
|
)?
|
|
} else {
|
|
let ring = ring.clone();
|
|
device.build_output_stream(
|
|
&config,
|
|
move |data: &mut [i16], _: &cpal::OutputCallbackInfo| {
|
|
let mut lock = ring.lock().unwrap();
|
|
for sample in data.iter_mut() {
|
|
*sample = lock.pop_front().unwrap_or(0);
|
|
}
|
|
},
|
|
err_cb,
|
|
None,
|
|
)?
|
|
};
|
|
|
|
stream.play().context("failed to start output stream")?;
|
|
|
|
// Signal success to the caller before parking.
|
|
let _ = init_tx.send(Ok(()));
|
|
|
|
// Keep stream alive until stopped.
|
|
while running_clone.load(Ordering::Relaxed) {
|
|
std::thread::park_timeout(std::time::Duration::from_millis(200));
|
|
}
|
|
drop(stream);
|
|
Ok(())
|
|
})();
|
|
|
|
if let Err(e) = result {
|
|
let _ = init_tx.send(Err(e.to_string()));
|
|
}
|
|
})?;
|
|
|
|
init_rx
|
|
.recv()
|
|
.map_err(|_| anyhow!("playback thread exited before signaling"))?
|
|
.map_err(|e| anyhow!("{e}"))?;
|
|
|
|
Ok(Self { tx, running })
|
|
}
|
|
|
|
/// Write a frame of PCM samples for playback.
|
|
pub fn write_frame(&self, pcm: &[i16]) {
|
|
let _ = self.tx.try_send(pcm.to_vec());
|
|
}
|
|
|
|
/// Stop playback.
|
|
pub fn stop(&self) {
|
|
self.running.store(false, Ordering::Relaxed);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Check if the input device supports i16 at 48 kHz mono.
|
|
fn supports_i16_input(device: &cpal::Device) -> Result<bool, anyhow::Error> {
|
|
let supported = device
|
|
.supported_input_configs()
|
|
.context("failed to query input configs")?;
|
|
for cfg in supported {
|
|
if cfg.sample_format() == SampleFormat::I16
|
|
&& cfg.min_sample_rate() <= SampleRate(48_000)
|
|
&& cfg.max_sample_rate() >= SampleRate(48_000)
|
|
&& cfg.channels() >= 1
|
|
{
|
|
return Ok(true);
|
|
}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
/// Check if the output device supports i16 at 48 kHz mono.
|
|
fn supports_i16_output(device: &cpal::Device) -> Result<bool, anyhow::Error> {
|
|
let supported = device
|
|
.supported_output_configs()
|
|
.context("failed to query output configs")?;
|
|
for cfg in supported {
|
|
if cfg.sample_format() == SampleFormat::I16
|
|
&& cfg.min_sample_rate() <= SampleRate(48_000)
|
|
&& cfg.max_sample_rate() >= SampleRate(48_000)
|
|
&& cfg.channels() >= 1
|
|
{
|
|
return Ok(true);
|
|
}
|
|
}
|
|
Ok(false)
|
|
}
|
|
|
|
#[inline]
|
|
fn f32_to_i16(s: f32) -> i16 {
|
|
(s.clamp(-1.0, 1.0) * i16::MAX as f32) as i16
|
|
}
|
|
|
|
#[inline]
|
|
fn i16_to_f32(s: i16) -> f32 {
|
|
s as f32 / i16::MAX as f32
|
|
}
|