233 lines
9.0 KiB
Rust
233 lines
9.0 KiB
Rust
//! Conformance, bit-exactness, and quality tests against ffmpeg's APV decoder (external oracle).
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::Command;
|
|
|
|
use filmcraft_apv::{
|
|
ChromaFormat, ContentLightLevel, DecodeOptions, Encoder, EncoderConfig, Frame, MasteringDisplay, Profile, decode_frame, decode_frame_with, probe,
|
|
};
|
|
|
|
fn ffmpeg() -> Option<PathBuf> {
|
|
// The APV demuxer is new in ffmpeg 8.0; older toolchains are found but
|
|
// cannot read the fixtures, so they skip like a missing tool (#1249).
|
|
filmcraft_testkit::ffmpeg_with_format_or_skip("apv oracle", "apv", "8.0")
|
|
}
|
|
|
|
fn fixture_dir() -> PathBuf {
|
|
filmcraft_testkit::fixtures_dir("apv")
|
|
}
|
|
|
|
fn native_pix_fmt(profile: Profile) -> &'static str {
|
|
match profile {
|
|
Profile::P422_10 => "yuv422p10le",
|
|
Profile::P422_12 => "yuv422p12le",
|
|
Profile::P444_10 => "yuv444p10le",
|
|
Profile::P444_12 => "yuv444p12le",
|
|
Profile::P4444_10 => "yuva444p10le",
|
|
Profile::P4444_12 => "yuva444p12le",
|
|
Profile::P400_10 => "gray10le",
|
|
}
|
|
}
|
|
|
|
/// Decode a raw `.apv` file with ffmpeg (`-v error -xerror`) to planar `u16` samples.
|
|
fn ffmpeg_decode_raw(ff: &Path, apv_path: &Path, pix_fmt: &str) -> (Vec<u16>, String) {
|
|
let out = Command::new(ff)
|
|
.args(["-hide_banner", "-v", "error", "-xerror", "-f", "apv", "-i"])
|
|
.arg(apv_path)
|
|
.args(["-f", "rawvideo", "-pix_fmt", pix_fmt, "-"])
|
|
.output()
|
|
.expect("run ffmpeg");
|
|
let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
|
|
assert!(out.status.success(), "ffmpeg failed on {:?}: {}", apv_path, stderr);
|
|
let samples = out.stdout.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes([c[0], c[1]])).collect();
|
|
(samples, stderr)
|
|
}
|
|
|
|
fn synthetic_frame(profile: Profile, w: u32, h: u32) -> Frame {
|
|
let chroma = profile.default_chroma();
|
|
let depth = profile.default_bit_depth();
|
|
let mut f = Frame::new(w, h, chroma, depth, chroma == ChromaFormat::Yuv4444);
|
|
let max_v = (1u32 << depth) - 1;
|
|
let lo = 16u32 << (depth - 8);
|
|
let hi = 235u32 << (depth - 8);
|
|
let span = hi - lo;
|
|
|
|
for y in 0..h {
|
|
for x in 0..w {
|
|
// Mix smooth gradients, diagonal edges, and high-frequency patterns
|
|
let grad = (x * 7 + y * 13) % span;
|
|
let checker = if ((x / 3) ^ (y / 5)) & 1 == 0 { 40 << (depth - 10) } else { 0 };
|
|
f.y[(y * w + x) as usize] = (lo + (grad + checker) % span).min(max_v) as u16;
|
|
}
|
|
}
|
|
let cw = f.chroma_width();
|
|
let ch = f.chroma_height();
|
|
for y in 0..ch {
|
|
for x in 0..cw {
|
|
let u = lo + ((x * 11 + y * 5 + 100) % span);
|
|
let v = lo + ((x * 3 + y * 17 + 300) % span);
|
|
f.cb[(y * cw + x) as usize] = u.min(max_v) as u16;
|
|
f.cr[(y * cw + x) as usize] = v.min(max_v) as u16;
|
|
}
|
|
}
|
|
if let Some(a) = f.alpha.as_mut() {
|
|
for y in 0..h {
|
|
for x in 0..w {
|
|
let dx = x as i32 - (w as i32) / 2;
|
|
let dy = y as i32 - (h as i32) / 2;
|
|
a[(y * w + x) as usize] =
|
|
if dx * dx + dy * dy < ((w.min(h) as i32) / 3).pow(2) { max_v as u16 } else { ((x * 19 + y * 23) % (max_v + 1)) as u16 };
|
|
}
|
|
}
|
|
}
|
|
f
|
|
}
|
|
|
|
fn flatten_frame(f: &Frame) -> Vec<u16> {
|
|
let mut v = Vec::new();
|
|
v.extend_from_slice(&f.y);
|
|
v.extend_from_slice(&f.cb);
|
|
v.extend_from_slice(&f.cr);
|
|
if let Some(a) = &f.alpha {
|
|
v.extend_from_slice(a);
|
|
}
|
|
v
|
|
}
|
|
|
|
fn psnr(a: &[u16], b: &[u16], peak: f64) -> f64 {
|
|
if a.is_empty() {
|
|
return 99.0;
|
|
}
|
|
let mse: f64 = a.iter().zip(b).map(|(&x, &y)| (x as f64 - y as f64).powi(2)).sum::<f64>() / a.len() as f64;
|
|
if mse == 0.0 { 99.0 } else { 10.0 * (peak * peak / mse).log10() }
|
|
}
|
|
|
|
#[test]
|
|
fn all_profiles_bit_exact_with_ffmpeg() {
|
|
let Some(ff) = ffmpeg() else { return };
|
|
let dir = fixture_dir();
|
|
|
|
for profile in Profile::ALL {
|
|
let (w, h) = (320u32, 192u32);
|
|
let src = synthetic_frame(profile, w, h);
|
|
let mut cfg = EncoderConfig::new(profile, w, h);
|
|
cfg.qp = Some(12);
|
|
let mut enc = Encoder::with_config(cfg).expect("encoder init");
|
|
|
|
let raw_au = enc.encode_raw_au(&src).expect("encode_raw_au");
|
|
let apv_path = dir.join(format!("oracle_{}.apv", profile.short_name()));
|
|
std::fs::write(&apv_path, &raw_au).expect("write .apv");
|
|
|
|
let (ff_samples, stderr) = ffmpeg_decode_raw(&ff, &apv_path, native_pix_fmt(profile));
|
|
assert!(stderr.trim().is_empty(), "{profile:?}: ffmpeg stderr: {stderr}");
|
|
|
|
let ours = decode_frame(&raw_au).expect("our decode");
|
|
let our_samples = flatten_frame(&ours);
|
|
assert_eq!(our_samples.len(), ff_samples.len(), "{profile:?}: sample count mismatch");
|
|
|
|
let max_diff = our_samples.iter().zip(&ff_samples).map(|(&a, &b)| (a as i32 - b as i32).unsigned_abs()).max().unwrap_or(0);
|
|
assert_eq!(max_diff, 0, "{profile:?}: our decoder must be 100% bit-exact with ffmpeg (max_diff={max_diff})");
|
|
|
|
let peak = ((1u32 << profile.default_bit_depth()) - 1) as f64;
|
|
let y_psnr = psnr(&ours.y, &src.y, peak);
|
|
assert!(y_psnr > 45.0, "{profile:?}: expected high PSNR at qp=12, got {y_psnr:.2} dB");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn odd_dimensions_and_multi_tile_bit_exact_with_ffmpeg() {
|
|
let Some(ff) = ffmpeg() else { return };
|
|
let dir = fixture_dir();
|
|
|
|
for (profile, w, h) in [
|
|
(Profile::P422_10, 640u32, 360u32),
|
|
(Profile::P422_10, 334, 202),
|
|
(Profile::P444_10, 333, 201),
|
|
(Profile::P4444_12, 512, 288),
|
|
(Profile::P400_10, 70, 38),
|
|
] {
|
|
let mut src = synthetic_frame(profile, w, h);
|
|
src.mastering_display = Some(MasteringDisplay {
|
|
primaries: [(46400, 19136), (11141, 52232), (8585, 3015)],
|
|
white_point: (20493, 21561),
|
|
max_luminance: 1000 << 8,
|
|
min_luminance: 1,
|
|
});
|
|
src.content_light = Some(ContentLightLevel { max_cll: 1000, max_fall: 400 });
|
|
|
|
let mut enc = Encoder::new(profile, w, h).expect("encoder init");
|
|
let raw_au = enc.encode_raw_au(&src).expect("encode");
|
|
let apv_path = dir.join(format!("oracle_geom_{}_{w}x{h}.apv", profile.short_name()));
|
|
std::fs::write(&apv_path, &raw_au).expect("write .apv");
|
|
|
|
let (ff_samples, stderr) = ffmpeg_decode_raw(&ff, &apv_path, native_pix_fmt(profile));
|
|
assert!(stderr.trim().is_empty(), "{profile:?} {w}x{h}: {stderr}");
|
|
|
|
let hdr = probe(&raw_au).expect("probe");
|
|
assert_eq!((hdr.width, hdr.height), (w, h));
|
|
|
|
let ours = decode_frame(&raw_au).expect("decode");
|
|
assert_eq!(ours.mastering_display, src.mastering_display);
|
|
assert_eq!(ours.content_light, src.content_light);
|
|
|
|
let our_samples = flatten_frame(&ours);
|
|
assert_eq!(our_samples, ff_samples, "{profile:?} {w}x{h}: bit-exact match with ffmpeg failed");
|
|
|
|
// Also verify single-threaded decode produces identical output
|
|
let ours_st = decode_frame_with(&raw_au, &DecodeOptions { bit_depth: None, threads: false }).expect("decode single-threaded");
|
|
assert_eq!(ours, ours_st);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn custom_q_matrix_and_fh_tile_sizes_bit_exact_with_ffmpeg() {
|
|
let Some(ff) = ffmpeg() else { return };
|
|
let dir = fixture_dir();
|
|
|
|
let profile = Profile::P444_12;
|
|
let (w, h) = (512u32, 256u32);
|
|
let src = synthetic_frame(profile, w, h);
|
|
|
|
let mut q_matrix = [[16u8; 64]; 4];
|
|
for (c, qm) in q_matrix.iter_mut().enumerate() {
|
|
for y in 0..8 {
|
|
for x in 0..8 {
|
|
// Intentionally asymmetric (x != y weight) to verify exact (x, y) matrix orientation
|
|
qm[y * 8 + x] = (10 + c * 3 + y * 5 + x * 2) as u8;
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut cfg = EncoderConfig::new(profile, w, h);
|
|
cfg.qp = Some(18);
|
|
cfg.q_matrix = Some(q_matrix);
|
|
cfg.write_tile_sizes_in_fh = true;
|
|
cfg.tile_width_in_mbs = 16;
|
|
cfg.tile_height_in_mbs = 8;
|
|
|
|
let mut enc = Encoder::with_config(cfg).expect("encoder init");
|
|
let raw_au = enc.encode_raw_au(&src).expect("encode");
|
|
let apv_path = dir.join("oracle_custom_qmat_444-12.apv");
|
|
std::fs::write(&apv_path, &raw_au).expect("write .apv");
|
|
|
|
let (ff_samples, stderr) = ffmpeg_decode_raw(&ff, &apv_path, native_pix_fmt(profile));
|
|
assert!(stderr.trim().is_empty(), "ffmpeg stderr: {stderr}");
|
|
|
|
let hdr = probe(&raw_au).expect("probe");
|
|
assert!(hdr.use_q_matrix);
|
|
assert!(hdr.tile_sizes_in_fh.is_some());
|
|
assert_eq!(hdr.num_tiles(), 4);
|
|
|
|
let ours = decode_frame(&raw_au).expect("decode");
|
|
let our_samples = flatten_frame(&ours);
|
|
assert_eq!(our_samples, ff_samples, "asymmetric q_matrix decode must be bit-exact with ffmpeg");
|
|
|
|
// Verify 8-bit and 16-bit rescaled output
|
|
let d8 = decode_frame_with(&raw_au, &DecodeOptions { bit_depth: Some(8), threads: true }).expect("decode 8-bit");
|
|
assert_eq!(d8.bit_depth, 8);
|
|
assert!(d8.y.iter().all(|&s| s <= 255));
|
|
|
|
let d16 = decode_frame_with(&raw_au, &DecodeOptions { bit_depth: Some(16), threads: true }).expect("decode 16-bit");
|
|
assert_eq!(d16.bit_depth, 16);
|
|
}
|