Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Preserve voice playback across pauses and packet bursts (#46880)

Eric Traut282d655defa0
diff --git a/codex-rs/voice-host/src/audio_sink.rs b/codex-rs/voice-host/src/audio_sink.rs
index 33f0062bbb..6c71cdde03 100644
--- a/codex-rs/voice-host/src/audio_sink.rs
+++ b/codex-rs/voice-host/src/audio_sink.rs
@@ -1,9 +1,10 @@
-//! Stock GstAudioSink scheduling with a bounded, epoch-owned CPAL writer.
+//! Forward decoded PCM directly to the bounded, epoch-owned CPAL queue.
+//! CPAL paces playback; a second audio ring can overwrite late speech with silence.
//! Native resets outside an owner-initiated teardown fail the session closed.
use super::playback::PlaybackWriter;
+use audio::gst_base::subclass::prelude::*;
use audio::prelude::*;
-use audio::subclass::prelude::*;
use gst::glib;
use gstreamer as gst;
use gstreamer_audio as audio;
@@ -14,14 +15,12 @@ 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 {
const NAME: &'static str = "CodexPrivateAudioSink";
type Type = super::Sink;
- type ParentType = audio::AudioSink;
+ type ParentType = audio::gst_base::BaseSink;
}
impl ObjectImpl for Sink {}
impl GstObjectImpl for Sink {}
@@ -59,15 +58,14 @@ mod imp {
})
}
}
- impl BaseSinkImpl for Sink {}
- impl AudioBaseSinkImpl for Sink {}
- impl AudioSinkImpl for Sink {
- fn prepare(&self, spec: &mut audio::AudioRingBufferSpec) -> Result<(), gst::LoggableError> {
+ impl BaseSinkImpl for Sink {
+ fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
let writer = self
.writer
.get()
.ok_or_else(|| gst::loggable_error!(gst::CAT_RUST, "speaker not bound"))?;
- let info = spec.audio_info();
+ let info = audio::AudioInfo::from_caps(caps)
+ .map_err(|_| gst::loggable_error!(gst::CAT_RUST, "invalid speaker caps"))?;
if info.rate() != writer.rate()
|| info.channels() != 1
|| info.format() != audio::AudioFormat::F32le
@@ -78,59 +76,47 @@ mod imp {
"unsupported speaker format"
));
}
- spec.set_segsize((writer.rate() / 100 * 4) as i32);
- spec.set_segtotal(4);
- spec.set_latency_time(10_000);
- spec.set_buffer_time(40_000);
Ok(())
}
- fn unprepare(&self) -> Result<(), gst::LoggableError> {
- Ok(())
- }
- fn write(&self, bytes: &[u8]) -> Result<i32, gst::LoggableError> {
- let writer = self
- .writer
- .get()
- .ok_or_else(|| gst::loggable_error!(gst::CAT_RUST, "speaker not bound"))?;
- 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")
- })
+ fn render(&self, buffer: &gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError> {
+ let writer = self.writer.get().ok_or(gst::FlowError::Error)?;
+ (|| {
+ let map = buffer.map_readable().map_err(|_| gst::FlowError::Error)?;
+ let mut bytes = map.as_slice();
+ while !bytes.is_empty() {
+ let written = writer.write(bytes).map_err(|_| gst::FlowError::Error)?;
+ bytes = &bytes[written..];
+ }
+ Ok(gst::FlowSuccess::Ok)
+ })()
+ .inspect_err(|_| writer.fail_if_current())
}
- fn delay(&self) -> u32 {
- self.writer.get().map_or(0, PlaybackWriter::delay)
- }
- fn reset(&self) {
+ fn unlock(&self) -> Result<(), gst::ErrorMessage> {
+ // Flushes cancel blocked writes. Owner-initiated teardown retires
+ // this writer's epoch first, so it cannot fail the next session.
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();
}
+ self.parent_unlock()
}
}
}
glib::wrapper! {
- pub struct Sink(ObjectSubclass<imp::Sink>) @extends audio::AudioSink, audio::AudioBaseSink, audio::gst_base::BaseSink, gst::Element, gst::Object;
+ pub struct Sink(ObjectSubclass<imp::Sink>) @extends 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", "none");
sink.set_sync(false);
sink.set_async(false);
sink.set_enable_last_sample(false);
sink
}
}
+
+#[cfg(test)]
+#[path = "audio_sink_tests.rs"]
+mod tests;
diff --git a/codex-rs/voice-host/src/audio_sink_tests.rs b/codex-rs/voice-host/src/audio_sink_tests.rs
new file mode 100644
index 0000000000..f9b545e2e1
--- /dev/null
+++ b/codex-rs/voice-host/src/audio_sink_tests.rs
@@ -0,0 +1,120 @@
+//! Verify that sink backpressure preserves PCM and native flushes cancel speaker writes.
+
+use super::*;
+use crate::devices::buffers::Buffers;
+use crate::devices::buffers::Playback;
+use crate::devices::playback::PlaybackPort;
+use pretty_assertions::assert_eq;
+use std::sync::Arc;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+use std::time::Instant;
+
+#[test]
+fn queued_audio_survives_a_pause_before_the_next_buffer() {
+ gst::init().unwrap();
+ let buffers = Arc::new(Buffers::new(
+ /*input_rate*/ 48_000, /*output_rate*/ 48_000,
+ ));
+ buffers.set_speaker_disabled(/*disabled*/ false).unwrap();
+ let port = PlaybackPort::new(buffers.clone(), /*rate*/ 48_000);
+ let source = gstreamer_app::AppSrc::builder()
+ .is_live(true)
+ .format(gst::Format::Time)
+ .caps(
+ &gst::Caps::builder("audio/x-raw")
+ .field("format", "F32LE")
+ .field("layout", "interleaved")
+ .field("channels", 1i32)
+ .field("rate", 48_000i32)
+ .build(),
+ )
+ .build();
+ let sink = Sink::new(port.writer());
+ let pipeline = gst::Pipeline::new();
+ pipeline
+ .add_many([source.upcast_ref::<gst::Element>(), sink.upcast_ref()])
+ .unwrap();
+ source.link(&sink).unwrap();
+ pipeline.set_state(gst::State::Playing).unwrap();
+ let first_samples = 960;
+ source
+ .push_buffer(gst::Buffer::from_slice(
+ 0.25_f32.to_le_bytes().repeat(first_samples),
+ ))
+ .unwrap();
+ let deadline = Instant::now() + Duration::from_secs(/*secs*/ 3);
+ while buffers.queued.load(Ordering::Acquire) < first_samples as u32 && Instant::now() < deadline
+ {
+ std::thread::park_timeout(Duration::from_millis(/*millis*/ 1));
+ }
+ // Leave room for both buffers so a slow test runner cannot trigger the
+ // writer's bounded-wait timeout. An independent output ring must not
+ // snapshot silence over the next buffer's samples during the pause.
+ std::thread::sleep(Duration::from_millis(/*millis*/ 20));
+ source
+ .push_buffer(gst::Buffer::from_slice(0.5_f32.to_le_bytes().repeat(960)))
+ .unwrap();
+ std::thread::sleep(Duration::from_millis(/*millis*/ 20));
+ let mut playback = Playback::default();
+ let mut actual = Vec::new();
+ while actual.len() < first_samples + 960 && Instant::now() < deadline {
+ for _ in 0..480 {
+ if let Some(sample) = playback.next(&buffers) {
+ actual.push(sample);
+ }
+ }
+ std::thread::park_timeout(Duration::from_millis(/*millis*/ 1));
+ }
+ buffers.set_speaker_disabled(/*disabled*/ true).unwrap();
+ pipeline.set_state(gst::State::Null).unwrap();
+ let expected: Vec<_> = std::iter::repeat_n(0.25, first_samples)
+ .chain(std::iter::repeat_n(0.5, 960))
+ .collect();
+ assert_eq!(actual, expected);
+ assert!(!buffers.failed.load(Ordering::Acquire));
+}
+
+#[test]
+fn unexpected_flush_cancels_a_blocked_speaker_write() {
+ gst::init().unwrap();
+ let buffers = Arc::new(Buffers::new(
+ /*input_rate*/ 48_000, /*output_rate*/ 48_000,
+ ));
+ buffers.set_speaker_disabled(/*disabled*/ false).unwrap();
+ let port = PlaybackPort::new(buffers.clone(), /*rate*/ 48_000);
+ let sink = Sink::new(port.writer());
+ sink.set_state(gst::State::Playing).unwrap();
+ let capacity = if cfg!(target_os = "linux") {
+ 4_800
+ } else {
+ 1_920
+ };
+ sink.imp()
+ .render(&gst::Buffer::from_slice(vec![0u8; capacity * 4]))
+ .unwrap();
+ let blocked_sink = sink.clone();
+ let blocked = std::thread::spawn(move || {
+ blocked_sink
+ .imp()
+ .render(&gst::Buffer::from_slice([0u8; 4]))
+ });
+ // The writer holds this lock while waiting for space in the full queue.
+ let deadline = Instant::now() + Duration::from_secs(/*secs*/ 1);
+ while !matches!(
+ port.0.producer.try_lock(),
+ Err(std::sync::TryLockError::WouldBlock)
+ ) {
+ assert!(Instant::now() < deadline, "speaker write did not block");
+ std::thread::yield_now();
+ }
+ assert!(
+ sink.static_pad("sink")
+ .unwrap()
+ .send_event(gst::event::FlushStart::new())
+ );
+ let result = blocked.join().unwrap();
+ sink.set_state(gst::State::Null).unwrap();
+ assert_eq!(result, Err(gst::FlowError::Error));
+ assert!(buffers.failed.load(Ordering::Acquire));
+}
diff --git a/codex-rs/voice-host/src/device_buffers.rs b/codex-rs/voice-host/src/device_buffers.rs
index b38f13fe2e..1e48f22769 100644
--- a/codex-rs/voice-host/src/device_buffers.rs
+++ b/codex-rs/voice-host/src/device_buffers.rs
@@ -103,9 +103,6 @@ pub(super) struct Buffers {
pub(super) microphone_peak: AtomicU16,
pub(super) speaker_peak: AtomicU16,
pub(super) queued: AtomicU32,
- pub(super) last_dac_ns: AtomicU64,
- pub(super) clock: Instant,
- pub(super) callback_sequence: AtomicU64,
}
impl Buffers {
@@ -143,9 +140,6 @@ impl Buffers {
microphone_peak: AtomicU16::new(/*v*/ 0),
speaker_peak: AtomicU16::new(/*v*/ 0),
queued: AtomicU32::new(/*v*/ 0),
- last_dac_ns: AtomicU64::new(/*v*/ 0),
- clock: Instant::now(),
- callback_sequence: AtomicU64::new(/*v*/ 0),
}
}
diff --git a/codex-rs/voice-host/src/devices.rs b/codex-rs/voice-host/src/devices.rs
index 93f43fe94f..a26e4aa7d5 100644
--- a/codex-rs/voice-host/src/devices.rs
+++ b/codex-rs/voice-host/src/devices.rs
@@ -168,7 +168,6 @@ impl Devices {
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() {}
// Opening a Bluetooth microphone can change the speaker's format.
@@ -385,9 +384,6 @@ 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
@@ -395,9 +391,6 @@ 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,
@@ -425,7 +418,6 @@ fn render_output<T>(
data.fill(T::from_sample(0.0));
return;
}
- let mut delivered_until = None;
for (index, chunk) in data.chunks_mut(BLOCK * channels).enumerate() {
let mut reference = Frame {
samples: [0.0; BLOCK],
@@ -433,18 +425,8 @@ fn render_output<T>(
at: start + Duration::from_secs_f64((index * BLOCK) as f64 / rate),
generation: buffers.speaker.load(Ordering::Acquire),
};
- for (offset, (frame, sample)) in chunk
- .chunks_mut(channels)
- .zip(&mut reference.samples)
- .enumerate()
- {
- let next = output.playback.next(buffers);
- if next.is_some() {
- delivered_until = Some(
- start + Duration::from_secs_f64((index * BLOCK + offset + 1) as f64 / rate),
- );
- }
- let rendered = T::from_sample(next.unwrap_or(0.0));
+ for (frame, sample) in chunk.chunks_mut(channels).zip(&mut reference.samples) {
+ let rendered = T::from_sample(output.playback.next(buffers).unwrap_or(0.0));
frame.fill(rendered);
*sample = f32::from_sample(rendered);
record_peak(&buffers.speaker_peak, *sample);
@@ -454,14 +436,6 @@ fn render_output<T>(
buffers.render_dropped.store(true, Ordering::Release);
}
}
- if let Some(end) = delivered_until {
- buffers.last_dac_ns.store(
- end.saturating_duration_since(buffers.clock)
- .as_nanos()
- .min(u128::from(u64::MAX)) as u64,
- Ordering::Release,
- );
- }
}
#[cfg(test)]
diff --git a/codex-rs/voice-host/src/playback.rs b/codex-rs/voice-host/src/playback.rs
index 2fffbfc6b4..199abfa5a9 100644
--- a/codex-rs/voice-host/src/playback.rs
+++ b/codex-rs/voice-host/src/playback.rs
@@ -1,6 +1,5 @@
//! 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;
@@ -8,7 +7,6 @@ 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;
@@ -24,7 +22,6 @@ pub(super) struct PlaybackPort(pub(super) Arc<PlaybackState>);
pub(crate) struct PlaybackWriter {
state: Arc<PlaybackState>,
epoch: u64,
- last_delay: AtomicU32,
}
impl PlaybackPort {
@@ -40,7 +37,6 @@ impl PlaybackPort {
PlaybackWriter {
state: self.0.clone(),
epoch: self.0.buffers.speaker.load(Ordering::Acquire),
- last_delay: AtomicU32::new(/*v*/ 0),
}
}
}
@@ -113,41 +109,6 @@ impl PlaybackWriter {
std::thread::park_timeout(Duration::from_millis(/*millis*/ 1));
}
}
-
- pub(crate) fn delay(&self) -> u32 {
- let buffers = &self.state.buffers;
- 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();
- }
- }
}
#[cfg(test)]
diff --git a/codex-rs/voice-host/src/playback_tests.rs b/codex-rs/voice-host/src/playback_tests.rs
index 70773a1519..3fb984589e 100644
--- a/codex-rs/voice-host/src/playback_tests.rs
+++ b/codex-rs/voice-host/src/playback_tests.rs
@@ -19,7 +19,7 @@ fn partial_writes_account_for_samples_until_the_device_consumes_them() {
assert_eq!(first, BLOCK * 4);
assert_eq!(writer.write(&bytes[first..]).unwrap(), 20 * 4);
assert_eq!(
- (writer.rate(), writer.delay()),
+ (writer.rate(), buffers.queued.load(Ordering::Acquire)),
(48000, (BLOCK + 20) as u32)
);
let mut playback = Playback::default();
@@ -27,7 +27,7 @@ fn partial_writes_account_for_samples_until_the_device_consumes_them() {
.map(|_| playback.next(&buffers).unwrap())
.collect();
assert_eq!(actual, samples);
- assert_eq!(writer.delay(), 0);
+ assert_eq!(buffers.queued.load(Ordering::Acquire), 0);
assert_eq!(playback.next(&buffers), None);
}
@@ -50,21 +50,6 @@ fn suppression_cancels_a_full_writer_and_old_writers_cannot_resume() {
assert_eq!(port.writer().write(&[0; 4]), Ok(4));
}
-#[test]
-fn delay_includes_pending_dac_time_but_not_another_generation() {
- let (buffers, _, writer) = active(/*rate*/ 48000);
- writer.write(&[0; 40]).unwrap();
- let end = buffers.clock.elapsed() + Duration::from_millis(/*millis*/ 100);
- buffers
- .last_dac_ns
- .store(end.as_nanos() as u64, Ordering::Release);
- let delay = writer.delay();
- assert!((10..=4810).contains(&delay));
- assert!(delay > 10);
- Buffers::set_disabled(&buffers.speaker, /*disabled*/ true).unwrap();
- assert_eq!(writer.delay(), 0);
-}
-
#[test]
fn retired_sink_failure_cannot_fail_the_next_speaker_epoch() {
let (buffers, port, writer) = active(/*rate*/ 48_000);
@@ -87,43 +72,6 @@ fn retired_sink_failure_cannot_fail_the_next_speaker_epoch() {
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_fail_but_stalled_consumption_drops_and_resumes() {
let (buffers, _, writer) = active(/*rate*/ 8000);
diff --git a/codex-rs/voice-host/src/playout.rs b/codex-rs/voice-host/src/playout.rs
index 60ba3f45bb..98266935bb 100644
--- a/codex-rs/voice-host/src/playout.rs
+++ b/codex-rs/voice-host/src/playout.rs
@@ -1,5 +1,6 @@
//! 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.
+//! Owned RTP memory retains ingress permits, bounding bursts without dropping valid queued speech.
+//! Native bus messages never accumulate or escape.
use super::audio_sink::Sink;
use super::playback::PlaybackWriter;
@@ -46,7 +47,9 @@ impl Playout {
let jitter = gst::ElementFactory::make("rtpjitterbuffer")
.property("latency", 60u32)
.property_from_str("mode", "slave")
- .property("drop-on-latency", true)
+ // Latency is the reordering deadline, not a cap on valid burst audio.
+ // Ingress permits already bound retained packets and bytes through decoding.
+ .property("drop-on-latency", false)
.property("do-lost", true)
.property("do-retransmission", false)
.build()
diff --git a/codex-rs/voice-host/src/playout_tests.rs b/codex-rs/voice-host/src/playout_tests.rs
index f0b3230887..f340cd6b24 100644
--- a/codex-rs/voice-host/src/playout_tests.rs
+++ b/codex-rs/voice-host/src/playout_tests.rs
@@ -4,7 +4,7 @@ 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 gstreamer_audio::gst_base::subclass::prelude::BaseSinkImpl;
use pretty_assertions::assert_eq;
use rtc::interceptor::Packet;
use rtc::interceptor::TaggedPacket;
@@ -13,8 +13,7 @@ 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() {
+fn init_audio_runtime() {
gst::init().unwrap();
let root = if codex_utils_cargo_bin::runfiles_available() {
let resource = format!(
@@ -47,6 +46,95 @@ fn real_decoder_renders_current_rtp_and_rejects_pre_epoch_arrivals() {
gst::Plugin::load_file(root.join(relative)).unwrap();
}
}
+}
+
+#[test]
+fn jitter_buffer_preserves_packets_delivered_in_a_burst() {
+ init_audio_runtime();
+ let mut encoder = opus::Encoder::new(
+ /*sample_rate*/ 48_000,
+ opus::Channels::Mono,
+ opus::Application::Voip,
+ )
+ .unwrap();
+ let mut encoded = vec![0; 4096];
+ let len = encoder.encode_float(&[0.25; 960], &mut encoded).unwrap();
+ encoded.truncate(len);
+ let buffers = Arc::new(Buffers::new(
+ /*input_rate*/ 48_000, /*output_rate*/ 48_000,
+ ));
+ buffers.set_speaker_disabled(/*disabled*/ false).unwrap();
+ let port = PlaybackPort::new(buffers.clone(), /*rate*/ 48_000);
+ let playout = Playout::new(port.writer()).unwrap();
+ let depay = playout
+ .pipeline
+ .children()
+ .into_iter()
+ .find(|element| {
+ element
+ .factory()
+ .is_some_and(|factory| factory.name() == "rtpopusdepay")
+ })
+ .unwrap();
+ let (forwarded, received) = mpsc::channel();
+ depay
+ .static_pad("sink")
+ .unwrap()
+ .add_probe(gst::PadProbeType::BUFFER, move |_, info| {
+ if let Some(buffer) = info.buffer() {
+ forwarded
+ .send(buffer.map_readable().unwrap().as_slice().to_vec())
+ .unwrap();
+ }
+ gst::PadProbeReturn::Ok
+ });
+ let (mut incoming, mut ingress) = Incoming::new();
+ incoming.set_suppressed(/*suppressed*/ false).unwrap();
+ let mut expected = Vec::new();
+ // A short scheduling pause can batch valid packets beyond the 60 ms
+ // reordering window. Every admitted packet must still reach the decoder.
+ for sequence in 0..12u16 {
+ 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.clone().into(),
+ }),
+ })
+ .unwrap();
+ let packet = incoming.take().unwrap().unwrap();
+ expected.push(packet.as_ref().to_vec());
+ playout.push(packet).unwrap();
+ }
+ let deadline = Instant::now() + Duration::from_secs(/*secs*/ 3);
+ let mut playback = Playback::default();
+ let mut actual = Vec::new();
+ while actual.len() < expected.len() && Instant::now() < deadline {
+ for _ in 0..960 {
+ playback.next(&buffers);
+ }
+ actual.extend(received.try_iter());
+ playout.check().unwrap();
+ std::thread::park_timeout(Duration::from_millis(/*millis*/ 1));
+ }
+ buffers.set_speaker_disabled(/*disabled*/ true).unwrap();
+ drop(playout);
+ assert_eq!(actual, expected);
+ assert!(!buffers.failed.load(Ordering::Acquire));
+}
+
+#[test]
+fn real_decoder_renders_current_rtp_and_rejects_pre_epoch_arrivals() {
+ init_audio_runtime();
let mut encoder = opus::Encoder::new(
/*sample_rate*/ 48000,
opus::Channels::Mono,
@@ -186,7 +274,11 @@ fn real_decoder_renders_current_rtp_and_rejects_pre_epoch_arrivals() {
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!(
+ sink.imp()
+ .render(&gst::Buffer::from_slice(f32::NAN.to_le_bytes()))
+ .is_err()
+ );
assert!(buffers.failed.load(Ordering::Acquire));
});
}