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-gpu/src/adjust.rs

@@ -3420,8 +3420,10 @@ mod tests {
             read_centre(&ctx, t)
         };
 
+        // The default rendering of a raw is Camera Raw's tone (D21): a grey
+        // goes through the ACR3 curve unchanged in hue.
         let scene = 3537.0 / 16383.0;
-        let viewed = dr_pipeline::view::Sigmoid::default_curve().channel(scene);
+        let viewed = dr_types::tone::evaluate(&dr_types::tone::ACR3_DEFAULT, scene);
         let expected = (dr_types::Transfer::Srgb.encode(viewed) * 255.0).round() as i32;
         let delta = (i32::from(from_sensor[0]) - expected).abs();
         assert!(

core/dr-gpu/src/demosaic.rs

@@ -578,7 +578,7 @@ impl DemosaicedImage {
             view,
             width,
             height,
-            color_matrix: raw.color_matrix.unwrap_or(IDENTITY_3X3),
+            color_matrix: rendering_matrix(raw),
             profile_tables: raw.profile_tables.clone(),
             as_shot_wb: [raw.wb_coeffs[0], raw.wb_coeffs[1], raw.wb_coeffs[2]],
             non_linear: false,
@@ -589,6 +589,23 @@ impl DemosaicedImage {
     }
 }
 
+/// TRACES: FR-DEV-3e
+/// The camera matrix a raw renders through: the file's — identity where the
+/// body is uncalibrated, so the image renders with no colour transform
+/// rather than not at all — times the baseline exposure as a gain
+/// (camera-profiles.md §11).
+///
+/// A uniform gain commutes with every scene operation before the view
+/// transform, so folding it in here is the same as an exposure step at the
+/// head of the chain, at no cost. The camera-space tap and the white-balance
+/// probe read camera RGB before this matrix and are unaffected.
+/// `RawImage::color_matrix` stays the file's: a merge writes a linear DNG
+/// from it and must not bake a gain into its pixels.
+fn rendering_matrix(raw: &RawImage) -> [f32; 9] {
+    let gain = raw.baseline_exposure.exp2();
+    raw.color_matrix.unwrap_or(IDENTITY_3X3).map(|v| v * gain)
+}
+
 /// Convert an f32 to half-precision bits, the general case: sign,
 /// subnormals, round-to-nearest-even, saturation at the largest finite.
 ///
@@ -937,7 +954,7 @@ impl Demosaicer {
             height,
             // Identity where the body is uncalibrated: the image renders with
             // no colour transform rather than not at all.
-            color_matrix: raw.color_matrix.unwrap_or(IDENTITY_3X3),
+            color_matrix: rendering_matrix(raw),
             profile_tables: raw.profile_tables.clone(),
             as_shot_wb: [raw.wb_coeffs[0], raw.wb_coeffs[1], raw.wb_coeffs[2]],
             // Whatever the profile database had for this body (FR-DEV-3e),