Files
craft-libs/crates/psd/src/resources.rs
T
Dylan M. TaylorandOmar Saidahmed 40ff186888 craft-psd: linked-layer record editing, the thumbnail header and brst (from PhotoCraft's crates/io) (#1054)
* craft-psd: Photoshop PSD/PSB reader and writer, moved from PhotoCraft

PhotoCraft's `photocraft-psd` crate (crates/psd at storytold/photocraft
63b641b55e54bf8f5c83efd977fdb16a2c255431) as `craft-psd`: the lossless
PSD/PSB model, reader, writer and builder, descriptors, the Photoshop
resource files that share its primitives (.abr, .asl, .aco, .act, .ase,
.grd, .pat, .atn, .csh, .shc) and the Photoshop blocks of a layered TIFF.
The crate had no dependency on any other PhotoCraft crate.

Code is unchanged apart from the crate name, craft-libs' rustfmt width,
comments that named other PhotoCraft crates, issue references (now
`photocraft#N`), and the corpus tests' directory (`CRAFT_PSD_CORPUS` or
`corpus/` at the workspace root). Tests, proptests, fuzz targets and
fixtures move with it.

Part of #778, #786.

* craft-psd: engine_data, the text engine document of type layers

The EngineData reader and writer from PhotoCraft's photocraft-text
(crates/text/src/engine_data.rs at storytold/photocraft 63b641b5): a
tree of values that is written back in Photoshop's layout, with strings
stored as plain bytes kept as plain bytes.

From EffectCraft's effectcraft-psd (crates/psd/src/engine_data.rs at
storytold/effectcraft 072e1af9), ported onto that tree: `first_style`,
the first style run as a typed `TextStyle` with bounded sizes and
spacings, and `minimal`, a one-run document for writers and fixtures.
`Value::index` is new.

Both apps had their own parser for the same syntax.

* craft-psd: engine_data::parse_lossy reads what it can of a damaged document

EffectCraft's EngineData reader was best effort: a truncated or damaged
document still gave the text and style it held. `parse_lossy` does that
on the same parser: a truncated dictionary, array or string keeps what
it has, a byte that starts no key is skipped, a token that is no number
becomes a name, and garbage gives an empty dictionary. `parse` stays
strict and is unchanged in what it accepts.

The parser's `value` is split into one function per kind of value, and
reads with `get` instead of indexing.

* craft-psd: typed views of type layers, smart objects and adjustments

Read-only views EffectCraft's effectcraft-psd had over the blocks this
crate keeps raw (storytold/effectcraft f334bcf3, crates/psd/src/parse.rs
and placed.rs). The blocks stay raw and write back unchanged.

- `text`: `TypeLayer` from `TySh`: text, transform (the identity when not
  finite), bounds, the first style run (read with
  `engine_data::parse_lossy`) and the text descriptor.
  `LayerRecord::type_layer`.
- `smart`: `SmartObject` from `SoLd`/`SoLE` (id, quad, non-affine
  transform, size, warp) and `PlLd`; `Warp` with the named styles and the
  custom quilt mesh; the quad geometry (`map`, `placed_bounds`,
  `placed_size`, `bake_scale`, `placement`). `LinkedFile` and
  `linked_files` for `lnk2`/`lnkD`/`lnk3`/`lnkE`, `PsdFile::linked_files`
  and `PsdFile::linked_data`. `LayerRecord::smart_object`.
- `adjust`: `Adjustment` from `nvrt`, `brit`, `CgEd`, `hue2`/`hue `,
  `levl`, `expA`, and the other adjustment keys by name;
  `LayerRecord::adjustment`, `solid_color` (`SoCo`) and `effects` (`lfx2`).
- `Descriptor`: `object`, `number`, `numbers`, `boolean`, `text`,
  `enumerated`, `raw_data`, `color`; `Value::as_number`.

Linked-file data is a range of the block's data, checked against the
record, instead of a range of the whole file.

* craft-psd: shared descriptor lookups

Descriptor::get_bool, get_number, get_text, get_enum and get_object,
used by asl, grd and slices in place of their own copies.

