Merge pull request #1647 from storytold/codex/dng-metadata

Share bounded DNG processing and camera metadata
This commit is contained in:
FredApps
2026-11-16 11:56:50 +01:00
committed by GitHub
5 changed files with 336 additions and 1 deletions
+211
View File
@@ -0,0 +1,211 @@
//! Bounded DNG processing and camera metadata, before application rendering.
//!
//! This is the [`crate::dng_lines`] companion on the same `craft_tiff::classic` IFDs. The full
//! reader's `dng::color_data` works on `craft_tiff::Tiff` and returns the values it will render
//! with (raw IFD first, implausible or singular values dropped, `BaselineExposureOffset` added).
//! This reader returns the tags as written, IFD 0 first, and fails on a value outside the file,
//! so a damaged file does not silently lose its white balance. For a well-formed file both read the
//! same matrices and neutral (see `tests/it/dng_metadata.rs`).
use crate::dng_lines::{self, Error, PHOTOMETRIC_CFA, Result};
use craft_tiff::classic::{Entry, Ifd, Tiff, tags};
type M3 = [[f64; 3]; 3];
type V3 = [f64; 3];
/// Camera-plane colour filter pattern.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Pattern {
pub rows: usize,
pub cols: usize,
pub colors: Vec<u8>,
}
/// Parsed image processing tags.
#[derive(Clone, Debug, Default)]
pub struct Params {
pub active_area: Option<[usize; 4]>,
pub linearization: Option<Vec<u16>>,
pub black_repeat: (usize, usize),
pub black: Vec<f64>,
pub black_delta_h: Vec<f64>,
pub black_delta_v: Vec<f64>,
pub white: Vec<f64>,
pub crop_origin: Option<(f64, f64)>,
pub crop_size: Option<(f64, f64)>,
pub cfa: Option<Pattern>,
}
/// Parsed camera colour calibration.
#[derive(Clone, Debug, Default)]
pub struct Calibration {
pub color_matrix: [Option<M3>; 2],
pub camera_calibration: [Option<M3>; 2],
pub forward_matrix: [Option<M3>; 2],
pub illuminant: [Option<u64>; 2],
pub analog_balance: Option<V3>,
pub as_shot_neutral: Option<V3>,
pub as_shot_white_xy: Option<(f64, f64)>,
pub baseline_exposure: f64,
}
/// Metadata reader with the file's main and raw IFDs.
pub struct Metadata<'a, 'i> {
pub tiff: Tiff<'a>,
pub main: &'i Ifd,
pub raw: &'i Ifd,
}
impl Metadata<'_, '_> {
/// A raw-image tag: from the raw IFD, else IFD 0.
fn raw_tag(&self, tag: u16) -> Option<&Entry> {
self.raw.get(tag).or_else(|| self.main.get(tag))
}
/// A camera-wide tag: from IFD 0, else the raw IFD.
fn main_tag(&self, tag: u16) -> Option<&Entry> {
self.main.get(tag).or_else(|| self.raw.get(tag))
}
/// A numeric tag's values; a value outside the file (or a zero denominator) is an error, so a
/// damaged file does not silently lose its white balance.
fn floats(&self, e: Option<&Entry>) -> Result<Option<Vec<f64>>> {
Ok(e.map(|e| self.tiff.floats(e)).transpose()?)
}
/// A 3 × 3 matrix tag (`None` when absent or not 3 × 3, e.g. for other colour counts).
fn matrix(&self, tag: u16) -> Result<Option<M3>> {
let Some(v) = self.floats(self.main_tag(tag))? else { return Ok(None) };
let Ok(v) = <[f64; 9]>::try_from(v.as_slice()) else { return Ok(None) };
Ok(Some([[v[0], v[1], v[2]], [v[3], v[4], v[5]], [v[6], v[7], v[8]]]))
}
fn vec3(&self, tag: u16) -> Result<Option<V3>> {
Ok(self.floats(self.main_tag(tag))?.and_then(|v| <[f64; 3]>::try_from(v.as_slice()).ok()))
}
/// The CFA pattern in camera planes (`None` for LinearRaw).
pub fn cfa(&self) -> Result<Option<Pattern>> {
let l = dng_lines::layout(&self.tiff, self.raw)?;
if l.photometric != PHOTOMETRIC_CFA {
return Ok(None);
}
let dims = self.raw_tag(tags::CFA_REPEAT_PATTERN_DIM).map(|e| self.tiff.uints(e)).transpose()?.unwrap_or_else(|| vec![2, 2]);
let (rows, cols) = match dims[..] {
[r, c, ..] => (r as usize, c as usize),
_ => return Err(Error::Malformed("CFARepeatPatternDim")),
};
if !(1..=8).contains(&rows) || !(1..=8).contains(&cols) {
return Err(Error::Unsupported(format!("{rows} × {cols} CFA pattern")));
}
let pattern = self.tiff.uints(self.raw_tag(tags::CFA_PATTERN).ok_or(Error::Malformed("no CFAPattern"))?)?;
if pattern.len() < rows * cols {
return Err(Error::Malformed("CFAPattern shorter than its repeat"));
}
let planes = match self.raw_tag(tags::CFA_PLANE_COLOR) {
Some(e) => self.tiff.uints(e)?,
None => vec![0, 1, 2],
};
let mut sorted = planes.clone();
sorted.sort_unstable();
if sorted != [0, 1, 2] {
return Err(Error::Unsupported("CFA colours other than red, green and blue".into()));
}
if let Some(e) = self.raw_tag(tags::CFA_LAYOUT)
&& self.tiff.uint(e)? != 1
{
return Err(Error::Unsupported("a non-rectangular CFA layout".into()));
}
let colors = pattern[..rows * cols]
.iter()
.map(|&v| planes.iter().position(|&p| p == v).map(|i| i as u8).ok_or(Error::Malformed("CFAPattern colour not in CFAPlaneColor")))
.collect::<Result<Vec<u8>>>()?;
Ok(Some(Pattern { rows, cols, colors }))
}
pub fn params(&self) -> Result<Params> {
let uint_pair = |tag| -> Result<Option<(usize, usize)>> {
match self.raw_tag(tag) {
Some(e) => match self.tiff.uints(e)?[..] {
[a, b, ..] => Ok(Some((a as usize, b as usize))),
_ => Err(Error::Malformed("short field")),
},
None => Ok(None),
}
};
let active_area = match self.raw_tag(tags::ACTIVE_AREA) {
Some(e) => match self.tiff.uints(e)?[..] {
[t, l, b, r, ..] => Some([t, l, b, r].map(|v| usize::try_from(v).unwrap_or(usize::MAX))),
_ => return Err(Error::Malformed("ActiveArea")),
},
None => None,
};
let linearization = match self.raw_tag(tags::LINEARIZATION_TABLE) {
Some(e) => {
// checked before `uints` allocates a u64 per entry
if e.count > 65_536 {
return Err(Error::Malformed("LinearizationTable longer than 65536"));
}
let v = self.tiff.uints(e)?;
Some(v.into_iter().map(|x| x.min(65_535) as u16).collect())
}
None => None,
};
let pair = |tag| -> Result<Option<(f64, f64)>> {
match self.raw_tag(tag) {
Some(e) => match self.tiff.floats(e)?[..] {
[a, b, ..] => Ok(Some((a, b))),
_ => Err(Error::Malformed("short field")),
},
None => Ok(None),
}
};
let list = |tag| -> Result<Vec<f64>> { Ok(self.raw_tag(tag).map(|e| self.tiff.floats(e)).transpose()?.unwrap_or_default()) };
Ok(Params {
active_area,
linearization,
black_repeat: uint_pair(tags::BLACK_LEVEL_REPEAT_DIM)?.unwrap_or((1, 1)),
black: list(tags::BLACK_LEVEL)?,
black_delta_h: list(tags::BLACK_LEVEL_DELTA_H)?,
black_delta_v: list(tags::BLACK_LEVEL_DELTA_V)?,
white: list(tags::WHITE_LEVEL)?,
crop_origin: pair(tags::DEFAULT_CROP_ORIGIN)?,
crop_size: pair(tags::DEFAULT_CROP_SIZE)?,
cfa: self.cfa()?,
})
}
/// The colour tags.
pub fn calibration(&self) -> Result<Calibration> {
let illum = |tag| self.main_tag(tag).map(|e| self.tiff.uint(e)).transpose();
let white_xy = self.floats(self.main_tag(tags::AS_SHOT_WHITE_XY))?.and_then(|v| match v[..] {
[x, y] => Some((x, y)),
_ => None,
});
Ok(Calibration {
color_matrix: [self.matrix(tags::COLOR_MATRIX_1)?, self.matrix(tags::COLOR_MATRIX_2)?],
camera_calibration: [self.matrix(tags::CAMERA_CALIBRATION_1)?, self.matrix(tags::CAMERA_CALIBRATION_2)?],
forward_matrix: [self.matrix(tags::FORWARD_MATRIX_1)?, self.matrix(tags::FORWARD_MATRIX_2)?],
illuminant: [illum(tags::CALIBRATION_ILLUMINANT_1)?, illum(tags::CALIBRATION_ILLUMINANT_2)?],
analog_balance: self.vec3(tags::ANALOG_BALANCE)?,
as_shot_neutral: self.vec3(tags::AS_SHOT_NEUTRAL)?,
as_shot_white_xy: white_xy,
baseline_exposure: self.floats(self.main_tag(tags::BASELINE_EXPOSURE))?.and_then(|v| v.first().copied()).unwrap_or(0.0),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn calibration_defaults_and_rejects_bad_rational() -> Result<()> {
let empty = Ifd::default();
let tiff = Tiff { data: &[], big_endian: false };
let metadata = Metadata { tiff, main: &empty, raw: &empty };
let calibration = metadata.calibration()?;
assert_eq!(calibration.baseline_exposure, 0.0);
assert_eq!(calibration.color_matrix, [None, None]);
// IFD with one BaselineExposure SRational pointing past the end of the file.
let data = [b'I', b'I', 42, 0, 8, 0, 0, 0, 1, 0, 42, 198, 10, 0, 1, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0];
let (tiff, first) = Tiff::new(&data)?;
let (ifd, _) = tiff.read_ifd(first, 0)?;
assert!(Metadata { tiff, main: &ifd, raw: &ifd }.calibration().is_err());
Ok(())
}
}
+3
View File
@@ -96,6 +96,9 @@ mod arw_lens_rm6;
/// Bounded DNG strip and tile sample reader.
#[cfg(feature = "line-dng")]
pub mod dng_lines;
/// Bounded DNG camera and processing metadata.
#[cfg(feature = "line-dng")]
pub mod dng_metadata;
#[allow(dead_code)]
mod huffman;
#[cfg(feature = "jxl")]
+1 -1
View File
@@ -214,7 +214,7 @@ pub(super) fn dng(raw: IfdBuilder, order: ByteOrder) -> Vec<u8> {
}
/// [`dng`] with extra IFD 0 tags (where DNG writers put camera-profile tags).
fn dng_with(raw: IfdBuilder, order: ByteOrder, extra: impl FnOnce(&mut IfdBuilder)) -> Vec<u8> {
pub(super) fn dng_with(raw: IfdBuilder, order: ByteOrder, extra: impl FnOnce(&mut IfdBuilder)) -> Vec<u8> {
let mut ifd0 = IfdBuilder::new();
ifd0.set(t::NEW_SUBFILE_TYPE, Value::Long(vec![1]));
ifd0.set(t::DNG_VERSION, Value::Byte(vec![1, 6, 0, 0]));
+119
View File
@@ -0,0 +1,119 @@
//! The bounded DNG metadata reader (`dng_metadata`) on hand-built DNGs, checked against the tags
//! written and, for the colour tags, against the full reader.
use super::dng::{base_ifd, dng, dng_with};
use craft_raw::dng_lines::{self, Error};
use craft_raw::dng_metadata::{Metadata, Pattern};
use craft_tiff::classic::{Tiff, tags as ct};
use craft_tiff::{ByteOrder, IfdBuilder, ImageData, Value};
fn cfa_raw(edit: impl FnOnce(&mut IfdBuilder)) -> IfdBuilder {
let mut raw = base_ifd(8, 4, 16, 1, true);
raw.set(ct::COMPRESSION, Value::Short(vec![1]));
raw.set_image(ImageData::Strips { rows_per_strip: 4, strips: vec![vec![0; 64]] });
edit(&mut raw);
raw
}
fn with_metadata<T>(bytes: &[u8], f: impl FnOnce(&Metadata) -> T) -> T {
let (tiff, first) = Tiff::new(bytes).unwrap();
let ifds = tiff.all_ifds(first).unwrap();
let raw = dng_lines::find_raw_ifd(&tiff, &ifds).unwrap();
f(&Metadata { tiff, main: &ifds[0], raw })
}
#[test]
fn processing_tags_are_read_from_the_raw_ifd() {
let raw = cfa_raw(|r| {
r.set(ct::ACTIVE_AREA, Value::Long(vec![1, 2, 3, 7]));
r.set(ct::LINEARIZATION_TABLE, Value::Short(vec![0, 10, 20]));
r.set(ct::BLACK_LEVEL_REPEAT_DIM, Value::Short(vec![2, 2]));
r.set(ct::BLACK_LEVEL, Value::Rational(vec![(64, 1), (65, 1), (66, 1), (67, 1)]));
r.set(ct::BLACK_LEVEL_DELTA_H, Value::SRational(vec![(1, 2); 8]));
r.set(ct::BLACK_LEVEL_DELTA_V, Value::SRational(vec![(-1, 2); 4]));
r.set(ct::WHITE_LEVEL, Value::Long(vec![4000]));
r.set(ct::DEFAULT_CROP_ORIGIN, Value::Rational(vec![(1, 2), (1, 1)]));
r.set(ct::DEFAULT_CROP_SIZE, Value::Long(vec![6, 2]));
});
for order in [ByteOrder::Little, ByteOrder::Big] {
let p = with_metadata(&dng(raw.clone(), order), |m| m.params().unwrap());
assert_eq!(p.active_area, Some([1, 2, 3, 7]));
assert_eq!(p.linearization, Some(vec![0, 10, 20]));
assert_eq!(p.black_repeat, (2, 2));
assert_eq!(p.black, [64.0, 65.0, 66.0, 67.0]);
assert_eq!(p.black_delta_h, [0.5; 8]);
assert_eq!(p.black_delta_v, [-0.5; 4]);
assert_eq!(p.white, [4000.0]);
assert_eq!((p.crop_origin, p.crop_size), (Some((0.5, 1.0)), Some((6.0, 2.0))));
// base_ifd writes CFAPattern 1 0 2 1 (GRBG)
assert_eq!(p.cfa, Some(Pattern { rows: 2, cols: 2, colors: vec![1, 0, 2, 1] }));
}
// a LinearizationTable longer than 65536 entries is refused
let long = cfa_raw(|r| {
r.set(ct::LINEARIZATION_TABLE, Value::Short(vec![1; 65_537]));
});
assert!(matches!(with_metadata(&dng(long, ByteOrder::Little), |m| m.params()), Err(Error::Malformed(_))));
// absent tags take the DNG defaults
let p = with_metadata(&dng(cfa_raw(|_| {}), ByteOrder::Little), |m| m.params().unwrap());
assert_eq!((p.active_area, p.linearization, p.black_repeat), (None, None, (1, 1)));
assert!(p.black.is_empty() && p.white.is_empty() && p.crop_origin.is_none());
}
#[test]
fn cfa_patterns_map_plane_colours_and_refuse_odd_layouts() {
let pattern = |edit: fn(&mut IfdBuilder)| with_metadata(&dng(cfa_raw(edit), ByteOrder::Little), |m| m.cfa());
// CFAPlaneColor reorders the planes: file colour 2 is plane 0
let swapped = pattern(|r| {
r.set(ct::CFA_PLANE_COLOR, Value::Byte(vec![2, 1, 0]));
r.set(ct::CFA_LAYOUT, Value::Short(vec![1]));
});
assert_eq!(swapped.unwrap(), Some(Pattern { rows: 2, cols: 2, colors: vec![1, 2, 0, 1] }));
let unsupported = |r: Result<Option<Pattern>, Error>| matches!(r, Err(Error::Unsupported(_)));
let malformed = |r: Result<Option<Pattern>, Error>| matches!(r, Err(Error::Malformed(_)));
assert!(unsupported(pattern(|r| {
r.set(ct::CFA_LAYOUT, Value::Short(vec![2]));
})));
assert!(unsupported(pattern(|r| {
r.set(ct::CFA_PLANE_COLOR, Value::Byte(vec![0, 1, 3]));
})));
assert!(unsupported(pattern(|r| {
r.set(ct::CFA_REPEAT_PATTERN_DIM, Value::Short(vec![9, 2]));
})));
assert!(malformed(pattern(|r| {
r.set(ct::CFA_REPEAT_PATTERN_DIM, Value::Short(vec![2]));
})));
assert!(malformed(pattern(|r| {
r.set(ct::CFA_REPEAT_PATTERN_DIM, Value::Short(vec![4, 4]));
})));
assert!(malformed(pattern(|r| {
r.set(ct::CFA_PATTERN, Value::Byte(vec![0, 1, 1, 3]));
})));
// LinearRaw has no pattern
let mut linear = base_ifd(4, 2, 16, 3, false);
linear.set(ct::COMPRESSION, Value::Short(vec![1]));
linear.set_image(ImageData::Strips { rows_per_strip: 2, strips: vec![vec![0; 48]] });
assert_eq!(with_metadata(&dng(linear, ByteOrder::Big), |m| m.cfa()).unwrap(), None);
}
#[test]
fn calibration_matches_the_full_reader() {
let bytes = dng_with(cfa_raw(|_| {}), ByteOrder::Little, |ifd0| {
ifd0.set(ct::COLOR_MATRIX_2, Value::SRational(vec![(2, 1), (0, 1), (0, 1), (0, 1), (2, 1), (0, 1), (0, 1), (0, 1), (2, 1)]));
ifd0.set(ct::CALIBRATION_ILLUMINANT_2, Value::Short(vec![17]));
ifd0.set(ct::ANALOG_BALANCE, Value::Rational(vec![(1, 1); 3]));
ifd0.set(ct::AS_SHOT_NEUTRAL, Value::Rational(vec![(1, 2), (1, 1), (3, 4)]));
ifd0.set(ct::BASELINE_EXPOSURE, Value::SRational(vec![(1, 4)]));
// not 3 x 3 (a four-colour camera): not a matrix here
ifd0.set(ct::FORWARD_MATRIX_1, Value::SRational(vec![(1, 1); 12]));
});
let c = with_metadata(&bytes, |m| m.calibration().unwrap());
let full = craft_raw::decode(&bytes).unwrap().color;
assert_eq!(c.color_matrix, full.color_matrix);
assert_eq!(c.illuminant, [Some(21), Some(17)]);
assert_eq!(c.as_shot_neutral, full.as_shot_neutral);
assert_eq!(c.analog_balance, Some([1.0; 3]));
assert_eq!(c.as_shot_white_xy, Some((0.3127, 0.329)));
assert_eq!(c.baseline_exposure, 0.25);
assert_eq!(c.forward_matrix, [None, None]);
assert_eq!(c.camera_calibration, [None, None]);
}
+2
View File
@@ -4,6 +4,8 @@
mod dng;
#[cfg(feature = "line-dng")]
mod dng_lines;
#[cfg(feature = "line-dng")]
mod dng_metadata;
#[cfg(feature = "dng")]
mod robust;
mod vendor_robust;