Files
craft-libs/crates/raw/src/orf.rs
T
FredApps a99c8f8e36 raw: leave LinearizationTable unapplied when OpcodeList1 is present
DNG chapter 7 runs OpcodeList1 on the stored codes, then the
LinearizationTable maps them to sensor values. decode was applying the
table first, so a develop pipeline that later applied list 1 saw already
linearized samples.

When list 1 is present the table is now carried on RawImage and left
unapplied (`linearized` stays false). apply_linearization maps it after
the list. Files without list 1 are unchanged.

The dng-only build already compiles on main (d16ee792 gated
cr3::orientation). A comment at that gate records the E0433 failure
mode.

Part of #778.
2026-11-15 21:26:02 +01:00

935 lines
47 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.
//! Olympus ORF — uncompressed variants; compressed sensor data is unsupported.
//!
//! Sources: TIFF 6.0 (the `IIRO`/`MMOR` container is a TIFF with a different magic number), Exif 2.3 (`CFAPattern`,
//! tag `0xa302`), the ExifTool Olympus tag-name documentation (maker-note sub-directories `0x2020` CameraSettings —
//! `0x0101/0x0102` PreviewImageStart/Length — and `0x2040` ImageProcessing — `0x0100` WB_RBLevels, `0x0600`
//! BlackLevel2, `0x0612–0x0615` CropLeft/Top/Width/Height) and black-box analysis of CC0 samples from
//! raw.pixls.us (E-1, E-400, XZ-2):
//!
//! - 16 bits per sample: little-endian words; some bodies (E-1, E-400) store 12-bit values in the top bits (the low
//! four bits zero in more than 99% of samples), which we shift down.
//! - 12-bit packed (XZ-2): each row is a sequence of little-endian 32-bit words read MSB-first (found by testing
//! candidate bit orders for the smoothest image).
//! - 12-bit packed in two fields (a few old compacts): IFD0 says uncompressed, 12 bits, many strips, and the strip
//! byte counts add up to exactly width × height × 1.5. Samples are packed MSB-first, two per three bytes
//! (`b0 << 4 | b1 >> 4`, `(b1 & 15) << 8 | b2`), rows are `width × 1.5` bytes with no padding. Stored rows
//! `0..h0` are the even output rows and the rows from `h0` on the odd ones (`h0 = (height + 1) / 2`, height
//! odd); the strip table has one gap where the second field starts (follow the offsets) and omits the last row
//! of the second field, which sits in the bytes right after the last strip. Derived by black-box analysis of
//! six CC0 files (C5060WZ, C7070WZ, SP-510UZ, SP-550UZ, SP-565UZ, SP-570UZ). Their Exif `CFAPattern` states the
//! layout (it matches the embedded thumbnails), the maker note's entries `0x1017`/`0x1018` hold the red and
//! blue gain (first value, 256 = 1.0; checked against neutral areas of the thumbnail), and nothing states a
//! black level or an active area.
//! - 12-bit blocks (E-300, E-500, E-330; the E-M5 Mark II and PEN-F high-resolution files): one strip of 12.8 bits
//! per pixel, `width * 8 / 5` bytes per row, made of 16-byte blocks. A block is 15 sample bytes followed by one
//! pad byte that is always zero; the 15 bytes are a little-endian 120-bit string holding ten 12-bit samples, sample
//! `i` at bits `[12 i, 12 i + 12)`, i.e. per byte triple `s0 = b0 | (b1 & 15) << 8`, `s1 = b1 >> 4 | b2 << 4`, left
//! to right. The layout was first recalled only roughly ("ten pixels, then a skipped byte"); the pad position
//! (last), the bit order and the pixel order were fixed by measurement on the CC0 files 2878 (E-300), 3540 (E-500)
//! and 3624 (E-330), as was the sensor-origin RGGB anchoring (the maker-note crop offsets are odd). The E-M5 Mark II
//! and PEN-F files were only checked for smoothness, not for CFA anchoring or black level.
//! - Compressed ORF sensor data is unsupported. The previous decoder was removed pending provenance
//! resolution; embedded previews remain available. See `docs/orf-compression.md`.
//! - The colour-filter layout is the file's Exif `CFAPattern`: GRBG on the E-1 and E-400, RGGB on the XZ-2, where
//! the colours of the decoded mosaic follow the embedded JPEG best with exactly that layout
//! (`corpus_orf_cfa_patterns`). The samples' active areas start at even offsets, so they can't tell whether the
//! pattern is anchored at the sensor origin (assumed) or at the active area. Files without a usable tag fall back
//! to the green diagonal found from the data, which can't tell red from blue (GRBG or RGGB is assumed).
use crate::shared::{cfa_from_exif, white_from_data_sourced};
use crate::tiffraw::{Packing, read_image};
use crate::unpack::unpack_msb;
use crate::{BlackLevel, Camera, Cfa, ColorData, Limits, Mode, OpcodeLists, Orientation, RawData, RawError, RawFormat, RawImage, Rect, Result};
use craft_tiff::image::chunk_bytes;
use craft_tiff::makernote::MakerNote;
use craft_tiff::{Ifd, Tiff, Value, makernote, tags as t};
use rayon::prelude::*;
const CAMERA_SETTINGS: u16 = 0x2020;
const IMAGE_PROCESSING: u16 = 0x2040;
const PREVIEW_START: u16 = 0x0101;
const PREVIEW_LENGTH: u16 = 0x0102;
const WB_RB: u16 = 0x0100;
/// ImageProcessing WB_GLevel: the green level the red and blue levels are relative to (256 when absent).
const WB_G: u16 = 0x011f;
const BLACK: u16 = 0x0600;
const MN_WB_RED: u16 = 0x1017;
const MN_WB_BLUE: u16 = 0x1018;
const MN_BLACK: u16 = 0x1012;
const MN_VALID_BITS: u16 = 0x102c;
const CROP: [u16; 4] = [0x0612, 0x0613, 0x0614, 0x0615];
/// The Olympus maker note.
pub(crate) fn maker_note(bytes: &[u8], tiff: &Tiff) -> Option<MakerNote> {
let make = tiff.find(t::MAKE).and_then(|e| e.value.as_str()).unwrap_or_default().to_string();
let e = tiff.exif().and_then(|e| e.get(t::MAKER_NOTE))?;
makernote::parse_makernote(bytes, e.offset, e.count() as u64, tiff.order, &make)
}
/// A maker-note sub-directory: an IFD pointer (offset relative to the note's base) in new-style notes, or the
/// IFD stored inline as an undefined blob (offsets relative to the base) in old-style ones.
pub(crate) fn sub_ifd(bytes: &[u8], mn: &MakerNote, tag: u16) -> Option<Ifd> {
let e = mn.ifd.get(tag)?;
let at = match &e.value {
Value::Undefined(_) | Value::Byte(_) => e.offset,
_ => mn.base.checked_add(mn.ifd.u64(tag)?)?,
};
let opts = craft_tiff::ParseOptions { max_ifds: 4, max_depth: 1, follow_children: false, ..Default::default() };
craft_tiff::parse_ifd_at(bytes, at, mn.order, mn.base, false, &opts).ok().map(|(i, _)| i)
}
/// Black level of a body without ImageProcessing: the main note's `0x1012` BlackLevel (the mean of its four values)
/// in `0x102c` ValidBits units, scaled to the decoded `bits`. The E-10 states 32 at 10 bits, and its 12-bit samples
/// bottom out at 124 to 132; the two-field compacts state 0 at 12 bits.
fn maker_note_black(m: &MakerNote, bits: u32) -> Option<f32> {
let bits = bits.min(16);
let v = m.ifd.f64s(MN_BLACK).filter(|v| v.len() == 4)?;
let valid = m.ifd.u64(MN_VALID_BITS).and_then(|b| u32::try_from(b).ok()).filter(|b| (8..=bits).contains(b))?;
let level = v.iter().sum::<f64>() / 4.0 * f64::from(1u32 << (bits - valid));
(level >= 0.0 && level < f64::from(1u32 << bits) / 4.0).then_some(level as f32)
}
/// Unpack one row of 12-bit samples stored as little-endian 32-bit words read MSB-first.
pub(crate) fn unpack_row_le32_msb(src: &[u8], bits: u32, out: &mut [u16]) {
let swapped: Vec<u8> = src
.chunks(4)
.flat_map(|c| {
let mut w = [0u8; 4];
w[..c.len()].copy_from_slice(c);
[w[3], w[2], w[1], w[0]]
})
.collect();
unpack_msb(&swapped, bits, out);
}
/// Unpack one row of 12-bit samples stored as 16-byte blocks: ten little-endian 12-bit fields in bytes 0..15, byte 15
/// a pad. `src` must hold exactly `out.len() / 10` blocks (`out.len()` a multiple of 10).
pub(crate) fn unpack_row_blocks16(src: &[u8], out: &mut [u16]) -> Result<()> {
if !out.len().is_multiple_of(10) || src.len() != out.len() / 10 * 16 {
return Err(RawError::Corrupt("ORF 12-bit block row has the wrong size".into()));
}
let (blocks, _) = src.as_chunks::<16>();
let (pixels, _) = out.as_chunks_mut::<10>();
for (block, px) in blocks.iter().zip(pixels) {
for k in 0..5 {
let (b0, b1, b2) = (block[3 * k] as u16, block[3 * k + 1] as u16, block[3 * k + 2] as u16);
px[2 * k] = b0 | (b1 & 15) << 8;
px[2 * k + 1] = b1 >> 4 | b2 << 4;
}
}
Ok(())
}
/// Whether the strip is the 12.8 bits per pixel block layout: a single strip, rows a whole number of 16-byte
/// blocks of ten pixels.
fn is_block16(w: usize, n: usize, total: u64, chunks: usize) -> bool {
chunks == 1 && w.is_multiple_of(10) && total.checked_mul(10) == (n as u64).checked_mul(16)
}
/// The layout found from the samples, for files without the Exif tag: GRBG when the greens sit on the main
/// diagonal of the 2×2 cell at the sensor origin, else RGGB. Over 32×32-pixel blocks of `a` (every fourth in both
/// directions) it compares the block totals of the two sites on each diagonal: the two greens of a block see the
/// same light, red and blue rarely do. Totals rather than single pixels, so that fine texture, which makes
/// neighbouring greens differ, doesn't outweigh a small difference between red and blue.
pub(crate) fn cfa_from_data(d: &[u16], w: usize, a: Rect) -> Cfa {
const BLOCK: usize = 32;
let (x0, y0) = (a.x.saturating_add(1) & !1, a.y.saturating_add(1) & !1);
let across = a.x.saturating_add(a.width).min(w).saturating_sub(x0) / BLOCK;
let down = a.y.saturating_add(a.height).saturating_sub(y0) / BLOCK;
let (mut main, mut anti) = (0u64, 0u64);
for by in (0..down).step_by(4) {
for bx in (0..across).step_by(4) {
let mut sums = [0i64; 4];
for y in 0..BLOCK {
let row = (y0 + by * BLOCK + y).checked_mul(w).and_then(|r| r.checked_add(x0 + bx * BLOCK));
// rows past the end of the samples: nothing more to read
let Some(row) = row.and_then(|start| d.get(start..start.checked_add(BLOCK)?)) else { break };
for (x, &v) in row.iter().enumerate() {
sums[(y & 1) * 2 + (x & 1)] += v as i64;
}
}
let [s0, s1, s2, s3] = sums;
main += (s0 - s3).unsigned_abs();
anti += (s1 - s2).unsigned_abs();
}
}
Cfa::bayer_static(if main < anti { "GRBG" } else { "RGGB" })
}
/// Byte offsets of the stored rows of the two-field 12-bit layout, or `None` unless every condition holds
/// exactly: odd height, even width, `strips` (offset, byte count; the whole table, not just the strips that fit the
/// rows-per-strip grid, since the field seam leaves a short strip) that are whole rows summing to
/// `width × height × 1.5` bytes, exactly one gap between consecutive strips (the second field starts right after
/// it, at row `(height + 1) / 2`), and a last row, right after the final strip, inside the file. Returns
/// `height + 1` offsets.
fn field_rows(strips: &[(u64, u64)], w: usize, h: usize, file_len: usize) -> Option<Vec<usize>> {
let rb = w.checked_mul(3)? / 2;
if rb == 0 || !w.is_multiple_of(2) || h.is_multiple_of(2) || h < 3 || strips.len() < 2 {
return None;
}
let h0 = h.div_ceil(2);
let total = strips.iter().try_fold(0u64, |a, s| a.checked_add(s.1))?;
if total != (rb as u64).checked_mul(h as u64)? {
return None;
}
let mut rows = Vec::with_capacity(h + 1);
let mut gaps = 0;
let mut end = None;
for &(offset, len) in strips {
let next_end = offset.checked_add(len).filter(|e| len > 0 && len % rb as u64 == 0 && *e <= file_len as u64)?;
match end {
Some(e) if offset < e => return None,
// the gap must be the field seam
Some(e) if offset > e => {
if rows.len() != h0 {
return None;
}
gaps += 1;
}
_ => {}
}
end = Some(next_end);
let (offset, rb) = (usize::try_from(offset).ok()?, rb);
rows.extend((0..usize::try_from(len).ok()? / rb).map(|r| offset + r * rb));
}
let tail = usize::try_from(end?).ok()?;
if gaps != 1 || rows.len() != h || tail.checked_add(rb)? > file_len {
return None;
}
rows.push(tail);
Some(rows)
}
/// Decode the supported uncompressed Olympus ORF layouts into a mosaic raw image.
pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawImage> {
let tiff = Tiff::parse(bytes)?;
let ifd0 = tiff.ifds.first().ok_or_else(|| RawError::Corrupt("TIFF without IFDs".into()))?;
let info = ifd0.image()?;
let (w, h) = (info.width as usize, info.height as usize);
let n = w.checked_mul(h).filter(|n| *n > 0 && *n <= limits.samples()).ok_or(RawError::Limit("image too large"))?;
// A partial TIFF directory is damage, not evidence of an unsupported compressed layout.
// Do not infer packing from an absent strip table or from clipped sensor bytes.
if info.compression == 1
&& (info.offsets.is_empty()
|| info.offsets.len() != info.byte_counts.len()
|| info
.offsets
.iter()
.zip(&info.byte_counts)
.any(|(&at, &len)| len == 0 || at.checked_add(len).is_none_or(|end| end > bytes.len() as u64)))
{
return Err(RawError::Corrupt("ORF strip table is missing or outside file".into()));
}
let chunks = info.chunks(bytes.len() as u64);
let total = chunks.iter().fold(0u64, |a, c| a.saturating_add(c.len));
let stated = cfa_from_exif(&tiff);
let mut two_field = false;
let mn = maker_note(bytes, &tiff);
let ip = mn.as_ref().and_then(|m| sub_ifd(bytes, m, IMAGE_PROCESSING));
let (mut data, bits, from_word16) = if info.compression != 1 {
return Err(RawError::Unsupported(format!("ORF compression {}", info.compression)));
} else if total >= (n as u64) * 2 {
let d = read_image(bytes, &info, tiff.order, Packing::Word16, limits)?;
(d, 16, true)
} else if is_block16(w, n, total, chunks.len()) {
let src = chunk_bytes(bytes, &chunks[0]).ok_or_else(|| RawError::Corrupt("ORF strip outside file".into()))?;
let stride = w / 10 * 16;
if src.len() as u64 != total || src.len() / stride != h {
return Err(RawError::Corrupt("ORF strip shorter than its rows".into()));
}
let d = if mode == Mode::Full || stated.is_none() {
let mut d = vec![0u16; n];
d.par_chunks_mut(w).enumerate().try_for_each(|(y, row)| unpack_row_blocks16(&src[y * stride..(y + 1) * stride], row))?;
d
} else {
Vec::new()
};
(RawData::U16(d), 12, false)
} else if info.bits() == 12 && total * 8 >= (n as u64) * 12 && total * 8 < (n as u64) * 13 && chunks.len() == 1 {
let src = chunk_bytes(bytes, &chunks[0]).ok_or_else(|| RawError::Corrupt("ORF strip outside file".into()))?;
// Only the declared 12-bit layout is supported here. A compressed stream in a 16-bit
// ORF container must not fall through to packed decoding just because its length fits.
// the strip as it is in the file (clipped at its end), not as its tag states it: one too short
// for the samples is a truncated file, refused before they are allocated
if (src.len() as u64).saturating_mul(8) < (n as u64).saturating_mul(12) {
return Err(RawError::Corrupt("ORF strip shorter than its samples".into()));
}
// the depth is fixed here, so a header-only probe needs the samples only when the file doesn't state its
// colour-filter layout
let d = if mode == Mode::Full || stated.is_none() {
let stride = src.len() / h;
let mut d = vec![0u16; n];
d.par_chunks_mut(w).enumerate().for_each(|(y, row)| unpack_row_le32_msb(&src[y * stride..(y + 1) * stride], 12, row));
d
} else {
Vec::new()
};
(RawData::U16(d), 12, false)
} else if let Some(rows) = (info.bits() == 12 && info.samples_per_pixel == 1 && info.planar != 2 && info.offsets.len() == info.byte_counts.len())
.then(|| field_rows(&info.offsets.iter().copied().zip(info.byte_counts.iter().copied()).collect::<Vec<_>>(), w, h, bytes.len()))
.flatten()
{
two_field = true;
let d = if mode == Mode::Full || stated.is_none() {
let (rb, h0) = (w * 3 / 2, h.div_ceil(2));
let mut d = vec![0u16; n];
d.par_chunks_mut(w).enumerate().for_each(|(y, row)| {
let stored = if y % 2 == 0 { y / 2 } else { h0 + y / 2 };
// every offset was checked against the file by `field_rows`
if let Some(src) = rows.get(stored).and_then(|&at| bytes.get(at..at + rb)) {
unpack_msb(src, 12, row);
}
});
d
} else {
Vec::new()
};
(RawData::U16(d), 12, false)
} else {
return Err(RawError::Unsupported("Olympus compressed ORF".into()));
};
let RawData::U16(ref mut samples) = data else { return Err(RawError::Unsupported("float ORF".into())) };
let bits = if from_word16 && bits == 16 && samples.iter().step_by(7).filter(|v| *v & 15 != 0).count() * 700 <= n {
// 12-bit values stored in the top bits
samples.par_iter_mut().for_each(|v| *v >>= 4);
12
} else if from_word16 && bits == 16 {
let mx = samples.iter().step_by(31).max().copied().unwrap_or(0);
if mx < 4096 {
12
} else if mx < 16384 {
14
} else {
16
}
} else {
bits
};
let active = match ip.as_ref().map(|i| CROP.map(|tag| i.u64(tag).map(|v| v as usize))) {
// checked: the tags are file data; `x + cw` on a hostile value would wrap past the bounds
Some([Some(x), Some(y), Some(cw), Some(ch)])
if cw > 0 && ch > 0 && x.checked_add(cw).is_some_and(|end| end <= w) && y.checked_add(ch).is_some_and(|end| end <= h) =>
{
Rect::new(x, y, cw, ch)
}
_ => Rect::new(0, 0, w, h),
};
let assumed_cfa = stated.is_none();
let cfa = stated.unwrap_or_else(|| cfa_from_data(samples, w, active));
let (black, black_source) = match ip.as_ref().and_then(|i| i.f64s(BLACK)).as_deref() {
Some(v @ [_, _, _, _]) => {
let a = cfa.shifted(active.x, active.y);
let values = a.pattern.iter().map(|&c| [v[0], (v[1] + v[2]) / 2.0, v[3]][c as usize] as f32).collect();
(BlackLevel { repeat_rows: 2, repeat_cols: 2, values, ..Default::default() }, crate::LevelSource::Metadata)
}
_ => match mn.as_ref().filter(|_| ip.is_none()).and_then(|m| maker_note_black(m, bits)) {
Some(b) => (BlackLevel::uniform(b), crate::LevelSource::Metadata),
None => (BlackLevel::uniform(0.0), crate::LevelSource::Fallback),
},
};
let wb = ip
.as_ref()
.and_then(|i| Some((i.f64s(WB_RB)?, i.f64(WB_G).filter(|g| *g > 0.0 && g.is_finite()).unwrap_or(256.0))))
.filter(|(v, _)| v.len() >= 2 && v[0] > 0.0 && v[1] > 0.0)
.map(|(v, g)| [(v[0] / g) as f32, 1.0, (v[1] / g) as f32])
.or_else(|| {
// the red and blue gains lead the main note's entries 0x1017/0x1018 on the two-field compacts and on
// the E-10 (16-bit words, no ImageProcessing; 384 and 406 on its CC0 file 5424)
let m = mn.as_ref().filter(|_| two_field || ip.is_none())?;
let g = |tag| m.ifd.f64s(tag).and_then(|v| v.first().copied()).filter(|g| *g > 25.6 && *g < 2560.0);
Some([(g(MN_WB_RED)? / 256.0) as f32, 1.0, (g(MN_WB_BLUE)? / 256.0) as f32])
});
let (white, white_source) = white_from_data_sourced(samples, bits);
let img = RawImage {
format: RawFormat::Orf,
width: w,
height: h,
cpp: 1,
data,
cfa: Some(cfa),
bits,
black,
white: vec![white],
active_area: active,
crop: Rect::new(0, 0, active.width, active.height),
orientation: Orientation::from_exif(ifd0.u16(t::ORIENTATION).unwrap_or(1)),
color: ColorData::default(),
wb_multipliers: wb,
linearized: false,
linearization_table: None,
pixel_aspect: 1.0,
opcodes: OpcodeLists::default(),
camera: tiff.ifds.first().map(Camera::from_ifd0).unwrap_or_default(),
cinema: Default::default(),
lens_metadata: Default::default(),
notices: crate::RawNotices { assumed_cfa, ..Default::default() },
level_sources: crate::LevelSources { black: black_source, white: white_source },
};
img.validate_for(mode)?;
Ok(img)
}
/// The large preview JPEG referenced by CameraSettings `PreviewImageStart/Length` (relative to the note base).
pub(crate) fn preview(bytes: &[u8]) -> Option<&[u8]> {
let tiff = Tiff::parse(bytes).ok()?;
let mn = maker_note(bytes, &tiff)?;
let cs = sub_ifd(bytes, &mn, CAMERA_SETTINGS)?;
let start = mn.base.checked_add(cs.u64(PREVIEW_START)?)? as usize;
let len = cs.u64(PREVIEW_LENGTH)? as usize;
bytes.get(start..start.checked_add(len)?.min(bytes.len()))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::EXIF_CFA_PATTERN;
use craft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter};
fn orf(w: u32, h: u32, bits: u16, strip: Vec<u8>) -> Vec<u8> {
orf_with(w, h, bits, strip, None)
}
/// A minimal ORF with one strip in IFD0 and, optionally, an Exif `CFAPattern`.
fn orf_with(w: u32, h: u32, bits: u16, strip: Vec<u8>, cfa_pattern: Option<&[u8]>) -> Vec<u8> {
orf_with_note(w, h, bits, strip, cfa_pattern, None)
}
/// [`orf_with`] plus an optional maker note blob in the Exif IFD.
fn orf_with_note(w: u32, h: u32, bits: u16, strip: Vec<u8>, cfa_pattern: Option<&[u8]>, note: Option<Vec<u8>>) -> Vec<u8> {
let mut ifd = IfdBuilder::new();
ifd.set(t::IMAGE_WIDTH, Value::Long(vec![w]));
ifd.set(t::IMAGE_LENGTH, Value::Long(vec![h]));
ifd.set(t::BITS_PER_SAMPLE, Value::Short(vec![bits]));
ifd.set(t::COMPRESSION, Value::Short(vec![1]));
ifd.set(t::PHOTOMETRIC, Value::Short(vec![1]));
ifd.set(t::MAKE, Value::Ascii("OLYMPUS IMAGING CORP.".into()));
ifd.set_image(ImageData::Strips { rows_per_strip: h, strips: vec![strip] });
if cfa_pattern.is_some() || note.is_some() {
let mut exif = IfdBuilder::new();
if let Some(p) = cfa_pattern {
exif.set(EXIF_CFA_PATTERN, Value::Undefined(p.to_vec()));
}
if let Some(n) = note {
exif.set(t::MAKER_NOTE, Value::Undefined(n));
}
ifd.set_child(t::EXIF_IFD, exif);
}
let mut b = TiffWriter::new(ByteOrder::Little, false).write(&[ifd]).unwrap();
b[2] = b'R';
b[3] = b'O';
b
}
/// A 16-bit container with a short sensor stream is not the supported 12-bit packed layout.
/// Both entry points must report unsupported rather than returning fabricated sensor pixels.
#[test]
fn compressed_sensor_data_is_unsupported_in_probe_and_decode() {
for strip_len in [8, 24, 25] {
let bytes = orf_with(4, 4, 16, vec![0; strip_len], Some(&[2, 0, 2, 0, 0, 1, 1, 2]));
assert!(matches!(crate::decode(&bytes), Err(RawError::Unsupported(why)) if why == "Olympus compressed ORF"));
assert!(matches!(crate::probe_info(&bytes), Err(RawError::Unsupported(why)) if why == "Olympus compressed ORF"));
}
}
#[test]
fn truncated_uncompressed_directory_and_strip_are_corrupt_not_compressed() {
let mut bytes = orf_with(4, 4, 16, vec![0; 32], Some(&[2, 0, 2, 0, 0, 1, 1, 2]));
// TiffWriter puts image chunks before its directory/metadata, so EOF is not a
// required sensor byte. Relocate the declared strip to EOF without changing it.
let directory = u32::from_le_bytes(bytes[4..8].try_into().unwrap()) as usize;
let count = u16::from_le_bytes(bytes[directory..directory + 2].try_into().unwrap()) as usize;
let entry = (0..count)
.map(|i| directory + 2 + i * 12)
.find(|&at| u16::from_le_bytes(bytes[at..at + 2].try_into().unwrap()) == t::STRIP_OFFSETS)
.unwrap();
let old_offset = u32::from_le_bytes(bytes[entry + 8..entry + 12].try_into().unwrap()) as usize;
let pixels = bytes[old_offset..old_offset + 32].to_vec();
let offset = bytes.len();
bytes.extend(pixels);
bytes[entry + 8..entry + 12].copy_from_slice(&(offset as u32).to_le_bytes());
assert!(crate::decode(&bytes).is_ok());
for cut in 0..bytes.len() {
for result in [crate::decode(&bytes[..cut]).map(|_| ()), crate::probe_info(&bytes[..cut]).map(|_| ())] {
assert!(!matches!(result, Err(RawError::Unsupported(ref why)) if why.contains("compressed")), "cut {cut}: {result:?}");
}
}
let result = crate::decode(&bytes[..bytes.len() - 1]);
assert!(matches!(result, Err(RawError::Corrupt(_))), "required final strip byte missing: {result:?}");
let result = crate::probe_info(&bytes[..bytes.len() - 1]);
assert!(matches!(result, Err(RawError::Corrupt(_))), "required final strip byte missing during probe: {result:?}");
}
/// Strip byte counts that add up past `u64::MAX` (LONG8 `[u64::MAX, 1]`) are an error or a picture, not an overflow.
#[test]
fn strip_byte_counts_past_u64_max_do_not_overflow() {
let file = crate::shared::tests::huge_strip_counts(orf(4, 2, 16, vec![0; 16]));
for mode in [Mode::Header, Mode::Full] {
let _ = super::decode(&file, mode, &Limits::default());
}
}
/// An old-style little-endian Olympus maker note (`OLYMP\0`, version 1, then the IFD) of SHORT (type 3) or
/// UNDEFINED (type 7) entries. Values longer than four bytes follow the IFD; their offsets count from the TIFF
/// header, so `at` is where the note sits in the file.
fn olymp_note(at: usize, entries: &[(u16, u16, Vec<u8>)]) -> Vec<u8> {
let ifd_end = 8 + 2 + 12 * entries.len() + 4;
let (mut b, mut extra) = (b"OLYMP\0\x01\0".to_vec(), Vec::new());
b.extend_from_slice(&(entries.len() as u16).to_le_bytes());
for (tag, typ, value) in entries {
b.extend_from_slice(&tag.to_le_bytes());
b.extend_from_slice(&typ.to_le_bytes());
b.extend_from_slice(&(if *typ == 3 { value.len() / 2 } else { value.len() } as u32).to_le_bytes());
if value.len() <= 4 {
let mut v = value.clone();
v.resize(4, 0);
b.extend_from_slice(&v);
} else {
b.extend_from_slice(&((at + ifd_end + extra.len()) as u32).to_le_bytes());
extra.extend_from_slice(value);
}
}
b.extend_from_slice(&0u32.to_le_bytes());
b.extend_from_slice(&extra);
b
}
/// SHORT values, little-endian.
fn shorts(v: &[u16]) -> Vec<u8> {
v.iter().flat_map(|x| x.to_le_bytes()).collect()
}
/// A 16 × 4 ORF of 12-bit samples in 16-bit words with an [`olymp_note`] of `entries`, decoded.
fn decode_noted(entries: &[(u16, u16, Vec<u8>)]) -> RawImage {
let (w, h) = (16u32, 4u32);
let words: Vec<u8> = (0..w * h).flat_map(|i| (((200 + i * 37) % 4096) as u16).to_le_bytes()).collect();
let file = |at| orf_with_note(w, h, 16, words.clone(), Some(RGGB), Some(olymp_note(at, entries)));
let at = file(0).windows(6).position(|b| b == b"OLYMP\0").unwrap();
let bytes = file(at);
assert_eq!(bytes.windows(6).position(|b| b == b"OLYMP\0"), Some(at));
crate::decode(&bytes).unwrap()
}
/// An ImageProcessing sub-directory stored inline (old-style note) with one unrelated entry and no levels.
fn bare_image_processing() -> (u16, u16, Vec<u8>) {
let mut ifd = 1u16.to_le_bytes().to_vec();
ifd.extend_from_slice(&[0, 0, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0]);
ifd.extend_from_slice(&0u32.to_le_bytes());
(IMAGE_PROCESSING, 7, ifd)
}
/// An ImageProcessing sub-directory stored inline (old-style note) of SHORT entries of at most two values.
fn image_processing(entries: &[(u16, &[u16])]) -> (u16, u16, Vec<u8>) {
let mut ifd = (entries.len() as u16).to_le_bytes().to_vec();
for (tag, v) in entries {
let mut value = shorts(v);
value.resize(4, 0);
ifd.extend([&tag.to_le_bytes()[..], &3u16.to_le_bytes(), &(v.len() as u32).to_le_bytes(), &value].concat());
}
ifd.extend_from_slice(&0u32.to_le_bytes());
(IMAGE_PROCESSING, 7, ifd)
}
/// The red and blue levels are relative to WB_GLevel (`0x011f`), 256 when it is absent or zero (as in
/// PhotoCraft's reader).
#[test]
fn as_shot_white_balance_is_relative_to_the_green_level() {
let wb = |g: Option<u16>| {
let mut e = vec![(WB_RB, &[512u16, 384][..])];
let g = g.map(|g| [g]);
e.extend(g.as_ref().map(|g| (WB_G, &g[..])));
decode_noted(&[image_processing(&e)]).wb_multipliers
};
assert_eq!(wb(None), Some([2.0, 1.0, 1.5]));
assert_eq!(wb(Some(256)), Some([2.0, 1.0, 1.5]));
assert_eq!(wb(Some(512)), Some([1.0, 1.0, 0.75]));
assert_eq!(wb(Some(0)), Some([2.0, 1.0, 1.5]));
}
/// The CameraSettings preview (`0x0101` start, relative to the note's base, and `0x0102` length) is the file's
/// embedded preview; a length past the end is clamped to the file.
#[test]
fn camera_settings_preview_is_the_embedded_preview() {
let mut jpeg = vec![0xff, 0xd8, 0xff, 0xc0, 0x00, 0x0b, 8, 0, 1, 0, 1, 1, 1, 0x11, 0];
jpeg.extend([0x55; 40]);
jpeg.extend([0xff, 0xd9]);
let long = |v: u32| v.to_le_bytes().to_vec();
// the note holds CameraSettings (30 bytes, inline) and the JPEG, both after its 38-byte IFD
let file = |at: usize, len: u32| {
let mut cs = 2u16.to_le_bytes().to_vec();
cs.extend([&PREVIEW_START.to_le_bytes()[..], &4u16.to_le_bytes(), &1u32.to_le_bytes(), &long((at + 38 + 30) as u32)].concat());
cs.extend([&PREVIEW_LENGTH.to_le_bytes()[..], &4u16.to_le_bytes(), &1u32.to_le_bytes(), &long(len)].concat());
cs.extend(0u32.to_le_bytes());
let note = olymp_note(at, &[(CAMERA_SETTINGS, 7, cs), (0xfff0, 7, jpeg.clone())]);
orf_with_note(16, 4, 16, vec![0; 128], Some(RGGB), Some(note))
};
let at = file(0, 0).windows(6).position(|b| b == b"OLYMP\0").unwrap();
let bytes = file(at, jpeg.len() as u32);
assert_eq!(preview(&bytes), Some(&jpeg[..]));
assert_eq!(crate::embedded_preview(&bytes), Some(jpeg.clone()));
let past = file(at, u32::MAX);
assert!(preview(&past).is_some_and(|p| p.starts_with(&jpeg) && p.len() < past.len()));
}
/// storytold/lightcraft#1273: the E-10 (16-bit words, no ImageProcessing sub-directory) keeps its red and blue gains in
/// maker-note entries `0x1017`/`0x1018`, as the two-field compacts do.
#[test]
fn as_shot_white_balance_from_the_main_maker_note() {
let wb = |red: u16, blue: Option<u16>| {
let mut e = vec![(MN_WB_RED, 3, shorts(&[red, 64]))];
e.extend(blue.map(|b| (MN_WB_BLUE, 3, shorts(&[b, 64]))));
decode_noted(&e).wb_multipliers
};
assert_eq!(wb(384, Some(406)), Some([1.5, 1.0, 406.0 / 256.0]));
// both gains are needed, within 0.1 to 10 (25.6 to 2560 in 256 units)
assert_eq!(wb(384, None), None);
assert_eq!(wb(0, Some(406)), None);
assert_eq!(wb(25, Some(406)), None);
assert_eq!(wb(384, Some(2560)), None);
assert_eq!(wb(27, Some(2559)), Some([27.0 / 256.0, 1.0, 2559.0 / 256.0]));
assert_eq!(decode_noted(&[]).wb_multipliers, None);
// a body with ImageProcessing but without its levels doesn't fall back to these entries
let e = [bare_image_processing(), (MN_WB_RED, 3, shorts(&[384, 64])), (MN_WB_BLUE, 3, shorts(&[406, 64]))];
assert_eq!(decode_noted(&e).wb_multipliers, None);
}
/// storytold/lightcraft#1273: a body without ImageProcessing states its black level in the main note, `0x1012` (four
/// values) in `0x102c` ValidBits units: the E-10's 32 at 10 bits is 128 on its 12-bit samples. The two-field
/// compacts state 0 at 12 bits.
#[test]
fn black_level_from_the_main_maker_note() {
let black = |level: u16, valid: Option<u16>| {
let mut e = vec![(MN_BLACK, 3, shorts(&[level; 4]))];
e.extend(valid.map(|v| (MN_VALID_BITS, 3, shorts(&[v, 0]))));
let r = decode_noted(&e);
assert_eq!(r.bits, 12);
r.black.values
};
assert_eq!(black(32, Some(10)), vec![128.0]);
assert_eq!(black(0, Some(12)), vec![0.0]);
assert_eq!(black(32, Some(12)), vec![32.0]);
// the four values are averaged
let e = [(MN_BLACK, 3, shorts(&[30, 32, 32, 34])), (MN_VALID_BITS, 3, shorts(&[10, 0]))];
assert_eq!(decode_noted(&e).black.values, vec![128.0]);
// no ValidBits, ValidBits above the samples' depth, a level of a quarter of the range or more: no black
assert_eq!(black(32, None), vec![0.0]);
assert_eq!(black(32, Some(14)), vec![0.0]);
assert_eq!(black(256, Some(10)), vec![0.0]);
// ImageProcessing present (without BlackLevel2): the main note isn't read
let e = [bare_image_processing(), (MN_BLACK, 3, shorts(&[32; 4])), (MN_VALID_BITS, 3, shorts(&[10, 0]))];
assert_eq!(decode_noted(&e).black.values, vec![0.0]);
}
/// A 12-bit mosaic stored as 16-bit words: `site(cx, cy)` gives the four values of the 2×2 cell at (cx, cy).
fn mosaic(w: usize, h: usize, site: impl Fn(usize, usize) -> [u16; 4]) -> Vec<u8> {
(0..w * h).flat_map(|i| site(i % w / 2, i / w / 2)[((i / w) & 1) * 2 + ((i % w) & 1)].to_le_bytes()).collect()
}
/// Smooth scene texture shared by the four sites of a cell.
fn shade(cx: usize, cy: usize) -> u16 {
((cx * 7 + cy * 13) % 23) as u16
}
const BGGR: &[u8] = &[2, 0, 2, 0, 2, 1, 1, 0];
const GRBG: &[u8] = &[2, 0, 2, 0, 1, 0, 2, 1];
// repeat counts in the other byte order
const RGGB: &[u8] = &[0, 2, 0, 2, 0, 1, 1, 2];
const GBRG: &[u8] = &[0, 2, 0, 2, 1, 2, 0, 1];
fn layout(bytes: &[u8]) -> String {
let r = crate::decode(bytes).unwrap();
assert_eq!(crate::probe_info(bytes).unwrap(), r.info());
r.cfa.unwrap().name()
}
#[test]
fn exif_cfa_pattern_states_the_layout() {
let (w, h) = (160usize, 144usize);
// samples whose green diagonal alone would say RGGB
let px = mosaic(w, h, |cx, cy| [600, 1000, 1000, 300].map(|v| v + shade(cx, cy)));
for (tag, name) in [(BGGR, "BGGR"), (GRBG, "GRBG"), (RGGB, "RGGB"), (GBRG, "GBRG")] {
assert_eq!(layout(&orf_with(w as u32, h as u32, 16, px.clone(), Some(tag))), name);
}
// not a 2×2 Bayer cell (four greens, greens side by side, a fourth colour), other repeat counts, wrong
// lengths: the samples decide
let unusable: [&[u8]; 8] = [
&[2, 0, 2, 0, 1, 1, 1, 1],
&[2, 0, 2, 0, 1, 1, 0, 2],
&[2, 0, 2, 0, 0, 1, 1, 3],
&[3, 0, 3, 0, 0, 1, 1, 2],
&[2, 2, 2, 0, 0, 1, 1, 2],
&[2, 0, 2, 0, 1, 0],
&[2, 0, 2, 0, 2, 1, 1, 0, 0],
&[],
];
for (site, name) in [([600, 1000, 1000, 300], "RGGB"), ([1000, 600, 300, 1000], "GRBG")] {
let px = mosaic(w, h, |cx, cy| site.map(|v| v + shade(cx, cy)));
assert_eq!(layout(&orf(w as u32, h as u32, 16, px.clone())), name);
for tag in unusable {
assert_eq!(layout(&orf_with(w as u32, h as u32, 16, px.clone(), Some(tag))), name, "{tag:?}");
}
}
}
#[test]
fn cfa_notice_distinguishes_missing_and_unusable_exif_from_stated_patterns() {
let (w, h) = (160usize, 144usize);
let strip = mosaic(w, h, |cx, cy| [600, 1000, 1000, 300].map(|value| value + shade(cx, cy)));
let expected: Vec<u16> = strip.as_chunks::<2>().0.iter().map(|word| u16::from_le_bytes(*word)).collect();
for (tag, assumed, pattern) in [
(None, true, "RGGB"),
(Some(&[2, 0, 2, 0, 0, 1][..]), true, "RGGB"),
(Some(&[2, 0, 2, 0, 0, 1, 1, 3][..]), true, "RGGB"),
(Some(BGGR), false, "BGGR"),
(Some(GRBG), false, "GRBG"),
] {
let bytes = orf_with(w as u32, h as u32, 16, strip.clone(), tag);
for mode in [Mode::Header, Mode::Full] {
let image = decode(&bytes, mode, &Limits::default()).unwrap();
assert_eq!(image.cfa, Some(Cfa::bayer_static(pattern)));
assert_eq!(image.data, RawData::U16(expected.clone()), "word16 samples remain unchanged");
assert_eq!(image.notices, crate::RawNotices { assumed_cfa: assumed, ..Default::default() });
}
}
}
#[test]
fn packed_12_bit_probe_agrees_with_decode() {
let (w, h) = (16usize, 4usize);
let strip: Vec<u8> = (0..w * h * 3 / 2).map(|i| (i * 37 % 251) as u8).collect();
for tag in [Some(BGGR), None] {
let bytes = orf_with(w as u32, h as u32, 12, strip.clone(), tag);
let r = crate::decode(&bytes).unwrap();
assert_eq!((r.bits, r.data.len()), (12, w * h));
assert_eq!(r.cfa.as_ref().unwrap().name(), if tag.is_some() { "BGGR" } else { "RGGB" });
assert_eq!(crate::probe_info(&bytes).unwrap(), r.info());
}
}
#[test]
fn data_fallback_looks_past_fine_texture() {
let (w, h) = (160usize, 144usize);
// greens on the main diagonal, red and blue close; a checkerboard of detail makes the two greens of a cell
// differ by far more than red differs from blue
let detail = |cx: usize, cy: usize| if (cx + cy) & 1 == 0 { 150 } else { -150i32 };
let site = |cx: usize, cy: usize| {
let (g, d) = (1000 + shade(cx, cy) as i32, detail(cx, cy));
[(g + d) as u16, 500, 520, (g - d) as u16]
};
assert_eq!(layout(&orf(w as u32, h as u32, 16, mosaic(w, h, site))), "GRBG");
// the same scene with the greens on the other diagonal
let px = mosaic(w, h, |cx, cy| {
let [g0, r, b, g1] = site(cx, cy);
[r, g0, g1, b]
});
assert_eq!(layout(&orf(w as u32, h as u32, 16, px)), "RGGB");
}
#[test]
fn data_fallback_survives_any_area() {
let d = vec![100u16; 64 * 64];
let big = usize::MAX;
for a in [
Rect::new(0, 0, 64, 64),
Rect::new(0, 0, 0, 0),
Rect::new(0, 0, 31, 31),
Rect::new(63, 63, 1, 1),
Rect::new(0, 0, 4096, 4096),
Rect::new(big, big, big, big),
Rect::new(0, big - 40, 64, 40),
] {
for w in [64, 0, 1, big] {
assert_eq!(cfa_from_data(&d, w, a).name(), "RGGB", "{a:?} width {w}");
assert_eq!(cfa_from_data(&[], w, a).name(), "RGGB", "{a:?} width {w}");
}
}
}
/// Output sample (x, y) of the two-field tests: distinct per site, all below 4096.
fn field_px(x: usize, y: usize) -> u16 {
((y * 331 + x * 17 + 5) % 4096) as u16
}
/// 12 bits MSB-first, two samples per three bytes, for output row `y`.
fn packed_row(w: usize, y: usize) -> Vec<u8> {
(0..w)
.step_by(2)
.flat_map(|x| {
let (a, b) = (field_px(x, y), field_px(x + 1, y));
[(a >> 4) as u8, ((a & 15) << 4 | b >> 8) as u8, b as u8]
})
.collect()
}
/// A two-field file: strips A1 (two rows), A2 (one row), a gap, B (all but the last row of the second field),
/// with the last row of the second field right after B, as the strip table of the old compacts has it (width 8,
/// height 5). `table_gap` keeps the gap in the table (else the strips are contiguous and the table is wrong).
fn two_field(table_gap: bool) -> Vec<u8> {
let (w, h) = (8usize, 5usize);
let h0 = h.div_ceil(2);
// stored rows: the even output rows, then the odd ones (the last of them is past the picture)
let stored: Vec<Vec<u8>> = (0..h0).map(|k| packed_row(w, 2 * k)).chain((0..h0).map(|k| packed_row(w, 2 * k + 1))).collect();
let a1 = stored[..2].concat();
let a2 = stored[2].clone();
let gap = vec![0xffu8; 20];
let b = stored[3].clone();
let b2 = stored[4].clone();
let last = stored[5].clone();
let mut ifd = IfdBuilder::new();
ifd.set(t::IMAGE_WIDTH, Value::Long(vec![w as u32]));
ifd.set(t::IMAGE_LENGTH, Value::Long(vec![h as u32]));
ifd.set(t::BITS_PER_SAMPLE, Value::Short(vec![12]));
ifd.set(t::COMPRESSION, Value::Short(vec![1]));
ifd.set(t::PHOTOMETRIC, Value::Short(vec![2]));
ifd.set(t::MAKE, Value::Ascii("OLYMPUS OPTICAL CO.,LTD".into()));
ifd.set_image(ImageData::Strips { rows_per_strip: 2, strips: vec![a1, a2, gap, b, b2, last] });
let mut exif = IfdBuilder::new();
exif.set(EXIF_CFA_PATTERN, Value::Undefined(BGGR.to_vec()));
ifd.set_child(t::EXIF_IFD, exif);
let mut b = TiffWriter::new(ByteOrder::Little, false).write(&[ifd]).unwrap();
b[2] = b'R';
b[3] = b'S';
// keep strips A1, A2, B1 and B2 in the table (drop the gap and the last row): four strips for a grid of three
let le = |b: &[u8], at: usize| u32::from_le_bytes(b[at..at + 4].try_into().unwrap());
let at0 = le(&b, 4) as usize;
let n = u16::from_le_bytes([b[at0], b[at0 + 1]]) as usize;
for e in (0..n).map(|i| at0 + 2 + 12 * i) {
let tag = u16::from_le_bytes([b[e], b[e + 1]]);
if tag != t::STRIP_OFFSETS && tag != t::STRIP_BYTE_COUNTS {
continue;
}
let at = le(&b, e + 8) as usize;
let all: Vec<u32> = (0..6).map(|i| le(&b, at + 4 * i)).collect();
let keep: Vec<u32> = if table_gap { vec![all[0], all[1], all[3], all[4]] } else { vec![all[0], all[1], all[2], all[3]] };
b[e + 4..e + 8].copy_from_slice(&(keep.len() as u32).to_le_bytes());
for (i, v) in keep.iter().enumerate() {
b[at + 4 * i..at + 4 * i + 4].copy_from_slice(&v.to_le_bytes());
}
}
b
}
#[test]
fn two_field_12_bit_layout() {
let bytes = two_field(true);
let r = crate::decode(&bytes).unwrap();
let want: Vec<u16> = (0..5).flat_map(|y| (0..8).map(move |x| field_px(x, y))).collect();
assert_eq!((r.data.clone(), r.bits, r.width, r.height), (RawData::U16(want), 12, 8, 5));
assert_eq!(r.cfa.as_ref().unwrap().name(), "BGGR");
assert_eq!(crate::probe_info(&bytes).unwrap(), r.info());
// the table without the gap: sizes no longer add up
let e = crate::decode(&two_field(false)).map(|_| ());
assert!(matches!(e, Err(RawError::Unsupported(_))), "{e:?}");
}
#[test]
fn two_field_layout_needs_every_condition() {
let chunk = |_index: usize, offset: u64, rows: u64| (offset, rows * 12);
// width 8, height 5: rows 0..3 are the first field, the gap, rows 3..5, the last row after them
let good = [chunk(0, 100, 2), chunk(1, 124, 1), chunk(2, 200, 2)];
let rows = field_rows(&good, 8, 5, 236).unwrap();
assert_eq!(rows, [100, 112, 124, 200, 212, 224]);
// the last row must be inside the file
assert!(field_rows(&good, 8, 5, 235).is_none());
// the gap is the field seam: not after two rows, not absent, not twice
assert!(field_rows(&[chunk(0, 100, 2), chunk(1, 140, 1), chunk(2, 164, 2)], 8, 5, 300).is_none());
assert!(field_rows(&[chunk(0, 100, 2), chunk(1, 124, 1), chunk(2, 136, 2)], 8, 5, 300).is_none());
assert!(field_rows(&[chunk(0, 100, 2), chunk(1, 124, 1), chunk(2, 200, 1), chunk(3, 300, 1)], 8, 5, 400).is_none());
// overlapping strips, sizes that don't add up, even height, odd width, a single strip
assert!(field_rows(&[chunk(0, 100, 2), chunk(1, 120, 1), chunk(2, 200, 2)], 8, 5, 300).is_none());
assert!(field_rows(&[chunk(0, 100, 2), chunk(1, 124, 1), chunk(2, 200, 1)], 8, 5, 300).is_none());
assert!(field_rows(&good, 8, 4, 300).is_none());
assert!(field_rows(&good, 7, 5, 300).is_none());
assert!(field_rows(&good[..1], 8, 5, 300).is_none());
}
#[test]
fn word16_shifted_and_packed12() {
let (w, h) = (16usize, 4usize);
let px: Vec<u16> = (0..w * h).map(|i| ((i * 211) % 4096) as u16).collect();
let words: Vec<u8> = px.iter().flat_map(|v| (v << 4).to_le_bytes()).collect();
let bytes = orf(w as u32, h as u32, 16, words);
assert_eq!(crate::probe(&bytes), Some(RawFormat::Orf));
let r = crate::decode(&bytes).unwrap();
assert_eq!((r.data.clone(), r.bits), (RawData::U16(px.clone()), 12));
// 12-bit: MSB-first stream, every 32-bit word byte-swapped
let mut be = Vec::new();
for p in px.chunks(2) {
let v = (p[0] as u32) << 12 | p[1] as u32;
be.extend_from_slice(&[(v >> 16) as u8, (v >> 8) as u8, v as u8]);
}
let le: Vec<u8> = be.chunks(4).flat_map(|c| [c[3], c[2], c[1], c[0]]).collect();
let bytes = orf(w as u32, h as u32, 12, le);
assert_eq!(crate::decode(&bytes).unwrap().data, RawData::U16(px));
let bytes = orf(w as u32, h as u32, 16, vec![0; 40]);
assert!(matches!(crate::decode(&bytes), Err(RawError::Unsupported(_))));
}
/// Pack samples into 16-byte blocks: ten little-endian 12-bit fields, then a zero pad byte.
fn pack_blocks(samples: &[u16]) -> Vec<u8> {
samples
.chunks(10)
.flat_map(|c| {
let mut v = 0u128;
for (i, s) in c.iter().enumerate() {
v |= (*s as u128 & 0xfff) << (12 * i);
}
let mut b = v.to_le_bytes();
b[15] = 0;
b
})
.collect()
}
#[test]
fn block16_round_trip() {
let (w, h) = (20usize, 4usize);
let samples: Vec<u16> = (0..w * h).map(|i| ((i * 509 + 17) % 4096) as u16).collect();
let strip = pack_blocks(&samples);
assert_eq!(strip.len(), w * h * 16 / 10);
let mut out = vec![0u16; w * h];
for (y, row) in out.chunks_mut(w).enumerate() {
unpack_row_blocks16(&strip[y * 32..(y + 1) * 32], row).unwrap();
}
assert_eq!(out, samples);
// a known block: s0 = b0 | (b1 & 15) << 8, s1 = b1 >> 4 | b2 << 4
let mut px = [0u16; 10];
let mut blk = [0u8; 16];
blk[..3].copy_from_slice(&[0x21, 0x43, 0x65]);
unpack_row_blocks16(&blk, &mut px).unwrap();
assert_eq!(&px[..2], &[0x321, 0x654]);
// the whole file through the decoder
let bytes = orf_with(w as u32, h as u32, 16, strip, Some(RGGB));
let r = crate::decode(&bytes).unwrap();
assert_eq!(r.bits, 12);
let RawData::U16(d) = &r.data else { panic!() };
assert_eq!(d, &samples);
}
#[test]
fn block16_routing() {
assert!(is_block16(3360, 3360 * 2504, 13461504, 1));
assert!(!is_block16(3360, 3360 * 2504, 3360 * 2504 * 12 / 8, 1)); // XZ-2: exactly 12.0 bpp
assert!(!is_block16(3360, 3360 * 2504, 13461504, 2));
assert!(!is_block16(3365, 3365 * 100, 3365 * 100 * 16 / 10, 1));
// the 12.0 bpp layout still decodes through its own branch
let bytes = orf_with(8, 2, 12, vec![0u8; 8 * 2 * 12 / 8], Some(RGGB));
assert!(crate::decode(&bytes).is_ok());
}
#[test]
fn block16_short_input_is_an_error() {
let mut px = [0u16; 10];
assert!(unpack_row_blocks16(&[0u8; 15], &mut px).is_err());
assert!(unpack_row_blocks16(&[0u8; 32], &mut px).is_err());
assert!(unpack_row_blocks16(&[], &mut px).is_err());
let mut odd = [0u16; 7];
assert!(unpack_row_blocks16(&[0u8; 16], &mut odd).is_err());
// a truncated file never panics
let bytes = orf_with(20, 4, 16, pack_blocks(&[5u16; 80]), Some(RGGB));
for cut in [bytes.len() - 1, bytes.len() - 40, bytes.len() / 2, 100] {
let _ = crate::decode(&bytes[..cut]);
}
}
}