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
25 changes: 24 additions & 1 deletion rs/moq-mux/src/container/consumer.rs
Original file line number Diff line number Diff line change
Expand Up @@ -85,6 +85,9 @@ pub struct Consumer<F: Container> {
// subscription names no start. Cleared once a first group is chosen.
startup: bool,

// Latch onto the newest group to arrive instead, discarding what arrived below it.
newest: bool,

// How far we may drift from the live edge before skipping a group.
max_delay: std::time::Duration,

Expand Down Expand Up @@ -166,6 +169,7 @@ impl<F: Container> Consumer<F> {
current: start.unwrap_or(0),
pending: VecDeque::new(),
startup: start.is_none(),
newest: false,
max_delay,
edge: None,
start: None,
Expand All @@ -177,6 +181,15 @@ impl<F: Container> Consumer<F> {
}
}

/// Start at the newest group to arrive, the live edge, rather than the floor or the oldest
/// group the publisher serves. The subscription keeps its budget, so every group after the
/// start arrives as it would for any reader; what arrived below the start is discarded.
pub(crate) fn live(mut self) -> Self {
self.startup = true;
self.newest = true;
self
}

/// The group sequence of the last event read.
pub(crate) fn group(&self) -> u64 {
self.group
Expand Down Expand Up @@ -274,7 +287,17 @@ impl<F: Container> Consumer<F> {
!group.empty
});
if any_frame {
self.current = self.pending.front().expect("a group has a frame").sequence;
// A live reader takes the newest group announced so far, though its frames may
// still be on their way, and discards the older ones the budget also delivers.
let start = match self.newest {
true => self.pending.back(),
false => self.pending.front(),
}
.expect("a group has a frame")
.sequence;
// Nothing has been read, so discarding what lies below the start is no gap.
self.pending.retain(|group| group.sequence >= start);
self.current = start;
self.startup = false;
}
}
Expand Down
99 changes: 64 additions & 35 deletions rs/moq-mux/src/container/source.rs
Original file line number Diff line number Diff line change
Expand Up @@ -72,8 +72,7 @@ pub(crate) struct ExportSource {
/// Wire format, consumed when the subscription resolves into a consumer.
media: Option<HangContainer>,
max_delay: std::time::Duration,
/// Start at the newest group, rather than the oldest the max delay still reaches, and
/// apply the max delay once it is read.
/// Start at the newest group, rather than the oldest the max delay still reaches.
live: bool,
/// The first group to read, so a resubscription skips groups already read.
start: Option<u64>,
Expand Down Expand Up @@ -252,9 +251,10 @@ impl ExportSource {
})
}

/// Start at the newest group the publisher has, the live edge, rather than the oldest
/// one the max delay still reaches; the max delay applies from the first frame on, to the
/// groups that follow.
/// Start at the newest group to arrive, the live edge, rather than the oldest one the max
/// delay still reaches. The subscription carries the max delay from the start: under a zero
/// budget every hop drops each group a newer one supersedes, and raising it later cannot
/// recover the groups that follow the edge.
pub fn live(mut self) -> Self {
self.live = true;
self
Expand Down Expand Up @@ -367,12 +367,7 @@ impl ExportSource {
};
(ready!(pending.poll_broadcast(waiter))?, name.clone())
};
// A zero budget asks only for the newest group.
let max_delay = match self.live {
true => std::time::Duration::ZERO,
false => self.max_delay,
};
let mut subscription = moq_net::track::Subscription::default().with_max_delay(max_delay);
let mut subscription = moq_net::track::Subscription::default().with_max_delay(self.max_delay);
if let Some(start) = self.start {
subscription = subscription.with_groups(start..);
}
Expand All @@ -392,7 +387,12 @@ impl ExportSource {
.media
.take()
.expect("media present until the subscription resolves");
self.state = SourceState::Active(Box::new(Consumer::new(track, media)));
let consumer = Consumer::new(track, media);
let consumer = match self.live {
true => consumer.live(),
false => consumer,
};
self.state = SourceState::Active(Box::new(consumer));
}

