From c31578e1ffc5aa480005c8ff5813287758e5deb1 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sun, 11 Oct 2026 14:49:47 +0000 Subject: [PATCH 1/5] #1065: DNG opcode lists (OpcodeList1/2/3) Problem: DNG opcode lists were ignored, so lens shading gain maps (phones and many cameras), bad pixel maps, vignette and distortion corrections and trims that a file asks for were silently left out, and an opcode a reader must apply could not be refused. Fix (DNG 1.7.1.0 chapter 7): a big-endian opcode list parser (at most 256 opcodes, every count checked against the parameter bytes before allocating) and the opcodes WarpRectilinear, WarpFisheye, WarpRectilinear2 (with the skip rule), FixVignetteRadial, FixBadPixelsConstant / List, TrimBounds, MapTable, MapPolynomial, GainMap, DeltaPerRow / Column and ScalePerRow / Column. OpcodeList1 runs on the stored samples (0-65535), OpcodeList2 on the linear values before white balance (the fused normalise splits only then), OpcodeList3 on the demosaiced camera values; values are clipped after each opcode. Unknown opcodes or ones newer than 1.7.1.0 are skipped when optional and an error naming them when mandatory; preview-only opcodes are skipped on the reduced-resolution path, and a mandatory OpcodeList3 keeps full resolution. Interpretations where the spec leaves room are recorded in the README. Files without opcode lists develop exactly as before. Tests: unit tests per opcode with known results (tables, polynomials, deltas, scales, gain map interpolation and edge replication, vignette, warps reproducing a ramp, fisheye, the skip rule, bad pixels, trim, hostile parameters) and whole-file tests of each list's stage, the optional flag, the preview path, and 3000 mutations under catch_unwind. Co-Authored-By: Claude Opus 5.5 --- crates/raw/src/opcode_raw.rs | 884 +++++++++++++++++++++++++++++++++++ 1 file changed, 884 insertions(+) create mode 100644 crates/raw/src/opcode_raw.rs diff --git a/crates/raw/src/opcode_raw.rs b/crates/raw/src/opcode_raw.rs new file mode 100644 index 000000000..bb05c650a --- /dev/null +++ b/crates/raw/src/opcode_raw.rs @@ -0,0 +1,884 @@ +//! DNG opcode lists (DNG 1.7.1.0 chapter 7, "Opcode List Processing"): OpcodeList1 on the raw +//! samples as stored, OpcodeList2 on the linear reference values (after linearisation, black and +//! white levels, before white balance), OpcodeList3 on the demosaiced picture. +//! +//! An opcode list is big-endian whatever the file's byte order: a count, then per opcode its ID, +//! the DNG version that defined it, flags (bit 0 optional, bit 1 skippable for preview quality) +//! and the size of its parameters. Implemented: WarpRectilinear (1), WarpFisheye (2), +//! FixVignetteRadial (3), FixBadPixelsConstant (4), FixBadPixelsList (5), TrimBounds (6), +//! MapTable (7), MapPolynomial (8), GainMap (9), DeltaPerRow / Column (10, 11), ScalePerRow / +//! Column (12, 13) and WarpRectilinear2 (14, with the skip rule for a following warp). An unknown +//! opcode, or one from a DNG version newer than 1.7.1.0, is skipped when it is optional and an +//! error when it is not. Values are clipped to the stage's logical range after every opcode +//! (0–65535 for OpcodeList1, 0–1 after). +//! +//! Interpretations where the specification leaves room (recorded in the crate README): +//! coordinates of OpcodeList1 are those of the stored raw image, of OpcodeList2 and 3 those of the +//! ActiveArea; GainMap positions are relative to the whole image of the stage (row / height, +//! column / width); Delta and MapPolynomial values are in the 0–1 range at every stage (scaled by +//! 65535 on OpcodeList1's integer samples), MapTable indexes 16-bit values (0–1 scaled by 65535 +//! after OpcodeList1); warps resample with a Catmull–Rom cubic and are refused on CFA mosaics, +//! as is TrimBounds before OpcodeList3. +//! +//! Every count and size is checked against the bytes of the parameter area before anything is +//! allocated, and per-opcode work is bounded by the image size. + +use crate::{Error, Result}; + +/// The newest DNG version whose opcodes this reader knows (1.7.1.0). +const KNOWN_VERSION: u32 = 0x0107_0100; + +/// Most opcodes in one list (each may touch the whole picture). +pub const MAX_OPCODES: usize = 256; + +const OPTIONAL: u32 = 1; +const PREVIEW_SKIPPABLE: u32 = 2; + +/// One opcode of a list. +#[derive(Clone, Debug, PartialEq)] +pub struct Opcode { + pub id: u32, + /// The DNG version that defined it, as four bytes in a big-endian u32 (1.3.0.0 = 0x01030000). + pub version: u32, + pub flags: u32, + pub params: Vec, +} + +impl Opcode { + pub fn optional(&self) -> bool { + self.flags & OPTIONAL != 0 + } + + pub fn preview_skippable(&self) -> bool { + self.flags & PREVIEW_SKIPPABLE != 0 + } +} + +/// The opcode lists of a raw IFD. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Lists { + pub list1: Vec, + pub list2: Vec, + pub list3: Vec, +} + +/// Parse an opcode list (big-endian). +pub fn parse(b: &[u8]) -> Result> { + let bad = || Error::Malformed("opcode list"); + let mut r = Reader::new(b); + let count = r.u32().map_err(|_| bad())? as usize; + // every opcode takes at least 16 bytes + if count > b.len() / 16 || count > MAX_OPCODES { + return Err(bad()); + } + let mut out = Vec::with_capacity(count); + for _ in 0..count { + let id = r.u32().map_err(|_| bad())?; + let version = r.u32().map_err(|_| bad())?; + let flags = r.u32().map_err(|_| bad())?; + let len = r.u32().map_err(|_| bad())? as usize; + let params = r.bytes(len).map_err(|_| bad())?.to_vec(); + out.push(Opcode { id, version, flags, params }); + } + Ok(out) +} + +/// Big-endian parameter reader. +struct Reader<'a> { + b: &'a [u8], + pos: usize, +} + +impl<'a> Reader<'a> { + fn new(b: &'a [u8]) -> Self { + Reader { b, pos: 0 } + } + + fn bytes(&mut self, n: usize) -> Result<&'a [u8]> { + let end = self.pos.checked_add(n).ok_or(Error::Malformed("opcode parameters"))?; + let s = self.b.get(self.pos..end).ok_or(Error::Malformed("opcode parameters too short"))?; + self.pos = end; + Ok(s) + } + + fn u32(&mut self) -> Result { + let s = self.bytes(4)?; + Ok(u32::from_be_bytes([s[0], s[1], s[2], s[3]])) + } + + fn f32(&mut self) -> Result { + let v = f32::from_bits(self.u32()?); + if v.is_finite() { Ok(v) } else { Err(Error::Malformed("non-finite opcode parameter")) } + } + + fn f64(&mut self) -> Result { + let s = self.bytes(8)?; + let v = f64::from_be_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]); + if v.is_finite() { Ok(v) } else { Err(Error::Malformed("non-finite opcode parameter")) } + } + + fn remaining(&self) -> usize { + self.b.len().saturating_sub(self.pos) + } + + /// A count of items of `size` bytes each that must fit in what is left. + fn count(&mut self, size: usize) -> Result { + let n = self.u32()? as usize; + if n.saturating_mul(size) > self.remaining() { + return Err(Error::Malformed("opcode count larger than its parameters")); + } + Ok(n) + } +} + +/// The picture an opcode list works on: `planes` interleaved samples per pixel. +pub struct Image<'a> { + pub data: &'a mut Vec, + pub width: usize, + pub height: usize, + pub planes: usize, + /// The stage's logical maximum: 65535 for OpcodeList1 (integer samples, rounded after every + /// opcode), 1 for OpcodeList2 and 3. + pub max: f32, + /// A CFA mosaic (one sample per pixel before the demosaic): warps are refused. + pub mosaic: bool, + /// TrimBounds is allowed (OpcodeList3 only: the picture may change size). + pub allow_trim: bool, + /// Origin of the picture after TrimBounds, relative to where it started. + pub origin: (usize, usize), +} + +impl Image<'_> { + fn integer(&self) -> bool { + self.max > 1.0 + } + + fn clip(&mut self) { + let (max, int) = (self.max, self.integer()); + for v in self.data.iter_mut() { + let c = v.clamp(0.0, max); + *v = if int { + c.round() + } else if c.is_nan() { + 0.0 + } else { + c + }; + } + } +} + +/// Apply `list`. `preview` skips the opcodes marked as only needed for full quality. +pub fn apply(list: &[Opcode], img: &mut Image, preview: bool) -> Result<()> { + let mut skip_warp = false; + for op in list { + let skip_this = std::mem::take(&mut skip_warp) && matches!(op.id, 1 | 2); + if skip_this || (preview && op.preview_skippable()) { + continue; + } + let known = op.version <= KNOWN_VERSION && (1..=14).contains(&op.id); + if !known { + if op.optional() { + continue; + } + return Err(Error::Unsupported(format!("DNG opcode {} (version {:08x})", op.id, op.version))); + } + match run(op, img) { + Ok(()) => {} + // an optional opcode this reader cannot apply here is left out + Err(Error::Unsupported(_)) if op.optional() => continue, + Err(e) => return Err(e), + } + img.clip(); + if op.id == 14 && op.optional() { + skip_warp = true; + } + } + Ok(()) +} + +fn run(op: &Opcode, img: &mut Image) -> Result<()> { + let mut r = Reader::new(&op.params); + match op.id { + 1 | 2 | 14 => warp(op.id, &mut r, img), + 3 => vignette(&mut r, img), + 4 => { + let constant = r.u32()?; + let phase = r.u32()?; + let mut bad = Vec::new(); + let c = if img.integer() { constant as f32 } else { constant as f32 / 65_535.0 }; + for (i, px) in img.data.iter().enumerate() { + if *px == c { + bad.push(i); + } + } + fix_bad(img, phase, &bad) + } + 5 => { + let phase = r.u32()?; + let points = r.u32()? as usize; + let rects = r.u32()? as usize; + if points.saturating_mul(8).saturating_add(rects.saturating_mul(16)) > r.remaining() { + return Err(Error::Malformed("FixBadPixelsList counts larger than its parameters")); + } + let (w, h) = (img.width, img.height); + let mut mask = vec![false; w * h]; + for _ in 0..points { + let (y, x) = (r.u32()? as usize, r.u32()? as usize); + if x < w && y < h { + mask[y * w + x] = true; + } + } + for _ in 0..rects { + let (t, l, b, rt) = (r.u32()? as usize, r.u32()? as usize, r.u32()? as usize, r.u32()? as usize); + for y in t.min(h)..b.min(h) { + for x in l.min(w)..rt.min(w) { + mask[y * w + x] = true; + } + } + } + let bad: Vec = mask.iter().enumerate().filter_map(|(i, &b)| b.then_some(i)).collect(); + fix_bad(img, phase, &bad) + } + 6 => trim(&mut r, img), + _ => area_op(op.id, &mut r, img), + } +} + +/// The area fields of opcodes 7–13, clamped to the picture. +struct Area { + top: usize, + left: usize, + bottom: usize, + right: usize, + plane: usize, + planes: usize, + row_pitch: usize, + col_pitch: usize, +} + +impl Area { + fn read(r: &mut Reader, img: &Image) -> Result { + let mut v = [0usize; 8]; + for x in &mut v { + *x = r.u32()? as usize; + } + let [top, left, bottom, right, plane, planes, row_pitch, col_pitch] = v; + if row_pitch == 0 || col_pitch == 0 { + return Err(Error::Malformed("opcode area with a zero pitch")); + } + let plane = plane.min(img.planes); + Ok(Area { + top: top.min(img.height), + left: left.min(img.width), + bottom: bottom.min(img.height), + right: right.min(img.width), + plane, + planes: planes.min(img.planes - plane), + row_pitch, + col_pitch, + }) + } + + /// Rows of the area, in order. + fn rows(&self) -> impl Iterator + use<> { + (self.top..self.bottom.max(self.top)).step_by(self.row_pitch) + } + + fn cols(&self) -> impl Iterator + use<> { + (self.left..self.right.max(self.left)).step_by(self.col_pitch) + } + + /// Visit every affected sample: f(row index in area, col index in area, x, y, plane index in + /// area, value). + fn each(&self, img: &mut Image, mut f: impl FnMut(usize, usize, usize, usize, usize, &mut f32)) { + let (w, np) = (img.width, img.planes); + for (ri, y) in self.rows().enumerate() { + for (ci, x) in self.cols().enumerate() { + for p in 0..self.planes { + if let Some(v) = img.data.get_mut((y * w + x) * np + self.plane + p) { + f(ri, ci, x, y, p, v); + } + } + } + } + } +} + +fn area_op(id: u32, r: &mut Reader, img: &mut Image) -> Result<()> { + let a = Area::read(r, img)?; + let scale = img.max; + match id { + 7 => { + let n = r.count(2)?; + if n == 0 { + return Err(Error::Malformed("MapTable without entries")); + } + let table: Vec = (0..n).map(|_| r.bytes(2).map(|b| f32::from(u16::from_be_bytes([b[0], b[1]])))).collect::>()?; + let last = table.last().copied().unwrap_or(0.0); + a.each(img, |_, _, _, _, _, v| { + let code = (*v / scale * 65_535.0).round().clamp(0.0, 65_535.0) as usize; + *v = table.get(code).copied().unwrap_or(last) / 65_535.0 * scale; + }); + } + 8 => { + let degree = r.u32()? as usize; + if degree > 8 { + return Err(Error::Malformed("MapPolynomial degree above 8")); + } + let c: Vec = (0..=degree).map(|_| r.f64()).collect::>()?; + a.each(img, |_, _, _, _, _, v| { + let x = f64::from(*v / scale); + let y = c.iter().rev().fold(0.0, |acc, k| acc * x + k); + *v = (y * f64::from(scale)) as f32; + }); + } + 9 => gain_map(&a, r, img)?, + 10..=13 => { + let n = r.count(4)?; + let vals: Vec = (0..n).map(|_| r.f32()).collect::>()?; + let per_row = matches!(id, 10 | 12); + let need = if per_row { a.rows().count() } else { a.cols().count() }; + if vals.len() < need { + return Err(Error::Malformed("opcode with fewer values than rows or columns")); + } + let delta = id <= 11; + a.each(img, |ri, ci, _, _, _, v| { + let k = vals.get(if per_row { ri } else { ci }).copied().unwrap_or(if delta { 0.0 } else { 1.0 }); + *v = if delta { *v + k * scale } else { *v * k }; + }); + } + _ => return Err(Error::Unsupported(format!("DNG opcode {id}"))), + } + Ok(()) +} + +fn gain_map(a: &Area, r: &mut Reader, img: &mut Image) -> Result<()> { + let points_v = r.u32()? as usize; + let points_h = r.u32()? as usize; + let spacing_v = r.f64()?; + let spacing_h = r.f64()?; + let origin_v = r.f64()?; + let origin_h = r.f64()?; + let map_planes = r.u32()? as usize; + let n = points_v.saturating_mul(points_h).saturating_mul(map_planes); + if points_v == 0 || points_h == 0 || map_planes == 0 || n.saturating_mul(4) > r.remaining() { + return Err(Error::Malformed("GainMap size")); + } + if (points_v > 1 && spacing_v <= 0.0) || (points_h > 1 && spacing_h <= 0.0) { + return Err(Error::Malformed("GainMap spacing")); + } + let gains: Vec = (0..n).map(|_| r.f32()).collect::>()?; + let (w, h) = (img.width.max(1) as f64, img.height.max(1) as f64); + let pos = |rel: f64, origin: f64, spacing: f64, points: usize| { + if points <= 1 { + return 0.0; + } + ((rel - origin) / spacing).clamp(0.0, (points - 1) as f64) + }; + let gain = |p: usize, mv: f64, mh: f64| -> f32 { + let mp = p.min(map_planes - 1); + let (v0, h0) = (mv.floor() as usize, mh.floor() as usize); + let (v1, h1) = ((v0 + 1).min(points_v - 1), (h0 + 1).min(points_h - 1)); + let (fv, fh) = (mv - v0 as f64, mh - h0 as f64); + let g = |v: usize, hh: usize| f64::from(gains.get((v * points_h + hh) * map_planes + mp).copied().unwrap_or(1.0)); + let top = g(v0, h0) * (1.0 - fh) + g(v0, h1) * fh; + let bottom = g(v1, h0) * (1.0 - fh) + g(v1, h1) * fh; + (top * (1.0 - fv) + bottom * fv) as f32 + }; + a.each(img, |_, _, x, y, p, v| { + let mv = pos(y as f64 / h, origin_v, spacing_v, points_v); + let mh = pos(x as f64 / w, origin_h, spacing_h, points_h); + *v *= gain(p, mv, mh); + }); + Ok(()) +} + +/// The optical centre in pixels and the distance to the farthest corner (chapter 7). +fn centre(img: &Image, cx: f64, cy: f64) -> (f64, f64, f64) { + let (x1, y1) = (img.width.saturating_sub(1) as f64, img.height.saturating_sub(1) as f64); + let (cx, cy) = (cx * x1, cy * y1); + let mx = cx.abs().max((x1 - cx).abs()); + let my = cy.abs().max((y1 - cy).abs()); + (cx, cy, (mx * mx + my * my).sqrt()) +} + +fn vignette(r: &mut Reader, img: &mut Image) -> Result<()> { + let k: Vec = (0..5).map(|_| r.f64()).collect::>()?; + let (cx, cy) = (r.f64()?, r.f64()?); + let (cx, cy, m) = centre(img, cx, cy); + if m <= 0.0 { + return Ok(()); + } + let (w, np) = (img.width, img.planes); + for (i, px) in img.data.chunks_exact_mut(np.max(1)).enumerate() { + let (x, y) = ((i % w) as f64, (i / w) as f64); + let r2 = ((x - cx).powi(2) + (y - cy).powi(2)) / (m * m); + let g = 1.0 + r2 * (k[0] + r2 * (k[1] + r2 * (k[2] + r2 * (k[3] + r2 * k[4])))); + for v in px { + *v = (f64::from(*v) * g) as f32; + } + } + Ok(()) +} + +/// Interpolate over `bad` pixels of a Bayer mosaic: the mean of the nearest good pixels of the +/// same colour (within 2, else 4, … up to 8 pixels). +fn fix_bad(img: &mut Image, phase: u32, bad: &[usize]) -> Result<()> { + if bad.is_empty() { + return Ok(()); + } + // a real sensor has few bad pixels; a list covering much of the picture is not one + if bad.len() > img.data.len() / 16 + 64 { + return Err(Error::Unsupported("bad pixel opcode covering much of the picture".into())); + } + if img.planes != 1 { + return Err(Error::Unsupported("bad pixel opcodes on a picture that is not a mosaic".into())); + } + // BayerPhase: the colour of the top-left pixel (0 red, 1 green in a red row, 2 green in a + // blue row, 3 blue) + let quad: [u8; 4] = match phase { + 0 => [0, 1, 1, 2], + 1 => [1, 0, 2, 1], + 2 => [1, 2, 0, 1], + 3 => [2, 1, 1, 0], + _ => return Err(Error::Malformed("BayerPhase")), + }; + let (w, h) = (img.width, img.height); + let mut is_bad = vec![false; w * h]; + for &i in bad { + if let Some(b) = is_bad.get_mut(i) { + *b = true; + } + } + let color = |x: usize, y: usize| quad[(y & 1) * 2 + (x & 1)]; + let src = img.data.clone(); + for &i in bad { + let (x, y) = (i % w, i / w); + let me = color(x, y); + for radius in [2isize, 4, 6, 8] { + let (mut sum, mut n) = (0f64, 0u32); + for dy in -radius..=radius { + for dx in -radius..=radius { + let (sx, sy) = (x as isize + dx, y as isize + dy); + if sx < 0 || sy < 0 || sx as usize >= w || sy as usize >= h || (dx == 0 && dy == 0) { + continue; + } + let (sx, sy) = (sx as usize, sy as usize); + if color(sx, sy) == me && !is_bad[sy * w + sx] { + sum += f64::from(src[sy * w + sx]); + n += 1; + } + } + } + if n > 0 { + if let Some(v) = img.data.get_mut(i) { + *v = (sum / f64::from(n)) as f32; + } + break; + } + } + } + Ok(()) +} + +fn trim(r: &mut Reader, img: &mut Image) -> Result<()> { + let (t, l, b, rt) = (r.u32()? as usize, r.u32()? as usize, r.u32()? as usize, r.u32()? as usize); + if !img.allow_trim { + return Err(Error::Unsupported("TrimBounds before the demosaic".into())); + } + let (b, rt) = (b.min(img.height), rt.min(img.width)); + if t >= b || l >= rt { + return Err(Error::Malformed("TrimBounds outside the picture")); + } + let (np, w) = (img.planes, img.width); + let nw = rt - l; + let mut out = Vec::with_capacity(nw * (b - t) * np); + for y in t..b { + out.extend_from_slice(img.data.get((y * w + l) * np..(y * w + rt) * np).ok_or(Error::Malformed("TrimBounds"))?); + } + *img.data = out; + img.width = nw; + img.height = b - t; + img.origin = (img.origin.0 + l, img.origin.1 + t); + Ok(()) +} + +/// Catmull–Rom weights for a fractional position `t` in 0–1. +fn cubic(t: f64) -> [f64; 4] { + let (t2, t3) = (t * t, t * t * t); + [(-t3 + 2.0 * t2 - t) / 2.0, (3.0 * t3 - 5.0 * t2 + 2.0) / 2.0, (-3.0 * t3 + 4.0 * t2 + t) / 2.0, (t3 - t2) / 2.0] +} + +/// The radial model of a warp opcode for one plane. +enum Radial { + /// WarpRectilinear: f = kr0 + kr1 r² + kr2 r⁴ + kr3 r⁶, tangential kt0, kt1. + Rectilinear([f64; 4], [f64; 2]), + /// WarpFisheye: f = (kr0 θ + kr1 θ³ + kr2 θ⁵ + kr3 θ⁷) / r, θ = atan r. + Fisheye([f64; 4]), + /// WarpRectilinear2: f(r) = Σ kr_p r^p (p ≤ 14) at r clamped to the valid range, multiplied + /// (or divided, reciprocal) into r; tangential kt0, kt1. + Rectilinear2 { kr: [f64; 15], kt: [f64; 2], min: f64, max: f64, reciprocal: bool }, +} + +impl Radial { + /// Source offset (normalised) of destination offset (dx, dy). + fn map(&self, dx: f64, dy: f64) -> (f64, f64) { + let r2 = dx * dx + dy * dy; + let tangential = |kt: &[f64; 2]| (kt[0] * (2.0 * dx * dy) + kt[1] * (r2 + 2.0 * dx * dx), kt[1] * (2.0 * dx * dy) + kt[0] * (r2 + 2.0 * dy * dy)); + match self { + Radial::Rectilinear(kr, kt) => { + let f = kr[0] + r2 * (kr[1] + r2 * (kr[2] + r2 * kr[3])); + let (tx, ty) = tangential(kt); + (f * dx + tx, f * dy + ty) + } + Radial::Fisheye(kr) => { + let r = r2.sqrt(); + let f = if r < 1e-12 { + kr[0] + } else { + let t = r.atan(); + let t2 = t * t; + t * (kr[0] + t2 * (kr[1] + t2 * (kr[2] + t2 * kr[3]))) / r + }; + (f * dx, f * dy) + } + Radial::Rectilinear2 { kr, kt, min, max, reciprocal } => { + let r = r2.sqrt().clamp(*min, *max); + let f = kr.iter().rev().fold(0.0, |acc, k| acc * r + k); + let f = if *reciprocal { + if f.abs() < 1e-12 { + return (dx, dy); + } + 1.0 / f + } else { + f + }; + let (tx, ty) = tangential(kt); + (f * dx + tx, f * dy + ty) + } + } + } +} + +fn warp(id: u32, r: &mut Reader, img: &mut Image) -> Result<()> { + if img.mosaic { + return Err(Error::Unsupported("a warp opcode on a CFA mosaic".into())); + } + let per_set = match id { + 1 => 6, + 2 => 4, + _ => 19, + }; + let n = r.count(per_set * 8)?; + if n != 1 && n != img.planes { + return Err(Error::Malformed("warp opcode coefficient sets")); + } + let mut sets = Vec::with_capacity(n); + for _ in 0..n { + let v: Vec = (0..per_set).map(|_| r.f64()).collect::>()?; + sets.push(match id { + 1 => Radial::Rectilinear([v[0], v[1], v[2], v[3]], [v[4], v[5]]), + 2 => Radial::Fisheye([v[0], v[1], v[2], v[3]]), + _ => { + let mut kr = [0f64; 15]; + kr.copy_from_slice(&v[..15]); + let (min, max) = (v[17].clamp(0.0, 1.0), v[18].clamp(0.0, 1.0)); + if min >= max { + return Err(Error::Malformed("WarpRectilinear2 valid radius range")); + } + Radial::Rectilinear2 { kr, kt: [v[15], v[16]], min, max, reciprocal: false } + } + }); + } + let (cx, cy) = (r.f64()?, r.f64()?); + if id == 14 { + let reciprocal = r.u32()? != 0; + for s in &mut sets { + if let Radial::Rectilinear2 { reciprocal: rr, .. } = s { + *rr = reciprocal; + } + } + } + let (cx, cy, m) = centre(img, cx, cy); + if m <= 0.0 { + return Ok(()); + } + let (w, h, np) = (img.width, img.height, img.planes); + let src = img.data.clone(); + let sample = |p: usize, x: isize, y: isize| { + let (x, y) = (x.clamp(0, w as isize - 1) as usize, y.clamp(0, h as isize - 1) as usize); + f64::from(src.get((y * w + x) * np + p).copied().unwrap_or(0.0)) + }; + for (i, px) in img.data.chunks_exact_mut(np.max(1)).enumerate() { + let (x, y) = ((i % w) as f64, (i / w) as f64); + let (dx, dy) = ((x - cx) / m, (y - cy) / m); + for (p, v) in px.iter_mut().enumerate() { + let model = sets.get(p).or(sets.first()); + let Some(model) = model else { continue }; + let (ox, oy) = model.map(dx, dy); + let (sx, sy) = (cx + m * ox, cy + m * oy); + if !sx.is_finite() || !sy.is_finite() { + continue; + } + let (fx, fy) = (sx.floor(), sy.floor()); + let (wx, wy) = (cubic(sx - fx), cubic(sy - fy)); + let (ix, iy) = (fx.clamp(-4.0, w as f64 + 4.0) as isize, fy.clamp(-4.0, h as f64 + 4.0) as isize); + let mut acc = 0.0; + for (j, wyj) in wy.iter().enumerate() { + let mut row = 0.0; + for (k, wxk) in wx.iter().enumerate() { + row += wxk * sample(p, ix + k as isize - 1, iy + j as isize - 1); + } + acc += wyj * row; + } + *v = acc as f32; + } + } + Ok(()) +} + +#[cfg(any(test, feature = "writer"))] +/// Encode an opcode list (big-endian), for tests: (id, flags, parameters). +pub fn encode(list: &[(u32, u32, Vec)]) -> Vec { + let mut out = (list.len() as u32).to_be_bytes().to_vec(); + for (id, flags, params) in list { + let version: u32 = if *id == 14 { 0x0106_0000 } else { 0x0103_0000 }; + for v in [*id, version, *flags, params.len() as u32] { + out.extend(v.to_be_bytes()); + } + out.extend(params); + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + + fn u(v: &[u32]) -> Vec { + v.iter().flat_map(|x| x.to_be_bytes()).collect() + } + + fn d(v: &[f64]) -> Vec { + v.iter().flat_map(|x| x.to_be_bytes()).collect() + } + + fn f(v: &[f32]) -> Vec { + v.iter().flat_map(|x| x.to_be_bytes()).collect() + } + + fn area(t: u32, l: u32, b: u32, r: u32, plane: u32, planes: u32, rp: u32, cp: u32) -> Vec { + u(&[t, l, b, r, plane, planes, rp, cp]) + } + + /// Run one opcode on a float picture (range 0–1). + fn run1(id: u32, params: Vec, data: &mut Vec, w: usize, h: usize, planes: usize) -> Result<(usize, usize)> { + let list = parse(&encode(&[(id, 0, params)]))?; + let mut img = Image { data, width: w, height: h, planes, max: 1.0, mosaic: false, allow_trim: true, origin: (0, 0) }; + apply(&list, &mut img, false)?; + Ok((img.width, img.height)) + } + + fn close(a: f32, b: f32) -> bool { + (a - b).abs() < 1e-5 + } + + #[test] + fn list_parsing_and_hostile_lists() { + let l = encode(&[(9, 1, vec![1, 2, 3]), (3, 2, vec![])]); + let p = parse(&l).unwrap(); + assert_eq!(p.len(), 2); + assert_eq!((p[0].id, p[0].version, p[0].params.as_slice()), (9, 0x0103_0000, &[1u8, 2, 3][..])); + assert!(p[0].optional() && !p[0].preview_skippable()); + assert!(!p[1].optional() && p[1].preview_skippable()); + // every truncation is an error, never a panic + for n in 0..l.len() { + assert!(parse(&l[..n]).is_err(), "{n}"); + } + // counts and sizes beyond the data + assert!(parse(&u(&[u32::MAX])).is_err()); + assert!(parse(&u(&[1, 9, 0, 0, u32::MAX])).is_err()); + assert!(parse(&u(&[(MAX_OPCODES + 1) as u32]).into_iter().chain(vec![0; 16 * (MAX_OPCODES + 1)]).collect::>()).is_err()); + assert_eq!(parse(&u(&[0])).unwrap(), vec![]); + } + + #[test] + fn unknown_and_newer_opcodes() { + let mut data = vec![0.5f32; 4]; + let mut img = Image { data: &mut data, width: 2, height: 2, planes: 1, max: 1.0, mosaic: false, allow_trim: false, origin: (0, 0) }; + // unknown id: skipped when optional, an error when not + assert!(apply(&parse(&encode(&[(99, 1, vec![])])).unwrap(), &mut img, false).is_ok()); + assert!(matches!(apply(&parse(&encode(&[(99, 0, vec![])])).unwrap(), &mut img, false), Err(Error::Unsupported(_)))); + // a known id from a newer DNG version is unknown + let newer = [Opcode { id: 3, version: 0x0108_0000, flags: 0, params: vec![] }]; + assert!(matches!(apply(&newer, &mut img, false), Err(Error::Unsupported(_)))); + // an opcode this stage cannot run: skipped when optional + let trim = Opcode { id: 6, version: 0x0103_0000, flags: 1, params: u(&[0, 0, 1, 1]) }; + assert!(apply(std::slice::from_ref(&trim), &mut img, false).is_ok()); + assert!(apply(&[Opcode { flags: 0, ..trim }], &mut img, false).is_err()); + // preview quality skips flagged opcodes + let scale = Opcode { id: 12, version: 0x0103_0000, flags: 2, params: [area(0, 0, 2, 2, 0, 1, 1, 1), u(&[2]), f(&[0.5, 0.5])].concat() }; + apply(std::slice::from_ref(&scale), &mut img, true).unwrap(); + assert_eq!(img.data[0], 0.5); + apply(&[scale], &mut img, false).unwrap(); + assert_eq!(img.data[0], 0.25); + // malformed parameters are errors + assert!(apply(&[Opcode { id: 10, version: 0x0103_0000, flags: 0, params: vec![0; 5] }], &mut img, false).is_err()); + } + + #[test] + fn map_table_polynomial_delta_and_scale() { + // 4 × 2, two planes; affect plane 1 only, every second column + let mut data: Vec = (0..16).map(|i| i as f32 / 20.0).collect(); + let orig = data.clone(); + // MapTable: 16-bit identity reversed (v → 1 − v) + let table: Vec = (0..=65_535u32).rev().flat_map(|v| (v as u16).to_be_bytes()).collect(); + run1(7, [area(0, 0, 2, 4, 1, 1, 1, 2), u(&[65_536]), table].concat(), &mut data, 4, 2, 2).unwrap(); + for (i, (a, b)) in data.iter().zip(&orig).enumerate() { + let (x, p) = ((i / 2) % 4, i % 2); + let want = if p == 1 && x % 2 == 0 { 1.0 - (b * 65_535.0).round() / 65_535.0 } else { *b }; + assert!(close(*a, want), "{i}: {a} {want}"); + } + // MapPolynomial 0.1 + 0.5 x on everything + let mut data = orig.clone(); + run1(8, [area(0, 0, 2, 4, 0, 2, 1, 1), u(&[1]), d(&[0.1, 0.5])].concat(), &mut data, 4, 2, 2).unwrap(); + for (a, b) in data.iter().zip(&orig) { + assert!(close(*a, 0.1 + 0.5 * b)); + } + // DeltaPerRow (rows 0, 1), ScalePerColumn (columns 1..3) + let mut data = orig.clone(); + run1(10, [area(0, 0, 2, 4, 0, 2, 1, 1), u(&[2]), f(&[0.01, -0.02])].concat(), &mut data, 4, 2, 2).unwrap(); + for (i, (a, b)) in data.iter().zip(&orig).enumerate() { + let want = (b + if i < 8 { 0.01 } else { -0.02 }).clamp(0.0, 1.0); + assert!(close(*a, want), "{i}"); + } + let mut data = orig.clone(); + run1(13, [area(0, 1, 2, 3, 0, 2, 1, 1), u(&[2]), f(&[2.0, 0.5])].concat(), &mut data, 4, 2, 2).unwrap(); + for (i, (a, b)) in data.iter().zip(&orig).enumerate() { + let x = (i / 2) % 4; + let want = match x { + 1 => (b * 2.0).min(1.0), + 2 => b * 0.5, + _ => *b, + }; + assert!(close(*a, want), "{i}"); + } + // too few deltas for the rows is an error + let mut data = orig.clone(); + assert!(run1(10, [area(0, 0, 2, 4, 0, 2, 1, 1), u(&[1]), f(&[0.1])].concat(), &mut data, 4, 2, 2).is_err()); + // zero pitch is an error, areas outside the picture are clamped + assert!(run1(12, [area(0, 0, 2, 4, 0, 1, 0, 1), u(&[0])].concat(), &mut data, 4, 2, 2).is_err()); + let mut data = orig.clone(); + run1(12, [area(1, 3, 99, 99, 5, 9, 1, 1), u(&[1]), f(&[0.0])].concat(), &mut data, 4, 2, 2).unwrap(); + assert_eq!(data, orig, "plane 5 does not exist"); + } + + #[test] + fn gain_map_interpolates_and_replicates() { + // 2 × 2 map at the corners of the picture's relative coordinates 0 and 0.5 + let (w, h) = (8, 8); + let mut data = vec![0.25f32; w * h]; + let gains = f(&[1.0, 2.0, 3.0, 4.0]); + run1(9, [area(0, 0, 8, 8, 0, 1, 1, 1), u(&[2, 2]), d(&[0.5, 0.5, 0.0, 0.0]), u(&[1]), gains].concat(), &mut data, w, h, 1).unwrap(); + let g = |x: usize, y: usize| data[y * w + x] / 0.25; + assert!(close(g(0, 0), 1.0)); + assert!(close(g(4, 0), 2.0), "{}", g(4, 0)); + assert!(close(g(0, 4), 3.0)); + assert!(close(g(2, 2), 2.5), "bilinear in the middle: {}", g(2, 2)); + assert!(close(g(7, 7), 4.0), "replicated past the map"); + // a map larger than its parameters is an error + let mut data = vec![0.25f32; 4]; + assert!(run1(9, [area(0, 0, 2, 2, 0, 1, 1, 1), u(&[1000, 1000]), d(&[0.1, 0.1, 0.0, 0.0]), u(&[1]), f(&[1.0])].concat(), &mut data, 2, 2, 1).is_err()); + } + + #[test] + fn vignette_and_warps() { + // FixVignetteRadial k0 = 1: g = 1 + r², the centre unchanged, the corners doubled + let (w, h) = (5, 5); + let mut data = vec![0.25f32; w * h]; + run1(3, d(&[1.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5]), &mut data, w, h, 1).unwrap(); + assert!(close(data[2 * w + 2], 0.25)); + assert!(close(data[0], 0.5) && close(data[w * h - 1], 0.5)); + assert!(close(data[2 * w], 0.25 * 1.5), "r² = 0.5 at the edge middle: {}", data[2 * w]); + // identity warps leave the picture alone; kr0 = 0.5 magnifies a ramp about the centre + let (w, h) = (9, 7); + let ramp: Vec = (0..w * h).flat_map(|i| [(i % w) as f32 / 10.0, (i / w) as f32 / 10.0]).collect(); + let mut data = ramp.clone(); + run1(1, [u(&[1]), d(&[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); + assert!(data.iter().zip(&ramp).all(|(a, b)| close(*a, *b))); + let mut data = ramp.clone(); + run1(1, [u(&[1]), d(&[0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); + // x' = 4 + 0.5 (x − 4): the cubic reproduces a linear ramp exactly + for x in 1..w - 1 { + let want = (4.0 + 0.5 * (x as f32 - 4.0)) / 10.0; + assert!(close(data[(3 * w + x) * 2], want), "x {x}: {} vs {want}", data[(3 * w + x) * 2]); + } + // one coefficient set per plane: plane 1 untouched + let mut data = ramp.clone(); + run1(1, [u(&[2]), d(&[0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); + assert!(data.iter().skip(1).step_by(2).zip(ramp.iter().skip(1).step_by(2)).all(|(a, b)| close(*a, *b))); + // three sets for two planes is malformed + let mut data = ramp.clone(); + assert!(run1(1, [u(&[3]), vec![0; 3 * 48 + 16]].concat(), &mut data, w, h, 2).is_err()); + // WarpFisheye kr0 = 1: f = atan(r) / r pulls sources towards the centre + let mut data = ramp.clone(); + run1(2, [u(&[1]), d(&[1.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); + let m = (16.0f64 + 9.0).sqrt(); + let dx = 3.0 / m; + let want = (4.0 + m * dx.atan()) / 10.0; + assert!((f64::from(data[(3 * w + 7) * 2]) - want).abs() < 1e-3, "{} vs {want}", data[(3 * w + 7) * 2]); + // WarpRectilinear2 identity (kr0 = 1), and the skip rule for a following warp + let wr2 = |flags| (14, flags, [u(&[1]), d(&[1.0]), d(&[0.0; 14]), d(&[0.0, 0.0, 0.0, 1.0, 0.5, 0.5]), u(&[0])].concat()); + let halve = (1, 0, [u(&[1]), d(&[0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat()); + for (flags, skipped) in [(1, true), (0, false)] { + let list = parse(&encode(&[wr2(flags), halve.clone()])).unwrap(); + let mut data = ramp.clone(); + let mut img = Image { data: &mut data, width: w, height: h, planes: 2, max: 1.0, mosaic: false, allow_trim: false, origin: (0, 0) }; + apply(&list, &mut img, false).unwrap(); + let unchanged = data.iter().zip(&ramp).all(|(a, b)| close(*a, *b)); + assert_eq!(unchanged, skipped, "optional WarpRectilinear2 {flags}"); + } + // warps are refused on a mosaic + let mut data = vec![0.5f32; 16]; + let mut img = Image { data: &mut data, width: 4, height: 4, planes: 1, max: 1.0, mosaic: true, allow_trim: false, origin: (0, 0) }; + assert!(apply(&parse(&encode(&[halve])).unwrap(), &mut img, false).is_err()); + } + + #[test] + fn bad_pixels_and_trim() { + // RGGB 6 × 6 with each colour flat; two bad pixels and a bad 2 × 2 rectangle + let (w, h) = (6, 6); + let level = [0.2f32, 0.5, 0.5, 0.8]; + let flat: Vec = (0..w * h).map(|i| level[(i / w % 2) * 2 + i % 2]).collect(); + let mut data = flat.clone(); + data[2 * w + 2] = 0.0; + data[3 * w + 4] = 0.0; + // FixBadPixelsConstant 0, phase 0 (red top left), integer stage + let mut ints: Vec = data.iter().map(|v| (v * 65_535.0).round()).collect(); + let list = parse(&encode(&[(4, 0, u(&[0, 0]))])).unwrap(); + let mut img = Image { data: &mut ints, width: w, height: h, planes: 1, max: 65_535.0, mosaic: true, allow_trim: false, origin: (0, 0) }; + apply(&list, &mut img, false).unwrap(); + for (a, b) in ints.iter().zip(&flat) { + assert_eq!(*a, (b * 65_535.0).round()); + } + // FixBadPixelsList: a point and a rectangle + let mut data = flat.clone(); + for i in [w + 1, 4 * w + 3, 4 * w + 4, 5 * w + 3, 5 * w + 4] { + data[i] = 0.9; + } + run1(5, u(&[0, 1, 1, 1, 1, 4, 3, 6, 5]), &mut data, w, h, 1).unwrap(); + assert!(data.iter().zip(&flat).all(|(a, b)| close(*a, *b)), "{data:?}"); + // a bad phase is malformed; huge lists are refused before allocating + let mut data = flat.clone(); + assert!(run1(5, u(&[7, 1, 0, 1, 1]), &mut data, w, h, 1).is_err()); + assert!(run1(5, u(&[0, u32::MAX, u32::MAX]), &mut data, w, h, 1).is_err()); + // TrimBounds + let mut data: Vec = (0..w * h * 3).map(|i| i as f32 / 200.0).collect(); + let (tw, th) = run1(6, u(&[1, 2, 4, 5]), &mut data, w, h, 3).unwrap(); + assert_eq!((tw, th, data.len()), (3, 3, 27)); + assert!(close(data[0], ((w + 2) * 3) as f32 / 200.0)); + let mut data = vec![0f32; 4]; + assert!(run1(6, u(&[1, 1, 1, 2]), &mut data, 2, 2, 1).is_err()); + } +} From c48cf22a03d6b251b43b21e28ac90a4ddd7715b7 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 19:41:21 -0500 Subject: [PATCH 2/5] Adapt attributed FilmCraft opcode envelopes to shared bounded API Reuse vangel76 source from filmcraft commit 7e6f075ef7d0e9d2517628a7f48f648b5aff2f1b. Keep shared extraction code unchanged while retaining corrected parent provenance. --- crates/raw/src/lib.rs | 2 + crates/raw/src/opcode_raw.rs | 893 ++--------------------------------- 2 files changed, 47 insertions(+), 848 deletions(-) diff --git a/crates/raw/src/lib.rs b/crates/raw/src/lib.rs index f97f5e11a..bfc098734 100644 --- a/crates/raw/src/lib.rs +++ b/crates/raw/src/lib.rs @@ -116,6 +116,8 @@ mod nef; mod nef_lens; #[cfg(feature = "nef")] mod nefc; +/// Bounded raw DNG opcode-list envelopes. +pub mod opcode_raw; pub mod opcodes; #[cfg(feature = "orf")] mod orf; diff --git a/crates/raw/src/opcode_raw.rs b/crates/raw/src/opcode_raw.rs index bb05c650a..05b4c31ce 100644 --- a/crates/raw/src/opcode_raw.rs +++ b/crates/raw/src/opcode_raw.rs @@ -1,653 +1,67 @@ -//! DNG opcode lists (DNG 1.7.1.0 chapter 7, "Opcode List Processing"): OpcodeList1 on the raw -//! samples as stored, OpcodeList2 on the linear reference values (after linearisation, black and -//! white levels, before white balance), OpcodeList3 on the demosaiced picture. -//! -//! An opcode list is big-endian whatever the file's byte order: a count, then per opcode its ID, -//! the DNG version that defined it, flags (bit 0 optional, bit 1 skippable for preview quality) -//! and the size of its parameters. Implemented: WarpRectilinear (1), WarpFisheye (2), -//! FixVignetteRadial (3), FixBadPixelsConstant (4), FixBadPixelsList (5), TrimBounds (6), -//! MapTable (7), MapPolynomial (8), GainMap (9), DeltaPerRow / Column (10, 11), ScalePerRow / -//! Column (12, 13) and WarpRectilinear2 (14, with the skip rule for a following warp). An unknown -//! opcode, or one from a DNG version newer than 1.7.1.0, is skipped when it is optional and an -//! error when it is not. Values are clipped to the stage's logical range after every opcode -//! (0–65535 for OpcodeList1, 0–1 after). -//! -//! Interpretations where the specification leaves room (recorded in the crate README): -//! coordinates of OpcodeList1 are those of the stored raw image, of OpcodeList2 and 3 those of the -//! ActiveArea; GainMap positions are relative to the whole image of the stage (row / height, -//! column / width); Delta and MapPolynomial values are in the 0–1 range at every stage (scaled by -//! 65535 on OpcodeList1's integer samples), MapTable indexes 16-bit values (0–1 scaled by 65535 -//! after OpcodeList1); warps resample with a Catmull–Rom cubic and are refused on CFA mosaics, -//! as is TrimBounds before OpcodeList3. -//! -//! Every count and size is checked against the bytes of the parameter area before anything is -//! allocated, and per-opcode work is bounded by the image size. +//! DNG opcode-list envelopes, retaining unrecognized records and their parameter bytes. -use crate::{Error, Result}; - -/// The newest DNG version whose opcodes this reader knows (1.7.1.0). -const KNOWN_VERSION: u32 = 0x0107_0100; - -/// Most opcodes in one list (each may touch the whole picture). -pub const MAX_OPCODES: usize = 256; - -const OPTIONAL: u32 = 1; -const PREVIEW_SKIPPABLE: u32 = 2; - -/// One opcode of a list. +/// An opcode with its version, flags and unmodified parameter bytes. #[derive(Clone, Debug, PartialEq)] pub struct Opcode { + /// Opcode identifier. pub id: u32, - /// The DNG version that defined it, as four bytes in a big-endian u32 (1.3.0.0 = 0x01030000). + /// Four-byte DNG version, stored as a big-endian integer. pub version: u32, + /// Opcode flags. pub flags: u32, + /// Unmodified parameter bytes. pub params: Vec, } - impl Opcode { + /// Unknown or unsupported optional opcodes may be skipped. pub fn optional(&self) -> bool { - self.flags & OPTIONAL != 0 + self.flags & 1 != 0 } - + /// The opcode may be skipped for preview quality. pub fn preview_skippable(&self) -> bool { - self.flags & PREVIEW_SKIPPABLE != 0 + self.flags & 2 != 0 } } -/// The opcode lists of a raw IFD. -#[derive(Clone, Debug, Default, PartialEq)] -pub struct Lists { - pub list1: Vec, - pub list2: Vec, - pub list3: Vec, -} +/// A damaged opcode list or one exceeding the caller's count limit. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Malformed; -/// Parse an opcode list (big-endian). -pub fn parse(b: &[u8]) -> Result> { - let bad = || Error::Malformed("opcode list"); - let mut r = Reader::new(b); - let count = r.u32().map_err(|_| bad())? as usize; - // every opcode takes at least 16 bytes - if count > b.len() / 16 || count > MAX_OPCODES { - return Err(bad()); +/// Parse a big-endian opcode list with an explicit maximum record count. +pub fn parse(bytes: &[u8], max_opcodes: usize) -> Result, Malformed> { + let mut at = 0usize; + let read = |at: &mut usize| -> Result { + let end = at.checked_add(4).ok_or(Malformed)?; + let value = bytes.get(*at..end).and_then(|b| b.try_into().ok()).map(u32::from_be_bytes).ok_or(Malformed)?; + *at = end; + Ok(value) + }; + let count = read(&mut at)? as usize; + if count > bytes.len() / 16 || count > max_opcodes { + return Err(Malformed); } let mut out = Vec::with_capacity(count); for _ in 0..count { - let id = r.u32().map_err(|_| bad())?; - let version = r.u32().map_err(|_| bad())?; - let flags = r.u32().map_err(|_| bad())?; - let len = r.u32().map_err(|_| bad())? as usize; - let params = r.bytes(len).map_err(|_| bad())?.to_vec(); + let id = read(&mut at)?; + let version = read(&mut at)?; + let flags = read(&mut at)?; + let len = read(&mut at)? as usize; + let end = at.checked_add(len).ok_or(Malformed)?; + let params = bytes.get(at..end).ok_or(Malformed)?.to_vec(); + at = end; out.push(Opcode { id, version, flags, params }); } Ok(out) } -/// Big-endian parameter reader. -struct Reader<'a> { - b: &'a [u8], - pos: usize, -} - -impl<'a> Reader<'a> { - fn new(b: &'a [u8]) -> Self { - Reader { b, pos: 0 } - } - - fn bytes(&mut self, n: usize) -> Result<&'a [u8]> { - let end = self.pos.checked_add(n).ok_or(Error::Malformed("opcode parameters"))?; - let s = self.b.get(self.pos..end).ok_or(Error::Malformed("opcode parameters too short"))?; - self.pos = end; - Ok(s) - } - - fn u32(&mut self) -> Result { - let s = self.bytes(4)?; - Ok(u32::from_be_bytes([s[0], s[1], s[2], s[3]])) - } - - fn f32(&mut self) -> Result { - let v = f32::from_bits(self.u32()?); - if v.is_finite() { Ok(v) } else { Err(Error::Malformed("non-finite opcode parameter")) } - } - - fn f64(&mut self) -> Result { - let s = self.bytes(8)?; - let v = f64::from_be_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]); - if v.is_finite() { Ok(v) } else { Err(Error::Malformed("non-finite opcode parameter")) } - } - - fn remaining(&self) -> usize { - self.b.len().saturating_sub(self.pos) - } - - /// A count of items of `size` bytes each that must fit in what is left. - fn count(&mut self, size: usize) -> Result { - let n = self.u32()? as usize; - if n.saturating_mul(size) > self.remaining() { - return Err(Error::Malformed("opcode count larger than its parameters")); - } - Ok(n) - } -} - -/// The picture an opcode list works on: `planes` interleaved samples per pixel. -pub struct Image<'a> { - pub data: &'a mut Vec, - pub width: usize, - pub height: usize, - pub planes: usize, - /// The stage's logical maximum: 65535 for OpcodeList1 (integer samples, rounded after every - /// opcode), 1 for OpcodeList2 and 3. - pub max: f32, - /// A CFA mosaic (one sample per pixel before the demosaic): warps are refused. - pub mosaic: bool, - /// TrimBounds is allowed (OpcodeList3 only: the picture may change size). - pub allow_trim: bool, - /// Origin of the picture after TrimBounds, relative to where it started. - pub origin: (usize, usize), -} - -impl Image<'_> { - fn integer(&self) -> bool { - self.max > 1.0 - } - - fn clip(&mut self) { - let (max, int) = (self.max, self.integer()); - for v in self.data.iter_mut() { - let c = v.clamp(0.0, max); - *v = if int { - c.round() - } else if c.is_nan() { - 0.0 - } else { - c - }; - } - } -} - -/// Apply `list`. `preview` skips the opcodes marked as only needed for full quality. -pub fn apply(list: &[Opcode], img: &mut Image, preview: bool) -> Result<()> { - let mut skip_warp = false; - for op in list { - let skip_this = std::mem::take(&mut skip_warp) && matches!(op.id, 1 | 2); - if skip_this || (preview && op.preview_skippable()) { - continue; - } - let known = op.version <= KNOWN_VERSION && (1..=14).contains(&op.id); - if !known { - if op.optional() { - continue; - } - return Err(Error::Unsupported(format!("DNG opcode {} (version {:08x})", op.id, op.version))); - } - match run(op, img) { - Ok(()) => {} - // an optional opcode this reader cannot apply here is left out - Err(Error::Unsupported(_)) if op.optional() => continue, - Err(e) => return Err(e), - } - img.clip(); - if op.id == 14 && op.optional() { - skip_warp = true; - } - } - Ok(()) -} - -fn run(op: &Opcode, img: &mut Image) -> Result<()> { - let mut r = Reader::new(&op.params); - match op.id { - 1 | 2 | 14 => warp(op.id, &mut r, img), - 3 => vignette(&mut r, img), - 4 => { - let constant = r.u32()?; - let phase = r.u32()?; - let mut bad = Vec::new(); - let c = if img.integer() { constant as f32 } else { constant as f32 / 65_535.0 }; - for (i, px) in img.data.iter().enumerate() { - if *px == c { - bad.push(i); - } - } - fix_bad(img, phase, &bad) - } - 5 => { - let phase = r.u32()?; - let points = r.u32()? as usize; - let rects = r.u32()? as usize; - if points.saturating_mul(8).saturating_add(rects.saturating_mul(16)) > r.remaining() { - return Err(Error::Malformed("FixBadPixelsList counts larger than its parameters")); - } - let (w, h) = (img.width, img.height); - let mut mask = vec![false; w * h]; - for _ in 0..points { - let (y, x) = (r.u32()? as usize, r.u32()? as usize); - if x < w && y < h { - mask[y * w + x] = true; - } - } - for _ in 0..rects { - let (t, l, b, rt) = (r.u32()? as usize, r.u32()? as usize, r.u32()? as usize, r.u32()? as usize); - for y in t.min(h)..b.min(h) { - for x in l.min(w)..rt.min(w) { - mask[y * w + x] = true; - } - } - } - let bad: Vec = mask.iter().enumerate().filter_map(|(i, &b)| b.then_some(i)).collect(); - fix_bad(img, phase, &bad) - } - 6 => trim(&mut r, img), - _ => area_op(op.id, &mut r, img), - } -} - -/// The area fields of opcodes 7–13, clamped to the picture. -struct Area { - top: usize, - left: usize, - bottom: usize, - right: usize, - plane: usize, - planes: usize, - row_pitch: usize, - col_pitch: usize, -} - -impl Area { - fn read(r: &mut Reader, img: &Image) -> Result { - let mut v = [0usize; 8]; - for x in &mut v { - *x = r.u32()? as usize; - } - let [top, left, bottom, right, plane, planes, row_pitch, col_pitch] = v; - if row_pitch == 0 || col_pitch == 0 { - return Err(Error::Malformed("opcode area with a zero pitch")); - } - let plane = plane.min(img.planes); - Ok(Area { - top: top.min(img.height), - left: left.min(img.width), - bottom: bottom.min(img.height), - right: right.min(img.width), - plane, - planes: planes.min(img.planes - plane), - row_pitch, - col_pitch, - }) - } - - /// Rows of the area, in order. - fn rows(&self) -> impl Iterator + use<> { - (self.top..self.bottom.max(self.top)).step_by(self.row_pitch) - } - - fn cols(&self) -> impl Iterator + use<> { - (self.left..self.right.max(self.left)).step_by(self.col_pitch) - } - - /// Visit every affected sample: f(row index in area, col index in area, x, y, plane index in - /// area, value). - fn each(&self, img: &mut Image, mut f: impl FnMut(usize, usize, usize, usize, usize, &mut f32)) { - let (w, np) = (img.width, img.planes); - for (ri, y) in self.rows().enumerate() { - for (ci, x) in self.cols().enumerate() { - for p in 0..self.planes { - if let Some(v) = img.data.get_mut((y * w + x) * np + self.plane + p) { - f(ri, ci, x, y, p, v); - } - } - } - } - } -} - -fn area_op(id: u32, r: &mut Reader, img: &mut Image) -> Result<()> { - let a = Area::read(r, img)?; - let scale = img.max; - match id { - 7 => { - let n = r.count(2)?; - if n == 0 { - return Err(Error::Malformed("MapTable without entries")); - } - let table: Vec = (0..n).map(|_| r.bytes(2).map(|b| f32::from(u16::from_be_bytes([b[0], b[1]])))).collect::>()?; - let last = table.last().copied().unwrap_or(0.0); - a.each(img, |_, _, _, _, _, v| { - let code = (*v / scale * 65_535.0).round().clamp(0.0, 65_535.0) as usize; - *v = table.get(code).copied().unwrap_or(last) / 65_535.0 * scale; - }); - } - 8 => { - let degree = r.u32()? as usize; - if degree > 8 { - return Err(Error::Malformed("MapPolynomial degree above 8")); - } - let c: Vec = (0..=degree).map(|_| r.f64()).collect::>()?; - a.each(img, |_, _, _, _, _, v| { - let x = f64::from(*v / scale); - let y = c.iter().rev().fold(0.0, |acc, k| acc * x + k); - *v = (y * f64::from(scale)) as f32; - }); - } - 9 => gain_map(&a, r, img)?, - 10..=13 => { - let n = r.count(4)?; - let vals: Vec = (0..n).map(|_| r.f32()).collect::>()?; - let per_row = matches!(id, 10 | 12); - let need = if per_row { a.rows().count() } else { a.cols().count() }; - if vals.len() < need { - return Err(Error::Malformed("opcode with fewer values than rows or columns")); - } - let delta = id <= 11; - a.each(img, |ri, ci, _, _, _, v| { - let k = vals.get(if per_row { ri } else { ci }).copied().unwrap_or(if delta { 0.0 } else { 1.0 }); - *v = if delta { *v + k * scale } else { *v * k }; - }); - } - _ => return Err(Error::Unsupported(format!("DNG opcode {id}"))), - } - Ok(()) -} - -fn gain_map(a: &Area, r: &mut Reader, img: &mut Image) -> Result<()> { - let points_v = r.u32()? as usize; - let points_h = r.u32()? as usize; - let spacing_v = r.f64()?; - let spacing_h = r.f64()?; - let origin_v = r.f64()?; - let origin_h = r.f64()?; - let map_planes = r.u32()? as usize; - let n = points_v.saturating_mul(points_h).saturating_mul(map_planes); - if points_v == 0 || points_h == 0 || map_planes == 0 || n.saturating_mul(4) > r.remaining() { - return Err(Error::Malformed("GainMap size")); - } - if (points_v > 1 && spacing_v <= 0.0) || (points_h > 1 && spacing_h <= 0.0) { - return Err(Error::Malformed("GainMap spacing")); - } - let gains: Vec = (0..n).map(|_| r.f32()).collect::>()?; - let (w, h) = (img.width.max(1) as f64, img.height.max(1) as f64); - let pos = |rel: f64, origin: f64, spacing: f64, points: usize| { - if points <= 1 { - return 0.0; - } - ((rel - origin) / spacing).clamp(0.0, (points - 1) as f64) - }; - let gain = |p: usize, mv: f64, mh: f64| -> f32 { - let mp = p.min(map_planes - 1); - let (v0, h0) = (mv.floor() as usize, mh.floor() as usize); - let (v1, h1) = ((v0 + 1).min(points_v - 1), (h0 + 1).min(points_h - 1)); - let (fv, fh) = (mv - v0 as f64, mh - h0 as f64); - let g = |v: usize, hh: usize| f64::from(gains.get((v * points_h + hh) * map_planes + mp).copied().unwrap_or(1.0)); - let top = g(v0, h0) * (1.0 - fh) + g(v0, h1) * fh; - let bottom = g(v1, h0) * (1.0 - fh) + g(v1, h1) * fh; - (top * (1.0 - fv) + bottom * fv) as f32 - }; - a.each(img, |_, _, x, y, p, v| { - let mv = pos(y as f64 / h, origin_v, spacing_v, points_v); - let mh = pos(x as f64 / w, origin_h, spacing_h, points_h); - *v *= gain(p, mv, mh); - }); - Ok(()) -} - -/// The optical centre in pixels and the distance to the farthest corner (chapter 7). -fn centre(img: &Image, cx: f64, cy: f64) -> (f64, f64, f64) { - let (x1, y1) = (img.width.saturating_sub(1) as f64, img.height.saturating_sub(1) as f64); - let (cx, cy) = (cx * x1, cy * y1); - let mx = cx.abs().max((x1 - cx).abs()); - let my = cy.abs().max((y1 - cy).abs()); - (cx, cy, (mx * mx + my * my).sqrt()) -} - -fn vignette(r: &mut Reader, img: &mut Image) -> Result<()> { - let k: Vec = (0..5).map(|_| r.f64()).collect::>()?; - let (cx, cy) = (r.f64()?, r.f64()?); - let (cx, cy, m) = centre(img, cx, cy); - if m <= 0.0 { - return Ok(()); - } - let (w, np) = (img.width, img.planes); - for (i, px) in img.data.chunks_exact_mut(np.max(1)).enumerate() { - let (x, y) = ((i % w) as f64, (i / w) as f64); - let r2 = ((x - cx).powi(2) + (y - cy).powi(2)) / (m * m); - let g = 1.0 + r2 * (k[0] + r2 * (k[1] + r2 * (k[2] + r2 * (k[3] + r2 * k[4])))); - for v in px { - *v = (f64::from(*v) * g) as f32; - } - } - Ok(()) -} - -/// Interpolate over `bad` pixels of a Bayer mosaic: the mean of the nearest good pixels of the -/// same colour (within 2, else 4, … up to 8 pixels). -fn fix_bad(img: &mut Image, phase: u32, bad: &[usize]) -> Result<()> { - if bad.is_empty() { - return Ok(()); - } - // a real sensor has few bad pixels; a list covering much of the picture is not one - if bad.len() > img.data.len() / 16 + 64 { - return Err(Error::Unsupported("bad pixel opcode covering much of the picture".into())); - } - if img.planes != 1 { - return Err(Error::Unsupported("bad pixel opcodes on a picture that is not a mosaic".into())); - } - // BayerPhase: the colour of the top-left pixel (0 red, 1 green in a red row, 2 green in a - // blue row, 3 blue) - let quad: [u8; 4] = match phase { - 0 => [0, 1, 1, 2], - 1 => [1, 0, 2, 1], - 2 => [1, 2, 0, 1], - 3 => [2, 1, 1, 0], - _ => return Err(Error::Malformed("BayerPhase")), - }; - let (w, h) = (img.width, img.height); - let mut is_bad = vec![false; w * h]; - for &i in bad { - if let Some(b) = is_bad.get_mut(i) { - *b = true; - } - } - let color = |x: usize, y: usize| quad[(y & 1) * 2 + (x & 1)]; - let src = img.data.clone(); - for &i in bad { - let (x, y) = (i % w, i / w); - let me = color(x, y); - for radius in [2isize, 4, 6, 8] { - let (mut sum, mut n) = (0f64, 0u32); - for dy in -radius..=radius { - for dx in -radius..=radius { - let (sx, sy) = (x as isize + dx, y as isize + dy); - if sx < 0 || sy < 0 || sx as usize >= w || sy as usize >= h || (dx == 0 && dy == 0) { - continue; - } - let (sx, sy) = (sx as usize, sy as usize); - if color(sx, sy) == me && !is_bad[sy * w + sx] { - sum += f64::from(src[sy * w + sx]); - n += 1; - } - } - } - if n > 0 { - if let Some(v) = img.data.get_mut(i) { - *v = (sum / f64::from(n)) as f32; - } - break; - } - } - } - Ok(()) -} - -fn trim(r: &mut Reader, img: &mut Image) -> Result<()> { - let (t, l, b, rt) = (r.u32()? as usize, r.u32()? as usize, r.u32()? as usize, r.u32()? as usize); - if !img.allow_trim { - return Err(Error::Unsupported("TrimBounds before the demosaic".into())); - } - let (b, rt) = (b.min(img.height), rt.min(img.width)); - if t >= b || l >= rt { - return Err(Error::Malformed("TrimBounds outside the picture")); - } - let (np, w) = (img.planes, img.width); - let nw = rt - l; - let mut out = Vec::with_capacity(nw * (b - t) * np); - for y in t..b { - out.extend_from_slice(img.data.get((y * w + l) * np..(y * w + rt) * np).ok_or(Error::Malformed("TrimBounds"))?); - } - *img.data = out; - img.width = nw; - img.height = b - t; - img.origin = (img.origin.0 + l, img.origin.1 + t); - Ok(()) -} - -/// Catmull–Rom weights for a fractional position `t` in 0–1. -fn cubic(t: f64) -> [f64; 4] { - let (t2, t3) = (t * t, t * t * t); - [(-t3 + 2.0 * t2 - t) / 2.0, (3.0 * t3 - 5.0 * t2 + 2.0) / 2.0, (-3.0 * t3 + 4.0 * t2 + t) / 2.0, (t3 - t2) / 2.0] -} - -/// The radial model of a warp opcode for one plane. -enum Radial { - /// WarpRectilinear: f = kr0 + kr1 r² + kr2 r⁴ + kr3 r⁶, tangential kt0, kt1. - Rectilinear([f64; 4], [f64; 2]), - /// WarpFisheye: f = (kr0 θ + kr1 θ³ + kr2 θ⁵ + kr3 θ⁷) / r, θ = atan r. - Fisheye([f64; 4]), - /// WarpRectilinear2: f(r) = Σ kr_p r^p (p ≤ 14) at r clamped to the valid range, multiplied - /// (or divided, reciprocal) into r; tangential kt0, kt1. - Rectilinear2 { kr: [f64; 15], kt: [f64; 2], min: f64, max: f64, reciprocal: bool }, -} - -impl Radial { - /// Source offset (normalised) of destination offset (dx, dy). - fn map(&self, dx: f64, dy: f64) -> (f64, f64) { - let r2 = dx * dx + dy * dy; - let tangential = |kt: &[f64; 2]| (kt[0] * (2.0 * dx * dy) + kt[1] * (r2 + 2.0 * dx * dx), kt[1] * (2.0 * dx * dy) + kt[0] * (r2 + 2.0 * dy * dy)); - match self { - Radial::Rectilinear(kr, kt) => { - let f = kr[0] + r2 * (kr[1] + r2 * (kr[2] + r2 * kr[3])); - let (tx, ty) = tangential(kt); - (f * dx + tx, f * dy + ty) - } - Radial::Fisheye(kr) => { - let r = r2.sqrt(); - let f = if r < 1e-12 { - kr[0] - } else { - let t = r.atan(); - let t2 = t * t; - t * (kr[0] + t2 * (kr[1] + t2 * (kr[2] + t2 * kr[3]))) / r - }; - (f * dx, f * dy) - } - Radial::Rectilinear2 { kr, kt, min, max, reciprocal } => { - let r = r2.sqrt().clamp(*min, *max); - let f = kr.iter().rev().fold(0.0, |acc, k| acc * r + k); - let f = if *reciprocal { - if f.abs() < 1e-12 { - return (dx, dy); - } - 1.0 / f - } else { - f - }; - let (tx, ty) = tangential(kt); - (f * dx + tx, f * dy + ty) - } - } - } -} - -fn warp(id: u32, r: &mut Reader, img: &mut Image) -> Result<()> { - if img.mosaic { - return Err(Error::Unsupported("a warp opcode on a CFA mosaic".into())); - } - let per_set = match id { - 1 => 6, - 2 => 4, - _ => 19, - }; - let n = r.count(per_set * 8)?; - if n != 1 && n != img.planes { - return Err(Error::Malformed("warp opcode coefficient sets")); - } - let mut sets = Vec::with_capacity(n); - for _ in 0..n { - let v: Vec = (0..per_set).map(|_| r.f64()).collect::>()?; - sets.push(match id { - 1 => Radial::Rectilinear([v[0], v[1], v[2], v[3]], [v[4], v[5]]), - 2 => Radial::Fisheye([v[0], v[1], v[2], v[3]]), - _ => { - let mut kr = [0f64; 15]; - kr.copy_from_slice(&v[..15]); - let (min, max) = (v[17].clamp(0.0, 1.0), v[18].clamp(0.0, 1.0)); - if min >= max { - return Err(Error::Malformed("WarpRectilinear2 valid radius range")); - } - Radial::Rectilinear2 { kr, kt: [v[15], v[16]], min, max, reciprocal: false } - } - }); - } - let (cx, cy) = (r.f64()?, r.f64()?); - if id == 14 { - let reciprocal = r.u32()? != 0; - for s in &mut sets { - if let Radial::Rectilinear2 { reciprocal: rr, .. } = s { - *rr = reciprocal; - } - } - } - let (cx, cy, m) = centre(img, cx, cy); - if m <= 0.0 { - return Ok(()); - } - let (w, h, np) = (img.width, img.height, img.planes); - let src = img.data.clone(); - let sample = |p: usize, x: isize, y: isize| { - let (x, y) = (x.clamp(0, w as isize - 1) as usize, y.clamp(0, h as isize - 1) as usize); - f64::from(src.get((y * w + x) * np + p).copied().unwrap_or(0.0)) - }; - for (i, px) in img.data.chunks_exact_mut(np.max(1)).enumerate() { - let (x, y) = ((i % w) as f64, (i / w) as f64); - let (dx, dy) = ((x - cx) / m, (y - cy) / m); - for (p, v) in px.iter_mut().enumerate() { - let model = sets.get(p).or(sets.first()); - let Some(model) = model else { continue }; - let (ox, oy) = model.map(dx, dy); - let (sx, sy) = (cx + m * ox, cy + m * oy); - if !sx.is_finite() || !sy.is_finite() { - continue; - } - let (fx, fy) = (sx.floor(), sy.floor()); - let (wx, wy) = (cubic(sx - fx), cubic(sy - fy)); - let (ix, iy) = (fx.clamp(-4.0, w as f64 + 4.0) as isize, fy.clamp(-4.0, h as f64 + 4.0) as isize); - let mut acc = 0.0; - for (j, wyj) in wy.iter().enumerate() { - let mut row = 0.0; - for (k, wxk) in wx.iter().enumerate() { - row += wxk * sample(p, ix + k as isize - 1, iy + j as isize - 1); - } - acc += wyj * row; - } - *v = acc as f32; - } - } - Ok(()) -} - -#[cfg(any(test, feature = "writer"))] -/// Encode an opcode list (big-endian), for tests: (id, flags, parameters). -pub fn encode(list: &[(u32, u32, Vec)]) -> Vec { +/// Encode records as a big-endian opcode list, preserving version and parameter bytes. +pub fn encode(list: &[Opcode]) -> Vec { let mut out = (list.len() as u32).to_be_bytes().to_vec(); - for (id, flags, params) in list { - let version: u32 = if *id == 14 { 0x0106_0000 } else { 0x0103_0000 }; - for v in [*id, version, *flags, params.len() as u32] { - out.extend(v.to_be_bytes()); + for op in list { + for value in [op.id, op.version, op.flags, op.params.len() as u32] { + out.extend(value.to_be_bytes()); } - out.extend(params); + out.extend_from_slice(&op.params); } out } @@ -655,230 +69,13 @@ pub fn encode(list: &[(u32, u32, Vec)]) -> Vec { #[cfg(test)] mod tests { use super::*; - - fn u(v: &[u32]) -> Vec { - v.iter().flat_map(|x| x.to_be_bytes()).collect() - } - - fn d(v: &[f64]) -> Vec { - v.iter().flat_map(|x| x.to_be_bytes()).collect() - } - - fn f(v: &[f32]) -> Vec { - v.iter().flat_map(|x| x.to_be_bytes()).collect() - } - - fn area(t: u32, l: u32, b: u32, r: u32, plane: u32, planes: u32, rp: u32, cp: u32) -> Vec { - u(&[t, l, b, r, plane, planes, rp, cp]) - } - - /// Run one opcode on a float picture (range 0–1). - fn run1(id: u32, params: Vec, data: &mut Vec, w: usize, h: usize, planes: usize) -> Result<(usize, usize)> { - let list = parse(&encode(&[(id, 0, params)]))?; - let mut img = Image { data, width: w, height: h, planes, max: 1.0, mosaic: false, allow_trim: true, origin: (0, 0) }; - apply(&list, &mut img, false)?; - Ok((img.width, img.height)) - } - - fn close(a: f32, b: f32) -> bool { - (a - b).abs() < 1e-5 - } - #[test] - fn list_parsing_and_hostile_lists() { - let l = encode(&[(9, 1, vec![1, 2, 3]), (3, 2, vec![])]); - let p = parse(&l).unwrap(); - assert_eq!(p.len(), 2); - assert_eq!((p[0].id, p[0].version, p[0].params.as_slice()), (9, 0x0103_0000, &[1u8, 2, 3][..])); - assert!(p[0].optional() && !p[0].preview_skippable()); - assert!(!p[1].optional() && p[1].preview_skippable()); - // every truncation is an error, never a panic - for n in 0..l.len() { - assert!(parse(&l[..n]).is_err(), "{n}"); - } - // counts and sizes beyond the data - assert!(parse(&u(&[u32::MAX])).is_err()); - assert!(parse(&u(&[1, 9, 0, 0, u32::MAX])).is_err()); - assert!(parse(&u(&[(MAX_OPCODES + 1) as u32]).into_iter().chain(vec![0; 16 * (MAX_OPCODES + 1)]).collect::>()).is_err()); - assert_eq!(parse(&u(&[0])).unwrap(), vec![]); - } - - #[test] - fn unknown_and_newer_opcodes() { - let mut data = vec![0.5f32; 4]; - let mut img = Image { data: &mut data, width: 2, height: 2, planes: 1, max: 1.0, mosaic: false, allow_trim: false, origin: (0, 0) }; - // unknown id: skipped when optional, an error when not - assert!(apply(&parse(&encode(&[(99, 1, vec![])])).unwrap(), &mut img, false).is_ok()); - assert!(matches!(apply(&parse(&encode(&[(99, 0, vec![])])).unwrap(), &mut img, false), Err(Error::Unsupported(_)))); - // a known id from a newer DNG version is unknown - let newer = [Opcode { id: 3, version: 0x0108_0000, flags: 0, params: vec![] }]; - assert!(matches!(apply(&newer, &mut img, false), Err(Error::Unsupported(_)))); - // an opcode this stage cannot run: skipped when optional - let trim = Opcode { id: 6, version: 0x0103_0000, flags: 1, params: u(&[0, 0, 1, 1]) }; - assert!(apply(std::slice::from_ref(&trim), &mut img, false).is_ok()); - assert!(apply(&[Opcode { flags: 0, ..trim }], &mut img, false).is_err()); - // preview quality skips flagged opcodes - let scale = Opcode { id: 12, version: 0x0103_0000, flags: 2, params: [area(0, 0, 2, 2, 0, 1, 1, 1), u(&[2]), f(&[0.5, 0.5])].concat() }; - apply(std::slice::from_ref(&scale), &mut img, true).unwrap(); - assert_eq!(img.data[0], 0.5); - apply(&[scale], &mut img, false).unwrap(); - assert_eq!(img.data[0], 0.25); - // malformed parameters are errors - assert!(apply(&[Opcode { id: 10, version: 0x0103_0000, flags: 0, params: vec![0; 5] }], &mut img, false).is_err()); - } - - #[test] - fn map_table_polynomial_delta_and_scale() { - // 4 × 2, two planes; affect plane 1 only, every second column - let mut data: Vec = (0..16).map(|i| i as f32 / 20.0).collect(); - let orig = data.clone(); - // MapTable: 16-bit identity reversed (v → 1 − v) - let table: Vec = (0..=65_535u32).rev().flat_map(|v| (v as u16).to_be_bytes()).collect(); - run1(7, [area(0, 0, 2, 4, 1, 1, 1, 2), u(&[65_536]), table].concat(), &mut data, 4, 2, 2).unwrap(); - for (i, (a, b)) in data.iter().zip(&orig).enumerate() { - let (x, p) = ((i / 2) % 4, i % 2); - let want = if p == 1 && x % 2 == 0 { 1.0 - (b * 65_535.0).round() / 65_535.0 } else { *b }; - assert!(close(*a, want), "{i}: {a} {want}"); - } - // MapPolynomial 0.1 + 0.5 x on everything - let mut data = orig.clone(); - run1(8, [area(0, 0, 2, 4, 0, 2, 1, 1), u(&[1]), d(&[0.1, 0.5])].concat(), &mut data, 4, 2, 2).unwrap(); - for (a, b) in data.iter().zip(&orig) { - assert!(close(*a, 0.1 + 0.5 * b)); - } - // DeltaPerRow (rows 0, 1), ScalePerColumn (columns 1..3) - let mut data = orig.clone(); - run1(10, [area(0, 0, 2, 4, 0, 2, 1, 1), u(&[2]), f(&[0.01, -0.02])].concat(), &mut data, 4, 2, 2).unwrap(); - for (i, (a, b)) in data.iter().zip(&orig).enumerate() { - let want = (b + if i < 8 { 0.01 } else { -0.02 }).clamp(0.0, 1.0); - assert!(close(*a, want), "{i}"); - } - let mut data = orig.clone(); - run1(13, [area(0, 1, 2, 3, 0, 2, 1, 1), u(&[2]), f(&[2.0, 0.5])].concat(), &mut data, 4, 2, 2).unwrap(); - for (i, (a, b)) in data.iter().zip(&orig).enumerate() { - let x = (i / 2) % 4; - let want = match x { - 1 => (b * 2.0).min(1.0), - 2 => b * 0.5, - _ => *b, - }; - assert!(close(*a, want), "{i}"); - } - // too few deltas for the rows is an error - let mut data = orig.clone(); - assert!(run1(10, [area(0, 0, 2, 4, 0, 2, 1, 1), u(&[1]), f(&[0.1])].concat(), &mut data, 4, 2, 2).is_err()); - // zero pitch is an error, areas outside the picture are clamped - assert!(run1(12, [area(0, 0, 2, 4, 0, 1, 0, 1), u(&[0])].concat(), &mut data, 4, 2, 2).is_err()); - let mut data = orig.clone(); - run1(12, [area(1, 3, 99, 99, 5, 9, 1, 1), u(&[1]), f(&[0.0])].concat(), &mut data, 4, 2, 2).unwrap(); - assert_eq!(data, orig, "plane 5 does not exist"); - } - - #[test] - fn gain_map_interpolates_and_replicates() { - // 2 × 2 map at the corners of the picture's relative coordinates 0 and 0.5 - let (w, h) = (8, 8); - let mut data = vec![0.25f32; w * h]; - let gains = f(&[1.0, 2.0, 3.0, 4.0]); - run1(9, [area(0, 0, 8, 8, 0, 1, 1, 1), u(&[2, 2]), d(&[0.5, 0.5, 0.0, 0.0]), u(&[1]), gains].concat(), &mut data, w, h, 1).unwrap(); - let g = |x: usize, y: usize| data[y * w + x] / 0.25; - assert!(close(g(0, 0), 1.0)); - assert!(close(g(4, 0), 2.0), "{}", g(4, 0)); - assert!(close(g(0, 4), 3.0)); - assert!(close(g(2, 2), 2.5), "bilinear in the middle: {}", g(2, 2)); - assert!(close(g(7, 7), 4.0), "replicated past the map"); - // a map larger than its parameters is an error - let mut data = vec![0.25f32; 4]; - assert!(run1(9, [area(0, 0, 2, 2, 0, 1, 1, 1), u(&[1000, 1000]), d(&[0.1, 0.1, 0.0, 0.0]), u(&[1]), f(&[1.0])].concat(), &mut data, 2, 2, 1).is_err()); - } - - #[test] - fn vignette_and_warps() { - // FixVignetteRadial k0 = 1: g = 1 + r², the centre unchanged, the corners doubled - let (w, h) = (5, 5); - let mut data = vec![0.25f32; w * h]; - run1(3, d(&[1.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5]), &mut data, w, h, 1).unwrap(); - assert!(close(data[2 * w + 2], 0.25)); - assert!(close(data[0], 0.5) && close(data[w * h - 1], 0.5)); - assert!(close(data[2 * w], 0.25 * 1.5), "r² = 0.5 at the edge middle: {}", data[2 * w]); - // identity warps leave the picture alone; kr0 = 0.5 magnifies a ramp about the centre - let (w, h) = (9, 7); - let ramp: Vec = (0..w * h).flat_map(|i| [(i % w) as f32 / 10.0, (i / w) as f32 / 10.0]).collect(); - let mut data = ramp.clone(); - run1(1, [u(&[1]), d(&[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); - assert!(data.iter().zip(&ramp).all(|(a, b)| close(*a, *b))); - let mut data = ramp.clone(); - run1(1, [u(&[1]), d(&[0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); - // x' = 4 + 0.5 (x − 4): the cubic reproduces a linear ramp exactly - for x in 1..w - 1 { - let want = (4.0 + 0.5 * (x as f32 - 4.0)) / 10.0; - assert!(close(data[(3 * w + x) * 2], want), "x {x}: {} vs {want}", data[(3 * w + x) * 2]); - } - // one coefficient set per plane: plane 1 untouched - let mut data = ramp.clone(); - run1(1, [u(&[2]), d(&[0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); - assert!(data.iter().skip(1).step_by(2).zip(ramp.iter().skip(1).step_by(2)).all(|(a, b)| close(*a, *b))); - // three sets for two planes is malformed - let mut data = ramp.clone(); - assert!(run1(1, [u(&[3]), vec![0; 3 * 48 + 16]].concat(), &mut data, w, h, 2).is_err()); - // WarpFisheye kr0 = 1: f = atan(r) / r pulls sources towards the centre - let mut data = ramp.clone(); - run1(2, [u(&[1]), d(&[1.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat(), &mut data, w, h, 2).unwrap(); - let m = (16.0f64 + 9.0).sqrt(); - let dx = 3.0 / m; - let want = (4.0 + m * dx.atan()) / 10.0; - assert!((f64::from(data[(3 * w + 7) * 2]) - want).abs() < 1e-3, "{} vs {want}", data[(3 * w + 7) * 2]); - // WarpRectilinear2 identity (kr0 = 1), and the skip rule for a following warp - let wr2 = |flags| (14, flags, [u(&[1]), d(&[1.0]), d(&[0.0; 14]), d(&[0.0, 0.0, 0.0, 1.0, 0.5, 0.5]), u(&[0])].concat()); - let halve = (1, 0, [u(&[1]), d(&[0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5])].concat()); - for (flags, skipped) in [(1, true), (0, false)] { - let list = parse(&encode(&[wr2(flags), halve.clone()])).unwrap(); - let mut data = ramp.clone(); - let mut img = Image { data: &mut data, width: w, height: h, planes: 2, max: 1.0, mosaic: false, allow_trim: false, origin: (0, 0) }; - apply(&list, &mut img, false).unwrap(); - let unchanged = data.iter().zip(&ramp).all(|(a, b)| close(*a, *b)); - assert_eq!(unchanged, skipped, "optional WarpRectilinear2 {flags}"); - } - // warps are refused on a mosaic - let mut data = vec![0.5f32; 16]; - let mut img = Image { data: &mut data, width: 4, height: 4, planes: 1, max: 1.0, mosaic: true, allow_trim: false, origin: (0, 0) }; - assert!(apply(&parse(&encode(&[halve])).unwrap(), &mut img, false).is_err()); - } - - #[test] - fn bad_pixels_and_trim() { - // RGGB 6 × 6 with each colour flat; two bad pixels and a bad 2 × 2 rectangle - let (w, h) = (6, 6); - let level = [0.2f32, 0.5, 0.5, 0.8]; - let flat: Vec = (0..w * h).map(|i| level[(i / w % 2) * 2 + i % 2]).collect(); - let mut data = flat.clone(); - data[2 * w + 2] = 0.0; - data[3 * w + 4] = 0.0; - // FixBadPixelsConstant 0, phase 0 (red top left), integer stage - let mut ints: Vec = data.iter().map(|v| (v * 65_535.0).round()).collect(); - let list = parse(&encode(&[(4, 0, u(&[0, 0]))])).unwrap(); - let mut img = Image { data: &mut ints, width: w, height: h, planes: 1, max: 65_535.0, mosaic: true, allow_trim: false, origin: (0, 0) }; - apply(&list, &mut img, false).unwrap(); - for (a, b) in ints.iter().zip(&flat) { - assert_eq!(*a, (b * 65_535.0).round()); - } - // FixBadPixelsList: a point and a rectangle - let mut data = flat.clone(); - for i in [w + 1, 4 * w + 3, 4 * w + 4, 5 * w + 3, 5 * w + 4] { - data[i] = 0.9; - } - run1(5, u(&[0, 1, 1, 1, 1, 4, 3, 6, 5]), &mut data, w, h, 1).unwrap(); - assert!(data.iter().zip(&flat).all(|(a, b)| close(*a, *b)), "{data:?}"); - // a bad phase is malformed; huge lists are refused before allocating - let mut data = flat.clone(); - assert!(run1(5, u(&[7, 1, 0, 1, 1]), &mut data, w, h, 1).is_err()); - assert!(run1(5, u(&[0, u32::MAX, u32::MAX]), &mut data, w, h, 1).is_err()); - // TrimBounds - let mut data: Vec = (0..w * h * 3).map(|i| i as f32 / 200.0).collect(); - let (tw, th) = run1(6, u(&[1, 2, 4, 5]), &mut data, w, h, 3).unwrap(); - assert_eq!((tw, th, data.len()), (3, 3, 27)); - assert!(close(data[0], ((w + 2) * 3) as f32 / 200.0)); - let mut data = vec![0f32; 4]; - assert!(run1(6, u(&[1, 1, 1, 2]), &mut data, 2, 2, 1).is_err()); + fn unknown_records_round_trip_and_limits_are_enforced() { + let records = vec![Opcode { id: 900, version: 0x0107_0100, flags: 3, params: vec![1, 2, 3] }]; + let bytes = encode(&records); + assert_eq!(parse(&bytes, 1).unwrap(), records); + assert!(parse(&bytes, 0).is_err()); + assert!(parse(&bytes[..bytes.len() - 1], 1).is_err()); + assert!(records[0].optional() && records[0].preview_skippable()); } } From cbc61723758bc4e9928250ff02755cb6ccc2962b Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 19:44:12 -0500 Subject: [PATCH 3/5] raw: reject unrepresentable opcode envelope lengths before encoding --- crates/raw/src/opcode_raw.rs | 48 +++++++++++++++++++++++++++++++----- 1 file changed, 42 insertions(+), 6 deletions(-) diff --git a/crates/raw/src/opcode_raw.rs b/crates/raw/src/opcode_raw.rs index 05b4c31ce..46a86dc92 100644 --- a/crates/raw/src/opcode_raw.rs +++ b/crates/raw/src/opcode_raw.rs @@ -54,25 +54,61 @@ pub fn parse(bytes: &[u8], max_opcodes: usize) -> Result, Malformed> Ok(out) } -/// Encode records as a big-endian opcode list, preserving version and parameter bytes. -pub fn encode(list: &[Opcode]) -> Vec { - let mut out = (list.len() as u32).to_be_bytes().to_vec(); +/// An opcode list cannot be represented in the DNG wire format or allocated. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct EncodeError; + +fn wire_length(length: usize) -> Result { + u32::try_from(length).map_err(|_| EncodeError) +} + +/// Encode records, rejecting unrepresentable counts and parameter lengths before allocation. +pub fn try_encode(list: &[Opcode]) -> Result, EncodeError> { + let count = wire_length(list.len())?; + let mut total = 4usize; for op in list { - for value in [op.id, op.version, op.flags, op.params.len() as u32] { + wire_length(op.params.len())?; + total = total.checked_add(16).and_then(|n| n.checked_add(op.params.len())).ok_or(EncodeError)?; + } + let mut out = Vec::new(); + out.try_reserve_exact(total).map_err(|_| EncodeError)?; + out.extend_from_slice(&count.to_be_bytes()); + for op in list { + for value in [op.id, op.version, op.flags, wire_length(op.params.len())?] { out.extend(value.to_be_bytes()); } out.extend_from_slice(&op.params); } - out + Ok(out) +} + +/// Encode records as a big-endian opcode list, preserving version and parameter bytes. +/// +/// # Panics +/// Panics if a count or parameter length exceeds the wire format or allocation fails. +/// Use [`try_encode`] when encoding untrusted or potentially large records. +pub fn encode(list: &[Opcode]) -> Vec { + try_encode(list).expect("DNG opcode list must fit its wire format and available memory") } #[cfg(test)] mod tests { use super::*; + #[test] + fn wire_lengths_are_checked_without_large_allocations() { + assert_eq!(wire_length(0), Ok(0)); + assert_eq!(wire_length(u32::MAX as usize), Ok(u32::MAX)); + if let Some(too_large) = (u32::MAX as usize).checked_add(1) { + assert_eq!(wire_length(too_large), Err(EncodeError)); + } + assert_eq!(try_encode(&[]).unwrap(), vec![0, 0, 0, 0]); + } + #[test] fn unknown_records_round_trip_and_limits_are_enforced() { let records = vec![Opcode { id: 900, version: 0x0107_0100, flags: 3, params: vec![1, 2, 3] }]; - let bytes = encode(&records); + let bytes = try_encode(&records).unwrap(); + assert_eq!(encode(&records), bytes); assert_eq!(parse(&bytes, 1).unwrap(), records); assert!(parse(&bytes, 0).is_err()); assert!(parse(&bytes[..bytes.len() - 1], 1).is_err()); From 2d271b95bd37476e9a1f8b0d388c533820843643 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 19:45:27 -0500 Subject: [PATCH 4/5] raw: expose opcode encoding as a fallible API without panics --- crates/raw/src/opcode_raw.rs | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/crates/raw/src/opcode_raw.rs b/crates/raw/src/opcode_raw.rs index 46a86dc92..ebb834344 100644 --- a/crates/raw/src/opcode_raw.rs +++ b/crates/raw/src/opcode_raw.rs @@ -63,7 +63,7 @@ fn wire_length(length: usize) -> Result { } /// Encode records, rejecting unrepresentable counts and parameter lengths before allocation. -pub fn try_encode(list: &[Opcode]) -> Result, EncodeError> { +pub fn encode(list: &[Opcode]) -> Result, EncodeError> { let count = wire_length(list.len())?; let mut total = 4usize; for op in list { @@ -82,15 +82,6 @@ pub fn try_encode(list: &[Opcode]) -> Result, EncodeError> { Ok(out) } -/// Encode records as a big-endian opcode list, preserving version and parameter bytes. -/// -/// # Panics -/// Panics if a count or parameter length exceeds the wire format or allocation fails. -/// Use [`try_encode`] when encoding untrusted or potentially large records. -pub fn encode(list: &[Opcode]) -> Vec { - try_encode(list).expect("DNG opcode list must fit its wire format and available memory") -} - #[cfg(test)] mod tests { use super::*; @@ -101,14 +92,13 @@ mod tests { if let Some(too_large) = (u32::MAX as usize).checked_add(1) { assert_eq!(wire_length(too_large), Err(EncodeError)); } - assert_eq!(try_encode(&[]).unwrap(), vec![0, 0, 0, 0]); + assert_eq!(encode(&[]).unwrap(), vec![0, 0, 0, 0]); } #[test] fn unknown_records_round_trip_and_limits_are_enforced() { let records = vec![Opcode { id: 900, version: 0x0107_0100, flags: 3, params: vec![1, 2, 3] }]; - let bytes = try_encode(&records).unwrap(); - assert_eq!(encode(&records), bytes); + let bytes = encode(&records).unwrap(); assert_eq!(parse(&bytes, 1).unwrap(), records); assert!(parse(&bytes, 0).is_err()); assert!(parse(&bytes[..bytes.len() - 1], 1).is_err()); From 89e96d2790375e04bfe166d922b9fe60aaed58bf Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 08:32:10 +0100 Subject: [PATCH 5/5] raw: opcodes::parse_list/write_list use the opcode_raw envelope walker and encoder One opcode-list envelope implementation: opcode_raw::Records walks the records (stopping at a truncated one) for both the strict opcode_raw::parse and the typed opcodes::parse_list, and opcodes::write_list encodes through opcode_raw::encode instead of truncating lengths with as. --- crates/raw/src/opcode_raw.rs | 79 +++++++++++++++++++++++++++--------- crates/raw/src/opcodes.rs | 36 ++++++++-------- 2 files changed, 75 insertions(+), 40 deletions(-) diff --git a/crates/raw/src/opcode_raw.rs b/crates/raw/src/opcode_raw.rs index ebb834344..5b04ca895 100644 --- a/crates/raw/src/opcode_raw.rs +++ b/crates/raw/src/opcode_raw.rs @@ -27,31 +27,54 @@ impl Opcode { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Malformed; +/// The records of a big-endian opcode list in order, as `(id, version, flags, params)`, ending at +/// the declared count or at the first truncated record. The envelope walk shared by [`parse`] and +/// the typed [`crate::opcodes::parse_list`]. +pub(crate) struct Records<'a> { + bytes: &'a [u8], + at: usize, + /// Records the list header still promises. + pub(crate) left: u32, +} + +impl<'a> Records<'a> { + /// The record walker of a list; `None` when even the count is missing. + pub(crate) fn new(bytes: &'a [u8]) -> Option { + let left = u32::from_be_bytes(bytes.get(..4)?.try_into().ok()?); + Some(Self { bytes, at: 4, left }) + } + fn u32(&mut self) -> Option { + let end = self.at.checked_add(4)?; + let value = u32::from_be_bytes(self.bytes.get(self.at..end)?.try_into().ok()?); + self.at = end; + Some(value) + } +} + +impl<'a> Iterator for Records<'a> { + type Item = (u32, u32, u32, &'a [u8]); + fn next(&mut self) -> Option { + if self.left == 0 { + return None; + } + let (id, version, flags, len) = (self.u32()?, self.u32()?, self.u32()?, self.u32()? as usize); + let end = self.at.checked_add(len)?; + let params = self.bytes.get(self.at..end)?; + self.at = end; + self.left -= 1; + Some((id, version, flags, params)) + } +} + /// Parse a big-endian opcode list with an explicit maximum record count. pub fn parse(bytes: &[u8], max_opcodes: usize) -> Result, Malformed> { - let mut at = 0usize; - let read = |at: &mut usize| -> Result { - let end = at.checked_add(4).ok_or(Malformed)?; - let value = bytes.get(*at..end).and_then(|b| b.try_into().ok()).map(u32::from_be_bytes).ok_or(Malformed)?; - *at = end; - Ok(value) - }; - let count = read(&mut at)? as usize; + let records = Records::new(bytes).ok_or(Malformed)?; + let count = records.left as usize; if count > bytes.len() / 16 || count > max_opcodes { return Err(Malformed); } - let mut out = Vec::with_capacity(count); - for _ in 0..count { - let id = read(&mut at)?; - let version = read(&mut at)?; - let flags = read(&mut at)?; - let len = read(&mut at)? as usize; - let end = at.checked_add(len).ok_or(Malformed)?; - let params = bytes.get(at..end).ok_or(Malformed)?.to_vec(); - at = end; - out.push(Opcode { id, version, flags, params }); - } - Ok(out) + let out: Vec = records.map(|(id, version, flags, params)| Opcode { id, version, flags, params: params.to_vec() }).collect(); + if out.len() == count { Ok(out) } else { Err(Malformed) } } /// An opcode list cannot be represented in the DNG wire format or allocated. @@ -104,4 +127,20 @@ mod tests { assert!(parse(&bytes[..bytes.len() - 1], 1).is_err()); assert!(records[0].optional() && records[0].preview_skippable()); } + + #[test] + fn typed_lists_share_the_envelope() { + use crate::opcodes::{self, Opcode as Typed}; + let typed = vec![Typed::TrimBounds { top: 1, left: 2, bottom: 3, right: 4 }, Typed::Unknown { id: 900, flags: 1, params: vec![5, 6] }]; + let bytes = opcodes::write_list(&typed); + let raw = parse(&bytes, 8).unwrap(); + assert_eq!(raw.iter().map(|o| (o.id, o.version)).collect::>(), [(6, 0x0103_0000), (900, 0x0103_0000)]); + assert_eq!(encode(&raw).unwrap(), bytes); + assert_eq!(opcodes::parse_list(&bytes), typed); + // a truncated last record: the typed reader keeps what came before, the raw one refuses + assert_eq!(opcodes::parse_list(&bytes[..bytes.len() - 1]), typed[..1]); + assert!(parse(&bytes[..bytes.len() - 1], 8).is_err()); + assert!(opcodes::parse_list(&[0, 0]).is_empty()); + assert!(parse(&[0, 0], 8).is_err()); + } } diff --git a/crates/raw/src/opcodes.rs b/crates/raw/src/opcodes.rs index 2143adcf1..f585dfd51 100644 --- a/crates/raw/src/opcodes.rs +++ b/crates/raw/src/opcodes.rs @@ -480,31 +480,27 @@ fn params(op: &Opcode) -> (u32, u32, Vec) { (id, 0, o) } -/// Serialise an opcode list (inverse of [`parse_list`]). +/// Serialise an opcode list (inverse of [`parse_list`]) through the shared envelope encoder +/// ([`crate::opcode_raw::encode`]). A list the wire format cannot hold (a count or parameter block +/// past 4 GiB) yields an empty blob rather than a truncated one. pub fn write_list(list: &[Opcode]) -> Vec { - let mut out = (list.len() as u32).to_be_bytes().to_vec(); - for op in list { - let (id, flags, p) = params(op); - for v in [id, if id == 14 { 0x0106_0000 } else { 0x0103_0000 }, flags, p.len() as u32] { - out.extend_from_slice(&v.to_be_bytes()); - } - out.extend_from_slice(&p); - } - out + let records: Vec = list + .iter() + .map(|op| { + let (id, flags, params) = params(op); + crate::opcode_raw::Opcode { id, version: if id == 14 { 0x0106_0000 } else { 0x0103_0000 }, flags, params } + }) + .collect(); + crate::opcode_raw::encode(&records).unwrap_or_default() } /// Parse an opcode list blob. Malformed opcodes become [`Opcode::Unknown`]; a truncated list stops early. pub fn parse_list(d: &[u8]) -> Vec { - let mut r = Rd { d, p: 0 }; - let Some(count) = r.u32() else { return vec![] }; - let mut out = Vec::new(); - for _ in 0..count.min(4096) { - let (Some(id), Some(_ver), Some(flags), Some(size)) = (r.u32(), r.u32(), r.u32(), r.u32()) else { break }; - let Some(params) = d.get(r.p..r.p.saturating_add(size as usize)) else { break }; - r.p += size as usize; - out.push(parse_one(id, flags, params).unwrap_or(Opcode::Unknown { id, flags, params: params.to_vec() })); - } - out + let Some(records) = crate::opcode_raw::Records::new(d) else { return vec![] }; + records + .take(4096) + .map(|(id, _version, flags, params)| parse_one(id, flags, params).unwrap_or(Opcode::Unknown { id, flags, params: params.to_vec() })) + .collect() } /// Radius normaliser: distance from the centre to the farthest image corner.