mirror of
https://github.com/storytold/effectcraft.git
synced 2026-11-16 15:22:43 +00:00
psd: keep layers past a damaged resource, report an unreadable Lr16 block
This commit is contained in:
1 parent
1cc80e7443
commit
59671cfd29
2 files changed
+105
-11
No files matched your search
+57
-11
@@ -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<u8>, 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<craft_psd::PsdFile, craft_psd::PsdError>, 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 {
|
||||
|
||||
@@ -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<u8> {
|
||||
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);
|
||||
}
|
||||
Reference in new issue
Block a user