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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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 @@ 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@@ -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.rsindex 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.rsindex 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.rsindex 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.rsindex 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));});}