Skip to content

armgit / codex

Public Imported from GitHub
0

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.lock
index 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.lock
index 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.bazel
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 @@ where
device.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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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();