mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 23:24:24 +00:00
1151 lines
56 KiB
Rust
1151 lines
56 KiB
Rust
//! Reading the pixel data of a TIFF IFD (strips or tiles; uncompressed, lossless/lossy JPEG, Deflate, JPEG XL), in parallel.
|
||
|
||
#[cfg(feature = "dng")]
|
||
use crate::unpack::inflate;
|
||
use crate::unpack::{f16_to_f32, f24_to_f32, read_u16s, undo_diff_u16, undo_float_predictor, unpack_lsb, unpack_msb, unpack_words32_msb_with};
|
||
use crate::{Limits, RawData, RawError, Result, ljpeg};
|
||
use craft_tiff::image::{Chunk, ImageInfo, chunk_bytes};
|
||
use craft_tiff::{ByteOrder, tags::compression as comp};
|
||
use rayon::prelude::*;
|
||
|
||
/// Bit packing for uncompressed integer data with bit depths other than 8/16.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
#[allow(dead_code)] // vendor decoders use the other variants
|
||
pub enum Packing {
|
||
/// TIFF standard: MSB-first, rows start on byte boundaries.
|
||
Msb,
|
||
/// LSB-first little-endian bit stream (some vendor raws), rows byte aligned.
|
||
Lsb,
|
||
/// Each sample stored in 16 bits in file byte order, regardless of `bits`.
|
||
Word16,
|
||
/// MSB-first bit stream inside 32-bit words stored in file byte order ([`unpack_words32_msb`](crate::unpack::unpack_words32_msb));
|
||
/// rows start on a word boundary.
|
||
Words32Msb,
|
||
}
|
||
|
||
pub(crate) enum ChunkPx {
|
||
U16(Vec<u16>),
|
||
F32(Vec<f32>),
|
||
}
|
||
|
||
/// The checks [`read_image`] makes before decoding anything (sample format, size limits, data
|
||
/// present); returns the number of samples.
|
||
pub(crate) fn check_image(data: &[u8], info: &ImageInfo, limits: &Limits) -> Result<usize> {
|
||
let (w, h) = (info.width as usize, info.height as usize);
|
||
let cpp = info.samples_per_pixel as usize;
|
||
let total = w.checked_mul(h).and_then(|v| v.checked_mul(cpp)).ok_or(RawError::Limit("image too large"))?;
|
||
if total > limits.samples() || total == 0 {
|
||
return Err(RawError::Limit("image too large"));
|
||
}
|
||
let chunks = info.chunks(data.len() as u64);
|
||
if chunks.is_empty() {
|
||
return Err(RawError::Corrupt("no image data chunks".into()));
|
||
}
|
||
// every visible sample needs a chunk: a short offsets table would leave zero-filled (black) regions.
|
||
// Count the table, not `chunks`: craft-tiff builds at most one descriptor per byte of file
|
||
// (storytold/craft-libs#827), so a grid of tiles sharing one payload lists fewer chunks than the
|
||
// table declares and would be refused here for a short file rather than for the data it holds.
|
||
let (across, down) = info.grid();
|
||
let planes = if info.planar == 2 { cpp } else { 1 };
|
||
let expected = (across as usize).saturating_mul(down as usize).saturating_mul(planes);
|
||
if info.offsets.len() < expected {
|
||
return Err(RawError::Corrupt(format!("{} image data chunks, expected {expected}", info.offsets.len())));
|
||
}
|
||
// Tile sizes don't depend on the image size, and every tile is decoded at its nominal size and held until the copy:
|
||
// a grid of tiles no larger than the image covers less than twice its width and height, so more than four times
|
||
// its samples (or one tile of more than TILE_SAMPLES_FLOOR on a tiny image) is no picture (storytold/lightcraft#2554).
|
||
let ccpp = if info.planar == 2 { 1 } else { cpp as u64 };
|
||
let nominal = chunks.iter().fold(0u64, |sum, c| sum.saturating_add(u64::from(c.width).saturating_mul(u64::from(c.height)).saturating_mul(ccpp)));
|
||
if nominal > (total as u64).saturating_mul(4).max(TILE_SAMPLES_FLOOR) {
|
||
return Err(RawError::Limit("image data chunks far larger than the image"));
|
||
}
|
||
// Plausibility bound before allocating: no supported coding stores more than ~2000 samples per byte
|
||
// (Deflate of constant data is the extreme), so tiny files cannot trigger huge allocations. The
|
||
// bytes are counted once however many chunks point at them: a grid of tiles sharing one small
|
||
// payload holds that payload's samples, not the grid's.
|
||
let mut spans: Vec<(u64, u64)> =
|
||
chunks.iter().filter_map(|c| Some((c.offset, c.offset.checked_add(chunk_bytes(data, c)?.len() as u64)?))).collect();
|
||
spans.sort_unstable();
|
||
let (mut available, mut end) = (0u64, 0u64);
|
||
for (a, b) in spans {
|
||
let a = a.max(end);
|
||
if b > a {
|
||
available = available.saturating_add(b - a);
|
||
end = b;
|
||
}
|
||
}
|
||
if available.saturating_mul(2048) < total as u64 {
|
||
return Err(RawError::Corrupt(format!("{available} bytes of image data cannot hold {total} samples")));
|
||
}
|
||
// Lossless JPEG codes every sample in a bit at least: ljpeg's per-frame check allows 8 samples per entropy byte plus
|
||
// 64 bytes of slack, which a frame's own headers (over 32 bytes with its Huffman table) cover twice over, so 16
|
||
// coded samples per byte, and twice that for 4:2:0 YCbCr (half the samples it fills are coded) (storytold/lightcraft#2554). The
|
||
// bytes are counted once per chunk that points at them here: tiles may legitimately share one payload (identical
|
||
// tiles written once), and each copy is decoded in full, so every reference brings its payload's samples. The
|
||
// unique-byte bound above still caps what a small payload shared by a large grid can make the output reserve.
|
||
let referenced = chunks.iter().fold(0u64, |sum, c| sum.saturating_add(chunk_bytes(data, c).map_or(0, |b| b.len() as u64)));
|
||
if info.compression == comp::JPEG && referenced.saturating_mul(32) < total as u64 {
|
||
return Err(RawError::Corrupt(format!("{referenced} bytes of lossless JPEG data cannot hold {total} samples")));
|
||
}
|
||
// Validate that the source actually contains the declared image before reporting a format
|
||
// limitation. A truncated unsupported float DNG must not be mistaken for a valid raw and
|
||
// silently replaced by its embedded preview.
|
||
let bits = info.bits() as u32;
|
||
let float = info.sample_format == 3;
|
||
if float && !matches!(bits, 16 | 24 | 32) {
|
||
return Err(RawError::Unsupported(format!("{bits}-bit floating-point samples")));
|
||
}
|
||
if !float && !(1..=16).contains(&bits) {
|
||
return Err(RawError::Unsupported(format!("{bits}-bit integer samples")));
|
||
}
|
||
Ok(total)
|
||
}
|
||
|
||
/// Read the samples of `info` in `mode`: [`Mode::Header`] only checks them ([`check_image`]) and
|
||
/// returns no samples (floating-point data as an empty `F32`).
|
||
pub(crate) fn read_image_in(
|
||
mode: crate::Mode,
|
||
data: &[u8],
|
||
info: &ImageInfo,
|
||
order: ByteOrder,
|
||
packing: Packing,
|
||
limits: &Limits,
|
||
) -> Result<RawData> {
|
||
match mode {
|
||
crate::Mode::Full => read_image(data, info, order, packing, limits),
|
||
crate::Mode::Header => {
|
||
check_image(data, info, limits)?;
|
||
check_uncompressed_chunks(data, info, &info.chunks(data.len() as u64), packing)?;
|
||
// a lossless-JPEG layout the decoder rejects (subsampled components, e.g. Sony's
|
||
// lossless M/S sizes) must fail here too, as the full decode will; likewise a JPEG XL
|
||
// chunk whose headers don't match the IFD
|
||
let first = info.chunks(data.len() as u64).first().copied();
|
||
if let Some(c) = first
|
||
&& let Some(src) = chunk_bytes(data, &c)
|
||
{
|
||
match info.compression {
|
||
7 => {
|
||
ljpeg::frame_info(src)?;
|
||
}
|
||
comp::JPEG_XL => {
|
||
let planar = info.planar == 2 && info.samples_per_pixel > 1;
|
||
let cpp = if planar { 1 } else { info.samples_per_pixel as usize };
|
||
let (cw, ch, vw, vh) = chunk_dims(info, &c);
|
||
jxl_chunk_check(src, cw, ch, vw, vh, cpp, info.bits() as u32, info.sample_format == 3)?;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
Ok(if info.sample_format == 3 { RawData::F32(Vec::new()) } else { RawData::U16(Vec::new()) })
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The nominal samples of all chunks [`check_image`] allows whatever the image size: one 2048 × 2048 tile.
|
||
const TILE_SAMPLES_FLOOR: u64 = 1 << 22;
|
||
|
||
/// Decode all chunks of `info` into one buffer of `width × height × cpp` samples.
|
||
pub(crate) fn read_image(data: &[u8], info: &ImageInfo, order: ByteOrder, packing: Packing, limits: &Limits) -> Result<RawData> {
|
||
let (w, h) = (info.width as usize, info.height as usize);
|
||
let total = check_image(data, info, limits)?;
|
||
let cpp = info.samples_per_pixel as usize;
|
||
let bits = info.bits() as u32;
|
||
let float = info.sample_format == 3;
|
||
let chunks = info.chunks(data.len() as u64);
|
||
check_uncompressed_chunks(data, info, &chunks, packing)?;
|
||
let planar = info.planar == 2 && cpp > 1;
|
||
let ccpp = if planar { 1 } else { cpp };
|
||
// The chunks are decoded and copied into the output in groups whose combined nominal size stays within
|
||
// a few times the output buffer's: everything decoded at once would retain the whole image twice, and
|
||
// a hostile tile table's chosen padding could stretch that much further (storytold/lightcraft#1517). One group
|
||
// still decodes in parallel; the grid order groups make, the copies stay disjoint.
|
||
// The tile grid decides how much is decoded, whatever the file's bytes: the nominal sizes of all
|
||
// the chunks stay within a few times the image (edge tiles pad it) before any is decoded.
|
||
let nominal = chunks.iter().fold(0usize, |sum, c| sum.saturating_add(chunk_samples(c, ccpp)));
|
||
if nominal > total.saturating_mul(4).saturating_add(1 << 24) {
|
||
return Err(RawError::Corrupt("the tile grid is much larger than the image".into()));
|
||
}
|
||
let group_samples = (total / 4).max(1 << 20);
|
||
let mut out_u16 = if float { Vec::new() } else { vec![0u16; total] };
|
||
let mut out_f32 = if float { vec![0f32; total] } else { Vec::new() };
|
||
let mut decode_from = 0usize;
|
||
while decode_from < chunks.len() {
|
||
let mut to = decode_from;
|
||
let mut taken = 0usize;
|
||
for (k, c) in chunks[decode_from..].iter().enumerate() {
|
||
let n = chunk_samples(c, ccpp);
|
||
if taken > 0 && taken.saturating_add(n) > group_samples {
|
||
break;
|
||
}
|
||
taken = taken.saturating_add(n);
|
||
to = decode_from + k + 1;
|
||
}
|
||
let decoded: Vec<Result<(Chunk, ChunkPx)>> = chunks[decode_from..to]
|
||
.par_iter()
|
||
.map(|c| decode_chunk(data, info, c, order, packing, ccpp, bits, float, limits).map(|p| (*c, p)))
|
||
.collect();
|
||
// a chunk that cannot be decoded is not a partial image: the file stays preview-only
|
||
let decoded = decoded.into_iter().collect::<Result<Vec<_>>>()?;
|
||
// The copy runs in parallel over bands of output rows: each band takes its rows of every chunk of the
|
||
// group that reaches it, in chunk order (so overlapping chunks resolve as a serial copy would).
|
||
let row_samples = w * cpp;
|
||
let threads = rayon::current_num_threads().max(1);
|
||
let band_rows = h.div_ceil(threads * 4).max(1);
|
||
if float {
|
||
out_f32.par_chunks_mut(band_rows * row_samples).enumerate().for_each(|(bi, band)| {
|
||
for (c, px) in &decoded {
|
||
if let ChunkPx::F32(v) = px {
|
||
place_chunk(band, bi * band_rows, c, v, w, h, cpp, planar);
|
||
}
|
||
}
|
||
});
|
||
} else {
|
||
out_u16.par_chunks_mut(band_rows * row_samples).enumerate().for_each(|(bi, band)| {
|
||
for (c, px) in &decoded {
|
||
if let ChunkPx::U16(v) = px {
|
||
place_chunk(band, bi * band_rows, c, v, w, h, cpp, planar);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
decode_from = to;
|
||
}
|
||
Ok(if float { RawData::F32(out_f32) } else { RawData::U16(out_u16) })
|
||
}
|
||
|
||
/// Copy the rows of chunk `c` (samples `src`, `c.width` per row, `ccpp` samples per pixel) that fall into the output
|
||
/// band `band`, which holds the image rows from `band_y0` on (`w` pixels of `cpp` samples each, `h` rows in the whole
|
||
/// image). Pixels past the image edge and samples `src` does not hold are skipped; a planar chunk (`planar`) writes
|
||
/// its one sample per pixel into the channel `c.plane`, a chunk of a plane the image does not have is skipped.
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn place_chunk<T: Copy>(band: &mut [T], band_y0: usize, c: &Chunk, src: &[T], w: usize, h: usize, cpp: usize, planar: bool) {
|
||
let (cw, ch) = (c.width as usize, c.height as usize);
|
||
let (x0, y0) = (c.x as usize, c.y as usize);
|
||
if x0 >= w || y0 >= h || cpp == 0 {
|
||
return;
|
||
}
|
||
let plane = c.plane as usize;
|
||
if planar && plane >= cpp {
|
||
return;
|
||
}
|
||
let ccpp = if planar { 1 } else { cpp };
|
||
let copy_w = cw.min(w - x0);
|
||
let copy_h = ch.min(h - y0);
|
||
let band_rows = band.len() / (w * cpp);
|
||
let first = y0.max(band_y0);
|
||
let last = (y0 + copy_h).min(band_y0 + band_rows);
|
||
for y in first..last {
|
||
let s0 = (y - y0) * cw * ccpp;
|
||
let Some(avail) = src.get(s0..) else { break };
|
||
let d0 = ((y - band_y0) * w + x0) * cpp;
|
||
if planar {
|
||
let row = &mut band[d0..d0 + copy_w * cpp];
|
||
for (o, &v) in row[plane..].iter_mut().step_by(cpp).zip(&avail[..copy_w.min(avail.len())]) {
|
||
*o = v;
|
||
}
|
||
} else {
|
||
let n = (copy_w * cpp).min(avail.len());
|
||
band[d0..d0 + n].copy_from_slice(&avail[..n]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Framing precedes allocation even in header-only probes: missing source rows may not
|
||
/// be reported as a decodable image and later silently filled with zero samples.
|
||
fn check_uncompressed_chunks(data: &[u8], info: &ImageInfo, chunks: &[Chunk], packing: Packing) -> Result<()> {
|
||
if info.compression != comp::NONE {
|
||
return Ok(());
|
||
}
|
||
let cpp = if info.planar == 2 { 1 } else { info.samples_per_pixel as usize };
|
||
for chunk in chunks {
|
||
let src = chunk_bytes(data, chunk).ok_or_else(|| RawError::Corrupt("uncompressed chunk is outside the file".into()))?;
|
||
let (cw, _, vw, vh) = chunk_dims(info, chunk);
|
||
let row = packed_row_bytes(cw as u64 * cpp as u64, info.bits() as u32, packing, info.sample_format == 3);
|
||
let last = packed_row_bytes(vw as u64 * cpp as u64, info.bits() as u32, packing, info.sample_format == 3);
|
||
let need = row.saturating_mul(vh.saturating_sub(1) as u64).saturating_add(last);
|
||
if (src.len() as u64) < need {
|
||
return Err(RawError::Corrupt(format!("an uncompressed chunk has {} bytes, expected at least {need}", src.len())));
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Bytes that `n` samples take in a row of an uncompressed or inflated chunk, laid out as
|
||
/// [`unpack_chunk`] reads them: whole bytes or 16-bit words, or 32-bit words for `Words32Msb`.
|
||
fn packed_row_bytes(n: u64, bits: u32, packing: Packing, float: bool) -> u64 {
|
||
if float {
|
||
return n.saturating_mul(u64::from(bits.div_ceil(8)));
|
||
}
|
||
let bit_len = n.saturating_mul(u64::from(bits));
|
||
match (bits, packing) {
|
||
(8, _) => n,
|
||
(16, _) | (_, Packing::Word16) => n.saturating_mul(2),
|
||
(_, Packing::Msb | Packing::Lsb) => bit_len.div_ceil(8),
|
||
(_, Packing::Words32Msb) => bit_len.div_ceil(32).saturating_mul(4),
|
||
}
|
||
}
|
||
|
||
/// A chunk's nominal decoded size in samples (per plane, as the decoder builds it).
|
||
fn chunk_samples(c: &Chunk, ccpp: usize) -> usize {
|
||
(c.width as usize).saturating_mul(c.height as usize).saturating_mul(ccpp)
|
||
}
|
||
|
||
/// Consecutive index ranges of `chunks` whose combined nominal samples (`ccpp` per pixel) stay within the group size
|
||
/// [`read_image`] uses for an image of `total` samples (at least one chunk per range). A decoder that holds its
|
||
/// decoded tiles until it copies them decodes one range at a time, so it holds a group's frames beside the output,
|
||
/// not the whole grid's (storytold/lightcraft#1517, storytold/lightcraft#2554).
|
||
#[cfg(feature = "arw")]
|
||
pub(crate) fn decode_groups(chunks: &[Chunk], ccpp: usize, total: usize) -> Vec<std::ops::Range<usize>> {
|
||
let budget = (total / 4).max(1 << 20);
|
||
let mut groups = Vec::new();
|
||
let (mut from, mut taken) = (0usize, 0usize);
|
||
for (i, c) in chunks.iter().enumerate() {
|
||
let n = chunk_samples(c, ccpp);
|
||
if i > from && taken.saturating_add(n) > budget {
|
||
groups.push(from..i);
|
||
(from, taken) = (i, 0);
|
||
}
|
||
taken = taken.saturating_add(n);
|
||
}
|
||
if from < chunks.len() {
|
||
groups.push(from..chunks.len());
|
||
}
|
||
groups
|
||
}
|
||
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn decode_chunk(
|
||
data: &[u8],
|
||
info: &ImageInfo,
|
||
c: &Chunk,
|
||
order: ByteOrder,
|
||
packing: Packing,
|
||
cpp: usize,
|
||
bits: u32,
|
||
float: bool,
|
||
limits: &Limits,
|
||
) -> Result<ChunkPx> {
|
||
let src = chunk_bytes(data, c).ok_or_else(|| RawError::Corrupt("chunk offset past end of file".into()))?;
|
||
let (cw, ch, vw, vh) = chunk_dims(info, c);
|
||
let n = cw.checked_mul(ch).and_then(|v| v.checked_mul(cpp)).ok_or(RawError::Limit("chunk too large"))?;
|
||
if n > limits.samples() {
|
||
return Err(RawError::Limit("chunk too large"));
|
||
}
|
||
match info.compression {
|
||
comp::NONE => {
|
||
// Require every visible sample. Nominal edge-tile padding may be absent, but
|
||
// missing image rows must not turn a truncated file into a zero-filled success.
|
||
let row_bytes = packed_row_bytes(cw as u64 * cpp as u64, bits, packing, float);
|
||
let last_row = packed_row_bytes(vw as u64 * cpp as u64, bits, packing, float);
|
||
let need = row_bytes.saturating_mul(vh.saturating_sub(1) as u64).saturating_add(last_row);
|
||
if (src.len() as u64) < need {
|
||
return Err(RawError::Corrupt(format!("an uncompressed chunk of {n} samples has only {} bytes", src.len())));
|
||
}
|
||
unpack_chunk(src, order, packing, cw, ch, cpp, bits, float, 1)
|
||
}
|
||
comp::JPEG => {
|
||
let f = ljpeg::decode(src, n.saturating_mul(2).max(1 << 16))?;
|
||
if f.data.len() < n {
|
||
// Some writers encode edge tiles smaller than nominal: accept a frame that covers the rows inside the image.
|
||
if f.data.is_empty() || f.data.len() % (cw * cpp) != 0 || f.data.len() / (cw * cpp) < vh {
|
||
return Err(RawError::Corrupt(format!("lossless JPEG tile has {} samples, expected {n}", f.data.len())));
|
||
}
|
||
}
|
||
let mut v = f.data;
|
||
v.resize(n, 0);
|
||
Ok(ChunkPx::U16(v))
|
||
}
|
||
#[cfg(feature = "dng")]
|
||
comp::LOSSY_JPEG => {
|
||
// lossy DNG: each chunk is a baseline (DCT) JPEG of 8-bit samples
|
||
// a JPEG decoded for a tile may hold no more samples than the tile (a real one is exactly the tile):
|
||
// many small tiles pointing at one big JPEG would otherwise each decode all of it
|
||
// (the JPEG codes whole MCUs, at most 32 × 32 pixels each, so its size is the tile's rounded up to them)
|
||
let mcu = |v: usize| v.div_ceil(32).saturating_mul(32);
|
||
let tile_budget =
|
||
mcu(cw).saturating_mul(mcu(ch)).saturating_mul(if cpp == 1 { 1 } else { 3 }).clamp(1, limits.max_lossy_tile_samples.max(1));
|
||
let (px, jw, jh, jc) = lossy_jpeg_with_tile(src, cpp, tile_budget, Some((cw, ch, vw, vh)))?;
|
||
// the buffer holds the rows the decoded JPEG covers (the caller zero-fills the tile's
|
||
// remainder and reads only rows it fills): a tile-many-larger decoded JPEG does not
|
||
// get the nominal tile's full buffer (storytold/lightcraft#1517)
|
||
let rows = ch.min(jh);
|
||
let mut v = vec![0u16; rows.max(1).saturating_mul(cw).saturating_mul(cpp)];
|
||
for y in 0..rows {
|
||
for x in 0..cw.min(jw) {
|
||
for k in 0..cpp {
|
||
v[(y * cw + x) * cpp + k] = px[(y * jw + x) * jc + k.min(jc - 1)] as u16;
|
||
}
|
||
}
|
||
}
|
||
Ok(ChunkPx::U16(v))
|
||
}
|
||
#[cfg(feature = "dng")]
|
||
comp::ADOBE_DEFLATE | comp::DEFLATE => {
|
||
// row bytes in u64: a wrapping `cw · cpp · …` in usize could come out small on 32-bit targets and slip past the gate
|
||
let row_bytes = packed_row_bytes(cw as u64 * cpp as u64, bits, packing, float);
|
||
// the gate caps at MAX_SAMPLES (≤ 2^30), so the `usize` cast below is lossless on 32-bit targets too
|
||
let inflate_len =
|
||
crate::checked_pixel_count(row_bytes, ch as u64).ok_or_else(|| RawError::Corrupt("bad TIFF chunk dimensions".into()))?;
|
||
// Deflate compresses at most about 1:1032, so a source this far under half of its
|
||
// nominal length cannot reconstruct the chunk: refused before the nominal buffer is
|
||
// inflated and predicted, which padding-only work would make gigabytes.
|
||
// Nor may the nominal chunk be mostly padding outside the image (a tile far larger than the picture):
|
||
// its allocation and predictor pass would be spent on samples nobody reads.
|
||
if n > vw
|
||
.saturating_mul(vh)
|
||
.saturating_mul(cpp)
|
||
.saturating_mul(MAX_PADDING_FACTOR)
|
||
.saturating_add(MAX_WRITER_TILE_SAMPLES.saturating_mul(cpp))
|
||
{
|
||
return Err(RawError::Limit("deflated chunk is mostly padding outside the image"));
|
||
}
|
||
if (src.len() as u64).saturating_mul(2048) < inflate_len {
|
||
return Err(RawError::Corrupt(format!("a deflated chunk of {inflate_len} bytes is packed into only {} bytes", src.len())));
|
||
}
|
||
let raw = inflate(src, inflate_len as usize)?;
|
||
// The stream has to reach the last row inside the image (edge strips may stop there);
|
||
// it is laid out in nominal rows, so shorter is a truncated chunk, not a picture.
|
||
let last = packed_row_bytes(vw as u64 * cpp as u64, bits, packing, float);
|
||
let visible = row_bytes.saturating_mul(vh.saturating_sub(1) as u64).saturating_add(last);
|
||
if (raw.len() as u64) < visible {
|
||
return Err(RawError::Corrupt(format!(
|
||
"a deflated chunk holds {} bytes, fewer than the {visible} bytes its in-image samples span",
|
||
raw.len()
|
||
)));
|
||
}
|
||
unpack_chunk(&raw, order, packing, cw, ch, cpp, bits, float, info.predictor)
|
||
}
|
||
comp::JPEG_XL => jxl_chunk(src, cw, ch, vw, vh, cpp, bits, float),
|
||
other => Err(RawError::Unsupported(format!("TIFF compression {other}"))),
|
||
}
|
||
}
|
||
|
||
/// A chunk's nominal size and the part of it inside the image (smaller for edge tiles).
|
||
fn chunk_dims(info: &ImageInfo, c: &Chunk) -> (usize, usize, usize, usize) {
|
||
let (cw, ch) = (c.width as usize, c.height as usize);
|
||
let vw = cw.min(info.width.saturating_sub(c.x) as usize);
|
||
let vh = ch.min(info.height.saturating_sub(c.y) as usize);
|
||
(cw, ch, vw, vh)
|
||
}
|
||
|
||
#[cfg(feature = "jxl")]
|
||
use crate::jxl::{check as jxl_chunk_check, decode as jxl_chunk};
|
||
|
||
#[cfg(not(feature = "jxl"))]
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn jxl_chunk(_: &[u8], _: usize, _: usize, _: usize, _: usize, _: usize, _: u32, _: bool) -> Result<ChunkPx> {
|
||
Err(RawError::Unsupported("JPEG XL DNG (built without the `jxl` feature)".into()))
|
||
}
|
||
|
||
#[cfg(not(feature = "jxl"))]
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn jxl_chunk_check(src: &[u8], cw: usize, ch: usize, vw: usize, vh: usize, cpp: usize, bits: u32, float: bool) -> Result<()> {
|
||
jxl_chunk(src, cw, ch, vw, vh, cpp, bits, float).map(|_| ())
|
||
}
|
||
|
||
/// How many times its in-image samples a deflated chunk's nominal size may reach (plus a writer tile of slack):
|
||
/// edge tiles of real files are mostly inside the image.
|
||
#[cfg(feature = "dng")]
|
||
const MAX_PADDING_FACTOR: usize = 32;
|
||
/// Samples per plane of the largest Deflate tile the DNG writer pads to (2048 × 2048, `dngwrite::MAX_DEFLATE_TILE`),
|
||
/// which a small image's one tile is nearly all padding of: such files still decode.
|
||
#[cfg(feature = "dng")]
|
||
const MAX_WRITER_TILE_SAMPLES: usize = 2048 * 2048;
|
||
|
||
#[cfg(all(test, feature = "dng"))]
|
||
/// Decode one baseline JPEG chunk to 8-bit samples: (samples, width, height, channels).
|
||
pub(crate) fn lossy_jpeg(src: &[u8], cpp: usize, max_samples: usize) -> Result<(Vec<u8>, usize, usize, usize)> {
|
||
lossy_jpeg_with_tile(src, cpp, max_samples, None)
|
||
}
|
||
|
||
/// Validate the actual frame before decode allocates its output. Edge tiles may store
|
||
/// a smaller frame covering all visible samples or bounded whole-MCU padding.
|
||
#[cfg(feature = "dng")]
|
||
fn lossy_jpeg_with_tile(
|
||
src: &[u8],
|
||
cpp: usize,
|
||
max_samples: usize,
|
||
tile: Option<(usize, usize, usize, usize)>,
|
||
) -> Result<(Vec<u8>, usize, usize, usize)> {
|
||
use zune_core::bytestream::ZCursor;
|
||
use zune_core::colorspace::ColorSpace;
|
||
use zune_core::options::DecoderOptions;
|
||
let cs = if cpp == 1 { ColorSpace::Luma } else { ColorSpace::RGB };
|
||
let opts = DecoderOptions::default().set_max_width(1 << 16).set_max_height(1 << 16).set_strict_mode(false).jpeg_set_out_colorspace(cs);
|
||
let mut d = zune_jpeg::JpegDecoder::new_with_options(ZCursor::new(src), opts);
|
||
// The header is read first: the JPEG's own dimensions, not the enclosing tile's, size every
|
||
// allocation `decode` makes, and they may claim billions of pixels.
|
||
d.decode_headers().map_err(|e| RawError::Corrupt(format!("lossy JPEG tile: {e}")))?;
|
||
let info = d.info().ok_or_else(|| RawError::Corrupt("lossy JPEG tile without a header".into()))?;
|
||
let (w, h) = (info.width as usize, info.height as usize);
|
||
if !matches!(cpp, 1 | 3) {
|
||
return Err(RawError::Unsupported(format!("lossy JPEG with {cpp} samples per pixel")));
|
||
}
|
||
if usize::from(info.components) != cpp {
|
||
return Err(RawError::Corrupt(format!("lossy JPEG has {} components, expected {cpp}", info.components)));
|
||
}
|
||
if let Some((cw, ch, vw, vh)) = tile {
|
||
if w < vw || h < vh {
|
||
return Err(RawError::Corrupt(format!("a lossy JPEG of {w} x {h} does not cover the {vw} x {vh} of its tile inside the image")));
|
||
}
|
||
// Writers can store a whole MCU around an edge tile. Keep the documented
|
||
// 32-pixel padding allowance without letting one tiny tile decode an arbitrary frame.
|
||
let mcu_extent = |value: usize| value.checked_add(31).map(|rounded| rounded / 32).and_then(|blocks| blocks.checked_mul(32));
|
||
let (Some(max_w), Some(max_h)) = (mcu_extent(cw), mcu_extent(ch)) else {
|
||
return Err(RawError::Corrupt("lossy JPEG tile dimensions overflow MCU padding".into()));
|
||
};
|
||
if w > max_w || h > max_h {
|
||
return Err(RawError::Corrupt(format!("a lossy JPEG of {w} x {h} exceeds its {max_w} x {max_h} MCU-padded tile dimensions")));
|
||
}
|
||
}
|
||
let c = cpp;
|
||
let out = w as u64 * h as u64 * c as u64;
|
||
if w == 0 || h == 0 || out > max_samples as u64 {
|
||
return Err(RawError::Corrupt(format!("a lossy JPEG of {w} × {h} × {c} would exceed the {max_samples} output samples allowed")));
|
||
}
|
||
let px = d.decode().map_err(|e| RawError::Corrupt(format!("lossy JPEG tile: {e}")))?;
|
||
if px.len() < w * h * c {
|
||
return Err(RawError::Corrupt("lossy JPEG tile: short output".into()));
|
||
}
|
||
Ok((px, w, h, c))
|
||
}
|
||
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn unpack_chunk(
|
||
src: &[u8],
|
||
order: ByteOrder,
|
||
packing: Packing,
|
||
cw: usize,
|
||
ch: usize,
|
||
cpp: usize,
|
||
bits: u32,
|
||
float: bool,
|
||
predictor: u16,
|
||
) -> Result<ChunkPx> {
|
||
let row_n = cw * cpp;
|
||
let (factor, fp) = match predictor {
|
||
1 => (0, false),
|
||
2 => (1, false),
|
||
3 => (1, true),
|
||
34892 => (2, false),
|
||
34893 => (4, false),
|
||
34894 => (2, true),
|
||
34895 => (4, true),
|
||
p => return Err(RawError::Unsupported(format!("predictor {p}"))),
|
||
};
|
||
if float {
|
||
let bp = bits.div_ceil(8) as usize;
|
||
let row_bytes = row_n * bp;
|
||
let mut out = vec![0f32; row_n * ch];
|
||
let mut rowbuf = vec![0u8; row_bytes];
|
||
let mut scratch = Vec::new();
|
||
for y in 0..ch {
|
||
let s = src.get(y * row_bytes..).unwrap_or(&[]);
|
||
let len = s.len().min(row_bytes);
|
||
rowbuf[..len].copy_from_slice(&s[..len]);
|
||
rowbuf[len..].fill(0);
|
||
let big = if fp {
|
||
undo_float_predictor(&mut rowbuf, row_n, bp, cpp * factor, &mut scratch);
|
||
true
|
||
} else {
|
||
if factor > 0 {
|
||
return Err(RawError::Unsupported("integer predictor on float data".into()));
|
||
}
|
||
order == ByteOrder::Big
|
||
};
|
||
let dst = &mut out[y * row_n..(y + 1) * row_n];
|
||
let samples = rowbuf.chunks_exact(bp);
|
||
match (bp, big) {
|
||
(2, true) => dst.iter_mut().zip(samples).for_each(|(o, b)| *o = f16_to_f32(u16::from_be_bytes([b[0], b[1]]))),
|
||
(2, false) => dst.iter_mut().zip(samples).for_each(|(o, b)| *o = f16_to_f32(u16::from_le_bytes([b[0], b[1]]))),
|
||
(3, true) => dst.iter_mut().zip(samples).for_each(|(o, b)| *o = f24_to_f32(u32::from_be_bytes([0, b[0], b[1], b[2]]))),
|
||
(3, false) => dst.iter_mut().zip(samples).for_each(|(o, b)| *o = f24_to_f32(u32::from_le_bytes([b[0], b[1], b[2], 0]))),
|
||
(4, true) => dst.iter_mut().zip(samples).for_each(|(o, b)| *o = f32::from_be_bytes([b[0], b[1], b[2], b[3]])),
|
||
_ => dst.iter_mut().zip(samples).for_each(|(o, b)| *o = f32::from_le_bytes([b[0], b[1], b[2], b[3]])),
|
||
}
|
||
}
|
||
return Ok(ChunkPx::F32(out));
|
||
}
|
||
if fp {
|
||
return Err(RawError::Unsupported("floating-point predictor on integer data".into()));
|
||
}
|
||
let mut out = vec![0u16; row_n * ch];
|
||
let mut words = Vec::new();
|
||
let (row_bytes, kind) = match (bits, packing) {
|
||
(8, _) => (row_n, 0),
|
||
(16, _) | (_, Packing::Word16) => (row_n * 2, 1),
|
||
(_, Packing::Msb) => ((row_n * bits as usize).div_ceil(8), 2),
|
||
(_, Packing::Lsb) => ((row_n * bits as usize).div_ceil(8), 3),
|
||
(_, Packing::Words32Msb) => ((row_n * bits as usize).div_ceil(32) * 4, 4),
|
||
};
|
||
for y in 0..ch {
|
||
let s = src.get(y * row_bytes..).unwrap_or(&[]);
|
||
let s = &s[..s.len().min(row_bytes)];
|
||
let row = &mut out[y * row_n..(y + 1) * row_n];
|
||
match kind {
|
||
0 => row.iter_mut().zip(s).for_each(|(o, &b)| *o = b as u16),
|
||
1 => read_u16s(s, order, row),
|
||
2 => unpack_msb(s, bits, row),
|
||
4 => unpack_words32_msb_with(s, order, bits, row, &mut words),
|
||
_ => unpack_lsb(s, bits, row),
|
||
}
|
||
if factor > 0 {
|
||
if bits == 8 {
|
||
for i in cpp * factor..row.len() {
|
||
row[i] = (row[i] as u8).wrapping_add(row[i - cpp * factor] as u8) as u16;
|
||
}
|
||
} else {
|
||
undo_diff_u16(row, cpp * factor);
|
||
// Horizontal differences wrap in the declared sample precision, not in
|
||
// the u16 container used by the unpacker (TIFF 6.0 Predictor 2).
|
||
if bits < 16 {
|
||
let mask = ((1u32 << bits) - 1) as u16;
|
||
row.iter_mut().for_each(|sample| *sample &= mask);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Ok(ChunkPx::U16(out))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod place_tests {
|
||
use super::*;
|
||
|
||
/// The serial per-sample copy `place_chunk` replaced: the oracle.
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn reference(out: &mut [u16], c: &Chunk, v: &[u16], w: usize, h: usize, cpp: usize, planar: bool) {
|
||
let ccpp = if planar { 1 } else { cpp };
|
||
let (cw, ch) = (c.width as usize, c.height as usize);
|
||
let (x0, y0) = (c.x as usize, c.y as usize);
|
||
if x0 >= w || y0 >= h {
|
||
return;
|
||
}
|
||
for y in 0..ch.min(h - y0) {
|
||
for x in 0..cw.min(w - x0) {
|
||
for s in 0..ccpp {
|
||
let src = (y * cw + x) * ccpp + s;
|
||
let dst_s = if planar { c.plane as usize } else { s };
|
||
if dst_s >= cpp {
|
||
continue;
|
||
}
|
||
let dst = ((y0 + y) * w + x0 + x) * cpp + dst_s;
|
||
if let (Some(o), Some(&s)) = (out.get_mut(dst), v.get(src)) {
|
||
*o = s;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn chunk(x: u32, y: u32, width: u32, height: u32, plane: u16) -> Chunk {
|
||
Chunk { index: 0, x, y, width, height, plane, offset: 0, len: 0 }
|
||
}
|
||
|
||
/// Chunks that overlap (the later one wins), run past the image edge, hold fewer samples than their size, or name a
|
||
/// plane the image does not have, placed through bands of several heights, equal the serial copy.
|
||
#[test]
|
||
fn place_chunk_matches_the_serial_copy_for_odd_chunks() {
|
||
let (w, h) = (11, 9);
|
||
for cpp in [1usize, 3] {
|
||
for planar in [false, true] {
|
||
let ccpp = if planar { 1 } else { cpp };
|
||
let specs = [
|
||
(0, 0, 8, 6, 0, 1u16),
|
||
(4, 3, 8, 8, 0, 2), // overlaps the first and runs past both edges
|
||
(4, 3, 8, 8, 0, 3), // the same place again, later wins
|
||
(0, 5, 5, 4, 1, 4),
|
||
(2, 2, 6, 6, 2, 5),
|
||
(0, 0, 4, 4, 3, 6), // plane 3: not an image plane for cpp <= 3
|
||
(9, 0, 6, 12, 0, 7), // only two columns inside
|
||
(20, 0, 4, 4, 0, 8), // right of the image
|
||
(0, 0, 11, 9, 0, 9), // whole image, short source below
|
||
];
|
||
let chunks: Vec<(Chunk, Vec<u16>)> = specs
|
||
.iter()
|
||
.map(|&(x, y, cw, ch, plane, val)| {
|
||
let n = (cw * ch) as usize * ccpp;
|
||
// the last chunk holds only 40 samples
|
||
let n = if val == 9 { 40 } else { n };
|
||
(chunk(x, y, cw, ch, plane), (0..n).map(|i| val * 100 + i as u16).collect())
|
||
})
|
||
.collect();
|
||
let mut want = vec![0u16; w * h * cpp];
|
||
for (c, v) in &chunks {
|
||
reference(&mut want, c, v, w, h, cpp, planar);
|
||
}
|
||
for band_rows in [1usize, 2, 4, 9, 20] {
|
||
let mut got = vec![0u16; w * h * cpp];
|
||
for (bi, band) in got.chunks_mut(band_rows * w * cpp).enumerate() {
|
||
for (c, v) in &chunks {
|
||
place_chunk(band, bi * band_rows, c, v, w, h, cpp, planar);
|
||
}
|
||
}
|
||
assert_eq!(got, want, "cpp {cpp} planar {planar} band rows {band_rows}");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[cfg(feature = "dng")]
|
||
mod lossy_tests {
|
||
use super::*;
|
||
use craft_tiff::image::Layout;
|
||
|
||
/// 65 536 tiles all pointing at the same 256 bytes: the image's samples can't come from them,
|
||
/// and nothing of its size is allocated to find that out.
|
||
#[test]
|
||
fn tiles_sharing_one_payload_count_its_bytes_once() {
|
||
// (longer than its tile count: craft-tiff builds at most one chunk per byte of file, and a shorter
|
||
// file is refused for its missing chunks before the bytes are counted)
|
||
let file = vec![0u8; 65_536 + 8];
|
||
let info = ImageInfo {
|
||
width: 4096,
|
||
height: 4096,
|
||
bits_per_sample: vec![8],
|
||
samples_per_pixel: 1,
|
||
compression: comp::NONE,
|
||
photometric: 34892,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: 16, tile_height: 16 },
|
||
offsets: vec![8; 65_536],
|
||
byte_counts: vec![256; 65_536],
|
||
};
|
||
let err = check_image(&file, &info, &Limits::default()).unwrap_err().to_string();
|
||
assert!(err.contains("cannot hold"), "{err}");
|
||
// A file shorter than its tile count must reach the same refusal: the table, not the byte-capped
|
||
// chunk list, says how many chunks the image declares (storytold/lightcraft#4165).
|
||
let short = vec![0u8; 8 + 256];
|
||
let err = check_image(&short, &info, &Limits::default()).unwrap_err().to_string();
|
||
assert!(err.contains("cannot hold"), "{err}");
|
||
}
|
||
|
||
/// A lossy-DNG-style image: two 16×8 tiles, each a baseline JPEG, the right one cut short
|
||
/// by the image edge.
|
||
#[test]
|
||
fn lossy_jpeg_tiles_decode() {
|
||
let (tw, th) = (16usize, 8usize);
|
||
let tile = |shade: u8| {
|
||
let px: Vec<u8> = (0..tw * th).flat_map(|i| [shade, (i % tw * 15) as u8, 200]).collect();
|
||
let mut out = Vec::new();
|
||
jpeg_encoder::Encoder::new(&mut out, 100).encode(&px, tw as u16, th as u16, jpeg_encoder::ColorType::Rgb).unwrap();
|
||
out
|
||
};
|
||
let (a, b) = (tile(40), tile(220));
|
||
let mut file = vec![0u8; 8];
|
||
let oa = file.len() as u64;
|
||
file.extend_from_slice(&a);
|
||
let ob = file.len() as u64;
|
||
file.extend_from_slice(&b);
|
||
let info = ImageInfo {
|
||
width: 24,
|
||
height: 8,
|
||
bits_per_sample: vec![8, 8, 8],
|
||
samples_per_pixel: 3,
|
||
compression: comp::LOSSY_JPEG,
|
||
photometric: 34892,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: tw as u32, tile_height: th as u32 },
|
||
offsets: vec![oa, ob],
|
||
byte_counts: vec![a.len() as u64, b.len() as u64],
|
||
};
|
||
let RawData::U16(v) = read_image(&file, &info, ByteOrder::Little, Packing::Msb, &Limits::default()).unwrap() else {
|
||
panic!("integer samples")
|
||
};
|
||
assert_eq!(v.len(), 24 * 8 * 3);
|
||
let px = |x: usize, y: usize| &v[(y * 24 + x) * 3..(y * 24 + x) * 3 + 3];
|
||
assert!((px(2, 3)[0] as i32 - 40).abs() <= 3 && (px(2, 3)[2] as i32 - 200).abs() <= 3, "{:?}", px(2, 3));
|
||
assert!((px(20, 3)[0] as i32 - 220).abs() <= 3, "second tile: {:?}", px(20, 3));
|
||
assert!((px(10, 5)[1] as i32 - 150).abs() <= 6, "green ramp: {:?}", px(10, 5));
|
||
}
|
||
|
||
/// A small tile may not decode a JPEG much larger than itself (a table of tiny tiles all pointing at one big
|
||
/// JPEG would decode it once per tile); a JPEG that fills the tile's whole 32 × 32 MCU block still decodes.
|
||
#[test]
|
||
fn a_lossy_tile_may_not_decode_a_much_larger_jpeg() {
|
||
let encode = |w: usize, h: usize| {
|
||
let mut out = Vec::new();
|
||
jpeg_encoder::Encoder::new(&mut out, 90).encode(&vec![128u8; w * h * 3], w as u16, h as u16, jpeg_encoder::ColorType::Rgb).unwrap();
|
||
out
|
||
};
|
||
let image = |jpeg: &[u8]| {
|
||
let mut file = vec![0u8; 8];
|
||
file.extend_from_slice(jpeg);
|
||
let info = ImageInfo {
|
||
width: 4,
|
||
height: 4,
|
||
bits_per_sample: vec![8, 8, 8],
|
||
samples_per_pixel: 3,
|
||
compression: comp::LOSSY_JPEG,
|
||
photometric: 34892,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: 16, tile_height: 16 },
|
||
offsets: vec![8],
|
||
byte_counts: vec![jpeg.len() as u64],
|
||
};
|
||
read_image(&file, &info, ByteOrder::Little, Packing::Msb, &Limits::default())
|
||
};
|
||
assert!(image(&encode(32, 32)).is_ok());
|
||
assert!(matches!(image(&encode(256, 256)), Err(RawError::Corrupt(_))));
|
||
}
|
||
|
||
/// A Deflate tile that is nearly all padding outside the image (a 4096 × 4096 tile holding one column of a
|
||
/// 4097-wide picture) is refused before its nominal buffer is inflated; the writer's largest padded tile
|
||
/// (2048 × 2048) is within the slack (`dngwrite`'s clamp test).
|
||
#[test]
|
||
fn a_deflate_tile_that_is_mostly_padding_is_refused() {
|
||
let file = vec![0u8; 8 + 8192];
|
||
let info = ImageInfo {
|
||
width: 4097,
|
||
height: 4096,
|
||
bits_per_sample: vec![8],
|
||
samples_per_pixel: 1,
|
||
compression: comp::ADOBE_DEFLATE,
|
||
photometric: 32803,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: 4096, tile_height: 4096 },
|
||
offsets: vec![8, 8],
|
||
byte_counts: vec![8192, 8192],
|
||
};
|
||
let chunks = info.chunks(file.len() as u64);
|
||
let edge = decode_chunk(&file, &info, &chunks[1], ByteOrder::Little, Packing::Msb, 1, 8, false, &Limits::default());
|
||
assert!(matches!(edge, Err(RawError::Limit(_))), "{:?}", edge.err());
|
||
}
|
||
|
||
fn strip_info(compression: u16, offsets: Vec<u64>, byte_counts: Vec<u64>) -> ImageInfo {
|
||
ImageInfo {
|
||
width: 4,
|
||
height: 4,
|
||
bits_per_sample: vec![8],
|
||
samples_per_pixel: 1,
|
||
compression,
|
||
photometric: 1,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Strips { rows_per_strip: 2 },
|
||
offsets,
|
||
byte_counts,
|
||
}
|
||
}
|
||
|
||
/// A missing strip or a strip that fails to decode is an error, not a black band in a "successful" image.
|
||
#[test]
|
||
fn missing_or_failed_chunks_are_errors() {
|
||
let file = vec![9u8; 8 + 8];
|
||
// both strips present
|
||
let ok = strip_info(comp::NONE, vec![0, 8], vec![8, 8]);
|
||
assert!(read_image(&file, &ok, ByteOrder::Little, Packing::Msb, &Limits::default()).is_ok());
|
||
// the second strip has no offset
|
||
let missing = strip_info(comp::NONE, vec![0], vec![8]);
|
||
assert!(read_image(&file, &missing, ByteOrder::Little, Packing::Msb, &Limits::default()).is_err());
|
||
// the header-only read rejects it too, as the full decode will
|
||
assert!(read_image_in(crate::Mode::Header, &file, &missing, ByteOrder::Little, Packing::Msb, &Limits::default()).is_err());
|
||
// the second strip starts past the end of the file
|
||
let past_end = strip_info(comp::NONE, vec![0, 100], vec![8, 8]);
|
||
assert!(read_image(&file, &past_end, ByteOrder::Little, Packing::Msb, &Limits::default()).is_err());
|
||
}
|
||
|
||
/// A small image whose uncompressed tile claims to be enormous (2048 x 2048 nominal, a few bytes of data) is
|
||
/// refused before that tile is allocated (storytold/lightcraft#1512); an edge tile stored at its full nominal size decodes. (A
|
||
/// tile larger still is refused by `check_image` before any decode: `tiles_far_larger_than_the_image_are_refused`.)
|
||
#[test]
|
||
fn a_huge_nominal_uncompressed_tile_with_little_data_is_refused() {
|
||
let info = |tile: u32, bytes: u64| ImageInfo {
|
||
width: 8,
|
||
height: 8,
|
||
bits_per_sample: vec![16],
|
||
samples_per_pixel: 1,
|
||
compression: comp::NONE,
|
||
photometric: 32803,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: tile, tile_height: tile },
|
||
offsets: vec![0],
|
||
byte_counts: vec![bytes],
|
||
};
|
||
let small = vec![1u8; 2 * 16 * 16];
|
||
assert!(read_image(&small, &info(16, small.len() as u64), ByteOrder::Little, Packing::Msb, &Limits::default()).is_ok());
|
||
let data = vec![1u8; 4096];
|
||
assert!(matches!(
|
||
read_image(&data, &info(2048, data.len() as u64), ByteOrder::Little, Packing::Msb, &Limits::default()),
|
||
Err(RawError::Corrupt(_))
|
||
));
|
||
}
|
||
|
||
/// A 16 × 16 image whose lossless-JPEG tile claims to be 16384 × 16384 (coded only as tall as the image, so the
|
||
/// file is small) is refused before the tile is allocated, by the header check too (storytold/lightcraft#2554); a 256 × 256
|
||
/// tile on the same image, as a writer with a fixed tile size stores it, still decodes.
|
||
#[test]
|
||
fn tiles_far_larger_than_the_image_are_refused() {
|
||
let read = |tile: u32, mode: crate::Mode| {
|
||
let t = ljpeg::encode(&vec![300u16; tile as usize * 16], tile as usize, 16, 1, 12, 1, 0);
|
||
let info = ImageInfo {
|
||
width: 16,
|
||
height: 16,
|
||
bits_per_sample: vec![12],
|
||
samples_per_pixel: 1,
|
||
compression: comp::JPEG,
|
||
photometric: 32803,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: tile, tile_height: tile },
|
||
offsets: vec![0],
|
||
byte_counts: vec![t.len() as u64],
|
||
};
|
||
read_image_in(mode, &t, &info, ByteOrder::Little, Packing::Msb, &Limits::default())
|
||
};
|
||
assert_eq!(read(256, crate::Mode::Full), Ok(RawData::U16(vec![300; 16 * 16])));
|
||
for mode in [crate::Mode::Header, crate::Mode::Full] {
|
||
assert!(matches!(read(16384, mode), Err(RawError::Limit(_))));
|
||
}
|
||
}
|
||
|
||
/// A lossless-JPEG tile may be coded only as tall as the part inside the image, never shorter.
|
||
#[test]
|
||
fn short_lossless_jpeg_tiles_are_errors() {
|
||
let tile = |rows: usize| ljpeg::encode(&vec![300u16; 8 * rows], 8, rows, 1, 12, 1, 0);
|
||
let decode = |height: u32, rows: usize| {
|
||
let t = tile(rows);
|
||
let info = ImageInfo {
|
||
width: 8,
|
||
height,
|
||
bits_per_sample: vec![12],
|
||
samples_per_pixel: 1,
|
||
compression: comp::JPEG,
|
||
photometric: 32803,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: 8, tile_height: 8 },
|
||
offsets: vec![0],
|
||
byte_counts: vec![t.len() as u64],
|
||
};
|
||
read_image(&t, &info, ByteOrder::Little, Packing::Msb, &Limits::default())
|
||
};
|
||
// an edge tile coded at its in-image height, and a full tile
|
||
assert_eq!(decode(6, 6), Ok(RawData::U16(vec![300; 8 * 6])));
|
||
assert_eq!(decode(8, 8), Ok(RawData::U16(vec![300; 8 * 8])));
|
||
// half of the visible rows are missing
|
||
assert!(decode(8, 4).is_err());
|
||
}
|
||
|
||
/// A lossy JPEG whose header alone claims more samples than any real tile or preview (here
|
||
/// 40000 × 40000 × 3) is refused from the header, before the decoder allocates its output
|
||
/// from the JPEG's own dimensions.
|
||
#[test]
|
||
fn an_oversized_lossy_jpeg_header_is_refused_before_decoding() {
|
||
// A real 8 × 8 baseline JPEG, whose frame header then claims other dimensions: the decoder
|
||
// parses the header, and the size check is what refuses it.
|
||
let px = vec![128u8; 8 * 8 * 3];
|
||
let mut j = Vec::new();
|
||
jpeg_encoder::Encoder::new(&mut j, 90).encode(&px, 8, 8, jpeg_encoder::ColorType::Rgb).unwrap();
|
||
// SOF0: marker, length, precision, then the height and the width
|
||
let sof = j.windows(2).position(|w| w == [0xff, 0xc0]).expect("a baseline frame header");
|
||
let claim = |j: &mut Vec<u8>, size: u16| {
|
||
j[sof + 5..sof + 7].copy_from_slice(&size.to_be_bytes());
|
||
j[sof + 7..sof + 9].copy_from_slice(&size.to_be_bytes());
|
||
};
|
||
claim(&mut j, 40_000);
|
||
let RawError::Corrupt(refused) = lossy_jpeg(&j, 3, 1 << 26).unwrap_err() else { panic!("a corrupt-data error") };
|
||
assert!(refused.contains("would exceed"), "{refused}");
|
||
// a header inside the budget passes the size check (and then fails to decode only for lack of data)
|
||
claim(&mut j, 1024);
|
||
match lossy_jpeg(&j, 3, 1 << 26) {
|
||
Ok(_) => {}
|
||
Err(RawError::Corrupt(m)) => assert!(!m.contains("would exceed"), "the smaller header was refused for its size: {m}"),
|
||
Err(other) => panic!("unexpected error: {other:?}"),
|
||
}
|
||
}
|
||
|
||
/// A lossy tile whose JPEG decodes far less than the nominal tile is fine: the rows the JPEG
|
||
/// covers hold its pixels, the rest of the output stays zero (and the tile's intermediate buffer
|
||
/// is sized by the JPEG, not by the nominal tile).
|
||
#[test]
|
||
fn a_lossy_jpeg_covers_its_tiles_part_of_the_image_or_is_refused() {
|
||
let px: Vec<u8> = (0..8 * 8).flat_map(|_| [30u8, 90, 150]).collect();
|
||
let mut j = Vec::new();
|
||
jpeg_encoder::Encoder::new(&mut j, 100).encode(&px, 8, 8, jpeg_encoder::ColorType::Rgb).unwrap();
|
||
let info = |width: u32, height: u32| ImageInfo {
|
||
width,
|
||
height,
|
||
bits_per_sample: vec![8, 8, 8],
|
||
samples_per_pixel: 3,
|
||
compression: comp::LOSSY_JPEG,
|
||
photometric: 34892,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: 16, tile_height: 16 },
|
||
offsets: vec![0],
|
||
byte_counts: vec![j.len() as u64],
|
||
};
|
||
// an 8 × 8 image in one nominal 16 × 16 tile: the JPEG covers what is inside the image
|
||
let RawData::U16(v) = read_image(&j, &info(8, 8), ByteOrder::Little, Packing::Msb, &Limits::default()).unwrap() else {
|
||
panic!("integer samples")
|
||
};
|
||
assert_eq!(v.len(), 8 * 8 * 3);
|
||
let at = |x: usize, y: usize| &v[(y * 8 + x) * 3..(y * 8 + x) * 3 + 3];
|
||
assert!((at(3, 3)[0] as i32 - 30).abs() <= 3 && (at(7, 7)[2] as i32 - 150).abs() <= 3, "{:?}", at(3, 3));
|
||
// a 16 × 16 image: the same JPEG would leave three quarters of it black
|
||
for (w, h) in [(16, 16), (9, 8), (8, 9)] {
|
||
let err = read_image(&j, &info(w, h), ByteOrder::Little, Packing::Msb, &Limits::default()).unwrap_err();
|
||
assert!(matches!(&err, RawError::Corrupt(m) if m.contains("does not cover")), "{w} × {h}: {err}");
|
||
}
|
||
}
|
||
|
||
/// A deflated tile is refused when its packed bytes are too few for deflate to have produced
|
||
/// the nominal chunk, or when the stream stops short of the rows inside the image; a fully
|
||
/// covered flat tile still decodes.
|
||
#[test]
|
||
fn a_short_or_undercovering_deflated_tile_is_refused() {
|
||
let info = |byte_counts: u64| ImageInfo {
|
||
width: 512,
|
||
height: 512,
|
||
bits_per_sample: vec![16],
|
||
samples_per_pixel: 1,
|
||
compression: comp::ADOBE_DEFLATE,
|
||
photometric: 32803,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: 512, tile_height: 512 },
|
||
offsets: vec![0],
|
||
byte_counts: vec![byte_counts],
|
||
};
|
||
// a complete flat tile: 512 KiB of zeros compresses to a few hundred bytes (well within
|
||
// deflate's packing bound) and inflates to every nominal byte the tile claims
|
||
let zlib = miniz_oxide::deflate::compress_to_vec_zlib(&vec![0u8; 512 * 512 * 2], 6);
|
||
assert_eq!(
|
||
read_image(&zlib, &info(zlib.len() as u64), ByteOrder::Little, Packing::Msb, &Limits::default()),
|
||
Ok(RawData::U16(vec![0; 512 * 512]))
|
||
);
|
||
// the same 1 KiB packed, but the stream claims a whole tile: a few hundred bytes cannot
|
||
// reconstruct 512 KiB from a decoder that compresses no further than about 1:1032
|
||
let zlib = miniz_oxide::deflate::compress_to_vec_zlib(&vec![0u8; 1024], 6);
|
||
assert!(
|
||
matches!(read_image(&zlib, &info(512 * 512 * 2), ByteOrder::Little, Packing::Msb, &Limits::default()), Err(RawError::Corrupt(_))),
|
||
"{zlib:?}"
|
||
);
|
||
// 500 KiB of zeros compress to a stream within the packing bound and inflating to more
|
||
// bytes than the in-image samples span, but 24 KiB short of the whole nominal tile:
|
||
// refused as truncated rather than filled with the predictor's padding
|
||
let zlib = miniz_oxide::deflate::compress_to_vec_zlib(&vec![0u8; 500 * 1000], 6);
|
||
assert!(matches!(
|
||
read_image(&zlib, &info(zlib.len() as u64), ByteOrder::Little, Packing::Msb, &Limits::default()),
|
||
Err(RawError::Corrupt(_))
|
||
));
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod budget_tests {
|
||
use super::*;
|
||
use crate::ljpeg;
|
||
use craft_tiff::image::Layout;
|
||
use craft_tiff::tags::photometric;
|
||
|
||
/// `w`×`h` CFA image in `tile`×`tile` lossless-JPEG tiles that all point at the same `payload` bytes at offset 0.
|
||
fn aliased(w: u32, h: u32, tile: u32, payload: u64) -> ImageInfo {
|
||
let n = (w.div_ceil(tile) * h.div_ceil(tile)) as usize;
|
||
ImageInfo {
|
||
width: w,
|
||
height: h,
|
||
bits_per_sample: vec![14],
|
||
samples_per_pixel: 1,
|
||
compression: 7,
|
||
photometric: photometric::CFA,
|
||
planar: 1,
|
||
predictor: 1,
|
||
sample_format: 1,
|
||
new_subfile_type: 0,
|
||
layout: Layout::Tiles { tile_width: tile, tile_height: tile },
|
||
offsets: vec![0; n],
|
||
byte_counts: vec![payload; n],
|
||
}
|
||
}
|
||
|
||
/// storytold/lightcraft#2554: 16 tiles of 256×256 sharing one 1 KiB payload pass the generic 2048-samples-per-byte bound (1 Mi samples
|
||
/// from 1 KiB) but no lossless JPEG holds that many samples in those bytes.
|
||
#[test]
|
||
fn lossless_jpeg_tiles_sharing_a_payload_are_refused() {
|
||
let data = vec![0u8; 1024];
|
||
let info = aliased(1024, 1024, 256, 1024);
|
||
assert!(matches!(check_image(&data, &info, &Limits::default()), Err(RawError::Corrupt(_))));
|
||
// the same grid declared as Deflate (~2000 samples per byte at most) still passes this check
|
||
let deflate = ImageInfo { compression: 8, ..info };
|
||
assert!(check_image(&data, &deflate, &Limits::default()).is_ok());
|
||
}
|
||
|
||
/// Tiles may share one payload (a writer storing identical tiles once): each reference decodes its payload in full,
|
||
/// so 32 constant 256×256 lossless-JPEG tiles pointing at one tile's bytes decode (header check and full decode),
|
||
/// though the shared bytes alone are far fewer than one bit per sample of the image.
|
||
#[test]
|
||
fn lossless_jpeg_tiles_sharing_a_real_tile_decode() {
|
||
let tile = ljpeg::encode(&vec![300u16; 256 * 256], 256, 256, 1, 12, 1, 0);
|
||
let info = ImageInfo { bits_per_sample: vec![12], byte_counts: vec![tile.len() as u64; 32], ..aliased(2048, 1024, 256, 0) };
|
||
// one copy of the bytes holds fewer than 32 samples per byte of the whole grid: a unique-byte bound refused it
|
||
assert!((tile.len() as u64) * 32 < 2048 * 1024, "{} bytes", tile.len());
|
||
assert!(read_image_in(crate::Mode::Header, &tile, &info, ByteOrder::Little, Packing::Msb, &Limits::default()).is_ok());
|
||
assert_eq!(read_image(&tile, &info, ByteOrder::Little, Packing::Msb, &Limits::default()), Ok(RawData::U16(vec![300; 2048 * 1024])));
|
||
}
|
||
|
||
/// The unique-byte bound still caps a large grid of tiles sharing a small payload: 256 tiles of 256×256 (16 Mi
|
||
/// samples) referencing the same 8000 bytes pass the per-reference lossless-JPEG bound (2 MB referenced) but those
|
||
/// 8000 bytes cannot hold 16 Mi samples, so nothing is reserved.
|
||
#[test]
|
||
fn a_huge_grid_sharing_a_small_payload_is_still_refused() {
|
||
let data = vec![0u8; 8000];
|
||
let info = aliased(4096, 4096, 256, 8000);
|
||
for mode in [crate::Mode::Header, crate::Mode::Full] {
|
||
let err = read_image_in(mode, &data, &info, ByteOrder::Little, Packing::Msb, &Limits::default()).unwrap_err();
|
||
assert!(matches!(&err, RawError::Corrupt(m) if m.contains("8000 bytes of image data")), "{err:?}");
|
||
}
|
||
}
|
||
|
||
/// storytold/lightcraft#2554: tiled decoders decode the grid in groups of at most a quarter of the image (1 Mi samples at
|
||
/// least), each group at least one chunk, covering every chunk once and in order.
|
||
#[cfg(feature = "arw")]
|
||
#[test]
|
||
fn decode_groups_split_the_grid() {
|
||
let info = aliased(4096, 4096, 512, 64);
|
||
let chunks = info.chunks(64);
|
||
assert_eq!(chunks.len(), 64);
|
||
let groups = decode_groups(&chunks, 1, 4096 * 4096);
|
||
// a quarter of 16 Mi samples is 4 Mi: 16 tiles of 256 Ki samples per group
|
||
assert_eq!(groups.len(), 4);
|
||
assert!(groups.iter().all(|g| g.len() == 16));
|
||
assert_eq!(groups.first().map(|g| g.start), Some(0));
|
||
assert!(groups.windows(2).all(|p| p[0].end == p[1].start));
|
||
assert_eq!(groups.last().map(|g| g.end), Some(64));
|
||
// a tile larger than the budget is still a group of its own
|
||
let big = aliased(8192, 8192, 8192, 64);
|
||
assert_eq!(decode_groups(&big.chunks(64), 1, 1 << 20), vec![0..1]);
|
||
}
|
||
}
|
||
|
||
#[cfg(all(test, feature = "dng"))]
|
||
mod compat_review_tests;
|