diff --git a/crates/psd/src/parse.rs b/crates/psd/src/parse.rs index 6ed618a47..b1f8b6b6d 100644 --- a/crates/psd/src/parse.rs +++ b/crates/psd/src/parse.rs @@ -19,13 +19,11 @@ impl Psd { if !is_psd(&data) { return Err(Error::NotPsd); } - let source = craft_psd::source::Source::new(data.clone()); - // Linked-file blocks can be most of a file: leave them in the source, read in place. - let linked = |key: &[u8; 4], _len: u64| matches!(key, b"lnk2" | b"lnkD" | b"lnk3" | b"lnkE"); - let (head, file, warnings) = match craft_psd::PsdFile::from_source_deferring(source, linked, |_| Ok(false), |_| false) { - Ok((file, _)) => { + let (read, shift) = read_file(&data); + let (head, file, warnings) = match read { + Ok(file) => { // The compression field before the merged image's data. - let merged = file.image_data.stored.as_ref().map_or(data.len(), |s| (s.offset as usize).saturating_sub(2)); + let merged = file.image_data.stored.as_ref().map_or(data.len(), |s| ((s.offset + shift) as usize).saturating_sub(2)); ((file.header.clone(), file.color_mode_data.clone(), merged), Some(file), vec![]) } // A damaged layer section must not discard the document: keep the header and the @@ -60,14 +58,23 @@ impl Psd { data: data.clone(), merged_offset, }; - let Some(file) = file else { return Ok(psd) }; + let Some(file) = file else { + psd.merged_alpha = section_merged_alpha(&data); + return Ok(psd); + }; + if let Some((block, e)) = file.unreadable_layer_block() { + // A 16/32-bit file's layers live in a global block; when it is damaged the file reads + // as flattened. Its layer count still says whether the merged image has alpha. + psd.merged_alpha = block.data.get(..2).is_some_and(|c| i16::from_be_bytes([c[0], c[1]]) < 0); + psd.warnings.push(format!("Layers could not be read ({}); only the flattened image is available", error(&e))); + } if let Some(info) = &file.layer_info { psd.merged_alpha = info.merged_alpha; - psd.layers = info.layers.iter().enumerate().map(|(i, rec)| psd.layer(rec, i)).collect(); + psd.layers = info.layers.iter().enumerate().map(|(i, rec)| psd.layer(rec, i, shift)).collect(); } for b in &file.global_blocks { if let Some(stored) = b.stored.as_ref().filter(|_| linked(&b.key, 0)) { - let start = stored.offset as usize; + let start = (stored.offset + shift) as usize; psd.linked_files(&data, start, start.saturating_add(stored.len as usize).min(data.len())); } } @@ -75,13 +82,14 @@ impl Psd { } /// One layer record of the model, its additional information read into [`Layer`]. - fn layer(&self, rec: &craft_psd::LayerRecord, index: usize) -> Layer { + /// `shift` moves craft-psd's offsets back into `self.data` (see [`read_file`]). + fn layer(&self, rec: &craft_psd::LayerRecord, index: usize, shift: u64) -> Layer { let channels = rec .channels .iter() .map(|c| match &c.stored { // `ChannelInfo` covers the compression field and the data after it. - Some(s) => ChannelInfo { id: c.id, offset: (s.offset as usize).saturating_sub(2), len: s.len as usize + 2 }, + Some(s) => ChannelInfo { id: c.id, offset: ((s.offset + shift) as usize).saturating_sub(2), len: s.len as usize + 2 }, None => ChannelInfo { id: c.id, offset: 0, len: 0 }, }) .collect(); @@ -419,6 +427,44 @@ fn flattened(data: &[u8]) -> Option<(craft_psd::Header, Vec, usize)> { (merged.checked_add(2)? <= data.len()).then(|| (head.header.clone(), head.color_mode_data.to_vec(), merged)) } +/// Linked-file blocks can be most of a file: leave them in the source, read in place. +fn linked(key: &[u8; 4], _len: u64) -> bool { + matches!(key, b"lnk2" | b"lnkD" | b"lnk3" | b"lnkE") +} + +/// Reads `data` with craft-psd. The image resources are not part of the model, so when the file +/// does not read, it is read again with an empty resource section: a damaged resource must not +/// cost the layers. The second value is how far that copy's offsets sit before `data`'s. +fn read_file(data: &Arc<[u8]>) -> (std::result::Result, u64) { + let read = |d: Arc<[u8]>| craft_psd::PsdFile::from_source_deferring(craft_psd::source::Source::new(d), linked, |_| Ok(false), |_| false).map(|(f, _)| f); + let first = read(data.clone()); + let be32 = |at: usize| data.get(at..at.checked_add(4)?).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]) as usize); + if first.is_ok() { + return (first, 0); + } + let Some(res_at) = be32(26).and_then(|cmd| cmd.checked_add(30)) else { return (first, 0) }; + let Some(res_len) = be32(res_at).filter(|&n| n > 0) else { return (first, 0) }; + let Some(rest) = res_at.checked_add(4 + res_len).and_then(|end| data.get(end..)) else { return (first, 0) }; + let mut copy = Vec::with_capacity(res_at + 4 + rest.len()); + copy.extend_from_slice(&data[..res_at]); + copy.extend_from_slice(&[0; 4]); + copy.extend_from_slice(rest); + match read(copy.into()) { + Ok(file) => (Ok(file), res_len as u64), + Err(_) => (first, 0), + } +} + +/// Whether the layer section's (unreadable) layer count is negative, which marks the merged +/// image's first extra channel as its transparency. +fn section_merged_alpha(data: &[u8]) -> bool { + let Ok(head) = craft_psd::head::HeadView::from_bytes(data) else { return false }; + let field = if head.header.version.is_psb() { 8 } else { 4 }; + let Some(at) = usize::try_from(head.layer_section_offset).ok().and_then(|a| a.checked_add(2 * field)) else { return false }; + let has_info = data.get(at - field..at).is_some_and(|l| l.iter().any(|&b| b != 0)); + has_info && data.get(at..at + 2).is_some_and(|c| i16::from_be_bytes([c[0], c[1]]) < 0) +} + /// This crate's error for one from craft-psd. fn error(e: &craft_psd::PsdError) -> Error { match e { diff --git a/crates/psd/src/tests/shared_corpus.rs b/crates/psd/src/tests/shared_corpus.rs index c6a6814d5..59d05271e 100644 --- a/crates/psd/src/tests/shared_corpus.rs +++ b/crates/psd/src/tests/shared_corpus.rs @@ -59,3 +59,51 @@ fn a_damaged_layer_section_keeps_the_merged_image() { assert!(p.warnings.iter().any(|w| w.contains("Layers could not be read")), "{:?}", p.warnings); assert!(p.composite().is_ok()); } + +/// The first generated case that is layered and passes `keep`, with its bytes. +fn layered(keep: impl Fn(&craft_psd::PsdFile) -> bool) -> Vec { + let case = craft_psd::testgen::all_cases() + .into_iter() + .find(|c| c.file.layer_info.as_ref().is_some_and(|l| !l.layers.is_empty()) && keep(&c.file)) + .expect("a layered case"); + case.file.to_bytes().expect("write") +} + +#[test] +fn a_damaged_resource_keeps_the_layers() { + let intact = layered(|f| f.header.depth == 8 && !f.resources.is_empty()); + let want = Psd::parse(intact.clone()).expect("intact"); + let mut bytes = intact; + // The first resource: signature, id, padded Pascal name, then its length, made to run off the end. + let res_at = 30 + u32::from_be_bytes(bytes[26..30].try_into().unwrap()) as usize; + let name = 1 + usize::from(bytes[res_at + 4 + 6]); + let len_at = res_at + 4 + 6 + name + name % 2; + bytes[len_at..len_at + 4].copy_from_slice(&0x7fff_fff0u32.to_be_bytes()); + let p = Psd::parse(bytes).expect("parse"); + assert!(p.warnings.is_empty(), "{:?}", p.warnings); + assert_eq!(p.layers.len(), want.layers.len()); + assert_eq!(p.merged_alpha, want.merged_alpha); + assert_eq!(p.composite().expect("composite").data, want.composite().expect("composite").data); + for i in 0..p.layers.len() { + assert_eq!(p.layers[i].name, want.layers[i].name); + assert_eq!(p.layer_pixels(i, false).map(|l| l.data).ok(), want.layer_pixels(i, false).map(|l| l.data).ok(), "layer {i}"); + } +} + +#[test] +fn a_damaged_16_bit_layer_block_is_reported() { + let intact = layered(|f| f.header.depth == 16 && matches!(f.layer_info_placement, craft_psd::LayerInfoPlacement::GlobalBlock { .. })); + let want = Psd::parse(intact.clone()).expect("intact"); + assert!(want.merged_alpha, "the generated 16-bit cases carry merged alpha"); + let mut bytes = intact; + let at = bytes.windows(8).position(|w| w == b"8BIMLr16").expect("Lr16 block"); + let psb = want.psb; + // Block header, then the layer count and the first record's rect: its channel count follows. + let channels = at + 8 + if psb { 8 } else { 4 } + 2 + 16; + bytes[channels..channels + 2].copy_from_slice(&u16::MAX.to_be_bytes()); + let p = Psd::parse(bytes).expect("flattened"); + assert!(p.layers.is_empty()); + assert!(p.warnings.iter().any(|w| w.contains("Layers could not be read")), "{:?}", p.warnings); + assert_eq!(p.merged_alpha, want.merged_alpha); + assert_eq!(p.composite().expect("composite").data, want.composite().expect("composite").data); +}