f67d38b35cc5
tests.rs
use super::*;
const GRAY: u16 = 1;
const RGB: u16 = 3;
/// PackBits as Photoshop writes it: runs of 3+ equal bytes repeated, the rest literal.
fn packbits(row: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut i = 0;
while i < row.len() {
let run = row[i..].iter().take(128).take_while(|&&b| b == row[i]).count();
if run >= 3 {
out.extend([(1 - run as i16) as u8, row[i]]);
i += run;
} else {
let mut j = i + 1;
while j < row.len() && j - i < 128 && !(j + 2 < row.len() && row[j] == row[j + 1] && row[j] == row[j + 2]) {
j += 1;
}
out.push((j - i - 1) as u8);
out.extend_from_slice(&row[i..j]);
i = j;
}
}
out
}
/// A minimal document: header, an empty colour mode section, one image resource, the given layer
/// and mask section, then the composite (`planes` are whole channels, top row first).
fn psd(mode: u16, depth: u16, w: u32, h: u32, planes: &[Vec<u16>], rle: bool, layers: &[u8]) -> Vec<u8> {
let mut v = b"8BPS".to_vec();
v.extend(1u16.to_be_bytes());
v.extend([0; 6]);
v.extend((planes.len() as u16).to_be_bytes());
v.extend(h.to_be_bytes());
v.extend(w.to_be_bytes());
v.extend(depth.to_be_bytes());
v.extend(mode.to_be_bytes());
v.extend(0u32.to_be_bytes());
let res = b"8BIM\x04\x0c\0\0\0\0\0\x02ab";
v.extend((res.len() as u32).to_be_bytes());
v.extend(res);
v.extend((layers.len() as u32).to_be_bytes());
v.extend(layers);
v.extend(u16::from(rle).to_be_bytes());
let rows: Vec<Vec<u8>> = planes
.iter()
.flat_map(|p| {
p.chunks(w.max(1) as usize).map(|r| r.iter().flat_map(|&s| if depth == 8 { vec![s as u8] } else { s.to_be_bytes().to_vec() }).collect::<Vec<u8>>())
})
.collect();
if rle {
let packed: Vec<Vec<u8>> = rows.iter().map(|r| packbits(r)).collect();
for p in &packed {
v.extend((p.len() as u16).to_be_bytes());
}
packed.iter().for_each(|p| v.extend(p));
} else {
rows.iter().for_each(|r| v.extend(r));
}
v
}
/// A layer and mask section whose layer info holds only a layer count.
fn layer_count(n: i16) -> Vec<u8> {
let mut v = 2u32.to_be_bytes().to_vec();
v.extend(n.to_be_bytes());
v.extend(0u32.to_be_bytes());
v
}
/// The 16-bit form: an empty layer info, an empty global mask, then the layers in an `Lr16` block.
fn lr16_count(n: i16) -> Vec<u8> {
let mut v = 0u32.to_be_bytes().to_vec();
v.extend(0u32.to_be_bytes());
v.extend(b"8BIMLr16");
v.extend(2u32.to_be_bytes());
v.extend(n.to_be_bytes());
v
}
fn rgba(r: &Raster) -> Vec<[u8; 4]> {
r.rgba.chunks(4).map(|p| [p[0], p[1], p[2], p[3]]).collect()
}
fn rgb_planes() -> Vec<Vec<u16>> {
// 4 x 2, with a run long enough for PackBits to repeat
vec![vec![10, 10, 10, 10, 1, 2, 3, 4], vec![20, 21, 22, 23, 5, 5, 5, 6], vec![30, 31, 32, 33, 7, 8, 9, 9]]
}
#[test]
fn rgb_8bit_raw_and_rle() {
for rle in [false, true] {
let r = decode("a.psd", &psd(RGB, 8, 4, 2, &rgb_planes(), rle, &[])).unwrap();
assert_eq!((r.width, r.height, r.has_alpha), (4, 2, false), "rle {rle}");
let p = rgba(&r);
assert_eq!(p[0], [10, 20, 30, 255], "rle {rle}");
assert_eq!(p[3], [10, 23, 33, 255], "rle {rle}");
assert_eq!(p[4], [1, 5, 7, 255], "rle {rle}");
assert_eq!(p[7], [4, 6, 9, 255], "rle {rle}");
}
}
#[test]
fn gray_8bit_raw_and_rle() {
for rle in [false, true] {
let r = decode("a.psd", &psd(GRAY, 8, 3, 1, &[vec![0, 128, 255]], rle, &[])).unwrap();
assert_eq!(rgba(&r), [[0, 0, 0, 255], [128, 128, 128, 255], [255, 255, 255, 255]], "rle {rle}");
}
}
#[test]
fn sixteen_bit_is_rounded_to_eight() {
// 257 * v is exactly v at 8 bits; 0x7fff and 0x8000 straddle the rounding point between 127 and 128
let gray = vec![0, 0xffff, 257 * 100, 0x7fff, 0x8000];
for rle in [false, true] {
let r = decode("a.psd", &psd(GRAY, 16, 5, 1, std::slice::from_ref(&gray), rle, &[])).unwrap();
let y: Vec<u8> = rgba(&r).iter().map(|p| p[0]).collect();
assert_eq!(y, [0, 255, 100, 127, 128], "rle {rle}");
let planes = [gray.clone(), gray.iter().map(|&s| 0xffff - s).collect(), vec![257 * 7; 5]];
let r = decode("a.psd", &psd(RGB, 16, 5, 1, &planes, rle, &[])).unwrap();
assert_eq!(rgba(&r)[2], [100, 155, 7, 255], "rle {rle}");
}
}
#[test]
fn merged_alpha_only_when_the_layer_count_says_so() {
let mut planes = rgb_planes();
planes.push(vec![255, 0, 128, 255, 255, 255, 255, 255]);
// a negative layer count: the first extra channel is the composite's transparency
let r = decode("a.psd", &psd(RGB, 8, 4, 2, &planes, true, &layer_count(-2))).unwrap();
assert!(r.has_alpha);
let a: Vec<u8> = rgba(&r).iter().map(|p| p[3]).collect();
assert_eq!(a, [255, 0, 128, 255, 255, 255, 255, 255]);
// a flat document (no layer section) or a positive count: the extra channel is a saved selection
for layers in [vec![], layer_count(2)] {
let r = decode("a.psd", &psd(RGB, 8, 4, 2, &planes, false, &layers)).unwrap();
assert!(!r.has_alpha);
assert!(rgba(&r).iter().all(|p| p[3] == 255));
assert_eq!(rgba(&r)[1], [10, 21, 31, 255]);
}
// 16-bit documents keep their layers in an Lr16 block; grayscale has its alpha second
// (the second pixel is 191 at 64/255 opacity, stored matted on white as 239)
let gray = [vec![257 * 9, 257 * 239], vec![0xffff, 257 * 64]];
let r = decode("a.psd", &psd(GRAY, 16, 2, 1, &gray, false, &lr16_count(-1))).unwrap();
assert_eq!(rgba(&r), [[9, 9, 9, 255], [191, 191, 191, 64]]);
let r = decode("a.psd", &psd(GRAY, 16, 2, 1, &gray, false, &lr16_count(1))).unwrap();
assert_eq!(rgba(&r), [[9, 9, 9, 255], [239, 239, 239, 255]]);
}
/// Global tagged blocks pad their data to 4 bytes: a 6-byte block before `Lr16` takes 8.
fn padded_lr16_count(n: i16) -> Vec<u8> {
let mut v = 0u32.to_be_bytes().to_vec();
v.extend(0u32.to_be_bytes());
v.extend(b"8BIMPatt");
v.extend(6u32.to_be_bytes());
v.extend([1, 2, 3, 4, 5, 6, 0, 0]);
v.extend(b"8BIMLr16");
v.extend(2u32.to_be_bytes());
v.extend(n.to_be_bytes());
v
}
#[test]
fn tagged_blocks_are_aligned_to_four_bytes() {
let gray = [vec![0, 0], vec![0xffff, 0]];
let r = decode("a.psd", &psd(GRAY, 16, 2, 1, &gray, false, &padded_lr16_count(-1))).unwrap();
assert!(r.has_alpha);
assert_eq!(rgba(&r)[1][3], 0);
}
#[test]
fn transparent_composite_is_unmatted_from_white() {
// Photoshop stores the composite blended over white: (204, 115, 225) at alpha 140 is saved as
// (227, 178, 239); fully transparent pixels are saved white and stay so
for depth in [8u16, 16] {
let k = if depth == 8 { 1 } else { 257 };
let planes: Vec<Vec<u16>> =
[[204u16, 227, 255], [115, 178, 255], [225, 239, 255], [255, 140, 0]].iter().map(|c| c.iter().map(|&v| v * k).collect()).collect();
for rle in [false, true] {
let r = decode("a.psd", &psd(RGB, depth, 3, 1, &planes, rle, &layer_count(-1))).unwrap();
let p = rgba(&r);
assert_eq!(p[0], [204, 115, 225, 255], "{depth} bit");
assert_eq!(p[1], [204, 115, 226, 140], "{depth} bit");
assert_eq!(p[2], [255, 255, 255, 0], "{depth} bit");
}
}
}
/// `file` with its image resources replaced by one version info resource (1057).
fn with_version_info(file: &[u8], real_merged_data: u8) -> Vec<u8> {
let mut res = b"8BIM\x04\x21\0\0".to_vec();
res.extend(5u32.to_be_bytes());
res.extend([0, 0, 0, 1, real_merged_data, 0]);
let old = u32::from_be_bytes(file[30..34].try_into().unwrap()) as usize;
let mut v = file[..30].to_vec();
v.extend((res.len() as u32).to_be_bytes());
v.extend(res);
v.extend(&file[34 + old..]);
v
}
#[test]
fn documents_without_a_real_composite_are_refused() {
let file = psd(RGB, 8, 4, 2, &rgb_planes(), true, &[]);
assert_eq!(rgba(&decode("a.psd", &with_version_info(&file, 1)).unwrap())[0], [10, 20, 30, 255]);
let msg = decode("a.psd", &with_version_info(&file, 0)).err().map(|e| e.to_string()).unwrap_or_default();
assert!(msg.contains("Maximize Compatibility"), "{msg}");
}
#[test]
fn unsupported_documents_say_why() {
let msg = |b: &[u8]| decode("a.psd", b).err().map(|e| e.to_string()).unwrap_or_default();
let ok = psd(RGB, 8, 4, 2, &rgb_planes(), false, &[]);
let with = |at: usize, bytes: &[u8]| {
let mut b = ok.clone();
b[at..at + bytes.len()].copy_from_slice(bytes);
b
};
assert!(msg(&with(4, &[0, 2])).contains("PSB"));
assert!(msg(&with(24, &[0, 4])).contains("CMYK"));
assert!(msg(&with(24, &[0, 9])).contains("Lab"));
assert!(msg(&with(24, &[0, 2])).contains("indexed"));
assert!(msg(&with(24, &[0, 0])).contains("bitmap"));
assert!(msg(&with(24, &[0, 7])).contains("multichannel"));
assert!(msg(&with(24, &[0, 8])).contains("duotone"));
assert!(msg(&with(22, &[0, 32])).contains("32-bit"));
assert!(msg(&with(22, &[0, 1])).contains("1-bit"));
let zip = ok.len() - 3 * 8 - 2;
assert!(msg(&with(zip, &[0, 2])).contains("ZIP"));
assert!(msg(&with(zip, &[0, 3])).contains("ZIP"));
assert!(decode("a.psd", &with(zip, &[0, 9])).is_err());
assert!(decode("a.psd", &with(4, &[0, 3])).is_err());
}
#[test]
fn hostile_input_is_an_error_not_a_panic() {
let rgb = |w: u32, h: u32| psd(RGB, 8, w, h, &rgb_planes(), false, &[]);
assert!(decode("a.psd", &rgb(4, 2)).is_ok());
assert!(decode("a.psd", &rgb(0, 2)).is_err());
assert!(decode("a.psd", &rgb(30_001, 1)).is_err());
assert!(decode("a.psd", &rgb(30_000, 30_000)).is_err());
// a big but legal size whose data is not there is refused before the picture is allocated
assert!(decode("a.psd", &rgb(16_000, 16_000)).is_err());
assert!(decode("a.psd", &psd(RGB, 8, 4, 2, &rgb_planes()[..2], false, &[])).is_err());
// an RLE row that decodes past the row's end
let mut b = psd(GRAY, 8, 2, 1, &[vec![1, 2]], true, &[]);
let n = b.len();
b.splice(n - 3.., [0xfe, 7]);
b.splice(n - 5..n - 3, 2u16.to_be_bytes());
assert!(decode("a.psd", &b).is_err());
// section lengths that point past the end
let mut b = rgb(4, 2);
b[26..30].copy_from_slice(&u32::MAX.to_be_bytes());
assert!(decode("a.psd", &b).is_err());
assert!(decode("a.psd", b"8BPS").is_err());
assert!(decode("a.psd", b"GIF89a").is_err());
let mut planes = rgb_planes();
planes.push(vec![255, 0, 128, 255, 255, 255, 255, 255]);
for file in [psd(RGB, 8, 4, 2, &planes, true, &layer_count(-2)), psd(GRAY, 16, 2, 1, &[vec![1, 2], vec![3, 4]], false, &lr16_count(-1))] {
for cut in 0..file.len() {
assert!(decode("a.psd", &file[..cut]).is_err(), "cut at {cut}");
}
for i in 0..file.len() {
for v in [0x00, 0x7f, 0x80, 0xff] {
let mut b = file.clone();
b[i] = v;
assert!(std::panic::catch_unwind(|| decode("a.psd", &b)).is_ok(), "byte {i} = {v:#x}");
}
}
}
}
#[test]
fn opens_as_a_still() {
let bytes = psd(RGB, 8, 4, 2, &rgb_planes(), true, &[]);
assert!(crate::still::sniff("a.psd", &bytes));
assert!(crate::is_importable(std::path::Path::new("Poster.PSD")));
let src = crate::open_bytes("a.psd", bytes.into(), &[]).unwrap();
assert_eq!(src.info().kind, crate::MediaKind::Still);
assert_eq!(src.info().video.as_ref().map(|v| (v.width, v.height, v.codec.as_str())), Some((4, 2, "PSD")));
}
// Prior Film decoder retained only as a compatibility oracle.
/// Expand one PackBits-coded row into `out`, which it must fill exactly.
fn legacy_unpack(name: &str, src: &[u8], out: &mut [u8]) -> Result<()> {
let (mut i, mut o) = (0, 0);
while o < out.len() {
let n = *src.get(i).ok_or_else(|| err(name, "truncated run-length row"))? as i8;
i += 1;
if n >= 0 {
let k = n as usize + 1;
let lit = src.get(i..i + k).ok_or_else(|| err(name, "truncated run-length row"))?;
out.get_mut(o..o + k).ok_or_else(|| err(name, "run-length row longer than the picture"))?.copy_from_slice(lit);
i += k;
o += k;
} else if n != -128 {
let k = usize::from(n.unsigned_abs()) + 1;
let v = *src.get(i).ok_or_else(|| err(name, "truncated run-length row"))?;
out.get_mut(o..o + k).ok_or_else(|| err(name, "run-length row longer than the picture"))?.fill(v);
i += 1;
o += k;
}
}
Ok(())
}
#[test]
fn shared_packbits_preserves_film_row_acceptance_and_bytes() {
for header in 0..=255u8 {
let full = std::iter::once(header).chain((0..128).map(|i| i as u8)).collect::<Vec<_>>();
for src in [vec![header], vec![header, 9], full] {
for width in [0, 1, 2, 127, 128, 129] {
let mut old = vec![0xA5; width];
let mut new = old.clone();
let before = legacy_unpack("a.psd", &src, &mut old);
let after = unpack("a.psd", &src, &mut new);
assert_eq!(before.is_ok(), after.is_ok(), "header={header}, width={width}, input={src:?}");
assert_eq!(old, new, "completed packets and untouched suffix agree even on error");
if let Err(e) = after {
assert!(matches!(e, MediaError::Decode(_)));
}
}
}
}
let mut row = [0; 3];
unpack("a.psd", &[128, 0, 7, 128, 255, 9, 255], &mut row).unwrap();
assert_eq!(row, [7, 9, 9], "no-ops allowed, trailing truncated packet ignored");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.