f67d38b35cc5
oracle_mux.rs
//! Muxer oracle tests: remux ffmpeg-made files with our writers and validate with ffmpeg/ffprobe.
use crate::common;
use common::*;
use filmcraft_isobmff::*;
use serde_json::Value;
use std::io::Cursor;
use std::path::{Path, PathBuf};
/// All samples of all tracks in decode order interleaved by decode time: (track, sample index).
fn interleave(f: &Mp4File, tracks: &[usize]) -> Vec<(usize, usize)> {
let mut v: Vec<(usize, usize)> = tracks.iter().flat_map(|&t| (0..f.tracks[t].samples.len()).map(move |i| (t, i))).collect();
v.sort_by(|a, b| {
let ta = &f.tracks[a.0];
let tb = &f.tracks[b.0];
let x = ta.samples[a.1].dts as i128 * tb.timescale as i128;
let y = tb.samples[b.1].dts as i128 * ta.timescale as i128;
x.cmp(&y).then(a.0.cmp(&b.0)).then(a.1.cmp(&b.1))
});
v
}
fn track_config(f: &Mp4File, t: &Track, copy_edits: bool) -> TrackConfig {
let mut cfg = TrackConfig::new(t.entries[0].clone(), t.timescale);
cfg.language = t.language.clone();
if copy_edits {
cfg.edits = t.edits.clone();
}
let _ = f;
cfg
}
enum Finish {
Normal,
Faststart,
}
fn remux(input: &Path, out_name: &str, brand: Brand, finish: Finish, timecode: Option<(TimecodeConfig, u32)>) -> Option<(Mp4File, PathBuf)> {
let data = std::fs::read(input).ok()?;
let f = open(data.as_slice()).unwrap();
let mut opts = WriterOptions::new(brand);
opts.movie_timescale = f.timescale;
opts.metadata.push(("©nam".into(), "FilmCraft test".into()));
let mut w = Mp4Writer::new(Cursor::new(Vec::new()), opts).unwrap();
let av: Vec<usize> = (0..f.tracks.len()).filter(|&i| matches!(f.tracks[i].kind, TrackKind::Video | TrackKind::Audio)).collect();
let mut map = vec![usize::MAX; f.tracks.len()];
for &i in &av {
map[i] = w.add_track(track_config(&f, &f.tracks[i], true)).unwrap();
}
if let Some((tc, start)) = timecode {
let v = av.iter().copied().find(|&i| f.tracks[i].kind == TrackKind::Video).unwrap();
w.add_timecode_track(map[v], tc, start).unwrap();
}
for (t, i) in interleave(&f, &av) {
let s = f.tracks[t].samples[i];
let bytes = f.read_sample(data.as_slice(), t, i).unwrap();
w.write_sample(map[t], WriteSample { data: &bytes, duration: s.duration, composition_offset: (s.pts - s.dts) as i32, is_sync: s.is_sync }).unwrap();
}
let out = match finish {
Finish::Normal => w.finish(),
Finish::Faststart => w.finish_faststart(),
}
.unwrap()
.into_inner();
let path = out_dir().join(out_name);
std::fs::write(&path, &out).unwrap();
// Our own reader must see identical sample tables and bytes.
let g = open(out.as_slice()).unwrap();
for (k, &i) in av.iter().enumerate() {
let (a, b) = (&f.tracks[i], &g.tracks[k]);
assert_eq!(a.samples.len(), b.samples.len(), "{out_name}: sample count");
assert_eq!(a.edit_offset, b.edit_offset, "{out_name}: edit offset");
assert_eq!(a.codec(), b.codec(), "{out_name}: codec");
for (j, (x, y)) in a.samples.iter().zip(&b.samples).enumerate() {
assert_eq!((x.size, x.dts, x.pts, x.duration, x.is_sync), (y.size, y.dts, y.pts, y.duration, y.is_sync), "{out_name}: sample {j}");
}
for j in 0..a.samples.len() {
assert_eq!(f.read_sample(data.as_slice(), i, j).unwrap(), g.read_sample(out.as_slice(), k, j).unwrap());
}
}
assert_eq!(g.metadata.title(), Some("FilmCraft test"));
Some((f, path))
}
fn stream_packets(path: &Path) -> Vec<Vec<Value>> {
let pk = packets(path);
let n = pk.iter().filter_map(|p| int(&p["stream_index"])).max().map(|m| m + 1).unwrap_or(0);
(0..n).map(|i| pk.iter().filter(|p| int(&p["stream_index"]) == Some(i)).cloned().collect()).collect()
}
/// Compare ffprobe's view of two files (per-stream packets: pts, dts, size, key flag).
fn assert_same_packets(a: &Path, b: &Path) {
let pa = stream_packets(a);
let pb = stream_packets(b);
for (i, (x, y)) in pa.iter().zip(&pb).enumerate() {
let key = |p: &Value| (int(&p["pts"]), int(&p["dts"]), int(&p["size"]), p["flags"].as_str().map(|f| f.starts_with('K')));
let kx: Vec<_> = x.iter().map(key).collect();
let ky: Vec<_> = y.iter().map(key).collect();
assert_eq!(kx.len(), ky.len(), "stream {i}: packet count {} vs {}", a.display(), b.display());
for (j, (p, q)) in kx.iter().zip(&ky).enumerate() {
assert_eq!(p, q, "stream {i} packet {j}");
}
}
}
fn assert_same_streams(a: &Path, b: &Path) {
let sa = streams(a);
let sb = streams(b);
for (x, y) in sa.iter().zip(&sb) {
if x["codec_type"] == "data" {
continue;
}
for k in ["codec_name", "width", "height", "sample_rate", "channels", "nb_frames", "duration_ts", "time_base", "profile", "pix_fmt"] {
assert_eq!(x[k], y[k], "stream field {k}");
}
}
}
fn decode_clean(path: &Path) {
let err = ffmpeg_decode_errors(path).unwrap();
assert!(err.trim().is_empty(), "ffmpeg reported errors for {}: {err}", path.display());
}
#[test]
fn remux_h264_aac_mp4_variants() {
let (Some(src), Some(_)) = (fixture("h264_bframes.mp4"), ffprobe()) else { return };
for (name, brand, finish) in [
("remux_h264_aac.mp4", Brand::Mp4, Finish::Normal),
("remux_h264_aac_fast.mp4", Brand::Mp4, Finish::Faststart),
("remux_h264_aac.mov", Brand::Mov, Finish::Normal),
] {
let (_, out) = remux(&src, name, brand, finish, None).unwrap();
decode_clean(&out);
assert_same_packets(&src, &out);
assert_same_streams(&src, &out);
eprintln!("{name}: ok");
}
// Faststart layout: moov before mdat.
let d = std::fs::read(out_dir().join("remux_h264_aac_fast.mp4")).unwrap();
let moov = d.windows(4).position(|w| w == b"moov").unwrap();
let mdat = d.windows(4).position(|w| w == b"mdat").unwrap();
assert!(moov < mdat);
}
#[test]
fn remux_other_codecs() {
if ffprobe().is_none() {
return;
}
for (src, name, brand) in [
("hevc.mp4", "remux_hevc.mp4", Brand::Mp4),
("h264.mov", "remux_h264_pcm.mov", Brand::Mov),
("mjpeg.mov", "remux_mjpeg.mov", Brand::Mov),
("pcm_f32.mov", "remux_pcm_f32.mov", Brand::Mov),
("pcm_s16be.mov", "remux_pcm_s16be.mov", Brand::Mov),
("aac_stereo44.m4a", "remux_aac.m4a", Brand::Mp4),
("colr_pasp.mov", "remux_colr_pasp.mov", Brand::Mov),
("editlist_cut.mp4", "remux_editlist.mp4", Brand::Mp4),
("alac.m4a", "remux_alac.m4a", Brand::Mp4),
("flac.mp4", "remux_flac.mp4", Brand::Mp4),
("opus.mp4", "remux_opus.mp4", Brand::Mp4),
("av1.mp4", "remux_av1.mp4", Brand::Mp4),
("vp9.mp4", "remux_vp9.mp4", Brand::Mp4),
("ac3.mp4", "remux_ac3.mp4", Brand::Mp4),
("dnxhd.mov", "remux_dnxhd.mov", Brand::Mov),
] {
let Some(p) = fixture(src) else { continue };
let (f, out) = remux(&p, name, brand, Finish::Faststart, None).unwrap();
decode_clean(&out);
let pcm = f.tracks.iter().any(|t| t.pcm_chunked);
if !pcm {
assert_same_packets(&p, &out);
}
assert_same_streams(&p, &out);
eprintln!("{name}: ok");
}
}
#[test]
fn remux_prores_pcm24_with_timecode() {
let (Some(src), Some(_)) = (fixture("prores.mov"), ffprobe()) else { return };
let tc = TimecodeConfig { flags: 0, timescale: 25, frame_duration: 1, frames_per_second: 25, start_frame: None, name: None };
let (f, out) = remux(&src, "remux_prores_tc.mov", Brand::Mov, Finish::Normal, Some((tc, 25 * 3600))).unwrap();
decode_clean(&out);
assert_same_streams(&src, &out);
let st = streams(&out);
assert!(st.iter().any(|s| s["tags"]["timecode"] == "01:00:00:00"), "timecode missing: {st:?}");
// PCM byte totals survive ffmpeg's repacketisation.
let g = open(std::fs::read(&out).unwrap()).unwrap();
let a = f.track_of_kind(TrackKind::Audio).unwrap();
let sum = |m: &Mp4File, i: usize| m.tracks[i].samples.iter().map(|s| s.size as u64).sum::<u64>();
assert_eq!(sum(&f, a), sum(&g, g.track_of_kind(TrackKind::Audio).unwrap()));
let t = &g.tracks[g.track_of_kind(TrackKind::Timecode).unwrap()];
let CodecConfig::Timecode(tc) = t.codec().unwrap() else { panic!() };
assert_eq!(tc.start_frame, Some(90000));
}
#[test]
fn pcm_in_mp4_ipcm() {
let (Some(src), Some(_)) = (fixture("pcm_s16be.mov"), ffprobe()) else { return };
let (_, out) = remux(&src, "remux_ipcm.mp4", Brand::Mp4, Finish::Normal, None).unwrap();
let st = streams(&out);
assert_eq!(st[0]["codec_tag_string"], "ipcm");
assert_eq!(st[0]["codec_name"], "pcm_s16be");
decode_clean(&out);
}
#[test]
fn aac_priming_edit() {
let (Some(src), Some(_)) = (fixture("aac.mp4"), ffprobe()) else { return };
let data = std::fs::read(&src).unwrap();
let f = open(data.as_slice()).unwrap();
let t = &f.tracks[0];
let mut w = Mp4Writer::new(Cursor::new(Vec::new()), WriterOptions::new(Brand::Mp4)).unwrap();
let mut cfg = TrackConfig::new(t.entries[0].clone(), t.timescale);
cfg.media_start = Some(1024);
let k = w.add_track(cfg).unwrap();
for (i, s) in t.samples.iter().enumerate() {
let d = f.read_sample(data.as_slice(), 0, i).unwrap();
w.write_sample(k, WriteSample { data: &d, duration: s.duration, composition_offset: 0, is_sync: true }).unwrap();
}
let out = out_dir().join("aac_priming.mp4");
std::fs::write(&out, w.finish().unwrap().into_inner()).unwrap();
decode_clean(&out);
let pk = packets(&out);
assert_eq!(int(&pk[0]["pts"]), Some(-1024));
assert_eq!(int(&streams(&out)[0]["duration_ts"]), int(&streams(&src)[0]["duration_ts"]));
}
#[test]
fn fragmented_writer_ffmpeg() {
let (Some(src), Some(_)) = (fixture("h264_bframes.mp4"), ffprobe()) else { return };
let data = std::fs::read(&src).unwrap();
let f = open(data.as_slice()).unwrap();
let mut w = FragmentedWriter::new(Vec::new(), WriterOptions::new(Brand::Mp4));
let tracks: Vec<usize> = (0..f.tracks.len()).collect();
for t in &f.tracks {
w.add_track(TrackConfig::new(t.entries[0].clone(), t.timescale)).unwrap();
}
let v = f.track_of_kind(TrackKind::Video).unwrap();
for (t, i) in interleave(&f, &tracks) {
let s = f.tracks[t].samples[i];
if t == v && s.is_sync && i > 0 {
w.flush_fragment().unwrap();
}
let d = f.read_sample(data.as_slice(), t, i).unwrap();
w.write_sample(t, WriteSample { data: &d, duration: s.duration, composition_offset: (s.pts - s.dts) as i32, is_sync: s.is_sync }).unwrap();
}
let bytes = w.finish().unwrap();
let out = out_dir().join("our_frag.mp4");
std::fs::write(&out, &bytes).unwrap();
decode_clean(&out);
let g = open(bytes.as_slice()).unwrap();
assert!(g.fragmented && g.fragment_count >= 4);
// ffprobe sees raw timestamps (no edit list in our init segment).
let ours = stream_packets(&out);
for (ti, t) in f.tracks.iter().enumerate() {
assert_eq!(ours[ti].len(), t.samples.len());
for (p, s) in ours[ti].iter().zip(&t.samples) {
assert_eq!(int(&p["pts"]), Some(s.pts));
assert_eq!(int(&p["dts"]), Some(s.dts));
assert_eq!(int(&p["size"]), Some(s.size as i64));
}
for i in 0..t.samples.len() {
assert_eq!(f.read_sample(data.as_slice(), ti, i).unwrap(), g.read_sample(bytes.as_slice(), ti, i).unwrap());
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.