5a24289898fd
icc.rs
//! ICC profiles: parsing (via `craft-cms`), matrix/TRC extraction, CMS fallback for LUT/CMYK profiles,
//! and writing matrix/TRC profiles for export embedding.
use crate::space::{NamedSpace, Trc, rgb_to_xyz_d50};
use craft_cms::{Builtin, ColorSpace, Curve, Intent, Pcs, Profile, Transform, TransformOptions};
use lightcraft_color::{D50, Mat3, RgbSpace, bradford};
use serde::{Deserialize, Serialize};
/// Colour model of the profile's device space.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum IccColorModel {
Rgb,
Gray,
Cmyk,
Other,
}
/// How a profile can be applied.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum IccKind {
/// RGB matrix/TRC (shaper) profile: exact, applied by us.
MatrixTrc { to_xyz_d50: Mat3, trc: [Trc; 3] },
/// Grayscale profile with a `kTRC`.
Gray { trc: Trc },
/// LUT-based (A2B), CMYK or otherwise needs a full CMS conversion.
NeedsCms,
}
/// Summary of a parsed ICC profile.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct IccInfo {
pub model: IccColorModel,
pub kind: IccKind,
/// Recognised well-known RGB space (by colorants), if any.
pub named: Option<NamedSpace>,
pub description: Option<String>,
}
/// Parse an ICC profile. Returns `None` for malformed or unsupported data (never panics).
pub fn parse(bytes: &[u8]) -> Option<IccInfo> {
let p = Profile::parse(bytes).ok()?;
Some(info_of(&p))
}
fn info_of(p: &Profile) -> IccInfo {
let desc = p.description.trim_end_matches('\0').trim().to_string();
let description = if desc.is_empty() { None } else { Some(desc) };
let model = match p.color_space {
ColorSpace::Rgb => IccColorModel::Rgb,
ColorSpace::Gray => IccColorModel::Gray,
ColorSpace::Cmyk => IccColorModel::Cmyk,
_ => IccColorModel::Other,
};
let has_lut = p.a2b[0].is_some() || p.a2b[1].is_some();
let kind = if model == IccColorModel::Rgb && p.is_matrix_shaper() && p.pcs == Pcs::Xyz {
let to_xyz_d50 = Mat3(p.matrix.unwrap_or([[0.0; 3]; 3]));
let trc =
p.trc.as_ref().map(|ts| [trc_from_icc(&ts[0]), trc_from_icc(&ts[1]), trc_from_icc(&ts[2])]).unwrap_or([Trc::Srgb, Trc::Srgb, Trc::Srgb]);
if to_xyz_d50.determinant().abs() > 1e-6 && trc.iter().all(valid_trc) { IccKind::MatrixTrc { to_xyz_d50, trc } } else { IccKind::NeedsCms }
} else if model == IccColorModel::Gray && p.gray_trc.is_some() && !has_lut {
let trc = p.gray_trc.as_ref().map(trc_from_icc).unwrap_or(Trc::Srgb);
if valid_trc(&trc) { IccKind::Gray { trc } } else { IccKind::NeedsCms }
} else {
IccKind::NeedsCms
};
let named = match &kind {
IccKind::MatrixTrc { to_xyz_d50, .. } => NamedSpace::recognize(to_xyz_d50),
_ => None,
};
IccInfo { model, kind, named, description }
}
fn valid_trc(t: &Trc) -> bool {
match t {
Trc::Parametric(p) => matches!(p.len(), 1 | 3 | 4 | 5 | 7) && p.iter().all(|v| v.is_finite()),
Trc::Gamma(g) => g.is_finite() && *g > 0.0,
_ => true,
}
}
fn trc_from_icc(t: &Curve) -> Trc {
match t {
Curve::Identity => Trc::Linear,
Curve::Gamma(g) => Trc::Gamma(*g as f32),
Curve::Parametric { kind, p } => Trc::Parametric(p[..Curve::param_count(*kind)].iter().map(|&v| v as f32).collect()),
Curve::Table(v) if v.is_empty() => Trc::Linear,
Curve::Table(v) if v.len() == 1 => Trc::Gamma(v[0]),
Curve::Table(v) => Trc::Table(v.iter().map(|&x| (x.clamp(0.0, 1.0) * 65535.0).round() as u16).collect()),
}
}
fn trc_to_icc(t: &Trc) -> Curve {
match t {
Trc::Linear => Curve::Identity,
Trc::Srgb => Curve::Parametric { kind: 3, p: [2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045, 0.0, 0.0] },
Trc::Gamma(g) => Curve::Gamma(*g as f64),
Trc::Rec709 => Curve::Parametric { kind: 3, p: [1.0 / 0.45, 1.0 / 1.099, 0.099 / 1.099, 1.0 / 4.5, 0.081, 0.0, 0.0] },
Trc::Parametric(p) => {
let kind = match p.len() {
1 => 0,
3 => 1,
4 => 2,
5 => 3,
_ => 4,
};
let mut arr = [0.0f64; 7];
for (dst, &src) in arr.iter_mut().zip(p.iter()) {
*dst = src as f64;
}
Curve::Parametric { kind, p: arr }
}
Trc::Table(v) => Curve::Table(v.iter().map(|&x| x as f32 / 65535.0).collect()),
}
}
/// ICC PCS illuminant (D50) as stored in profiles.
const ICC_D50: [f64; 3] = [0.9642, 1.0, 0.8249];
/// Build an ICC v4 display-class matrix/TRC profile for `space` with the given encoding curve
/// (D50 PCS, Bradford `chad`), for embedding in exported files.
pub fn write_matrix_trc(space: &RgbSpace, trc: &Trc) -> Vec<u8> {
let mut p = Builtin::Srgb.profile().clone();
p.matrix = Some(rgb_to_xyz_d50(space).0);
let curve = trc_to_icc(trc);
p.trc = Some([curve.clone(), curve.clone(), curve]);
p.white_point = ICC_D50;
p.chad = Some(bradford(space.white, D50).0);
p.rendering_intent = Intent::Perceptual;
p.description = match trc {
t if t.is_linear() => format!("{} (linear)", space.name),
_ => space.name.to_string(),
};
p.copyright = "No copyright, use freely".to_string();
let encoded = p.with_encoded_bytes();
craft_cms::normalize_for_embedding(encoded.to_bytes().to_vec())
}
/// A profile for one of the well-known spaces with its standard curve.
pub fn write_named(n: NamedSpace) -> Vec<u8> {
write_matrix_trc(&n.rgb_space(), &n.trc())
}
pub(crate) fn linear_rec2020_profile() -> Profile {
let mut p = Builtin::Rec2020.profile().clone();
p.trc = Some([Curve::Identity, Curve::Identity, Curve::Identity]);
p
}
/// Convert device samples (0..1, interleaved, `channels` = 1, 3 or 4 matching the profile's colour
/// model) to linear Rec.2020 through a full CMS transform. `None` if the profile cannot be applied.
pub(crate) fn cms_to_linear_rec2020(icc: &[u8], samples: &[f32], channels: usize) -> Option<Vec<[f32; 3]>> {
let src = Profile::parse(icc).ok()?;
let expected = match src.color_space {
ColorSpace::Rgb => 3,
ColorSpace::Gray => 1,
ColorSpace::Cmyk => 4,
_ => return None,
};
if channels != expected {
return None;
}
let dst = linear_rec2020_profile();
let opts = TransformOptions { intent: Intent::RelativeColorimetric, bpc: false, precise_float: true };
let t = Transform::with_options(&src, &dst, opts).ok()?;
let n = samples.len() / channels;
let mut out = vec![0f32; n * 3];
const ROWS: usize = 1 << 16;
let src_chunks = samples.chunks(ROWS * channels);
let dst_chunks = out.chunks_mut(ROWS * 3);
#[cfg(feature = "parallel")]
{
use rayon::prelude::*;
let pairs: Vec<_> = src_chunks.zip(dst_chunks).collect();
let ok = pairs.into_par_iter().all(|(s, d)| t.convert_f32(s, channels, d, 3, false).is_ok());
if !ok {
return None;
}
}
#[cfg(not(feature = "parallel"))]
for (s, d) in src_chunks.zip(dst_chunks) {
t.convert_f32(s, channels, d, 3, false).ok()?;
}
Some(out.as_chunks::<3>().0.iter().map(|c| [c[0], c[1], c[2]]).collect())
}
#[cfg(test)]
mod tests {
use super::*;
use lightcraft_color::{DISPLAY_P3, PROPHOTO, SRGB};
#[test]
fn write_then_parse_recognises() {
for n in NamedSpace::ALL {
let bytes = write_named(n);
assert!(bytes.len() > 128, "{n:?}");
let info = parse(&bytes).expect("parses");
assert_eq!(info.named, Some(n), "{n:?}");
match info.kind {
IccKind::MatrixTrc { trc, .. } => assert!(trc[0].approx_eq(&n.trc(), 2e-4), "{n:?} {:?}", trc[0]),
k => panic!("{k:?}"),
}
}
}
#[test]
fn tags_are_aligned() {
for n in NamedSpace::ALL {
for trc in [n.trc(), Trc::Linear] {
let b = write_matrix_trc(&n.rgb_space(), &trc);
assert_eq!(b.len() % 4, 0, "{n:?}");
assert_eq!(u32::from_be_bytes(b[0..4].try_into().unwrap()) as usize, b.len());
let count = u32::from_be_bytes(b[128..132].try_into().unwrap()) as usize;
for t in 0..count {
let off = u32::from_be_bytes(b[132 + 12 * t + 4..132 + 12 * t + 8].try_into().unwrap());
assert_eq!(off % 4, 0, "{n:?} tag {t}");
}
assert!(parse(&b).is_some_and(|i| i.named == Some(n)), "{n:?}");
}
}
}
#[test]
fn linear_profile() {
let bytes = write_matrix_trc(&PROPHOTO, &Trc::Linear);
let info = parse(&bytes).unwrap();
assert_eq!(info.named, Some(NamedSpace::ProPhoto));
let IccKind::MatrixTrc { trc, .. } = info.kind else { panic!() };
assert!(trc[1].is_linear());
}
#[test]
fn cms_path_matches_matrix_path() {
let bytes = write_named(NamedSpace::DisplayP3);
let px = [0.2f32, 0.5, 0.8];
let out = cms_to_linear_rec2020(&bytes, &px, 3).unwrap()[0];
let lin = px.map(|v| Trc::Srgb.to_linear(v));
let m = DISPLAY_P3.to_space(&lightcraft_color::REC2020);
let want = m.apply_f32(lin);
for i in 0..3 {
assert!((out[i] - want[i]).abs() < 2e-3, "{out:?} vs {want:?}");
}
let _ = SRGB;
}
/// Two profiles for one space are byte-identical, and the header date is fixed: exports of the
/// same photo with the same settings hash the same (#180).
#[test]
fn written_profiles_are_deterministic() {
for n in NamedSpace::ALL {
let a = write_named(n);
let b = write_named(n);
assert_eq!(a, b, "{n:?}");
assert_eq!(&a[24..36], &[0u8; 12], "{n:?} header date/time");
// the profile ID is "not computed", not a hash of a timestamp
assert_eq!(&a[84..100], &[0u8; 16], "{n:?} profile ID");
}
let lin = write_matrix_trc(&PROPHOTO, &Trc::Linear);
assert_eq!(lin, write_matrix_trc(&PROPHOTO, &Trc::Linear));
assert_eq!(&lin[24..36], &[0u8; 12]);
}
#[test]
fn garbage_is_none() {
assert!(parse(&[]).is_none());
assert!(parse(&[0u8; 200]).is_none());
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.