diff --git a/crates/psd/src/tests.rs b/crates/psd/src/tests.rs index f70ebaf5f..7bc88006b 100644 --- a/crates/psd/src/tests.rs +++ b/crates/psd/src/tests.rs @@ -1,5 +1,6 @@ use super::write::*; use super::*; +use crate::pixels::srgb_encode; mod integration; mod opt; @@ -564,3 +565,32 @@ fn rows_too_wide_for_rle_are_written_raw() { assert!(c.data.iter().all(|px| *px == want), "{:?} vs {want:?}", c.data[0]); assert!(p.layer_pixels(0, false).is_ok()); } + +#[test] +fn written_32_bit_color_samples_keep_their_range() { + // The reader keeps finite 32-bit samples outside 0..1; the writer must be able to + // produce those fixtures. Integer depths stay clamped. A layer is present so the + // merged transparency flag is set and alpha is read back. + let want = [2.0, -0.5, 0.25, 1.5]; + let mut d = WDoc::new(1, 1); + d.depth = 32; + d.rle = false; + d.composite = Some(vec![want]); + d.layers.push(WLayer::solid("HDR", Rect::new(0, 0, 1, 1), want)); + let bytes = write(&d); + for v in want { + assert!(bytes.windows(4).any(|w| w == v.to_be_bytes()), "missing the {v} sample"); + } + let p = Psd::parse(bytes).expect("parse"); + assert!(p.merged_alpha); + let c = p.composite().expect("composite"); + assert_eq!(c.data[0], [srgb_encode(2.0), srgb_encode(-0.5), srgb_encode(0.25), 1.5]); + assert_eq!(p.layer_pixels(0, false).expect("layer").data[0], c.data[0]); + + let mut d8 = WDoc::new(1, 1); + d8.composite = Some(vec![want]); + d8.layers.push(WLayer::solid("HDR", Rect::new(0, 0, 1, 1), want)); + let p8 = Psd::parse(write(&d8)).expect("parse 8-bit"); + let q = |x: f32| (x.clamp(0.0, 1.0) * 255.0).round() / 255.0; + assert_eq!(p8.composite().expect("composite").data[0], [q(2.0), q(-0.5), q(0.25), q(1.5)]); +} diff --git a/crates/psd/src/write.rs b/crates/psd/src/write.rs index e67862470..6f77ad438 100644 --- a/crates/psd/src/write.rs +++ b/crates/psd/src/write.rs @@ -10,8 +10,9 @@ use craft_psd::{ BlendMode, BlendingRanges, ChannelData, Compression, GlobalLayerMask, Header, ImageData, LayerFlags, LayerInfoPlacement, MaskData, PsdFile, Version, }; -use crate::descriptor::{self, DValue, Descriptor, put_u16, put_u32, put_utf16}; -use crate::{ColorMode, Rect, Section, engine_data}; +use crate::descriptor::{self, put_u16, put_u32, put_utf16, DValue, Descriptor}; +use crate::limits::finite_sample; +use crate::{engine_data, ColorMode, Rect, Section}; /// A layer mask for [`WLayer`]. #[derive(Clone, Debug)] @@ -127,7 +128,11 @@ fn mode_channels(mode: ColorMode, p: [f32; 4]) -> Vec { ColorMode::Cmyk => { // Stored values are inverted ink amounts: k = max, c = r / max (reader: r = c * k). let m = p[0].max(p[1]).max(p[2]); - if m <= 0.0 { vec![0.0, 0.0, 0.0, 0.0] } else { vec![p[0] / m, p[1] / m, p[2] / m, m] } + if m <= 0.0 { + vec![0.0, 0.0, 0.0, 0.0] + } else { + vec![p[0] / m, p[1] / m, p[2] / m, m] + } } ColorMode::Grayscale => vec![p[0]], _ => vec![p[0], p[1], p[2]], @@ -137,7 +142,9 @@ fn mode_channels(mode: ColorMode, p: [f32; 4]) -> Vec { fn encode_samples(v: &[f32], depth: u16) -> Vec { let mut out = Vec::with_capacity(v.len() * usize::from(depth.div_ceil(8))); for &x in v { - let x = x.clamp(0.0, 1.0); + // Integer depths are stored in 0..1. 32-bit documents keep finite samples + // outside that range (HDR); NaN and infinities use the reader's mapping. + let x = if depth == 32 { finite_sample(x) } else { x.clamp(0.0, 1.0) }; if depth == 32 { out.extend_from_slice(&x.to_be_bytes()); } else if depth == 16 { @@ -151,7 +158,11 @@ fn encode_samples(v: &[f32], depth: u16) -> Vec { /// The layer and merged-image compression of `doc`. fn compression(doc: &WDoc) -> Compression { - if doc.rle { Compression::Rle } else { Compression::Raw } + if doc.rle { + Compression::Rle + } else { + Compression::Raw + } } /// One channel of a `w`×`h` plane, encoded by craft-psd. An empty plane is written raw.