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,