mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
## Why Audio queue saturation and processing delays could terminate voice sessions. Muted sessions also need outgoing audio to keep the peer alive. ## What changed - Drop stale or excess incoming, capture, render-reference, and playback audio so fresh audio can resume. Reset affected processing state while preserving queue bounds and mute generations. - Send paced, generated Opus silence while muted, without using device or processing buffers. - Add fixed helper exit stages and session failure categories to default TUI logs without logging raw native errors, SDP, or device error text. Preserve observed helper exit status for shutdown. ## Testing Extend tests to cover decoded mute silence and RTP sequence continuity, recovery after stale audio and queue saturation, and shutdown after observing helper output closure. Verify the helper's exit stage when the parent pipe closes during blocked startup. GitOrigin-RevId: 17d580a72acd4423fb0b4f5107d9b541b964d069
168 lines
5.0 KiB
Rust
168 lines
5.0 KiB
Rust
//! Takes incoming Opus RTP before the upstream track queue, preserving network arrival time.
|
|
//! Packet and byte permits follow owned data through the consumer, not merely through this queue.
|
|
//! Stale or saturated media is discarded so a slow worker can resume with fresh speaker audio.
|
|
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::AtomicBool;
|
|
use std::sync::atomic::AtomicU64;
|
|
use std::sync::atomic::Ordering;
|
|
use std::time::Duration;
|
|
use std::time::Instant;
|
|
|
|
use rtc::interceptor::Interceptor;
|
|
use rtc::interceptor::NoopInterceptor;
|
|
use rtc::interceptor::Packet;
|
|
use rtc::interceptor::StreamInfo;
|
|
use rtc::interceptor::TaggedPacket;
|
|
use rtc::interceptor::interceptor;
|
|
use rtc::sansio;
|
|
use rtc::shared::error::Error;
|
|
use rtc::shared::marshal::Marshal;
|
|
use rtc::shared::marshal::MarshalSize;
|
|
use tokio::sync::OwnedSemaphorePermit;
|
|
use tokio::sync::Semaphore;
|
|
use tokio::sync::mpsc;
|
|
|
|
const PACKETS: usize = 64;
|
|
const BYTES: usize = 2 * 1024 * 1024;
|
|
const PACKET_BYTES: usize = 64 * 1024;
|
|
|
|
struct State {
|
|
epoch: AtomicU64,
|
|
failed: AtomicBool,
|
|
packets: Arc<Semaphore>,
|
|
bytes: Arc<Semaphore>,
|
|
}
|
|
|
|
pub(crate) struct ReceivedRtp {
|
|
data: Vec<u8>,
|
|
pub(crate) at: Instant,
|
|
epoch: u64,
|
|
_packet: OwnedSemaphorePermit,
|
|
_bytes: OwnedSemaphorePermit,
|
|
}
|
|
|
|
impl AsRef<[u8]> for ReceivedRtp {
|
|
fn as_ref(&self) -> &[u8] {
|
|
&self.data
|
|
}
|
|
}
|
|
|
|
pub(crate) struct Incoming {
|
|
state: Arc<State>,
|
|
receiver: mpsc::Receiver<ReceivedRtp>,
|
|
}
|
|
|
|
#[derive(Interceptor)]
|
|
pub(crate) struct Ingress {
|
|
#[next]
|
|
next: NoopInterceptor,
|
|
state: Arc<State>,
|
|
sender: mpsc::Sender<ReceivedRtp>,
|
|
stream: Option<u32>,
|
|
}
|
|
|
|
impl Incoming {
|
|
pub(crate) fn new() -> (Self, Ingress) {
|
|
let state = Arc::new(State {
|
|
epoch: AtomicU64::new(/*v*/ 1),
|
|
failed: AtomicBool::new(false),
|
|
packets: Arc::new(Semaphore::new(/*permits*/ PACKETS)),
|
|
bytes: Arc::new(Semaphore::new(/*permits*/ BYTES)),
|
|
});
|
|
let (sender, receiver) = mpsc::channel(/*buffer*/ PACKETS);
|
|
(
|
|
Self {
|
|
state: state.clone(),
|
|
receiver,
|
|
},
|
|
Ingress {
|
|
next: NoopInterceptor::new(),
|
|
state,
|
|
sender,
|
|
stream: None,
|
|
},
|
|
)
|
|
}
|
|
|
|
pub(crate) fn set_suppressed(&self, suppressed: bool) -> Result<(), &'static str> {
|
|
let epoch = self.state.epoch.load(Ordering::Acquire);
|
|
if (epoch % 2 == 1) != suppressed {
|
|
self.state.epoch.store(
|
|
epoch.checked_add(1).ok_or("audio epoch exhausted")?,
|
|
Ordering::Release,
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn take(&mut self) -> Result<Option<ReceivedRtp>, &'static str> {
|
|
if self.state.failed.load(Ordering::Acquire) {
|
|
return Err("incoming audio failed");
|
|
}
|
|
let epoch = self.state.epoch.load(Ordering::Acquire);
|
|
for _ in 0..PACKETS {
|
|
let Ok(packet) = self.receiver.try_recv() else {
|
|
return Ok(None);
|
|
};
|
|
if epoch.is_multiple_of(2) && packet.epoch == epoch {
|
|
if packet.at.elapsed() > Duration::from_secs(/*secs*/ 1) {
|
|
continue;
|
|
}
|
|
return Ok(Some(packet));
|
|
}
|
|
}
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
#[interceptor]
|
|
impl Ingress {
|
|
#[overrides]
|
|
fn handle_read(&mut self, message: TaggedPacket) -> Result<(), Self::Error> {
|
|
let Packet::Rtp(packet) = message.message else {
|
|
return Ok(());
|
|
};
|
|
let epoch = self.state.epoch.load(Ordering::Acquire);
|
|
if epoch % 2 == 1 || self.state.failed.load(Ordering::Acquire) {
|
|
return Ok(());
|
|
}
|
|
let size = packet.marshal_size();
|
|
if size > PACKET_BYTES
|
|
|| packet.header.payload_type != crate::audio_track::OPUS_PAYLOAD_TYPE
|
|
|| self.stream.is_some_and(|ssrc| ssrc != packet.header.ssrc)
|
|
{
|
|
self.state.failed.store(true, Ordering::Release);
|
|
return Ok(());
|
|
}
|
|
self.stream = Some(packet.header.ssrc);
|
|
if message.now.elapsed() > Duration::from_secs(/*secs*/ 1) {
|
|
return Ok(());
|
|
}
|
|
let Ok(packet_permit) = self.state.packets.clone().try_acquire_owned() else {
|
|
return Ok(());
|
|
};
|
|
let Ok(bytes_permit) = self.state.bytes.clone().try_acquire_many_owned(size as u32) else {
|
|
return Ok(());
|
|
};
|
|
let mut data = vec![0; size];
|
|
if packet.marshal_to(&mut data).ok() != Some(size) {
|
|
self.state.failed.store(true, Ordering::Release);
|
|
return Ok(());
|
|
}
|
|
let _ = self.sender.try_send(ReceivedRtp {
|
|
data,
|
|
at: message.now,
|
|
epoch,
|
|
_packet: packet_permit,
|
|
_bytes: bytes_permit,
|
|
});
|
|
// Consume here: no second copy is retained by the upstream track-event queue.
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "incoming_tests.rs"]
|
|
mod tests;
|