//! Camera Raw's GPU preview pass against the CPU develop (the oracle), stage by stage, at 8, 16 //! and 32 bits. Skips, with a message, when there is no adapter or device or it can't render //! `Rgba32Float`; with `WGPU_BACKEND` set those fail instead, as in `parity.rs`. A pipeline that //! doesn't build on an adapter that can run it fails. The shader itself is validated without a //! GPU ([`the_shader_validates_without_a_gpu`]), so a WGSL error fails on every runner. use photocraft_algo::camera_raw::{CameraRaw, Wheel, develop, per_pixel, white_black_points}; use photocraft_gpu::{CameraRawDevelop, DeviceHealth, Fault}; /// Largest difference from the CPU develop, per channel. The pass evaluates the same /// expressions in f32, so what remains is the GPU's own `pow`, `exp2` and `sin` (a few ulps) and /// how they move a value across a table entry; measured at most about 1e-5 on NVIDIA (Vulkan, /// DX12) and WARP. 1/4096 keeps a margin and stays well under one 8-bit step (the compositor's /// tolerance is 1/255). const TOL: f32 = 1.0 / 4096.0; struct Gpu { device: wgpu::Device, queue: wgpu::Queue, dev: CameraRawDevelop, _lock: std::sync::MutexGuard<'static, ()>, } fn gpu() -> Option { let lock = crate::GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner); let required = std::env::var_os("WGPU_BACKEND").is_some(); // `WGPU_BACKEND` picks the backend; `PHOTOCRAFT_TEST_FALLBACK_ADAPTER=1` the software one (WARP). let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env()); let fallback = std::env::var_os("PHOTOCRAFT_TEST_FALLBACK_ADAPTER").is_some(); let options = wgpu::RequestAdapterOptions { force_fallback_adapter: fallback, ..Default::default() }; let adapter = match pollster::block_on(instance.request_adapter(&options)) { Ok(a) => a, Err(e) => { assert!(!required, "WGPU_BACKEND is set but has no adapter: {e}"); eprintln!("skipping Camera Raw GPU tests: no adapter ({e})"); return None; } }; let info = adapter.get_info(); if !CameraRawDevelop::supported(&adapter) { assert!(!required, "WGPU_BACKEND is set but {} can't render Rgba32Float", info.name); eprintln!("skipping Camera Raw GPU tests: adapter can't render Rgba32Float"); return None; } let (device, queue) = match pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())) { Ok(d) => d, Err(e) => { assert!(!required, "WGPU_BACKEND is set but {} has no device: {e}", info.name); eprintln!("skipping Camera Raw GPU tests: no device ({e})"); return None; } }; eprintln!("Camera Raw GPU tests on {:?} ({})", info.backend, info.name); // The adapter can run the pass: a pipeline that doesn't build is a bug in it, not a skip. let dev = CameraRawDevelop::new(&device).unwrap_or_else(|e| panic!("the Camera Raw pipeline didn't build on {}: {}", info.name, e.0)); Some(Gpu { device, queue, dev, _lock: lock }) } /// The Camera Raw shader parses and validates (naga, as wgpu does before any driver sees it), /// with no adapter: the GPU tests below skip on runners without one. #[test] fn the_shader_validates_without_a_gpu() { let src = photocraft_gpu::CAMERA_RAW_SHADER; let module = wgpu::naga::front::wgsl::parse_str(src).unwrap_or_else(|e| panic!("{}", e.emit_to_string(src))); wgpu::naga::valid::Validator::new(wgpu::naga::valid::ValidationFlags::all(), wgpu::naga::valid::Capabilities::empty()) .validate(&module) .unwrap_or_else(|e| panic!("{}", e.emit_to_string(src))); assert!(!module.entry_points.is_empty()); } #[derive(Clone, Copy, Debug)] enum Depth { Eight, Sixteen, Float, } const DEPTHS: [Depth; 3] = [Depth::Eight, Depth::Sixteen, Depth::Float]; fn hash(i: usize, c: u64) -> f32 { let mut z = (i as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ c.wrapping_mul(0xC2B2_AE3D_27D4_EB4F); z = (z ^ (z >> 29)).wrapping_mul(0xBF58_476D_1CE4_E5B9); (z >> 40) as f32 / (1u64 << 24) as f32 } /// Gradients, noise and saturated patches (every Color Mixer band), quantized to `depth`. The /// 32-bit image also has values above 1 and a few below 0. fn image(w: usize, h: usize, depth: Depth) -> Vec<[f32; 4]> { (0..w * h) .map(|i| { let (x, y) = ((i % w) as f32 / w as f32, (i / w) as f32 / h as f32); let mut c = if (i / w).is_multiple_of(4) { // A hue sweep at full and half saturation. let hue = x * 6.0; let f = |n: f32| (((hue + n) % 6.0 - 3.0).abs() - 1.0).clamp(0.0, 1.0); let s = if (i / w).is_multiple_of(8) { 1.0 } else { 0.5 }; [f(0.0), f(4.0), f(2.0)].map(|v| (1.0 - s) * 0.6 + s * v) } else { [0.1 + 0.8 * x, 0.2 + 0.6 * y, 0.5 - 0.4 * x * y].map(|v| v + (hash(i, 1) - 0.5) * 0.15) }; if let Depth::Float = depth { c = c.map(|v| v * (1.0 + 1.5 * y) - 0.02 * hash(i, 2)); } let q = |v: f32| match depth { Depth::Eight => (v.clamp(0.0, 1.0) * 255.0).round() / 255.0, Depth::Sixteen => (v.clamp(0.0, 1.0) * 32768.0).round() / 32768.0, Depth::Float => v, }; [q(c[0]), q(c[1]), q(c[2]), 1.0] }) .collect() } /// Develops `p` both ways and returns the largest channel difference. fn compare(g: &mut Gpu, p: &CameraRaw, depth: Depth) -> f32 { let (w, h) = (171, 113); let float = matches!(depth, Depth::Float); let src = image(w, h, depth); let mut cpu = src.clone(); develop(&mut cpu, w, h, p, float); let points = white_black_points(&src, w, h, p); let stages = per_pixel(p, w, h, float, points).unwrap_or_else(|| panic!("{p:?} has a spatial stage")); let out = g.dev.develop(&g.device, &g.queue, None, &src, None, [w as u32, h as u32], &stages).unwrap(); assert_eq!(out.len(), cpu.len()); let mut worst = (0.0f32, 0usize); for (i, (a, b)) in out.iter().zip(&cpu).enumerate() { assert!(a.iter().all(|v| v.is_finite()), "{p:?} {depth:?}: non-finite GPU pixel {i}: {a:?}"); assert_eq!(a[3], b[3], "alpha is kept"); for c in 0..3 { let d = (a[c] - b[c]).abs(); if d > worst.0 { worst = (d, i); } } } let (d, i) = worst; assert!(d <= TOL, "{p:?} {depth:?}: GPU {:?} vs CPU {:?} at pixel {i} (source {:?}), off by {d}", out[i], cpu[i], src[i]); if !float { assert!(out.iter().all(|q| q[..3].iter().all(|v| (0.0..=1.0).contains(v))), "{p:?} {depth:?}: clipped like the CPU"); } d } fn check(name: &str, sets: &[CameraRaw]) { let Some(mut g) = gpu() else { return }; for p in sets { for depth in DEPTHS { let d = compare(&mut g, p, depth); eprintln!("{name} {depth:?}: max |GPU - CPU| = {d:.2e}"); } } } #[test] fn white_balance_and_exposure() { check( "white balance", &[ CameraRaw { temperature: 40.0, tint: -25.0, ..Default::default() }, CameraRaw { temperature: -70.0, tint: 60.0, exposure: -1.2, ..Default::default() }, CameraRaw { exposure: 1.5, ..Default::default() }, ], ); } #[test] fn contrast_without_texture_or_clarity() { check("contrast", &[CameraRaw { contrast: 60.0, ..Default::default() }, CameraRaw { contrast: -80.0, exposure: 0.4, ..Default::default() }]); } #[test] fn whites_and_blacks() { check( "whites/blacks", &[ CameraRaw { whites: 70.0, blacks: -45.0, ..Default::default() }, CameraRaw { whites: -60.0, blacks: 50.0, temperature: 20.0, ..Default::default() }, CameraRaw { whites: 30.0, ..Default::default() }, CameraRaw { blacks: -100.0, exposure: -0.5, ..Default::default() }, // ProPhoto's power-law encoding. CameraRaw { whites: 50.0, blacks: -30.0, encoding_gamma: 1.8, ..Default::default() }, ], ); } #[test] fn tone_curves() { check( "tone curves", &[ CameraRaw { curve_highlights: -60.0, curve_lights: 30.0, curve_darks: 40.0, curve_shadows: -20.0, curve_splits: [20.0, 45.0, 80.0], ..Default::default() }, CameraRaw { point_curve: vec![[0.0, 20.0], [64.0, 50.0], [192.0, 220.0], [255.0, 245.0]], ..Default::default() }, CameraRaw { point_curve_red: vec![[0.0, 0.0], [128.0, 160.0], [255.0, 255.0]], point_curve_green: vec![[0.0, 10.0], [255.0, 230.0]], point_curve_blue: vec![[0.0, 0.0], [100.0, 70.0], [255.0, 255.0]], ..Default::default() }, ], ); } #[test] fn vibrance_and_saturation() { check( "presence", &[ CameraRaw { vibrance: 70.0, ..Default::default() }, CameraRaw { saturation: -60.0, ..Default::default() }, CameraRaw { vibrance: -40.0, saturation: 50.0, ..Default::default() }, ], ); } #[test] fn color_mixer() { let ramp = |k: f32| std::array::from_fn(|i| ((i as f32 * 37.0 + k) % 200.0) - 100.0); check( "color mixer", &[ CameraRaw { hsl_hue: ramp(0.0), ..Default::default() }, CameraRaw { hsl_sat: ramp(50.0), ..Default::default() }, CameraRaw { hsl_lum: ramp(120.0), ..Default::default() }, CameraRaw { hsl_hue: ramp(10.0), hsl_sat: ramp(80.0), hsl_lum: ramp(150.0), ..Default::default() }, ], ); } #[test] fn color_grading() { check( "color grading", &[ CameraRaw { grade_shadows: Wheel { hue: 220.0, sat: 70.0, lum: 20.0 }, ..Default::default() }, CameraRaw { grade_midtones: Wheel { hue: 120.0, sat: 30.0, lum: -15.0 }, grade_highlights: Wheel { hue: 40.0, sat: 50.0, lum: 10.0 }, grade_global: Wheel { hue: 300.0, sat: 15.0, lum: 5.0 }, grade_blending: 80.0, grade_balance: -40.0, ..Default::default() }, ], ); } #[test] fn vignette() { check( "vignette", &[ CameraRaw { vignette_amount: -70.0, ..Default::default() }, CameraRaw { vignette_amount: -50.0, vignette_roundness: -60.0, vignette_feather: 20.0, vignette_highlights: 70.0, ..Default::default() }, CameraRaw { vignette_amount: 60.0, vignette_roundness: 80.0, vignette_midpoint: 20.0, vignette_style: "colorPriority".into(), ..Default::default() }, CameraRaw { vignette_amount: -40.0, vignette_style: "paintOverlay".into(), ..Default::default() }, CameraRaw { vignette_amount: 40.0, vignette_style: "paintOverlay".into(), ..Default::default() }, ], ); } #[test] fn grain_in_full_resolution_coordinates() { check( "grain", &[ CameraRaw { grain_amount: 60.0, seed: 3, ..Default::default() }, // A preview proxy: the noise lattice is sampled at full-resolution positions. CameraRaw { grain_amount: 80.0, grain_size: 60.0, grain_roughness: 90.0, seed: u32::MAX, pixel_scale: 0.143, ..Default::default() }, CameraRaw { grain_amount: 25.0, grain_size: 0.0, grain_roughness: 0.0, seed: 77, pixel_scale: 0.5, ..Default::default() }, ], ); } #[test] fn every_per_pixel_stage_at_once() { let mut hsl = [0.0; 8]; hsl[1] = 35.0; hsl[5] = -50.0; check( "all stages", &[CameraRaw { temperature: 25.0, tint: 10.0, exposure: 0.3, contrast: 25.0, whites: 20.0, blacks: -15.0, vibrance: 30.0, saturation: 10.0, curve_darks: 20.0, point_curve: vec![[0.0, 8.0], [255.0, 250.0]], hsl_hue: hsl, hsl_sat: hsl, hsl_lum: hsl, grade_shadows: Wheel { hue: 210.0, sat: 25.0, lum: 0.0 }, vignette_amount: -30.0, grain_amount: 20.0, pixel_scale: 0.2, ..Default::default() }], ); } #[test] fn identity_leaves_pixels_alone_and_spatial_settings_have_no_pass() { let Some(mut g) = gpu() else { return }; let p = CameraRaw::default(); let src = image(64, 32, Depth::Float); let stages = per_pixel(&p, 64, 32, false, None).unwrap(); let out = g.dev.develop(&g.device, &g.queue, None, &src, Some(1), [64, 32], &stages).unwrap(); assert_eq!(out, src, "the CPU develop returns early, unclipped"); for spatial in [ CameraRaw { dehaze: 10.0, ..Default::default() }, CameraRaw { shadows: 10.0, ..Default::default() }, CameraRaw { highlights: -10.0, ..Default::default() }, CameraRaw { texture: 10.0, ..Default::default() }, CameraRaw { clarity: 10.0, ..Default::default() }, CameraRaw { sharpen_amount: 10.0, ..Default::default() }, CameraRaw { noise_luminance: 10.0, ..Default::default() }, CameraRaw { noise_color: 10.0, ..Default::default() }, ] { assert!(spatial.spatial() && per_pixel(&spatial, 64, 32, false, Some((0.0, 1.0))).is_none(), "{spatial:?}"); } // Whites and Blacks need the image's points. assert!(per_pixel(&CameraRaw { whites: 10.0, ..Default::default() }, 64, 32, false, None).is_none()); } #[test] fn a_cached_source_is_reused_and_a_new_key_uploads() { let Some(mut g) = gpu() else { return }; let p = CameraRaw { exposure: 0.5, ..Default::default() }; let stages = per_pixel(&p, 64, 32, false, None).unwrap(); let a = image(64, 32, Depth::Eight); let b: Vec<[f32; 4]> = a.iter().map(|q| [q[2], q[0], q[1], 1.0]).collect(); let first = g.dev.develop(&g.device, &g.queue, None, &a, Some(7), [64, 32], &stages).unwrap(); // Same key: the uploaded source stays (callers key by the proxy's identity). assert_eq!(g.dev.develop(&g.device, &g.queue, None, &b, Some(7), [64, 32], &stages).unwrap(), first); let mut cpu = b.clone(); develop(&mut cpu, 64, 32, &p, false); let other = g.dev.develop(&g.device, &g.queue, None, &b, Some(8), [64, 32], &stages).unwrap(); assert!(other.iter().zip(&cpu).all(|(x, y)| (0..3).all(|c| (x[c] - y[c]).abs() <= TOL))); } #[test] fn bad_sizes_and_faulted_devices_are_errors() { let Some(mut g) = gpu() else { return }; let stages = per_pixel(&CameraRaw { exposure: 0.5, ..Default::default() }, 4, 4, false, None).unwrap(); let px = vec![[0.5f32; 4]; 16]; for size in [[0, 4], [4, 0], [5, 4], [3, 3], [u32::MAX, 1]] { assert!(g.dev.develop(&g.device, &g.queue, None, &px, None, size, &stages).is_err(), "{size:?}"); } let health = DeviceHealth::new(); health.mark(Fault::Lost("test".into())); assert!(g.dev.develop(&g.device, &g.queue, Some(&health), &px, None, [4, 4], &stages).is_err()); // And the pass still works afterwards. assert!(g.dev.develop(&g.device, &g.queue, Some(&DeviceHealth::new()), &px, None, [4, 4], &stages).is_ok()); }