loop {
Expand All @@ -402,12 +402,7 @@ impl ExportSource {
let SourceState::Active(consumer) = &mut self.state else {
unreachable!("subscription resolved into an Active consumer");
};
let event = ready!(consumer.poll_item(waiter))?;
if std::mem::take(&mut self.live) {
// Started at the live edge: from here the budget tolerates reordering.
consumer.set_max_delay(self.max_delay);
}
match event {
match ready!(consumer.poll_item(waiter))? {
Some(Item::Read(Read::Frame { group, frame })) => {
if self.ends.is_some_and(|(end_group, _)| end_group != group) {
self.finish_ends();
Expand Down Expand Up @@ -659,26 +654,60 @@ mod tests {
}
}

/// The requested budget must be present on the first SUBSCRIBE. Updating it
/// after SUBSCRIBE_OK cannot recover backlog the publisher already skipped.
/// The requested budget must be present on the first SUBSCRIBE, a live start's too. Updating
/// it after SUBSCRIBE_OK cannot recover backlog the publisher already skipped, nor the groups a
/// zero budget drops as superseded before the update lands.
#[tokio::test]
async fn latency_is_sent_with_the_initial_subscription() {
let live = Live::avc3();
let max_delay = std::time::Duration::from_secs(10);
let mut export = ExportSource::for_video(&live.source().await, live.track.name(), &video(None), max_delay)
.unwrap()
.expect("fixture should produce a video rendition");

let observed = kio::wait(|waiter| {
let _ = export.poll_read(waiter);
match live.track.subscription() {
Some(subscription) => Poll::Ready(subscription.max_delay),
None => Poll::Pending,
}
})
.await;
for live_start in [false, true] {
let live = Live::avc3();
let max_delay = std::time::Duration::from_secs(10);
let export = ExportSource::for_video(&live.source().await, live.track.name(), &video(None), max_delay)
.unwrap()
.expect("fixture should produce a video rendition");
let mut export = match live_start {
true => export.live(),
false => export,
};

let observed = kio::wait(|waiter| {
let _ = export.poll_read(waiter);
match live.track.subscription() {
Some(subscription) => Poll::Ready(subscription.max_delay),
None => Poll::Pending,
}
})
.await;

assert_eq!(observed, max_delay, "live start: {live_start}");
}
}

assert_eq!(observed, max_delay);
/// A live start reads from the newest group, though the budget delivers older ones too.
#[tokio::test(start_paused = true)]
async fn a_live_start_reads_from_the_newest_group() {
use crate::container::test_util::raw_frame;

let mut live = Live::audio(audio(None));
for timestamp in [0, 24_000, 48_000] {
live.track.write(raw_frame(timestamp, b"audio", true)).unwrap();
}
let mut export = ExportSource::for_audio(
&live.source().await,
live.track.name(),
&audio(None),
std::time::Duration::from_secs(10),
)
.unwrap()
.unwrap()
.live();

let frame = kio::wait(|waiter| export.poll_read(waiter)).await.unwrap().unwrap();
assert_eq!(frame.timestamp.as_micros(), 48_000);
live.track.write(raw_frame(72_000, b"audio", true)).unwrap();
let frame = kio::wait(|waiter| export.poll_read(waiter)).await.unwrap().unwrap();
assert_eq!(frame.timestamp.as_micros(), 72_000);
assert_eq!(export.skips(), 0, "nothing below the start counts as skipped");
}
async fn audio_export() -> (moq_net::track::Producer, ExportSource) {
use std::time::Duration;
Expand Down
7 changes: 3 additions & 4 deletions rs/moq-mux/src/container/ts/export_test.rs
Original file line number Diff line number Diff line change
Expand Up @@ -5626,10 +5626,9 @@ async fn tune_in_does_not_wait_on_dropped_audio() {
assert!(!out.is_empty(), "the tune-in waited on audio it had dropped");
}

/// A join whose first group the publisher cuts short, as a zero-budget live-edge subscribe
/// is cut when the next group lands before the raised budget reaches it (moq-dev/moq#5565),
/// starts at the next group: nothing of the cut-off start goes out, the next keyframe leads
/// the audio, and the rest is intact.
/// A join whose first group the publisher cuts short (moq-dev/moq#5565) starts at the next
/// group: nothing of the cut-off start goes out, the next keyframe leads the audio, and the
/// rest is intact.
#[tokio::test(start_paused = true)]
async fn a_start_group_cut_short_starts_at_the_next() {
use crate::container::Container as _;
Expand Down
6 changes: 3 additions & 3 deletions rs/moq-mux/src/jitter.rs
Original file line number Diff line number Diff line change
Expand Up @@ -77,9 +77,9 @@ pub(crate) enum Push {
///
/// A track starts on a whole group. Until a frame of it has gone out, a loss (a frame
/// dropped here, or the rest of a group its source cut short) takes everything the track
/// holds with it, and the track starts at its next sync frame. Whole groups missing after one
/// that ended take nothing: a joiner whose zero-budget live-edge pick has the
/// publisher cut its group short starts at the next group rather than on the cut-off start.
/// holds with it, and the track starts at its next sync frame, so a joiner whose start group
/// was cut short starts at the next group rather than on the cut-off start. Whole groups
/// missing after one that ended take nothing.
/// What goes before a track's first frame out is [`Buffer::trimmed`], not lost; what drops
/// after it is [`Buffer::dropped`].
///
Expand Down
7 changes: 6 additions & 1 deletion test/ts/holes.py
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,7 @@
"""

import json
import os
import subprocess
import sys
from collections import Counter
Expand Down Expand Up @@ -57,8 +58,12 @@ def cuts(source: Span, capture: Span, frame: Fraction) -> list[str]:

def probe(path: str) -> dict[str, tuple[dict, list[int], Span]]:
"""Each audio and video stream by PID: the stream, its decode timestamps, and its span."""
# Probe the whole file, not FFmpeg's first 5 MB: a stream whose first frame comes after that
# is never described, so the second frame of its first PES repeats the first's timestamp
# and every later one in that PES runs a frame behind, which reads as a hole.
report = json.loads(subprocess.run(
["ffprobe", "-v", "error", "-show_entries", "stream=index,id,codec_type,codec_name,time_base:packet=stream_index,dts,pts",
["ffprobe", "-v", "error", "-probesize", str(os.path.getsize(path)), "-analyzeduration", str(2**62),
"-show_entries", "stream=index,id,codec_type,codec_name,time_base:packet=stream_index,dts,pts",
"-of", "json", path],
check=True, capture_output=True, text=True,
).stdout)
Expand Down
20 changes: 20 additions & 0 deletions test/ts/holes.test.py
Original file line number Diff line number Diff line change
@@ -1,5 +1,7 @@
import importlib.util
import pathlib
import subprocess
import tempfile
import unittest
from fractions import Fraction

Expand Down Expand Up @@ -57,5 +59,23 @@ def test_lost_prefix(self):
capture = (Fraction(10), *self.SOURCE[1:])
self.assertEqual(len(holes.cuts(self.SOURCE, capture, self.FRAME)), 1)


class Probe(unittest.TestCase):
def test_audio_starting_past_the_default_probe(self):
# Intra-only video ahead of an MP2 stream that starts 3 s in, past FFmpeg's default 5 MB
# probe: probed that far only, its first PES reads as a hole.
with tempfile.TemporaryDirectory() as tmp:
path = str(pathlib.Path(tmp, "late.ts"))
subprocess.run([
"ffmpeg", "-v", "error",
"-f", "lavfi", "-i", "testsrc2=size=1280x720:rate=25:duration=4",
"-itsoffset", "3", "-f", "lavfi", "-i", "sine=sample_rate=48000:duration=1",
"-map", "0:v", "-map", "1:a", "-c:v", "mpeg2video", "-g", "1", "-q:v", "1",
"-c:a", "mp2", "-f", "mpegts", path,
], check=True)
streams = holes.probe(path)
_, dts, _ = streams["0x101"]
self.assertEqual(holes.holes(dts, holes.step(dts)), [])

if __name__ == "__main__":
unittest.main()
Loading