dtourolle
65c1f1a468
Diagnostic only. "matrix" switches the camera profile off and "look200" doubles its look, so a DNG's tables can be judged against the matrix render; "preset:<name>" applies a shipped preset as the menu does. The example now renders through render_detailed, the path every frontend takes, because a preset with clarity in it composes a detail stage that plain render refuses.
224 lines
8.9 KiB
Rust
224 lines
8.9 KiB
Rust
//! Render a RAW file through the full pipeline and write a PPM.
|
||
//!
|
||
//! The end-to-end check: decode → demosaic → adjust → display encode, on a
|
||
//! real file rather than a synthetic fixture. Unit tests prove each stage in
|
||
//! isolation; this proves they compose into an image a person would accept.
|
||
//!
|
||
//! ```sh
|
||
//! cargo run -p dr-gpu --example develop -- IMG.CR2 out.ppm
|
||
//! ```
|
||
//!
|
||
//! PPM because it needs no encoder dependency and every image viewer reads
|
||
//! it. This is a diagnostic, not the export path (FR-EXP-*).
|
||
|
||
use dr_gpu::{AdjustPass, Demosaicer, GpuContext};
|
||
use dr_pipeline::ops::{
|
||
blacks_whites, brilliance, colour_mixer, contrast, curve, exposure, highlights_shadows,
|
||
vibrance, white_balance,
|
||
};
|
||
use dr_pipeline::{EditGraph, ParamId};
|
||
|
||
fn main() {
|
||
env_logger::init();
|
||
|
||
let mut args = std::env::args().skip(1);
|
||
let Some(input) = args.next() else {
|
||
eprintln!("usage: develop <file.cr2> [out.ppm] [preset]");
|
||
eprintln!(" preset: neutral (default) | matrix | look200 | punchy | recover | …");
|
||
std::process::exit(2);
|
||
};
|
||
let output = args.next().unwrap_or_else(|| "develop.ppm".into());
|
||
let preset = args.next().unwrap_or_else(|| "neutral".into());
|
||
|
||
let bytes = std::fs::read(&input).expect("read file");
|
||
|
||
let t0 = std::time::Instant::now();
|
||
let raw = dr_decode::decode(&bytes).expect("decode");
|
||
let decode_ms = t0.elapsed().as_secs_f32() * 1000.0;
|
||
println!(
|
||
"decoded {} × {} ({:?}), {decode_ms:.0} ms",
|
||
raw.crop.width, raw.crop.height, raw.cfa_pattern
|
||
);
|
||
|
||
let ctx = pollster::block_on(GpuContext::new_headless()).expect("gpu");
|
||
println!("adapter {} ({:?})", ctx.adapter_name(), ctx.backend());
|
||
|
||
let t1 = std::time::Instant::now();
|
||
let demosaicer = Demosaicer::new(&ctx).expect("demosaicer");
|
||
let image = demosaicer.run(&raw).expect("demosaic");
|
||
ctx.device
|
||
.poll(wgpu::PollType::wait_indefinitely())
|
||
.expect("poll");
|
||
println!("demosaiced {:.0} ms", t1.elapsed().as_secs_f32() * 1000.0);
|
||
|
||
// Build an edit. The presets exist so the output can be eyeballed for
|
||
// each operation actually doing something, not merely compiling.
|
||
let mut graph = EditGraph::default_chain();
|
||
match preset.as_str() {
|
||
"punchy" => {
|
||
graph.set_param(exposure::ID, exposure::EXPOSURE, 0.3);
|
||
graph.set_param(
|
||
highlights_shadows::ID,
|
||
highlights_shadows::HIGHLIGHTS,
|
||
-40.0,
|
||
);
|
||
graph.set_param(highlights_shadows::ID, highlights_shadows::SHADOWS, 30.0);
|
||
graph.set_param(blacks_whites::ID, blacks_whites::BLACKS, -20.0);
|
||
graph.set_param(blacks_whites::ID, blacks_whites::WHITES, 25.0);
|
||
graph.set_param(vibrance::ID, vibrance::VIBRANCE, 35.0);
|
||
}
|
||
"recover" => {
|
||
graph.set_param(exposure::ID, exposure::EXPOSURE, -0.5);
|
||
graph.set_param(
|
||
highlights_shadows::ID,
|
||
highlights_shadows::HIGHLIGHTS,
|
||
-80.0,
|
||
);
|
||
graph.set_param(highlights_shadows::ID, highlights_shadows::SHADOWS, 60.0);
|
||
graph.set_param(brilliance::ID, brilliance::BRILLIANCE, 40.0);
|
||
graph.set_param(white_balance::ID, white_balance::TEMPERATURE, 15.0);
|
||
}
|
||
// The camera profile switched off: the matrix alone, as every
|
||
// photograph rendered before D20. Beside "neutral" on a DNG that
|
||
// embeds a profile, the difference is the profile's tables.
|
||
"matrix" => {
|
||
graph.set_param(
|
||
dr_pipeline::ops::camera_profile::ID,
|
||
dr_pipeline::ops::camera_profile::APPLY,
|
||
0.0,
|
||
);
|
||
}
|
||
// The profile's look table at twice its strength.
|
||
"look200" => {
|
||
graph.set_param(
|
||
dr_pipeline::ops::camera_profile::ID,
|
||
dr_pipeline::ops::camera_profile::LOOK,
|
||
200.0,
|
||
);
|
||
}
|
||
// Contrast alone, so its effect can be judged without anything else
|
||
// moving.
|
||
"contrast" => {
|
||
graph.set_param(contrast::ID, contrast::CONTRAST, 60.0);
|
||
}
|
||
"flat" => {
|
||
graph.set_param(contrast::ID, contrast::CONTRAST, -60.0);
|
||
}
|
||
// The mixer, pushed hard on the two things this scene actually has:
|
||
// green vegetation and grey-blue rock.
|
||
"mixer" => {
|
||
graph.set_param(colour_mixer::ID, ParamId("green_sat"), 80.0);
|
||
graph.set_param(colour_mixer::ID, ParamId("green_hue"), -40.0);
|
||
graph.set_param(colour_mixer::ID, ParamId("chartreuse_sat"), 60.0);
|
||
graph.set_param(colour_mixer::ID, ParamId("azure_lum"), -50.0);
|
||
}
|
||
// One band only, to check the weighting really is selective rather
|
||
// than affecting the whole image.
|
||
"mixer_one" => {
|
||
graph.set_param(colour_mixer::ID, ParamId("green_sat"), 100.0);
|
||
}
|
||
// A classic S-curve: shadows down, highlights up, mid held.
|
||
"curve_s" => {
|
||
graph.set_param(curve::ID, curve::P1_Y, 0.15);
|
||
graph.set_param(curve::ID, curve::P3_Y, 0.85);
|
||
}
|
||
// The inverse, a film-like lifted-shadow look.
|
||
"curve_lift" => {
|
||
graph.set_param(curve::ID, curve::P0_Y, 0.12);
|
||
graph.set_param(curve::ID, curve::P1_Y, 0.32);
|
||
}
|
||
// A shipped preset by name — `preset:Vivid landscape` — applied as
|
||
// the presets menu applies it, so a look can be judged on a real file.
|
||
named if named.starts_with("preset:") => {
|
||
let name = &named["preset:".len()..];
|
||
let preset = dr_pipeline::bundled::lookup(&Default::default(), name)
|
||
.unwrap_or_else(|| panic!("no shipped preset called {name:?}"));
|
||
let _ = preset.apply(&mut graph, dr_pipeline::Scope::adjustments());
|
||
}
|
||
_ => {}
|
||
}
|
||
|
||
let shader = graph.compose();
|
||
println!(
|
||
"shader {} active op(s), {} uniform floats, structure {:016x}",
|
||
shader.source.matches("---- ").count(),
|
||
shader.uniforms.len(),
|
||
shader.structure_hash
|
||
);
|
||
|
||
let mut adjust = AdjustPass::new(&ctx);
|
||
let (w, h) = image.size();
|
||
|
||
// Through the detail stage when the edit has one — clarity, sharpening
|
||
// — which is the path every frontend takes; `render` alone refuses such
|
||
// a shader.
|
||
let t2 = std::time::Instant::now();
|
||
let detail = graph.compose_detail(image.size(), (w, h));
|
||
let key = graph.invalidation().through(dr_pipeline::Affects::Colour);
|
||
adjust
|
||
.render_detailed(&image, &shader, w, h, None, &detail, key)
|
||
.expect("adjust");
|
||
ctx.device
|
||
.poll(wgpu::PollType::wait_indefinitely())
|
||
.expect("poll");
|
||
println!("adjusted {:.2} ms", t2.elapsed().as_secs_f32() * 1000.0);
|
||
|
||
// Time a second render with only a value changed: this is the slider
|
||
// path, and it must not recompile.
|
||
graph.set_param(exposure::ID, exposure::EXPOSURE, 0.31);
|
||
let again = graph.compose();
|
||
let key = graph.invalidation().through(dr_pipeline::Affects::Colour);
|
||
let t3 = std::time::Instant::now();
|
||
adjust
|
||
.render_detailed(&image, &again, w, h, None, &detail, key)
|
||
.expect("adjust");
|
||
ctx.device
|
||
.poll(wgpu::PollType::wait_indefinitely())
|
||
.expect("poll");
|
||
println!(
|
||
"re-render {:.2} ms ({} pipeline(s) compiled)",
|
||
t3.elapsed().as_secs_f32() * 1000.0,
|
||
adjust.cached_pipelines()
|
||
);
|
||
|
||
// `export_pixels`, because that is honestly what this is: the frame is
|
||
// going into a PPM, not onto a screen. See the note on that method for
|
||
// why the two readbacks were never the same thing (AC-8).
|
||
let (pixels, pw, ph) = adjust.export_pixels().expect("readback");
|
||
|
||
// Sanity: an all-black or all-white result means something upstream
|
||
// failed silently, and it is far easier to see here than in a viewer.
|
||
let mut sum = 0u64;
|
||
let mut min = 255u8;
|
||
let mut max = 0u8;
|
||
for px in pixels.chunks_exact(4) {
|
||
let l = px[0].max(px[1]).max(px[2]);
|
||
sum += u64::from(l);
|
||
min = min.min(l);
|
||
max = max.max(l);
|
||
}
|
||
let mean = sum as f64 / (pixels.len() / 4) as f64;
|
||
println!("levels min {min}, mean {mean:.1}, max {max}");
|
||
if max == 0 {
|
||
eprintln!("WARNING: the image is entirely black");
|
||
}
|
||
|
||
write_ppm(&output, &pixels, pw, ph);
|
||
println!("wrote {output} ({pw} × {ph})");
|
||
}
|
||
|
||
/// Write binary PPM (P6): a three-line header then RGB triples.
|
||
fn write_ppm(path: &str, rgba: &[u8], w: u32, h: u32) {
|
||
use std::io::Write;
|
||
|
||
let mut out = Vec::with_capacity((w * h * 3) as usize + 32);
|
||
out.extend_from_slice(format!("P6\n{w} {h}\n255\n").as_bytes());
|
||
for px in rgba.chunks_exact(4) {
|
||
out.extend_from_slice(&px[..3]);
|
||
}
|
||
std::fs::File::create(path)
|
||
.expect("create output")
|
||
.write_all(&out)
|
||
.expect("write output");
|
||
}
|