From b620f4c22f11238d407f04d9ec52cc2cf0286550 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Sat, 3 Oct 2026 05:21:04 -0400 Subject: [PATCH] M13.4: HEVC / AV1 export round trips (FilmCraft import + ffprobe/ffmpeg/libdav1d oracles) Co-Authored-By: Claude Opus 5.5 --- crates/export/tests/hevc_av1_roundtrip.rs | 271 ++++++++++++++++++++++ 1 file changed, 271 insertions(+) create mode 100644 crates/export/tests/hevc_av1_roundtrip.rs diff --git a/crates/export/tests/hevc_av1_roundtrip.rs b/crates/export/tests/hevc_av1_roundtrip.rs new file mode 100644 index 00000000..d3ae0228 --- /dev/null +++ b/crates/export/tests/hevc_av1_roundtrip.rs @@ -0,0 +1,271 @@ +//! HEVC (MP4 `hvc1`) and AV1 (MP4 `av01`, WebM `V_AV1`) export, decoded back through +//! EffectCraft's own import path (FilmCraft's demuxers and HEVC / AV1 decoders) and — when +//! installed — ffprobe / ffmpeg as external oracles (skipped otherwise). +//! +//! The comp: 64×48 @ 10 fps, 1.2 s (12 frames), dark-blue background, a red solid of 32×48 +//! centred, starting at frame 5 (inter frames code both static and changing blocks). + +use std::path::{Path, PathBuf}; +use std::process::Command; + +use effectcraft_color::Label; +use effectcraft_export::render_queue::{AudioOutput, CodecProfile, OutputFormat, OutputModule, RateControlMode, RenderSettings, TimeSpan, WebmVideoCodec}; +use effectcraft_export::{Job, Progress, export}; +use effectcraft_media::MediaPool; +use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, Project, Solid, build}; +use effectcraft_raster::Image; +use effectcraft_render::{FootageSource, NoFootage}; +use effectcraft_time::{FrameRate, Tick}; + +const W: u32 = 64; +const H: u32 = 48; +const BG: [f32; 3] = [0.1, 0.1, 0.4]; +const FRAMES: u64 = 12; + +fn out_dir(name: &str) -> PathBuf { + let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/export-hevc-av1").join(name); + let _ = std::fs::remove_dir_all(&d); + std::fs::create_dir_all(&d).expect("mkdir"); + d +} + +fn project(audio: Option<&Path>) -> (Project, ItemId) { + let mut p = Project::default(); + let mut comp = Comp::new(W, H, FrameRate::new(10, 1), Tick::from_seconds_f64(1.2)); + comp.background = BG; + let sid = p.add_item("Red", Label::Red, None, ItemKind::Solid(Solid { color: [1.0, 0.0, 0.0], width: 32, height: H, pixel_aspect: 1.0 })); + let mut l = build::layer(&mut p, &comp, "Red", LayerSource::Solid { item: sid }, (32, H), None); + l.in_point = comp.frame_rate.tick_of(5); + comp.layers.push(l); + if let Some(path) = audio { + let f = effectcraft_media::probe(path).expect("probe wav"); + let fid = p.add_item("tone.wav", Label::SeaFoam, None, ItemKind::Footage(f)); + let l = build::layer(&mut p, &comp, "tone", LayerSource::Footage { item: fid }, (0, 0), None); + comp.layers.push(l); + } + let cid = p.add_item("Comp 1", Label::Sandstone, None, ItemKind::Comp(comp.into())); + (p, cid) +} + +fn run(p: &Project, cid: ItemId, footage: &dyn FootageSource, om: &OutputModule, path: &Path) -> effectcraft_export::Report { + let s = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() }; + let path = path.to_string_lossy().to_string(); + let job = Job { project: p, footage, expr: None, accel: None, comp: cid, settings: &s, output: om, path: &path, sink: None, nested_switches: true }; + let mut last = Progress::default(); + let r = export(&job, &mut |pr| { + last = *pr; + true + }) + .expect("export"); + assert_eq!((last.done, r.frames), (FRAMES, FRAMES)); + r +} + +fn px(img: &Image, x: u32, y: u32) -> [f32; 4] { + img.data[img.idx(x, y)] +} + +fn near(a: [f32; 3], b: [f32; 3], tol: f32) -> bool { + a.iter().zip(b).all(|(x, y)| (x - y).abs() <= tol) +} + +fn check_frame(img: &Image, k: u64, tol: f32) { + let corner = px(img, 2, 2); + assert!(near([corner[0], corner[1], corner[2]], BG, tol), "frame {k} corner {corner:?}"); + let c = px(img, img.width / 2, img.height / 2); + let want = if k >= 5 { [1.0, 0.0, 0.0] } else { BG }; + assert!(near([c[0], c[1], c[2]], want, tol), "frame {k} centre {c:?} want {want:?}"); +} + +/// Import our file through the media layer and check every frame. +fn decode_movie(path: &Path, tol: f32) -> effectcraft_project::Footage { + let f = effectcraft_media::probe(path).expect("probe our output"); + assert_eq!((f.width, f.height), (W, H)); + assert!(f.has_video); + let n = f.frame_rate.frame_at(f.duration - Tick(1)) + 1; + assert_eq!(n as u64, FRAMES, "frame count from duration {:?} @ {:?}", f.duration, f.frame_rate); + let pool = MediaPool::new(); + for k in 0..FRAMES { + let img = pool.frame_at(&f, f.frame_rate.tick_of(k as i64)).expect("decode"); + check_frame(&img, k, tol); + } + f +} + +fn have(tool: &str) -> bool { + Command::new(tool).arg("-version").output().map(|o| o.status.success()).unwrap_or(false) +} + +/// `codec|w|h|pix_fmt|frames` of the video stream, or `None` without ffprobe. +fn ffprobe_video(path: &Path) -> Option { + if !have("ffprobe") { + eprintln!("ffprobe not found: skipping the oracle"); + return None; + } + let out = Command::new("ffprobe") + .args(["-v", "error", "-select_streams", "v:0", "-count_frames", "-show_entries", "stream=codec_name,width,height,pix_fmt,nb_read_frames"]) + .args(["-of", "compact=p=0:nk=1"]) + .arg(path) + .output() + .expect("ffprobe"); + assert!(out.status.success() && out.stderr.is_empty(), "ffprobe rejected {}: {}", path.display(), String::from_utf8_lossy(&out.stderr)); + Some(String::from_utf8_lossy(&out.stdout).trim().to_string()) +} + +/// Decode every frame with ffmpeg (no errors allowed) and check frames 0, 4, 5 and the last. +fn ffmpeg_check(path: &Path, decoder: Option<&str>, tol: f32) { + if !have("ffmpeg") { + eprintln!("ffmpeg not found: skipping the oracle decode"); + return; + } + let dir = path.with_extension("ffmpeg"); + let _ = std::fs::create_dir_all(&dir); + let mut cmd = Command::new("ffmpeg"); + cmd.args(["-hide_banner", "-loglevel", "error", "-xerror", "-y"]); + if let Some(d) = decoder { + cmd.args(["-c:v", d]); + } + let out = cmd.arg("-i").arg(path).args(["-pix_fmt", "rgba"]).arg(dir.join("f%03d.png")).output().expect("ffmpeg"); + assert!(out.status.success() && out.stderr.is_empty(), "ffmpeg ({decoder:?}) failed on {}: {}", path.display(), String::from_utf8_lossy(&out.stderr)); + for k in [0, 4, 5, FRAMES - 1] { + let img = image::open(dir.join(format!("f{:03}.png", k + 1))).expect("ffmpeg frame").to_rgba8(); + check_frame(&Image::from_rgba8(img.width(), img.height(), img.as_raw()), k, tol); + } +} + +fn module(format: OutputFormat, keyint: u32) -> OutputModule { + let mut om = OutputModule::for_format(format); + om.codec.keyframe_interval = keyint; + om.codec.rate_control = RateControlMode::Quality; + om.codec.quality = 80; + om.audio = AudioOutput::Off; + om +} + +/// Key-frame flags of the MP4 video samples (via ffprobe), or `None` without it. +fn ffprobe_keyframes(path: &Path) -> Option> { + if !have("ffprobe") { + return None; + } + let out = Command::new("ffprobe") + .args(["-v", "error", "-select_streams", "v:0", "-show_entries", "packet=flags", "-of", "csv=p=0"]) + .arg(path) + .output() + .expect("ffprobe"); + Some(String::from_utf8_lossy(&out.stdout).lines().map(|l| l.starts_with('K')).collect()) +} + +#[test] +fn hevc_mp4_roundtrip() { + let d = out_dir("hevc"); + let (p, cid) = project(None); + let om = module(OutputFormat::Hevc, 4); + let path = d.join("comp.mp4"); + let r = run(&p, cid, &NoFootage, &om, &path); + assert!(r.bytes > 100 && !r.audio); + let bytes = std::fs::read(&path).unwrap(); + assert!(bytes.windows(4).any(|w| w == b"hvc1") && bytes.windows(4).any(|w| w == b"hvcC")); + decode_movie(&path, 0.08); + if let Some(s) = ffprobe_video(&path) { + assert_eq!(s, "hevc|64|48|yuv420p|12"); + } + if let Some(k) = ffprobe_keyframes(&path) { + assert_eq!(k, (0..FRAMES).map(|i| i % 4 == 0).collect::>(), "IDR every 4 frames"); + } + ffmpeg_check(&path, None, 0.08); +} + +#[test] +fn hevc_main10_bitrate_mode() { + let d = out_dir("hevc10"); + let (p, cid) = project(None); + let mut om = module(OutputFormat::Hevc, 0); + om.codec.profile = CodecProfile::Main10; + om.codec.rate_control = RateControlMode::Bitrate; + om.bitrate_kbps = 2_000; + om.codec.level = Some(31); + let path = d.join("comp10.mp4"); + run(&p, cid, &NoFootage, &om, &path); + decode_movie(&path, 0.08); + if let Some(s) = ffprobe_video(&path) { + assert_eq!(s, "hevc|64|48|yuv420p10le|12"); + } + ffmpeg_check(&path, None, 0.08); +} + +#[test] +fn av1_mp4_roundtrip() { + let d = out_dir("av1"); + let (p, cid) = project(None); + let om = module(OutputFormat::Av1, 6); + let path = d.join("comp.mp4"); + run(&p, cid, &NoFootage, &om, &path); + let bytes = std::fs::read(&path).unwrap(); + assert!(bytes.windows(4).any(|w| w == b"av01") && bytes.windows(4).any(|w| w == b"av1C")); + decode_movie(&path, 0.08); + if let Some(s) = ffprobe_video(&path) { + assert_eq!(s, "av1|64|48|yuv420p|12"); + } + if let Some(k) = ffprobe_keyframes(&path) { + assert_eq!(k, (0..FRAMES).map(|i| i % 6 == 0).collect::>(), "key frame every 6 frames"); + } + ffmpeg_check(&path, Some("libdav1d"), 0.08); +} + +#[test] +fn av1_webm_with_opus() { + let d = out_dir("av1-webm"); + let wav = d.join("tone.wav"); + write_tone(&wav, 2.0); + let (p, cid) = project(Some(&wav)); + let pool = MediaPool::new(); + let mut om = module(OutputFormat::WebM, 0); + om.webm_codec = WebmVideoCodec::Av1; + om.codec.profile = CodecProfile::Main10; + om.audio = AudioOutput::Auto; + om.opus_bitrate_kbps = 96; + let path = d.join("comp.webm"); + let r = run(&p, cid, &pool, &om, &path); + assert!(r.audio); + let f = decode_movie(&path, 0.08); + assert!(f.has_audio); + let s = MediaPool::new().audio_samples(&f, Tick::from_seconds_f64(0.3), 24_000, 48_000); + let l = rms(s.iter().step_by(2).copied()); + assert!((l - 0.3536).abs() < 0.06, "left RMS {l}"); + if let Some(s) = ffprobe_video(&path) { + assert_eq!(s, "av1|64|48|yuv420p10le|12"); + } + ffmpeg_check(&path, Some("libdav1d"), 0.08); +} + +fn rms(v: impl Iterator) -> f32 { + let (s, n) = v.fold((0.0f64, 0usize), |(s, n), x| (s + (x as f64) * (x as f64), n + 1)); + (s / n.max(1) as f64).sqrt() as f32 +} + +/// 16-bit stereo WAV with a 440 Hz sine at amplitude 0.5 (left) and silence (right). +fn write_tone(path: &Path, secs: f64) { + let sr = 48_000u32; + let n = (secs * sr as f64) as usize; + let mut data = Vec::with_capacity(n * 4); + for i in 0..n { + let s = (0.5 * (2.0 * std::f64::consts::PI * 440.0 * i as f64 / sr as f64).sin() * 32767.0).round() as i16; + data.extend_from_slice(&s.to_le_bytes()); + data.extend_from_slice(&0i16.to_le_bytes()); + } + let mut w = Vec::new(); + w.extend_from_slice(b"RIFF"); + w.extend_from_slice(&(36 + data.len() as u32).to_le_bytes()); + w.extend_from_slice(b"WAVEfmt "); + w.extend_from_slice(&16u32.to_le_bytes()); + w.extend_from_slice(&1u16.to_le_bytes()); + w.extend_from_slice(&2u16.to_le_bytes()); + w.extend_from_slice(&sr.to_le_bytes()); + w.extend_from_slice(&(sr * 4).to_le_bytes()); + w.extend_from_slice(&4u16.to_le_bytes()); + w.extend_from_slice(&16u16.to_le_bytes()); + w.extend_from_slice(b"data"); + w.extend_from_slice(&(data.len() as u32).to_le_bytes()); + w.extend_from_slice(&data); + std::fs::write(path, w).expect("write wav"); +}