Ported from storytold/photocraft#9552 (its crates/psd part).

* craft-psd: the typed views use the shared descriptor lookups

One set of Descriptor accessors: the get_* lookups from photocraft#9552.
numbers, raw_data and color move next to them as get_numbers,
get_raw_data and get_color.

* craft-psd: linked-layer record editing, the thumbnail header and brst

Format code that PhotoCraft keeps in crates/io (linked.rs,
psd_thumbnail.rs, blocks.rs at storytold/photocraft f1b5e7d7), moved
here without the document mapping:

- smart: `file_type`, `encode_embedded_file` (a version-7 liFD record),
  `linked_records`, `linked_uuids`, `rebuild_linked_block`,
  `select_linked_records` (exact UTF-8 ids, cut selected records are an
  error), `contains_linked_record`, `copy_linked_record`.
- resources: `Thumbnail` reads the 1036/1033 header, and
  `Thumbnail::jfif_bytes` writes it as Photoshop does.
- tagged: `channel_restrictions` / `channel_restrictions_data` for brst.

PhotoCraft's tests for these functions move with them.

---------

Co-authored-by: Omar Saidahmed <osaidahm@uwaterloo.ca>
2026-11-11 21:35:45 -05:00

525 lines
20 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Image resources section (`8BIM` resource blocks).
use crate::descriptor::UnicodeString;
use crate::error::{PsdError, Result};
use crate::io::{Reader, WriteExt, read_pascal, write_pascal};
/// Well-known resource ids.
pub mod ids {
/// Resolution info (`ResolutionInfo` structure).
pub const RESOLUTION_INFO: u16 = 1005;
/// Target layer index.
pub const LAYER_STATE: u16 = 1024;
/// Layer group ids (one u16 per layer).
pub const LAYER_GROUP_INFO: u16 = 1026;
/// Legacy (Photoshop 4) thumbnail, BGR.
pub const THUMBNAIL_PS4: u16 = 1033;
/// Thumbnail (JFIF).
pub const THUMBNAIL: u16 = 1036;
/// Global lighting angle.
pub const GLOBAL_ANGLE: u16 = 1037;
/// ICC profile.
pub const ICC_PROFILE: u16 = 1039;
/// Global altitude.
pub const GLOBAL_ALTITUDE: u16 = 1049;
/// Version info (has real merged data flag).
pub const VERSION_INFO: u16 = 1057;
/// EXIF data 1.
pub const EXIF: u16 = 1058;
/// XMP metadata.
pub const XMP: u16 = 1060;
/// Document timeline settings (versioned descriptor).
pub const TIMELINE_INFO: u16 = 1075;
/// Selected layer ids (`u16` count followed by `u32` ids).
pub const LAYER_SELECTION_IDS: u16 = 1069;
}
/// One image resource block.
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ImageResource {
/// Signature, normally `8BIM` (also `MeSa`, `AgHg`, `PHUT`, `DCSR` seen in the wild).
pub signature: [u8; 4],
/// Resource id.
pub id: u16,
/// Pascal name bytes (usually empty).
pub name: Vec<u8>,
/// Resource data (without the even padding).
pub data: Vec<u8>,
}
/// Fixed-point resolution info (resource 1005).
///
/// `h_res_fixed` and `v_res_fixed` are always pixels per inch (16.16 fixed).
/// `h_res_unit` and `v_res_unit` only say how to display that number
/// (1 = pixels/inch, 2 = pixels/cm) and do not rescale the stored value.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ResolutionInfo {
/// Horizontal resolution, 16.16 fixed point, always pixels per inch.
pub h_res_fixed: u32,
/// Display unit for the horizontal resolution (1 = px/in, 2 = px/cm).
pub h_res_unit: u16,
/// Ruler unit for width (1 in, 2 cm, 3 pt, 4 pica, 5 column).
pub width_unit: u16,
/// Vertical resolution, 16.16 fixed point, always pixels per inch.
pub v_res_fixed: u32,
/// Display unit for the vertical resolution (1 = px/in, 2 = px/cm).
pub v_res_unit: u16,
/// Ruler unit for height (1 in, 2 cm, 3 pt, 4 pica, 5 column).
pub height_unit: u16,
}
impl ResolutionInfo {
/// Resolution info for `dpi` pixels per inch in both directions.
pub fn from_dpi(dpi: f64) -> Self {
let f = (dpi * 65536.0).round().clamp(0.0, u32::MAX as f64) as u32;
ResolutionInfo { h_res_fixed: f, h_res_unit: 1, width_unit: 1, v_res_fixed: f, v_res_unit: 1, height_unit: 1 }
}
/// Horizontal resolution in pixels per inch.
pub fn h_res(&self) -> f64 {
f64::from(self.h_res_fixed) / 65536.0
}
/// Vertical resolution in pixels per inch.
pub fn v_res(&self) -> f64 {
f64::from(self.v_res_fixed) / 65536.0
}
/// Parses 16 bytes.
pub fn from_bytes(b: &[u8]) -> Result<Self> {
let mut r = Reader::new(b);
Ok(ResolutionInfo {
h_res_fixed: r.u32()?,
h_res_unit: r.u16()?,
width_unit: r.u16()?,
v_res_fixed: r.u32()?,
v_res_unit: r.u16()?,
height_unit: r.u16()?,
})
}
/// Serializes to 16 bytes.
pub fn to_bytes(&self) -> Vec<u8> {
let mut v = Vec::with_capacity(16);
v.put_u32(self.h_res_fixed);
v.put_u16(self.h_res_unit);
v.put_u16(self.width_unit);
v.put_u32(self.v_res_fixed);
v.put_u16(self.v_res_unit);
v.put_u16(self.height_unit);
v
}
}
/// Version info (resource 1057).
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VersionInfo {
/// Version (1).
pub version: u32,
/// `false` when the merged image is a placeholder.
pub has_real_merged_data: bool,
/// Writer application name.
pub writer: UnicodeString,
/// Reader application name.
pub reader: UnicodeString,
/// File version.
pub file_version: u32,
}
impl VersionInfo {
/// Parses resource data.
pub fn from_bytes(b: &[u8]) -> Result<Self> {
let mut r = Reader::new(b);
Ok(VersionInfo {
version: r.u32()?,
has_real_merged_data: r.u8()? != 0,
writer: UnicodeString::read(&mut r)?,
reader: UnicodeString::read(&mut r)?,
file_version: r.u32()?,
})
}
/// Serializes.
pub fn to_bytes(&self) -> Vec<u8> {
let mut v = Vec::new();
v.put_u32(self.version);
v.put_u8(u8::from(self.has_real_merged_data));
self.writer.write(&mut v);
self.reader.write(&mut v);
v.put_u32(self.file_version);
v
}
}
/// The thumbnail resource (1036; 1033 in Photoshop 4, whose samples are BGR): a 28-byte
/// big-endian header and the image data (Adobe's specification, "Thumbnail resource format").
/// Photoshop writes format 1 (JFIF), 24 bits per pixel, one plane, with the long side at 160
/// pixels or less.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Thumbnail<'a> {
/// 1 for JFIF (`kJpegRGB`), 0 for raw RGB (`kRawRGB`).
pub format: u32,
/// Width in pixels.
pub width: u32,
/// Height in pixels.
pub height: u32,
/// Bits per pixel (24).
pub bits_per_pixel: u16,
/// Planes (1).
pub planes: u16,
/// The image data after the header: a JFIF stream for format 1.
pub data: &'a [u8],
}
impl<'a> Thumbnail<'a> {
/// Length of the header in front of the image data.
pub const HEADER_LEN: usize = 28;
/// Longest side Photoshop gives a thumbnail.
pub const MAX_SIDE: u32 = 160;
/// Reads a thumbnail resource's data. Its sizes are not checked against the image data,
/// which a reader decodes on its own.
pub fn from_bytes(data: &'a [u8]) -> Result<Self> {
let mut r = Reader::new(data);
let format = r.u32()?;
let (width, height) = (r.u32()?, r.u32()?);
// Width bytes, total size and compressed size: derived values a reader recomputes.
r.skip(12)?;
let (bits_per_pixel, planes) = (r.u16()?, r.u16()?);
Ok(Thumbnail { format, width, height, bits_per_pixel, planes, data: r.peek_rest() })
}
/// The data of a JFIF thumbnail resource for a `width`×`height` image: the header as
/// Photoshop writes it (width bytes padded to 4, total size, compressed size, 24 bits, one
/// plane), then `jfif`. An error when a size does not fit its 32-bit field.
pub fn jfif_bytes(width: u32, height: u32, jfif: &[u8]) -> Result<Vec<u8>> {
let too_big = || PsdError::LimitExceeded("thumbnail too large for its header");
let width_bytes = width.checked_mul(24).map(|v| v.div_ceil(32) * 4).ok_or_else(too_big)?;
let total = width_bytes.checked_mul(height).ok_or_else(too_big)?;
let compressed = u32::try_from(jfif.len()).map_err(|_| too_big())?;
let mut out = Vec::with_capacity(Self::HEADER_LEN + jfif.len());
for v in [1, width, height, width_bytes, total, compressed] {
out.put_u32(v);
}
out.put_u16(24);
out.put_u16(1);
out.put(jfif);
Ok(out)
}
}
/// Typed view of a known resource.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum ResourceData<'a> {
/// 1005
ResolutionInfo(ResolutionInfo),
/// 1024: index of the target layer.
LayerState(u16),
/// 1026: group id per layer.
LayerGroupInfo(Vec<u16>),
/// 1036 / 1033: raw thumbnail resource (28-byte header + JFIF/raw data).
Thumbnail(&'a [u8]),
/// 1037: global lighting angle in degrees.
GlobalAngle(i32),
/// 1039: ICC profile bytes.
IccProfile(&'a [u8]),
/// 1049: global altitude.
GlobalAltitude(i32),
/// 1057
VersionInfo(VersionInfo),
/// 1058: EXIF bytes.
Exif(&'a [u8]),
/// 1060: XMP packet (UTF-8).
Xmp(&'a [u8]),
/// 1075: document timeline settings; tracks and rational times remain descriptor data.
TimelineInfo(crate::VersionedDescriptor),
/// A `mani` legacy animation resource in the plug-in resource id range (4000..=4999).
Animation(crate::animation::AnimationResource<'a>),
/// 1069: selected layer ids, in their stored order. An empty list is explicit.
LayerSelectionIds(Vec<u32>),
}
/// Decodes resource 1069 after checking the complete count-derived payload before allocation.
/// The format parser preserves zero IDs, duplicates and order for the document mapper to
/// resolve; truncated data and trailing bytes are malformed rather than partial selections.
fn layer_selection_ids(data: &[u8]) -> Result<Vec<u32>> {
let mut r = Reader::new(data);
let count = r.u16()?;
r.check_count(u64::from(count), 4)?;
if r.remaining() != usize::from(count) * 4 {
return Err(PsdError::invalid("layer selection ids length does not match its count"));
}
(0..count).map(|_| r.u32()).collect()
}
impl ImageResource {
/// A new `8BIM` resource with an empty name.
pub fn new(id: u16, data: Vec<u8>) -> Self {
ImageResource { signature: *b"8BIM", id, name: Vec::new(), data }
}
/// Typed parse of well-known resources. Returns `None` for unknown ids,
/// `Some(Err)` if the data is malformed.
pub fn parsed(&self) -> Option<Result<ResourceData<'_>>> {
let d = &self.data[..];
let be_i32 = |d: &[u8]| -> Result<i32> { Reader::new(d).i32() };
Some(match self.id {
ids::RESOLUTION_INFO => ResolutionInfo::from_bytes(d).map(ResourceData::ResolutionInfo),
ids::LAYER_STATE => Reader::new(d).u16().map(ResourceData::LayerState),
ids::LAYER_GROUP_INFO => {
if !d.len().is_multiple_of(2) {
Err(PsdError::invalid("layer group info has odd length"))
} else {
Ok(ResourceData::LayerGroupInfo(d.as_chunks::<2>().0.iter().map(|c| u16::from_be_bytes([c[0], c[1]])).collect()))
}
}
ids::THUMBNAIL | ids::THUMBNAIL_PS4 => Ok(ResourceData::Thumbnail(d)),
ids::GLOBAL_ANGLE => be_i32(d).map(ResourceData::GlobalAngle),
ids::ICC_PROFILE => Ok(ResourceData::IccProfile(d)),
ids::GLOBAL_ALTITUDE => be_i32(d).map(ResourceData::GlobalAltitude),
ids::VERSION_INFO => VersionInfo::from_bytes(d).map(ResourceData::VersionInfo),
ids::EXIF => Ok(ResourceData::Exif(d)),
ids::XMP => Ok(ResourceData::Xmp(d)),
ids::TIMELINE_INFO => crate::animation::parse_descriptor(d).map(ResourceData::TimelineInfo),
4000..=4999 if d.starts_with(b"mani") => crate::animation::AnimationResource::from_bytes(d).map(ResourceData::Animation),
ids::LAYER_SELECTION_IDS => layer_selection_ids(d).map(ResourceData::LayerSelectionIds),
_ => return None,
})
}
/// XMP packet as a string (resource 1060).
pub fn xmp_str(&self) -> Option<&str> {
(self.id == ids::XMP).then(|| std::str::from_utf8(&self.data).ok()).flatten()
}
pub(crate) fn read(r: &mut Reader<'_>) -> Result<Self> {
let signature = r.array::<4>()?;
if !matches!(&signature, b"8BIM" | b"MeSa" | b"AgHg" | b"PHUT" | b"DCSR") {
return Err(PsdError::InvalidSignature { expected: "8BIM resource", found: signature });
}
let id = r.u16()?;
let name = read_pascal(r, 2)?;
let len = r.u32()?;
let data = r.bytes_u64(u64::from(len))?.to_vec();
if len % 2 == 1 {
r.skip(1)?;
}
Ok(ImageResource { signature, id, name, data })
}
pub(crate) fn write(&self, out: &mut Vec<u8>) -> Result<()> {
out.put(&self.signature);
out.put_u16(self.id);
write_pascal(out, &self.name, 2);
out.put_len(self.data.len() as u64, false)?;
out.put(&self.data);
if self.data.len() % 2 == 1 {
out.put_u8(0);
}
Ok(())
}
}
pub(crate) fn read_section(r: &mut Reader<'_>) -> Result<Vec<ImageResource>> {
let len = r.u32()?;
let mut s = r.sub(u64::from(len))?;
let mut v = Vec::new();
while !s.is_empty() {
v.push(ImageResource::read(&mut s)?);
}
Ok(v)
}
/// Serialized size of the resource section [`write_section`] writes, its length field included.
pub(crate) fn section_len(res: &[ImageResource]) -> u64 {
res.iter().fold(4u64, |n, r| {
let name = 1 + r.name.len().min(255);
let name = name + name % 2;
let data = r.data.len().saturating_add(r.data.len() % 2);
n.saturating_add((4 + 2 + name + 4) as u64).saturating_add(data as u64)
})
}
pub(crate) fn write_section(out: &mut Vec<u8>, res: &[ImageResource]) -> Result<()> {
let at = out.begin_len(false);
for r in res {
r.write(out)?;
}
out.end_len(at, false)
}
/// Builds the data for a 1057 version info resource, with the writer and reader names Photoshop
/// 2026 writes ("Adobe Photoshop", "Adobe Photoshop 2026"), without a NUL terminator.
pub fn version_info_resource(has_real_merged_data: bool) -> ImageResource {
ImageResource::new(
ids::VERSION_INFO,
VersionInfo {
version: 1,
has_real_merged_data,
writer: UnicodeString::new("Adobe Photoshop"),
reader: UnicodeString::new("Adobe Photoshop 2026"),
file_version: 1,
}
.to_bytes(),
)
}
#[cfg(test)]
mod tests {
use super::*;
fn roundtrip(res: &[ImageResource]) -> Vec<u8> {
let mut out = Vec::new();
write_section(&mut out, res).unwrap();
let back = read_section(&mut Reader::new(&out)).unwrap();
assert_eq!(back, res);
out
}
#[test]
fn empty_section() {
assert_eq!(roundtrip(&[]), vec![0, 0, 0, 0]);
}
#[test]
fn odd_data_is_padded() {
let out = roundtrip(&[ImageResource::new(1000, vec![1, 2, 3])]);
// len(4) + sig(4) + id(2) + name(2) + size(4) + data(3) + pad(1)
assert_eq!(out.len(), 4 + 4 + 2 + 2 + 4 + 4);
assert_eq!(*out.last().unwrap(), 0);
}
#[test]
fn named_resources() {
let mut r = ImageResource::new(2000, vec![9; 4]);
r.name = b"path".to_vec();
let mut r2 = ImageResource::new(2001, vec![]);
r2.name = b"abc".to_vec();
r2.signature = *b"MeSa";
roundtrip(&[r, r2]);
}
#[test]
fn bad_signature() {
let mut out = Vec::new();
write_section(&mut out, &[ImageResource::new(1, vec![])]).unwrap();
out[4] = b'X';
assert!(read_section(&mut Reader::new(&out)).is_err());
}
#[test]
fn truncation_errors() {
let mut out = Vec::new();
write_section(&mut out, &[ImageResource::new(1005, ResolutionInfo::from_dpi(72.0).to_bytes())]).unwrap();
for cut in 0..out.len() {
assert!(read_section(&mut Reader::new(&out[..cut])).is_err());
}
}
#[test]
fn typed_resolution() {
let ri = ResolutionInfo::from_dpi(300.0);
let r = ImageResource::new(ids::RESOLUTION_INFO, ri.to_bytes());
match r.parsed() {
Some(Ok(ResourceData::ResolutionInfo(p))) => {
assert_eq!(p, ri);
assert!((p.h_res() - 300.0).abs() < 1e-9);
assert!((p.v_res() - 300.0).abs() < 1e-9);
}
other => panic!("{other:?}"),
}
}
#[test]
fn typed_misc() {
let r = ImageResource::new(ids::GLOBAL_ANGLE, 120i32.to_be_bytes().to_vec());
assert_eq!(r.parsed(), Some(Ok(ResourceData::GlobalAngle(120))));
let r = ImageResource::new(ids::GLOBAL_ALTITUDE, 30i32.to_be_bytes().to_vec());
assert_eq!(r.parsed(), Some(Ok(ResourceData::GlobalAltitude(30))));
let r = ImageResource::new(ids::LAYER_STATE, vec![0, 2]);
assert_eq!(r.parsed(), Some(Ok(ResourceData::LayerState(2))));
let r = ImageResource::new(ids::LAYER_GROUP_INFO, vec![0, 1, 0, 2]);
assert_eq!(r.parsed(), Some(Ok(ResourceData::LayerGroupInfo(vec![1, 2]))));
let r = ImageResource::new(ids::LAYER_GROUP_INFO, vec![0]);
assert!(matches!(r.parsed(), Some(Err(_))));
let r = ImageResource::new(ids::ICC_PROFILE, vec![1]);
assert_eq!(r.parsed(), Some(Ok(ResourceData::IccProfile(&[1]))));
let r = ImageResource::new(ids::EXIF, vec![2]);
assert_eq!(r.parsed(), Some(Ok(ResourceData::Exif(&[2]))));
let r = ImageResource::new(ids::THUMBNAIL, vec![3]);
assert_eq!(r.parsed(), Some(Ok(ResourceData::Thumbnail(&[3]))));
let r = ImageResource::new(ids::XMP, b"<x/>".to_vec());
assert_eq!(r.xmp_str(), Some("<x/>"));
assert_eq!(ImageResource::new(4242, vec![]).parsed(), None);
}
/// Parsing preserves the stored list exactly, including zero, duplicates and deselection.
#[test]
fn typed_layer_selection_ids_preserve_empty_order_and_duplicates() {
for ids in [vec![], vec![9], vec![u32::MAX, 0, 9, 9]] {
let mut data = (ids.len() as u16).to_be_bytes().to_vec();
data.extend(ids.iter().flat_map(|id| id.to_be_bytes()));
let r = ImageResource::new(ids::LAYER_SELECTION_IDS, data);
assert_eq!(r.parsed(), Some(Ok(ResourceData::LayerSelectionIds(ids))));
roundtrip(&[r]);
}
}
/// Declared lengths must match the entire payload, including at the maximum valid count.
#[test]
fn typed_layer_selection_ids_reject_mismatched_counts_and_truncation() {
for data in [vec![], vec![0], vec![0, 1], vec![0, 1, 0, 0, 0], vec![0, 0, 0], vec![0, 0, 0, 0, 0, 1], vec![255, 255]] {
let r = ImageResource::new(ids::LAYER_SELECTION_IDS, data);
assert!(matches!(r.parsed(), Some(Err(_))), "{:?}", r.data);
}
let mut data = u16::MAX.to_be_bytes().to_vec();
data.extend((0..u32::from(u16::MAX)).flat_map(u32::to_be_bytes));
let r = ImageResource::new(ids::LAYER_SELECTION_IDS, data);
let Some(Ok(ResourceData::LayerSelectionIds(ids))) = r.parsed() else { panic!("maximum count must parse") };
assert_eq!(ids.len(), usize::from(u16::MAX));
}
#[test]
fn thumbnail_header_follows_the_spec_and_reads_back() {
let b = Thumbnail::jfif_bytes(160, 90, &[0xFF, 0xD8, 0xFF, 0xD9]).unwrap();
let u = |i: usize| u32::from_be_bytes(b[i..i + 4].try_into().unwrap());
assert_eq!((u(0), u(4), u(8), u(12), u(16), u(20)), (1, 160, 90, 480, 480 * 90, 4));
assert_eq!(&b[24..28], &[0, 24, 0, 1]);
assert_eq!(&b[28..], &[0xFF, 0xD8, 0xFF, 0xD9]);
// Width bytes are padded to 4: 3 px × 3 bytes = 9 → 12.
let odd = Thumbnail::jfif_bytes(3, 1, &[]).unwrap();
assert_eq!(u32::from_be_bytes(odd[12..16].try_into().unwrap()), 12);
let t = Thumbnail::from_bytes(&b).unwrap();
assert_eq!((t.format, t.width, t.height, t.bits_per_pixel, t.planes, t.data), (1, 160, 90, 24, 1, [0xFF, 0xD8, 0xFF, 0xD9].as_slice()));
for cut in 0..Thumbnail::HEADER_LEN {
assert!(Thumbnail::from_bytes(&b[..cut]).is_err());
}
assert!(Thumbnail::jfif_bytes(u32::MAX, 1, &[]).is_err());
assert!(Thumbnail::jfif_bytes(40_000, 40_000, &[]).is_err());
}
#[test]
fn version_info_roundtrip() {
let r = version_info_resource(false);
match r.parsed() {
Some(Ok(ResourceData::VersionInfo(v))) => {
assert!(!v.has_real_merged_data);
assert_eq!(v.to_bytes(), r.data);
}
other => panic!("{other:?}"),
}
}
/// Byte for byte what Photoshop 2026 writes (every Photoshop-authored oracle in the corpus):
/// u32 count + UTF-16BE, no NUL terminator.
#[test]
fn version_info_matches_photoshop_bytes() {
let mut want = vec![0, 0, 0, 1, 1];
for s in ["Adobe Photoshop", "Adobe Photoshop 2026"] {
want.extend_from_slice(&(s.len() as u32).to_be_bytes());
want.extend(s.encode_utf16().flat_map(u16::to_be_bytes));
}
want.extend_from_slice(&[0, 0, 0, 1]);
assert_eq!(version_info_resource(true).data, want);
}
}