codecs, meta: read PSD header and image resources with craft-psd (#4167)

This commit is contained in:
Dylan M. Taylor committed 2026-11-14 00:09:58 +00:00
1 parent 264330d7e9
commit 9cd6817c3b
7 files changed
+114 -134

No files matched your search

Generated
+33
View File
@@ -1251,6 +1251,17 @@ dependencies = [
"serde",
]
[[package]]
name = "craft-psd"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=68b8171b0d2c133d4a99ed3ae621e9ebb74a703f#68b8171b0d2c133d4a99ed3ae621e9ebb74a703f"
dependencies = [
"encoding_rs",
"flate2",
"rayon",
"thiserror 2.0.21",
]
[[package]]
name = "craft-tiff"
version = "0.1.0"
@@ -1817,6 +1828,20 @@ dependencies = [
"bytemuck",
]
[[package]]
name = "encoding_rs"
version = "0.8.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "89253175e704ab869b04f9db224d38630e0211a53841a79181deae0889e169f5"
dependencies = [
"cfg-if",
"core_detect",
"multiversion_no_op",
"rustversion",
"scopeguard",
"simdutf8",
]
[[package]]
name = "endi"
version = "1.1.1"
@@ -3708,6 +3733,7 @@ dependencies = [
"bytemuck",
"craft-gainmap",
"craft-heif",
"craft-psd",
"dhat",
"image",
"image-webp",
@@ -3952,6 +3978,7 @@ dependencies = [
"chrono",
"craft-heif",
"craft-metadata",
"craft-psd",
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=430a908f68819bf23d14fe73ab9b18d8f4fd4e5d)",
"lightcraft-geom",
"proptest",
@@ -4331,6 +4358,12 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "multiversion_no_op"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d"
[[package]]
name = "naga"
version = "30.0.1"
+2
View File
@@ -21,6 +21,8 @@ craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.
craft-window = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", features = ["egui"] }
# HDR gain maps: ISO 21496-1 and hdrgm metadata, compute and apply (moved from crates/codecs; craft-libs#904).
craft-gainmap = { git = "https://github.com/storytold/craft-libs", rev = "430a908f68819bf23d14fe73ab9b18d8f4fd4e5d" }
# PSD/PSB: the header, colour mode data and image resources (craft-libs#885).
craft-psd = { git = "https://github.com/storytold/craft-libs", rev = "68b8171b0d2c133d4a99ed3ae621e9ebb74a703f" }
# internal
lightcraft-denoise-core = { path = "crates/denoise-core" }
lightcraft-denoise = { path = "crates/denoise", default-features = false }
+1
View File
@@ -13,6 +13,7 @@ lightcraft-geom = { workspace = true }
lightcraft-color = { workspace = true }
lightcraft-raster = { workspace = true }
craft-gainmap = { workspace = true }
craft-psd = { workspace = true }
craft-heif = { workspace = true, optional = true }
serde = { workspace = true }
bytemuck = { workspace = true }
+67 -77
View File
@@ -40,36 +40,51 @@ impl<'a> Rd<'a> {
}
}
pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {
let mut r = Rd { b: bytes, p: 0 };
if r.take(4)? != b"8BPS" {
return Err(err("bad signature"));
}
let version = r.u16()?;
let psb = match version {
1 => false,
2 => true,
_ => return Err(err("bad version")),
};
r.take(6)?;
let channels = r.u16()? as usize;
let height = r.u32()? as usize;
let width = r.u32()? as usize;
let depth = r.u16()?;
let mode = r.u16()?;
check_size(F, width as u64, height as u64, opts)?;
if channels == 0 || channels > 56 {
return Err(err("bad channel count"));
}
/// The header (`craft-psd`), colour mode data and image resources, with a reader at the layer and mask section.
struct Start<'a> {
psb: bool,
channels: usize,
width: usize,
height: usize,
depth: u16,
mode: u16,
color_mode_data: &'a [u8],
resources: Vec<craft_psd::ImageResource>,
r: Rd<'a>,
}
// Colour mode data (palette for indexed).
fn start<'a>(bytes: &'a [u8], opts: &DecodeOptions) -> Result<Start<'a>> {
// the size limit first, from the header's fixed fields, so an oversized file is `TooLarge` as for other formats
if let (Some(&[h0, h1, h2, h3]), Some(&[w0, w1, w2, w3])) = (bytes.get(14..18), bytes.get(18..22)) {
check_size(F, u64::from(u32::from_be_bytes([w0, w1, w2, w3])), u64::from(u32::from_be_bytes([h0, h1, h2, h3])), opts)?;
}
let h = craft_psd::Header::from_bytes(bytes).map_err(|e| match e {
craft_psd::PsdError::UnexpectedEof { .. } => err("truncated"),
e => err(&e.to_string()),
})?;
let mut r = Rd { b: bytes, p: 26 };
let cm_len = r.u32()? as usize;
let color_mode_data = r.take(cm_len)?;
// Image resources.
let res_len = r.u32()? as usize;
let res = r.take(res_len)?;
let (icc, exif, xmp) = resources(res);
r.take(res_len)?;
// a resource section that doesn't parse is left out: the picture still decodes, without its profile and metadata
let resources = craft_psd::Head::from_bytes(bytes).map(|head| head.resources).unwrap_or_default();
Ok(Start {
psb: h.version.is_psb(),
channels: usize::from(h.channels),
width: h.width as usize,
height: h.height as usize,
depth: h.depth,
mode: h.color_mode.as_u16(),
color_mode_data,
resources,
r,
})
}
pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {
let Start { psb, channels, width, height, depth, mode, color_mode_data, resources: res, mut r } = start(bytes, opts)?;
let (icc, exif, xmp) = resources(&res);
// Layer and mask information: only the layer count sign matters (merged transparency).
let lm_len = if psb { r.u64()? } else { u64::from(r.u32()?) };
@@ -342,29 +357,8 @@ fn packbits(src: &[u8], out: &mut Vec<u8>) {
/// depth, colour mode or compression, or merged image data that runs past the end of the file
/// (truncated). The run-length data itself is not unpacked.
pub(crate) fn header(bytes: &[u8]) -> Result<(u32, u32, u16)> {
let mut r = Rd { b: bytes, p: 0 };
if r.take(4)? != b"8BPS" {
return Err(err("bad signature"));
}
let psb = match r.u16()? {
1 => false,
2 => true,
_ => return Err(err("bad version")),
};
r.take(6)?;
let channels = r.u16()? as usize;
let height = r.u32()? as usize;
let width = r.u32()? as usize;
let depth = r.u16()?;
let mode = r.u16()?;
check_size(F, width as u64, height as u64, &DecodeOptions::default())?;
if channels == 0 || channels > 56 {
return Err(err("bad channel count"));
}
let cm_len = r.u32()? as usize;
let color_mode_data = r.take(cm_len)?;
let res_len = r.u32()? as usize;
let (_, exif, _) = resources(r.take(res_len)?);
let Start { psb, channels, width, height, depth, mode, color_mode_data, resources: res, mut r } = start(bytes, &DecodeOptions::default())?;
let (_, exif, _) = resources(&res);
let lm_len = if psb { r.u64()? as usize } else { r.u32()? as usize };
r.take(lm_len)?;
let compression = r.u16()?;
@@ -444,28 +438,12 @@ fn unpackbits(mut src: &[u8], row: &mut [u8]) -> Result<()> {
Ok(())
}
fn resources(mut b: &[u8]) -> (Option<Vec<u8>>, Option<Vec<u8>>, Option<String>) {
let (mut icc, mut exif, mut xmp) = (None, None, None);
while b.len() >= 12 && &b[0..4] == b"8BIM" {
let id = u16::from_be_bytes([b[4], b[5]]);
let name_len = b[6] as usize;
let name_total = (1 + name_len + 1) & !1;
let p = 6 + name_total;
if p + 4 > b.len() {
break;
}
let size = u32::from_be_bytes([b[p], b[p + 1], b[p + 2], b[p + 3]]) as usize;
let start = p + 4;
let Some(data) = start.checked_add(size).and_then(|end| b.get(start..end)) else { break };
match id {
1039 => icc = Some(data.to_vec()),
1058 => exif = Some(if data.starts_with(b"Exif\0\0") { data[6..].to_vec() } else { data.to_vec() }),
1060 => xmp = Some(String::from_utf8_lossy(data).trim_end_matches('\0').to_string()),
_ => {}
}
let next = start + ((size + 1) & !1);
b = b.get(next..).unwrap_or(&[]);
}
/// ICC (1039), EXIF (1058, without its optional `Exif\0\0` prefix) and XMP (1060) resources; the last of each id.
fn resources(res: &[craft_psd::ImageResource]) -> (Option<Vec<u8>>, Option<Vec<u8>>, Option<String>) {
let last = |id: u16| res.iter().rev().find(|r| r.id == id).map(|r| r.data.as_slice());
let icc = last(1039).map(<[u8]>::to_vec);
let exif = last(1058).map(|d| d.strip_prefix(b"Exif\0\0").unwrap_or(d).to_vec());
let xmp = last(1060).map(|d| String::from_utf8_lossy(d).trim_end_matches('\0').to_string());
(icc, exif, xmp)
}
@@ -514,8 +492,8 @@ mod tests {
#[test]
fn huge_rle_with_truncated_count_table_is_rejected_before_allocating() {
// 1 × 2^30 px, 56 channels: the row table alone would be 56 Gi entries; the file has 4 bytes.
let mut b = header(56, 1, 1 << 30, 32, 3, 1);
// 1 × 300 000 px, 56 channels: the row table alone would be 16.8 M entries; the file has 4 bytes.
let mut b = header(56, 1, 300_000, 32, 3, 1);
b.extend_from_slice(&[0, 0, 0, 0]);
let e = decode(&b, &DecodeOptions::default()).unwrap_err();
assert!(matches!(e, Error::Malformed(_, ref m) if m == "truncated"), "{e:?}");
@@ -523,18 +501,30 @@ mod tests {
#[test]
fn huge_rle_of_empty_rows_is_rejected_before_allocating() {
// 2^30 × 1 px RGB at 32 bits: every row count is 0, which used to zero-pad 3 × 4 GiB.
let mut b = header(3, 1 << 30, 1, 32, 3, 1);
// 300 000 × 1 px RGB at 32 bits: every row count is 0, which used to zero-pad 3 × 1.2 MB.
let mut b = header(3, 300_000, 1, 32, 3, 1);
b.extend_from_slice(&[0; 6]);
let e = decode(&b, &DecodeOptions::default()).unwrap_err();
assert!(matches!(e, Error::Malformed(_, ref m) if m.contains("too short")), "{e:?}");
// 1 Gpx RGB 8-bit whose (plausible) row counts claim more data than the file holds.
let mut b = header(3, 1 << 20, 1 << 10, 8, 3, 1);
// 0.27 Gpx RGB 8-bit whose (plausible) row counts claim more data than the file holds.
let mut b = header(3, 1 << 18, 1 << 10, 8, 3, 1);
b.extend_from_slice(&[0xFF; 3 * 1024 * 2]);
let e = decode(&b, &DecodeOptions::default()).unwrap_err();
assert!(matches!(e, Error::Malformed(_, ref m) if m == "truncated"), "{e:?}");
}
#[test]
fn a_damaged_resource_section_is_left_out() {
// a resource section of 4 bytes that is not an `8BIM` record: the picture decodes without it
let mut b = header(3, 1, 1, 8, 3, 0);
b[30..34].copy_from_slice(&4u32.to_be_bytes());
b.splice(34..34, *b"JUNK");
b.extend_from_slice(&[1, 2, 3]);
let d = decode(&b, &DecodeOptions::default()).unwrap();
assert_eq!((d.width, d.height, d.icc.is_none()), (1, 1, true));
assert_eq!(super::header(&b).unwrap(), (1, 1, 1));
}
#[test]
fn rle_repeat_run_past_row_width_is_an_error() {
// 4 × 1 gray 8-bit; the single row is a 128-byte repeat run.
+3 -1
View File
@@ -1495,8 +1495,10 @@ mod tests {
section.push(0);
}
}
// a valid header: one RGB pixel, 8 bits
let mut p = b"8BPS\0\x01".to_vec();
p.resize(26, 0);
p.resize(12, 0);
p.extend_from_slice(&[0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 8, 0, 3]);
p.extend_from_slice(&(colour as u32).to_be_bytes());
p.resize(p.len() + colour, 0);
p.extend_from_slice(&(section.len() as u32).to_be_bytes());
+1
View File
@@ -11,6 +11,7 @@ workspace = true
[dependencies]
craft-tiff = { workspace = true }
craft-metadata = { workspace = true }
craft-psd = { workspace = true }
lightcraft-geom = { workspace = true }
serde = { workspace = true }
quick-xml = { workspace = true }
+7 -56
View File
@@ -2,73 +2,24 @@
use crate::container::Embedded;
struct Reader<'a> {
bytes: &'a [u8],
offset: usize,
}
impl<'a> Reader<'a> {
fn take(&mut self, length: usize) -> Option<&'a [u8]> {
let end = self.offset.checked_add(length)?;
let bytes = self.bytes.get(self.offset..end)?;
self.offset = end;
Some(bytes)
}
fn u16(&mut self) -> Option<u16> {
let bytes = self.take(2)?;
Some(u16::from_be_bytes([*bytes.first()?, *bytes.get(1)?]))
}
fn u32(&mut self) -> Option<u32> {
let bytes = self.take(4)?;
Some(u32::from_be_bytes([*bytes.first()?, *bytes.get(1)?, *bytes.get(2)?, *bytes.get(3)?]))
}
}
pub(crate) fn embedded(bytes: &[u8]) -> Embedded {
parse(bytes).unwrap_or_default()
}
/// The EXIF (1058) and XMP (1060) resources of the head `craft-psd` reads (header, colour mode data, image
/// resources). `None` for a head that does not parse, a second EXIF or XMP resource, or XMP that is not UTF-8.
pub(crate) fn parse(bytes: &[u8]) -> Option<Embedded> {
let mut reader = Reader { bytes, offset: 0 };
if reader.take(4)? != b"8BPS" || !matches!(reader.u16()?, 1 | 2) {
return None;
}
// The fixed header after the version is reserved bytes, channels, dimensions, depth and colour mode.
reader.take(6 + 2 + 4 + 4 + 2 + 2)?;
let colour_mode_length = usize::try_from(reader.u32()?).ok()?;
reader.take(colour_mode_length)?;
let resource_length = usize::try_from(reader.u32()?).ok()?;
let resources = reader.take(resource_length)?;
parse_resources(resources)
}
fn parse_resources(bytes: &[u8]) -> Option<Embedded> {
let mut reader = Reader { bytes, offset: 0 };
let head = craft_psd::Head::from_bytes(bytes).ok()?;
let (mut exif, mut xmp) = (None, None);
while reader.offset < bytes.len() {
if reader.take(4)? != b"8BIM" {
return None;
}
let id = reader.u16()?;
let name_length = usize::from(*reader.take(1)?.first()?);
let pascal_length = 1usize.checked_add(name_length)?.checked_add(1)? & !1;
reader.take(pascal_length.checked_sub(1)?)?;
let data_length = usize::try_from(reader.u32()?).ok()?;
let data = reader.take(data_length)?;
if !data_length.is_multiple_of(2) {
reader.take(1)?;
}
match id {
for r in &head.resources {
match r.id {
1058 if exif.is_some() => return None,
1058 => exif = Some(data),
1058 => exif = Some(r.data.as_slice()),
1060 if xmp.is_some() => return None,
1060 => xmp = Some(std::str::from_utf8(data).ok()?),
1060 => xmp = Some(std::str::from_utf8(&r.data).ok()?),
_ => {}
}
}
Some(Embedded {
exif: exif.map(crate::strip_exif_header).map(<[u8]>::to_vec),
xmp: xmp.map(|text| text.trim_end_matches('\0').to_string()),