f67d38b35cc5
mxf_oracle.rs
//! MXF against ffmpeg: ffmpeg writes the files (OP1a, OP-Atom, D-10) and decodes them as the
//! oracle. Our decode must match frame for frame (H.264 bit-exact, VC-3 ±2, ProRes ±1 LSB), seek
//! to random frames exactly, and give sample-exact PCM.
use crate::common;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use common::*;
use filmcraft_codecs::MxfSource;
use filmcraft_media::{FrameRequest, MediaKind, MediaSource};
use filmcraft_time::FrameRate;
const V25: &[&str] = &["-f", "lavfi", "-i", "testsrc2=size=320x240:rate=25"];
const TONE: &[&str] = &["-f", "lavfi", "-i", "sine=frequency=440:sample_rate=48000"];
const NOISE: &[&str] = &["-f", "lavfi", "-i", "anoisesrc=color=pink:sample_rate=48000:amplitude=0.5:seed=7"];
fn spec(name: &str) -> Vec<String> {
let cat = |p: &[&[&str]]| p.concat().into_iter().map(String::from).collect::<Vec<_>>();
match name {
// long-GOP H.264 with B pictures (ffmpeg writes no temporal offsets: order from the POCs)
"mxf_h264_bf2.mxf" => cat(&[
V25,
NOISE,
&["-t", "2", "-c:v", "libx264", "-bf", "2", "-g", "12", "-pix_fmt", "yuv420p", "-c:a", "pcm_s16le", "-ac", "2", "-timecode", "01:00:00:00"],
]),
// the same at 720p and a high rate: pictures far longer than the head read for the order
"mxf_h264_bf2_720p.mxf" => cat(&[
&["-f", "lavfi", "-i", "testsrc2=size=1280x720:rate=25"],
NOISE,
&["-t", "2", "-c:v", "libx264", "-bf", "2", "-g", "12", "-b:v", "12M", "-pix_fmt", "yuv420p", "-c:a", "pcm_s16le", "-ac", "2"],
]),
"mxf_h264_2997df.mxf" => cat(&[
&["-f", "lavfi", "-i", "testsrc2=size=320x240:rate=30000/1001"],
NOISE,
&["-t", "1", "-c:v", "libx264", "-bf", "0", "-g", "10", "-pix_fmt", "yuv420p", "-c:a", "pcm_s24le", "-ac", "2", "-timecode", "01:00:00;00"],
]),
"mxf_dnxhr_lb.mxf" => {
cat(&[V25, TONE, &["-t", "1", "-c:v", "dnxhd", "-profile:v", "dnxhr_lb", "-pix_fmt", "yuv422p", "-c:a", "pcm_s24le", "-ac", "2"]])
}
"mxf_prores.mxf" => cat(&[V25, TONE, &["-t", "1", "-c:v", "prores_ks", "-profile:v", "3", "-pix_fmt", "yuv422p10le", "-c:a", "pcm_s16le"]]),
"mxf_mpeg2.mxf" => cat(&[V25, NOISE, &["-t", "1", "-c:v", "mpeg2video", "-bf", "2", "-c:a", "pcm_s16le"]]),
// XDCAM HD422 style: 1080i 4:2:2 long GOP
"mxf_xdcam_hd422.mxf" => cat(&[
&["-f", "lavfi", "-i", "testsrc2=size=1920x1080:rate=50,tinterlace=mode=interleave_top,setfield=tff"],
NOISE,
&[
"-t",
"0.4",
"-c:v",
"mpeg2video",
"-pix_fmt",
"yuv422p",
"-flags",
"+ilme+ildct",
"-bf",
"2",
"-g",
"12",
"-b:v",
"50M",
"-c:a",
"pcm_s24le",
"-ac",
"2",
],
]),
"mxf_atom_dnxhr.mxf" => cat(&[V25, &["-t", "1", "-c:v", "dnxhd", "-profile:v", "dnxhr_lb", "-pix_fmt", "yuv422p", "-f", "mxf_opatom"]]),
"mxf_atom_pcm.mxf" => cat(&[NOISE, &["-t", "1", "-c:a", "pcm_s24le", "-ac", "1", "-f", "mxf_opatom"]]),
"mxf_d10.mxf" => cat(&[
&["-f", "lavfi", "-i", "testsrc2=size=720x608:rate=25"],
NOISE,
&[
"-t",
"0.4",
"-c:v",
"mpeg2video",
"-pix_fmt",
"yuv422p",
"-minrate",
"30M",
"-maxrate",
"30M",
"-b:v",
"30M",
"-bufsize",
"1200000",
"-rc_init_occupancy",
"1200000",
"-intra_vlc",
"1",
"-non_linear_quant",
"1",
"-g",
"1",
"-flags",
"+ildct+low_delay",
"-dc",
"10",
"-ps",
"1",
"-qmin",
"1",
"-qmax",
"3",
"-c:a",
"pcm_s16le",
"-ac",
"4",
"-f",
"mxf_d10",
],
]),
other => panic!("unknown fixture {other}"),
}
}
pub const ALL: &[&str] = &[
"mxf_h264_bf2.mxf",
"mxf_h264_bf2_720p.mxf",
"mxf_h264_2997df.mxf",
"mxf_dnxhr_lb.mxf",
"mxf_prores.mxf",
"mxf_mpeg2.mxf",
"mxf_xdcam_hd422.mxf",
"mxf_atom_dnxhr.mxf",
"mxf_atom_pcm.mxf",
"mxf_d10.mxf",
];
fn make(ff: &Path, name: &str) -> PathBuf {
let args = spec(name);
let refs: Vec<&str> = args.iter().map(String::as_str).collect();
fixture(ff, name, &refs).unwrap_or_else(|| panic!("could not generate {name}"))
}
fn open(p: &Path) -> MxfSource {
MxfSource::open(p.file_name().unwrap().to_str().unwrap(), bytes(p)).unwrap()
}
/// Number of video packets ffprobe lists.
fn ffprobe_video_packets(file: &Path) -> Option<usize> {
let fp = filmcraft_testkit::ffprobe()?;
let o = std::process::Command::new(fp)
.args(["-v", "error", "-select_streams", "v:0", "-count_packets", "-show_entries", "stream=nb_read_packets", "-of", "csv=p=0"])
.arg(file)
.output()
.ok()?;
String::from_utf8_lossy(&o.stdout).trim().parse().ok()
}
/// Every frame in order, then `seeks` random frames, against ffmpeg's decode (within `tol`).
fn check_video(ff: &Path, file: &Path, pix_fmt: &str, chroma: (usize, usize), bps: usize, tol: u16, seeks: usize) {
let src = open(file);
let v = src.info().video.clone().unwrap();
let (w, h) = (v.width as usize, v.height as usize);
let (cw, ch) = (w / chroma.0, h / chroma.1);
let raw = ffmpeg_frames(ff, file, pix_fmt);
let fsize = (w * h + 2 * cw * ch) * bps;
let n = raw.len() / fsize;
let rate = v.frame_rate;
assert_eq!(src.info().duration, rate.tick_of(n as i64), "{}: duration = ffmpeg's frame count {n}", file.display());
if let Some(p) = ffprobe_video_packets(file) {
assert_eq!(p, n, "packets = frames");
}
let frame = |i: usize| raw_planes(&raw[i * fsize..(i + 1) * fsize], w, h, cw, ch, bps);
let mut worst = 0;
for i in 0..n {
let f = src.video_frame(FrameRequest::full(rate.tick_of(i as i64))).unwrap();
let d = max_diff(&planes(&f), &frame(i));
worst = worst.max(d);
assert!(d <= tol, "{}: frame {i} differs by {d}", file.display());
}
// random access on a fresh source (no warm cache), out of order
let src = open(file);
let mut rng = Rng(0x9E37_79B9_7F4A_7C15);
for _ in 0..seeks {
let i = rng.below(n as u64) as usize;
let f = src.video_frame(FrameRequest::full(rate.tick_of(i as i64))).unwrap();
let d = max_diff(&planes(&f), &frame(i));
assert!(d <= tol, "{}: seek to frame {i} differs by {d}", file.display());
}
eprintln!("{}: {n} frames, max diff {worst}", file.display());
}
/// Our audio, as interleaved f32, equals ffmpeg's decode exactly.
fn check_audio_exact(ff: &Path, file: &Path, extra: &[&str]) {
let src = open(file);
let a = src.info().audio().cloned().unwrap();
let ch = a.channels as usize;
let want = ffmpeg_audio_f32(ff, file, extra);
let n = want.len() / ch;
assert!(n > 0);
let got = src.audio(0, n, a.sample_rate).unwrap();
for i in 0..n {
for c in 0..ch {
assert_eq!(got.channels[c][i], want[i * ch + c], "{}: sample {i} channel {c}", file.display());
}
}
// random windows (sample-exact seeking)
let mut rng = Rng(77);
for _ in 0..20 {
let s = rng.below(n as u64 - 100) as usize;
let len = 1 + rng.below(3000) as usize;
let got = src.audio(s as i64, len, a.sample_rate).unwrap();
for k in 0..len.min(n - s) {
for c in 0..ch {
assert_eq!(got.channels[c][k], want[(s + k) * ch + c], "window at {s}+{k}");
}
}
}
eprintln!("{}: {n} sample frames × {ch} channels exact", file.display());
}
#[test]
fn h264_long_gop_with_b_frames_bit_exact() {
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_h264_bf2.mxf");
let src = open(&f);
let info = src.info();
assert_eq!(info.container, "MXF OP1a");
assert_eq!(info.kind, MediaKind::Movie);
let v = info.video.as_ref().unwrap();
assert_eq!((v.width, v.height, v.frame_rate), (320, 240, FrameRate::FPS_25));
assert_eq!(v.codec, "H.264");
assert_eq!(info.start_timecode, Some(90_000), "01:00:00:00 at 25 fps");
assert_eq!(src.file().timecode.unwrap().format(), "01:00:00:00");
let t = &src.file().tracks[src.file().track_of_kind(craft_media::mxf::TrackKind::Picture).unwrap()];
assert!(t.needs_reorder && !t.temporal_offsets, "ffmpeg marks B pictures without temporal offsets");
assert_eq!(t.samples.iter().filter(|s| s.key).count(), 5, "an IDR every 12 frames over 50");
check_video(&ff, &f, "yuv420p", (2, 2), 1, 0, 25);
check_audio_exact(&ff, &f, &[]);
}
/// Reordering B pictures reads only a short head of every picture, not the pictures.
#[test]
fn h264_long_gop_order_needs_only_the_slice_headers() {
use std::sync::Mutex;
/// Remembers the length of every read.
struct Counting(filmcraft_media::SharedReader, Arc<Mutex<Vec<usize>>>);
impl filmcraft_media::reader::ByteReader for Counting {
fn len(&self) -> u64 {
self.0.len()
}
fn read_at(&self, offset: u64, buf: &mut [u8]) -> std::io::Result<()> {
self.1.lock().unwrap().push(buf.len());
self.0.read_at(offset, buf)
}
}
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_h264_bf2_720p.mxf");
let data = bytes(&f);
let reads = Arc::new(Mutex::new(Vec::new()));
let reader = Arc::new(Counting(Arc::new(filmcraft_media::reader::MemReader(data.clone())), reads.clone()));
let src = MxfSource::open_reader("bf2_720p.mxf", reader).unwrap();
let t = &src.file().tracks[src.file().track_of_kind(craft_media::mxf::TrackKind::Picture).unwrap()];
assert!(t.needs_reorder && !t.temporal_offsets);
assert!(t.samples.iter().all(|s| s.size > 16 << 10), "the pictures must be longer than the long head read");
// one 2 KiB head per picture, and no 16 KiB read (the fallback for a slice header that does
// not fit in the short head)
let reads = reads.lock().unwrap();
assert_eq!(reads.iter().filter(|&&n| n == 2 << 10).count(), t.samples.len());
assert!(!reads.contains(&(16 << 10)));
// the order found from the short heads is the right one
check_video(&ff, &f, "yuv420p", (2, 2), 1, 0, 10);
}
#[test]
fn h264_2997_drop_frame_timecode_and_24_bit_audio() {
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_h264_2997df.mxf");
let src = open(&f);
let info = src.info();
assert_eq!(info.video.as_ref().unwrap().frame_rate, FrameRate::FPS_29_97);
let tc = src.file().timecode.unwrap();
assert!(tc.drop_frame);
assert_eq!(tc.format(), "01:00:00;00");
assert_eq!(info.start_timecode, Some(107_892));
assert_eq!(info.audio().unwrap().bits_per_sample, Some(24));
check_video(&ff, &f, "yuv420p", (2, 2), 1, 0, 10);
check_audio_exact(&ff, &f, &[]);
}
#[test]
fn dnxhr_op1a_within_two_lsb() {
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_dnxhr_lb.mxf");
let src = open(&f);
assert_eq!(src.info().video.as_ref().unwrap().codec, "DNxHR LB");
check_video(&ff, &f, "yuv422p", (2, 1), 1, 2, 10);
check_audio_exact(&ff, &f, &[]);
}
#[test]
fn prores_op1a_within_one_lsb() {
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_prores.mxf");
let src = open(&f);
assert!(src.info().video.as_ref().unwrap().codec.starts_with("Apple ProRes 422"), "{}", src.info().video.as_ref().unwrap().codec);
check_video(&ff, &f, "yuv422p10le", (2, 1), 2, 1, 10);
check_audio_exact(&ff, &f, &[]);
}
/// MPEG-2 frames are compared within the IDCT tolerance of `filmcraft-mpeg2v` (an
/// IEEE 1180-accurate IDCT against ffmpeg's integer one).
const MPEG2_TOL: u16 = 4;
#[test]
fn mpeg2_long_gop_decodes() {
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_mpeg2.mxf");
let src = open(&f);
let v = src.info().video.as_ref().unwrap();
assert!(v.codec.starts_with("MPEG-2 Video (Main@"), "{}", v.codec);
assert_eq!(v.pixel_format, "YUV 4:2:0 8-bit, progressive");
// temporal offsets: ffmpeg's MPEG-2 index carries them
let t = &src.file().tracks[src.file().track_of_kind(craft_media::mxf::TrackKind::Picture).unwrap()];
assert!(t.temporal_offsets);
check_video(&ff, &f, "yuv420p", (2, 2), 1, MPEG2_TOL, 12);
check_audio_exact(&ff, &f, &[]);
}
#[test]
fn xdcam_hd422_decodes() {
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_xdcam_hd422.mxf");
let src = open(&f);
let v = src.info().video.as_ref().unwrap();
assert_eq!(v.codec, "MPEG-2 Video (4:2:2@High)");
assert_eq!(v.pixel_format, "YUV 4:2:2 8-bit, interlaced (upper field first)");
assert_eq!((v.width, v.height), (1920, 1080));
check_video(&ff, &f, "yuv422p", (2, 1), 1, MPEG2_TOL, 6);
check_audio_exact(&ff, &f, &[]);
}
#[test]
fn op_atom_video_and_audio_files() {
let ff = filmcraft_testkit::require_ffmpeg!();
let v = make(&ff, "mxf_atom_dnxhr.mxf");
let src = open(&v);
assert_eq!(src.info().container, "MXF OP-Atom");
assert!(!src.info().has_audio());
assert_eq!(src.file().tracks[0].wrapping, craft_media::mxf::Wrapping::Clip);
check_video(&ff, &v, "yuv422p", (2, 1), 1, 2, 10);
let a = make(&ff, "mxf_atom_pcm.mxf");
let src = open(&a);
assert_eq!(src.info().kind, MediaKind::AudioOnly);
assert_eq!(src.info().container, "MXF OP-Atom");
let ai = src.info().audio().cloned().unwrap();
assert_eq!((ai.sample_rate, ai.channels, ai.bits_per_sample), (48_000, 1, Some(24)));
assert_eq!(src.info().duration, filmcraft_time::Tick::from_units(48_000, 48_000));
check_audio_exact(&ff, &a, &[]);
}
#[test]
fn d10_aes3_elements_sample_exact() {
let ff = filmcraft_testkit::require_ffmpeg!();
let f = make(&ff, "mxf_d10.mxf");
let src = open(&f);
let a = src.info().audio().cloned().unwrap();
assert_eq!(a.codec, "AES3 PCM");
assert!(a.channels >= 4, "{}", a.channels);
let v = src.info().video.as_ref().unwrap();
assert_eq!(v.codec, "MPEG-2 Video (4:2:2@Main)");
assert_eq!((v.width, v.height), (720, 608));
// ffmpeg presents D-10 sound as one multichannel stream too
check_audio_exact(&ff, &f, &[]);
// IMX: intra-only 4:2:2 at 608 lines (with the VBI)
check_video(&ff, &f, "yuv422p", (2, 1), 1, MPEG2_TOL, 4);
}
#[test]
fn truncated_and_corrupt_files_never_panic() {
let ff = filmcraft_testkit::require_ffmpeg!();
for name in ["mxf_h264_bf2.mxf", "mxf_atom_pcm.mxf", "mxf_prores.mxf"] {
let f = make(&ff, name);
let full = std::fs::read(&f).unwrap();
let mut rng = Rng(0xDEAD_BEEF);
for k in 1..=16 {
let cut = full.len() * k / 17;
let part: std::sync::Arc<[u8]> = full[..cut].to_vec().into();
if let Ok(s) = MxfSource::open(name, part) {
let info = s.info().clone();
if let Some(v) = &info.video {
for _ in 0..4 {
let t = v.frame_rate.tick_of(rng.below(60) as i64);
let _ = s.video_frame(FrameRequest::full(t));
}
}
if let Some(a) = info.audio() {
let _ = s.audio(rng.below(96_000) as i64, 4000, a.sample_rate);
}
}
}
for _ in 0..30 {
let mut g = full.clone();
for _ in 0..8 {
let at = rng.below(g.len() as u64) as usize;
g[at] = rng.below(256) as u8;
}
if let Ok(s) = MxfSource::open(name, g.into()) {
if s.info().video.is_some() {
for i in [0, 7, 30] {
let _ = s.video_frame(FrameRequest::full(s.info().frame_rate().tick_of(i)));
}
}
if s.info().has_audio() {
let _ = s.audio(0, 9600, 48_000);
}
}
}
}
}
/// `cargo xtask fixtures codecs`: build every MXF fixture.
#[test]
#[ignore]
fn generate_fixtures() {
let Some(ff) = filmcraft_testkit::ffmpeg() else {
for n in ALL {
filmcraft_testkit::fixtures::report(n, filmcraft_testkit::fixtures::Status::Skipped);
}
return;
};
for n in ALL {
let out = dir().join(n);
filmcraft_testkit::fixtures::generate_and_report(n, std::slice::from_ref(&out), || {
let args = spec(n);
let refs: Vec<&str> = args.iter().map(String::as_str).collect();
fixture(&ff, n, &refs)
});
}
}
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.