From b9ab1eaa2e2fec6e4f2b3d7cf66261feee0eb37e Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Sat, 21 Nov 2026 01:56:10 +0100 Subject: [PATCH 1/2] fix(media): preserve Matroska audio position on cold seek --- crates/media/src/craft_source.rs | 12 ++++-- crates/media/tests/it/footage.rs | 67 ++++++++++++++++++++++++++++++++ 2 files changed, 75 insertions(+), 4 deletions(-) diff --git a/crates/media/src/craft_source.rs b/crates/media/src/craft_source.rs index 85b5b5447..3f55082ff 100644 --- a/crates/media/src/craft_source.rs +++ b/crates/media/src/craft_source.rs @@ -173,15 +173,19 @@ impl ContainerFile { } ContainerFile::Matroska(f) => { let track = &f.tracks[track_idx]; + // Indexed PTS already subtracts CodecDelay rounded to the container clock. + // Translate only that rounding difference, not the full delay a second time. + let tick_ns = i128::from(f.info.timestamp_scale.max(1)); let delay_ns = i128::from(track.codec_delay_ns); + let rounding_ns = ((delay_ns + tick_ns / 2) / tick_ns) * tick_ns - delay_ns; let preroll_ns = i128::from(track.seek_pre_roll_ns.max(80_000_000)); - let target_ns = (i128::from(start.max(0)) * 1_000_000_000) / i128::from(native_rate) + delay_ns; - let seek_ns = (target_ns - preroll_ns).max(0); - let t_track = track.ns_to_ticks(i64::try_from(seek_ns).unwrap_or(0)); + let target_ns = (i128::from(start.max(0)) * 1_000_000_000) / i128::from(native_rate); + let seek_ns = (target_ns - preroll_ns - rounding_ns).max(0); + let t_track = track.ns_to_ticks(i64::try_from(seek_ns).unwrap_or(i64::MAX)); let sample_idx = track.sample_at_pts(t_track).unwrap_or(0); let seek_idx = sample_idx.saturating_sub(2); let sample_pts = track.samples.get(seek_idx).map_or(0, |s| s.pts); - let sample_ns = i128::from(track.ticks_to_ns(sample_pts)) - delay_ns; + let sample_ns = i128::from(track.ticks_to_ns(sample_pts)) + rounding_ns; let decoded_pos = i64::try_from((sample_ns * i128::from(native_rate)) / 1_000_000_000).unwrap_or(0); (seek_idx, decoded_pos) } diff --git a/crates/media/tests/it/footage.rs b/crates/media/tests/it/footage.rs index 13f3f4675..a655efce7 100644 --- a/crates/media/tests/it/footage.rs +++ b/crates/media/tests/it/footage.rs @@ -1592,6 +1592,73 @@ fn filmcraft_fallback_handles_mjpeg_mov() { assert_eq!((img.width, img.height), (160, 120)); } +/// A cold seek and uninterrupted playback must cross the same audible boundary. The PCM is +/// contiguous, so the test isolates reset positioning from separately handled timestamp gaps. +#[test] +fn matroska_cold_seek_applies_codec_delay_once() { + use craft_media::matroska::{self, MkvWriter, MuxOptions, TrackKind, TrackSpec}; + use craft_video::prores::{ChromaFormat, Encoder, Frame, Profile}; + + const RATE: u32 = 48_000; + const PACKET_FRAMES: usize = 4_800; + const PACKET_NS: i64 = 100_000_000; + const DELAY_NS: i64 = 8_250_000; // 396 samples, but 8 rounded container ticks. + const CHANGE_PACKET: i64 = 32; + const HALF_WINDOW: usize = 192; + + let profile = Profile::P4444; + let black = Frame::new(16, 16, ChromaFormat::Yuv444, 10, false).unwrap(); + let picture = Encoder::new(profile, 16, 16).encode(&black).unwrap(); + let mut video = TrackSpec::new(TrackKind::Video, "V_PRORES"); + video.video_size = Some((16, 16)); + video.codec_private = profile.fourcc().to_vec(); + video.default_duration_ns = Some(4_000_000_000); + + let mut audio = TrackSpec::new(TrackKind::Audio, "A_PCM/INT/LIT"); + audio.audio = Some((f64::from(RATE), 1, Some(16))); + audio.codec_delay_ns = DELAY_NS as u64; + audio.default_duration_ns = Some(PACKET_NS as u64); + let mut mux = MkvWriter::new(std::io::Cursor::new(Vec::new()), vec![video, audio], MuxOptions::default()).unwrap(); + mux.write_frame(0, 0, true, &picture, None).unwrap(); + let silent = vec![0; PACKET_FRAMES * 2]; + let signal = 16_384i16.to_le_bytes().repeat(PACKET_FRAMES); + for n in 0..40 { + let pcm = if n < CHANGE_PACKET { &silent } else { &signal }; + mux.write_frame(1, n * PACKET_NS - DELAY_NS, true, pcm, None).unwrap(); + } + let bytes = mux.finish().unwrap().into_inner(); + let mkv = matroska::open(bytes.as_slice()).unwrap(); + assert_eq!(mkv.tracks[1].samples[0].pts, -8); + + // Distinct files and pools keep the two decoder states independent. + let dir = tempfile::tempdir().unwrap(); + let warm_path = dir.path().join("sequential.mkv"); + let cold_path = dir.path().join("cold.mkv"); + std::fs::write(&warm_path, &bytes).unwrap(); + std::fs::write(&cold_path, &bytes).unwrap(); + let warm = probe(&warm_path).unwrap(); + let cold = probe(&cold_path).unwrap(); + for f in [&warm, &cold] { + assert!(f.has_audio); + assert_eq!(f.codec, "ProRes", "exercise the shared Matroska route, not legacy fallback"); + } + + let warm_pool = MediaPool::new(); + for n in 0..CHANGE_PACKET - 1 { + let t = Tick::from_units(n * PACKET_FRAMES as i64, i64::from(RATE)); + let _ = warm_pool.audio_samples(&warm, t, PACKET_FRAMES, RATE); + } + let boundary = CHANGE_PACKET * PACKET_FRAMES as i64 - DELAY_NS * i64::from(RATE) / 1_000_000_000; + let t = Tick::from_units(boundary - HALF_WINDOW as i64, i64::from(RATE)); + let sequential = warm_pool.audio_samples(&warm, t, 2 * HALF_WINDOW, RATE); + assert_eq!(sequential.len(), 4 * HALF_WINDOW); + assert!(sequential[..2 * HALF_WINDOW].iter().all(|s| s.abs() < 1e-6)); + assert!(sequential[2 * HALF_WINDOW..].iter().all(|s| s.abs() > 0.1)); + + let seek = MediaPool::new().audio_samples(&cold, t, 2 * HALF_WINDOW, RATE); + assert_eq!(seek, sequential, "cold seek must not shift the signal boundary"); +} + #[test] fn matroska_opus_audio_timing_and_seek() { let Some(p) = try_ffmpeg_fixture( From e084232b7095d6d399913b069a16345d25f1e48b Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Sat, 21 Nov 2026 08:52:03 +0700 Subject: [PATCH 2/2] Match Matroska cold-seek audio frame rounding --- crates/media/src/craft_source.rs | 19 ++++++++++++------- crates/media/tests/it/footage.rs | 16 ++++++++++++---- 2 files changed, 24 insertions(+), 11 deletions(-) diff --git a/crates/media/src/craft_source.rs b/crates/media/src/craft_source.rs index 3f55082ff..f4843db3a 100644 --- a/crates/media/src/craft_source.rs +++ b/crates/media/src/craft_source.rs @@ -174,25 +174,30 @@ impl ContainerFile { ContainerFile::Matroska(f) => { let track = &f.tracks[track_idx]; // Indexed PTS already subtracts CodecDelay rounded to the container clock. - // Translate only that rounding difference, not the full delay a second time. + // Translate between that clock and the warm path's whole-frame delay. let tick_ns = i128::from(f.info.timestamp_scale.max(1)); let delay_ns = i128::from(track.codec_delay_ns); - let rounding_ns = ((delay_ns + tick_ns / 2) / tick_ns) * tick_ns - delay_ns; + let indexed_delay_ns = ((delay_ns + tick_ns / 2) / tick_ns) * tick_ns; + let delay_frames = audio_frames_from_ns(delay_ns, native_rate); let preroll_ns = i128::from(track.seek_pre_roll_ns.max(80_000_000)); - let target_ns = (i128::from(start.max(0)) * 1_000_000_000) / i128::from(native_rate); - let seek_ns = (target_ns - preroll_ns - rounding_ns).max(0); + let target_ns = ((i128::from(start.max(0)) + delay_frames) * 1_000_000_000) / i128::from(native_rate); + let seek_ns = (target_ns - preroll_ns - indexed_delay_ns).max(0); let t_track = track.ns_to_ticks(i64::try_from(seek_ns).unwrap_or(i64::MAX)); let sample_idx = track.sample_at_pts(t_track).unwrap_or(0); let seek_idx = sample_idx.saturating_sub(2); let sample_pts = track.samples.get(seek_idx).map_or(0, |s| s.pts); - let sample_ns = i128::from(track.ticks_to_ns(sample_pts)) + rounding_ns; - let decoded_pos = i64::try_from((sample_ns * i128::from(native_rate)) / 1_000_000_000).unwrap_or(0); + let sample_ns = i128::from(track.ticks_to_ns(sample_pts)) + indexed_delay_ns; + let decoded_pos = i64::try_from(audio_frames_from_ns(sample_ns, native_rate) - delay_frames).unwrap_or(0); (seek_idx, decoded_pos) } } } } +fn audio_frames_from_ns(ns: i128, rate: u32) -> i128 { + (ns * i128::from(rate)) / 1_000_000_000 +} + fn open_audio_tracks(container: &ContainerFile, source: &dyn ByteSource, candidates: I) -> Option<(Vec, Vec)> where I: IntoIterator, @@ -213,7 +218,7 @@ where let dec = AudioTrackDecoder::new(¶ms, &refs).ok()?; let native_rate = dec.sample_rate().max(1); let channels = u32::from(dec.layout().channels()).max(1); - let delay_samples = i64::try_from((i128::from(codec_delay_ns) * i128::from(native_rate)) / 1_000_000_000).unwrap_or(0); + let delay_samples = i64::try_from(audio_frames_from_ns(i128::from(codec_delay_ns), native_rate)).unwrap_or(0); audio_infos.push(AudioStreamInfo { sample_rate: native_rate, channels, diff --git a/crates/media/tests/it/footage.rs b/crates/media/tests/it/footage.rs index a655efce7..df1751ff6 100644 --- a/crates/media/tests/it/footage.rs +++ b/crates/media/tests/it/footage.rs @@ -1596,13 +1596,21 @@ fn filmcraft_fallback_handles_mjpeg_mov() { /// contiguous, so the test isolates reset positioning from separately handled timestamp gaps. #[test] fn matroska_cold_seek_applies_codec_delay_once() { + assert_matroska_cold_seek_codec_delay(8_250_000); // Exactly 396 samples, but 8 indexed ticks. +} + +#[test] +fn matroska_cold_seek_matches_fractional_codec_delay_rounding() { + assert_matroska_cold_seek_codec_delay(8_260_000); // 396.48 samples, also 8 indexed ticks. +} + +fn assert_matroska_cold_seek_codec_delay(delay_ns: i64) { use craft_media::matroska::{self, MkvWriter, MuxOptions, TrackKind, TrackSpec}; use craft_video::prores::{ChromaFormat, Encoder, Frame, Profile}; const RATE: u32 = 48_000; const PACKET_FRAMES: usize = 4_800; const PACKET_NS: i64 = 100_000_000; - const DELAY_NS: i64 = 8_250_000; // 396 samples, but 8 rounded container ticks. const CHANGE_PACKET: i64 = 32; const HALF_WINDOW: usize = 192; @@ -1616,7 +1624,7 @@ fn matroska_cold_seek_applies_codec_delay_once() { let mut audio = TrackSpec::new(TrackKind::Audio, "A_PCM/INT/LIT"); audio.audio = Some((f64::from(RATE), 1, Some(16))); - audio.codec_delay_ns = DELAY_NS as u64; + audio.codec_delay_ns = delay_ns as u64; audio.default_duration_ns = Some(PACKET_NS as u64); let mut mux = MkvWriter::new(std::io::Cursor::new(Vec::new()), vec![video, audio], MuxOptions::default()).unwrap(); mux.write_frame(0, 0, true, &picture, None).unwrap(); @@ -1624,7 +1632,7 @@ fn matroska_cold_seek_applies_codec_delay_once() { let signal = 16_384i16.to_le_bytes().repeat(PACKET_FRAMES); for n in 0..40 { let pcm = if n < CHANGE_PACKET { &silent } else { &signal }; - mux.write_frame(1, n * PACKET_NS - DELAY_NS, true, pcm, None).unwrap(); + mux.write_frame(1, n * PACKET_NS - delay_ns, true, pcm, None).unwrap(); } let bytes = mux.finish().unwrap().into_inner(); let mkv = matroska::open(bytes.as_slice()).unwrap(); @@ -1648,7 +1656,7 @@ fn matroska_cold_seek_applies_codec_delay_once() { let t = Tick::from_units(n * PACKET_FRAMES as i64, i64::from(RATE)); let _ = warm_pool.audio_samples(&warm, t, PACKET_FRAMES, RATE); } - let boundary = CHANGE_PACKET * PACKET_FRAMES as i64 - DELAY_NS * i64::from(RATE) / 1_000_000_000; + let boundary = CHANGE_PACKET * PACKET_FRAMES as i64 - delay_ns * i64::from(RATE) / 1_000_000_000; let t = Tick::from_units(boundary - HALF_WINDOW as i64, i64::from(RATE)); let sequential = warm_pool.audio_samples(&warm, t, 2 * HALF_WINDOW, RATE); assert_eq!(sequential.len(), 4 * HALF_WINDOW);