psd: share plane stream, RLE row-count and ZIP limit framing (#786) (#2884)

This commit is contained in:
Dylan M. Taylor authored and GitHub committed 2026-11-21 13:22:16 -05:00
1 parent ba25ccd233
commit 5319811431
2 files changed
+217 -6

No files matched your search

+156 -6
View File
@@ -514,15 +514,24 @@ fn read_count(r: &mut Reader<'_>, v: Version) -> Result<usize> {
Ok(if v.is_psb() { r.u32()? as usize } else { r.u16()? as usize })
}
/// Reads `rows` RLE byte-count entries (`u16` for PSD, `u32` for PSB) from `data`,
/// returning the parsed counts and the remaining row-payload slice.
pub fn read_rle_row_counts(data: &[u8], rows: usize, version: Version) -> Result<(Vec<usize>, &[u8])> {
let mut r = Reader::new(data);
let count_size = if version.is_psb() { 4 } else { 2 };
r.check_count(rows as u64, count_size as u64)?;
let mut counts = Vec::with_capacity(rows);
for _ in 0..rows {
counts.push(read_count(&mut r, version)?);
}
Ok((counts, r.peek_rest()))
}
fn decode_rle(data: &[u8], layout: &PlaneLayout, total: usize) -> Result<Vec<u8>> {
let rows = layout.rows()?;
let rb = layout.row_bytes();
let mut r = Reader::new(data);
r.check_count(rows as u64, layout.count_size() as u64)?;
let mut counts = Vec::with_capacity(rows);
for _ in 0..rows {
counts.push(read_count(&mut r, layout.version)?);
}
let (counts, rest) = read_rle_row_counts(data, rows, layout.version)?;
let mut r = Reader::new(rest);
// PackBits expands at most 64x (2 input bytes -> 128 output bytes).
if (total as u64) > (r.remaining() as u64).saturating_mul(64) {
return Err(PsdError::Decompress("RLE data too short for declared size".into()));
@@ -742,6 +751,147 @@ pub fn zip_decompress(data: &[u8], expected: usize) -> Result<Vec<u8>> {
Ok(out)
}
/// Decompresses a zlib stream up to `limit` output bytes, verifying the zlib trailer
/// when the stream ends within `limit`.
///
/// Unlike [`zip_decompress`], a stream that ends cleanly with fewer than `limit` bytes
/// returns the bytes produced so far so callers can apply their own recovery (such as
/// zero-padding a short layer channel). Corrupt streams, bad Adler-32 checksums, or
/// streams that produce more than `limit` bytes return an error.
pub fn zip_decompress_up_to(data: &[u8], limit: usize) -> Result<Vec<u8>> {
const OOM: PsdError = PsdError::OutOfMemory("not enough memory for the decoded channel data");
let mut decoder = flate2::Decompress::new(true);
let mut out = Vec::new();
out.try_reserve_exact(limit.min(data.len().saturating_mul(1032))).map_err(|_| OOM)?;
let mut buf = vec![0u8; limit.clamp(8192, 1 << 20)];
loop {
let before = (decoder.total_in(), decoder.total_out());
let input = data.get(before.0 as usize..).ok_or_else(|| PsdError::Decompress("zlib input overflow".into()))?;
let status = decoder.decompress(input, &mut buf, flate2::FlushDecompress::None).map_err(|e| PsdError::Decompress(e.to_string()))?;
let got = decoder.total_out();
if got > limit as u64 {
return Err(PsdError::LimitExceeded("zlib output exceeds caller limit"));
}
let n = (got - before.1) as usize;
out.try_reserve(n).map_err(|_| OOM)?;
out.extend_from_slice(buf.get(..n).ok_or_else(|| PsdError::Decompress("zlib output overflow".into()))?);
if status == flate2::Status::StreamEnd {
return Ok(out);
}
if before == (decoder.total_in(), got) {
return Err(PsdError::Decompress("incomplete zlib stream".into()));
}
}
}
/// Staged access to a sequence of encoded image planes (e.g. a single layer channel or
/// a multi-plane merged image).
///
/// Unlike [`decode_planes`], this lets callers:
/// - borrow uncompressed (`Raw`) planes directly from the input slice without copying,
/// - read only a prefix of `total_planes` (for example skipping trailing spot channels),
/// - supply their own per-plane allocation, memory budget, and RLE/ZIP recovery policy.
#[derive(Debug, Clone)]
pub enum PlaneStream<'a> {
/// Uncompressed planes: each [`Self::next_raw_plane`] borrows `plane_bytes` from `rest`.
Raw {
/// Remaining unread bytes.
rest: &'a [u8],
},
/// PackBits RLE planes: `counts` holds `total_planes * height` row byte counts, followed by `rest`.
Rle {
/// Per-row byte counts for all planes, plane after plane.
counts: Vec<usize>,
/// Remaining unread row payload bytes.
rest: &'a [u8],
},
/// Inflated ZIP data holding consecutive planes.
Zip {
/// Inflated bytes (at most `zip_limit`).
data: Vec<u8>,
},
}
impl<'a> PlaneStream<'a> {
/// Prepares a plane stream from `data` (positioned immediately after the 2-byte compression field).
///
/// For RLE, reads the `total_planes * height` row-count table. For ZIP/ZIP-with-prediction,
/// invokes `before_zip(zip_limit)` (allowing callers to charge a memory budget before
/// allocation) and inflates up to `zip_limit` bytes via [`zip_decompress_up_to`].
pub fn open(
compression: Compression,
data: &'a [u8],
total_planes: usize,
height: usize,
version: Version,
zip_limit: usize,
before_zip: impl FnOnce(usize) -> Result<()>,
) -> Result<Self> {
match compression {
Compression::Raw => Ok(Self::Raw { rest: data }),
Compression::Rle => {
let total_rows = total_planes.checked_mul(height).ok_or(PsdError::LimitExceeded("row count overflow"))?;
let (counts, rest) = read_rle_row_counts(data, total_rows, version)?;
Ok(Self::Rle { counts, rest })
}
Compression::Zip | Compression::ZipPrediction => {
before_zip(zip_limit)?;
Ok(Self::Zip { data: zip_decompress_up_to(data, zip_limit)? })
}
Compression::Unknown(c) => Err(PsdError::Unsupported(format!("compression method {c}"))),
}
}
/// Borrows the next `plane_bytes` from a `Raw` stream, advancing past it.
pub fn next_raw_plane(&mut self, plane_bytes: usize) -> Result<&'a [u8]> {
let Self::Raw { rest } = self else {
return Err(PsdError::invalid("expected raw plane stream"));
};
if rest.len() < plane_bytes {
return Err(PsdError::UnexpectedEof { offset: rest.len(), needed: plane_bytes - rest.len() });
}
let (head, tail) = rest.split_at(plane_bytes);
*rest = tail;
Ok(head)
}
/// Decodes `height` RLE rows of `plane_index` into `out`, advancing past their payload bytes.
///
/// When `padded` is true, uses [`packbits::decode_padded_into`] (zero-padding short rows and
/// clipping oversized packets); otherwise uses strict PackBits decoding.
pub fn next_rle_plane_into(&mut self, plane_index: usize, row_bytes: usize, height: usize, padded: bool, out: &mut Vec<u8>) -> Result<()> {
let Self::Rle { counts, rest } = self else {
return Err(PsdError::invalid("expected RLE plane stream"));
};
let base = plane_index.checked_mul(height).ok_or(PsdError::LimitExceeded("row count overflow"))?;
for row in 0..height {
let n = *counts.get(base + row).ok_or(PsdError::UnexpectedEof { offset: 0, needed: 1 })?;
if rest.len() < n {
return Err(PsdError::UnexpectedEof { offset: rest.len(), needed: n - rest.len() });
}
let (src, tail) = rest.split_at(n);
*rest = tail;
if padded {
packbits::decode_padded_into(src, row_bytes, row_bytes, out)?;
} else {
packbits::decode_into(src, row_bytes, out)?;
}
}
Ok(())
}
/// Returns a mutable slice of `plane_bytes` for `plane_index` in a `Zip` stream.
pub fn zip_plane_mut(&mut self, plane_index: usize, plane_bytes: usize) -> Result<&mut [u8]> {
let Self::Zip { data } = self else {
return Err(PsdError::invalid("expected ZIP plane stream"));
};
let start = plane_index.checked_mul(plane_bytes).ok_or(PsdError::LimitExceeded("plane offset overflow"))?;
let end = start.checked_add(plane_bytes).ok_or(PsdError::LimitExceeded("plane offset overflow"))?;
let len = data.len();
data.get_mut(start..end).ok_or(PsdError::UnexpectedEof { offset: len, needed: end.saturating_sub(len) })
}
}
/// Applies horizontal delta prediction in place (encoder side).
///
/// * 1/8-bit: byte-wise delta per row.
+61
View File
@@ -870,3 +870,64 @@ fn packbits_slice_roundtrips_all_packet_lengths() {
}
}
}
#[test]
fn rle_row_counts_parse_psd_and_psb_and_reject_short_tables() {
let psd = [0, 3, 0, 5, 1, 2, 3];
let (counts, rest) = read_rle_row_counts(&psd, 2, Version::Psd).unwrap();
assert_eq!(counts, vec![3, 5]);
assert_eq!(rest, &[1, 2, 3]);
assert!(matches!(read_rle_row_counts(&psd[..3], 2, Version::Psd), Err(PsdError::UnexpectedEof { .. })));
let psb = [0, 0, 0, 3, 0, 1, 0, 0, 9];
let (counts, rest) = read_rle_row_counts(&psb, 2, Version::Psb).unwrap();
assert_eq!(counts, vec![3, 0x10000]);
assert_eq!(rest, &[9]);
assert!(matches!(read_rle_row_counts(&psb[..7], 2, Version::Psb), Err(PsdError::UnexpectedEof { .. })));
}
#[test]
fn zip_decompress_up_to_enforces_limit_and_verifies_trailer() {
let payload: Vec<u8> = (0..1024).map(|i| (i * 17 % 251) as u8).collect();
let compressed = zip_compress(&payload);
assert_eq!(zip_decompress_up_to(&compressed, payload.len()).unwrap(), payload);
assert_eq!(zip_decompress_up_to(&compressed, payload.len() * 2).unwrap(), payload);
assert!(matches!(zip_decompress_up_to(&compressed, payload.len() - 1), Err(PsdError::LimitExceeded(_))));
let mut bad_adler = compressed.clone();
let last = bad_adler.len() - 1;
bad_adler[last] ^= 0xff;
assert!(matches!(zip_decompress_up_to(&bad_adler, payload.len()), Err(PsdError::Decompress(_))));
assert!(matches!(zip_decompress_up_to(&compressed[..compressed.len() / 2], payload.len()), Err(PsdError::Decompress(_))));
}
#[test]
fn plane_stream_stages_raw_rle_and_zip_planes() {
let raw_bytes = [1u8, 2, 3, 4, 5, 6];
let mut raw_stream = PlaneStream::open(Compression::Raw, &raw_bytes, 3, 2, Version::Psd, 0, |_| Ok(())).unwrap();
assert_eq!(raw_stream.next_raw_plane(2).unwrap(), &[1, 2]);
assert_eq!(raw_stream.next_raw_plane(2).unwrap(), &[3, 4]);
// Two RLE planes (2 rows x 2 bytes each); first row of plane 0 is short for padded recovery.
let mut rle_data = vec![0, 2, 0, 2, 0, 2, 0, 2];
rle_data.extend_from_slice(&[0, 9]); // 1 byte literal, zero-padded to 2 when padded=true
rle_data.extend_from_slice(&[255, 8]); // 2 copies of 8
rle_data.extend_from_slice(&[255, 7]);
rle_data.extend_from_slice(&[255, 6]);
let mut rle_stream = PlaneStream::open(Compression::Rle, &rle_data, 2, 2, Version::Psd, 0, |_| Ok(())).unwrap();
let mut plane0 = Vec::new();
rle_stream.next_rle_plane_into(0, 2, 2, true, &mut plane0).unwrap();
assert_eq!(plane0, vec![9, 0, 8, 8]);
let mut plane1 = Vec::new();
rle_stream.next_rle_plane_into(1, 2, 2, false, &mut plane1).unwrap();
assert_eq!(plane1, vec![7, 7, 6, 6]);
let zip_src = zip_compress(&[10, 20, 30, 40]);
let refused = PlaneStream::open(Compression::Zip, &zip_src, 2, 1, Version::Psd, 4, |_| Err(PsdError::LimitExceeded("budget")));
assert!(matches!(refused, Err(PsdError::LimitExceeded("budget"))));
let mut zip_stream = PlaneStream::open(Compression::Zip, &zip_src, 2, 1, Version::Psd, 4, |_| Ok(())).unwrap();
assert_eq!(zip_stream.zip_plane_mut(0, 2).unwrap(), &[10, 20]);
assert_eq!(zip_stream.zip_plane_mut(1, 2).unwrap(), &[30, 40]);
}