LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-EXP-COLORSPACE: export in sRGB, Display P3, Adobe RGB (1998) compatible, ProPhoto RGB or Rec. 2020
Brandon Thomas7f40a7a7d9f6
diff --git a/Cargo.lock b/Cargo.lockindex e6d6f3f37..0c1362b6c 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2208,6 +2208,7 @@ dependencies = ["proptest","rayon","serde",+ "serde_json",][[package]]diff --git a/apps/lightcraft-web/src/wire.rs b/apps/lightcraft-web/src/wire.rsindex 6dbe81b2c..9dc5dd310 100644--- a/apps/lightcraft-web/src/wire.rs+++ b/apps/lightcraft-web/src/wire.rs@@ -88,6 +88,8 @@ impl WireJob {quality: if self.draft { Quality::Draft } else { Quality::Full },apply_crop: self.apply_crop,overlay: lightcraft_engine::pipeline::Overlay::from_parts(self.overlay.0, self.overlay.1),+ // workers render previews (exports run in-process)+ space: lightcraft_engine::pipeline::OutputSpace::Srgb,}}diff --git a/crates/color/src/lib.rs b/crates/color/src/lib.rsindex 77d06185a..da9ea7003 100644--- a/crates/color/src/lib.rs+++ b/crates/color/src/lib.rs@@ -118,7 +118,7 @@ pub const PROPHOTO: RgbSpace =RgbSpace { name: "ProPhoto RGB", r: Xy::new(0.734699, 0.265301), g: Xy::new(0.159597, 0.840403), b: Xy::new(0.036598, 0.000105), white: D50 };/// The 1998 "Adobe RGB" primaries (a public colour-space definition; name used descriptively).pub const ADOBE_RGB: RgbSpace =- RgbSpace { name: "Adobe RGB (1998)", r: Xy::new(0.64, 0.33), g: Xy::new(0.21, 0.71), b: Xy::new(0.15, 0.06), white: D65 };+ RgbSpace { name: "Adobe RGB (1998) compatible", r: Xy::new(0.64, 0.33), g: Xy::new(0.21, 0.71), b: Xy::new(0.15, 0.06), white: D65 };/// The develop pipeline's working space: linear Rec.2020 / D65.pub const WORKING: RgbSpace = REC2020;diff --git a/crates/engine/src/export.rs b/crates/engine/src/export.rsindex 107a501be..7c27b50a1 100644--- a/crates/engine/src/export.rs+++ b/crates/engine/src/export.rs@@ -1,9 +1,11 @@-//! Export: encode a rendered image to JPEG / PNG / TIFF / WebP / AVIF with an embedded sRGB profile,-//! optional output sharpening and a JPEG file-size limit. Pure (bytes in, bytes out) so the desktop+//! Export: encode a rendered image to JPEG / PNG / TIFF / WebP / AVIF in sRGB, Display P3, Adobe RGB+//! (1998) compatible, ProPhoto RGB or Rec. 2020 with an embedded ICC profile we generate from the+//! published primaries and curves, optional output sharpening and a JPEG file-size limit. Pure (bytes in, bytes out) so the desktop//! app, CLI, MCP and the web build share it; writing the file is the caller's job.use lightcraft_codecs::{ChromaSubsampling, EncodeImage, EncodeMeta, NamedSpace, TiffCompression, encode, icc};use lightcraft_meta::{DateTime, Gps, Metadata};+pub use lightcraft_pipeline::OutputSpace;use lightcraft_raster::Rgba8;use serde::{Deserialize, Serialize};@@ -198,6 +200,8 @@ pub struct ExportOptions {pub remove_location: bool,/// Text watermark (none when absent or the text is empty).pub watermark: Option<Watermark>,+ /// Output colour space (AVIF is always sRGB: its muxer cannot embed a profile).+ pub color_space: OutputSpace,}impl Default for ExportOptions {@@ -213,12 +217,14 @@ impl Default for ExportOptions {metadata: MetadataPolicy::All,remove_location: false,watermark: None,+ color_space: OutputSpace::Srgb,}}}impl ExportOptions {- /// Read options from command params (`format`, `quality`, `longEdge`, `limitKb`, `sharpen`, `sharpenAmount`, `naming`).+ /// Read options from command params (`format`, `quality`, `longEdge`, `limitKb`, `sharpen`,+ /// `sharpenAmount`, `naming`, `metadata`, `removeLocation`, `watermark`, `colorSpace`).pub fn from_json(p: &serde_json::Value) -> Self {use serde_json::Value;let d = Self::default();@@ -243,9 +249,15 @@ impl ExportOptions {_ => None,}.filter(|w: &Watermark| !w.text.trim().is_empty()),+ color_space: s("colorSpace").and_then(OutputSpace::parse).unwrap_or(d.color_space),}}+ /// The colour space the file is actually written in (AVIF: sRGB).+ pub fn effective_space(&self) -> OutputSpace {+ if self.format == ExportFormat::Avif { OutputSpace::Srgb } else { self.color_space }+ }+/// Output file name for photo `stem` at 1-based position `seq` in a batch.pub fn file_name(&self, stem: &str, seq: usize) -> String {let base = if self.naming.trim().is_empty() { "{name}" } else { self.naming.as_str() };@@ -304,7 +316,8 @@ pub fn output_sharpen(img: &mut Rgba8, target: SharpenFor, amount: SharpenAmount}}-/// Encode a rendered (display-referred sRGB) image according to `o`. Resizing to `long_edge` is the+/// Encode a rendered display-referred image according to `o` (its pixels must already be in+/// `o.effective_space()`). Resizing to `long_edge` is the/// caller's job (render at that size); sharpening is applied here.pub fn encode_image(img: &Rgba8, o: &ExportOptions) -> Result<Vec<u8>, String> {encode_with_metadata(img, o, None)@@ -314,10 +327,12 @@ pub fn encode_image(img: &Rgba8, o: &ExportOptions) -> Result<Vec<u8>, String> {pub fn encode_with_metadata(img: &Rgba8, o: &ExportOptions, meta: Option<&Metadata>) -> Result<Vec<u8>, String> {let mut img = img.clone();output_sharpen(&mut img, o.sharpen, o.sharpen_amount);+ let space = o.effective_space();if let Some(wm) = &o.watermark {- draw_watermark(&mut img, wm);+ let wm = Watermark { color: srgb8_in(space, wm.color), ..wm.clone() };+ draw_watermark(&mut img, &wm);}- let profile = icc::write_named(NamedSpace::Srgb);+ let profile = icc::write_named(named_space(space));let exif = meta.map(lightcraft_meta::write_exif);let xmp = meta.map(|m| lightcraft_meta::write_xmp(m, None));let meta = EncodeMeta { icc: Some(&profile), exif: exif.as_deref(), xmp: xmp.as_deref() };@@ -358,6 +373,31 @@ pub fn encode_with_metadata(img: &Rgba8, o: &ExportOptions, meta: Option<&Metadar.map_err(|e| e.to_string())}+/// The codecs' name of an output space (for its ICC profile).+pub fn named_space(s: OutputSpace) -> NamedSpace {+ match s {+ OutputSpace::Srgb => NamedSpace::Srgb,+ OutputSpace::DisplayP3 => NamedSpace::DisplayP3,+ OutputSpace::AdobeRgb => NamedSpace::AdobeRgb,+ OutputSpace::ProPhoto => NamedSpace::ProPhoto,+ OutputSpace::Rec2020 => NamedSpace::Rec2020,+ }+}++/// An 8-bit sRGB colour expressed in `space` (encoded with its curve).+pub fn srgb8_in(space: OutputSpace, c: [u8; 3]) -> [u8; 3] {+ if space == OutputSpace::Srgb {+ return c;+ }+ let lin = c.map(lightcraft_color::transfer::decode_srgb8);+ let m = lightcraft_color::SRGB.to_space(&space.rgb_space()).to_f32();+ let t = space.trc();+ std::array::from_fn(|i| {+ let v = m[i][0] * lin[0] + m[i][1] * lin[1] + m[i][2] * lin[2];+ (t.encode(v) * 255.0 + 0.5) as u8+ })+}+/// Parse a shutter speed such as `1/250`, `0.5` or `2"` into seconds.fn parse_shutter(s: &str) -> Option<f64> {let s = s.trim().trim_end_matches(['s', '"']).trim();@@ -414,7 +454,7 @@ pub fn export_photo(session: &mut crate::Session, id: lightcraft_catalog::PhotoIlet full = p.width.max(p.height).max(1) as usize;let size = o.long_edge.map_or(full, |l| l as usize);let meta = export_metadata(p, o);- let r = session.render_now(id, size, size)?;+ let r = session.render_export(id, size, o.effective_space())?;let bytes = encode_with_metadata(&r.image, o, meta.as_ref())?;Ok(Exported { file_name: o.file_name(&stem, seq), bytes, width: r.image.width, height: r.image.height })}@@ -516,4 +556,80 @@ mod tests {assert_eq!(o.long_edge, Some(2048));assert_eq!(o.file_name("IMG/1", 7), "IMG_1-007.jpg");}++ /// A flat field of a saturated green inside Display P3 but outside sRGB, rendered into `space`.+ fn p3_green(space: OutputSpace) -> Rgba8 {+ use lightcraft_color::{DISPLAY_P3, REC2020};+ let c = DISPLAY_P3.to_space(&REC2020).apply_f32([0.04, 0.45, 0.04]);+ let src = lightcraft_raster::Rgb32f::filled(16, 16, c);+ let req = lightcraft_pipeline::RenderRequest { space, ..lightcraft_pipeline::RenderRequest::fit(16, 16) };+ lightcraft_pipeline::render(&src, &Default::default(), &Default::default(), &req).image+ }++ /// Decode `bytes` and return the centre pixel in linear sRGB primaries (unclamped), plus the+ /// recognised space of the embedded profile.+ fn decoded_in_srgb(bytes: &[u8]) -> ([f32; 3], Option<NamedSpace>) {+ let d = lightcraft_codecs::decode(bytes, Default::default()).expect("decodes");+ let m = d.space.to_space(&lightcraft_color::SRGB);+ (m.apply_f32(d.image.get(8, 8)), d.space.named)+ }++ #[test]+ fn p3_colour_survives_a_p3_export_and_is_clipped_in_srgb() {+ let o = |space| ExportOptions { format: ExportFormat::Png, color_space: space, ..Default::default() };+ let (p3, named) = decoded_in_srgb(&encode_image(&p3_green(OutputSpace::DisplayP3), &o(OutputSpace::DisplayP3)).unwrap());+ assert_eq!(named, Some(NamedSpace::DisplayP3));+ assert!(p3[0] < -0.03 || p3[2] < -0.03, "outside sRGB after a P3 round trip: {p3:?}");+ let (s, named) = decoded_in_srgb(&encode_image(&p3_green(OutputSpace::Srgb), &o(OutputSpace::Srgb)).unwrap());+ assert_eq!(named, Some(NamedSpace::Srgb));+ assert!(s.iter().all(|v| *v > -0.002), "{s:?}");+ // the green itself is about the same brightness either way+ assert!((p3[1] - s[1]).abs() < 0.15, "{p3:?} {s:?}");+ }++ #[test]+ fn every_space_embeds_its_own_profile_and_round_trips() {+ let grey = {+ let src = lightcraft_raster::Rgb32f::filled(16, 16, [0.18; 3]);+ let base = lightcraft_pipeline::RenderRequest::fit(16, 16);+ move |space| {+ lightcraft_pipeline::render(&src, &Default::default(), &Default::default(), &lightcraft_pipeline::RenderRequest { space, ..base })+ .image+ }+ };+ let reference =+ decoded_in_srgb(&encode_image(&grey(OutputSpace::Srgb), &ExportOptions { format: ExportFormat::Tiff, ..Default::default() }).unwrap()).0;+ for space in OutputSpace::ALL {+ for format in [ExportFormat::Jpeg, ExportFormat::Png, ExportFormat::Tiff, ExportFormat::Webp] {+ let o = ExportOptions { format, color_space: space, ..Default::default() };+ let bytes = encode_image(&grey(space), &o).unwrap();+ let (px, named) = decoded_in_srgb(&bytes);+ assert_eq!(named, Some(named_space(space)), "{space:?} {format:?}");+ // a neutral grey decodes to the same linear value whatever the output space+ for c in 0..3 {+ assert!((px[c] - reference[c]).abs() < 0.01, "{space:?} {format:?}: {px:?} vs {reference:?}");+ }+ }+ let icc = icc::write_named(named_space(space));+ let info = icc::parse(&icc).expect("our profile parses");+ assert_eq!(info.named, Some(named_space(space)));+ assert!(info.description.as_deref().is_some_and(|d| !d.is_empty()));+ }+ let o = ExportOptions { format: ExportFormat::Avif, color_space: OutputSpace::ProPhoto, ..Default::default() };+ assert_eq!(o.effective_space(), OutputSpace::Srgb);+ let o = ExportOptions::from_json(&serde_json::json!({"colorSpace": "displayP3"}));+ assert_eq!(o.color_space, OutputSpace::DisplayP3);+ assert_eq!(ExportOptions::from_json(&serde_json::json!({"colorSpace": "Adobe RGB (1998) compatible"})).color_space, OutputSpace::AdobeRgb);+ }++ #[test]+ fn srgb_watermark_colour_is_converted() {+ assert_eq!(srgb8_in(OutputSpace::Srgb, [10, 200, 30]), [10, 200, 30]);+ for s in OutputSpace::ALL {+ assert_eq!(srgb8_in(s, [255, 255, 255]), [255, 255, 255], "{s:?}");+ assert_eq!(srgb8_in(s, [0, 0, 0]), [0, 0, 0], "{s:?}");+ }+ let p3 = srgb8_in(OutputSpace::DisplayP3, [255, 0, 0]);+ assert!(p3[0] < 255 && p3[1] > 0, "{p3:?}");+ }}diff --git a/crates/engine/src/media.rs b/crates/engine/src/media.rsindex e10b31a1e..98adc8391 100644--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@ -518,6 +518,16 @@ impl crate::Session {r.rendered}+ /// Synchronous render for export: like [`Self::render_now`], into colour space `space`.+ pub fn render_export(&mut self, id: PhotoId, max: usize, space: lightcraft_pipeline::OutputSpace) -> Result<Rendered, String> {+ let mut job = self.render_job(id, max, max, false, true).ok_or("no such photo")?;+ job.request.space = space;+ job.key ^= (space as u64 + 1).wrapping_mul(0xa076_1d64_78bd_642f);+ let r = job.run();+ self.accept(&r);+ r.rendered+ }+/// The source proxy for pixel-statistics commands (auto tone/WB), loading synchronously.pub fn source_now(&mut self, id: PhotoId, level: SourceLevel) -> Result<Arc<Rgb32f>, String> {let p = self.catalog.photo(id).ok_or("no such photo")?.clone();diff --git a/crates/gpu/src/ctx.rs b/crates/gpu/src/ctx.rsindex 010ff7ba0..dad0a42ba 100644--- a/crates/gpu/src/ctx.rs+++ b/crates/gpu/src/ctx.rs@@ -125,8 +125,7 @@ fn constants() -> String {use lightcraft_pipeline::tone::{LUT_MAX_EV, LUT_MIN_EV, LUT_N};let mut s = String::new();let [to_lms, from_lms, to_lab, from_lab] = lightcraft_color::perceptual::oklab_matrices();- let to_srgb = lightcraft_color::REC2020.to_space(&lightcraft_color::SRGB).to_f32();- for (name, m) in [("OK_TO_LMS", to_lms), ("OK_FROM_LMS", from_lms), ("OK_TO_LAB", to_lab), ("OK_FROM_LAB", from_lab), ("TO_SRGB", to_srgb)] {+ for (name, m) in [("OK_TO_LMS", to_lms), ("OK_FROM_LMS", from_lms), ("OK_TO_LAB", to_lab), ("OK_FROM_LAB", from_lab)] {let rows: Vec<String> = m.iter().map(|r| format!("vec3<f32>({:?}, {:?}, {:?})", r[0], r[1], r[2])).collect();s += &format!("const {name} = array<vec3<f32>, 3>({});\n", rows.join(", "));}diff --git a/crates/gpu/src/params.rs b/crates/gpu/src/params.rsindex b18461a2e..279692c91 100644--- a/crates/gpu/src/params.rs+++ b/crates/gpu/src/params.rs@@ -66,6 +66,10 @@ const FIELDS: &[(&str, usize)] = &[("CALIB", 1),("CALIB_M", 9),("SHADOW_TINT", 1),+ ("OUT_M", 9),+ ("OUT_Y", 3),+ ("OUT_TRC", 1),+ ("OUT_GAMMA", 1),];/// `(name, index)` of every field (for the WGSL constants).@@ -212,6 +216,11 @@ pub fn finish_block(fp: &FinishParams, masks: &[[f32; MASK_TERMS]], present: &Prp.fs("CALIB_M", m.as_flattened());}p.f("SHADOW_TINT", fp.shadow_tint);+ p.fs("OUT_M", fp.to_out.as_flattened());+ p.fs("OUT_Y", &fp.out_luma);+ let (trc, gamma) = fp.out_trc.code();+ p.u("OUT_TRC", trc);+ p.f("OUT_GAMMA", gamma);if let Some((amt, cell, rough, seed)) = fp.grain {p.b("GRAIN", true);p.f("GRAIN_AMT", amt);diff --git a/crates/gpu/src/render.rs b/crates/gpu/src/render.rsindex 0174da93e..8f0bf08fe 100644--- a/crates/gpu/src/render.rs+++ b/crates/gpu/src/render.rs@@ -460,7 +460,7 @@ pub fn render(lap("masks", &mut t, &mut cx);// 5. per-pixel stage- let fp = FinishParams::new(s, &plan.frame, info, w, h, plan.px_per_long, prep.air);+ let fp = FinishParams::new(s, &plan.frame, info, w, h, plan.px_per_long, prep.air, req.space);let present = Present { clarity: prep.clarity.is_some(), texture: prep.texture.is_some(), dark: prep.dark.is_some() };let (p, aux) = finish_block(&fp, &terms, &present);let aux = gpu.upload(&aux);diff --git a/crates/gpu/src/wgsl/finish.wgsl b/crates/gpu/src/wgsl/finish.wgslindex d405e9495..71b20d5b7 100644--- a/crates/gpu/src/wgsl/finish.wgsl+++ b/crates/gpu/src/wgsl/finish.wgsl@@ -218,6 +218,26 @@ fn enc8(v: f32) -> u32 {return u32(clamp(v, 0.0, 1.0) * 255.0 + 0.5);}+// sRGB-curve-encoded value → the output space's own curve (`OutputTrc`: 0 sRGB, 1 gamma, 2 Rec.709).+fn out_encode(v: f32) -> f32 {+ let kind = pu(F_OUT_TRC);+ if (kind == 0u) {+ return v;+ }+ let e = clamp(v, 0.0, 1.0);+ var l = e / 12.92;+ if (e > 0.04045) {+ l = pow((e + 0.055) / 1.055, 2.4);+ }+ if (kind == 1u) {+ return pow(l, 1.0 / pf(F_OUT_GAMMA));+ }+ if (l < 0.018) {+ return l * 4.5;+ }+ return 1.099 * pow(l, 0.45) - 0.099;+}+@compute @workgroup_size(16, 16)fn main(@builtin(global_invocation_id) gid: vec3<u32>) {let w = pu(F_W);@@ -399,9 +419,14 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {}}- // --- gamut map to sRGB (desaturate towards luminance until in range)- var r = mul3(TO_SRGB, d);- let yy = clamp(0.2126 * r.x + 0.7152 * r.y + 0.0722 * r.z, 0.0, 1.0);+ // --- gamut map to the output space (desaturate towards luminance until in range)+ let om = array<vec3<f32>, 3>(+ vec3<f32>(pf(F_OUT_M), pf(F_OUT_M + 1u), pf(F_OUT_M + 2u)),+ vec3<f32>(pf(F_OUT_M + 3u), pf(F_OUT_M + 4u), pf(F_OUT_M + 5u)),+ vec3<f32>(pf(F_OUT_M + 6u), pf(F_OUT_M + 7u), pf(F_OUT_M + 8u)),+ );+ var r = mul3(om, d);+ let yy = clamp(pf(F_OUT_Y) * r.x + pf(F_OUT_Y + 1u) * r.y + pf(F_OUT_Y + 2u) * r.z, 0.0, 1.0);var tg = 1.0;for (var k = 0u; k < 3u; k++) {let cc = r[k];@@ -439,5 +464,6 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {let k = pf(F_GRAIN_AMT) * g * (0.35 + 2.6 * lum * (1.0 - lum));e = e + k;}+ e = vec3<f32>(out_encode(e.x), out_encode(e.y), out_encode(e.z));out[i] = enc8(e.x) | (enc8(e.y) << 8u) | (enc8(e.z) << 16u) | (255u << 24u);}diff --git a/crates/gpu/tests/equivalence.rs b/crates/gpu/tests/equivalence.rsindex d6fdab543..619114764 100644--- a/crates/gpu/tests/equivalence.rs+++ b/crates/gpu/tests/equivalence.rs@@ -462,3 +462,32 @@ fn red_eye_matches() {};check("red eye + spot (cpu stage)", &src, &info, &s, &RenderRequest::fit(600, 600));}++fn saturated(s: &mut DevelopSettings) {+ typical(s);+ s.color.saturation = 70.0;+ s.color.vibrance = 40.0;+ s.curve.highlights = 30.0;+ s.curve.shadows = -20.0;+ s.grain.amount = 30.0;+}++#[test]+fn output_spaces_match() {+ if !gpu() {+ return;+ }+ // Export colour spaces: matrix to the target primaries, gamut mapping into the target gamut and+ // its encoding curve, on both renderers. Saturated edits push colours to the gamut edges.+ use lightcraft_pipeline::OutputSpace;+ let src = scene(0, 900, 600);+ let raw = SourceInfo { raw: true, ..Default::default() };+ for space in OutputSpace::ALL {+ for (name, edit) in [("typical", typical as Edit), ("saturated + curves + grain", saturated as Edit)] {+ let mut s = DevelopSettings::default();+ edit(&mut s);+ let req = RenderRequest { space, ..RenderRequest::fit(640, 640) };+ check(&format!("{space:?} {name}"), &src, &raw, &s, &req);+ }+ }+}diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rsindex 663c8f08a..57f289c12 100644--- a/crates/mcp/src/tools.rs+++ b/crates/mcp/src/tools.rs@@ -188,6 +188,7 @@ pub fn helper_tools(has_ui: bool) -> Vec<Value> {"naming": {"type": "string", "description": "e.g. {name}-{seq}"},"metadata": {"type": "string", "enum": ["all", "allExceptCamera", "copyright", "none"]},"removeLocation": {"type": "boolean"},+ "colorSpace": {"type": "string", "enum": ["srgb", "displayP3", "adobeRgb", "proPhoto", "rec2020"], "description": "Output colour space (default sRGB; AVIF is always sRGB). adobeRgb = Adobe RGB (1998) compatible; the embedded ICC profile is generated from the published primaries"},"watermark": {"description": "Text, or {text, size (fraction of short edge), opacity, anchor (topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight), inset, color [r,g,b], shadow}"}}),&[],@@ -534,6 +535,7 @@ pub fn call_tool(b: &mut dyn Backend, name: &str, args: &Value) -> ToolResult {"metadata","removeLocation","watermark",+ "colorSpace",],),)diff --git a/crates/pipeline/Cargo.toml b/crates/pipeline/Cargo.tomlindex ff997b5c5..27d778164 100644--- a/crates/pipeline/Cargo.toml+++ b/crates/pipeline/Cargo.toml@@ -20,3 +20,4 @@ serde = { workspace = true }lightcraft-scenes = { workspace = true }proptest = { workspace = true }image = { workspace = true }+serde_json = { workspace = true }diff --git a/crates/pipeline/src/finish.rs b/crates/pipeline/src/finish.rsindex 0ab6199e4..83f1c0330 100644--- a/crates/pipeline/src/finish.rs+++ b/crates/pipeline/src/finish.rs@@ -1,8 +1,8 @@//! The per-pixel stage: everything after the spatial planes are ready, in one parallel pass.+use lightcraft_color::luminance_2020;use lightcraft_color::spline::{Lut1, MonotoneCurve};use lightcraft_color::transfer::linear_to_srgb;-use lightcraft_color::{REC2020, SRGB, luminance_2020};use lightcraft_develop::{DevelopSettings, LocalAdjustments, ToneCurve, VignetteStyle};use lightcraft_geom::Point;use lightcraft_raster::Rgba8;@@ -10,6 +10,7 @@ use lightcraft_raster::Rgba8;use crate::colorops::ColorOps;use crate::geometry::Frame;use crate::local::log_lum;+use crate::output::{OutputSpace, OutputTrc};use crate::tone::ToneMap;use crate::{Prepared, SourceInfo, for_rows};@@ -153,7 +154,11 @@ pub struct FinishParams {/// Refine Saturation as 0..1 (1 = the curves' own saturation).pub refine_sat: f32,pub vig: Option<Vig>,- pub to_srgb: [[f32; 3]; 3],+ /// Linear Rec.2020 → linear output RGB, the output's luminance weights (gamut mapping) and its+ /// encoding curve (see [`crate::output`]).+ pub to_out: [[f32; 3]; 3],+ pub out_luma: [f32; 3],+ pub out_trc: OutputTrc,pub hl: f32,pub sh: f32,pub clar: f32,@@ -178,8 +183,18 @@ pub struct FinishParams {}impl FinishParams {- /// Parameters for a `w × h` render; `ev`/`air_pre` as in [`crate::Prepared`].- pub fn new(s: &DevelopSettings, frame: &Frame, info: &SourceInfo, w: usize, h: usize, px_per_long: f64, air_pre: f32) -> FinishParams {+ /// Parameters for a `w × h` render into `space`; `ev`/`air_pre` as in [`crate::Prepared`].+ #[allow(clippy::too_many_arguments)]+ pub fn new(+ s: &DevelopSettings,+ frame: &Frame,+ info: &SourceInfo,+ w: usize,+ h: usize,+ px_per_long: f64,+ air_pre: f32,+ space: OutputSpace,+ ) -> FinishParams {let effects = s.section_enabled("effects");let (clar, tex, dehaze) = if effects {((s.effects.clarity / 100.0) as f32, (s.effects.texture / 100.0) as f32, (s.effects.dehaze / 100.0) as f32)@@ -205,7 +220,9 @@ impl FinishParams {curves: curve_luts(&s.curve),refine_sat: (s.curve.refine_saturation / 100.0).clamp(0.0, 1.0) as f32,vig: if effects { vignette(s) } else { None },- to_srgb: REC2020.to_space(&SRGB).to_f32(),+ to_out: space.from_working(),+ out_luma: space.luma(),+ out_trc: space.trc(),hl: (s.light.highlights / 100.0) as f32,sh: (s.light.shadows / 100.0) as f32,clar,@@ -228,10 +245,45 @@ impl FinishParams {}}-pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &SourceInfo) -> Rgba8 {+pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &SourceInfo, space: OutputSpace) -> Rgba8 {let (w, h) = (p.img.width, p.img.height);- let fp = FinishParams::new(s, frame, info, w, h, p.px_per_long, p.air);- let FinishParams { tone, ops, curves, vig, to_srgb, hl, sh, clar, tex, dehaze, sharpen, sharpen_mask, air, air_pre, gain, ev, grain, .. } = &fp;+ let fp = FinishParams::new(s, frame, info, w, h, p.px_per_long, p.air, space);+ let trc = fp.out_trc;+ let data = finish_with(p, &fp, |e| match trc {+ OutputTrc::Srgb => [enc(e[0]), enc(e[1]), enc(e[2]), 255],+ t => {+ let x = e.map(|v| enc(t.encode(lightcraft_color::transfer::srgb_to_linear(v.clamp(0.0, 1.0)))));+ [x[0], x[1], x[2], 255]+ }+ });+ Rgba8 { width: w, height: h, data }+}++/// The per-pixel stage: every output pixel's colour in the output primaries, encoded with the sRGB+/// curve (tone curves and grain applied; not clamped), handed to `store` for the final encoding.+pub(crate) fn finish_with<T: Copy + Default + Send>(p: &Prepared, fp: &FinishParams, store: impl Fn([f32; 3]) -> T + Sync + Send) -> Vec<T> {+ let (w, h) = (p.img.width, p.img.height);+ let FinishParams {+ tone,+ ops,+ curves,+ vig,+ to_out,+ out_luma,+ hl,+ sh,+ clar,+ tex,+ dehaze,+ sharpen,+ sharpen_mask,+ air,+ air_pre,+ gain,+ ev,+ grain,+ ..+ } = fp;let (hl, sh, clar, tex, dehaze, sharpen, sharpen_mask, air, air_pre, gain, ev) =(*hl, *sh, *clar, *tex, *dehaze, *sharpen, *sharpen_mask, *air, *air_pre, *gain, *ev);let terms: Vec<[f32; MASK_TERMS]> = p.masks.iter().map(|m| mask_terms(&m.adjust)).collect();@@ -240,8 +292,8 @@ pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &Solet aspect = w as f32 / h as f32;let srgb = srgb_lut();- let mut out = Rgba8::new(w, h);- for_rows(&mut out.data, w, |y, row| {+ let mut out = vec![T::default(); w * h];+ for_rows(&mut out, w, |y, row| {for (x, px) in row.iter_mut().enumerate() {let i = y * w + x;let raw = p.img.data[i];@@ -388,14 +440,14 @@ pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &So}}- // --- gamut map to sRGB (desaturate towards luminance until in range)- let m = to_srgb;+ // --- gamut map to the output space (desaturate towards luminance until in range)+ let m = to_out;let mut r = [m[0][0] * d[0] + m[0][1] * d[1] + m[0][2] * d[2],m[1][0] * d[0] + m[1][1] * d[1] + m[1][2] * d[2],m[2][0] * d[0] + m[2][1] * d[1] + m[2][2] * d[2],];- let yy = (0.2126 * r[0] + 0.7152 * r[1] + 0.0722 * r[2]).clamp(0.0, 1.0);+ let yy = (out_luma[0] * r[0] + out_luma[1] * r[1] + out_luma[2] * r[2]).clamp(0.0, 1.0);let mut t = 1.0f32;for c in r {if c < 0.0 {@@ -427,7 +479,7 @@ pub(crate) fn finish(p: &Prepared, s: &DevelopSettings, frame: &Frame, info: &Solet k = amt * g * (0.35 + 2.6 * lum * (1.0 - lum));e = e.map(|v| v + k);}- *px = [enc(e[0]), enc(e[1]), enc(e[2]), 255];+ *px = store(e);}});outdiff --git a/crates/pipeline/src/lib.rs b/crates/pipeline/src/lib.rsindex 548febbd2..0b7596540 100644--- a/crates/pipeline/src/lib.rs+++ b/crates/pipeline/src/lib.rs@@ -11,7 +11,7 @@//! clarity, local adjustments (masks)//! 3. tone map — contrast / whites / blacks filmic curve on luminance, highlight desaturation//! 4. colour — vibrance, saturation, colour mixer, colour grading, B&W (OkLCh)-//! 5. display — gamut map to sRGB, encode, tone curves (parametric + point), vignette, grain+//! 5. display — gamut map to the output space (sRGB unless [`RenderRequest::space`] says otherwise), encode, tone curves (parametric + point), vignette, grain//!//! Spatial parameters are specified relative to the image's long edge, so a 400 px preview and a//! 60 MP export look alike.@@ -29,6 +29,7 @@ pub mod geometry;pub mod local;pub mod masks;pub mod optics;+pub mod output;pub mod profiles;pub mod redeye;pub mod spots;@@ -37,6 +38,7 @@ pub mod transform;pub mod upright;pub mod visualize;+pub use output::{OutputSpace, OutputTrc};pub use visualize::Overlay;use lightcraft_develop::{DevelopSettings, Treatment};@@ -84,11 +86,13 @@ pub struct RenderRequest {pub apply_crop: bool,/// A diagnostic view drawn over the result (e.g. Point Color's "visualize range").pub overlay: Overlay,+ /// Colour space of the result (exports; previews stay sRGB).+ pub space: OutputSpace,}impl RenderRequest {pub fn fit(max_w: usize, max_h: usize) -> Self {- Self { max_w, max_h, quality: Quality::Full, apply_crop: true, overlay: Overlay::None }+ Self { max_w, max_h, quality: Quality::Full, apply_crop: true, overlay: Overlay::None, space: OutputSpace::Srgb }}}@@ -344,7 +348,7 @@ fn render_impl(src: Src<'_>, info: &SourceInfo, s: &DevelopSettings, req: &Rendeif let Some((a, c)) = shared {c.put(CacheEntry { src: a.clone(), geo, sampled, lin: Some((lin_key, lin)), planes });}- let image = finish::finish(&prep, s, frame, info);+ let image = finish::finish(&prep, s, frame, info, req.space);lap("finish", &mut t);let histogram = Histogram::of_srgb8(&image);lap("histogram", &mut t);diff --git a/crates/pipeline/src/output.rs b/crates/pipeline/src/output.rsnew file mode 100644index 000000000..fc532bb77--- /dev/null+++ b/crates/pipeline/src/output.rs@@ -0,0 +1,175 @@+//! Output encoding: the colour space (primaries + transfer curve) and sample format a render is+//! delivered in. Previews are always 8-bit sRGB; exports may ask for a wide-gamut space and/or+//! 16-bit or linear float samples.+//!+//! The per-pixel stage works in scene-linear Rec.2020 and ends by converting to the target's+//! primaries, gamut mapping into the *target* gamut, and encoding. Tone curves and grain operate on+//! sRGB-curve-encoded values of the target primaries (identical to the sRGB path when the target is+//! sRGB); afterwards the values are re-encoded with the target's own curve.++use lightcraft_color::{ADOBE_RGB, DISPLAY_P3, PROPHOTO, REC2020, RgbSpace, SRGB};+use serde::{Deserialize, Serialize};++/// The RGB space an image is rendered into.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub enum OutputSpace {+ #[default]+ Srgb,+ DisplayP3,+ /// Primaries and gamma of the published Adobe RGB (1998) specification ("compatible": our own+ /// profile, built from the published numbers).+ AdobeRgb,+ ProPhoto,+ Rec2020,+}++/// The encoding curve of an [`OutputSpace`].+#[derive(Clone, Copy, Debug, PartialEq)]+pub enum OutputTrc {+ /// IEC 61966-2-1 (sRGB, Display P3).+ Srgb,+ /// Pure power law: encoded = linear^(1/g).+ Gamma(f32),+ /// ITU-R BT.709 / BT.2020 OETF.+ Rec709,+}++impl OutputTrc {+ /// Linear → encoded (input clamped to 0..1).+ pub fn encode(self, v: f32) -> f32 {+ let v = v.clamp(0.0, 1.0);+ match self {+ OutputTrc::Srgb => lightcraft_color::transfer::linear_to_srgb(v),+ OutputTrc::Gamma(g) => v.powf(1.0 / g),+ OutputTrc::Rec709 => {+ if v < 0.018 {+ v * 4.5+ } else {+ 1.099 * v.powf(0.45) - 0.099+ }+ }+ }+ }++ /// Encoded → linear (input clamped to 0..1).+ pub fn decode(self, e: f32) -> f32 {+ let e = e.clamp(0.0, 1.0);+ match self {+ OutputTrc::Srgb => lightcraft_color::transfer::srgb_to_linear(e),+ OutputTrc::Gamma(g) => e.powf(g),+ OutputTrc::Rec709 => {+ if e < 0.081 {+ e / 4.5+ } else {+ ((e + 0.099) / 1.099).powf(1.0 / 0.45)+ }+ }+ }+ }++ /// Code for the GPU kernel: 0 sRGB, 1 gamma, 2 Rec.709.+ pub fn code(self) -> (u32, f32) {+ match self {+ OutputTrc::Srgb => (0, 1.0),+ OutputTrc::Gamma(g) => (1, g),+ OutputTrc::Rec709 => (2, 1.0),+ }+ }+}++impl OutputSpace {+ pub const ALL: [OutputSpace; 5] = [OutputSpace::Srgb, OutputSpace::DisplayP3, OutputSpace::AdobeRgb, OutputSpace::ProPhoto, OutputSpace::Rec2020];++ pub fn rgb_space(self) -> RgbSpace {+ match self {+ OutputSpace::Srgb => SRGB,+ OutputSpace::DisplayP3 => DISPLAY_P3,+ OutputSpace::AdobeRgb => ADOBE_RGB,+ OutputSpace::ProPhoto => PROPHOTO,+ OutputSpace::Rec2020 => REC2020,+ }+ }++ pub fn trc(self) -> OutputTrc {+ match self {+ OutputSpace::Srgb | OutputSpace::DisplayP3 => OutputTrc::Srgb,+ OutputSpace::AdobeRgb => OutputTrc::Gamma(563.0 / 256.0),+ OutputSpace::ProPhoto => OutputTrc::Gamma(1.8),+ OutputSpace::Rec2020 => OutputTrc::Rec709,+ }+ }++ /// User-facing name.+ pub fn label(self) -> &'static str {+ match self {+ OutputSpace::Srgb => "sRGB",+ OutputSpace::DisplayP3 => "Display P3",+ OutputSpace::AdobeRgb => "Adobe RGB (1998) compatible",+ OutputSpace::ProPhoto => "ProPhoto RGB",+ OutputSpace::Rec2020 => "Rec. 2020",+ }+ }++ pub fn parse(s: &str) -> Option<OutputSpace> {+ let k: String = s.chars().filter(|c| c.is_ascii_alphanumeric()).collect::<String>().to_ascii_lowercase();+ Some(match k.as_str() {+ "srgb" => OutputSpace::Srgb,+ "displayp3" | "p3" => OutputSpace::DisplayP3,+ "adobergb" | "adobergb1998" | "adobergb1998compatible" | "widegamutrgb" => OutputSpace::AdobeRgb,+ "prophoto" | "prophotorgb" | "rommrgb" => OutputSpace::ProPhoto,+ "rec2020" | "bt2020" | "itur2020" => OutputSpace::Rec2020,+ _ => return None,+ })+ }++ /// Linear Rec.2020 → linear target RGB (Bradford-adapted for D50 targets), row-major.+ pub fn from_working(self) -> [[f32; 3]; 3] {+ REC2020.to_space(&self.rgb_space()).to_f32()+ }++ /// Luminance weights of the target's linear RGB, as the gamut mapper uses them. sRGB keeps the+ /// rounded BT.709 weights the pipeline has always used (byte-identical previews and exports).+ pub fn luma(self) -> [f32; 3] {+ match self {+ OutputSpace::Srgb => [0.2126, 0.7152, 0.0722],+ o => o.rgb_space().luma().map(|v| v as f32),+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn trcs_invert() {+ for o in OutputSpace::ALL {+ let t = o.trc();+ for i in 0..=100 {+ let x = i as f32 / 100.0;+ assert!((t.decode(t.encode(x)) - x).abs() < 1e-5, "{o:?} {x}");+ }+ }+ }++ #[test]+ fn parse_and_serde_names() {+ for o in OutputSpace::ALL {+ let s = serde_json::to_value(o).unwrap();+ assert_eq!(OutputSpace::parse(s.as_str().unwrap()), Some(o));+ assert_eq!(OutputSpace::parse(o.label()), Some(o), "{}", o.label());+ }+ }++ #[test]+ fn white_maps_to_white() {+ for o in OutputSpace::ALL {+ let m = o.from_working();+ for row in m {+ assert!((row.iter().sum::<f32>() - 1.0).abs() < 1e-4, "{o:?}");+ }+ assert!((o.luma().iter().sum::<f32>() - 1.0).abs() < 1e-4);+ }+ }+}diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rsindex 0ac333088..ac684fc73 100644--- a/crates/ui-egui/src/panels/dialogs.rs+++ b/crates/ui-egui/src/panels/dialogs.rs@@ -109,6 +109,24 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {&[(F::Jpeg, "JPEG"), (F::Png, "PNG"), (F::Tiff, "TIFF"), (F::Webp, "WebP"), (F::Avif, "AVIF")],&mut opts.format,);+ if opts.format == F::Avif {+ ui.label(egui::RichText::new("Color space: sRGB (AVIF)").color(t.text_dim));+ } else {+ use lightcraft_engine::export::OutputSpace as C;+ choices(+ ui,+ "Color space",+ "exportColorSpace",+ &[+ (C::Srgb, "sRGB"),+ (C::DisplayP3, "P3"),+ (C::AdobeRgb, "Adobe RGB"),+ (C::ProPhoto, "ProPhoto"),+ (C::Rec2020, "Rec.2020"),+ ],+ &mut opts.color_space,+ );+ }if matches!(opts.format, F::Jpeg | F::Avif) {let mut q = opts.quality as f64;if num(ui, &QUALITY, &mut q) {@@ -292,6 +310,7 @@ pub fn confirm_dialog(app: &mut LightcraftApp, dlg: &Dialog) -> Result<serde_jso"format": opts.format, "quality": opts.quality, "longEdge": long_edge, "limitKb": limit_kb,"sharpen": opts.sharpen, "sharpenAmount": opts.sharpen_amount, "naming": opts.naming, "dir": dir,"metadata": opts.metadata, "removeLocation": opts.remove_location, "watermark": opts.watermark,+ "colorSpace": opts.color_space,}),),Dialog::Merge { opts } => crate::merge::start_final(app, opts),diff --git a/docs/mcp.md b/docs/mcp.mdindex 02bdcb09b..8beaa8321 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -85,7 +85,7 @@ During development you can also point the client at `cargo run --release -p ligh| `apply_preset {preset, amount?, ids?}` | Apply a preset (ids from `cmd_presets_list`) || `crop {id?, rect?, angle?, reset?}` | Normalized crop rect `[x0,y0,x1,y1]` and straighten angle || `render_photo {id?, size?, format?, path?}` | Render with current settings → **image content** (PNG, or JPEG with `format: "jpeg"`), long edge `size` (default 1024) |-| `export {path, id?, longEdge?, quality?}` | Full-quality render to `.png` / `.jpg` / `.tif` / `.webp` (headless; the desktop app writes PNG) |+| `export {path, id?, longEdge?, quality?, colorSpace?}` | Full-quality render to `.png` / `.jpg` / `.tif` / `.webp` (headless; the desktop app writes PNG) |Tools taking `id` make that photo active first; without it they act on the active photo.diff --git a/docs/parity.md b/docs/parity.mdindex 19d1af2d2..f8e1321cb 100644--- a/docs/parity.md+++ b/docs/parity.md@@ -55,41 +55,39 @@ and prints the summary; `cargo xtask parity --write` refreshes the summary tableOrdered by tier, then user value, then (low) effort. Take the first one nobody is working on.-1. **LR-EXP-COLORSPACE** (P0) — export is sRGB only. Add Display P3 / Adobe RGB-compatible / ProPhoto-compatible /- Rec.2020 output (our own primaries + ICC from `crates/codecs/src/icc.rs`). High value, low–medium effort.-2. **LR-EXP-PREVIOUS + LR-EXP-DIALOG presets** (P0) — remember the last export settings (⌘E "export with previous")+1. **LR-EXP-PREVIOUS + LR-EXP-DIALOG presets** (P0) — remember the last export settings (⌘E "export with previous")and offer built-in export presets (small JPEG, full JPEG, TIFF). Medium value, low effort.-3. **LR-LIB-SHOWFINDER** (P0) — reveal the original in Finder/Explorer/file manager. Medium value, low effort.-4. **LR-EDIT-EFFECTS-VIGNETTE** (P0) — the vignette style (highlight priority / colour priority / paint overlay) is+2. **LR-LIB-SHOWFINDER** (P0) — reveal the original in Finder/Explorer/file manager. Medium value, low effort.+3. **LR-EDIT-EFFECTS-VIGNETTE** (P0) — the vignette style (highlight priority / colour priority / paint overlay) isrendered but has no UI. Low effort.-5. **LR-VIEW-BEFOREAFTER** (P0) — add top/bottom and split top/bottom layouts (⌥Y). Low effort.-6. **LR-MASK-OVERLAY + LR-MASK-PINS** (P0/P1) — show the evaluated mask alpha as a coloured overlay (all mask+4. **LR-VIEW-BEFOREAFTER** (P0) — add top/bottom and split top/bottom layouts (⌥Y). Low effort.+5. **LR-MASK-OVERLAY + LR-MASK-PINS** (P0/P1) — show the evaluated mask alpha as a coloured overlay (all maskkinds, colour/opacity choice), not just brush dabs and outlines. High value, medium effort.-7. **LR-MASK-BRUSH + LR-MASK-SLIDERS** (P0) — apply the stored Auto Mask flag (edge-aware brush) and the local+6. **LR-MASK-BRUSH + LR-MASK-SLIDERS** (P0) — apply the stored Auto Mask flag (edge-aware brush) and the localNoise / Moiré / Defringe sliders, which are stored but not rendered. High value, medium effort.-8. **LR-REM-SPOT-EDIT + LR-REM-BRUSH-PARAMS** (P0) — select a spot pin, move target/source, delete with ⌫,+7. **LR-REM-SPOT-EDIT + LR-REM-BRUSH-PARAMS** (P0) — select a spot pin, move target/source, delete with ⌫,feather/opacity sliders, `[`/`]` size keys. Medium effort.-9. **LR-VIEW-PHOTOGRID** (P0) — group the justified grid by capture date with headers. Low–medium effort.-10. **LR-CROP-STRAIGHTEN** (P0) — draw-along-the-horizon straighten tool (+ double-click auto). Low effort.-11. **LR-PRE-CREATE + LR-PRE-PANEL + LR-BEHAV-PREVIEW-HOVER** (P0/P1) — per-group checkboxes in Create Preset;+8. **LR-VIEW-PHOTOGRID** (P0) — group the justified grid by capture date with headers. Low–medium effort.+9. **LR-CROP-STRAIGHTEN** (P0) — draw-along-the-horizon straighten tool (+ double-click auto). Low effort.+10. **LR-PRE-CREATE + LR-PRE-PANEL + LR-BEHAV-PREVIEW-HOVER** (P0/P1) — per-group checkboxes in Create Preset;live preview while hovering presets/profiles/versions. Medium effort.-12. **LR-PROF-DROPDOWN** (P0) — favourites/recent in the profile menu (and later a browser, LR-PROF-BROWSER).-13. **LR-LIB-KEYWORD** (P0) — rename/delete a keyword library-wide; keyword list in the left panel for browsing.-14. **LR-PREF-GENERAL + LR-IMP-RAWDEFAULT** (P0/P1) — a Settings dialog: raw defaults (preset or camera-specific),+11. **LR-PROF-DROPDOWN** (P0) — favourites/recent in the profile menu (and later a browser, LR-PROF-BROWSER).+12. **LR-LIB-KEYWORD** (P0) — rename/delete a keyword library-wide; keyword list in the left panel for browsing.+13. **LR-PREF-GENERAL + LR-IMP-RAWDEFAULT** (P0/P1) — a Settings dialog: raw defaults (preset or camera-specific),XMP prefs, cache, GPU. Medium effort.-15. **LR-IMP-ADD-DIALOG + LR-IMP-LOCAL** (P0) — an import review grid with per-photo checkboxes and destination+14. **LR-IMP-ADD-DIALOG + LR-IMP-LOCAL** (P0) — an import review grid with per-photo checkboxes and destinationalbum; browse folders before adding. Medium effort.-16. **LR-EXP-TYPE + LR-EXP-DIM** (P0) — Original (+XMP) and DNG export (writer exists in+15. **LR-EXP-TYPE + LR-EXP-DIM** (P0) — Original (+XMP) and DNG export (writer exists in`crates/raw/src/dngwrite.rs`), short edge / width / height / megapixels, "don't enlarge", ppi.-17. **LR-IMP-FORMATS** (P0) — CR3, compressed NEF/RAF/ORF, RW2 v4 (preview only today); HEIC/AVIF decode (no+16. **LR-IMP-FORMATS** (P0) — CR3, compressed NEF/RAF/ORF, RW2 v4 (preview only today); HEIC/AVIF decode (nopermissive pure-Rust decoder yet). High value, high effort (clean sources needed).-18. **LR-VIEW-FULLSCREEN + LR-VIEW-NAVIGATOR + LR-VIEW-INFOOVERLAY** (P1) — view modes. Medium effort.-19. **LR-LIB-RENAME + LR-LIB-CAPTURETIME + LR-LIB-LABEL UI** (P1) — batch rename, capture-time edit, label menu/names.-20. **LR-EYE-RED** (P1) — red-eye correction (panel placeholder exists; no render).-21. **LR-EDIT-COLOR-POINTCOLOR, LR-EDIT-CALIB, LR-EDIT-LIGHT-CURVE-TAT, LR-EDIT-LIGHT-CURVE-REFINESAT** (P1) —+17. **LR-VIEW-FULLSCREEN + LR-VIEW-NAVIGATOR + LR-VIEW-INFOOVERLAY** (P1) — view modes. Medium effort.+18. **LR-LIB-RENAME + LR-LIB-CAPTURETIME + LR-LIB-LABEL UI** (P1) — batch rename, capture-time edit, label menu/names.+19. **LR-EYE-RED** (P1) — red-eye correction (panel placeholder exists; no render).+20. **LR-EDIT-COLOR-POINTCOLOR, LR-EDIT-CALIB, LR-EDIT-LIGHT-CURVE-TAT, LR-EDIT-LIGHT-CURVE-REFINESAT** (P1) —missing develop controls (calibration matters for XMP interop).-22. **LR-EXP-BITDEPTH + LR-EXP-COMPRESSION** (P1) — 16-bit TIFF/PNG and TIFF compression choice.-23. **LR-EDIT-OPTICS-PROFILE** (P1) — a lens-profile database of our own (embedded DNG/maker corrections work today).+21. **LR-EXP-BITDEPTH + LR-EXP-COMPRESSION** (P1) — 16-bit TIFF/PNG and TIFF compression choice.+22. **LR-EDIT-OPTICS-PROFILE** (P1) — a lens-profile database of our own (embedded DNG/maker corrections work today).## Shortcuts: conflicts and missing bindings@@ -444,7 +442,7 @@ under the UI command that wraps it (a no-op error); the UI command now wins.| LR-EXP-QUALITY | JPEG quality | P0 | ✅ | `cmd:app.export` (`quality`, `limitKb`) | || LR-EXP-BITDEPTH | Bit depth | P1 | ⬜ | | 8-bit only || LR-EXP-COMPRESSION | TIFF compression | P1 | ⬜ | | always Deflate |-| LR-EXP-COLORSPACE | Output colour space | P0 | ⬜ | `crates/engine/src/export.rs` | sRGB only |+| LR-EXP-COLORSPACE | Output colour space | P0 | ✅ | `cmd:app.export` (`colorSpace`), `crates/pipeline/src/output.rs`, `crates/engine/src/export.rs` | sRGB, Display P3, Adobe RGB (1998) compatible, ProPhoto RGB, Rec. 2020: rendered from the working space with gamut mapping into the target gamut (CPU + GPU), own ICC profile embedded; AVIF stays sRGB (muxer has no ICC) || LR-EXP-HDR | HDR output | P2 | ⬜ | | || LR-EXP-SHARPEN | Output sharpening | P1 | ✅ | `cmd:app.export` (`sharpen`, `sharpenAmount`) | || LR-EXP-METADATA | Metadata policy | P1 | ✅ | `cmd:app.export` (`metadata`, `removeLocation`) | |