Lightweight coding agent that runs in your terminal
Rust
Connect voice-host RTP audio to speaker playback (#43248)
Benjamin Carlssona9896da3febc
diff --git a/MODULE.bazel.lock b/MODULE.bazel.lockindex fe0127ec16..e3aa8731ba 100644--- a/MODULE.bazel.lock+++ b/MODULE.bazel.lock@@ -1158,6 +1158,8 @@"gobject-sys_0.22.6": "{\"dependencies\":[{\"name\":\"glib-sys\",\"req\":\"^0.22.0\"},{\"name\":\"libc\",\"req\":\"^0.2\"},{\"kind\":\"dev\",\"name\":\"shell-words\",\"req\":\"^1.0.0\"},{\"kind\":\"build\",\"name\":\"system-deps\",\"req\":\"^7\"},{\"kind\":\"dev\",\"name\":\"tempfile\",\"req\":\"^3\"}],\"features\":{\"v2_58\":[],\"v2_62\":[\"v2_58\"],\"v2_66\":[\"v2_62\"],\"v2_68\":[\"v2_66\"],\"v2_70\":[\"v2_68\"],\"v2_72\":[\"v2_70\"],\"v2_74\":[\"v2_72\"],\"v2_76\":[\"v2_74\"],\"v2_78\":[\"v2_74\"],\"v2_80\":[\"v2_78\"],\"v2_82\":[\"v2_80\"],\"v2_84\":[\"v2_82\"],\"v2_86\":[\"v2_84\"]}}","goblin_0.10.5": "{\"dependencies\":[{\"default_features\":false,\"name\":\"log\",\"optional\":true,\"req\":\"^0.4\"},{\"name\":\"plain\",\"req\":\"^0.2.3\"},{\"default_features\":false,\"name\":\"scroll\",\"req\":\"^0.13\"},{\"kind\":\"dev\",\"name\":\"stderrlog\",\"req\":\"^0.6.0\"}],\"features\":{\"alloc\":[\"scroll/derive\",\"log\"],\"archive\":[\"alloc\"],\"default\":[\"std\",\"elf32\",\"elf64\",\"mach32\",\"mach64\",\"pe32\",\"pe64\",\"te\",\"archive\",\"endian_fd\"],\"elf32\":[],\"elf64\":[],\"endian_fd\":[\"alloc\"],\"mach32\":[\"alloc\",\"endian_fd\",\"archive\"],\"mach64\":[\"alloc\",\"endian_fd\",\"archive\"],\"pe32\":[\"alloc\",\"endian_fd\"],\"pe64\":[\"alloc\",\"endian_fd\"],\"std\":[\"alloc\",\"scroll/std\"],\"te\":[\"alloc\",\"endian_fd\"]}}","group_0.13.0": "{\"dependencies\":[{\"default_features\":false,\"name\":\"ff\",\"req\":\"^0.13\"},{\"name\":\"memuse\",\"optional\":true,\"req\":\"^0.2\"},{\"default_features\":false,\"name\":\"rand\",\"optional\":true,\"req\":\"^0.8\"},{\"default_features\":false,\"name\":\"rand_core\",\"req\":\"^0.6\"},{\"name\":\"rand_xorshift\",\"optional\":true,\"req\":\"^0.3\"},{\"default_features\":false,\"name\":\"subtle\",\"req\":\"^2.2.1\"}],\"features\":{\"alloc\":[],\"default\":[\"alloc\"],\"tests\":[\"alloc\",\"rand\",\"rand_xorshift\"],\"wnaf-memuse\":[\"alloc\",\"memuse\"]}}",+ "gstreamer-app-sys_0.25.0": "{\"dependencies\":[{\"name\":\"glib-sys\",\"req\":\"^0.22.0\"},{\"name\":\"gstreamer-base-sys\",\"req\":\"^0.25.0\"},{\"name\":\"gstreamer-sys\",\"req\":\"^0.25.0\"},{\"name\":\"libc\",\"req\":\"^0.2\"},{\"kind\":\"dev\",\"name\":\"shell-words\",\"req\":\"^1.0.0\"},{\"kind\":\"build\",\"name\":\"system-deps\",\"req\":\"^7\"},{\"kind\":\"dev\",\"name\":\"tempfile\",\"req\":\"^3\"}],\"features\":{\"v1_16\":[],\"v1_18\":[\"v1_16\"],\"v1_20\":[\"v1_18\"],\"v1_22\":[\"v1_20\"],\"v1_24\":[\"v1_22\"],\"v1_26\":[\"v1_24\"],\"v1_28\":[\"v1_26\"],\"v1_30\":[\"v1_28\"]}}",+ "gstreamer-app_0.25.2": "{\"dependencies\":[{\"name\":\"futures-core\",\"req\":\"^0.3\"},{\"kind\":\"dev\",\"name\":\"futures-executor\",\"req\":\"^0.3\"},{\"name\":\"futures-sink\",\"req\":\"^0.3\"},{\"features\":[\"sink\"],\"kind\":\"dev\",\"name\":\"futures-util\",\"req\":\"^0.3\"},{\"kind\":\"dev\",\"name\":\"gir-format-check\",\"req\":\"^0.1\"},{\"name\":\"glib\",\"req\":\"^0.22.0\"},{\"name\":\"gst\",\"package\":\"gstreamer\",\"req\":\"^0.25.0\"},{\"name\":\"gst-base\",\"package\":\"gstreamer-base\",\"req\":\"^0.25.0\"},{\"name\":\"gstreamer-app-sys\",\"req\":\"^0.25.0\"},{\"name\":\"libc\",\"req\":\"^0.2\"}],\"features\":{\"default\":[],\"v1_16\":[\"gst/v1_16\",\"gst-base/v1_16\",\"gstreamer-app-sys/v1_16\"],\"v1_18\":[\"gst/v1_18\",\"gst-base/v1_18\",\"gstreamer-app-sys/v1_18\",\"v1_16\"],\"v1_20\":[\"gst/v1_20\",\"gst-base/v1_20\",\"gstreamer-app-sys/v1_20\",\"v1_18\"],\"v1_22\":[\"gst/v1_22\",\"gst-base/v1_22\",\"gstreamer-app-sys/v1_22\",\"v1_20\"],\"v1_24\":[\"gst/v1_24\",\"gst-base/v1_24\",\"gstreamer-app-sys/v1_24\",\"v1_22\"],\"v1_26\":[\"gst/v1_26\",\"gst-base/v1_26\",\"gstreamer-app-sys/v1_26\",\"v1_24\"],\"v1_28\":[\"gst/v1_28\",\"gst-base/v1_28\",\"gstreamer-app-sys/v1_28\",\"v1_26\"],\"v1_30\":[\"gst/v1_30\",\"gst-base/v1_30\",\"gstreamer-app-sys/v1_30\",\"v1_28\"]}}","gstreamer-audio-sys_0.25.3": "{\"dependencies\":[{\"name\":\"glib-sys\",\"req\":\"^0.22.0\"},{\"name\":\"gobject-sys\",\"req\":\"^0.22.0\"},{\"name\":\"gstreamer-base-sys\",\"req\":\"^0.25.0\"},{\"name\":\"gstreamer-sys\",\"req\":\"^0.25.0\"},{\"name\":\"libc\",\"req\":\"^0.2\"},{\"kind\":\"dev\",\"name\":\"shell-words\",\"req\":\"^1.0.0\"},{\"kind\":\"build\",\"name\":\"system-deps\",\"req\":\"^7\"},{\"kind\":\"dev\",\"name\":\"tempfile\",\"req\":\"^3\"}],\"features\":{\"v1_16\":[],\"v1_18\":[\"v1_16\"],\"v1_20\":[\"v1_18\"],\"v1_22\":[\"v1_20\"],\"v1_24\":[\"v1_22\"],\"v1_26\":[\"v1_24\"],\"v1_28\":[\"v1_26\"],\"v1_30\":[\"v1_28\"]}}","gstreamer-audio_0.25.3": "{\"dependencies\":[{\"kind\":\"dev\",\"name\":\"byte-slice-cast\",\"req\":\"^1.0\"},{\"name\":\"cfg-if\",\"req\":\"^1.0\"},{\"kind\":\"dev\",\"name\":\"gir-format-check\",\"req\":\"^0.1\"},{\"name\":\"glib\",\"req\":\"^0.22.0\"},{\"name\":\"gst\",\"package\":\"gstreamer\",\"req\":\"^0.25.0\"},{\"name\":\"gst-base\",\"package\":\"gstreamer-base\",\"req\":\"^0.25.0\"},{\"name\":\"gstreamer-audio-sys\",\"req\":\"^0.25.0\"},{\"kind\":\"dev\",\"name\":\"itertools\",\"req\":\"^0.15\"},{\"name\":\"libc\",\"req\":\"^0.2\"},{\"name\":\"serde\",\"optional\":true,\"req\":\"^1.0\"},{\"kind\":\"dev\",\"name\":\"serde_json\",\"req\":\"^1.0\"},{\"name\":\"smallvec\",\"req\":\"^1.0\"}],\"features\":{\"default\":[],\"serde\":[\"dep:serde\",\"gst/serde\"],\"v1_16\":[\"gst/v1_16\",\"gst-base/v1_16\",\"gstreamer-audio-sys/v1_16\"],\"v1_18\":[\"gst/v1_18\",\"gst-base/v1_18\",\"gstreamer-audio-sys/v1_18\",\"v1_16\"],\"v1_20\":[\"gst/v1_20\",\"gst-base/v1_20\",\"gstreamer-audio-sys/v1_20\",\"v1_18\"],\"v1_22\":[\"gst/v1_22\",\"gst-base/v1_22\",\"gstreamer-audio-sys/v1_22\",\"v1_20\"],\"v1_24\":[\"gst/v1_24\",\"gst-base/v1_24\",\"gstreamer-audio-sys/v1_24\",\"v1_22\"],\"v1_26\":[\"gst/v1_26\",\"gst-base/v1_26\",\"gstreamer-audio-sys/v1_26\",\"v1_24\"],\"v1_28\":[\"gst/v1_28\",\"gst-base/v1_28\",\"gstreamer-audio-sys/v1_28\",\"v1_26\"],\"v1_30\":[\"gst/v1_30\",\"gst-base/v1_30\",\"gstreamer-audio-sys/v1_30\",\"v1_28\"]}}","gstreamer-base-sys_0.25.3": "{\"dependencies\":[{\"name\":\"glib-sys\",\"req\":\"^0.22.0\"},{\"name\":\"gobject-sys\",\"req\":\"^0.22.0\"},{\"name\":\"gstreamer-sys\",\"req\":\"^0.25.0\"},{\"name\":\"libc\",\"req\":\"^0.2\"},{\"kind\":\"dev\",\"name\":\"shell-words\",\"req\":\"^1.0.0\"},{\"kind\":\"build\",\"name\":\"system-deps\",\"req\":\"^7\"},{\"kind\":\"dev\",\"name\":\"tempfile\",\"req\":\"^3\"}],\"features\":{\"v1_14_1\":[],\"v1_14_3\":[\"v1_14_1\"],\"v1_16\":[\"v1_14_3\"],\"v1_18\":[\"v1_16\"],\"v1_20\":[\"v1_18\"],\"v1_22\":[\"v1_20\"],\"v1_24\":[\"v1_22\"],\"v1_26\":[\"v1_24\"],\"v1_28\":[\"v1_26\"],\"v1_30\":[\"v1_28\"]}}",diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex c485a3997e..464d3f1f29 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -5050,6 +5050,7 @@ dependencies = ["crossbeam-queue","futures","gstreamer",+ "gstreamer-app","gstreamer-audio","libloading","opus",@@ -8236,6 +8237,34 @@ dependencies = ["thiserror 2.0.18",]+[[package]]+name = "gstreamer-app"+version = "0.25.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "97f8ae9238c2352398dcc084de28df3f7099af216ac6c160b52318d23f25c010"+dependencies = [+ "futures-core",+ "futures-sink",+ "glib",+ "gstreamer",+ "gstreamer-app-sys",+ "gstreamer-base",+ "libc",+]++[[package]]+name = "gstreamer-app-sys"+version = "0.25.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7a74a8211e5d7df2f45b612c284ddf56b92bdf4e879e8ed72e7c46dd0842e158"+dependencies = [+ "glib-sys",+ "gstreamer-base-sys",+ "gstreamer-sys",+ "libc",+ "system-deps",+]+[[package]]name = "gstreamer-audio"version = "0.25.3"diff --git a/codex-rs/voice-host/BUILD.bazel b/codex-rs/voice-host/BUILD.bazelindex ad24a4a1bf..3cdb23f758 100644--- a/codex-rs/voice-host/BUILD.bazel+++ b/codex-rs/voice-host/BUILD.bazel@@ -4,4 +4,5 @@ codex_rust_crate(name = "voice-host",crate_name = "codex_voice_host",crate_srcs = [],+ unit_test_args = ["--test-threads=1"],)diff --git a/codex-rs/voice-host/Cargo.toml b/codex-rs/voice-host/Cargo.tomlindex 9cebfef44d..6ce04e3de9 100644--- a/codex-rs/voice-host/Cargo.toml+++ b/codex-rs/voice-host/Cargo.toml@@ -32,6 +32,7 @@ webrtc = "=0.20.3"cpal = "=0.18.2"crossbeam-queue = "0.3.12"gstreamer = { version = "=0.25.3", features = ["v1_28"] }+gstreamer-app = { version = "=0.25.2", features = ["v1_28"] }gstreamer-audio = { version = "=0.25.3", features = ["v1_28"] }opus = "=0.4.0"rubato = { version = "=5.0.0", default-features = false }diff --git a/codex-rs/voice-host/src/audio_sink.rs b/codex-rs/voice-host/src/audio_sink.rsindex 6d43fdc081..0d466ac9f7 100644--- a/codex-rs/voice-host/src/audio_sink.rs+++ b/codex-rs/voice-host/src/audio_sink.rs@@ -2,6 +2,7 @@//! Native resets outside an owner-initiated teardown fail the session closed.use super::playback::PlaybackWriter;+use audio::prelude::*;use audio::subclass::prelude::*;use gst::glib;use gstreamer as gst;@@ -13,6 +14,8 @@ mod imp {#[derive(Default)]pub struct Sink {pub(super) writer: OnceLock<PlaybackWriter>,+ #[cfg(test)]+ first_event: OnceLock<&'static str>,}#[glib::object_subclass]impl ObjectSubclass for Sink {@@ -89,7 +92,12 @@ mod imp {.writer.get().ok_or_else(|| gst::loggable_error!(gst::CAT_RUST, "speaker not bound"))?;- writer.write(bytes).map(|n| n as i32).map_err(|_| {+ writer.write(bytes).map(|n| n as i32).map_err(|_error| {+ #[cfg(test)]+ self.first_event.get_or_init(|| {+ eprintln!("native sink first event: {_error}");+ _error+ });writer.fail_if_current();gst::loggable_error!(gst::CAT_RUST, "speaker write failed")})@@ -99,6 +107,11 @@ mod imp {}fn reset(&self) {if let Some(writer) = self.writer.get() {+ #[cfg(test)]+ self.first_event.get_or_init(|| {+ eprintln!("native sink first event: reset");+ "reset"+ });writer.fail_if_current();}}@@ -108,3 +121,15 @@ mod imp {glib::wrapper! {pub struct Sink(ObjectSubclass<imp::Sink>) @extends audio::AudioSink, audio::AudioBaseSink, audio::gst_base::BaseSink, gst::Element, gst::Object;}++impl Sink {+ pub(super) fn new(writer: PlaybackWriter) -> Self {+ let sink: Self = glib::Object::new();+ assert!(sink.imp().writer.set(writer).is_ok());+ sink.set_provide_clock(false);+ sink.set_property_from_str("slave-method", "resample");+ sink.set_async(false);+ sink.set_enable_last_sample(false);+ sink+ }+}diff --git a/codex-rs/voice-host/src/capture_worker.rs b/codex-rs/voice-host/src/capture_worker.rsindex afef3891e9..c97ab53f33 100644--- a/codex-rs/voice-host/src/capture_worker.rs+++ b/codex-rs/voice-host/src/capture_worker.rs@@ -23,13 +23,16 @@ impl CaptureWorker {&mut self,controls: codex_realtime_webrtc::AudioControls,) -> io::Result<()> {+ // Retire the old sink before rebuilding microphone processing.+ self.buffers+ .set_speaker_disabled(controls.speaker_suppressed)?;let previous = self.buffers.microphone.load(Ordering::Acquire);Buffers::set_disabled(&self.buffers.microphone, controls.microphone_muted)?;if previous != self.buffers.microphone.load(Ordering::Acquire) {self.pending.clear();self.processor.reset().map_err(io::Error::other)?;}- Buffers::set_disabled(&self.buffers.speaker, controls.speaker_suppressed)+ Ok(())}pub(super) async fn service(diff --git a/codex-rs/voice-host/src/capture_worker_tests.rs b/codex-rs/voice-host/src/capture_worker_tests.rsindex 61b55882ac..ef18870307 100644--- a/codex-rs/voice-host/src/capture_worker_tests.rs+++ b/codex-rs/voice-host/src/capture_worker_tests.rs@@ -81,6 +81,67 @@ fn enqueue(worker: &CaptureWorker, samples: usize, generation: u64, at: Instant)}}+#[test]+fn combined_mute_and_suppression_cancel_old_speaker_and_capture_work() {+ let buffers = Arc::new(Buffers::new(+ /*input_rate*/ 48_000, /*output_rate*/ 48_000,+ ));+ let port = super::super::playback::PlaybackPort::new(buffers.clone(), /*rate*/ 48_000);+ let mut worker = CaptureWorker {+ buffers: buffers.clone(),+ processor: processing::Processor::new(+ /*input_rate*/ 48_000, /*output_rate*/ 48_000,+ )+ .unwrap(),+ pending: VecDeque::new(),+ };+ worker+ .set_controls(AudioControls {+ microphone_muted: false,+ speaker_suppressed: false,+ })+ .unwrap();+ worker.pending.push_back(crate::audio_track::EncodedAudio {+ data: vec![1],+ at: Instant::now(),+ });+ // A failed speaker transition must not start microphone reset first.+ buffers.speaker.store(u64::MAX, Ordering::Release);+ assert!(+ worker+ .set_controls(AudioControls {+ microphone_muted: true,+ speaker_suppressed: false,+ })+ .is_err()+ );+ assert_eq!(+ (+ buffers.speaker.load(Ordering::Acquire),+ buffers.microphone.load(Ordering::Acquire),+ worker.pending.len(),+ ),+ (u64::MAX, 2, 1)+ );+ buffers.speaker.store(/*val*/ 2, Ordering::Release);+ let writer = port.writer();+ worker+ .set_controls(AudioControls {+ microphone_muted: true,+ speaker_suppressed: true,+ })+ .unwrap();+ assert_eq!(+ (+ buffers.speaker.load(Ordering::Acquire),+ buffers.microphone.load(Ordering::Acquire),+ worker.pending.len(),+ writer.write(&[0; 4]),+ ),+ (3, 3, 0, Err("speaker writer cancelled"))+ );+}+async fn receive_capture(worker: &mut CaptureWorker,local: &mut Transport,diff --git a/codex-rs/voice-host/src/device_buffers.rs b/codex-rs/voice-host/src/device_buffers.rsindex b65b1cedc4..0609d9dbae 100644--- a/codex-rs/voice-host/src/device_buffers.rs+++ b/codex-rs/voice-host/src/device_buffers.rs@@ -3,6 +3,8 @@//! Generation changes, rejected capture buffers and capture gaps discard incomplete frames.//! Capture/render capacity covers the worker deadline; playback and callback limits stay fixed.+use std::sync::Mutex;+use std::sync::PoisonError;use std::sync::atomic::AtomicBool;use std::sync::atomic::AtomicU16;use std::sync::atomic::AtomicU32;@@ -93,6 +95,7 @@ pub(super) struct Buffers {pub(super) playback: ArrayQueue<Frame>,pub(super) microphone: AtomicU64,pub(super) speaker: AtomicU64,+ pub(super) speaker_failure_gate: Mutex<()>,pub(super) serviced: AtomicBool,pub(super) failed: AtomicBool,pub(super) microphone_peak: AtomicU16,@@ -100,6 +103,7 @@ pub(super) struct Buffers {pub(super) queued: AtomicU32,pub(super) last_dac_ns: AtomicU64,pub(super) clock: Instant,+ pub(super) callback_sequence: AtomicU64,}impl Buffers {@@ -129,6 +133,7 @@ impl Buffers {playback: ArrayQueue::new(QUEUE_CAPACITY),microphone: AtomicU64::new(/*v*/ 1),speaker: AtomicU64::new(/*v*/ 1),+ speaker_failure_gate: Mutex::new(()),serviced: AtomicBool::new(false),failed: AtomicBool::new(false),microphone_peak: AtomicU16::new(/*v*/ 0),@@ -136,6 +141,7 @@ impl Buffers {queued: AtomicU32::new(/*v*/ 0),last_dac_ns: AtomicU64::new(/*v*/ 0),clock: Instant::now(),+ callback_sequence: AtomicU64::new(/*v*/ 0),}}@@ -147,6 +153,14 @@ impl Buffers {})}+ pub(super) fn set_speaker_disabled(&self, disabled: bool) -> std::io::Result<()> {+ let _transition = self+ .speaker_failure_gate+ .lock()+ .unwrap_or_else(PoisonError::into_inner);+ Self::set_disabled(&self.speaker, disabled)+ }+// One control worker writes each epoch. Odd epochs are disabled; every// transition advances the epoch so disable/re-enable cannot replay old audio.pub(super) fn set_disabled(epoch: &AtomicU64, disabled: bool) -> std::io::Result<()> {diff --git a/codex-rs/voice-host/src/devices.rs b/codex-rs/voice-host/src/devices.rsindex ff5a09055c..5fcaab5232 100644--- a/codex-rs/voice-host/src/devices.rs+++ b/codex-rs/voice-host/src/devices.rs@@ -11,6 +11,8 @@ mod buffers;mod capture_worker;#[path = "playback.rs"]mod playback;+#[path = "playout.rs"]+mod playout;#[path = "processing.rs"]mod processing;@@ -48,6 +50,7 @@ pub(super) struct Devices {output_config: cpal::SupportedStreamConfig,output_stream_config: cpal::StreamConfig,playback: PlaybackPort,+ playout: Option<playout::Playout>,worker: capture_worker::CaptureWorker,}@@ -144,6 +147,7 @@ impl Devices {output_config,output_stream_config,playback,+ playout: None,worker: capture_worker::CaptureWorker {buffers,processor,@@ -160,19 +164,28 @@ impl Devices {let previous = buffers.speaker.load(Ordering::Acquire);self.worker.set_controls(controls)?;if previous != buffers.speaker.load(Ordering::Acquire) {- // Invalidate writers first, then wait off the callback for any in-flight write.- let _producer = self+ // Stop callbacks before native teardown can block the worker.+ drop(self.output.take());+ drop(self.playout.take());+ // The new epoch cancelled writers before either teardown; wait for+ // any in-flight write before resetting its queue.+ let producer = self.playback.0.producer.lock().map_err(|_| io::Error::other("speaker writer failed"))?;- // Dropping the stream stops its callbacks and discards device-owned audio.- drop(self.output.take());while buffers.playback.pop().is_some() {}while buffers.rendered.pop().is_some() {}buffers.queued.store(/*val*/ 0, Ordering::Release);buffers.last_dac_ns.store(/*val*/ 0, Ordering::Release);+ drop(producer);+ while buffers.rendered.pop().is_some() {}+ self.worker.processor.reset_render();+ if !controls.speaker_suppressed {+ self.playout =+ Some(playout::Playout::new(self.playback.writer()).map_err(io::Error::other)?);+ }let output = stream!(self.output_config.sample_format(),build_output,@@ -193,15 +206,26 @@ impl Devices {&mut self,audio: &mut crate::audio_track::AudioTrack,) -> io::Result<usize> {+ if let Some(playout) = &self.playout {+ playout.check().map_err(io::Error::other)?;+ }self.worker.service(audio, Instant::now).await}++ pub(super) fn receive(&self, packet: crate::incoming::ReceivedRtp) -> io::Result<()> {+ if let Some(playout) = &self.playout {+ playout.push(packet).map_err(io::Error::other)?;+ }+ Ok(())+ }}impl Drop for Devices {fn drop(&mut self) {self.worker.buffers.failed.store(true, Ordering::Release);- let _producer = self.playback.0.producer.lock().ok();drop(self.output.take());+ drop(self.playout.take());+ let _producer = self.playback.0.producer.lock().ok();}}@@ -340,6 +364,9 @@ wheredevice.build_output_stream(*config,move |data: &mut [T], info: &cpal::OutputCallbackInfo| {+ buffers+ .callback_sequence+ .fetch_add(/*val*/ 1, Ordering::AcqRel);let timestamp = info.timestamp();let start = Instant::now()+ timestamp@@ -347,6 +374,9 @@ where.checked_duration_since(timestamp.callback).unwrap_or_default();render_output(data, channels, rate, start, &buffers, &mut output);+ buffers+ .callback_sequence+ .fetch_add(/*val*/ 1, Ordering::Release);},move |error| handle_stream_error(&failure, error),/*timeout*/ None,diff --git a/codex-rs/voice-host/src/devices_unavailable.rs b/codex-rs/voice-host/src/devices_unavailable.rsindex 24fd94d33a..03af795eb1 100644--- a/codex-rs/voice-host/src/devices_unavailable.rs+++ b/codex-rs/voice-host/src/devices_unavailable.rs@@ -5,6 +5,10 @@ use std::io;pub(super) struct Devices;impl Devices {+ pub(super) fn receive(&self, _: crate::incoming::ReceivedRtp) -> io::Result<()> {+ Self::open().map(|_| ())+ }+pub(super) fn take_state(&self) -> io::Result<codex_realtime_webrtc::AudioState> {Self::open().map(|_| codex_realtime_webrtc::AudioState::default())}diff --git a/codex-rs/voice-host/src/main.rs b/codex-rs/voice-host/src/main.rsindex 580de49418..3fc237eb89 100644--- a/codex-rs/voice-host/src/main.rs+++ b/codex-rs/voice-host/src/main.rs@@ -105,15 +105,19 @@ fn run(let mut answered = false;let mut devices: Option<devices::Devices> = None;loop {- if let Some(peer) = &mut transport {- // The next media stage feeds these owned packets into the jitter/decode pipeline.- while peer.incoming.take().map_err(io::Error::other)?.is_some() {}- }let message = if let Some(devices) = &mut devices {let peer = transport.as_mut().ok_or_else(|| io::Error::other("voice peer not started"))?;wait_for_control(&receiver, || {+ // Bound one pass to the ingress queue capacity so new media+ // cannot indefinitely postpone a waiting privacy control.+ for _ in 0..64 {+ let Some(packet) = peer.incoming.take().map_err(io::Error::other)? else {+ break;+ };+ devices.receive(packet)?;+ }executor.block_on(devices.service(&mut peer.audio))?;Ok(())})?@@ -141,16 +145,23 @@ fn run(Message::DevicesOpened {}}Ok(Message::SetAudioControls { controls }) => {- transport+ let peer = transport.as_ref()- .ok_or_else(|| io::Error::other("voice peer not started"))?- .incoming- .set_suppressed(controls.speaker_suppressed)- .map_err(io::Error::other)?;+ .ok_or_else(|| io::Error::other("voice peer not started"))?;+ if controls.speaker_suppressed {+ peer.incoming+ .set_suppressed(controls.speaker_suppressed)+ .map_err(io::Error::other)?;+ }devices.as_mut().ok_or_else(|| io::Error::other("audio devices not open"))?.set_controls(controls)?;+ if !controls.speaker_suppressed {+ peer.incoming+ .set_suppressed(controls.speaker_suppressed)+ .map_err(io::Error::other)?;+ }Message::AudioControlsApplied {}}Ok(Message::StartTransport {}) if transport.is_none() => {diff --git a/codex-rs/voice-host/src/playback.rs b/codex-rs/voice-host/src/playback.rsindex 618a6bc865..8779c48bff 100644--- a/codex-rs/voice-host/src/playback.rs+++ b/codex-rs/voice-host/src/playback.rs@@ -1,11 +1,14 @@//! Bounded mono F32LE writes for the native sink, never called from a device callback.//! Each writer belongs to one speaker epoch. Reset cancels it before locking the producer.+//! Delay queries retain the last coherent estimate during brief callback contention.use super::buffers::BLOCK;use super::buffers::Buffers;use super::buffers::Frame;use std::sync::Arc;use std::sync::Mutex;+use std::sync::PoisonError;+use std::sync::atomic::AtomicU32;use std::sync::atomic::Ordering;use std::time::Duration;use std::time::Instant;@@ -21,6 +24,7 @@ pub(super) struct PlaybackPort(pub(super) Arc<PlaybackState>);pub(crate) struct PlaybackWriter {state: Arc<PlaybackState>,epoch: u64,+ last_delay: AtomicU32,}impl PlaybackPort {@@ -31,12 +35,25 @@ impl PlaybackPort {rate,}))}++ pub(super) fn writer(&self) -> PlaybackWriter {+ PlaybackWriter {+ state: self.0.clone(),+ epoch: self.0.buffers.speaker.load(Ordering::Acquire),+ last_delay: AtomicU32::new(/*v*/ 0),+ }+ }}impl PlaybackWriter {pub(crate) fn fail_if_current(&self) {- if self.state.buffers.speaker.load(Ordering::Acquire) == self.epoch {- self.state.buffers.failed.store(true, Ordering::Release);+ let buffers = &self.state.buffers;+ let _transition = buffers+ .speaker_failure_gate+ .lock()+ .unwrap_or_else(PoisonError::into_inner);+ if buffers.speaker.load(Ordering::Acquire) == self.epoch {+ buffers.failed.store(true, Ordering::Release);}}@@ -93,19 +110,37 @@ impl PlaybackWriter {pub(crate) fn delay(&self) -> u32 {let buffers = &self.state.buffers;- if buffers.speaker.load(Ordering::Acquire) != self.epoch || self.epoch % 2 == 1 {- return 0;+ let deadline = Instant::now() + Duration::from_millis(/*millis*/ 10);+ loop {+ let sequence = buffers.callback_sequence.load(Ordering::Acquire);+ if buffers.speaker.load(Ordering::Acquire) != self.epoch || self.epoch % 2 == 1 {+ return 0;+ }+ let remaining =+ buffers.last_dac_ns.load(Ordering::Acquire).saturating_sub(+ buffers.clock.elapsed().as_nanos().min(u128::from(u64::MAX)) as u64,+ );+ let hardware =+ (u128::from(remaining) * u128::from(self.state.rate)).div_ceil(1_000_000_000);+ let delay = buffers+ .queued+ .load(Ordering::Acquire)+ .saturating_add(hardware.min(u128::from(u32::MAX)) as u32);+ if sequence.is_multiple_of(2)+ && sequence == buffers.callback_sequence.load(Ordering::Acquire)+ {+ self.last_delay.store(delay, Ordering::Relaxed);+ return delay;+ }+ if Instant::now() >= deadline {+ return if buffers.speaker.load(Ordering::Acquire) == self.epoch {+ self.last_delay.load(Ordering::Relaxed)+ } else {+ 0+ };+ }+ std::thread::yield_now();}- let remaining = buffers- .last_dac_ns- .load(Ordering::Acquire)- .saturating_sub(buffers.clock.elapsed().as_nanos().min(u128::from(u64::MAX)) as u64);- let hardware =- (u128::from(remaining) * u128::from(self.state.rate)).div_ceil(1_000_000_000);- buffers- .queued- .load(Ordering::Acquire)- .saturating_add(hardware.min(u128::from(u32::MAX)) as u32)}}diff --git a/codex-rs/voice-host/src/playback_tests.rs b/codex-rs/voice-host/src/playback_tests.rsindex 6ed06d778f..18d2796ee5 100644--- a/codex-rs/voice-host/src/playback_tests.rs+++ b/codex-rs/voice-host/src/playback_tests.rs@@ -2,15 +2,6 @@ use super::*;use crate::devices::buffers::Playback;use pretty_assertions::assert_eq;-impl PlaybackPort {- pub(super) fn writer(&self) -> PlaybackWriter {- PlaybackWriter {- state: self.0.clone(),- epoch: self.0.buffers.speaker.load(Ordering::Acquire),- }- }-}-fn active(rate: u32) -> (Arc<Buffers>, PlaybackPort, PlaybackWriter) {let buffers = Arc::new(Buffers::new(rate, rate));Buffers::set_disabled(&buffers.speaker, /*disabled*/ false).unwrap();@@ -72,6 +63,65 @@ fn delay_includes_pending_dac_time_but_not_another_generation() {assert_eq!(writer.delay(), 0);}+#[test]+fn retired_sink_failure_cannot_fail_the_next_speaker_epoch() {+ let (buffers, port, writer) = active(/*rate*/ 48_000);+ let transition = buffers.speaker_failure_gate.lock().unwrap();+ let (started, ready) = std::sync::mpsc::sync_channel(/*bound*/ 0);+ let failing = std::thread::spawn(move || {+ started.send(()).unwrap();+ writer.fail_if_current();+ });+ ready.recv().unwrap();+ // Hold the same transition gate while retiring the old writer, then let+ // the pending native failure inspect its now-stale epoch.+ Buffers::set_disabled(&buffers.speaker, /*disabled*/ true).unwrap();+ drop(transition);+ failing.join().unwrap();+ assert!(!buffers.failed.load(Ordering::Acquire));++ buffers.set_speaker_disabled(/*disabled*/ false).unwrap();+ port.writer().fail_if_current();+ assert!(buffers.failed.load(Ordering::Acquire));+}++#[test]+fn delay_contention_preserves_the_last_snapshot_without_failing_the_device() {+ let (buffers, port, writer) = active(/*rate*/ 48000);+ writer.write(&[0; 40]).unwrap();+ assert_eq!(writer.delay(), 10);+ buffers+ .callback_sequence+ .store(/*val*/ 1, Ordering::Release);+ let mut playback = Playback::default();+ let consumed: Vec<_> = (0..10).map(|_| playback.next(&buffers).unwrap()).collect();+ assert_eq!(consumed, vec![0.0; 10]);+ assert_eq!(+ (writer.delay(), buffers.failed.load(Ordering::Acquire)),+ (10, false)+ );+ buffers+ .callback_sequence+ .store(/*val*/ 2, Ordering::Release);+ assert_eq!(writer.delay(), 0);++ writer.write(&[0; 20]).unwrap();+ assert_eq!(writer.delay(), 5);+ buffers+ .callback_sequence+ .store(/*val*/ 3, Ordering::Release);+ Buffers::set_disabled(&buffers.speaker, /*disabled*/ true).unwrap();+ assert_eq!(writer.delay(), 0);+ Buffers::set_disabled(&buffers.speaker, /*disabled*/ false).unwrap();+ assert_eq!(+ (+ port.writer().delay(),+ buffers.failed.load(Ordering::Acquire)+ ),+ (0, false)+ );+}+#[test]fn invalid_samples_and_stalled_consumption_fail_without_growing_the_queue() {let (buffers, _, writer) = active(/*rate*/ 8000);diff --git a/codex-rs/voice-host/src/playout.rs b/codex-rs/voice-host/src/playout.rsnew file mode 100644index 0000000000..60ba3f45bb--- /dev/null+++ b/codex-rs/voice-host/src/playout.rs@@ -0,0 +1,172 @@+//! One explicit RTP jitter/decode pipeline per audible epoch; no autoplugging or device discovery.+//! Owned RTP memory retains ingress permits, and native bus messages never accumulate or escape.++use super::audio_sink::Sink;+use super::playback::PlaybackWriter;+use crate::incoming::ReceivedRtp;+use gst::prelude::*;+use gstreamer as gst;+use std::sync::Arc;+use std::sync::atomic::AtomicBool;+use std::sync::atomic::Ordering;+use std::time::Instant;++pub(super) struct Playout {+ pipeline: gst::Pipeline,+ source: gstreamer_app::AppSrc,+ anchor: (Instant, gst::ClockTime),+ failed: Arc<AtomicBool>,+ latency: Arc<AtomicBool>,+}++impl Playout {+ pub(super) fn new(writer: PlaybackWriter) -> Result<Self, &'static str> {+ gst::init().map_err(|_| "audio runtime initialization failed")?;+ let caps = gst::Caps::builder("audio/x-raw")+ .field("format", "F32LE")+ .field("layout", "interleaved")+ .field("channels", 1i32)+ .field("rate", writer.rate() as i32)+ .build();+ let source = gstreamer_app::AppSrc::builder()+ .is_live(true)+ .format(gst::Format::Time)+ .block(false)+ .max_buffers(64)+ .max_bytes(2 * 1024 * 1024)+ .caps(+ &gst::Caps::builder("application/x-rtp")+ .field("media", "audio")+ .field("encoding-name", "OPUS")+ .field("clock-rate", 48000i32)+ .field("payload", i32::from(crate::audio_track::OPUS_PAYLOAD_TYPE))+ .build(),+ )+ .build();+ let jitter = gst::ElementFactory::make("rtpjitterbuffer")+ .property("latency", 60u32)+ .property_from_str("mode", "slave")+ .property("drop-on-latency", true)+ .property("do-lost", true)+ .property("do-retransmission", false)+ .build()+ .map_err(|_| "jitter buffer unavailable")?;+ let depay = gst::ElementFactory::make("rtpopusdepay")+ .build()+ .map_err(|_| "audio depayloader unavailable")?;+ let decoder = gst::ElementFactory::make("opusdec")+ .property("plc", true)+ .property("use-inband-fec", false)+ .build()+ .map_err(|_| "audio decoder unavailable")?;+ let convert = gst::ElementFactory::make("audioconvert")+ .build()+ .map_err(|_| "audio converter unavailable")?;+ let resample = gst::ElementFactory::make("audioresample")+ .build()+ .map_err(|_| "audio resampler unavailable")?;+ let filter = gst::ElementFactory::make("capsfilter")+ .property("caps", caps)+ .build()+ .map_err(|_| "audio format filter unavailable")?;+ let sink = Sink::new(writer);+ let pipeline = gst::Pipeline::new();+ let elements = [+ source.upcast_ref(),+ &jitter,+ &depay,+ &decoder,+ &convert,+ &resample,+ &filter,+ sink.upcast_ref(),+ ];+ pipeline+ .add_many(elements)+ .map_err(|_| "audio pipeline assembly failed")?;+ gst::Element::link_many(elements).map_err(|_| "audio pipeline linking failed")?;+ pipeline.use_clock(Some(&gst::SystemClock::obtain()));+ let failed = Arc::new(AtomicBool::new(false));+ let latency = Arc::new(AtomicBool::new(true));+ let failure = failed.clone();+ let changed = latency.clone();+ pipeline+ .bus()+ .ok_or("audio bus unavailable")?+ .set_sync_handler(move |_, message| {+ match message.view() {+ gst::MessageView::Error(_)+ | gst::MessageView::Eos(_)+ | gst::MessageView::ClockLost(_) => {+ failure.store(true, Ordering::Release);+ }+ gst::MessageView::Latency(_) => {+ changed.store(true, Ordering::Release);+ }+ _ => {}+ }+ gst::BusSyncReply::Drop+ });+ let mut playout = Self {+ pipeline,+ source,+ anchor: (Instant::now(), gst::ClockTime::ZERO),+ failed,+ latency,+ };+ playout+ .pipeline+ .set_state(gst::State::Playing)+ .map_err(|_| "audio pipeline start failed")?;+ playout.anchor = (+ Instant::now(),+ playout+ .pipeline+ .current_running_time()+ .ok_or("audio clock unavailable")?,+ );+ Ok(playout)+ }++ pub(super) fn push(&self, packet: ReceivedRtp) -> Result<(), &'static str> {+ let Some(elapsed) = packet.at.checked_duration_since(self.anchor.0) else {+ return Ok(());+ };+ let time = self+ .anchor+ .1+ .checked_add(gst::ClockTime::try_from(elapsed).map_err(|_| "audio timestamp overflow")?)+ .ok_or("audio timestamp overflow")?;+ let mut buffer = gst::Buffer::from_slice(packet);+ buffer+ .get_mut()+ .ok_or("audio packet unexpectedly shared")?+ .set_pts(time);+ self.source+ .push_buffer(buffer)+ .map_err(|_| "audio pipeline rejected packet")?;+ self.check()+ }++ pub(super) fn check(&self) -> Result<(), &'static str> {+ if self.failed.load(Ordering::Acquire) {+ return Err("audio playback failed");+ }+ if self.latency.swap(false, Ordering::AcqRel) {+ self.pipeline+ .recalculate_latency()+ .map_err(|_| "audio latency negotiation failed")?;+ }+ Ok(())+ }+}++impl Drop for Playout {+ fn drop(&mut self) {+ let _ = self.pipeline.set_state(gst::State::Null);+ }+}++#[cfg(test)]+#[path = "playout_tests.rs"]+mod tests;diff --git a/codex-rs/voice-host/src/playout_tests.rs b/codex-rs/voice-host/src/playout_tests.rsnew file mode 100644index 0000000000..f0b3230887--- /dev/null+++ b/codex-rs/voice-host/src/playout_tests.rs@@ -0,0 +1,192 @@+use super::*;+use crate::devices::buffers::Buffers;+use crate::devices::buffers::Playback;+use crate::devices::playback::PlaybackPort;+use crate::incoming::Incoming;+use gst::glib::subclass::prelude::ObjectSubclassIsExt;+use gstreamer_audio::subclass::prelude::AudioSinkImpl;+use pretty_assertions::assert_eq;+use rtc::interceptor::Packet;+use rtc::interceptor::TaggedPacket;+use rtc::sansio::Protocol;+use std::sync::atomic::AtomicUsize;+use std::sync::mpsc;+use std::time::Duration;++#[test]+fn real_decoder_renders_current_rtp_and_rejects_pre_epoch_arrivals() {+ gst::init().unwrap();+ let root = if codex_utils_cargo_bin::runfiles_available() {+ let resource = format!(+ "../../third_party/voice/native_link_{}_{}/runtime.json",+ std::env::consts::OS,+ std::env::consts::ARCH+ );+ Some(+ codex_utils_cargo_bin::find_resource!(resource)+ .unwrap()+ .parent()+ .unwrap()+ .to_path_buf(),+ )+ } else {+ std::env::var_os("CODEX_TEST_VOICE_RUNTIME").map(std::path::PathBuf::from)+ };+ // Ordinary Cargo builds use installed plugins; explicit fixtures must load exactly.+ if let Some(root) = root {+ for plugin in+ "app audioconvert audioresample coreelements opus rtp rtpmanager".split_whitespace()+ {+ let relative = if cfg!(target_os = "macos") {+ format!("plugins/libgst{plugin}.dylib")+ } else if cfg!(windows) {+ format!("bin/gst{plugin}.dll")+ } else {+ format!("lib/gstreamer-1.0/libgst{plugin}.so")+ };+ gst::Plugin::load_file(root.join(relative)).unwrap();+ }+ }+ let mut encoder = opus::Encoder::new(+ /*sample_rate*/ 48000,+ opus::Channels::Mono,+ opus::Application::Voip,+ )+ .unwrap();+ // Prepare media before the live clock starts so encoding cost cannot slow the sender.+ let packets: Vec<_> = (0..40u16)+ .map(|sequence| {+ let samples: Vec<_> = (0..960)+ .map(|n| ((usize::from(sequence) * 960 + n) as f32 * 0.07).sin() * 0.2)+ .collect();+ let mut encoded = vec![0; 4096];+ let len = encoder.encode_float(&samples, &mut encoded).unwrap();+ encoded.truncate(len);+ (sequence, encoded)+ })+ .collect();+ let old = Instant::now();+ let buffers = Arc::new(Buffers::new(+ /*input_rate*/ 48000, /*output_rate*/ 48000,+ ));+ buffers.set_speaker_disabled(/*disabled*/ false).unwrap();+ let port = PlaybackPort::new(buffers.clone(), /*rate*/ 48000);+ let playout = Playout::new(port.writer()).unwrap();+ let (mut incoming, mut ingress) = Incoming::new();+ incoming.set_suppressed(/*suppressed*/ false).unwrap();+ let audible = AtomicUsize::new(0);+ let last_callback_us = AtomicUsize::new(0);+ let max_callback_gap_us = AtomicUsize::new(0);+ let started = Instant::now();+ std::thread::scope(|scope| {+ // Device callbacks run independently of incoming RTP work.+ let (stop, stopping) = mpsc::channel::<Instant>();+ let callback_buffers = buffers.clone();+ let callback_audible = &audible;+ let last_callback_us = &last_callback_us;+ let max_callback_gap_us = &max_callback_gap_us;+ let consumer = scope.spawn(move || {+ let mut output = Playback::default();+ let mut deadline = None;+ loop {+ match stopping.try_recv() {+ Ok(end) => deadline = Some(end),+ Err(mpsc::TryRecvError::Disconnected) => break,+ Err(mpsc::TryRecvError::Empty) => {}+ }+ if deadline.is_some_and(|end| Instant::now() >= end) {+ break;+ }+ // This checks real decoding, not a wall-clock device cadence.+ // Drain available frames promptly so CI scheduling stalls do not+ // trigger the native sink's production backpressure deadline.+ if callback_buffers.queued.load(Ordering::Acquire) == 0 {+ std::thread::park_timeout(Duration::from_millis(/*millis*/ 1));+ continue;+ }+ let count = (0..960)+ .filter_map(|_| output.next(&callback_buffers))+ .filter(|sample| sample.abs() > 0.01)+ .count();+ callback_audible.fetch_add(count, Ordering::Relaxed);+ let completed_us = started.elapsed().as_micros() as usize;+ let previous_us = last_callback_us.swap(completed_us, Ordering::Relaxed);+ max_callback_gap_us.fetch_max(completed_us - previous_us, Ordering::Relaxed);+ }+ });+ for (sequence, encoded) in packets {+ ingress+ .handle_read(TaggedPacket {+ now: Instant::now(),+ transport: Default::default(),+ message: Packet::Rtp(rtc::rtp::Packet {+ header: rtc::rtp::header::Header {+ version: 2,+ payload_type: crate::audio_track::OPUS_PAYLOAD_TYPE,+ sequence_number: sequence,+ timestamp: u32::from(sequence) * 960,+ ssrc: 7,+ ..Default::default()+ },+ payload: encoded.into(),+ }),+ })+ .unwrap();+ let mut packet = incoming.take().unwrap().unwrap();+ // Exercise the decoder epoch boundary independently of ingress age limits.+ if sequence < 10 {+ packet.at = old;+ }+ playout.push(packet).unwrap();+ // RTP advances by 20 ms per packet; avoid accumulating work and wakeup delays.+ let next_packet =+ started + Duration::from_millis(/*millis*/ (u64::from(sequence) + 1) * 20);+ std::thread::sleep(next_packet.saturating_duration_since(Instant::now()));+ if sequence == 9 {+ assert_eq!(audible.load(Ordering::Relaxed), 0);+ }+ playout.check().unwrap();+ assert!(+ !buffers.failed.load(Ordering::Acquire),+ "packet {sequence}; elapsed={:?}, audible={}, queued={}, last_callback_us={}, max_callback_gap_us={}",+ started.elapsed(),+ audible.load(Ordering::Relaxed),+ buffers.queued.load(Ordering::Acquire),+ last_callback_us.load(Ordering::Relaxed),+ max_callback_gap_us.load(Ordering::Relaxed)+ );+ }+ let deadline = Instant::now() + Duration::from_secs(/*secs*/ 3);+ stop.send(deadline).unwrap();+ while audible.load(Ordering::Relaxed) <= 4800 && Instant::now() < deadline {+ std::thread::sleep(Duration::from_millis(/*millis*/ 20));+ playout.check().unwrap();+ assert!(+ !buffers.failed.load(Ordering::Acquire),+ "drain; elapsed={:?}, audible={}, queued={}, last_callback_us={}, max_callback_gap_us={}",+ started.elapsed(),+ audible.load(Ordering::Relaxed),+ buffers.queued.load(Ordering::Acquire),+ last_callback_us.load(Ordering::Relaxed),+ max_callback_gap_us.load(Ordering::Relaxed)+ );+ if Instant::now() >= deadline {+ break;+ }+ }+ drop(stop);+ consumer.join().unwrap();+ let audible = audible.load(Ordering::Relaxed);+ assert!(+ audible > 4800,+ "real decoded non-silent audio must reach the sink writer; observed {audible} samples"+ );+ buffers.set_speaker_disabled(/*disabled*/ true).unwrap();+ drop(playout);+ assert!(!buffers.failed.load(Ordering::Acquire));+ buffers.set_speaker_disabled(/*disabled*/ false).unwrap();+ let sink = Sink::new(port.writer());+ assert!(sink.imp().write(&f32::NAN.to_le_bytes()).is_err());+ assert!(buffers.failed.load(Ordering::Acquire));+ });+}diff --git a/codex-rs/voice-host/src/processing.rs b/codex-rs/voice-host/src/processing.rsindex bc8c16bce8..4ba26cfb69 100644--- a/codex-rs/voice-host/src/processing.rs+++ b/codex-rs/voice-host/src/processing.rs@@ -150,6 +150,15 @@ impl Processor {Ok(())}+ pub(super) fn reset_render(&mut self) {+ // Speaker changes discard old references without resetting capture or APM state.+ self.render.resampler.reset();+ self.render.input.clear();+ self.render.output.clear();+ self.render.end = None;+ self.render_delay = 0;+ }+pub(super) fn validate_callback_timing(&self,input_frames: u32,diff --git a/codex-rs/voice-host/src/processing_tests.rs b/codex-rs/voice-host/src/processing_tests.rsindex 15446365e7..43e62b0661 100644--- a/codex-rs/voice-host/src/processing_tests.rs+++ b/codex-rs/voice-host/src/processing_tests.rs@@ -155,6 +155,41 @@ fn unmute_reset_rejects_delayed_pre_unmute_audio_and_partial_history() {assert!(processor.capture.output.is_empty());}+#[test]+fn speaker_reset_discards_partial_echo_reference_but_keeps_capture_history() {+ let mut processor = Processor::new(/*input_rate*/ 48_000, /*output_rate*/ 48_000).unwrap();+ let mut fresh = Processor::new(/*input_rate*/ 48_000, /*output_rate*/ 48_000).unwrap();+ let start = Instant::now();+ let mut frame = Frame {+ samples: [0.75; 256],+ len: 256,+ at: start,+ generation: 2,+ };+ processor.render.push(&frame).unwrap();+ processor.render.output.push_back(0.75);+ processor.capture.input.extend([0.25; 256]);+ processor.pending.extend([0.25; 480]);+ processor.render_delay = 123;+ processor.reset_render();+ assert_eq!(processor.capture.input, VecDeque::from(vec![0.25; 256]));+ assert_eq!(processor.pending, vec![0.25; 480]);+ assert_eq!(processor.render_delay, 0);++ frame.samples.fill(0.0);+ let mut actual = Vec::new();+ let mut expected = Vec::new();+ for index in 0..5 {+ frame.at = start + Duration::from_secs_f64(index as f64 * 256.0 / 48_000.0);+ processor.render.push(&frame).unwrap();+ fresh.render.push(&frame).unwrap();+ actual.extend(std::iter::from_fn(|| processor.render.next()));+ expected.extend(std::iter::from_fn(|| fresh.render.next()));+ }+ assert!(!actual.is_empty());+ assert_eq!(actual, expected);+}+#[test]fn capture_gap_discards_old_partial_packet_and_preserves_unmute_cutoff() {let mut processor = Processor::new(/*input_rate*/ 48_000, /*output_rate*/ 48_000).unwrap();