f67d38b35cc5
fx_tests.rs
//! GPU-vs-CPU parity of the effect stage (`filmcraft_render::gpufx::FxOp::apply` is the
//! reference).
//!
//! Tolerances:
//! - Exact checks ([`gpu_effects_match_cpu_exactly`]): the working image read back as f32 from a
//! half-float-representable source (so the source draw is lossless) must match the CPU op to
//! [`EXACT`] per value (f32 arithmetic and the GPU's `pow` / `sqrt` differ in the last bits).
//! Step functions (Posterize, Color Pass, Leave Color and Change to Color keys, Extract) may
//! flip a pixel that lands on a threshold; at most [`FLIPS`] of the values may differ by more.
//! - Composited plans ([`gpu_effect_layers_match_cpu_plan`]): the compositor's criterion (p99 of
//! the per-pixel max 8-bit channel difference โค 6, mean < 1.5) away from layer outlines, as for
//! the blend modes.
use super::blend_tests::{device, interior, ramp_layer, stats8, yuv_frame};
use super::*;
use filmcraft_geom::{Affine, Vec2};
use filmcraft_project::{EffectInstance, ParamValue, find_effect};
use filmcraft_render::effects::FxCtx;
use filmcraft_render::gpufx::FxOp;
use filmcraft_render::plan::{LayerFx, execute_cpu};
use filmcraft_time::Tick;
const EXACT: f32 = 1e-4;
const FLIPS: f64 = 0.01;
fn cx(t: Tick, px_scale: f32) -> FxCtx<'static> {
FxCtx {
t,
px_scale,
mask_scale: px_scale,
seconds: 0.0,
timecode: "",
clip_name: "",
project: None,
env: None,
frame_rate: 24.0,
working: filmcraft_color::WorkingSpace::Rec709,
}
}
fn effect(id: &str, params: &[(&str, ParamValue)]) -> EffectInstance {
let mut e = find_effect(id).unwrap_or_else(|| panic!("{id}")).instance();
for (k, v) in params {
e.params.get_mut(*k).unwrap_or_else(|| panic!("{id}.{k}")).value = v.clone();
}
e
}
fn fl(v: f64) -> ParamValue {
ParamValue::Float(v)
}
fn col(r: f32, g: f32, b: f32) -> ParamValue {
ParamValue::Color([r, g, b, 1.0])
}
fn ch(c: u32) -> ParamValue {
ParamValue::Choice(c)
}
fn pt(x: f64, y: f64) -> ParamValue {
ParamValue::Vec2(Vec2::new(x, y))
}
fn half(v: f32) -> f32 {
super::blend_tests::f16_to_f32(f32_to_f16(v))
}
/// Linear premultiplied test picture, every value representable in half floats: hue sweep along
/// x, lightness along y, a grey ramp, black and white columns, super-whites (up to 1.6), and
/// alpha 1 / partial / 0 bands.
fn picture(w: u32, h: u32) -> Vec<f32> {
let mut px = Vec::with_capacity((w * h * 4) as usize);
for y in 0..h {
for x in 0..w {
let fx = x as f32 / (w - 1) as f32;
let fy = y as f32 / (h - 1) as f32;
let c = match x % 11 {
0 => [0.0, 0.0, 0.0],
1 => [1.0, 1.0, 1.0],
2 => [fy, fy, fy],
3 => [1.6 * fy, 1.2 * fy, 0.3],
_ => {
let rgb = filmcraft_color::hsl_to_rgb(fx, 0.25 + 0.75 * ((y % 5) as f32 / 4.0), 0.1 + 0.8 * fy);
rgb.map(filmcraft_color::srgb_to_linear)
}
};
let a = match y % 7 {
0 => 0.0,
1 | 2 => 0.5 + 0.4 * fx,
3 => 0.25,
_ => 1.0,
};
px.extend_from_slice(&[c[0] * a, c[1] * a, c[2] * a, a].map(half));
}
}
px
}
/// Max |cpu โ gpu| (finite values required) and the share of values off by more than 0.02.
fn compare(cpu: &[f32], gpu: &[f32]) -> (f32, f64) {
assert_eq!(cpu.len(), gpu.len());
let mut worst = 0f32;
let mut flips = 0usize;
for (a, b) in cpu.iter().zip(gpu) {
assert!(b.is_finite(), "non-finite GPU value");
let d = (a - b).abs() / (1.0 + a.abs());
if d > 0.02 {
flips += 1;
} else {
worst = worst.max(d);
}
}
(worst, flips as f64 / cpu.len() as f64)
}
/// Effect cases: (effect id, parameters, whether a threshold may flip pixels).
fn cases() -> Vec<(&'static str, Vec<(&'static str, ParamValue)>, bool)> {
vec![
("brightness_contrast", vec![("brightness", fl(30.0)), ("contrast", fl(40.0))], false),
("brightness_contrast", vec![("brightness", fl(-100.0)), ("contrast", fl(-100.0))], false),
("brightness_contrast", vec![("brightness", fl(100.0)), ("contrast", fl(100.0))], false),
("brightness_contrast", vec![("brightness", fl(-20.0)), ("contrast", fl(900.0))], false),
("proc_amp", vec![("brightness", fl(10.0)), ("contrast", fl(130.0)), ("hue", fl(200.0)), ("saturation", fl(150.0))], false),
("proc_amp", vec![("hue", fl(-400.0)), ("saturation", fl(0.0))], false),
("tint", vec![], false),
("tint", vec![("black", col(0.2, 0.1, 0.5)), ("white", col(1.0, 0.9, 0.3)), ("amount", fl(60.0))], false),
("black_white", vec![], false),
("color_balance", vec![("shadow_r", fl(50.0)), ("mid_g", fl(-40.0)), ("hi_b", fl(80.0)), ("shadow_b", fl(-100.0)), ("hi_r", fl(100.0))], false),
("color_balance", vec![("mid_r", fl(70.0)), ("hi_g", fl(-60.0)), ("preserve", ParamValue::Bool(true))], false),
(
"three_way_color",
vec![
("shadow_hue", fl(220.0)),
("shadow_balance", fl(60.0)),
("hi_hue", fl(30.0)),
("hi_balance", fl(80.0)),
("mid_level", fl(-30.0)),
("saturation", fl(130.0)),
],
false,
),
(
"three_way_color",
vec![
("shadow_level", fl(50.0)),
("hi_level", fl(-40.0)),
("shadow_threshold", fl(50.0)),
("shadow_softness", fl(0.0)),
("hi_threshold", fl(50.0)),
("hi_softness", fl(0.0)),
("saturation", fl(0.0)),
],
false,
),
// overlapping ranges (shadow edge above the highlight edge)
(
"three_way_color",
vec![
("shadow_threshold", fl(80.0)),
("hi_threshold", fl(20.0)),
("shadow_balance", fl(70.0)),
("hi_balance", fl(70.0)),
("hi_hue", fl(200.0)),
("shadow_level", fl(30.0)),
("hi_level", fl(30.0)),
],
false,
),
("leave_color", vec![("amount", fl(80.0)), ("tolerance", fl(20.0)), ("softness", fl(30.0))], true),
("leave_color", vec![("amount", fl(100.0)), ("color", col(0.1, 0.8, 0.2)), ("tolerance", fl(0.0)), ("softness", fl(0.0))], true),
("change_to_color", vec![], true),
("change_to_color", vec![("hue_tol", fl(30.0)), ("softness", fl(10.0)), ("to", col(0.9, 0.9, 0.1))], true),
("color_pass", vec![("similarity", fl(30.0))], true),
("color_pass", vec![("similarity", fl(45.0)), ("reverse", ParamValue::Bool(true)), ("color", col(0.2, 0.4, 0.9))], true),
("gamma_correction", vec![("gamma", fl(5.0))], false),
("gamma_correction", vec![("gamma", fl(28.0))], false),
("gamma_correction", vec![("gamma", fl(0.0))], false),
("gamma_correction", vec![("gamma", fl(-3.0))], false),
("levels", vec![("in_black", fl(20.0)), ("in_white", fl(230.0)), ("out_black", fl(10.0)), ("out_white", fl(240.0)), ("gamma", fl(150.0))], false),
("levels", vec![("in_black", fl(200.0)), ("in_white", fl(0.0)), ("gamma", fl(5.0)), ("out_white", fl(-50.0))], true),
("extract", vec![], true),
("extract", vec![("invert", ParamValue::Bool(true))], true),
("extract", vec![("black", fl(40.0)), ("white", fl(200.0)), ("softness", fl(30.0))], true),
("extract", vec![("black", fl(90.0)), ("white", fl(160.0)), ("invert", ParamValue::Bool(true))], true),
("extract", vec![("black", fl(90.0)), ("white", fl(160.0)), ("softness", fl(1.0))], true),
("extract", vec![("black", fl(40.0)), ("white", fl(200.0)), ("softness", fl(100.0))], true),
("extract", vec![("black", fl(160.0)), ("white", fl(90.0))], true),
("extract", vec![("black", fl(90.0)), ("white", fl(90.0))], true),
("invert", vec![("blend", fl(30.0))], false),
("invert", vec![("channel", ParamValue::Choice(1))], false),
("invert", vec![("channel", ParamValue::Choice(2)), ("blend", fl(70.0))], false),
("invert", vec![("channel", ParamValue::Choice(3))], false),
("invert", vec![("channel", ParamValue::Choice(4)), ("blend", fl(20.0))], false),
("invert", vec![("channel", ParamValue::Choice(9))], false),
("posterize", vec![("levels", fl(2.0))], true),
("posterize", vec![("levels", fl(7.0))], true),
("posterize", vec![("levels", fl(255.0))], true),
("gaussian_blur", vec![("blurriness", fl(0.0))], false),
("gaussian_blur", vec![("blurriness", fl(5.0))], false),
("gaussian_blur", vec![("blurriness", fl(5.0)), ("repeat_edge", ParamValue::Bool(true))], false),
("gaussian_blur", vec![("blurriness", fl(80.0))], false),
("gaussian_blur", vec![("blurriness", fl(80.0)), ("repeat_edge", ParamValue::Bool(true))], false),
("gaussian_blur", vec![("blurriness", fl(12.0)), ("dimensions", ParamValue::Choice(1))], false),
("gaussian_blur", vec![("blurriness", fl(12.0)), ("dimensions", ParamValue::Choice(2)), ("repeat_edge", ParamValue::Bool(true))], false),
("gaussian_blur", vec![("blurriness", fl(3000.0)), ("repeat_edge", ParamValue::Bool(true))], false),
("gaussian_blur", vec![("blurriness", fl(1e9))], false),
("gaussian_blur", vec![("blurriness", fl(-50.0))], false),
("camera_blur", vec![("percent", fl(20.0))], false),
("directional_blur", vec![("length", fl(10.0)), ("direction", fl(30.0))], false),
("directional_blur", vec![("length", fl(0.2))], false),
("directional_blur", vec![("length", fl(1000.0)), ("direction", fl(-100.0))], false),
("bokeh_blur", vec![("amount", fl(0.2))], false),
("bokeh_blur", vec![("amount", fl(3.0)), ("shape", ch(0)), ("highlight", fl(0.0))], false),
("bokeh_blur", vec![("amount", fl(11.0)), ("shape", ch(4)), ("rotation", fl(20.0))], false),
("bokeh_blur", vec![("amount", fl(30.0)), ("shape", ch(1)), ("rotation", fl(-75.0)), ("highlight", fl(100.0)), ("threshold", fl(40.0))], false),
("bokeh_blur", vec![("amount", fl(60.0)), ("shape", ch(5)), ("highlight", fl(300.0)), ("threshold", fl(0.0))], false),
("bokeh_blur", vec![("amount", fl(500.0)), ("shape", ch(2))], false),
("sharpen", vec![("amount", fl(80.0))], false),
("sharpen", vec![("amount", fl(4000.0))], false),
("unsharp_mask", vec![("amount", fl(150.0)), ("radius", fl(3.0)), ("threshold", fl(10.0))], true),
("unsharp_mask", vec![("radius", fl(0.1))], false),
("unsharp_mask", vec![("amount", fl(300.0)), ("radius", fl(250.0))], false),
("crop", vec![("left", fl(10.0)), ("top", fl(5.0)), ("right", fl(20.0)), ("bottom", fl(15.0))], false),
("crop", vec![("left", fl(10.0)), ("top", fl(5.0)), ("right", fl(20.0)), ("bottom", fl(15.0)), ("feather", fl(12.0))], false),
("crop", vec![("left", fl(12.0)), ("top", fl(5.0)), ("right", fl(20.0)), ("zoom", ParamValue::Bool(true))], false),
("crop", vec![("left", fl(70.0)), ("right", fl(70.0)), ("feather", fl(5000.0))], false),
("edge_feather", vec![("amount", fl(30.0))], false),
("transform", vec![("scale_height", fl(150.0)), ("rotation", fl(30.0)), ("position", pt(30.0, 20.0)), ("opacity", fl(60.0))], false),
(
"transform",
vec![
("uniform_scale", ParamValue::Bool(false)),
("scale_width", fl(80.0)),
("scale_height", fl(120.0)),
("skew", fl(20.0)),
("skew_axis", fl(45.0)),
("anchor", pt(10.0, 30.0)),
],
false,
),
("horizontal_flip", vec![], false),
("vertical_flip", vec![], false),
("mirror", vec![("center", pt(20.0, 10.0)), ("angle", fl(30.0))], false),
("mirror", vec![("angle", fl(200.0))], false),
("offset", vec![("shift", pt(10.0, 30.0)), ("blend", fl(25.0))], false),
("offset", vec![("shift", pt(-1e5, 7.25))], false),
("asc_cdl", vec![("r_slope", fl(1.4)), ("g_offset", fl(-0.1)), ("b_power", fl(2.2)), ("saturation", fl(1.6))], false),
("asc_cdl", vec![("r_power", fl(0.0)), ("g_slope", fl(0.0)), ("saturation", fl(0.0))], false),
("channel_mix", vec![("rr", fl(50.0)), ("rg", fl(60.0)), ("gb", fl(-80.0)), ("bc", fl(30.0))], false),
("channel_mix", vec![("rb", fl(120.0)), ("monochrome", ParamValue::Bool(true))], false),
("color_replace", vec![("similarity", fl(40.0))], true),
("color_replace", vec![("similarity", fl(25.0)), ("solid", ParamValue::Bool(true)), ("target", col(0.3, 0.6, 0.2))], true),
("color_replace", vec![("similarity", fl(0.0))], true),
("alpha_adjust", vec![("opacity", fl(60.0))], false),
("alpha_adjust", vec![("ignore", ParamValue::Bool(true)), ("invert", ParamValue::Bool(true))], false),
("alpha_adjust", vec![("invert", ParamValue::Bool(true)), ("mask_only", ParamValue::Bool(true)), ("opacity", fl(150.0))], false),
("vignette", vec![], false),
("vignette", vec![("amount", fl(-100.0)), ("midpoint", fl(50.0)), ("roundness", fl(0.0)), ("feather", fl(50.0))], false),
(
"vignette",
vec![("amount", fl(-30.0)), ("midpoint", fl(20.0)), ("roundness", fl(-100.0)), ("feather", fl(0.0)), ("color", col(0.1, 0.4, 0.7))],
false,
),
("vignette", vec![("amount", fl(40.0)), ("midpoint", fl(90.0)), ("roundness", fl(100.0)), ("feather", fl(100.0))], false),
("video_limiter", vec![], false),
("video_limiter", vec![("axis", ch(0)), ("clip_level", ch(0)), ("compression", ch(0))], false),
("video_limiter", vec![("axis", ch(1)), ("clip_level", ch(9)), ("compression", ch(4))], false),
("video_limiter", vec![("axis", ch(2)), ("clip_level", ch(5)), ("compression", ch(2))], false),
("video_limiter", vec![("axis", ch(3)), ("clip_level", ch(0)), ("compression", ch(1))], false),
(
"video_limiter",
vec![
("axis", ch(2)),
("clip_level", ch(0)),
("compression", ch(0)),
("gamut_warning", ParamValue::Bool(true)),
("warning_color", col(0.0, 1.0, 0.0)),
],
false,
),
(
"lumetri",
vec![
("temperature", fl(20.0)),
("tint", fl(-10.0)),
("exposure", fl(0.5)),
("contrast", fl(15.0)),
("highlights", fl(-20.0)),
("shadows", fl(25.0)),
("whites", fl(10.0)),
("blacks", fl(-15.0)),
("saturation", fl(110.0)),
("creative_on", ParamValue::Bool(false)),
("vignette_on", ParamValue::Bool(false)),
],
false,
),
(
"lumetri",
vec![
("basic_on", ParamValue::Bool(false)),
("creative_sat", fl(120.0)),
("vibrance", fl(30.0)),
("faded_film", fl(25.0)),
("shadow_tint", col(0.4, 0.45, 0.6)),
("highlight_tint", col(0.6, 0.55, 0.4)),
("vignette_on", ParamValue::Bool(false)),
],
false,
),
(
"lumetri",
vec![
("basic_on", ParamValue::Bool(false)),
("creative_on", ParamValue::Bool(false)),
("vignette_amount", fl(-3.0)),
("vignette_midpoint", fl(45.0)),
("vignette_roundness", fl(-30.0)),
("vignette_feather", fl(60.0)),
],
false,
),
(
"lumetri",
vec![
("temperature", fl(-15.0)),
("tint", fl(10.0)),
("exposure", fl(0.3)),
("contrast", fl(20.0)),
("highlights", fl(-10.0)),
("shadows", fl(15.0)),
("whites", fl(-5.0)),
("blacks", fl(5.0)),
("saturation", fl(105.0)),
("creative_sat", fl(110.0)),
("vibrance", fl(20.0)),
("faded_film", fl(15.0)),
("shadow_tint", col(0.48, 0.5, 0.55)),
("highlight_tint", col(0.52, 0.5, 0.45)),
("vignette_amount", fl(2.0)),
("vignette_midpoint", fl(50.0)),
("vignette_roundness", fl(20.0)),
("vignette_feather", fl(50.0)),
],
false,
),
(
"lumetri",
vec![("exposure", fl(4.0)), ("contrast", fl(100.0)), ("temperature", fl(100.0)), ("tint", fl(100.0)), ("whites", fl(100.0)), ("blacks", fl(100.0))],
false,
),
(
"lumetri",
vec![
("exposure", fl(-4.0)),
("contrast", fl(-100.0)),
("temperature", fl(-100.0)),
("tint", fl(-100.0)),
("whites", fl(-100.0)),
("blacks", fl(-100.0)),
],
false,
),
]
}
/// Every effect case on the GPU against its CPU reference, on the working image read back as f32.
#[test]
fn gpu_effects_match_cpu_exactly() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
effects_match_cpu_exactly(&dev, &q);
}
/// The same on DX12 with FXC, wgpu's shader compiler when `dxcompiler.dll` is not shipped (as in
/// FilmCraft's builds). FXC aborted on the effect stage ("internal error: compilation aborted
/// unexpectedly"), so every Windows device on DX12 rendered effects, previews and exports on the
/// CPU. WARP stands in when there is no GPU.
#[cfg(windows)]
#[test]
fn gpu_effects_match_cpu_exactly_with_fxc() {
let mut desc = wgpu::InstanceDescriptor::new_without_display_handle();
desc.backends = wgpu::Backends::DX12;
desc.backend_options.dx12.shader_compiler = wgpu::Dx12Compiler::Fxc;
let instance = wgpu::Instance::new(desc);
let adapter = [false, true].into_iter().find_map(|force_fallback_adapter| {
pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions { force_fallback_adapter, ..Default::default() })).ok()
});
let Some(adapter) = adapter else {
eprintln!("no DX12 adapter; skipping");
return;
};
eprintln!("DX12 + FXC on {}", adapter.get_info().name);
let (dev, q) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).expect("DX12 device");
effects_match_cpu_exactly(&dev, &q);
}
fn effects_match_cpu_exactly(dev: &wgpu::Device, q: &wgpu::Queue) {
let mut c = GpuCompositor::new(dev, q);
assert!(c.fx.is_some(), "the effect stage did not build on this device (see the log for the pipeline error)");
let (w, h) = (67u32, 41u32);
let px = picture(w, h);
let frame = VideoFrame::rgba_f32(w, h, px.clone());
let mut failures = Vec::new();
for (id, params, steps) in cases() {
let e = effect(id, ¶ms);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w as usize, h as usize).unwrap_or_else(|| panic!("{id} has no GPU op"));
assert!(op.gpu_ok(), "{id} {params:?}: not GPU-capable");
let mut cpu = filmcraft_render::Image { w: w as usize, h: h as usize, px: px.clone() };
op.apply(&mut cpu);
let fx = LayerFx { size: (w, h), decimation: 1, turns: 0, ops: vec![op] };
let (_, _, gpu) = c.effect_image(&frame, &fx).expect("effect image");
let (worst, flips) = compare(&cpu.px, &gpu);
eprintln!("{id} {params:?}: max rel diff {worst:.2e}, {:.3}% flipped", flips * 100.0);
if worst > EXACT || flips > if steps { FLIPS } else { 0.0 } {
failures.push(format!("{id} {params:?}: {worst:.2e}, flips {flips:.4}"));
}
}
assert!(failures.is_empty(), "GPU effects differ from the CPU:\n{}", failures.join("\n"));
}
/// #3465 review: a neutral Three-Way Color Corrector leaves every value alone on both paths,
/// negative and HDR channels included.
#[test]
fn gpu_neutral_three_way_leaves_negative_and_hdr_values() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let (w, h) = (16u32, 8u32);
let mut px = picture(w, h);
for (i, p) in px.chunks_mut(4).enumerate() {
p[3] = 1.0;
if i % 3 == 0 {
p[0] = -0.1;
}
if i % 5 == 0 {
p[1] = 2.0;
}
}
let frame = VideoFrame::rgba_f32(w, h, px.clone());
let e = effect("three_way_color", &[]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w as usize, h as usize).expect("three_way_color has a GPU op");
assert!(op.is_identity_three_way());
let mut cpu = filmcraft_render::Image { w: w as usize, h: h as usize, px: px.clone() };
op.apply(&mut cpu);
assert_eq!(cpu.px, px, "the CPU leaves a neutral corrector's input untouched");
let (_, _, gpu) = c.effect_image(&frame, &LayerFx { size: (w, h), decimation: 1, turns: 0, ops: vec![op] }).expect("effect image");
let (worst, flips) = compare(&px, &gpu);
assert!(worst <= EXACT && flips == 0.0, "the GPU changed a neutral corrector's input: {worst:.2e}, {flips:.4} of the values");
}
#[test]
fn gpu_extract_zero_softness_has_no_fractional_edge() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let (w, h) = (67, 41);
let px = picture(w, h);
let frame = VideoFrame::rgba_f32(w, h, px.clone());
let mut masks = Vec::new();
for invert in [false, true] {
let e = effect("extract", &[("black", fl(90.0)), ("white", fl(160.0)), ("invert", ParamValue::Bool(invert))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w as usize, h as usize).unwrap();
let (_, _, gpu) = c.effect_image(&frame, &LayerFx { size: (w, h), decimation: 1, turns: 0, ops: vec![op] }).unwrap();
for (src, out) in px.as_chunks::<4>().0.iter().zip(gpu.as_chunks::<4>().0.iter()) {
assert_eq!(out[3], src[3], "Extract must preserve alpha");
assert!(out[0] == 0.0 || out[0] == out[3], "zero softness produced a fractional edge: {out:?}");
assert_eq!(out[0], out[1]);
assert_eq!(out[0], out[2]);
}
masks.push(gpu);
}
for ((normal, inverted), src) in masks[0].as_chunks::<4>().0.iter().zip(masks[1].as_chunks::<4>().0.iter()).zip(px.as_chunks::<4>().0.iter()) {
assert_eq!(normal[0] + inverted[0], src[3], "inversion must complement the premultiplied mask");
}
}
/// Chains run in order (and Unsharp keeps its original while blurring, between other blurs).
#[test]
fn gpu_effect_chains_match_cpu() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let (w, h) = (96u32, 54u32);
let px = picture(w, h);
let frame = VideoFrame::rgba_f32(w, h, px.clone());
let chains: Vec<Vec<EffectInstance>> = vec![
vec![
effect("brightness_contrast", &[("brightness", fl(20.0)), ("contrast", fl(30.0))]),
effect("gaussian_blur", &[("blurriness", fl(8.0))]),
effect("tint", &[("amount", fl(50.0))]),
],
vec![
effect("gaussian_blur", &[("blurriness", fl(90.0)), ("repeat_edge", ParamValue::Bool(true))]),
effect("unsharp_mask", &[("amount", fl(200.0)), ("radius", fl(4.0))]),
effect("gaussian_blur", &[("blurriness", fl(3.0)), ("dimensions", ParamValue::Choice(1))]),
effect("sharpen", &[("amount", fl(50.0))]),
],
vec![
effect("crop", &[("left", fl(10.0)), ("bottom", fl(20.0)), ("feather", fl(4.0))]),
effect("transform", &[("rotation", fl(-15.0)), ("scale_height", fl(110.0))]),
effect("horizontal_flip", &[]),
effect("levels", &[("in_black", fl(15.0)), ("gamma", fl(80.0))]),
effect("offset", &[("shift", pt(70.0, 10.0))]),
effect("invert", &[("channel", ParamValue::Choice(4))]),
effect("directional_blur", &[("length", fl(6.0)), ("direction", fl(90.0))]),
],
];
for chain in chains {
let ops: Vec<FxOp> = chain.iter().filter_map(|e| FxOp::eval(e, &cx(Tick::ZERO, 1.0), w as usize, h as usize)).collect();
assert!(ops.iter().all(FxOp::gpu_ok));
let mut cpu = filmcraft_render::Image { w: w as usize, h: h as usize, px: px.clone() };
for op in &ops {
op.apply(&mut cpu);
}
let names: Vec<&str> = chain.iter().map(|e| e.effect.as_str()).collect();
let (_, _, gpu) = c.effect_image(&frame, &LayerFx { size: (w, h), decimation: 1, turns: 0, ops }).expect("effect image");
let (worst, flips) = compare(&cpu.px, &gpu);
eprintln!("{names:?}: max rel diff {worst:.2e}, {:.3}% flipped", flips * 100.0);
assert!(worst < EXACT * 2.0 && flips == 0.0, "{names:?}: {worst}, {flips}");
}
}
/// Keyframed parameters are evaluated at the layer's time on the CPU: the GPU result follows them.
#[test]
fn keyframed_effects_follow_time() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let (w, h) = (48u32, 32u32);
let px = picture(w, h);
let frame = VideoFrame::rgba_f32(w, h, px.clone());
let mut blur = effect("gaussian_blur", &[]);
let mut bc = effect("brightness_contrast", &[]);
let p = blur.params.get_mut("blurriness").expect("blurriness");
p.put_keyframe(Tick::ZERO, fl(0.0));
p.put_keyframe(Tick::from_seconds_f64(1.0), fl(30.0));
let p = bc.params.get_mut("brightness").expect("brightness");
p.put_keyframe(Tick::ZERO, fl(-50.0));
p.put_keyframe(Tick::from_seconds_f64(1.0), fl(60.0));
let mut last: Option<Vec<f32>> = None;
for s in [0.0, 0.3, 0.75, 1.0] {
let cx = cx(Tick::from_seconds_f64(s), 1.0);
let ops: Vec<FxOp> = [&bc, &blur].iter().filter_map(|e| FxOp::eval(e, &cx, w as usize, h as usize)).collect();
let mut cpu = filmcraft_render::Image { w: w as usize, h: h as usize, px: px.clone() };
for op in &ops {
op.apply(&mut cpu);
}
let (_, _, gpu) = c.effect_image(&frame, &LayerFx { size: (w, h), decimation: 1, turns: 0, ops }).expect("effect image");
let (worst, flips) = compare(&cpu.px, &gpu);
assert!(worst < EXACT && flips == 0.0, "t = {s}: {worst}, {flips}");
assert_ne!(last.as_ref(), Some(&gpu), "t = {s}: the keyframes change the picture");
last = Some(gpu);
}
}
/// Hostile values: non-finite parameters stay on the CPU (`gpu_ok` is false), huge radii and
/// sizes are capped as on the CPU and run in bounded time on the GPU.
#[test]
fn hostile_parameters_are_bounded() {
let (w, h) = (40usize, 24usize);
let nan = [
effect("brightness_contrast", &[("brightness", fl(f64::NAN))]),
effect("gaussian_blur", &[("blurriness", fl(f64::INFINITY))]),
effect("directional_blur", &[("length", fl(f64::NAN))]),
effect("bokeh_blur", &[("rotation", fl(f64::NAN))]),
effect("bokeh_blur", &[("highlight", fl(f64::INFINITY))]),
effect("transform", &[("rotation", fl(f64::NAN))]),
effect("crop", &[("left", fl(f64::NAN))]),
effect("offset", &[("shift", pt(f64::INFINITY, 0.0))]),
effect("levels", &[("in_black", fl(f64::NEG_INFINITY))]),
effect("transform", &[("scale_height", fl(1e300))]),
// minifying resamples (the CPU's mip path) stay on the CPU
effect("transform", &[("scale_height", fl(20.0))]),
effect("crop", &[("left", fl(-300.0)), ("zoom", ParamValue::Bool(true))]),
effect("vignette", &[("amount", fl(f64::NAN))]),
effect("vignette", &[("midpoint", fl(f64::INFINITY))]),
effect("vignette", &[("roundness", fl(f64::NAN))]),
effect("vignette", &[("feather", fl(f64::NAN))]),
effect("video_limiter", &[("clip_level", fl(f64::NAN))]),
effect("video_limiter", &[("compression", fl(f64::INFINITY))]),
effect("video_limiter", &[("axis", fl(f64::NAN))]),
effect("video_limiter", &[("warning_color", ParamValue::Color([f32::NAN, 0.0, 0.0, 1.0]))]),
effect("lumetri", &[("exposure", fl(f64::NAN))]),
effect("lumetri", &[("temperature", fl(f64::INFINITY))]),
effect("lumetri", &[("contrast", fl(f64::NAN))]),
effect("lumetri", &[("vignette_amount", fl(f64::NAN))]),
];
for e in &nan {
let op = FxOp::eval(e, &cx(Tick::ZERO, 1.0), w, h);
// gaussian with an infinite radius is capped (no blur), which the GPU runs
if e.effect == "gaussian_blur" {
assert!(op.as_ref().is_some_and(FxOp::gpu_ok));
continue;
}
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()), "{}: {op:?}", e.effect);
// and the CPU reference copes
let mut img = filmcraft_render::Image::filled(w, h, [0.3, 0.2, 0.1, 1.0]);
if let Some(op) = op {
op.apply(&mut img);
}
}
// huge radii: box radii capped by the image size
let op = FxOp::eval(&effect("gaussian_blur", &[("blurriness", fl(1e30))]), &cx(Tick::ZERO, 1.0), w, h);
let Some(FxOp::Gaussian { rx, ry, .. }) = op else { panic!("{op:?}") };
assert!(rx.iter().chain(&ry).all(|r| *r as usize <= 4 * w.max(h).max(8)), "{rx:?} {ry:?}");
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let frame = VideoFrame::rgba_f32(w as u32, h as u32, picture(w as u32, h as u32));
let ops = vec![
FxOp::eval(&effect("gaussian_blur", &[("blurriness", fl(1e30))]), &cx(Tick::ZERO, 1.0), w, h).expect("op"),
FxOp::eval(&effect("unsharp_mask", &[("radius", fl(1e30)), ("amount", fl(1e30))]), &cx(Tick::ZERO, 1.0), w, h).expect("op"),
FxOp::eval(&effect("directional_blur", &[("length", fl(1e30))]), &cx(Tick::ZERO, 1.0), w, h).expect("op"),
FxOp::eval(&effect("bokeh_blur", &[("amount", fl(1e30))]), &cx(Tick::ZERO, 1.0), w, h).expect("op"),
FxOp::eval(&effect("bokeh_blur", &[("amount", fl(f64::NAN))]), &cx(Tick::ZERO, 1.0), w, h).expect("op"),
];
let t0 = std::time::Instant::now();
let (_, _, gpu) = c.effect_image(&frame, &LayerFx { size: (w as u32, h as u32), decimation: 1, turns: 0, ops }).expect("effect image");
assert!(t0.elapsed().as_secs() < 30);
assert_eq!(gpu.len(), w * h * 4);
// a working image larger than any texture is refused, not attempted
assert!(c.effect_image(&frame, &LayerFx { size: (1 << 20, 4), decimation: 1, turns: 0, ops: vec![FxOp::BlackWhite] }).is_none());
// and the refusal ends its frame: the next frame, which uses no effect, releases the working
// images the first one pooled
c.composite(&FramePlan::Layers { width: w, height: h, layers: vec![PlanLayer::new(Arc::new(frame), Affine::IDENTITY, 1.0, Blend::Normal)] });
assert!(c.fx.as_ref().is_some_and(|f| f.is_idle()), "working images kept after a refused effect image");
}
#[test]
fn lumetri_unsupported_sections_fall_back() {
let (w, h) = (40usize, 24usize);
// sharpen > 0 and input LUT (explicitly required by brief)
let e = effect("lumetri", &[("sharpen", fl(10.0)), ("input_lut", ParamValue::Text("custom.cube".into()))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()), "sharpen > 0 and input_lut must fall back to CPU");
// sharpen alone
let e = effect("lumetri", &[("sharpen", fl(20.0))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// input_lut alone
let e = effect("lumetri", &[("input_lut", ParamValue::Text("test.cube".into()))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// look_lut
let e = effect("lumetri", &[("look_lut", ParamValue::Text("look.cube".into()))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// look > 0
let e = effect("lumetri", &[("look", ch(1))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// curve_luma modified
let e = effect("lumetri", &[("curve_luma", ParamValue::Curve(vec![[0.0, 0.1], [1.0, 0.9]]))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// hue_vs_sat non-empty
let e = effect("lumetri", &[("hue_vs_sat", ParamValue::Curve(vec![[0.5, 0.5]]))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// wheel offset
let e = effect("lumetri", &[("wheel_shadows", pt(0.5, 0.0))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// wheel lightness
let e = effect("lumetri", &[("wheel_midtones_l", fl(20.0))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// HSL secondary on
let e = effect("lumetri", &[("hsl_on", ParamValue::Bool(true))]);
let op = FxOp::eval(&e, &cx(Tick::ZERO, 1.0), w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
// HDR working space
let e = effect("lumetri", &[]);
let mut cx_hdr = cx(Tick::ZERO, 1.0);
cx_hdr.working = filmcraft_color::WorkingSpace::Rec2100Pq;
let op = FxOp::eval(&e, &cx_hdr, w, h);
assert!(op.as_ref().is_some_and(|o| !o.gpu_ok()));
}
/// Layers with effect chains in a composited plan โ YUV and RGBA sources, a decimated working
/// image, rotated / scaled placement, partial opacity and alpha, blend modes โ match the CPU plan
/// executor.
#[test]
fn gpu_effect_layers_match_cpu_plan() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let (w, h) = (320usize, 180usize);
let ops = |list: &[EffectInstance], lw: u32, lh: u32, px_scale: f32| -> Vec<FxOp> {
list.iter().filter_map(|e| FxOp::eval(e, &cx(Tick::ZERO, px_scale), lw as usize, lh as usize)).collect()
};
let chain_a = [
effect("brightness_contrast", &[("brightness", fl(15.0)), ("contrast", fl(25.0))]),
effect("gaussian_blur", &[("blurriness", fl(6.0))]),
effect("tint", &[("amount", fl(40.0))]),
];
let chain_b = [
effect("crop", &[("left", fl(8.0)), ("right", fl(12.0)), ("feather", fl(6.0))]),
effect("unsharp_mask", &[("amount", fl(120.0)), ("radius", fl(2.0))]),
effect("color_balance", &[("hi_b", fl(60.0)), ("shadow_r", fl(40.0))]),
];
let chain_c = [effect("mirror", &[("angle", fl(90.0))]), effect("gaussian_blur", &[("blurriness", fl(50.0)), ("dimensions", ParamValue::Choice(1))])];
let ramp = ramp_layer(160, 120, 0);
for mode in [Blend::Normal, Blend::Screen, Blend::Multiply, Blend::Overlay] {
let plan = FramePlan::Layers {
width: w,
height: h,
layers: vec![
// YUV source decoded at half size (decimation 2) with effects, filling the output
PlanLayer {
frame: yuv_frame(640, 360),
matrix: Affine::IDENTITY,
opacity: 1.0,
blend: Blend::Normal,
fx: Some(Arc::new(LayerFx { size: (320, 180), decimation: 2, turns: 0, ops: ops(&chain_c, 320, 180, 0.5) })),
input: None,
},
PlanLayer {
frame: ramp.clone(),
matrix: Affine::motion(Vec2::new(170.0, 95.0), Vec2::new(1.1, 1.1), 17.0, Vec2::new(80.0, 60.0)),
opacity: 0.8,
blend: mode,
fx: Some(Arc::new(LayerFx { size: (160, 120), decimation: 1, turns: 0, ops: ops(&chain_a, 160, 120, 1.0) })),
input: None,
},
PlanLayer::new(ramp.clone(), Affine::translate(10.0, 20.0), 0.5, Blend::Normal),
PlanLayer {
frame: yuv_frame(320, 180),
matrix: Affine::motion(Vec2::new(250.0, 70.0), Vec2::new(0.45, 0.45), -9.0, Vec2::new(160.0, 90.0)),
opacity: 0.7,
blend: mode,
fx: Some(Arc::new(LayerFx { size: (320, 180), decimation: 1, turns: 0, ops: ops(&chain_b, 320, 180, 1.0) })),
input: None,
},
],
};
let cpu = execute_cpu(&plan).over_black_rgba8();
c.composite(&plan);
let (_, _, gpu) = c.read_output().expect("readback");
let keep = interior(&plan);
let (p99, mean, max) = stats8(&cpu, &gpu, &keep);
let (ap99, amean, _) = stats8(&cpu, &gpu, &vec![true; keep.len()]);
eprintln!("{mode:?}: interior 8-bit p99 {p99} mean {mean:.3} max {max}; with edges p99 {ap99} mean {amean:.3}");
assert!(p99 <= 6 && mean < 1.5, "{mode:?}: p99 {p99}, mean {mean}");
}
}
/// Plans without effects never create working textures.
#[test]
fn plain_layers_skip_the_effect_stage() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let plan = FramePlan::Layers { width: 64, height: 36, layers: vec![PlanLayer::new(yuv_frame(64, 36), Affine::IDENTITY, 1.0, Blend::Normal)] };
c.composite(&plan);
assert!(c.fx.as_ref().is_some_and(fx::FxStage::is_idle));
let fx = LayerFx { size: (64, 36), decimation: 1, turns: 0, ops: vec![FxOp::BlackWhite] };
let with = FramePlan::Layers {
width: 64,
height: 36,
layers: vec![PlanLayer { fx: Some(Arc::new(fx)), ..PlanLayer::new(yuv_frame(64, 36), Affine::IDENTITY, 1.0, Blend::Normal) }],
};
c.composite(&with);
assert!(!c.fx.as_ref().is_some_and(fx::FxStage::is_idle));
// and they are released once no layer needs them
c.composite(&plan);
assert!(c.fx.as_ref().is_some_and(fx::FxStage::is_idle));
}
/// Without an effect stage (devices without compute shaders) the compositor renders a layer's
/// effects on the CPU itself: the picture is the same.
#[test]
fn layers_with_effects_fall_back_to_the_cpu_without_a_stage() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let ops: Vec<FxOp> = [effect("tint", &[("amount", fl(70.0))]), effect("gaussian_blur", &[("blurriness", fl(10.0))])]
.iter()
.filter_map(|e| FxOp::eval(e, &cx(Tick::ZERO, 1.0), 160, 120))
.collect();
let plan = FramePlan::Layers {
width: 200,
height: 150,
layers: vec![
PlanLayer::new(yuv_frame(200, 150), Affine::IDENTITY, 1.0, Blend::Normal),
PlanLayer {
fx: Some(Arc::new(LayerFx { size: (160, 120), decimation: 1, turns: 0, ops })),
..PlanLayer::new(
ramp_layer(160, 120, 2),
Affine::motion(Vec2::new(100.0, 75.0), Vec2::new(0.9, 0.9), 8.0, Vec2::new(80.0, 60.0)),
0.8,
Blend::Screen,
)
},
],
};
let cpu = execute_cpu(&plan).over_black_rgba8();
for stage in [true, false] {
let mut c = GpuCompositor::new(&dev, &q);
if !stage {
c.fx = None;
}
c.composite(&plan);
let (_, _, gpu) = c.read_output().expect("readback");
let (p99, mean, _) = stats8(&cpu, &gpu, &interior(&plan));
eprintln!("effect stage {stage}: interior p99 {p99}, mean {mean:.3}");
assert!(p99 <= 6 && mean < 1.5, "stage {stage}: p99 {p99}, mean {mean}");
}
}
/// The half-float upload is lossless for this input, so a 1:1 effect source draw must be too.
/// Odd dimensions expose interpolation drift that can invent opacity before any effect runs.
#[test]
fn effect_source_identity_preserves_odd_sized_half_float_texels() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
for (w, h) in [(67u32, 41u32), (96, 54), (64, 32)] {
let px = picture(w, h);
let frame = VideoFrame::rgba_f32(w, h, px.clone());
for n in [0, 1] {
let (ow, oh, gpu) = c.effect_image(&frame, &LayerFx { size: (w, h), decimation: n, turns: 0, ops: Vec::new() }).expect("source image");
assert_eq!((ow, oh, gpu.len()), (w, h, px.len()));
for (i, (expected, actual)) in px.iter().zip(&gpu).enumerate() {
assert_eq!(actual.to_bits(), expected.to_bits(), "{w}x{h} n{n} source component{i}: {actual} != {expected}");
}
}
}
}
#[test]
fn alpha_invert_does_not_amplify_invented_opacity_at_odd_source_pixels() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
let (w, h) = (67, 41);
let px = picture(w, h);
let frame = VideoFrame::rgba_f32(w, h, px.clone());
let op = FxOp::Invert { channel: 4, blend: 0.2 };
let mut cpu = filmcraft_render::Image { w: w as usize, h: h as usize, px: px.clone() };
op.apply(&mut cpu);
let (_, _, gpu) = c.effect_image(&frame, &LayerFx { size: (w, h), decimation: 1, turns: 0, ops: vec![op] }).expect("alpha invert image");
assert_eq!(gpu.len(), px.len());
let (worst, flips) = compare(&cpu.px, &gpu);
assert!(worst <= EXACT && flips == 0.0, "alpha invert: {worst}, {flips}");
let mut transparent = 0;
for (source, result) in px.as_chunks::<4>().0.iter().zip(gpu.as_chunks::<4>().0.iter()) {
if source[3] == 0.0 {
transparent += 1;
assert_eq!(&result[..3], &[0.0; 3], "a transparent source must not acquire neighboring RGB");
assert!((result[3] - 0.8).abs() <= f32::EPSILON);
}
}
assert_eq!(transparent, 402);
}
/// A turned working image (display rotation) matches the CPU's: decimated, then turned.
#[test]
fn effect_source_quarter_turns_match_the_cpu() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
for (w, h) in [(67u32, 41u32), (96, 54)] {
let frame = VideoFrame::rgba_f32(w, h, picture(w, h));
for n in [1, 2, 4] {
for turns in 1..4u8 {
let (dw, dh) = ((w / n) as usize, (h / n) as usize);
let size = if turns % 2 == 1 { (dh as u32, dw as u32) } else { (dw as u32, dh as u32) };
let fx = LayerFx { size, decimation: n, turns, ops: Vec::new() };
let cpu = filmcraft_render::plan::effect_image(&frame, &fx);
let (gw, gh, gpu) = c.effect_image(&frame, &fx).expect("turned source image");
assert_eq!((gw as usize, gh as usize, gpu.len()), (cpu.w, cpu.h, cpu.px.len()));
let (worst, flips) = compare(&cpu.px, &gpu);
assert!(worst <= EXACT && flips == 0.0, "{w}x{h} n{n} turns{turns}: {worst}, {flips}");
}
}
}
}
/// The exact source grid keeps the existing box-minification behavior at non-unit factors.
#[test]
fn effect_source_integer_decimation_preserves_cpu_box_oracle() {
let Some((dev, q)) = device() else {
eprintln!("no GPU adapter; skipping");
return;
};
let mut c = GpuCompositor::new(&dev, &q);
for (w, h) in [(67u32, 41u32), (96, 54)] {
let frame = VideoFrame::rgba_f32(w, h, picture(w, h));
for n in [2, 4, 8] {
let (ow, oh, cpu) = frame.to_linear_f32_decimated(n as usize);
let (gw, gh, gpu) =
c.effect_image(&frame, &LayerFx { size: (ow as u32, oh as u32), decimation: n, turns: 0, ops: Vec::new() }).expect("decimated source image");
assert_eq!((gw as usize, gh as usize, gpu.len()), (ow, oh, cpu.len()));
let (worst, flips) = compare(&cpu, &gpu);
assert!(worst <= EXACT && flips == 0.0, "{w}x{h} n{n} source box: {worst}, {flips}");
}
}
}
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.