f67d38b35cc5
tests.rs
use super::*;
use filmcraft_media::generators::GeneratorSource;
use filmcraft_media::{FrameRequest, Generator, MediaSource};
use filmcraft_project::{ItemKind, Label, MediaClip, MediaRef, SequenceSettings, TrackKind};
use filmcraft_render::SourceMap;
use filmcraft_time::TICKS_PER_SECOND;
pub(crate) fn project() -> (Arc<Project>, ItemId, SourceMap) {
let mut p = Project::new("x");
let g = GeneratorSource::new(Generator::ColorMatte { color: [1.0, 0.0, 0.0, 1.0] }, 320, 180, FrameRate::FPS_24, Tick(2 * TICKS_PER_SECOND));
let tone = GeneratorSource::new(Generator::Tone { hz: 440.0, db: -6.0 }, 320, 180, FrameRate::FPS_24, Tick(2 * TICKS_PER_SECOND));
let add = |p: &mut Project, g: &GeneratorSource| {
let info = g.info().clone();
p.add_item(
&info.name.clone(),
Label::Iris,
ItemKind::Media(Box::new(MediaClip {
media: MediaRef::Generator(g.generator.clone()),
info,
interpret: Default::default(),
mark_in: None,
mark_out: None,
markers: vec![],
offline: false,
proxy: None,
identity: None,
})),
None,
)
};
let red = add(&mut p, &g);
let t = add(&mut p, &tone);
let seq = p.new_sequence("s", SequenceSettings { width: 320, height: 180, frame_rate: FrameRate::FPS_24, ..Default::default() }, 1, 1, None);
let r = FrameRate::FPS_24;
let v = p.make_track_item(red, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, r.tick_of(24)), r).unwrap();
let a = p.make_track_item(t, TrackKind::Audio, Tick::ZERO, TimeRange::new(Tick::ZERO, r.tick_of(24)), r).unwrap();
p.sequence_mut(seq).unwrap().video_tracks[0].items.push(v);
p.sequence_mut(seq).unwrap().audio_tracks[0].items.push(a);
let mut m = SourceMap::default();
m.0.insert(red, Arc::new(g));
m.0.insert(t, Arc::new(tone));
(Arc::new(p), seq, m)
}
fn tmp(name: &str) -> String {
let d = std::env::temp_dir().join(format!("fc-export-{}", std::process::id()));
std::fs::create_dir_all(&d).unwrap();
d.join(name).to_string_lossy().to_string()
}
#[test]
fn mjpeg_mov_roundtrip() {
let (p, seq, m) = project();
let path = tmp("out.mov");
let prog = Progress::default();
let r = export(&p, seq, &ExportSettings { format: Format::Mjpeg, path: path.clone(), ..Default::default() }, &m, &prog).unwrap();
assert_eq!(r.frames, 24);
assert!(prog.finished.load(Ordering::Relaxed));
let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
let src = filmcraft_codecs::open_bytes("out.mov", bytes).unwrap();
let info = src.info();
assert_eq!(info.video.as_ref().unwrap().width, 320);
assert!((info.duration.seconds() - 1.0).abs() < 0.05, "{}", info.duration.seconds());
let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 2))).unwrap().to_rgba8();
assert!(f[0] > 230 && f[1] < 30, "{:?}", &f[..4]);
let a = src.audio(0, 24_000, 48_000).unwrap();
let pk = a.peaks()[0];
assert!((pk - 0.5).abs() < 0.05, "tone at -6 dB: {pk}");
if let Some(ffprobe) = filmcraft_testkit::ffprobe_or_skip("export mjpeg frame count") {
let out = std::process::Command::new(ffprobe)
.args(["-v", "error", "-count_frames", "-select_streams", "v:0", "-show_entries", "stream=nb_read_frames", "-of", "csv=p=0", &path])
.output()
.unwrap();
assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), "24");
}
}
#[test]
fn wav_png_gif() {
let (p, seq, m) = project();
for (fmt, name) in [(Format::Wav, "a.wav"), (Format::Gif, "a.gif"), (Format::PngSequence, "seq.png")] {
let path = tmp(name);
let prog = Progress::default();
let mut s = ExportSettings { format: fmt, path: path.clone(), scale: 0.5, ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(6)));
let r = export(&p, seq, &s, &m, &prog).unwrap();
assert!(r.bytes > 0, "{fmt:?}");
}
assert!(std::path::Path::new(&tmp("seq005.png")).exists());
}
/// GIF delays are whole centiseconds (#854): at 24 fps they alternate 4/4/5 cs so a second of
/// frames lasts 1000 ms, not 24 × 40 ms = 960 ms.
#[test]
fn gif_frame_delays_add_up_to_the_duration() {
let d: Vec<u16> = (0..6).map(|i| gif_delay_cs(FrameRate::FPS_24, i)).collect();
assert_eq!(d, [4, 4, 5, 4, 4, 4]);
let ntsc: u64 = (0..30).map(|i| u64::from(gif_delay_cs(FrameRate::FPS_29_97, i))).sum();
assert_eq!(ntsc, 100, "30 frames at 29.97 fps last 1.001 s");
// hostile rates neither panic nor overflow
assert_eq!(gif_delay_cs(FrameRate { num: 0, den: 0 }, 3), 0);
let _ = gif_delay_cs(FrameRate { num: 1, den: i64::MAX }, i64::MAX);
let (p, seq, m) = project();
let path = tmp("timing.gif");
let mut s = ExportSettings { format: Format::Gif, path: path.clone(), scale: 0.25, ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(24)));
export(&p, seq, &s, &m, &Progress::default()).unwrap();
use image::AnimationDecoder;
let dec = image::codecs::gif::GifDecoder::new(std::io::Cursor::new(std::fs::read(&path).unwrap())).unwrap();
let frames = dec.into_frames().collect_frames().unwrap();
assert_eq!(frames.len(), 24);
let ms: u32 = frames.iter().map(|f| f.delay().numer_denom_ms()).map(|(n, d)| n / d.max(1)).sum();
assert_eq!(ms, 1000);
}
#[test]
fn prores_export_roundtrip() {
let (p, seq, m) = project();
let path = tmp("pr.mov");
export(&p, seq, &ExportSettings { format: Format::ProRes, path: path.clone(), ..Default::default() }, &m, &Progress::default()).unwrap();
let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
let src = filmcraft_codecs::open_bytes("pr.mov", bytes).unwrap();
assert!(src.info().video.as_ref().unwrap().codec.contains("ProRes 422 HQ"));
let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 3))).unwrap().to_rgba8();
assert!(f[0] > 240 && f[1] < 15 && f[2] < 15, "{:?}", &f[..4]);
}
/// #2142: SDR ProRes, DNxHR and APV (MOV) and H.264 (MP4) exports carry a `colr` box with the
/// export's BT.709 colour: Apple's media stack reads the colour of the MOV codecs only from there.
#[test]
fn sdr_exports_carry_a_colr_box() {
use filmcraft_isobmff::ColorInfo;
let (p, seq, m) = project();
let nclc = ColorInfo::Nclc { primaries: 1, transfer: 1, matrix: 1 };
let nclx = ColorInfo::Nclx { primaries: 1, transfer: 1, matrix: 1, full_range: false };
for (format, name, want) in [
(Format::ProRes, "colr-prores.mov", nclc.clone()),
(Format::DnxHr, "colr-dnxhr.mov", nclc.clone()),
(Format::Apv, "colr-apv.mov", nclc.clone()),
(Format::H264, "colr-h264.mp4", nclx),
] {
let path = tmp(name);
export(&p, seq, &ExportSettings { format, path: path.clone(), include_audio: false, ..Default::default() }, &m, &Progress::default()).unwrap();
let bytes = std::fs::read(&path).unwrap();
let file = filmcraft_isobmff::open(bytes).unwrap();
let t = file.track_of_kind(filmcraft_isobmff::TrackKind::Video).unwrap();
let v = file.tracks[t].entries[0].video.as_ref().unwrap();
assert_eq!(v.color.as_ref(), Some(&want), "{name}");
assert!(v.mastering_display.is_none() && v.content_light.is_none(), "{name}: no HDR metadata on SDR");
}
}
/// ProRes 4444 / 4444 XQ export (#342): 4:4:4 frames under the `ap4h` / `ap4x` codes, and with
/// Include Alpha Channel the picture's alpha survives instead of being flattened over black.
#[test]
fn prores_4444_export_roundtrip() {
let (p, seq, m) = project();
for (profile, label) in [("4444", "ProRes 4444"), ("4444xq", "ProRes 4444 XQ")] {
let path = tmp(&format!("pr_{profile}.mov"));
let s = ExportSettings { format: Format::ProRes, path: path.clone(), prores_profile: profile.into(), ..Default::default() };
export(&p, seq, &s, &m, &Progress::default()).unwrap();
let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
let src = filmcraft_codecs::open_bytes("pr.mov", bytes).unwrap();
let codec = src.info().video.as_ref().unwrap().codec.clone();
assert!(codec.contains(label), "{profile}: {codec}");
let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 3))).unwrap();
assert!(f.format_label().contains("4:4:4"), "{profile}: {}", f.format_label());
let px = f.to_rgba8();
assert!(px[0] > 240 && px[1] < 15 && px[2] < 15 && px[3] == 255, "{profile}: {:?}", &px[..4]);
}
// a half-transparent matte keeps its alpha with Include Alpha Channel, and only then
let mut p = (*p).clone();
let half = GeneratorSource::new(Generator::ColorMatte { color: [1.0, 0.0, 0.0, 0.5] }, 320, 180, FrameRate::FPS_24, Tick(2 * TICKS_PER_SECOND));
let item = p.sequence(seq).unwrap().video_tracks[0].items[0].item;
if let ItemKind::Media(mc) = &mut p.item_mut(item).unwrap().kind {
mc.media = MediaRef::Generator(half.generator.clone());
}
let mut m = m;
m.0.insert(item, Arc::new(half));
let p = Arc::new(p);
for alpha in [true, false] {
let path = tmp(&format!("pr_4444_alpha_{alpha}.mov"));
let s = ExportSettings { format: Format::ProRes, path: path.clone(), prores_profile: "4444".into(), alpha, ..Default::default() };
assert!(s.keeps_alpha() == alpha);
export(&p, seq, &s, &m, &Progress::default()).unwrap();
let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
let src = filmcraft_codecs::open_bytes("pr.mov", bytes).unwrap();
let px = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 3))).unwrap().to_rgba8();
if alpha {
assert!((px[3] as i32 - 128).abs() <= 3, "alpha kept: {:?}", &px[..4]);
} else {
assert_eq!(px[3], 255, "flattened: {:?}", &px[..4]);
}
}
}
#[test]
fn dnxhr_export_roundtrip() {
let (p, seq, m) = project();
for (profile, label) in [("hq", "DNxHR HQ"), ("hqx", "DNxHR HQX"), ("sq", "DNxHR SQ")] {
let path = tmp(&format!("dnx_{profile}.mov"));
let s = ExportSettings { format: Format::DnxHr, path: path.clone(), dnx_profile: profile.into(), ..Default::default() };
export(&p, seq, &s, &m, &Progress::default()).unwrap();
let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
let src = filmcraft_codecs::open_bytes("dnx.mov", bytes).unwrap();
let info = src.info().video.clone().unwrap();
assert_eq!(info.codec, label);
let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 3))).unwrap();
assert!(f.format_label().contains("4:2:2"), "{}", f.format_label());
let px = f.to_rgba8();
assert!(px[0] > 240 && px[1] < 15 && px[2] < 15, "{profile}: {:?}", &px[..4]);
}
}
/// Burn-in: an H.264 export of a dark-blue matte with a caption, decoded by ffmpeg (external test
/// oracle only), has bright caption pixels in the lower part of the frame, and none without
/// `burn_captions` or above the caption.
#[test]
fn caption_burn_in_h264_ffmpeg_oracle() {
let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("H.264 caption burn-in export") else { return };
let mut p = Project::new("cap");
let (w, h) = (640u32, 360u32);
let g = GeneratorSource::new(Generator::ColorMatte { color: [0.0, 0.0, 0.2, 1.0] }, w, h, FrameRate::FPS_24, Tick(2 * TICKS_PER_SECOND));
let info = g.info().clone();
let matte = p.add_item(
"matte",
Label::Iris,
ItemKind::Media(Box::new(MediaClip {
media: MediaRef::Generator(g.generator.clone()),
info,
interpret: Default::default(),
mark_in: None,
mark_out: None,
markers: vec![],
offline: false,
proxy: None,
identity: None,
})),
None,
);
let r = FrameRate::FPS_24;
let seq = p.new_sequence("s", SequenceSettings { width: w, height: h, frame_rate: r, ..Default::default() }, 1, 0, None);
let v = p.make_track_item(matte, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, r.tick_of(24)), r).unwrap();
let tid = filmcraft_project::TrackId(p.alloc_id());
let cid = filmcraft_project::ClipId(p.alloc_id());
let mut ct = filmcraft_project::CaptionTrack::new(tid, "Subtitle".into(), filmcraft_project::CaptionFormat::Subtitle);
ct.style.background = false;
ct.captions.push(filmcraft_project::Caption {
id: cid,
start: Tick::ZERO,
duration: r.tick_of(24),
text: "BURNED IN".into(),
speaker: None,
cue_id: None,
settings: String::new(),
});
let q = p.sequence_mut(seq).unwrap();
q.video_tracks[0].items.push(v);
q.caption_tracks.push(ct);
let mut m = SourceMap::default();
m.0.insert(matte, Arc::new(g));
let p = Arc::new(p);
let decode = |burn: bool| -> Vec<u8> {
let path = tmp(if burn { "burn.mp4" } else { "noburn.mp4" });
let s = ExportSettings { format: Format::H264, path: path.clone(), include_audio: false, burn_captions: burn, ..Default::default() };
export(&p, seq, &s, &m, &Progress::default()).unwrap();
let out = std::process::Command::new(&ffmpeg)
.args(["-v", "error", "-i", &path, "-vf", "select=eq(n\\,12)", "-frames:v", "1", "-f", "rawvideo", "-pix_fmt", "rgb24", "-"])
.output()
.unwrap();
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert_eq!(out.stdout.len(), (w * h * 3) as usize);
out.stdout
};
let bright = |rgb: &[u8], y0: u32, y1: u32, x0: u32, x1: u32| -> usize {
(y0..y1).flat_map(|y| (x0..x1).map(move |x| ((y * w + x) * 3) as usize)).filter(|&i| rgb[i] > 200 && rgb[i + 1] > 200 && rgb[i + 2] > 200).count()
};
let with = decode(true);
let without = decode(false);
let lower = bright(&with, h * 2 / 3, h, 0, w);
assert!(lower > 300, "white caption text in the lower third: {lower}");
assert_eq!(bright(&with, 0, h / 2, 0, w), 0, "nothing above the caption");
assert_eq!(bright(&without, 0, h, 0, w), 0, "no burn-in unless asked");
// centred: text on both sides of the centre line
let (left, right) = (bright(&with, h * 2 / 3, h, 0, w / 2), bright(&with, h * 2 / 3, h, w / 2, w));
assert!(left > 100 && right > 100, "{left} / {right}");
}
/// HDR sequences export PQ / HLG with colour signalling in the bitstream (VUI, ProRes header) and
/// the container (`colr`, `mdcv`, `clli`); our demuxer and ffprobe both read it back, and the
/// picture survives the round trip.
#[test]
fn hdr_exports_signal_pq_and_hlg() {
use filmcraft_color::{ColorPipeline, Transfer, WorkingSpace};
for (ws, fmt, ext, transfer, ff_transfer) in [
(WorkingSpace::Rec2100Pq, Format::ProRes, "mov", Transfer::Pq, "smpte2084"),
(WorkingSpace::Rec2100Pq, Format::H264, "mp4", Transfer::Pq, "smpte2084"),
(WorkingSpace::Rec2100Hlg, Format::ProRes, "mov", Transfer::Hlg, "arib-std-b67"),
(WorkingSpace::Rec2100Hlg, Format::H264, "mp4", Transfer::Hlg, "arib-std-b67"),
] {
let (p, seq, m) = project();
let mut p = (*p).clone();
p.sequence_mut(seq).unwrap().settings.color = ColorPipeline { working: ws, ..ColorPipeline::REC709 };
let p = Arc::new(p);
let path = tmp(&format!("hdr-{}.{ext}", ws.id()));
let s = ExportSettings { format: fmt, path: path.clone(), include_audio: false, ..Default::default() };
export(&p, seq, &s, &m, &Progress::default()).unwrap();
// our demuxer/decoder sees the signalling
let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
let src = filmcraft_codecs::open_bytes(&path, bytes).unwrap();
let v = src.info().video.clone().unwrap();
assert_eq!(v.color.transfer, transfer, "{path}");
assert_eq!(v.color.primaries, filmcraft_color::Primaries::Bt2020, "{path}");
assert_eq!(v.color.matrix, filmcraft_color::Matrix::Bt2020Ncl, "{path}");
// PQ exports carry mastering metadata (1000 cd/m² peak; MaxCLL 0 = unknown), which sets
// the tone-mapping peak when the file is used again
if transfer == Transfer::Pq {
let hdr = v.hdr.unwrap_or_else(|| panic!("{path}: no HDR metadata"));
assert_eq!((hdr.mastering_max_nits, hdr.max_cll, hdr.peak_nits()), (Some(1000.0), None, Some(1000.0)), "{path}");
}
// 709 red matte → BT.2020 HDR → decoded back into Rec. 709 (tone mapped) stays red
let f = src.video_frame(FrameRequest::full(Tick::ZERO)).unwrap();
let back = filmcraft_render::colorman::decode(&Project::new("x"), ItemId(0), &f, 1, &ColorPipeline::REC709);
let c = filmcraft_render::Image::unpremul(back.get(160, 90));
assert!(c[0] > 0.6 && c[1] < 0.05 && c[2] < 0.05, "{path}: {c:?}");
// ffprobe agrees
let Some(ffprobe) = filmcraft_testkit::ffprobe_or_skip("hdr export signalling") else { continue };
let out = std::process::Command::new(&ffprobe)
.args([
"-v",
"error",
"-select_streams",
"v:0",
"-show_entries",
"stream=color_transfer,color_primaries,color_space:stream_side_data",
"-of",
"default=nw=1",
&path,
])
.output()
.unwrap();
let txt = String::from_utf8_lossy(&out.stdout).to_string();
assert!(txt.contains(&format!("color_transfer={ff_transfer}")), "{path}: {txt}");
assert!(txt.contains("color_primaries=bt2020"), "{path}: {txt}");
assert!(txt.contains("color_space=bt2020nc"), "{path}: {txt}");
if transfer == Transfer::Pq {
assert!(txt.contains("Mastering display metadata") && txt.contains("max_luminance=10000000/10000"), "{path}: {txt}");
assert!(txt.contains("Content light level metadata"), "{path}: {txt}");
}
eprintln!("{path}:\n{txt}");
}
}
/// Scenario runner for the GPU hook: everything in one test because the renderer registry is
/// process-global and parallel tests would see each other's factories.
#[test]
fn gpu_hook_scenarios() {
// 1. Declining renderer: byte-equal to Off, and an empty registry too.
crate::reset_frame_renderers_for_tests();
crate::register_frame_renderer(|| None);
let (p, seq, m) = project();
let mk = |path: &String, gpu: Option<bool>| {
let mut s = ExportSettings { format: Format::PngSequence, path: path.clone(), ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(2)));
s.gpu_rendering = match gpu {
Some(true) | None => crate::GpuRendering::Auto,
Some(false) => crate::GpuRendering::Off,
};
export(&p, seq, &s, &m, &Progress::default()).unwrap()
};
mk(&tmp("off.png"), Some(false));
mk(&tmp("auto-declined.png"), Some(true));
assert_eq!(std::fs::read(tmp("off000.png")).unwrap(), std::fs::read(tmp("auto-declined000.png")).unwrap(), "declined GPU export must be byte-equal to Off");
crate::reset_frame_renderers_for_tests();
mk(&tmp("auto-empty.png"), Some(true));
assert_eq!(std::fs::read(tmp("off000.png")).unwrap(), std::fs::read(tmp("auto-empty000.png")).unwrap(), "empty registry must behave like Off");
// 2. Producing renderer: counters up and its picture reaches the export.
crate::reset_frame_renderers_for_tests();
crate::register_frame_renderer(|| Some(Box::new(FakeRenderer(filmcraft_render::plan::DeviceCaps::ALL)) as Box<dyn FrameRenderer>));
mk(&tmp("fake-gpu.png"), Some(true));
assert!(gpu_render_stats().frames >= 2, "gpu frames counted: {:?}", gpu_render_stats());
assert_eq!(gpu_render_stats().fallbacks, 0);
mk(&tmp("fake-off.png"), Some(false));
assert_eq!(gpu_render_stats().fallbacks, 0, "Off must not count as fallback");
assert_ne!(std::fs::read(tmp("fake-gpu000.png")).unwrap(), std::fs::read(tmp("fake-off000.png")).unwrap(), "the fake GPU picture must reach the export");
// 3. Hostile and degenerate frame sizes must not panic with a renderer attached.
crate::reset_frame_renderers_for_tests();
crate::register_frame_renderer(|| None);
for (w, h) in [(1, 1), (17, 13), (4096, 1)] {
let mut p = Project::new("x");
let g = GeneratorSource::new(Generator::ColorMatte { color: [0.5, 0.5, 0.5, 1.0] }, 320, 180, FrameRate::FPS_24, Tick(2 * TICKS_PER_SECOND));
let info = g.info().clone();
let red = p.add_item(
&info.name.clone(),
Label::Iris,
ItemKind::Media(Box::new(MediaClip {
media: MediaRef::Generator(g.generator.clone()),
info,
interpret: Default::default(),
mark_in: None,
mark_out: None,
markers: vec![],
offline: false,
proxy: None,
identity: None,
})),
None,
);
let seq = p.new_sequence("s", SequenceSettings { width: w, height: h, frame_rate: FrameRate::FPS_24, ..Default::default() }, 1, 1, None);
let v = p.make_track_item(red, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(2)), FrameRate::FPS_24).unwrap();
p.sequence_mut(seq).unwrap().video_tracks[0].items.push(v);
let mut m = SourceMap::default();
m.0.insert(red, Arc::new(g));
let mut s = ExportSettings { format: Format::PngSequence, path: tmp("hostile.png"), ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(1)));
s.gpu_rendering = crate::GpuRendering::Auto;
let r = export(&Arc::new(p), seq, &s, &m, &Progress::default());
if r.is_err() {
continue; // sizes the exporter rejects are fine too — as long as nothing panics
}
let bytes = std::fs::read(tmp("hostile000.png")).unwrap_or_default();
assert!(!bytes.is_empty(), "{w}x{h}: PNG written");
}
// 4. A renderer that panics is dropped, not put back: the export still completes, every
// frame comes from the CPU (byte-equal to Off), and no renderer is used after its panic.
crate::reset_frame_renderers_for_tests();
PANICS.store(0, std::sync::atomic::Ordering::SeqCst);
crate::register_frame_renderer(|| Some(Box::new(PanickingRenderer) as Box<dyn FrameRenderer>));
let (p, seq, m) = project();
let mk12 = |path: &String, gpu: crate::GpuRendering| {
let mut s = ExportSettings { format: Format::PngSequence, path: path.clone(), ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(12)));
s.gpu_rendering = gpu;
export(&p, seq, &s, &m, &Progress::default()).unwrap()
};
mk12(&tmp("panic-off.png"), crate::GpuRendering::Off);
mk12(&tmp("panic-auto.png"), crate::GpuRendering::Auto);
for f in ["000", "005", "011"] {
assert_eq!(
std::fs::read(tmp(&format!("panic-off{f}.png"))).unwrap(),
std::fs::read(tmp(&format!("panic-auto{f}.png"))).unwrap(),
"frame {f}: a panicking GPU renderer falls back to the CPU"
);
}
// at most one panic per pooled renderer (4): none is used again after it panicked
assert!(PANICS.load(std::sync::atomic::Ordering::SeqCst) <= 4, "renderer reused after a panic: {}", PANICS.load(std::sync::atomic::Ordering::SeqCst));
// 5. A frame the planner hands back as one CPU image (an adjustment layer with an effect the
// GPU doesn't run, over the clip from frame 12) is rendered by the CPU without taking a
// pooled renderer: it counts as a fallback, and the renderer's picture reaches only the
// frames before it.
crate::reset_frame_renderers_for_tests();
crate::register_frame_renderer(|| Some(Box::new(FakeRenderer(filmcraft_render::plan::DeviceCaps::ALL)) as Box<dyn FrameRenderer>));
let (p, seq, m) = project();
let mut p = Arc::unwrap_or_clone(p);
let r = FrameRate::FPS_24;
let adj = p.add_item("adj", Label::Iris, ItemKind::AdjustmentLayer { width: 320, height: 180, rate: r, duration: Tick(TICKS_PER_SECOND) }, None);
let mut over = p.make_track_item(adj, TrackKind::Video, r.tick_of(12), TimeRange::new(Tick::ZERO, r.tick_of(12)), r).unwrap();
over.effects.insert(0, filmcraft_project::find_effect("emboss").unwrap().instance());
let v2 = filmcraft_project::TrackId(p.alloc_id());
let q = p.sequence_mut(seq).unwrap();
q.video_tracks.push(filmcraft_project::Track::new(v2, TrackKind::Video, "Video 2".into()));
q.video_tracks[1].items.push(over);
let p = Arc::new(p);
let mk24 = |path: &String, gpu: crate::GpuRendering| {
let mut s = ExportSettings { format: Format::PngSequence, path: path.clone(), ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, r.tick_of(24)));
s.gpu_rendering = gpu;
export(&p, seq, &s, &m, &Progress::default()).unwrap()
};
mk24(&tmp("adj-off.png"), crate::GpuRendering::Off);
mk24(&tmp("adj-auto.png"), crate::GpuRendering::Auto);
let frame = |name: &str, f: &str| std::fs::read(tmp(&format!("{name}{f}.png"))).unwrap();
assert_ne!(frame("adj-off", "011"), frame("adj-auto", "011"), "a layered frame goes to the renderer");
for f in ["012", "023"] {
assert_eq!(frame("adj-off", f), frame("adj-auto", f), "frame {f}: an adjustment layer frame is the CPU's");
}
assert_eq!((gpu_render_stats().frames, gpu_render_stats().fallbacks), (12, 12), "{:?}", gpu_render_stats());
// 6. An adjustment layer whose effect the GPU runs (Invert, over the clip from frame 12) is
// handed to a renderer whose device runs adjustment layers, and never to one without an
// effect stage: there those frames render on the export's thread, byte-equal to Off, and
// count as fallbacks.
let (p, seq, m) = project();
let mut p = Arc::unwrap_or_clone(p);
let adj = p.add_item("adj", Label::Iris, ItemKind::AdjustmentLayer { width: 320, height: 180, rate: r, duration: Tick(TICKS_PER_SECOND) }, None);
let mut over = p.make_track_item(adj, TrackKind::Video, r.tick_of(12), TimeRange::new(Tick::ZERO, r.tick_of(12)), r).unwrap();
over.effects.insert(0, filmcraft_project::find_effect("invert").unwrap().instance());
let v2 = filmcraft_project::TrackId(p.alloc_id());
let q = p.sequence_mut(seq).unwrap();
q.video_tracks.push(filmcraft_project::Track::new(v2, TrackKind::Video, "Video 2".into()));
q.video_tracks[1].items.push(over);
let p = Arc::new(p);
let mk24 = |path: &String, gpu: crate::GpuRendering| {
let mut s = ExportSettings { format: Format::PngSequence, path: path.clone(), ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, r.tick_of(24)));
s.gpu_rendering = gpu;
export(&p, seq, &s, &m, &Progress::default()).unwrap()
};
mk24(&tmp("gpu-adj-off.png"), crate::GpuRendering::Off);
crate::reset_frame_renderers_for_tests();
crate::register_frame_renderer(|| Some(Box::new(FakeRenderer(filmcraft_render::plan::DeviceCaps::NONE)) as Box<dyn FrameRenderer>));
mk24(&tmp("gpu-adj-nofx.png"), crate::GpuRendering::Auto);
assert_ne!(frame("gpu-adj-off", "011"), frame("gpu-adj-nofx", "011"), "a frame without the adjustment layer goes to the renderer");
for f in ["012", "023"] {
assert_eq!(frame("gpu-adj-off", f), frame("gpu-adj-nofx", f), "frame {f}: no effect stage, the CPU renders it");
}
assert_eq!((gpu_render_stats().frames, gpu_render_stats().fallbacks), (12, 12), "{:?}", gpu_render_stats());
crate::reset_frame_renderers_for_tests();
crate::register_frame_renderer(|| Some(Box::new(FakeRenderer(filmcraft_render::plan::DeviceCaps::ALL)) as Box<dyn FrameRenderer>));
mk24(&tmp("gpu-adj-fx.png"), crate::GpuRendering::Auto);
for f in ["012", "023"] {
assert_ne!(frame("gpu-adj-off", f), frame("gpu-adj-fx", f), "frame {f}: an effect stage runs the adjustment layer");
}
assert_eq!((gpu_render_stats().frames, gpu_render_stats().fallbacks), (24, 0), "{:?}", gpu_render_stats());
reuse_scenario();
crate::reset_frame_renderers_for_tests();
}
/// `gpu_hook_scenarios` case 6 (run from there: the registry is process-global).
fn reuse_scenario() {
// 6. Parts of a larger job (render-preview segments) reuse the renderers the previous part
// built instead of building new ones; a standalone export frees them when it ends, and a
// failed (panicked) pool is never kept.
crate::reset_frame_renderers_for_tests();
BUILT.store(0, std::sync::atomic::Ordering::SeqCst);
crate::register_frame_renderer(|| {
BUILT.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
Some(Box::new(FakeRenderer(filmcraft_render::plan::DeviceCaps::ALL)) as Box<dyn FrameRenderer>)
});
let (p, seq, m) = project();
let part = |path: &String, batch: bool| {
let mut s = ExportSettings { format: Format::PngSequence, path: path.clone(), part_of_batch: batch, ..Default::default() };
s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(2)));
s.gpu_rendering = crate::GpuRendering::Auto;
export(&p, seq, &s, &m, &Progress::default()).unwrap()
};
let built = || BUILT.load(std::sync::atomic::Ordering::SeqCst);
part(&tmp("reuse-a.png"), true);
let first = built();
assert!(first >= 1, "the first part builds its renderers");
assert_eq!(crate::idle_renderer_count(), first, "a finished part keeps its renderers");
part(&tmp("reuse-b.png"), true);
assert_eq!(built(), first, "the next part reuses them instead of building new ones");
assert_eq!(std::fs::read(tmp("reuse-a000.png")).unwrap(), std::fs::read(tmp("reuse-b000.png")).unwrap(), "a reused renderer draws the same");
part(&tmp("reuse-c.png"), false);
assert_eq!(built(), first, "a standalone export also takes the kept ones");
assert_eq!(crate::idle_renderer_count(), 0, "and frees every renderer when it ends");
part(&tmp("reuse-d.png"), true);
crate::release_idle_renderers();
assert_eq!(crate::idle_renderer_count(), 0, "the job's end frees them");
crate::reset_frame_renderers_for_tests();
crate::register_frame_renderer(|| Some(Box::new(PanickingRenderer) as Box<dyn FrameRenderer>));
part(&tmp("reuse-panic.png"), true);
assert_eq!(crate::idle_renderer_count(), 0, "a pool whose renderer panicked is not kept");
}
static BUILT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
static PANICS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
struct PanickingRenderer;
impl FrameRenderer for PanickingRenderer {
fn render(
&mut self,
_project: &Project,
_seq: ItemId,
_t: Tick,
_opts: filmcraft_render::RenderOptions,
_sources: &dyn SourceProvider,
) -> Option<filmcraft_render::Image> {
PANICS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
panic!("GPU renderer failure (test)");
}
fn caps(&self) -> filmcraft_render::plan::DeviceCaps {
filmcraft_render::plan::DeviceCaps::ALL
}
}
/// Returns a blank picture for every frame it is given, on a device that runs these caps.
struct FakeRenderer(filmcraft_render::plan::DeviceCaps);
impl FrameRenderer for FakeRenderer {
fn render(
&mut self,
_project: &Project,
_seq: ItemId,
_t: Tick,
_opts: filmcraft_render::RenderOptions,
_sources: &dyn SourceProvider,
) -> Option<filmcraft_render::Image> {
Some(filmcraft_render::Image::new(320, 180))
}
fn caps(&self) -> filmcraft_render::plan::DeviceCaps {
self.0
}
}
/// The render threads may convert H.264 input ahead ([`VideoEncoder::prepare_ahead`]): the packets
/// are the same whether a picture was converted ahead (in any order), converted by the encoder
/// itself (none ahead, or one ahead for another picture size), or never asked for.
#[test]
fn h264_input_converted_ahead_encodes_to_the_same_packets() {
let (w, h) = (96u32, 64u32);
let frames: Vec<Vec<u8>> = (0..8u32)
.map(|t| {
(0..w * h)
.flat_map(|i| {
let (x, y) = (i % w, i / w);
[(x * 3 + t * 7) as u8, (y * 5 + t) as u8, ((x + y) * 2 + t * 3) as u8, 255]
})
.collect()
})
.collect();
let s = ExportSettings { format: Format::H264, ..Default::default() };
let frame = |i: usize| EncoderFrame { width: w, height: h, rgba: &frames[i], hdr: None, index: i as u64 };
let encode_all = |ahead: bool| -> Vec<Vec<u8>> {
let mut enc = h264_factory(Format::H264, w, h, FrameRate::FPS_24, &s).unwrap().unwrap();
if ahead {
let prepare = enc.prepare_ahead().expect("the H.264 encoder converts ahead");
for i in (0..frames.len()).rev().filter(|&i| i != 3) {
prepare(&frame(i));
}
// a picture of another size under index 5: the encoder converts that one itself
prepare(&EncoderFrame { width: w / 2, height: h / 2, rgba: &frames[5][..(w * h) as usize], hdr: None, index: 5 });
// and one it is never asked to encode
prepare(&EncoderFrame { index: 99, ..frame(0) });
}
let mut out = Vec::new();
for i in 0..frames.len() {
out.extend(enc.encode(&frame(i)).unwrap().into_iter().map(|p| p.data));
}
out.extend(enc.flush().unwrap().into_iter().map(|p| p.data));
out
};
let plain = encode_all(false);
assert!(!plain.is_empty());
assert!(plain == encode_all(true), "converting ahead changed the packets");
}
/// The report names the video encoder that ran. An export that asked for hardware encoding and got
/// the software encoder says so: a two-pass H.264 export with Hardware encoding Auto came out of the
/// software encoder with nothing saying that NVENC had not run. No hardware encoder is registered
/// here, so the software one runs both passes, and the warning comes once.
#[test]
fn the_report_names_the_encoder_and_says_when_hardware_was_not_used() {
let (p, seq, m) = project();
let two_pass = ExportSettings {
format: Format::H264,
path: tmp("hw-auto.mp4"),
hardware_encoding: HardwareEncoding::Auto,
bitrate_mode: BitrateMode::Vbr2Pass,
..Default::default()
};
let r = export(&p, seq, &two_pass, &m, &Progress::default()).unwrap();
assert_eq!(r.encoder.as_deref(), Some("software"));
assert_eq!(r.warnings, ["hardware encoding is Auto, but no hardware H.264 encoder is available here; the software encoder ran"]);
let json = serde_json::to_value(&r).unwrap();
assert_eq!(json["encoder"], "software");
assert_eq!(json["warnings"][0], r.warnings[0].as_str());
// hardware encoding Off (the default): the encoder is named, and there is nothing to warn about
let r = export(&p, seq, &ExportSettings { format: Format::ProRes, path: tmp("hw-off.mov"), ..Default::default() }, &m, &Progress::default()).unwrap();
assert_eq!(r.encoder.as_deref(), Some("software"));
assert!(serde_json::to_value(&r).unwrap().get("warnings").is_none(), "no empty list");
// an export without a video encoder names none
let r = export(&p, seq, &ExportSettings { format: Format::Wav, path: tmp("hw.wav"), ..Default::default() }, &m, &Progress::default()).unwrap();
assert_eq!(r.encoder, None);
assert!(serde_json::to_value(&r).unwrap().get("encoder").is_none());
}
/// #4656: the APV encoder for 4:4:4 profiles, driven directly.
mod apv_chroma {
use super::*;
use crate::encoders::apv_factory;
/// Encodes one frame with an APV encoder for `profile` and decodes it back.
fn encode_apv(profile: &str, w: u32, h: u32, signal: ColorSignal, rgba: &[u8], hdr: Option<&[f32]>) -> Result<craft_video::apv::Frame> {
let s = ExportSettings { format: Format::Apv, apv_profile: profile.into(), signal, ..Default::default() };
let mut enc = apv_factory(Format::Apv, w, h, FrameRate::FPS_24, &s).unwrap()?;
let packets = enc.encode(&EncoderFrame { width: w, height: h, rgba, hdr, index: 0 })?;
Ok(craft_video::apv::decode_frame(&packets[0].data).unwrap())
}
/// One-pixel red and blue columns: the chroma of each column must survive on its own.
fn stripes_rgba(w: usize, h: usize) -> Vec<u8> {
(0..w * h).flat_map(|i| if (i % w).is_multiple_of(2) { [255, 0, 0, 255] } else { [0, 0, 255, 255] }).collect()
}
/// The decoded samples scaled back to 10 bits.
fn at10(fr: &craft_video::apv::Frame, plane: &[u16], i: usize) -> i32 {
i32::from(plane[i]) >> (fr.bit_depth - 10)
}
/// Asserts adjacent red and blue columns of every row keep their own chroma.
fn assert_stripes(fr: &craft_video::apv::Frame, w: usize, h: usize, what: &str) {
for row in 0..h {
let i = row * w;
let (cb0, cb1) = (at10(fr, &fr.cb, i), at10(fr, &fr.cb, i + 1));
let (cr0, cr1) = (at10(fr, &fr.cr, i), at10(fr, &fr.cr, i + 1));
assert!(cb0 < 512 && cb1 > 512, "{what} row {row}: cb {cb0} (red) {cb1} (blue)");
assert!(cr0 > 512 && cr1 < 512, "{what} row {row}: cr {cr0} (red) {cr1} (blue)");
assert!((cb0 - cb1).abs() > 200 && (cr0 - cr1).abs() > 200, "{what} row {row}: {cb0} {cb1} {cr0} {cr1}");
}
}
/// Every 4:4:4 profile keeps one-pixel colour stripes apart, and alpha stays opaque.
#[test]
fn apv_444_profiles_keep_full_resolution_chroma() {
let (w, h) = (16usize, 8usize);
let rgba = stripes_rgba(w, h);
for profile in ["444-10", "444-12", "4444-10", "4444-12"] {
let fr = encode_apv(profile, w as u32, h as u32, ColorSignal::default(), &rgba, None).unwrap();
assert_eq!((fr.cb.len(), fr.cr.len()), (w * h, w * h), "{profile}");
assert_stripes(&fr, w, h, profile);
if let Some(a) = &fr.alpha {
let max = ((1u32 << fr.bit_depth) - 1) as u16;
assert!(a.iter().all(|&v| v == max), "{profile}: opaque alpha");
}
}
}
/// HDR float input keeps full chroma resolution; it carries no alpha, so alpha is opaque.
#[test]
fn apv_hdr_4444_keeps_full_resolution_chroma_and_opaque_alpha() {
let (w, h) = (16usize, 8usize);
let rgb: Vec<f32> = (0..w * h).flat_map(|i| if (i % w).is_multiple_of(2) { [0.8, 0.0, 0.0] } else { [0.0, 0.0, 0.8] }).collect();
let fr = encode_apv("4444-10", w as u32, h as u32, ColorSignal::PQ, &[], Some(&rgb)).unwrap();
assert_stripes(&fr, w, h, "hdr 4444");
let a = fr.alpha.as_ref().unwrap();
let max = ((1u32 << fr.bit_depth) - 1) as u16;
assert!(a.len() == w * h && a.iter().all(|&v| v == max));
}
/// 4:2:2 and 4:0:0 still code the expected luma, and 4:0:0 HDR uses the signal's matrix.
#[test]
fn apv_422_and_monochrome_still_encode() {
let (w, h) = (16usize, 8usize);
let grey = [128u8, 128, 128, 255].repeat(w * h);
let want = (64.0 + 876.0 * (128.0 / 255.0f32)).round() as i32;
for profile in ["422-10", "422-12", "400-10"] {
let fr = encode_apv(profile, w as u32, h as u32, ColorSignal::default(), &grey, None).unwrap();
assert_eq!(fr.y.len(), w * h);
assert!(fr.y.iter().all(|&v| (i32::from(v) >> (fr.bit_depth - 10)).abs_diff(want) <= 2), "{profile}: {:?}", &fr.y[..4]);
assert_eq!(fr.cb.len(), if profile == "400-10" { 0 } else { w.div_ceil(2) * h }, "{profile}");
}
// 4:0:0 HDR takes the signal's matrix: pure red is Kr
let rgb = [1.0f32, 0.0, 0.0].repeat(w * h);
let fr = encode_apv("400-10", w as u32, h as u32, ColorSignal::PQ, &[], Some(&rgb)).unwrap();
let (kr, _) = ColorSignal::PQ.kr_kb();
let want = (64.0 + 876.0 * kr).round() as i32;
assert!(fr.y.iter().all(|&v| (i32::from(v) >> (fr.bit_depth - 10)).abs_diff(want) <= 2), "want {want}, got {:?}", &fr.y[..4]);
}
/// A picture buffer shorter than the frame size is an encode error, not a panic.
#[test]
fn apv_short_input_is_an_error_not_a_panic() {
for profile in ["422-10", "444-10", "4444-10", "400-10"] {
let s = ExportSettings { format: Format::Apv, apv_profile: profile.into(), ..Default::default() };
let mut enc = apv_factory(Format::Apv, 16, 8, FrameRate::FPS_24, &s).unwrap().unwrap();
let short = vec![0u8; 16 * 8 * 4 - 1];
assert!(enc.encode(&EncoderFrame { width: 16, height: 8, rgba: &short, hdr: None, index: 0 }).is_err(), "{profile}");
let short = vec![0f32; 16 * 8 * 3 - 1];
assert!(enc.encode(&EncoderFrame { width: 16, height: 8, rgba: &[], hdr: Some(&short), index: 0 }).is_err(), "{profile}");
}
}
}
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.