From 50f8cc339770ebc648ba29f0ac45e0b986c37dd6 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 11:45:48 +0100 Subject: [PATCH 1/5] psd: write fixtures with craft_psd --- crates/psd/src/lib.rs | 1 - crates/psd/src/pixels.rs | 36 ----- crates/psd/src/tests.rs | 15 +- crates/psd/src/tests/opt.rs | 2 +- crates/psd/src/write.rs | 303 +++++++++++++----------------------- 5 files changed, 125 insertions(+), 232 deletions(-) diff --git a/crates/psd/src/lib.rs b/crates/psd/src/lib.rs index 91792a837..07f5f0359 100644 --- a/crates/psd/src/lib.rs +++ b/crates/psd/src/lib.rs @@ -32,7 +32,6 @@ pub use model::{ Adjustment, ChannelInfo, ColorMode, Layer, LayerMask, LinkedFile, MAX_GROUP_DEPTH, Node, Pixels, Rect, Section, SmartObject, SubPath, TextInfo, VectorMask, }; pub use parse::is_psd; -pub(crate) use pixels::pack_bits; #[cfg(test)] use pixels::{lab_to_rgb, srgb_encode, unpack_bits}; diff --git a/crates/psd/src/pixels.rs b/crates/psd/src/pixels.rs index 290a7b6f4..4907e21f7 100644 --- a/crates/psd/src/pixels.rs +++ b/crates/psd/src/pixels.rs @@ -505,42 +505,6 @@ pub(crate) fn unpack_bits(src: &[u8], row: usize, out: &mut Vec) -> Result<( Ok(()) } -/// PackBits encoding of one row. -pub(crate) fn pack_bits(src: &[u8]) -> Vec { - let mut out = vec![]; - let mut i = 0; - while i < src.len() { - // run of identical bytes - let mut run = 1; - while i + run < src.len() && src[i + run] == src[i] && run < 128 { - run += 1; - } - if run >= 2 { - out.push((1 - run as isize) as i8 as u8); - out.push(src[i]); - i += run; - continue; - } - // literal run - let start = i; - let mut n = 0; - while i < src.len() && n < 128 { - if i + 1 < src.len() && src[i + 1] == src[i] { - break; - } - i += 1; - n += 1; - } - if n == 0 { - i += 1; - n = 1; - } - out.push((n - 1) as u8); - out.extend_from_slice(&src[start..start + n]); - } - out -} - pub(crate) fn srgb_encode(v: f32) -> f32 { if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 } } diff --git a/crates/psd/src/tests.rs b/crates/psd/src/tests.rs index fd041138a..36470ba9b 100644 --- a/crates/psd/src/tests.rs +++ b/crates/psd/src/tests.rs @@ -171,7 +171,7 @@ fn text_effects_fill_and_adjustments() { #[test] fn packbits_round_trip() { for src in [vec![], vec![1u8], vec![5; 300], (0..=255).collect::>(), vec![1, 1, 2, 3, 3, 3, 4, 5, 5]] { - let enc = pack_bits(&src); + let enc = craft_psd::compression::packbits::encode_vec(&src); let mut out = vec![]; unpack_bits(&enc, src.len(), &mut out).unwrap(); assert_eq!(out, src); @@ -519,3 +519,16 @@ fn a_failed_inflate_reports_its_status_not_its_output() { let Err(Error::Invalid(msg)) = crate::limits::inflate(&z, 1 << 21) else { panic!("the checksum fails") }; assert!(msg.len() < 100, "{} bytes", msg.len()); } + +#[test] +fn written_32_bit_documents_decode() { + // 32-bit samples are written as floats, raw or RLE, so both read back whole. + for rle in [true, false] { + let p = Psd::parse(write(&doc_with_layers(32, ColorMode::Rgb, rle))).expect("parse"); + assert_eq!(p.depth, 32); + assert!(p.composite().is_ok(), "rle={rle}"); + for i in 0..p.layers.len() { + assert!(p.layer_pixels(i, false).is_ok(), "rle={rle} layer {i}"); + } + } +} diff --git a/crates/psd/src/tests/opt.rs b/crates/psd/src/tests/opt.rs index 44bcec071..241af0069 100644 --- a/crates/psd/src/tests/opt.rs +++ b/crates/psd/src/tests/opt.rs @@ -385,7 +385,7 @@ fn stream(planes: &[Vec], w: usize, h: usize, depth: u16, comp: u16) -> Vec< match comp { 0 => planes.iter().for_each(|p| out.extend(p)), 1 => { - let rows: Vec> = planes.iter().flat_map(|p| p.chunks(rowb.max(1)).map(pack_bits)).collect(); + let rows: Vec> = planes.iter().flat_map(|p| p.chunks(rowb.max(1)).map(craft_psd::compression::packbits::encode_vec)).collect(); rows.iter().for_each(|r| out.extend((r.len() as u16).to_be_bytes())); rows.iter().for_each(|r| out.extend(r)); } diff --git a/crates/psd/src/write.rs b/crates/psd/src/write.rs index a92e76dcd..e46576467 100644 --- a/crates/psd/src/write.rs +++ b/crates/psd/src/write.rs @@ -1,10 +1,17 @@ //! A minimal Photoshop document writer, per the same specification as the reader: RGB, CMYK or //! Grayscale, 8 or 16 bits, raw or RLE channels, pixel layers with layer masks, groups and any //! additional-information blocks (helpers below build text, effects, fill and adjustment -//! blocks). Used to generate test fixtures; not a full exporter. +//! blocks). Used to generate test fixtures; not a full exporter. The file itself is laid out and +//! encoded by craft-psd ([`craft_psd::PsdFile::to_bytes`]). + +use craft_psd::layer::{LayerInfo, LayerRecord}; +use craft_psd::tagged::{SectionType, TaggedBlock}; +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, pack_bits}; +use crate::{ColorMode, Rect, Section, engine_data}; /// A layer mask for [`WLayer`]. #[derive(Clone, Debug)] @@ -93,7 +100,7 @@ impl WLayer { pub struct WDoc { pub width: u32, pub height: u32, - /// 8 or 16. + /// 8, 16 or 32 (32-bit samples are written as floats). pub depth: u16, /// Rgb, Cmyk or Grayscale. pub mode: ColorMode, @@ -128,10 +135,12 @@ 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() * if depth == 16 { 2 } else { 1 }); + 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); - if depth == 16 { + if depth == 32 { + out.extend_from_slice(&x.to_be_bytes()); + } else if depth == 16 { put_u16(&mut out, (x * 65535.0).round() as u16); } else { out.push((x * 255.0).round() as u8); @@ -140,139 +149,69 @@ fn encode_samples(v: &[f32], depth: u16) -> Vec { out } -/// One channel's data (compression field + data) for a `w`×`h` plane. -fn channel_data(v: &[f32], w: usize, h: usize, depth: u16, rle: bool) -> Vec { - let raw = encode_samples(v, depth); - let mut out = vec![]; - let rowb = raw.len() / h.max(1); - if !rle || w == 0 || h == 0 { - put_u16(&mut out, 0); - out.extend_from_slice(&raw); - return out; - } - put_u16(&mut out, 1); - let rows: Vec> = raw.chunks(rowb.max(1)).map(pack_bits).collect(); - for r in &rows { - put_u16(&mut out, r.len() as u16); - } - for r in rows { - out.extend_from_slice(&r); - } - out +/// The layer and merged-image compression of `doc`. +fn compression(doc: &WDoc) -> Compression { + if doc.rle { Compression::Rle } else { Compression::Raw } } -fn pascal4(out: &mut Vec, s: &str) { - let b: Vec = s.bytes().map(|c| if c < 0x80 { c } else { b'?' }).take(255).collect(); - out.push(b.len() as u8); - out.extend_from_slice(&b); - let total = 1 + b.len(); - out.resize(out.len() + total.div_ceil(4) * 4 - total, 0); +/// One channel of a `w`×`h` plane, encoded by craft-psd. An empty plane is written raw. +fn channel(id: i16, v: &[f32], w: usize, h: usize, doc: &WDoc) -> craft_psd::Result { + let c = if w == 0 || h == 0 { Compression::Raw } else { compression(doc) }; + ChannelData::encode(id, c, &encode_samples(v, doc.depth), w, h, doc.depth, Version::Psd) } -fn block(out: &mut Vec, key: &[u8; 4], data: &[u8]) { - out.extend_from_slice(b"8BIM"); - out.extend_from_slice(key); - let padded = data.len().div_ceil(2) * 2; - put_u32(out, padded as u32); - out.extend_from_slice(data); - out.resize(out.len() + padded - data.len(), 0); +/// A legacy Pascal name: ASCII, anything else as `?`, at most 255 bytes. +fn legacy_name(s: &str) -> Vec { + s.bytes().map(|c| if c < 0x80 { c } else { b'?' }).take(255).collect() } -fn layer_info(doc: &WDoc) -> Vec { - let mut out = vec![]; - out.extend_from_slice(&(-(doc.layers.len() as i16)).to_be_bytes()); - let mut chan_data: Vec)>> = vec![]; - for l in &doc.layers { - let (w, h) = (l.rect.width() as usize, l.rect.height() as usize); - let mut chans: Vec<(i16, Vec)> = vec![]; - let n = w * h; - let alpha: Vec = l.pixels.iter().take(n).map(|p| p[3]).collect(); - chans.push((-1, channel_data(&alpha, w, h, doc.depth, doc.rle))); - let cc = doc.mode.color_channels(); - let planes: Vec> = l.pixels.iter().take(n).map(|p| mode_channels(doc.mode, *p)).collect(); - for c in 0..cc { - let plane: Vec = planes.iter().map(|v| v[c]).collect(); - chans.push((c as i16, channel_data(&plane, w, h, doc.depth, doc.rle))); - } - if let Some(m) = &l.mask { - chans.push((-2, channel_data(&m.data, m.rect.width() as usize, m.rect.height() as usize, doc.depth, doc.rle))); - } - // record - for v in [l.rect.top, l.rect.left, l.rect.bottom, l.rect.right] { - out.extend_from_slice(&v.to_be_bytes()); - } - put_u16(&mut out, chans.len() as u16); - for (id, d) in &chans { - out.extend_from_slice(&id.to_be_bytes()); - put_u32(&mut out, d.len() as u32); - } - out.extend_from_slice(b"8BIM"); - out.extend_from_slice(&l.blend); - out.push(l.opacity); - out.push(l.clipping as u8); - let mut flags = 8u8; - if l.hidden { - flags |= 2; - } - out.push(flags); - out.push(0); - let mut extra = vec![]; - match &l.mask { - Some(m) => { - put_u32(&mut extra, 20); - for v in [m.rect.top, m.rect.left, m.rect.bottom, m.rect.right] { - extra.extend_from_slice(&v.to_be_bytes()); - } - extra.push(m.default_color); - extra.push(if m.disabled { 2 } else { 0 }); - extra.extend_from_slice(&[0, 0]); - } - None => put_u32(&mut extra, 0), - } - put_u32(&mut extra, 0); // blending ranges - pascal4(&mut extra, &l.name); - let luni = unicode_plain(&l.name); - block(&mut extra, b"luni", &luni); - match l.section { - Section::Layer => {} - s => { - let mut d = vec![]; - put_u32( - &mut d, - match s { - Section::OpenFolder => 1, - Section::ClosedFolder => 2, - _ => 3, - }, - ); - d.extend_from_slice(b"8BIM"); - d.extend_from_slice(&l.blend); - block(&mut extra, b"lsct", &d); - } - } - for (k, d) in &l.blocks { - block(&mut extra, k, d); - } - put_u32(&mut out, extra.len() as u32); - out.extend_from_slice(&extra); - chan_data.push(chans); - } - for chans in chan_data { - for (_, d) in chans { - out.extend_from_slice(&d); - } - } - if out.len() % 2 == 1 { - out.push(0); - } - out +fn psd_rect(r: Rect) -> craft_psd::Rect { + craft_psd::Rect { top: r.top, left: r.left, bottom: r.bottom, right: r.right } } -/// A Unicode string without the terminating NUL (the layer-name `luni` form). -fn unicode_plain(s: &str) -> Vec { - let mut out = vec![]; - put_utf16(&mut out, s, false); - out +/// The layer record of `l`: pixels, mask, name, section and blocks. +fn record(l: &WLayer, doc: &WDoc) -> craft_psd::Result { + let (w, h) = (l.rect.width() as usize, l.rect.height() as usize); + let n = w * h; + let alpha: Vec = l.pixels.iter().take(n).map(|p| p[3]).collect(); + let mut channels = vec![channel(-1, &alpha, w, h, doc)?]; + let planes: Vec> = l.pixels.iter().take(n).map(|p| mode_channels(doc.mode, *p)).collect(); + for c in 0..doc.mode.color_channels() { + let plane: Vec = planes.iter().map(|v| v[c]).collect(); + channels.push(channel(c as i16, &plane, w, h, doc)?); + } + let mut mask = MaskData::None; + if let Some(m) = &l.mask { + channels.push(channel(-2, &m.data, m.rect.width() as usize, m.rect.height() as usize, doc)?); + mask = MaskData::Mask(craft_psd::LayerMask::new(psd_rect(m.rect), m.default_color, if m.disabled { 2 } else { 0 })); + } + let mut flags = LayerFlags(8); + flags.set_hidden(l.hidden); + let mut blocks = vec![TaggedBlock::unicode_name(&l.name)]; + let kind = match l.section { + Section::Layer => None, + Section::OpenFolder => Some(SectionType::OpenFolder), + Section::ClosedFolder => Some(SectionType::ClosedFolder), + Section::Divider => Some(SectionType::BoundingDivider), + }; + if let Some(kind) = kind { + blocks.push(TaggedBlock::section_divider(kind, Some(BlendMode::from_key(l.blend)), None)); + } + blocks.extend(l.blocks.iter().map(|(k, d)| TaggedBlock::new(*k, d.clone()))); + Ok(LayerRecord { + rect: psd_rect(l.rect), + channels, + blend_mode: BlendMode::from_key(l.blend), + opacity: l.opacity, + clipping: u8::from(l.clipping), + flags, + filler: 0, + mask, + blending_ranges: BlendingRanges::default(), + name: legacy_name(&l.name), + blocks, + extra_trailing: vec![], + }) } /// Normal "over" of the visible pixel layers (groups ignored), straight alpha. @@ -298,76 +237,54 @@ fn flatten(doc: &WDoc) -> Vec<[f32; 4]> { acc } -/// Serialise a document. +/// Serialise a document with craft-psd. pub fn write(doc: &WDoc) -> Vec { + // Every input `WDoc` describes is in range for the writer; a failure is a bug in the caller. + #[allow(clippy::expect_used)] + build(doc).and_then(|f| f.to_bytes()).expect("a WDoc is always writable") +} + +fn build(doc: &WDoc) -> craft_psd::Result { let cc = doc.mode.color_channels(); - let mut out = vec![]; - out.extend_from_slice(b"8BPS"); - put_u16(&mut out, 1); - out.extend_from_slice(&[0; 6]); - put_u16(&mut out, (cc + 1) as u16); - put_u32(&mut out, doc.height); - put_u32(&mut out, doc.width); - put_u16(&mut out, doc.depth); - put_u16(&mut out, doc.mode.to_u16()); - put_u32(&mut out, 0); // colour mode data - put_u32(&mut out, 0); // image resources - // Layer and mask information. - let mut lm = vec![]; - if !doc.layers.is_empty() { - let li = layer_info(doc); - if doc.depth == 16 { - put_u32(&mut lm, 0); - put_u32(&mut lm, 0); // global layer mask info - let mut padded = li; - while !padded.len().is_multiple_of(4) { - padded.push(0); - } - lm.extend_from_slice(b"8BIM"); - lm.extend_from_slice(b"Lr16"); - put_u32(&mut lm, padded.len() as u32); - lm.extend_from_slice(&padded); - } else { - put_u32(&mut lm, li.len() as u32); - lm.extend_from_slice(&li); - put_u32(&mut lm, 0); - } - if !doc.linked.is_empty() { - let d = linked_block(&doc.linked); - lm.extend_from_slice(b"8BIM"); - lm.extend_from_slice(b"lnk2"); - put_u32(&mut lm, d.len() as u32); - lm.extend_from_slice(&d); - } + let header = Header::new(Version::Psd, doc.width, doc.height, (cc + 1) as u16, doc.depth, craft_psd::ColorMode::from_u16(doc.mode.to_u16())); + let layers = doc.layers.iter().map(|l| record(l, doc)).collect::>>()?; + let has_layers = !layers.is_empty(); + let mut global_blocks = vec![]; + if has_layers && !doc.linked.is_empty() { + global_blocks.push(TaggedBlock::new(*b"lnk2", linked_block(&doc.linked))); } - put_u32(&mut out, lm.len() as u32); - out.extend_from_slice(&lm); // Merged image. let comp = doc.composite.clone().unwrap_or_else(|| flatten(doc)); - let w = doc.width as usize; let planes: Vec> = comp.iter().map(|p| mode_channels(doc.mode, *p)).collect(); - let mut chans: Vec> = (0..cc).map(|c| planes.iter().map(|v| v[c]).collect()).collect(); - chans.push(comp.iter().map(|p| p[3]).collect()); - if doc.rle { - put_u16(&mut out, 1); - let rows: Vec>> = - chans.iter().map(|c| encode_samples(c, doc.depth).chunks((w * if doc.depth == 16 { 2 } else { 1 }).max(1)).map(pack_bits).collect()).collect(); - for c in &rows { - for r in c { - put_u16(&mut out, r.len() as u16); - } - } - for c in rows { - for r in c { - out.extend_from_slice(&r); - } - } - } else { - put_u16(&mut out, 0); - for c in &chans { - out.extend_from_slice(&encode_samples(c, doc.depth)); - } + let mut merged = vec![]; + for c in 0..cc { + merged.extend(encode_samples(&planes.iter().map(|v| v[c]).collect::>(), doc.depth)); } + merged.extend(encode_samples(&comp.iter().map(|p| p[3]).collect::>(), doc.depth)); + let image_data = ImageData::encode(compression(doc), &merged, &header)?; + Ok(PsdFile { + header, + color_mode_data: vec![], + resources: vec![], + layer_info: has_layers.then_some(LayerInfo { merged_alpha: true, layers, padding: None }), + // 16-bit layers go in an `Lr16` block, as Photoshop writes them. + layer_info_placement: if has_layers && doc.depth == 16 { + LayerInfoPlacement::GlobalBlock { index: 0, signature: *b"8BIM", key: *b"Lr16", padding: None } + } else { + LayerInfoPlacement::Section + }, + global_layer_mask: has_layers.then(GlobalLayerMask::default), + global_blocks, + layer_mask_trailing: vec![], + image_data, + write_as_psb: false, + }) +} + +/// A Unicode string without the terminating NUL (the layer-name `luni` form). +fn unicode_plain(s: &str) -> Vec { + let mut out = vec![]; + put_utf16(&mut out, s, false); out } From 49abf0b402d7f151a6f8e6f6829d900a070ebfa7 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 11:57:54 +0100 Subject: [PATCH 2/5] psd: write 32-bit layers in Lr32, wide RLE rows raw --- crates/psd/src/tests.rs | 32 ++++++++++++++++++++++++++++++++ crates/psd/src/write.rs | 18 +++++++++++------- 2 files changed, 43 insertions(+), 7 deletions(-) diff --git a/crates/psd/src/tests.rs b/crates/psd/src/tests.rs index 36470ba9b..f70ebaf5f 100644 --- a/crates/psd/src/tests.rs +++ b/crates/psd/src/tests.rs @@ -532,3 +532,35 @@ fn written_32_bit_documents_decode() { } } } + +#[test] +fn deep_layers_go_in_their_global_block() { + for (depth, key) in [(16, b"Lr16"), (32, b"Lr32")] { + let bytes = write(&doc_with_layers(depth, ColorMode::Rgb, true)); + let file = craft_psd::PsdFile::from_bytes(&bytes).expect("parse"); + assert!( + matches!(file.layer_info_placement, craft_psd::LayerInfoPlacement::GlobalBlock { key: k, .. } if &k == key), + "{depth}-bit: {:?}", + file.layer_info_placement + ); + assert_eq!(Psd::parse(bytes).expect("parse").layers.len(), doc_with_layers(depth, ColorMode::Rgb, true).layers.len()); + } +} + +#[test] +fn rows_too_wide_for_rle_are_written_raw() { + // 20000 32-bit samples are 80000 bytes per row, past the 65535 an RLE row count holds. + let doc = |w: u32| { + let mut d = WDoc::new(w, 1); + d.depth = 32; + d.composite = Some(vec![[0.5, 0.25, 0.75, 1.0]; w as usize]); + d.layers.push(WLayer::solid("Wide", Rect::new(0, 0, w as i32, 1), [0.5, 0.25, 0.75, 1.0])); + d + }; + let want = Psd::parse(write(&doc(100))).expect("narrow").composite().expect("composite").data[0]; + let p = Psd::parse(write(&doc(20_000))).expect("parse"); + let c = p.composite().expect("composite"); + assert_eq!(c.data.len(), 20_000); + assert!(c.data.iter().all(|px| *px == want), "{:?} vs {want:?}", c.data[0]); + assert!(p.layer_pixels(0, false).is_ok()); +} diff --git a/crates/psd/src/write.rs b/crates/psd/src/write.rs index e46576467..bd55b566e 100644 --- a/crates/psd/src/write.rs +++ b/crates/psd/src/write.rs @@ -157,7 +157,10 @@ fn compression(doc: &WDoc) -> Compression { /// One channel of a `w`×`h` plane, encoded by craft-psd. An empty plane is written raw. fn channel(id: i16, v: &[f32], w: usize, h: usize, doc: &WDoc) -> craft_psd::Result { let c = if w == 0 || h == 0 { Compression::Raw } else { compression(doc) }; - ChannelData::encode(id, c, &encode_samples(v, doc.depth), w, h, doc.depth, Version::Psd) + let samples = encode_samples(v, doc.depth); + // A PSD RLE row holds at most 65535 bytes; a wider plane is written raw. + ChannelData::encode(id, c, &samples, w, h, doc.depth, Version::Psd) + .or_else(|_| ChannelData::encode(id, Compression::Raw, &samples, w, h, doc.depth, Version::Psd)) } /// A legacy Pascal name: ASCII, anything else as `?`, at most 255 bytes. @@ -261,17 +264,18 @@ fn build(doc: &WDoc) -> craft_psd::Result { merged.extend(encode_samples(&planes.iter().map(|v| v[c]).collect::>(), doc.depth)); } merged.extend(encode_samples(&comp.iter().map(|p| p[3]).collect::>(), doc.depth)); - let image_data = ImageData::encode(compression(doc), &merged, &header)?; + let image_data = ImageData::encode(compression(doc), &merged, &header).or_else(|_| ImageData::encode(Compression::Raw, &merged, &header))?; Ok(PsdFile { header, color_mode_data: vec![], resources: vec![], layer_info: has_layers.then_some(LayerInfo { merged_alpha: true, layers, padding: None }), - // 16-bit layers go in an `Lr16` block, as Photoshop writes them. - layer_info_placement: if has_layers && doc.depth == 16 { - LayerInfoPlacement::GlobalBlock { index: 0, signature: *b"8BIM", key: *b"Lr16", padding: None } - } else { - LayerInfoPlacement::Section + // 16- and 32-bit layers go in an `Lr16` / `Lr32` block, as Photoshop writes them. + layer_info_placement: match doc.depth { + 16 | 32 if has_layers => { + LayerInfoPlacement::GlobalBlock { index: 0, signature: *b"8BIM", key: craft_psd::tiff::layer_info_key(doc.depth), padding: None } + } + _ => LayerInfoPlacement::Section, }, global_layer_mask: has_layers.then(GlobalLayerMask::default), global_blocks, From 00bf6a06c9a556947b17955ed0cee1ea816a9369 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 12:30:10 +0100 Subject: [PATCH 3/5] psd: keep the luni block's bytes so exported files are unchanged --- crates/psd/src/write.rs | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/crates/psd/src/write.rs b/crates/psd/src/write.rs index bd55b566e..e67862470 100644 --- a/crates/psd/src/write.rs +++ b/crates/psd/src/write.rs @@ -163,6 +163,15 @@ fn channel(id: i16, v: &[f32], w: usize, h: usize, doc: &WDoc) -> craft_psd::Res .or_else(|_| ChannelData::encode(id, Compression::Raw, &samples, w, h, doc.depth, Version::Psd)) } +/// The `luni` block: the UTF-16 length and code units, unpadded, as this writer has always +/// written it (`TaggedBlock::unicode_name` adds a terminator, which would change exported files). +fn unicode_name(name: &str) -> TaggedBlock { + let units: Vec = name.encode_utf16().collect(); + let mut data = (units.len() as u32).to_be_bytes().to_vec(); + data.extend(units.iter().flat_map(|u| u.to_be_bytes())); + TaggedBlock::new(*b"luni", data) +} + /// A legacy Pascal name: ASCII, anything else as `?`, at most 255 bytes. fn legacy_name(s: &str) -> Vec { s.bytes().map(|c| if c < 0x80 { c } else { b'?' }).take(255).collect() @@ -190,7 +199,7 @@ fn record(l: &WLayer, doc: &WDoc) -> craft_psd::Result { } let mut flags = LayerFlags(8); flags.set_hidden(l.hidden); - let mut blocks = vec![TaggedBlock::unicode_name(&l.name)]; + let mut blocks = vec![unicode_name(&l.name)]; let kind = match l.section { Section::Layer => None, Section::OpenFolder => Some(SectionType::OpenFolder), From 952918aa02bde6a6aece0360cee1df55ccd0a275 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 12:59:44 +0100 Subject: [PATCH 4/5] psd: keep finite 32-bit color samples outside 0..1 Integer depths are still clamped. NaN and infinities use the same mapping as the reader. --- crates/psd/src/tests.rs | 30 ++++++++++++++++++++++++++++++ crates/psd/src/write.rs | 21 ++++++++++++++++----- 2 files changed, 46 insertions(+), 5 deletions(-) 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. From 7311b6574cfb9e916812bfca9b93c4472fb768b7 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 13:30:21 +0100 Subject: [PATCH 5/5] psd: rustfmt write.rs to the workspace style The previous commit had been formatted without rustfmt.toml (use_small_heuristics = "Max"), so cargo fmt --check failed on the gate. --- crates/psd/src/write.rs | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/crates/psd/src/write.rs b/crates/psd/src/write.rs index 6f77ad438..e5ec285b8 100644 --- a/crates/psd/src/write.rs +++ b/crates/psd/src/write.rs @@ -10,9 +10,9 @@ use craft_psd::{ BlendMode, BlendingRanges, ChannelData, Compression, GlobalLayerMask, Header, ImageData, LayerFlags, LayerInfoPlacement, MaskData, PsdFile, Version, }; -use crate::descriptor::{self, put_u16, put_u32, put_utf16, DValue, Descriptor}; +use crate::descriptor::{self, DValue, Descriptor, put_u16, put_u32, put_utf16}; use crate::limits::finite_sample; -use crate::{engine_data, ColorMode, Rect, Section}; +use crate::{ColorMode, Rect, Section, engine_data}; /// A layer mask for [`WLayer`]. #[derive(Clone, Debug)] @@ -128,11 +128,7 @@ 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]], @@ -158,11 +154,7 @@ 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.