psd: write 32-bit layers in Lr32, wide RLE rows raw

This commit is contained in:
FredApps committed 2026-11-16 11:57:54 +01:00
1 parent 50f8cc3397
commit 49abf0b402
2 files changed
+43 -7

No files matched your search

+32
View File
@@ -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());
}
+11 -7
View File
@@ -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<ChannelData> {
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<PsdFile> {
merged.extend(encode_samples(&planes.iter().map(|v| v[c]).collect::<Vec<_>>(), doc.depth));
}
merged.extend(encode_samples(&comp.iter().map(|p| p[3]).collect::<Vec<_>>(), 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,