mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 23:42:27 +00:00
Merge pull request #1653 from storytold/codex/dng-opcode-interpreter
Parse DNG opcode parameters into typed values
This commit is contained in:
2 files changed
+419
No files matched your search
@@ -122,6 +122,7 @@ mod nef;
|
||||
mod nef_lens;
|
||||
#[cfg(feature = "nef")]
|
||||
mod nefc;
|
||||
pub mod opcode_params;
|
||||
/// Bounded raw DNG opcode-list envelopes.
|
||||
pub mod opcode_raw;
|
||||
pub mod opcodes;
|
||||
|
||||
@@ -0,0 +1,418 @@
|
||||
//! Context-aware parsing of DNG opcode parameters. Image processing remains the caller's job.
|
||||
//!
|
||||
//! The typed [`crate::opcodes`] model is the file's own view (owned, serialisable, lenient: a
|
||||
//! malformed opcode becomes `Unknown`, a zero pitch reads as 1, coordinates stay as written). This
|
||||
//! module answers a different question for a caller about to apply an opcode to a given image:
|
||||
//! parameters borrowed from the record (bad-pixel lists are not copied), checked strictly (a zero
|
||||
//! pitch, a count larger than its bytes or a warp on a mosaic is an error) and areas clamped to the
|
||||
//! image. The record envelope comes from [`crate::opcode_raw`]; the rectangle on the wire is
|
||||
//! [`crate::opcodes::Area`], which [`Area::clamp`] turns into image coordinates.
|
||||
|
||||
/// Image properties used to validate and clamp opcode parameters.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct Context {
|
||||
pub width: usize,
|
||||
pub height: usize,
|
||||
pub planes: usize,
|
||||
pub mosaic: bool,
|
||||
pub allow_trim: bool,
|
||||
}
|
||||
/// A parameter failure, retaining the diagnostic used by the caller.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum ParseError {
|
||||
Malformed(&'static str),
|
||||
Unsupported(&'static str),
|
||||
}
|
||||
/// A clamped image area and its sample pitches.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct Area {
|
||||
pub top: usize,
|
||||
pub left: usize,
|
||||
pub bottom: usize,
|
||||
pub right: usize,
|
||||
pub plane: usize,
|
||||
pub planes: usize,
|
||||
pub row_pitch: usize,
|
||||
pub col_pitch: usize,
|
||||
}
|
||||
impl Area {
|
||||
/// Iterate sampled rows, rejecting a zero pitch even for caller-constructed areas.
|
||||
pub fn rows(&self) -> Result<impl Iterator<Item = usize> + use<>, ParseError> {
|
||||
if self.row_pitch == 0 {
|
||||
return Err(ParseError::Malformed("opcode area with a zero pitch"));
|
||||
}
|
||||
Ok((self.top..self.bottom.max(self.top)).step_by(self.row_pitch))
|
||||
}
|
||||
/// Iterate sampled columns, rejecting a zero pitch even for caller-constructed areas.
|
||||
pub fn cols(&self) -> Result<impl Iterator<Item = usize> + use<>, ParseError> {
|
||||
if self.col_pitch == 0 {
|
||||
return Err(ParseError::Malformed("opcode area with a zero pitch"));
|
||||
}
|
||||
Ok((self.left..self.right.max(self.left)).step_by(self.col_pitch))
|
||||
}
|
||||
}
|
||||
/// Borrowed bad-pixel coordinates, decoded lazily without copying the payload.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct PointRecords<'a>(&'a [u8]);
|
||||
impl PointRecords<'_> {
|
||||
pub fn iter(&self) -> impl Iterator<Item = (u32, u32)> + '_ {
|
||||
self.0.as_chunks::<8>().0.iter().map(|b| (u32::from_be_bytes([b[0], b[1], b[2], b[3]]), u32::from_be_bytes([b[4], b[5], b[6], b[7]])))
|
||||
}
|
||||
}
|
||||
/// Borrowed bad-pixel rectangles, decoded lazily without copying the payload.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct RectangleRecords<'a>(&'a [u8]);
|
||||
impl RectangleRecords<'_> {
|
||||
pub fn iter(&self) -> impl Iterator<Item = [u32; 4]> + '_ {
|
||||
self.0.as_chunks::<16>().0.iter().map(|b| {
|
||||
[
|
||||
u32::from_be_bytes([b[0], b[1], b[2], b[3]]),
|
||||
u32::from_be_bytes([b[4], b[5], b[6], b[7]]),
|
||||
u32::from_be_bytes([b[8], b[9], b[10], b[11]]),
|
||||
u32::from_be_bytes([b[12], b[13], b[14], b[15]]),
|
||||
]
|
||||
})
|
||||
}
|
||||
}
|
||||
/// Parameters for the fourteen defined opcodes.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Params<'a> {
|
||||
WarpRectilinear { planes: Vec<[f64; 6]>, center: [f64; 2] },
|
||||
WarpFisheye { planes: Vec<[f64; 4]>, center: [f64; 2] },
|
||||
FixVignetteRadial { k: [f64; 5], center: [f64; 2] },
|
||||
FixBadPixelsConstant { constant: u32, bayer_phase: u32 },
|
||||
FixBadPixelsList { bayer_phase: u32, points: PointRecords<'a>, rects: RectangleRecords<'a> },
|
||||
TrimBounds { top: usize, left: usize, bottom: usize, right: usize },
|
||||
MapTable { area: Area, table: Vec<u16> },
|
||||
MapPolynomial { area: Area, coefficients: Vec<f64> },
|
||||
GainMap { area: Area, points_v: usize, points_h: usize, spacing: [f64; 2], origin: [f64; 2], map_planes: usize, gains: Vec<f32> },
|
||||
DeltaPerRow { area: Area, deltas: Vec<f32> },
|
||||
DeltaPerColumn { area: Area, deltas: Vec<f32> },
|
||||
ScalePerRow { area: Area, scales: Vec<f32> },
|
||||
ScalePerColumn { area: Area, scales: Vec<f32> },
|
||||
WarpRectilinear2 { planes: Vec<[f64; 19]>, center: [f64; 2], reciprocal: bool },
|
||||
}
|
||||
struct Reader<'a> {
|
||||
bytes: &'a [u8],
|
||||
pos: usize,
|
||||
}
|
||||
impl<'a> Reader<'a> {
|
||||
fn take(&mut self, n: usize) -> Result<&'a [u8], ParseError> {
|
||||
let end = self.pos.checked_add(n).ok_or(ParseError::Malformed("opcode parameters"))?;
|
||||
let b = self.bytes.get(self.pos..end).ok_or(ParseError::Malformed("opcode parameters too short"))?;
|
||||
self.pos = end;
|
||||
Ok(b)
|
||||
}
|
||||
fn u32(&mut self) -> Result<u32, ParseError> {
|
||||
let b = self.take(4)?;
|
||||
Ok(u32::from_be_bytes([b[0], b[1], b[2], b[3]]))
|
||||
}
|
||||
fn f32(&mut self) -> Result<f32, ParseError> {
|
||||
let v = f32::from_bits(self.u32()?);
|
||||
if v.is_finite() { Ok(v) } else { Err(ParseError::Malformed("non-finite opcode parameter")) }
|
||||
}
|
||||
fn f64(&mut self) -> Result<f64, ParseError> {
|
||||
let b = self.take(8)?;
|
||||
let v = f64::from_be_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]);
|
||||
if v.is_finite() { Ok(v) } else { Err(ParseError::Malformed("non-finite opcode parameter")) }
|
||||
}
|
||||
fn remaining(&self) -> usize {
|
||||
self.bytes.len().saturating_sub(self.pos)
|
||||
}
|
||||
fn count(&mut self, size: usize) -> Result<usize, ParseError> {
|
||||
let n = self.u32()? as usize;
|
||||
if n.saturating_mul(size) > self.remaining() { Err(ParseError::Malformed("opcode count larger than its parameters")) } else { Ok(n) }
|
||||
}
|
||||
fn array<const N: usize>(&mut self) -> Result<[f64; N], ParseError> {
|
||||
let mut a = [0.0; N];
|
||||
for x in &mut a {
|
||||
*x = self.f64()?;
|
||||
}
|
||||
Ok(a)
|
||||
}
|
||||
fn area(&mut self, c: Context) -> Result<Area, ParseError> {
|
||||
let wire = crate::opcodes::Area {
|
||||
top: self.u32()?,
|
||||
left: self.u32()?,
|
||||
bottom: self.u32()?,
|
||||
right: self.u32()?,
|
||||
plane: self.u32()?,
|
||||
planes: self.u32()?,
|
||||
row_pitch: self.u32()?,
|
||||
col_pitch: self.u32()?,
|
||||
};
|
||||
Area::clamp(wire, c)
|
||||
}
|
||||
}
|
||||
impl Area {
|
||||
/// The area of an opcode as written ([`crate::opcodes::Area`]) clamped to the image of `c`:
|
||||
/// coordinates to its size, the plane range to its planes. A zero pitch is an error here (the
|
||||
/// typed reader reads it as 1).
|
||||
pub fn clamp(wire: crate::opcodes::Area, c: Context) -> Result<Area, ParseError> {
|
||||
if wire.row_pitch == 0 || wire.col_pitch == 0 {
|
||||
return Err(ParseError::Malformed("opcode area with a zero pitch"));
|
||||
}
|
||||
let px = |v: u32| v as usize;
|
||||
let plane = px(wire.plane).min(c.planes);
|
||||
Ok(Area {
|
||||
top: px(wire.top).min(c.height),
|
||||
left: px(wire.left).min(c.width),
|
||||
bottom: px(wire.bottom).min(c.height),
|
||||
right: px(wire.right).min(c.width),
|
||||
plane,
|
||||
planes: px(wire.planes).min(c.planes - plane),
|
||||
row_pitch: px(wire.row_pitch),
|
||||
col_pitch: px(wire.col_pitch),
|
||||
})
|
||||
}
|
||||
}
|
||||
/// Parse a known opcode's parameters. Unknown identifiers return an unsupported error.
|
||||
pub fn parse(id: u32, bytes: &[u8], context: Context) -> Result<Params<'_>, ParseError> {
|
||||
let mut r = Reader { bytes, pos: 0 };
|
||||
match id {
|
||||
1 | 2 | 14 => {
|
||||
if context.mosaic {
|
||||
return Err(ParseError::Unsupported("a warp opcode on a CFA mosaic"));
|
||||
}
|
||||
let per = match id {
|
||||
1 => 6,
|
||||
2 => 4,
|
||||
_ => 19,
|
||||
};
|
||||
let n = r.count(per * 8)?;
|
||||
if n != 1 && n != context.planes {
|
||||
return Err(ParseError::Malformed("warp opcode coefficient sets"));
|
||||
}
|
||||
match id {
|
||||
1 => {
|
||||
let planes = (0..n).map(|_| r.array()).collect::<Result<_, _>>()?;
|
||||
let center = r.array()?;
|
||||
Ok(Params::WarpRectilinear { planes, center })
|
||||
}
|
||||
2 => {
|
||||
let planes = (0..n).map(|_| r.array()).collect::<Result<_, _>>()?;
|
||||
let center = r.array()?;
|
||||
Ok(Params::WarpFisheye { planes, center })
|
||||
}
|
||||
_ => {
|
||||
let mut planes = Vec::with_capacity(n);
|
||||
for _ in 0..n {
|
||||
let mut p: [f64; 19] = r.array()?;
|
||||
p[17] = p[17].clamp(0.0, 1.0);
|
||||
p[18] = p[18].clamp(0.0, 1.0);
|
||||
if p[17] >= p[18] {
|
||||
return Err(ParseError::Malformed("WarpRectilinear2 valid radius range"));
|
||||
}
|
||||
planes.push(p);
|
||||
}
|
||||
let center = r.array()?;
|
||||
let reciprocal = r.u32()? != 0;
|
||||
Ok(Params::WarpRectilinear2 { planes, center, reciprocal })
|
||||
}
|
||||
}
|
||||
}
|
||||
3 => Ok(Params::FixVignetteRadial { k: r.array()?, center: r.array()? }),
|
||||
4 => Ok(Params::FixBadPixelsConstant { constant: r.u32()?, bayer_phase: r.u32()? }),
|
||||
5 => {
|
||||
let bayer_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(ParseError::Malformed("FixBadPixelsList counts larger than its parameters"));
|
||||
}
|
||||
let points =
|
||||
PointRecords(r.take(points.checked_mul(8).ok_or(ParseError::Malformed("FixBadPixelsList counts larger than its parameters"))?)?);
|
||||
let rects =
|
||||
RectangleRecords(r.take(rects.checked_mul(16).ok_or(ParseError::Malformed("FixBadPixelsList counts larger than its parameters"))?)?);
|
||||
Ok(Params::FixBadPixelsList { bayer_phase, points, rects })
|
||||
}
|
||||
6 => {
|
||||
let top = r.u32()? as usize;
|
||||
let left = r.u32()? as usize;
|
||||
let bottom = r.u32()? as usize;
|
||||
let right = r.u32()? as usize;
|
||||
if !context.allow_trim {
|
||||
return Err(ParseError::Unsupported("TrimBounds before the demosaic"));
|
||||
}
|
||||
let bottom = bottom.min(context.height);
|
||||
let right = right.min(context.width);
|
||||
if top >= bottom || left >= right {
|
||||
return Err(ParseError::Malformed("TrimBounds outside the picture"));
|
||||
}
|
||||
Ok(Params::TrimBounds { top, left, bottom, right })
|
||||
}
|
||||
7..=13 => {
|
||||
let area = r.area(context)?;
|
||||
match id {
|
||||
7 => {
|
||||
let n = r.count(2)?;
|
||||
if n == 0 {
|
||||
return Err(ParseError::Malformed("MapTable without entries"));
|
||||
}
|
||||
let table = (0..n)
|
||||
.map(|_| {
|
||||
let b = r.take(2)?;
|
||||
Ok(u16::from_be_bytes([b[0], b[1]]))
|
||||
})
|
||||
.collect::<Result<_, ParseError>>()?;
|
||||
Ok(Params::MapTable { area, table })
|
||||
}
|
||||
8 => {
|
||||
let degree = r.u32()? as usize;
|
||||
if degree > 8 {
|
||||
return Err(ParseError::Malformed("MapPolynomial degree above 8"));
|
||||
}
|
||||
let coefficients = (0..=degree).map(|_| r.f64()).collect::<Result<_, _>>()?;
|
||||
Ok(Params::MapPolynomial { area, coefficients })
|
||||
}
|
||||
9 => {
|
||||
let points_v = r.u32()? as usize;
|
||||
let points_h = r.u32()? as usize;
|
||||
let spacing = r.array()?;
|
||||
let origin = r.array()?;
|
||||
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(ParseError::Malformed("GainMap size"));
|
||||
}
|
||||
if (points_v > 1 && spacing[0] <= 0.0) || (points_h > 1 && spacing[1] <= 0.0) {
|
||||
return Err(ParseError::Malformed("GainMap spacing"));
|
||||
}
|
||||
let gains = (0..n).map(|_| r.f32()).collect::<Result<_, _>>()?;
|
||||
Ok(Params::GainMap { area, points_v, points_h, spacing, origin, map_planes, gains })
|
||||
}
|
||||
_ => {
|
||||
let n = r.count(4)?;
|
||||
let vals = (0..n).map(|_| r.f32()).collect::<Result<Vec<_>, _>>()?;
|
||||
let need = if matches!(id, 10 | 12) {
|
||||
area.bottom.saturating_sub(area.top).div_ceil(area.row_pitch)
|
||||
} else {
|
||||
area.right.saturating_sub(area.left).div_ceil(area.col_pitch)
|
||||
};
|
||||
if vals.len() < need {
|
||||
return Err(ParseError::Malformed("opcode with fewer values than rows or columns"));
|
||||
}
|
||||
Ok(match id {
|
||||
10 => Params::DeltaPerRow { area, deltas: vals },
|
||||
11 => Params::DeltaPerColumn { area, deltas: vals },
|
||||
12 => Params::ScalePerRow { area, scales: vals },
|
||||
_ => Params::ScalePerColumn { area, scales: vals },
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => Err(ParseError::Unsupported("unknown DNG opcode")),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn u(v: &[u32]) -> Vec<u8> {
|
||||
v.iter().flat_map(|x| x.to_be_bytes()).collect()
|
||||
}
|
||||
fn d(v: &[f64]) -> Vec<u8> {
|
||||
v.iter().flat_map(|x| x.to_be_bytes()).collect()
|
||||
}
|
||||
fn f(v: &[f32]) -> Vec<u8> {
|
||||
v.iter().flat_map(|x| x.to_be_bytes()).collect()
|
||||
}
|
||||
fn ctx() -> Context {
|
||||
Context { width: 4, height: 3, planes: 2, mosaic: false, allow_trim: true }
|
||||
}
|
||||
#[test]
|
||||
fn caller_constructed_areas_reject_zero_pitch() -> Result<(), ParseError> {
|
||||
let mut area = Area { top: 1, left: 2, bottom: 7, right: 9, plane: 0, planes: 1, row_pitch: 2, col_pitch: 3 };
|
||||
assert_eq!(area.rows()?.collect::<Vec<_>>(), vec![1, 3, 5]);
|
||||
assert_eq!(area.cols()?.collect::<Vec<_>>(), vec![2, 5, 8]);
|
||||
area.row_pitch = 0;
|
||||
area.col_pitch = 0;
|
||||
assert!(area.rows().is_err());
|
||||
assert!(area.cols().is_err());
|
||||
// Empty/reversed bounds must not allow an invalid pitch through either.
|
||||
area.bottom = 0;
|
||||
area.right = 0;
|
||||
assert!(area.rows().is_err());
|
||||
assert!(area.cols().is_err());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_all_variants_and_clamps_areas() -> Result<(), ParseError> {
|
||||
let area = u(&[0, 1, 8, 9, 1, 5, 1, 2]);
|
||||
let cases = vec![
|
||||
(1, [u(&[1]), d(&[1., 0., 0., 0., 0., 0., 0.5, 0.5])].concat()),
|
||||
(2, [u(&[1]), d(&[1., 0., 0., 0., 0.5, 0.5])].concat()),
|
||||
(3, d(&[0., 0., 0., 0., 0., 0.5, 0.5])),
|
||||
(4, u(&[0, 0])),
|
||||
(5, u(&[0, 1, 1, 1, 2, 0, 0, 1, 1])),
|
||||
(6, u(&[0, 1, 8, 9])),
|
||||
(7, [area.clone(), u(&[1]), vec![0, 1]].concat()),
|
||||
(8, [area.clone(), u(&[0]), d(&[1.])].concat()),
|
||||
(9, [area.clone(), u(&[1, 1]), d(&[0., 0., 0., 0.]), u(&[1]), f(&[1.])].concat()),
|
||||
(10, [area.clone(), u(&[3]), f(&[1., 2., 3.])].concat()),
|
||||
(11, [area.clone(), u(&[2]), f(&[1., 2.])].concat()),
|
||||
(12, [area.clone(), u(&[3]), f(&[1., 2., 3.])].concat()),
|
||||
(13, [area.clone(), u(&[2]), f(&[1., 2.])].concat()),
|
||||
(14, [u(&[1]), d(&[0.; 17]), d(&[-1., 2., 0.5, 0.5]), u(&[1])].concat()),
|
||||
];
|
||||
for (id, bytes) in cases {
|
||||
let p = parse(id, &bytes, ctx())?;
|
||||
assert!(matches!(
|
||||
(id, p),
|
||||
(1, Params::WarpRectilinear { .. })
|
||||
| (2, Params::WarpFisheye { .. })
|
||||
| (3, Params::FixVignetteRadial { .. })
|
||||
| (4, Params::FixBadPixelsConstant { .. })
|
||||
| (5, Params::FixBadPixelsList { .. })
|
||||
| (6, Params::TrimBounds { .. })
|
||||
| (7, Params::MapTable { .. })
|
||||
| (8, Params::MapPolynomial { .. })
|
||||
| (9, Params::GainMap { .. })
|
||||
| (10, Params::DeltaPerRow { .. })
|
||||
| (11, Params::DeltaPerColumn { .. })
|
||||
| (12, Params::ScalePerRow { .. })
|
||||
| (13, Params::ScalePerColumn { .. })
|
||||
| (14, Params::WarpRectilinear2 { .. })
|
||||
));
|
||||
}
|
||||
assert!(matches!(
|
||||
parse(7, &[area, u(&[1]), vec![0, 1]].concat(), ctx()),
|
||||
Ok(Params::MapTable { area: Area { bottom: 3, right: 4, plane: 1, planes: 1, .. }, .. })
|
||||
));
|
||||
Ok(())
|
||||
}
|
||||
#[test]
|
||||
fn validates_in_application_order() {
|
||||
assert_eq!(parse(1, &[], Context { mosaic: true, ..ctx() }), Err(ParseError::Unsupported("a warp opcode on a CFA mosaic")));
|
||||
assert_eq!(parse(6, &[], Context { allow_trim: false, ..ctx() }), Err(ParseError::Malformed("opcode parameters too short")));
|
||||
assert_eq!(
|
||||
parse(6, &u(&[0, 0, 1, 1]), Context { allow_trim: false, ..ctx() }),
|
||||
Err(ParseError::Unsupported("TrimBounds before the demosaic"))
|
||||
);
|
||||
assert_eq!(parse(5, &u(&[0, u32::MAX, u32::MAX]), ctx()), Err(ParseError::Malformed("FixBadPixelsList counts larger than its parameters")));
|
||||
let a = u(&[0, 0, 3, 4, 0, 1, 1, 1]);
|
||||
assert_eq!(parse(10, &[a, u(&[1]), f(&[f32::NAN])].concat(), ctx()), Err(ParseError::Malformed("non-finite opcode parameter")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_areas_clamp_to_the_image() {
|
||||
let c = ctx();
|
||||
let wire = crate::opcodes::Area { top: 1, left: 2, bottom: 9_999, right: 9_999, plane: 9, planes: 9, row_pitch: 2, col_pitch: 1 };
|
||||
let a = Area::clamp(wire, c).unwrap();
|
||||
assert_eq!((a.bottom, a.right), (c.height, c.width));
|
||||
assert_eq!((a.plane, a.planes), (c.planes, 0));
|
||||
assert!(Area::clamp(crate::opcodes::Area { row_pitch: 0, ..wire }, c).is_err());
|
||||
// the typed reader and this one agree on a well-formed area
|
||||
let typed = crate::opcodes::Opcode::MapTable { area: crate::opcodes::Area { col_pitch: 1, ..wire }, table: vec![1, 2] };
|
||||
let bytes = crate::opcodes::write_list(&[typed]);
|
||||
let record = &crate::opcode_raw::parse(&bytes, 1).unwrap()[0];
|
||||
match parse(record.id, &record.params, c).unwrap() {
|
||||
Params::MapTable { area, table } => {
|
||||
assert_eq!(area, a);
|
||||
assert_eq!(table, [1, 2]);
|
||||
}
|
||||
other => panic!("MapTable expected, got {other:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user