diff --git a/Cargo.lock b/Cargo.lock index 2a431e3339..0d32cc52e4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1009,15 +1009,6 @@ dependencies = [ "ruzstd", ] -[[package]] -name = "craft-cms" -version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=010702ee9b030844c852939095b1da0d0656a890#010702ee9b030844c852939095b1da0d0656a890" -dependencies = [ - "md-5", - "rayon", -] - [[package]] name = "craft-codepage" version = "0.1.0" @@ -6736,8 +6727,8 @@ dependencies = [ name = "vectorcraft-color" version = "0.24.1" dependencies = [ - "craft-cms", "kurbo 0.13.1", + "moxcms", "proptest", "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index f8e8dc95a3..6d2ab9e37b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,7 +12,6 @@ repository = "https://github.com/storytold/vectorcraft" [workspace.dependencies] craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "64b181977a0488e4d1e167bc5cc8cfededc2ed4b", default-features = false, features = ["interpret", "write"] } -craft-cms = { git = "https://github.com/storytold/craft-libs", rev = "010702ee9b030844c852939095b1da0d0656a890" } craft-print = { git = "https://github.com/storytold/craft-libs", rev = "64b181977a0488e4d1e167bc5cc8cfededc2ed4b" } craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "64b181977a0488e4d1e167bc5cc8cfededc2ed4b" } craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "64b181977a0488e4d1e167bc5cc8cfededc2ed4b", features = ["serde"] } diff --git a/crates/color/Cargo.toml b/crates/color/Cargo.toml index 9c1e7b522c..a007ede39f 100644 --- a/crates/color/Cargo.toml +++ b/crates/color/Cargo.toml @@ -9,11 +9,11 @@ description = "VectorCraft color" workspace = true [dependencies] -craft-cms = { workspace = true } kurbo = { workspace = true } serde = { workspace = true } serde_json = { workspace = true } thiserror = { workspace = true } +moxcms = "0.8" [dev-dependencies] proptest = { workspace = true } diff --git a/crates/color/src/cms/icc.rs b/crates/color/src/cms/icc.rs index a3b87f2fc6..8fc287ae23 100644 --- a/crates/color/src/cms/icc.rs +++ b/crates/color/src/cms/icc.rs @@ -1,23 +1,22 @@ -//! ICC profiles through `craft-cms` (pure Rust): built-in RGB spaces and user-supplied `.icc` -//! files, and the profiles exports embed ([`builtin_rgb_bytes`], [`cmyk_profile`], [`gray_profile`]). +//! ICC profiles through `moxcms` (pure Rust): built-in RGB spaces and user-supplied `.icc` files, +//! and the profiles exports embed ([`encode_builtin`]), written in code from the CMS. use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::{Arc, Mutex, OnceLock}; -use craft_cms::{ - Builtin, Clut, ColorSpace, Curve, Intent as CmsIntent, Pcs, Profile, ProfileClass, Transform, builtin, - pipeline::Stage, - profile::{Lut, LutKind}, +use moxcms::{ + ColorProfile, DataColorSpace, Layout, LocalizableString, LutMultidimensionalType, LutStore, LutWarehouse, Matrix3d, ProfileClass, ProfileText, + RenderingIntent, ToneReprCurve, TransformF32Executor, TransformOptions, Vector3d, }; use super::{CmsError, Intent, ProfileKind, lab, profiles_generation}; -fn cms_intent(i: Intent) -> CmsIntent { +fn moxcms_intent(i: Intent) -> RenderingIntent { match i { - Intent::Perceptual => CmsIntent::Perceptual, - Intent::RelativeColorimetric => CmsIntent::RelativeColorimetric, - Intent::Saturation => CmsIntent::Saturation, - Intent::AbsoluteColorimetric => CmsIntent::AbsoluteColorimetric, + Intent::Perceptual => RenderingIntent::Perceptual, + Intent::RelativeColorimetric => RenderingIntent::RelativeColorimetric, + Intent::Saturation => RenderingIntent::Saturation, + Intent::AbsoluteColorimetric => RenderingIntent::AbsoluteColorimetric, } } @@ -27,12 +26,25 @@ fn intent_index(i: Intent) -> usize { INTENTS.iter().position(|x| *x == i).unwrap_or(1) } -type Xf = Option>; +type Xf = Option>; /// A direct transform's cache key: destination [`IccProfile::id`], [`profiles_generation`] it was -/// built in, intent index, black-point compensation. +/// built in, intent index, black-point compensation. The id tells a reloaded profile from the old +/// one of the same name, which settings built before the reload still convert into; the +/// generation only lets the cache drop what reloads left behind. type DirectKey = (u64, u64, usize, bool); +/// The transforms of [`IccProfile::to_same_model_of`]: into ProPhoto RGB's primaries with linear +/// tone curves, where black-point compensation is a linear remap, and from there into the +/// destination. +struct SameModel { + into: Arc, + out_of: Arc, + /// The source's and the destination's black as luminance in the linear space (both 0 without + /// compensation). + black: [f32; 2], +} + /// A parsed ICC profile plus lazily-built transforms to/from sRGB. pub struct IccProfile { pub name: String, @@ -41,13 +53,28 @@ pub struct IccProfile { pub kind: ProfileKind, /// The file it was loaded from (empty for profiles made in code). source: Vec, - profile: Profile, - srgb: Profile, + profile: ColorProfile, + srgb: ColorProfile, to_srgb: [OnceLock; 4], from_srgb: [OnceLock; 4], - /// Direct transforms into other profiles ([`Self::to_rgb_of`], [`Self::to_same_model_of`]), - /// by destination, intent and black-point compensation. - direct: Mutex>, + /// Direct transforms into other RGB profiles ([`Self::to_rgb_of`]), by destination, intent + /// and black-point compensation. + direct: Mutex>)>>, + /// Transforms into other profiles of the same model ([`Self::to_same_model_of`]), keyed as + /// [`Self::direct`] is. + same_model: Mutex>)>>, +} + +/// A transform from one profile into an RGB profile without passing through sRGB: into the +/// destination's primaries with linear tone curves, where black-point compensation is a linear +/// remap, then onto its own curves. +struct Direct { + to_linear: Arc, + /// Linear → the destination's curves; `None` when the destination isn't a matrix profile + /// (the first transform goes straight into it, without compensation). + to_dest: Option>, + /// The source black's luminance in the linear destination (0: no compensation). + black: f32, } impl std::fmt::Debug for IccProfile { @@ -56,16 +83,25 @@ impl std::fmt::Debug for IccProfile { } } +fn text(t: &Option) -> Option { + match t.as_ref()? { + ProfileText::PlainString(s) => Some(s.clone()), + ProfileText::Localizable(v) => v.iter().find(|l| l.language == "en").or(v.first()).map(|l| l.value.clone()), + ProfileText::Description(d) => Some(if d.ascii_string.is_empty() { d.unicode_string.clone() } else { d.ascii_string.clone() }), + } + .map(|s| s.trim_matches(char::from(0)).trim().to_string()) + .filter(|s| !s.is_empty()) +} + impl IccProfile { - pub fn from_profile(name: Option, profile: Profile) -> Result { + pub fn from_profile(name: Option, profile: ColorProfile) -> Result { let kind = match profile.color_space { - ColorSpace::Rgb => ProfileKind::Rgb, - ColorSpace::Cmyk => ProfileKind::Cmyk, - ColorSpace::Gray => ProfileKind::Gray, + DataColorSpace::Rgb => ProfileKind::Rgb, + DataColorSpace::Cmyk => ProfileKind::Cmyk, + DataColorSpace::Gray => ProfileKind::Gray, other => return Err(CmsError::Unsupported(format!("profile colour space {other:?} is not RGB, CMYK or Gray"))), }; - let desc = profile.description.trim_matches(char::from(0)).trim(); - let name = name.or_else(|| (!desc.is_empty()).then(|| desc.to_string())).unwrap_or_else(|| format!("Untitled {kind:?} profile")); + let name = name.or_else(|| text(&profile.description)).unwrap_or_else(|| format!("Untitled {kind:?} profile")); static NEXT_ID: AtomicU64 = AtomicU64::new(0); Ok(Self { name, @@ -73,10 +109,11 @@ impl IccProfile { kind, source: Vec::new(), profile, - srgb: builtin::srgb().clone(), + srgb: ColorProfile::new_srgb(), to_srgb: Default::default(), from_srgb: Default::default(), direct: Mutex::new(Vec::new()), + same_model: Mutex::new(Vec::new()), }) } @@ -90,7 +127,7 @@ impl IccProfile { String::from_utf8_lossy(&tag.to_be_bytes()) ))); } - let p = Profile::parse(bytes).map_err(|e| CmsError::BadProfile(format!("{e:?}")))?; + let p = ColorProfile::new_from_slice(bytes).map_err(|e| CmsError::BadProfile(format!("{e:?}")))?; Ok(Self { source: bytes.to_vec(), ..Self::from_profile(name, p)? }) } @@ -99,6 +136,14 @@ impl IccProfile { if self.source.is_empty() { encode(&self.profile) } else { Ok(self.source.clone()) } } + fn layout(&self) -> Layout { + match self.kind { + ProfileKind::Cmyk => Layout::Rgba, // 4 channels + ProfileKind::Gray => Layout::Gray, + ProfileKind::Rgb => Layout::Rgb, + } + } + fn channels(&self) -> usize { match self.kind { ProfileKind::Cmyk => 4, @@ -107,15 +152,19 @@ impl IccProfile { } } + fn opts(intent: Intent) -> TransformOptions { + TransformOptions { rendering_intent: moxcms_intent(intent), ..Default::default() } + } + fn to_xf(&self, intent: Intent) -> Xf { self.to_srgb[intent_index(intent)] - .get_or_init(|| Transform::new(&self.profile, &self.srgb, cms_intent(intent), false).ok().map(Arc::new)) + .get_or_init(|| self.profile.create_transform_f32(self.layout(), &self.srgb, Layout::Rgb, Self::opts(intent)).ok()) .clone() } fn inverse_xf(&self, intent: Intent) -> Xf { self.from_srgb[intent_index(intent)] - .get_or_init(|| Transform::new(&self.srgb, &self.profile, cms_intent(intent), false).ok().map(Arc::new)) + .get_or_init(|| self.srgb.create_transform_f32(Layout::Rgb, &self.profile, self.layout(), Self::opts(intent)).ok()) .clone() } @@ -134,7 +183,7 @@ impl IccProfile { } let xf = self.to_xf(intent)?; let mut dst = [0.0f32; 3]; - xf.eval_fast(v, &mut dst).ok()?; + xf.transform(v, &mut dst).ok()?; Some(dst.map(|x| x.clamp(0.0, 1.0))) } @@ -148,7 +197,7 @@ impl IccProfile { return None; } let xf = self.to_xf(intent)?; - xf.convert_f32(v, n, dst, 3, false).ok()?; + xf.transform(v, dst).ok()?; dst.iter_mut().for_each(|x| *x = x.clamp(0.0, 1.0)); Some(()) } @@ -157,53 +206,142 @@ impl IccProfile { pub fn from_srgb(&self, rgb: [f32; 3], intent: Intent) -> Option> { let xf = self.inverse_xf(intent)?; let mut dst = vec![0.0f32; self.channels()]; - xf.eval_fast(&rgb, &mut dst).ok()?; + xf.transform(&rgb, &mut dst).ok()?; Some(dst.into_iter().map(|x| x.clamp(0.0, 1.0)).collect()) } - fn direct_xf(&self, dest: &IccProfile, intent: Intent, bpc: bool) -> Xf { - let generation = profiles_generation(); - let key = (dest.id, generation, intent_index(intent), bpc); - let mut cache = self.direct.lock().unwrap_or_else(|e| e.into_inner()); - cache.retain(|(k, _)| k.1 == generation); - if let Some((_, t)) = cache.iter().find(|(k, _)| *k == key) { - return t.clone(); - } - let t = Transform::new(&self.profile, &dest.profile, cms_intent(intent), bpc).ok().map(Arc::new); - cache.push((key, t.clone())); - t - } - /// Device values (RGB / CMYK / Gray, 0..1) → `dest`'s RGB, converted directly with `intent`: /// not through sRGB, so colours outside sRGB keep their place in a wider space. With `bpc` /// (and an intent other than absolute), this profile's black maps onto the destination's - /// black (black-point compensation). `None` when `dest` isn't RGB or no transform can be built. + /// black (black-point compensation, the darkest ink the profile prints becoming RGB 0 rather + /// than a dark grey). `None` when `dest` isn't RGB or no transform can be built. pub fn to_rgb_of(&self, dest: &IccProfile, v: &[f32], intent: Intent, bpc: bool) -> Option<[f32; 3]> { - if dest.kind != ProfileKind::Rgb { - return None; - } - let xf = self.direct_xf(dest, intent, bpc && intent != Intent::AbsoluteColorimetric)?; + let t = self.direct_xf(dest, intent, bpc && intent != Intent::AbsoluteColorimetric)?; let mut src = v.to_vec(); src.resize(self.channels(), 0.0); + let mut lin = [0.0f32; 3]; + t.to_linear.transform(&src, &mut lin).ok()?; + let Some(to_dest) = &t.to_dest else { return Some(lin.map(|x| x.clamp(0.0, 1.0))) }; + if t.black > 0.0 { + lin = lin.map(|x| (x - t.black) / (1.0 - t.black)); + } + let lin = lin.map(|x| x.clamp(0.0, 1.0)); let mut out = [0.0f32; 3]; - xf.eval_fast(&src, &mut out).ok()?; + to_dest.transform(&lin, &mut out).ok()?; Some(out.map(|x| x.clamp(0.0, 1.0))) } + fn direct_xf(&self, dest: &IccProfile, intent: Intent, bpc: bool) -> Option> { + if dest.kind != ProfileKind::Rgb { + return None; + } + let generation = profiles_generation(); + let key = (dest.id, generation, intent_index(intent), bpc); + let mut cache = self.direct.lock().unwrap_or_else(|e| e.into_inner()); + // an older generation's entries can't match again: drop them so reloads don't pile up + cache.retain(|(k, _)| k.1 == generation); + if let Some((_, t)) = cache.iter().find(|(k, _)| *k == key) { + return t.clone(); + } + let t = self.build_direct(dest, intent, bpc).map(Arc::new); + cache.push((key, t.clone())); + t + } + + fn build_direct(&self, dest: &IccProfile, intent: Intent, bpc: bool) -> Option { + let d = &dest.profile; + let matrix = d.red_trc.is_some() && d.green_trc.is_some() && d.blue_trc.is_some(); + if !matrix { + let xf = self.profile.create_transform_f32(self.layout(), d, Layout::Rgb, Self::opts(intent)).ok()?; + return Some(Direct { to_linear: xf, to_dest: None, black: 0.0 }); + } + let mut linear = d.clone(); + for trc in [&mut linear.red_trc, &mut linear.green_trc, &mut linear.blue_trc] { + *trc = Some(ToneReprCurve::Parametric(vec![1.0])); + } + // A coding-independent code point names the transfer curve outright (moxcms's sRGB has + // one) and would override the linear curves. + linear.cicp = None; + let to_linear = self.profile.create_transform_f32(self.layout(), &linear, Layout::Rgb, Self::opts(intent)).ok()?; + let to_dest = linear.create_transform_f32(Layout::Rgb, d, Layout::Rgb, Self::opts(Intent::RelativeColorimetric)).ok()?; + // The source black: the darkest colour the profile reproduces, found as lcms does for an + // output profile (black sent into the profile and read back), made neutral. + let black = if bpc && self.kind == ProfileKind::Cmyk { + let inks = self.from_srgb([0.0; 3], Intent::RelativeColorimetric)?; + let mut lin = [0.0f32; 3]; + to_linear.transform(&inks, &mut lin).ok()?; + let y = |c: &moxcms::Xyzd| c.y as f32; + let lum = lin[0] * y(&d.red_colorant) + lin[1] * y(&d.green_colorant) + lin[2] * y(&d.blue_colorant); + lum.clamp(0.0, 0.5) + } else { + 0.0 + }; + Some(Direct { to_linear, to_dest: Some(to_dest), black }) + } + /// Device values of this profile → device values of `dest`, a profile of the same model, - /// converted with `intent` directly. With `bpc` (and an intent other than absolute), this - /// profile's black maps onto the destination's black. `None` when `dest` is of another model or - /// no transform can be built. + /// converted with `intent` through ProPhoto RGB rather than sRGB, so colours outside sRGB + /// keep their place. With `bpc` (and an intent other than absolute), this profile's black + /// maps onto the destination's black (black-point compensation). `None` when `dest` is of + /// another model or no transform can be built. pub fn to_same_model_of(&self, dest: &IccProfile, v: &[f32], intent: Intent, bpc: bool) -> Option> { if dest.kind != self.kind || v.len() != self.channels() { return None; } - let xf = self.direct_xf(dest, intent, bpc && intent != Intent::AbsoluteColorimetric)?; + let bpc = bpc && intent != Intent::AbsoluteColorimetric; + let generation = profiles_generation(); + let key = (dest.id, generation, intent_index(intent), bpc); + let t = { + let mut cache = self.same_model.lock().unwrap_or_else(|e| e.into_inner()); + cache.retain(|(k, _)| k.1 == generation); + match cache.iter().find(|(k, _)| *k == key) { + Some((_, t)) => t.clone(), + None => { + let t = self.build_same_model(dest, intent, bpc).map(Arc::new); + cache.push((key, t.clone())); + t + } + } + }?; + let mut lin = [0.0f32; 3]; + t.into.transform(v, &mut lin).ok()?; + let [from, to] = t.black; + if from > 0.0 || to > 0.0 { + lin = lin.map(|x| to + (x - from) * (1.0 - to) / (1.0 - from)); + } + let lin = lin.map(|x| x.clamp(0.0, 1.0)); let mut out = vec![0.0f32; dest.channels()]; - xf.eval_fast(v, &mut out).ok()?; + t.out_of.transform(&lin, &mut out).ok()?; Some(out.into_iter().map(|x| x.clamp(0.0, 1.0)).collect()) } + fn build_same_model(&self, dest: &IccProfile, intent: Intent, bpc: bool) -> Option { + let mut linear = rgb_space(super::PROPHOTO_RGB)?; + for trc in [&mut linear.red_trc, &mut linear.green_trc, &mut linear.blue_trc] { + *trc = Some(ToneReprCurve::Parametric(vec![1.0])); + } + linear.cicp = None; + let into = self.profile.create_transform_f32(self.layout(), &linear, Layout::Rgb, Self::opts(intent)).ok()?; + let out_of = linear.create_transform_f32(Layout::Rgb, &dest.profile, dest.layout(), Self::opts(intent)).ok()?; + let black = if bpc { + // Each profile's black: the darkest colour it reproduces, found as `build_direct` + // finds it, as luminance in the linear space. + let luminance = |p: &IccProfile, xf: &Arc| -> Option { + let inks = p.from_srgb([0.0; 3], Intent::RelativeColorimetric)?; + let mut lin = [0.0f32; 3]; + xf.transform(&inks, &mut lin).ok()?; + let y = |c: &moxcms::Xyzd| c.y as f32; + let lum = lin[0] * y(&linear.red_colorant) + lin[1] * y(&linear.green_colorant) + lin[2] * y(&linear.blue_colorant); + Some(lum.clamp(0.0, 0.5)) + }; + let back = dest.profile.create_transform_f32(dest.layout(), &linear, Layout::Rgb, Self::opts(intent)).ok()?; + [luminance(self, &into)?, luminance(dest, &back)?] + } else { + [0.0; 2] + }; + Some(SameModel { into, out_of, black }) + } + /// Whether transforms can be built for this profile (checked at registration). pub fn usable(&self) -> bool { self.to_xf(Intent::RelativeColorimetric).is_some() && self.inverse_xf(Intent::RelativeColorimetric).is_some() @@ -211,17 +349,17 @@ impl IccProfile { } /// The primaries and tone curves of built-in RGB space `name`. -fn rgb_space(name: &str) -> Option { +fn rgb_space(name: &str) -> Option { Some(match name { - super::WIDE_GAMUT_RGB => Builtin::AdobeRgbCompat.profile().clone(), - super::DISPLAY_P3 => Builtin::DisplayP3.profile().clone(), - super::PROPHOTO_RGB => Builtin::ProPhotoCompat.profile().clone(), - super::SRGB => Builtin::Srgb.profile().clone(), + super::WIDE_GAMUT_RGB => ColorProfile::new_adobe_rgb(), + super::DISPLAY_P3 => ColorProfile::new_display_p3(), + super::PROPHOTO_RGB => ColorProfile::new_pro_photo_rgb(), + super::SRGB => ColorProfile::new_srgb(), _ => return None, }) } -/// Built-in RGB working spaces from `craft-cms`'s standard primaries. +/// Built-in RGB working spaces from `moxcms`'s standard primaries. pub fn builtin_rgb(name: &str) -> Option { IccProfile::from_profile(Some(name.to_string()), rgb_space(name)?).ok() } @@ -232,8 +370,8 @@ pub(super) fn builtin_rgb_bytes(name: &str) -> Result, CmsError> { } /// Encode `p` as an ICC file. The creation date is fixed so exports are reproducible. -pub(super) fn encode(p: &Profile) -> Result, CmsError> { - let mut bytes = p.to_bytes().as_ref().clone(); +pub(super) fn encode(p: &ColorProfile) -> Result, CmsError> { + let mut bytes = aligned(p.encode().map_err(|e| CmsError::BadProfile(format!("{e:?}")))?); // Header bytes 24..36: year, month, day, hours, minutes, seconds (u16 each). if let Some(date) = bytes.get_mut(24..36) { date.copy_from_slice(&[2026u16, 1, 1, 0, 0, 0].map(u16::to_be_bytes).concat()); @@ -241,10 +379,63 @@ pub(super) fn encode(p: &Profile) -> Result, CmsError> { Ok(bytes) } +/// `icc` with every tagged element starting on a 4-byte boundary, padded with zeros, as ICC.1 +/// §7.1.2 requires (moxcms packs them, so a 62-byte `desc` left the next tag unaligned, #1584). +/// Tags that share data keep sharing it. A profile whose tag table doesn't read is returned as it is. +fn aligned(icc: Vec) -> Vec { + const TABLE: usize = 128; + let be = |b: &[u8], at: usize| b.get(at..at + 4).map(|v| u32::from_be_bytes([v[0], v[1], v[2], v[3]]) as usize); + let Some(n) = be(&icc, TABLE).filter(|n| *n <= 1000) else { return icc }; + let data_start = TABLE + 4 + 12 * n; + let mut entries = Vec::with_capacity(n); + for i in 0..n { + let e = TABLE + 4 + 12 * i; + let (Some(off), Some(size)) = (be(&icc, e + 4), be(&icc, e + 8)) else { return icc }; + if off < data_start || off.checked_add(size).is_none_or(|end| end > icc.len()) { + return icc; + } + entries.push((off, size)); + } + if entries.iter().all(|(off, _)| off.is_multiple_of(4)) && icc.len().is_multiple_of(4) { + return icc; + } + let mut out = icc.get(..data_start).map(<[u8]>::to_vec).unwrap_or_default(); + let mut moved: Vec<((usize, usize), usize)> = Vec::new(); + let mut order: Vec = (0..n).collect(); + order.sort_by_key(|&i| entries[i].0); + for i in order { + let (off, size) = entries[i]; + let at = match moved.iter().find(|(k, _)| *k == (off, size)) { + Some((_, at)) => *at, + None => { + out.resize(out.len().next_multiple_of(4), 0); + let at = out.len(); + out.extend_from_slice(&icc[off..off + size]); + moved.push(((off, size), at)); + at + } + }; + let e = TABLE + 4 + 12 * i + 4; + out[e..e + 4].copy_from_slice(&(at as u32).to_be_bytes()); + } + out.resize(out.len().next_multiple_of(4), 0); + let len = out.len() as u32; + out[0..4].copy_from_slice(&len.to_be_bytes()); + // The profile ID (an MD5 of the old bytes) no longer matches: zero is "not computed". + if let Some(id) = out.get_mut(84..100) { + id.fill(0); + } + out +} + +fn text_tag(s: &str) -> Option { + Some(ProfileText::Localizable(vec![LocalizableString::new("en".into(), "US".into(), s.into())])) +} + /// Profiles made here carry their name and no copyright claim. -fn labelled(mut p: Profile, name: &str) -> Profile { - p.description = name.to_string(); - p.copyright = "No copyright, use freely".to_string(); +fn labelled(mut p: ColorProfile, name: &str) -> ColorProfile { + p.description = text_tag(name); + p.copyright = text_tag("No copyright, use freely"); p } @@ -258,67 +449,91 @@ const GAMUT_GRID: usize = 9; /// 9⁴ table, and Lab → CMYK in 17³ tables, Lab PCS (ICC v4 encoding): `mapped` (gamut-mapped, /// with black-point compensation) for the perceptual and saturation intents, `colorimetric` (the /// colorimetric inverse of `to_lab`) for the colorimetric intents and the gamut tag. +/// It carries every tag ICC.1 requires of an output profile: the tables for all three intents +/// and the gamut tag (Windows rejects a CMYK profile without them, so Photos couldn't show a CMYK +/// TIFF that embedded one, #2707). The media white point is `paper` (absolute XYZ, D50), which +/// the ICC-absolute colorimetric intent reproduces. pub(super) fn cmyk_profile( name: &str, paper: [f32; 3], to_lab: impl Fn([f32; 4]) -> lab::Lab, mapped: impl Fn(lab::Lab) -> [f32; 4], colorimetric: impl Fn(lab::Lab) -> [f32; 4], -) -> Profile { +) -> ColorProfile { let unit = |i: usize, n: usize| i as f32 / (n - 1) as f32; - let mut a2b_clut = Vec::with_capacity(A2B_GRID.pow(4) * 3); + let q = |v: f32| (v.clamp(0.0, 1.0) * 65535.0).round() as u16; + let mut a2b = Vec::with_capacity(A2B_GRID.pow(4) * 3); for i in 0..A2B_GRID.pow(4) { let cmyk = [3, 2, 1, 0].map(|d| unit(i / A2B_GRID.pow(d) % A2B_GRID, A2B_GRID)); let l = to_lab(cmyk); - a2b_clut.extend([l.l / 100.0, (l.a + 128.0) / 255.0, (l.b + 128.0) / 255.0]); + a2b.extend([l.l / 100.0, (l.a + 128.0) / 255.0, (l.b + 128.0) / 255.0].map(q)); } let b2a_of = |from_lab: &dyn Fn(lab::Lab) -> [f32; 4]| { - let mut clut = Vec::with_capacity(B2A_GRID.pow(3) * 4); + let mut b2a = Vec::with_capacity(B2A_GRID.pow(3) * 4); for i in 0..B2A_GRID.pow(3) { let [l, a, b] = [2, 1, 0].map(|d| unit(i / B2A_GRID.pow(d) % B2A_GRID, B2A_GRID)); - clut.extend(from_lab(lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0))); + b2a.extend(from_lab(lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0)).map(q)); } - clut + b2a }; - let (b2a_mapped_clut, b2a_clut) = (b2a_of(&mapped), b2a_of(&colorimetric)); - let mut gamut_clut = Vec::with_capacity(GAMUT_GRID.pow(3)); + let (b2a_mapped, b2a) = (b2a_of(&mapped), b2a_of(&colorimetric)); + // Gamut: 0 where a colour separates and comes back within a ΔE of 3, else out of gamut. + let mut gamut = Vec::with_capacity(GAMUT_GRID.pow(3)); for i in 0..GAMUT_GRID.pow(3) { let [l, a, b] = [2, 1, 0].map(|d| unit(i / GAMUT_GRID.pow(d) % GAMUT_GRID, GAMUT_GRID)); let want = lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0); - gamut_clut.push(if lab::delta_e2000(want, to_lab(colorimetric(want))) <= 3.0 { 0.0 } else { 1.0 }); + gamut.push(if lab::delta_e2000(want, to_lab(colorimetric(want))) <= 3.0 { 0 } else { u16::MAX }); } - let table = |inputs: usize, outputs: usize, grid: usize, clut: Vec| Lut { - kind: LutKind::Ab, - inputs, - outputs, - stages: vec![Stage::Clut(Clut::new(vec![grid; inputs], outputs, clut).expect("valid CLUT dimensions"))], + let identity = |n: usize| vec![ToneReprCurve::Parametric(vec![1.0]); n]; + let table = |inputs: usize, outputs: usize, grid: usize, clut: Vec| { + let mut grid_points = [0u8; 16]; + grid_points[..inputs].fill(grid as u8); + LutWarehouse::Multidimensional(LutMultidimensionalType { + num_input_channels: inputs as u8, + num_output_channels: outputs as u8, + grid_points, + clut: Some(LutStore::Store16(clut)), + // A curves sit on the device side (the gamut tag's is its one output), B curves on the + // PCS side. + a_curves: identity(inputs + outputs - 3), + b_curves: identity(3), + m_curves: vec![], + matrix: Matrix3d::IDENTITY, + bias: Vector3d::default(), + }) }; - let a2b = table(4, 3, A2B_GRID, a2b_clut); - let b2a_mapped = table(3, 4, B2A_GRID, b2a_mapped_clut); - let b2a = table(3, 4, B2A_GRID, b2a_clut); - let _gamut = table(3, 1, GAMUT_GRID, gamut_clut); - let mut p = Profile::gray([f64::from(paper[0]), f64::from(paper[1]), f64::from(paper[2])], Curve::Gamma(1.0)) - .unwrap_or_else(|_| Builtin::Srgb.profile().clone()); - p.class = ProfileClass::Output; - p.color_space = ColorSpace::Cmyk; - p.pcs = Pcs::Lab; - p.rendering_intent = CmsIntent::RelativeColorimetric; - p.white_point = [f64::from(paper[0]), f64::from(paper[1]), f64::from(paper[2])]; - p.matrix = None; - p.trc = None; - p.gray_trc = None; - p.a2b = [Some(a2b.clone()), Some(a2b.clone()), Some(a2b)]; - p.b2a = [Some(b2a_mapped.clone()), Some(b2a), Some(b2a_mapped)]; + let a2b = table(4, 3, A2B_GRID, a2b); + let b2a_mapped = table(3, 4, B2A_GRID, b2a_mapped); + let b2a = table(3, 4, B2A_GRID, b2a); + let gamut = table(3, 1, GAMUT_GRID, gamut); + let mut p = ColorProfile::default(); + p.profile_class = ProfileClass::OutputDevice; + p.color_space = DataColorSpace::Cmyk; + p.pcs = DataColorSpace::Lab; + p.rendering_intent = RenderingIntent::RelativeColorimetric; + p.white_point = moxcms::WHITE_POINT_D50.to_xyzd(); + p.media_white_point = Some(moxcms::Xyzd::new(f64::from(paper[0]), f64::from(paper[1]), f64::from(paper[2]))); + p.lut_a_to_b_perceptual = Some(a2b.clone()); + p.lut_a_to_b_saturation = Some(a2b.clone()); + p.lut_a_to_b_colorimetric = Some(a2b); + p.lut_b_to_a_perceptual = Some(b2a_mapped.clone()); + p.lut_b_to_a_saturation = Some(b2a_mapped); + p.lut_b_to_a_colorimetric = Some(b2a); + p.gamut = Some(gamut); labelled(p, name) } /// The grey space of greyscale exports: sRGB's tone curve, D50 white. -pub(super) fn gray_profile(name: &str) -> Profile { - labelled(Builtin::SGray.profile().clone(), name) +pub(super) fn gray_profile(name: &str) -> ColorProfile { + let mut p = ColorProfile::new_gray_with_gamma(2.2); + p.gray_trc = ColorProfile::new_srgb().red_trc; + labelled(p, name) } /// The first tag signature the tag table of ICC `bytes` lists twice, which the ICC -/// specification forbids. +/// specification forbids. moxcms parses every entry of the table, so a profile listing one +/// description, copyright or table tag thousands of times, each pointing at the same large data, +/// would decode and copy that data once per entry. A table it can't read is left to moxcms. pub(crate) fn repeated_tag(bytes: &[u8]) -> Option { let be32 = |at: usize| bytes.get(at..at.checked_add(4)?).map(|v| u32::from_be_bytes([v[0], v[1], v[2], v[3]])); let tags = be32(128)? as usize; @@ -336,7 +551,9 @@ pub(crate) fn repeated_tag(bytes: &[u8]) -> Option { const MAX_LOCALIZED_TEXT: usize = 1 << 20; /// Whether the localized-name records of the `mluc` tags in ICC `bytes` take at most -/// [`MAX_LOCALIZED_TEXT`] together. +/// [`MAX_LOCALIZED_TEXT`] together. moxcms copies each record into a string of its own, and records +/// may all point at the same bytes, so a profile under a megabyte could make it allocate +/// gigabytes. A table it can't read is left to moxcms to refuse. pub(crate) fn localized_text_fits(bytes: &[u8]) -> bool { let be32 = |b: &[u8], at: usize| b.get(at..at.checked_add(4)?).map(|v| u32::from_be_bytes([v[0], v[1], v[2], v[3]]) as usize); let Some(tags) = be32(bytes, 128) else { return true }; @@ -350,7 +567,10 @@ pub(crate) fn localized_text_fits(bytes: &[u8]) -> bool { } let records = be32(tag, 8).unwrap_or(0); for r in 0..records { + // Each record's header: language, country, length, offset. let Some(length) = r.checked_mul(12).and_then(|h| be32(tag, h + 16 + 4)) else { break }; + // Each record counts its 12-byte header too: records of length 0 are not free, so + // many tags pointing at one `mluc` can't make this loop quadratic. total = total.saturating_add(length).saturating_add(12); if total > MAX_LOCALIZED_TEXT { return false;