Render raws through Camera Raw's tone by default, after baseline exposure

The rendering half of camera-profiles.md §11-§12 (D21). The view
transform gains a curve choice — Camera Raw (the default) or D19's
sigmoid. Camera Raw converts to linear ProPhoto, clips to [0, 1], runs
the curve on the largest and smallest channel and places the middle
one at its old fraction between them (RefBaselineRGBTone), and
converts back: hue kept, saturation raised where the curve is steep,
which is where Adobe Standard's look desaturated. White sets the input
scale (1 at its default, so sensor white is display white) and
contrast bends the input about grey (1 at its default).

The curve rides in the profile buffer after the tables: the profile's
own, else the ACR3 default, which the placeholder every profile-less
source binds also carries — so a CR2 with no .dcp still gets Camera
Raw's tone. Baseline exposure is a gain folded into the rendering
matrix at upload; RawImage::color_matrix stays the file's for the
merge's linear DNG.

camera_raw::apply_reference is the CPU statement; GPU tests hold the
shader to it on 256 colours and on greys against the ACR3 table. The
sigmoid's own tests now choose it explicitly.

core/dr-pipeline/src/camera_raw.rs

@@ -0,0 +1,155 @@
+//! TRACES: FR-DEV-3j | FR-DEV-3e
+//! Camera Raw's tone, as a rendering the view transform can choose (D21).
+//!
+//! Lightroom's colour is mostly its tone curve (camera-profiles.md §1): the
+//! profile's `ProfileToneCurve`, or the ACR3 default for a profile with none.
+//! Half of what the curve does is *how* it is applied. Camera Raw's
+//! `RefBaselineRGBTone` runs it on the largest and the smallest channel, and
+//! places the middle channel at the fraction between them it had before. Hue
+//! is kept; saturation rises wherever the curve is steeper than the
+//! diagonal, which for the ACR3 curve is the shadows and the midtones —
+//! where Adobe Standard's look table desaturated to compensate.
+//!
+//! It runs in linear ProPhoto, as Camera Raw does, on values clipped to
+//! `[0, 1]`; its output is linear and goes to the output transform as the
+//! sigmoid's does. The curve is read from the profile buffer
+//! (`ops::camera_profile::profile_buffer`), which always carries one.
+//!
+//! [`apply_reference`] is the arithmetic on the CPU; the GPU test holds the
+//! shader to it.
+
+use crate::ops::camera_profile::{mul, working_prophoto};
+use crate::view::{DEFAULT_CONTRAST, DEFAULT_WHITE, SCENE_GREY};
+
+/// The input scale for a white point: 1 at the default, so sensor white is
+/// display white as in Camera Raw; each stop of `white` above it halves the
+/// input.
+pub fn input_scale(white: f32) -> f32 {
+    (DEFAULT_WHITE - white).exp2()
+}
+
+/// The power the input is bent by about middle grey: 1 at the default
+/// contrast, so the curve is Camera Raw's untouched.
+pub fn contrast_power(contrast: f32) -> f32 {
+    contrast / DEFAULT_CONTRAST
+}
+
+/// The curve, its scale and its contrast applied to one ProPhoto colour.
+fn rgb_tone(curve: &[f32], p: [f32; 3]) -> [f32; 3] {
+    let p = p.map(|v| v.clamp(0.0, 1.0));
+    let hi = p[0].max(p[1]).max(p[2]);
+    let lo = p[0].min(p[1]).min(p[2]);
+    let (c_hi, c_lo) = (
+        dr_types::tone::evaluate(curve, hi),
+        dr_types::tone::evaluate(curve, lo),
+    );
+    if hi - lo <= 1e-7 {
+        return [c_hi; 3];
+    }
+    p.map(|v| c_lo + (c_hi - c_lo) * (v - lo) / (hi - lo))
+}
+
+/// TRACES: FR-DEV-3j
+/// The view transform's Camera Raw rendering of one working-space colour.
+pub fn apply_reference(curve: &[f32], c: [f32; 3], contrast: f32, white: f32) -> [f32; 3] {
+    let (to, back) = working_prophoto();
+    let scale = input_scale(white);
+    let power = contrast_power(contrast);
+    let mut p = mul(to, c).map(|v| v * scale);
+    if power != 1.0 {
+        p = p.map(|v| SCENE_GREY * (v.max(0.0) / SCENE_GREY).powf(power));
+    }
+    mul(back, rgb_tone(curve, p))
+}
+
+/// The WGSL, a helper the view transform asks for after
+/// `ops::camera_profile`'s ProPhoto constants. Mirrors [`apply_reference`].
+pub const CAMERA_RAW_WGSL: &str = "
+fn camera_raw_curve(x: f32) -> f32 {
+    let base = profile_curve_base();
+    let n = u32(profile_table[2].x);
+    let s = clamp(x, 0.0, 1.0) * f32(n - 1u);
+    let i = min(u32(s), n - 2u);
+    return mix(profile_table[base + i].x, profile_table[base + i + 1u].x, s - f32(i));
+}
+
+// Camera Raw's RGBTone: the curve on the largest and smallest channel, the
+// middle one kept at its fraction between them, so hue survives.
+fn camera_raw_tone(c: vec3<f32>, scale: f32, power: f32, grey: f32) -> vec3<f32> {
+    var p = PROFILE_FROM_WORKING * c * scale;
+    if (power != 1.0) {
+        p = grey * pow(max(p, vec3<f32>(0.0)) / grey, vec3<f32>(power));
+    }
+    p = clamp(p, vec3<f32>(0.0), vec3<f32>(1.0));
+    let hi = max(p.r, max(p.g, p.b));
+    let lo = min(p.r, min(p.g, p.b));
+    let c_hi = camera_raw_curve(hi);
+    let c_lo = camera_raw_curve(lo);
+    var out = vec3<f32>(c_hi);
+    if (hi - lo > 1e-7) {
+        out = vec3<f32>(c_lo) + (c_hi - c_lo) * (p - vec3<f32>(lo)) / (hi - lo);
+    }
+    return PROFILE_TO_WORKING * out;
+}
+";
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use dr_types::tone::{evaluate, ACR3_DEFAULT};
+
+    fn identity() -> Vec<f32> {
+        (0..1025).map(|i| i as f32 / 1024.0).collect()
+    }
+
+    #[test]
+    fn at_its_defaults_the_input_is_untouched() {
+        assert_eq!(input_scale(DEFAULT_WHITE), 1.0);
+        assert_eq!(contrast_power(DEFAULT_CONTRAST), 1.0);
+    }
+
+    #[test]
+    fn grey_goes_through_the_curve_and_stays_grey() {
+        for v in [0.02, 0.13, 0.5] {
+            let out = apply_reference(&ACR3_DEFAULT, [v; 3], DEFAULT_CONTRAST, DEFAULT_WHITE);
+            let want = evaluate(&ACR3_DEFAULT, v);
+            assert!(
+                out.iter().all(|o| (o - want).abs() < 1e-4),
+                "{v}: {out:?} vs {want}"
+            );
+        }
+    }
+
+    #[test]
+    fn an_identity_curve_changes_nothing_inside_the_range() {
+        let c = [0.4, 0.2, 0.1];
+        let out = apply_reference(&identity(), c, DEFAULT_CONTRAST, DEFAULT_WHITE);
+        assert!(
+            out.iter().zip(c).all(|(o, c)| (o - c).abs() < 1e-4),
+            "{out:?}"
+        );
+    }
+
+    #[test]
+    fn the_middle_channel_keeps_its_place_between_the_other_two() {
+        let p = [0.3, 0.12, 0.05];
+        let out = rgb_tone(&ACR3_DEFAULT, p);
+        let before = (p[1] - p[2]) / (p[0] - p[2]);
+        let after = (out[1] - out[2]) / (out[0] - out[2]);
+        assert!((before - after).abs() < 1e-5, "{before} {after}");
+    }
+
+    #[test]
+    fn the_acr_curve_raises_saturation_in_the_midtones() {
+        let p = [0.15, 0.08, 0.05];
+        let out = rgb_tone(&ACR3_DEFAULT, p);
+        let sat = |c: [f32; 3]| (c[0] - c[2]) / c[0];
+        assert!(sat(out) > sat(p), "{p:?} -> {out:?}");
+    }
+
+    #[test]
+    fn white_halves_the_input_per_stop() {
+        assert_eq!(input_scale(DEFAULT_WHITE + 1.0), 0.5);
+        assert!(contrast_power(2.8) > 1.0);
+    }
+}