Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion quest/m1/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -147,7 +147,6 @@ above them.
- [Audio warmup](/quest/m1/audio-warmup.md) - a viewer joining an Opus rendition mid-stream never hears the unconverged first 80 ms
- [#3021](/quest/m1/3021-moq-gst-anchor-generated-media-timelines-to-wall-clock.md) - moq-gst picks the broadcast wall epoch; a restarted source is a new epoch, not a forward re-anchor
- [moqsrc A/V alignment](/quest/m1/gst-src-av-sync.md) - every `moqsrc` pad of a run shares one timestamp reference and segment base
- [TS export backlog](/quest/m1/ts-export-backlog.md) - `export ts` reads a track only until a frame is due, like FLV and MKV, so a backlog stays in the source
- [CLI stdin shutdown on release](/quest/m1/cli-stdin-release.md) - backport only the runtime-teardown fix so a stopped CLI exits while its stdin writer stays open
- [Draft 14-16 updates](/quest/m1/ietf-legacy-updates.md) - Rust and JS apply and answer moq-transport 14-16 request updates without ending or leaking the request
- [Tail arrivals](/quest/m1/tail-arrivals.md) - a track judges its pending tail from recorded arrivals, not a cache scan, and errors a reader whose tail ends short
Expand Down
35 changes: 0 additions & 35 deletions quest/m1/ts-export-backlog.md

This file was deleted.

14 changes: 12 additions & 2 deletions rs/moq-mux/benches/export.rs
Original file line number Diff line number Diff line change
Expand Up @@ -83,6 +83,12 @@ async fn export(format: &str, source: moq_mux::Source, stream: moq_mux::catalog:
std::hint::black_box(chunk);
chunks += 1;
}
} else if format == "ts" {
let mut export = moq_mux::container::ts::Export::new(source).await.unwrap();
while let Some(chunk) = export.next().await.unwrap() {
std::hint::black_box(chunk);
chunks += 1;
}
} else {
let mut export = moq_mux::container::mkv::Export::new(source, stream).with_fragment_duration(Duration::ZERO);
while let Some(chunk) = export.next().await.unwrap() {
Expand All @@ -101,7 +107,7 @@ fn bench_export(c: &mut Criterion) {
let mut group = c.benchmark_group("container-export");
group.sample_size(10);
group.measurement_time(Duration::from_secs(1));
for format in ["flv", "mkv"] {
for format in ["flv", "mkv", "ts"] {
for tracks in [1, 4, 16] {
for frames in [1, 16, 64] {
group.throughput(Throughput::Elements((tracks * frames) as u64));
Expand All @@ -111,7 +117,11 @@ fn bench_export(c: &mut Criterion) {
|| runtime.block_on(prepare(tracks, frames)),
|(source, stream, fixture)| {
let chunks = runtime.block_on(export(format, source, stream));
assert_eq!(chunks, 1 + tracks * frames);
if format == "ts" {
assert!(chunks > 0);
} else {
assert_eq!(chunks, 1 + tracks * frames);
}
fixture
},
BatchSize::PerIteration,
Expand Down
144 changes: 94 additions & 50 deletions rs/moq-mux/src/container/ts/export.rs
Original file line number Diff line number Diff line change
Expand Up @@ -251,6 +251,13 @@ struct Track {
pack: Option<Pack>,
}

/// Shared program state needed while reading one track.
struct Input<'a> {
waiting_for_header: bool,
video_start: Option<Timestamp>,
jitter: &'a mut jitter::Buffer<u16, Queued>,
}

impl Track {
/// A track reading `source`, its PID filled in by the catalog.
fn new(source: ExportSource, kind: Kind) -> Self {
Expand Down Expand Up @@ -298,6 +305,58 @@ impl Track {
self.release(name, jitter, false)
}

/// Read until a frame is due, or hold the first frame until the program tables are built.
fn fill(&mut self, name: &str, waiter: &kio::Waiter, input: &mut Input<'_>) -> crate::Result<()> {
if self.pending.is_some() || self.finished {
return Ok(());
}
let is_video = matches!(self.kind, Kind::Video(_));
loop {
if !input.waiting_for_header && input.jitter.full(&self.pid) {
break;
}
match self.source.poll_read(waiter)? {
Poll::Ready(Some(frame)) => {
if input.waiting_for_header && !self.source.header_ready() {
continue;
}
let pending = Pending {
frame,
restart: self.base.0 + self.source.markers(),
skip: self.base.1 + self.source.skips(),
arrived: self.empty,
read: web_async::time::Instant::now(),
};
// A new timeline must reach the reset before tune-in alignment can drop it.
if let Some(start) = input.video_start
&& !is_video && pending.restart == self.restart
&& pending.frame.timestamp < start
{
continue;
}
if input.waiting_for_header {
self.pending = Some(pending);
break;
}
self.queue(name, pending, input.jitter)?;
}
Poll::Ready(None) => {
self.finished = true;
break;
}
Poll::Pending => {
self.empty = web_async::time::Instant::now();
break;
}
}
}
// Nothing more can come in below the frames still held for their DTS.
if self.finished && !input.waiting_for_header {
self.release(name, input.jitter, true)?;
}
Ok(())
}

/// Queue each AC-3 sync frame of a passed-through PES on its own, due at its own decode
/// time: a receiver's buffer holds and decodes each on its own, and the whole PES would
/// overflow it. A frame the last PES began decodes ahead of this PES, so the jitter buffer
Expand Down Expand Up @@ -1003,8 +1062,8 @@ impl<E: catalog::Catalog> Export<E> {
si.poll(waiter);
}

// 2. Read every frame the sources have: into the jitter buffer, or before the
// program tables are built, one per track.
// 2. Read each source until it has a frame due, or before the program tables
// are built, hold one per track.
self.fill(waiter)?;

// 3. Build the program tables once the layout is resolved and every
Expand Down Expand Up @@ -1109,6 +1168,25 @@ impl<E: catalog::Catalog> Export<E> {
let drain = self.max_drain();
self.lay(Some(schedule::slot(decode.saturating_sub(drain.as_nanos()))))?;
}
if self.queue.is_empty() {
// Releasing a due frame opens room in its source. Read it before parking:
// a zero-delay slot may need another frame to prove the slot is complete.
let track = self.tracks.get_mut(&name).expect("the released frame's track");
let finished = track.finished;
track.fill(
&name,
waiter,
&mut Input {
waiting_for_header: false,
video_start: self.video_start,
jitter: &mut self.jitter,
},
)?;
if !finished && track.finished {
self.schedule
.set_ended(self.tracks.values().all(|track| track.finished));
}
}
}
self.lay_due(waiter)?;
if let Some(out) = self.pop() {
Expand Down Expand Up @@ -1198,61 +1276,21 @@ impl<E: catalog::Catalog> Export<E> {
}))
}

/// Read every frame the sources have ready.
/// Read each source until it has a frame due.
///
/// Before the program tables are built, each track holds its first frame instead,
/// and slices that arrive before their codec config resolves are dropped: a receiver
/// joining mid-GOP can't use them, and parking them would stop us polling for the
/// keyframe that carries the parameter sets. [`ExportSource`] has already transformed
/// Annex-B avc3/hev1 into length-prefixed form and resolved the avcC/hvcC.
fn fill(&mut self, waiter: &kio::Waiter) -> crate::Result<()> {
let waiting_for_header = self.psi.is_none();
let video_start = self.video_start;
for (name, track) in self.tracks.iter_mut() {
if track.pending.is_some() || track.finished {
continue;
}
let is_video = matches!(track.kind, Kind::Video(_));
loop {
match track.source.poll_read(waiter)? {
Poll::Ready(Some(frame)) => {
if waiting_for_header && !track.source.header_ready() {
continue;
}
let pending = Pending {
frame,
restart: track.base.0 + track.source.markers(),
skip: track.base.1 + track.source.skips(),
arrived: track.empty,
read: web_async::time::Instant::now(),
};
// A new timeline must reach the reset before tune-in alignment can drop it.
if let Some(start) = video_start
&& !is_video && pending.restart == track.restart
&& pending.frame.timestamp < start
{
continue;
}
if waiting_for_header {
track.pending = Some(pending);
break;
}
track.queue(name, pending, &mut self.jitter)?;
}
Poll::Ready(None) => {
track.finished = true;
break;
}
Poll::Pending => {
track.empty = web_async::time::Instant::now();
break;
}
}
}
// Nothing more can come in below the frames still held for their DTS.
if track.finished && !waiting_for_header {
track.release(name, &mut self.jitter, true)?;
}
let mut input = Input {
waiting_for_header: self.psi.is_none(),
video_start: self.video_start,
jitter: &mut self.jitter,
};
for (name, track) in &mut self.tracks {
track.fill(name, waiter, &mut input)?;
}
Ok(())
}
Expand Down Expand Up @@ -1542,6 +1580,12 @@ impl<E: catalog::Catalog> Export<E> {
stats
}

/// How many access units are waiting in the jitter buffer.
#[cfg(test)]
pub(super) fn buffered(&self) -> usize {
self.jitter.len()
}

/// When the next queued frame is due, or the next grid slot while media is queued or
/// every source has finished and the tail runs out.
#[cfg(test)]
Expand Down
60 changes: 60 additions & 0 deletions rs/moq-mux/src/container/ts/export_test.rs
Original file line number Diff line number Diff line change
Expand Up @@ -9044,3 +9044,63 @@ async fn a_switch_reads_the_instance_it_followed() {
"nothing of the newer instance: {pts:?}"
);
}

/// A sink stall leaves arrived media in its source rather than draining it into the jitter buffer.
#[tokio::test(start_paused = true)]
async fn a_backlog_stays_in_the_source_until_due() {
use crate::container::test_util::{Live, raw_frame};

for delay in [Duration::ZERO, Duration::from_millis(100)] {
let mut config = AudioConfig::new(AAC { profile: 2 }, 44100, 2);
config.description = Some(Bytes::from_static(&[0x12, 0x10]));
let mut live = Live::audio(config);
let mut export = Export::new(live.source().await).await.unwrap().with_delay(delay);
let start = tokio::time::Instant::now();
live.track.write(raw_frame(0, b"first", true)).unwrap();
// A zero-delay slot needs a later frame to prove it is complete.
live.track.write(raw_frame(40_000, b"warm", false)).unwrap();
while !export
.next()
.await
.unwrap()
.unwrap()
.payload
.windows(5)
.any(|part| part == b"first")
{}
// Acquiring the first clock advances mock time; the publisher keeps capturing on it.
let base = 40_000 + start.elapsed().as_micros() as u64;
for index in 1..=50 {
tokio::time::advance(Duration::from_millis(20)).await;
live.track
.write(raw_frame(base + index * 20_000, b"backlog", false))
.unwrap();
}
// Settle the final zero-delay slot while the publication stays live.
live.track.write(raw_frame(base + 1_040_000, b"tail", false)).unwrap();
// Keep the sink stalled until every backlog frame has reached its deadline.
tokio::time::advance(delay).await;
let mut frames = 0;
while frames < 50 {
let frame = tokio::time::timeout(DRAIN, export.next())
.await
.unwrap_or_else(|_| {
panic!(
"{delay:?}: {frames}/50 frames released, {} buffered, {} dropped",
export.buffered(),
export.dropped()
)
})
.unwrap()
.unwrap();
frames += frame.payload.windows(7).filter(|part| *part == b"backlog").count();
assert!(
export.buffered() <= 1,
"{delay:?}: {} frames buffered",
export.buffered()
);
}
assert_eq!(frames, 50);
assert_eq!(export.dropped(), 0, "the sink's stall does not make arrived media late");
}
}
Loading
Loading