mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 23:42:27 +00:00
Adapt camera EXIF to shared TIFF and add bounded parity tests
Retain original contributor imports as authored commits. Reuse shared spans and writer, preserve field semantics, add text budget and differential controls.
This commit is contained in:
1 parent
ef3e23916f
commit
2c7891db0e
2 files changed
+485
-104
No files matched your search
@@ -1,8 +1,12 @@
|
||||
//! Minimal EXIF reader for the camera settings the photography commands use (exposure, aperture,
|
||||
//! Unnormalized camera-field EXIF view, reused from PhotoCraft (exposure, aperture,
|
||||
//! ISO, focal length, camera and lens names). Input is the raw TIFF-structured EXIF payload
|
||||
//! (`II*\0` / `MM\0*`, as stored in `Document.metadata.exif`); malformed data yields `None`
|
||||
//! fields, never a panic. Tag numbers are from the EXIF 2.32 specification (CIPA DC-008).
|
||||
|
||||
// Semantics originate in PhotoCraft, including Brandon Thomas and Fabio Lussi.
|
||||
// Unlike read_exif this view does not normalize dates or derive missing fields.
|
||||
#![cfg_attr(test, allow(clippy::unwrap_used, clippy::expect_used, clippy::panic))]
|
||||
|
||||
/// Camera settings read from EXIF.
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct CameraInfo {
|
||||
@@ -30,20 +34,22 @@ impl CameraInfo {
|
||||
}
|
||||
}
|
||||
|
||||
/// Text bytes decoded per EXIF read (real Make/Model/Lens/Date strings are a few dozen bytes).
|
||||
const MAX_TEXT_BYTES: usize = 1 << 20;
|
||||
|
||||
struct Tiff<'a> {
|
||||
b: &'a [u8],
|
||||
le: bool,
|
||||
order: craft_tiff::ByteOrder,
|
||||
/// Text bytes this read may still decode: duplicate tags can share one large blank value.
|
||||
text_left: std::cell::Cell<usize>,
|
||||
}
|
||||
|
||||
impl Tiff<'_> {
|
||||
fn u16(&self, o: usize) -> Option<u16> {
|
||||
let s = self.b.get(o..o.checked_add(2)?)?;
|
||||
Some(if self.le { u16::from_le_bytes([s[0], s[1]]) } else { u16::from_be_bytes([s[0], s[1]]) })
|
||||
self.order.read_u16(self.b, o)
|
||||
}
|
||||
fn u32(&self, o: usize) -> Option<u32> {
|
||||
let s = self.b.get(o..o.checked_add(4)?)?;
|
||||
let a = [s[0], s[1], s[2], s[3]];
|
||||
Some(if self.le { u32::from_le_bytes(a) } else { u32::from_be_bytes(a) })
|
||||
self.order.read_u32(self.b, o)
|
||||
}
|
||||
/// Entries of the IFD at `off`: (tag, type, count, value offset field position).
|
||||
fn ifd(&self, off: usize) -> Vec<(u16, u16, u32, usize)> {
|
||||
@@ -56,19 +62,14 @@ impl Tiff<'_> {
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn data_at(&self, typ: u16, count: u32, field: usize) -> Option<usize> {
|
||||
let size = match typ {
|
||||
1 | 2 | 6 | 7 => 1usize,
|
||||
3 | 8 => 2,
|
||||
4 | 9 | 11 => 4,
|
||||
5 | 10 | 12 => 8,
|
||||
_ => return None,
|
||||
fn data_at(&self, typ: u16, _count: u32, field: usize) -> Option<usize> {
|
||||
// Keep this caller's historical classic-TIFF type policy; shared spans also
|
||||
// support IFD/BigTIFF types which CameraInfo never accepted.
|
||||
if !(1..=12).contains(&typ) {
|
||||
return None;
|
||||
}
|
||||
.checked_mul(usize::try_from(count).ok()?)?;
|
||||
let at = if size <= 4 { field } else { usize::try_from(self.u32(field)?).ok()? };
|
||||
// The whole value must lie inside the payload, not just its first element.
|
||||
self.b.get(at..at.checked_add(size)?)?;
|
||||
Some(at)
|
||||
let span = craft_tiff::entry_span(self.b, field.checked_sub(8)?, self.order, false, 0)?;
|
||||
usize::try_from(span.start).ok()
|
||||
}
|
||||
fn number(&self, typ: u16, count: u32, field: usize) -> Option<f64> {
|
||||
let at = self.data_at(typ, count, field)?;
|
||||
@@ -87,16 +88,23 @@ impl Tiff<'_> {
|
||||
}
|
||||
}
|
||||
fn text(&self, typ: u16, count: u32, field: usize) -> Option<String> {
|
||||
#[cfg(test)]
|
||||
TEXT_DECODES.with(|c| c.set(c.get() + 1));
|
||||
if typ != 2 {
|
||||
return None;
|
||||
}
|
||||
let at = self.data_at(typ, count, field)?;
|
||||
let s = self.b.get(at..at.checked_add(usize::try_from(count).ok()?)?)?;
|
||||
let n = usize::try_from(count).ok()?;
|
||||
self.text_left.set(self.text_left.get().checked_sub(n)?);
|
||||
let s = self.b.get(at..at.checked_add(n)?)?;
|
||||
let s = String::from_utf8_lossy(s).trim_end_matches('\0').trim().to_string();
|
||||
(!s.is_empty()).then_some(s)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
thread_local!(static TEXT_DECODES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) });
|
||||
|
||||
/// Reads [`CameraInfo`] from a TIFF-structured EXIF payload (an `Exif\0\0` prefix is skipped).
|
||||
pub fn read(exif: &[u8]) -> CameraInfo {
|
||||
let b = exif.strip_prefix(b"Exif\0\0").unwrap_or(exif);
|
||||
@@ -106,7 +114,11 @@ pub fn read(exif: &[u8]) -> CameraInfo {
|
||||
Some([b'M', b'M', 0, 42]) => false,
|
||||
_ => return info,
|
||||
};
|
||||
let t = Tiff { b, le };
|
||||
let t = Tiff {
|
||||
b,
|
||||
order: if le { craft_tiff::ByteOrder::Little } else { craft_tiff::ByteOrder::Big },
|
||||
text_left: std::cell::Cell::new(MAX_TEXT_BYTES),
|
||||
};
|
||||
let Some(ifd0) = t.u32(4) else { return info };
|
||||
let mut queue = vec![ifd0 as usize];
|
||||
let mut seen = Vec::new();
|
||||
@@ -117,15 +129,17 @@ pub fn read(exif: &[u8]) -> CameraInfo {
|
||||
seen.push(off);
|
||||
for (tag, typ, count, field) in t.ifd(off) {
|
||||
match tag {
|
||||
0x010F => info.make = t.text(typ, count, field),
|
||||
0x0110 => info.model = t.text(typ, count, field),
|
||||
// Duplicate TIFF text tags can point at the same large payload. Keep the first
|
||||
// recognized value and do not repeatedly decode/copy later duplicates.
|
||||
0x010F if info.make.is_none() => info.make = t.text(typ, count, field),
|
||||
0x0110 if info.model.is_none() => info.model = t.text(typ, count, field),
|
||||
0x829A => info.exposure_time = t.number(typ, count, field),
|
||||
0x829D => info.f_number = t.number(typ, count, field),
|
||||
0x8827 => info.iso = t.number(typ, count, field),
|
||||
0x920A => info.focal_length = t.number(typ, count, field),
|
||||
0xA405 => info.focal_length_35mm = t.number(typ, count, field).filter(|v| *v > 0.0),
|
||||
0xA434 => info.lens = t.text(typ, count, field),
|
||||
0x9003 => info.date_taken = t.text(typ, count, field),
|
||||
0xA434 if info.lens.is_none() => info.lens = t.text(typ, count, field),
|
||||
0x9003 if info.date_taken.is_none() => info.date_taken = t.text(typ, count, field),
|
||||
0x8769 => {
|
||||
if let Some(p) = t.u32(field) {
|
||||
queue.push(p as usize);
|
||||
@@ -138,86 +152,47 @@ pub fn read(exif: &[u8]) -> CameraInfo {
|
||||
info
|
||||
}
|
||||
|
||||
/// Builds a little-endian EXIF payload (used by tests and by synthetic fixtures).
|
||||
pub fn build(info: &CameraInfo) -> Vec<u8> {
|
||||
// IFD0: Make, Model, ExifIFD pointer; Exif IFD: the rest. Data area after the IFDs.
|
||||
let mut ifd0: Vec<(u16, u16, u32, Vec<u8>)> = Vec::new();
|
||||
let mut exif: Vec<(u16, u16, u32, Vec<u8>)> = Vec::new();
|
||||
let text = |s: &str| {
|
||||
let mut v = s.as_bytes().to_vec();
|
||||
v.push(0);
|
||||
v
|
||||
};
|
||||
let rational = |v: f64| {
|
||||
let d = 10000u32;
|
||||
let mut b = ((v * d as f64).round() as u32).to_le_bytes().to_vec();
|
||||
b.extend_from_slice(&d.to_le_bytes());
|
||||
b
|
||||
};
|
||||
if let Some(s) = &info.make {
|
||||
ifd0.push((0x010F, 2, s.len() as u32 + 1, text(s)));
|
||||
/// Build a classic TIFF EXIF block using the shared TIFF writer.
|
||||
/// Raw date strings and numeric rounding match the camera-field view. Text is
|
||||
/// bounded to the reader's 1 MiB aggregate budget; oversized inputs return an error.
|
||||
/// Physical directory placement is not part of this API's contract.
|
||||
pub fn try_build(info: &CameraInfo) -> craft_tiff::Result<Vec<u8>> {
|
||||
use craft_tiff::{ByteOrder, IfdBuilder, TiffError, TiffWriter, Value};
|
||||
let total =
|
||||
[&info.make, &info.model, &info.lens, &info.date_taken].into_iter().flatten().try_fold(0usize, |n, s| n.checked_add(s.len())?.checked_add(1));
|
||||
if total.is_none_or(|n| n > MAX_TEXT_BYTES) {
|
||||
return Err(TiffError::Limit("camera EXIF text"));
|
||||
}
|
||||
if let Some(s) = &info.model {
|
||||
ifd0.push((0x0110, 2, s.len() as u32 + 1, text(s)));
|
||||
}
|
||||
if let Some(v) = info.exposure_time {
|
||||
exif.push((0x829A, 5, 1, rational(v)));
|
||||
}
|
||||
if let Some(v) = info.f_number {
|
||||
exif.push((0x829D, 5, 1, rational(v)));
|
||||
}
|
||||
if let Some(v) = info.iso {
|
||||
exif.push((0x8827, 3, 1, (v as u16).to_le_bytes().to_vec()));
|
||||
}
|
||||
if let Some(s) = &info.date_taken {
|
||||
exif.push((0x9003, 2, s.len() as u32 + 1, text(s)));
|
||||
}
|
||||
if let Some(v) = info.focal_length {
|
||||
exif.push((0x920A, 5, 1, rational(v)));
|
||||
}
|
||||
if let Some(v) = info.focal_length_35mm {
|
||||
exif.push((0xA405, 3, 1, (v as u16).to_le_bytes().to_vec()));
|
||||
}
|
||||
if let Some(s) = &info.lens {
|
||||
exif.push((0xA434, 2, s.len() as u32 + 1, text(s)));
|
||||
}
|
||||
let ifd_len = |n: usize| 2 + 12 * n + 4;
|
||||
let ifd0_off = 8usize;
|
||||
let n0 = ifd0.len() + 1;
|
||||
let exif_off = ifd0_off + ifd_len(n0);
|
||||
let mut data_off = exif_off + ifd_len(exif.len());
|
||||
let mut out = b"II*\0".to_vec();
|
||||
out.extend_from_slice(&(ifd0_off as u32).to_le_bytes());
|
||||
let mut data = Vec::new();
|
||||
let mut write_ifd = |out: &mut Vec<u8>, entries: &[(u16, u16, u32, Vec<u8>)], extra: Option<u32>| {
|
||||
let n = entries.len() + usize::from(extra.is_some());
|
||||
out.extend_from_slice(&(n as u16).to_le_bytes());
|
||||
for (tag, typ, count, bytes) in entries {
|
||||
out.extend_from_slice(&tag.to_le_bytes());
|
||||
out.extend_from_slice(&typ.to_le_bytes());
|
||||
out.extend_from_slice(&count.to_le_bytes());
|
||||
if bytes.len() <= 4 {
|
||||
let mut f = bytes.clone();
|
||||
f.resize(4, 0);
|
||||
out.extend_from_slice(&f);
|
||||
} else {
|
||||
out.extend_from_slice(&(data_off as u32).to_le_bytes());
|
||||
data.extend_from_slice(bytes);
|
||||
data_off += bytes.len();
|
||||
}
|
||||
let mut root = IfdBuilder::new();
|
||||
let mut exif = IfdBuilder::new();
|
||||
for (tag, value) in [(0x010f, &info.make), (0x0110, &info.model)] {
|
||||
if let Some(value) = value {
|
||||
root.set(tag, Value::Ascii(value.clone()));
|
||||
}
|
||||
if let Some(p) = extra {
|
||||
out.extend_from_slice(&0x8769u16.to_le_bytes());
|
||||
out.extend_from_slice(&4u16.to_le_bytes());
|
||||
out.extend_from_slice(&1u32.to_le_bytes());
|
||||
out.extend_from_slice(&p.to_le_bytes());
|
||||
}
|
||||
for (tag, value) in [(0x9003, &info.date_taken), (0xa434, &info.lens)] {
|
||||
if let Some(value) = value {
|
||||
exif.set(tag, Value::Ascii(value.clone()));
|
||||
}
|
||||
out.extend_from_slice(&0u32.to_le_bytes());
|
||||
};
|
||||
write_ifd(&mut out, &ifd0, Some(exif_off as u32));
|
||||
write_ifd(&mut out, &exif, None);
|
||||
out.extend_from_slice(&data);
|
||||
out
|
||||
}
|
||||
for (tag, value) in [(0x829a, info.exposure_time), (0x829d, info.f_number), (0x920a, info.focal_length)] {
|
||||
if let Some(value) = value {
|
||||
exif.set(tag, Value::Rational(vec![((value * 10000.0).round() as u32, 10000)]));
|
||||
}
|
||||
}
|
||||
for (tag, value) in [(0x8827, info.iso), (0xa405, info.focal_length_35mm)] {
|
||||
if let Some(value) = value {
|
||||
exif.set(tag, Value::Short(vec![value as u16]));
|
||||
}
|
||||
}
|
||||
// Empty child IFDs are valid here; the reader yields absent fields.
|
||||
root.set_child(0x8769, exif);
|
||||
TiffWriter::new(ByteOrder::Little, false).write(&[root])
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn build(info: &CameraInfo) -> Vec<u8> {
|
||||
try_build(info).unwrap_or_default()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -252,6 +227,72 @@ mod tests {
|
||||
|
||||
/// Hostile payloads: huge counts, offsets near `u32::MAX`, self-referencing IFDs and random
|
||||
/// bytes read as `None` fields instead of panicking or overflowing (usize is 32 bits on wasm).
|
||||
#[test]
|
||||
fn blank_duplicate_text_tags_share_one_decode_budget() {
|
||||
// Blank values never fill `make`, so every duplicate would decode the same 1 MiB again;
|
||||
// the per-read budget stops after the first, so the later real value is not reached.
|
||||
let blank = MAX_TEXT_BYTES;
|
||||
let entry = |count: u32, off: u32| {
|
||||
let mut e = Vec::new();
|
||||
e.extend_from_slice(&0x010Fu16.to_le_bytes());
|
||||
e.extend_from_slice(&2u16.to_le_bytes());
|
||||
e.extend_from_slice(&count.to_le_bytes());
|
||||
e.extend_from_slice(&off.to_le_bytes());
|
||||
e
|
||||
};
|
||||
let mut b = b"II*\0".to_vec();
|
||||
b.extend_from_slice(&8u32.to_le_bytes());
|
||||
b.extend_from_slice(&3u16.to_le_bytes());
|
||||
b.extend(entry(blank as u32, 50));
|
||||
b.extend(entry(blank as u32, 50));
|
||||
b.extend(entry(2, u32::from_le_bytes(*b"M\0\0\0")));
|
||||
b.extend_from_slice(&0u32.to_le_bytes());
|
||||
assert_eq!(b.len(), 50);
|
||||
b.extend(std::iter::repeat_n(b' ', blank));
|
||||
assert_eq!(read(&b).make, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn duplicate_text_tags_keep_the_first_value_without_copying_large_duplicates() {
|
||||
let value = vec![b'X'; 2 * 1024 * 1024];
|
||||
let mut b = b"II*\0".to_vec();
|
||||
b.extend_from_slice(&8u32.to_le_bytes());
|
||||
// IFD0: Make="M", a duplicate Make pointing at a 2 MiB payload, and the Exif IFD link.
|
||||
b.extend_from_slice(&3u16.to_le_bytes());
|
||||
b.extend_from_slice(&0x010Fu16.to_le_bytes());
|
||||
b.extend_from_slice(&2u16.to_le_bytes());
|
||||
b.extend_from_slice(&2u32.to_le_bytes());
|
||||
b.extend_from_slice(b"M\0\0\0");
|
||||
b.extend_from_slice(&0x010Fu16.to_le_bytes());
|
||||
b.extend_from_slice(&2u16.to_le_bytes());
|
||||
b.extend_from_slice(&(value.len() as u32).to_le_bytes());
|
||||
b.extend_from_slice(&80u32.to_le_bytes());
|
||||
b.extend_from_slice(&0x8769u16.to_le_bytes());
|
||||
b.extend_from_slice(&4u16.to_le_bytes());
|
||||
b.extend_from_slice(&1u32.to_le_bytes());
|
||||
b.extend_from_slice(&50u32.to_le_bytes());
|
||||
b.extend_from_slice(&0u32.to_le_bytes());
|
||||
// Exif IFD at 50: DateTimeOriginal="D" and the same large duplicate payload at offset 80.
|
||||
b.extend_from_slice(&2u16.to_le_bytes());
|
||||
b.extend_from_slice(&0x9003u16.to_le_bytes());
|
||||
b.extend_from_slice(&2u16.to_le_bytes());
|
||||
b.extend_from_slice(&2u32.to_le_bytes());
|
||||
b.extend_from_slice(b"D\0\0\0");
|
||||
b.extend_from_slice(&0x9003u16.to_le_bytes());
|
||||
b.extend_from_slice(&2u16.to_le_bytes());
|
||||
b.extend_from_slice(&(value.len() as u32).to_le_bytes());
|
||||
b.extend_from_slice(&80u32.to_le_bytes());
|
||||
b.extend_from_slice(&0u32.to_le_bytes());
|
||||
b.extend_from_slice(&value);
|
||||
|
||||
TEXT_DECODES.with(|c| c.set(0));
|
||||
let info = read(&b);
|
||||
assert_eq!(info.make.as_deref(), Some("M"));
|
||||
assert_eq!(info.date_taken.as_deref(), Some("D"));
|
||||
// One decode per tag: duplicates must be skipped before `text` copies their payload.
|
||||
assert_eq!(TEXT_DECODES.with(|c| c.get()), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_payloads_never_panic() {
|
||||
let entry = |tag: u16, typ: u16, count: u32, value: u32| {
|
||||
@@ -292,10 +333,113 @@ mod tests {
|
||||
}
|
||||
let _ = read(&n);
|
||||
}
|
||||
let good =
|
||||
build(&CameraInfo { make: Some("Make".into()), date_taken: Some("2024:02:17 12:40:19".into()), exposure_time: Some(0.004), ..Default::default() });
|
||||
let good = build(&CameraInfo {
|
||||
make: Some("Make".into()),
|
||||
date_taken: Some("2024:02:17 12:40:19".into()),
|
||||
exposure_time: Some(0.004),
|
||||
..Default::default()
|
||||
});
|
||||
for cut in 0..good.len() {
|
||||
let _ = read(&good[..cut]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Keep the previous byte reader only as a test oracle during the shared-span cutover.
|
||||
#[cfg(test)]
|
||||
#[path = "camera_fields_legacy_tests.rs"]
|
||||
mod legacy;
|
||||
|
||||
#[cfg(test)]
|
||||
mod shared_span_parity {
|
||||
use super::*;
|
||||
|
||||
fn compare(bytes: &[u8]) {
|
||||
assert_eq!(format!("{:?}", read(bytes)), format!("{:?}", legacy::read(bytes)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_writer_matches_legacy_fields_and_rejects_oversized_text() {
|
||||
for value in [0.0, -1.0, 0.004, 2.8, 65535.0, f64::INFINITY, f64::NAN] {
|
||||
let camera = CameraInfo {
|
||||
exposure_time: Some(value),
|
||||
f_number: Some(value),
|
||||
iso: Some(value),
|
||||
focal_length: Some(value),
|
||||
focal_length_35mm: Some(value),
|
||||
date_taken: Some("raw date".into()),
|
||||
make: Some("M".into()),
|
||||
model: Some("Model".into()),
|
||||
lens: Some("Lens".into()),
|
||||
};
|
||||
let old = legacy::CameraInfo {
|
||||
exposure_time: camera.exposure_time,
|
||||
f_number: camera.f_number,
|
||||
iso: camera.iso,
|
||||
focal_length: camera.focal_length,
|
||||
focal_length_35mm: camera.focal_length_35mm,
|
||||
date_taken: camera.date_taken.clone(),
|
||||
make: camera.make.clone(),
|
||||
model: camera.model.clone(),
|
||||
lens: camera.lens.clone(),
|
||||
};
|
||||
let bytes = try_build(&camera).unwrap();
|
||||
assert_eq!(format!("{:?}", read(&bytes)), format!("{:?}", legacy::read(&legacy::build(&old))));
|
||||
}
|
||||
assert_eq!(read(&try_build(&CameraInfo::default()).unwrap()), CameraInfo::default());
|
||||
assert!(try_build(&CameraInfo { make: Some("x".repeat(MAX_TEXT_BYTES)), ..Default::default() }).is_err());
|
||||
assert!(try_build(&CameraInfo { make: Some("x".repeat(MAX_TEXT_BYTES - 1)), ..Default::default() }).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preserves_camera_selection_for_valid_truncated_and_mutated_payloads() {
|
||||
let bytes = build(&CameraInfo {
|
||||
make: Some("Maker".into()),
|
||||
model: Some("Camera".into()),
|
||||
lens: Some("Lens".into()),
|
||||
exposure_time: Some(0.125),
|
||||
f_number: Some(2.8),
|
||||
iso: Some(200.0),
|
||||
focal_length: Some(50.0),
|
||||
focal_length_35mm: Some(75.0),
|
||||
date_taken: Some("not normalized: original date".into()),
|
||||
});
|
||||
compare(&bytes);
|
||||
let mut prefixed = b"Exif\0\0".to_vec();
|
||||
prefixed.extend_from_slice(&bytes);
|
||||
compare(&prefixed);
|
||||
for end in 0..=bytes.len() {
|
||||
compare(&bytes[..end]);
|
||||
}
|
||||
// Exercise offsets, tags, types, counts and payloads independently, not random
|
||||
// external data. The complete shared span must remain bounded for every edit.
|
||||
for index in 0..bytes.len() {
|
||||
for value in [0, 0xff, 0x80] {
|
||||
let mut changed = bytes.clone();
|
||||
changed[index] = value;
|
||||
compare(&changed);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preserves_partial_entry_and_zero_count_semantics_in_both_orders() {
|
||||
for little in [true, false] {
|
||||
let u16b = |v: u16| if little { v.to_le_bytes() } else { v.to_be_bytes() };
|
||||
let u32b = |v: u32| if little { v.to_le_bytes() } else { v.to_be_bytes() };
|
||||
for count in [0u32, 1, 2, u32::MAX] {
|
||||
let mut bytes = if little { b"II".to_vec() } else { b"MM".to_vec() };
|
||||
bytes.extend(u16b(42));
|
||||
bytes.extend(u32b(8));
|
||||
bytes.extend(u16b(1));
|
||||
bytes.extend(u16b(0x8827));
|
||||
bytes.extend(u16b(3));
|
||||
bytes.extend(u32b(count));
|
||||
bytes.extend(u16b(200));
|
||||
compare(&bytes); // two inline bytes, no full 12-byte entry/next pointer
|
||||
bytes.extend(u16b(0));
|
||||
compare(&bytes);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
// Frozen differential oracle: PhotoCraft main abb30dff, exif.rs. Test-only, not a production fallback.
|
||||
#![allow(dead_code)]
|
||||
// Minimal EXIF reader for the camera settings the photography commands use (exposure, aperture,
|
||||
// ISO, focal length, camera and lens names). Input is the raw TIFF-structured EXIF payload
|
||||
// (`II*\0` / `MM\0*`, as stored in `Document.metadata.exif`); malformed data yields `None`
|
||||
// fields, never a panic. Tag numbers are from the EXIF 2.32 specification (CIPA DC-008).
|
||||
|
||||
/// Camera settings read from EXIF.
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct CameraInfo {
|
||||
pub make: Option<String>,
|
||||
pub model: Option<String>,
|
||||
pub lens: Option<String>,
|
||||
/// Seconds.
|
||||
pub exposure_time: Option<f64>,
|
||||
pub f_number: Option<f64>,
|
||||
pub iso: Option<f64>,
|
||||
/// Millimetres.
|
||||
pub focal_length: Option<f64>,
|
||||
/// 35 mm-equivalent focal length in millimetres.
|
||||
pub focal_length_35mm: Option<f64>,
|
||||
/// DateTimeOriginal as stored (`YYYY:MM:DD HH:MM:SS`).
|
||||
pub date_taken: Option<String>,
|
||||
}
|
||||
|
||||
impl CameraInfo {
|
||||
/// Linear exposure factor `t · ISO / N²` (relative brightness of the image for one scene).
|
||||
pub fn exposure_factor(&self) -> Option<f64> {
|
||||
let t = self.exposure_time?;
|
||||
let n = self.f_number.unwrap_or(1.0).max(0.1);
|
||||
Some(t * self.iso.unwrap_or(100.0) / 100.0 / (n * n))
|
||||
}
|
||||
}
|
||||
|
||||
/// Text bytes decoded per EXIF read (real Make/Model/Lens/Date strings are a few dozen bytes).
|
||||
const MAX_TEXT_BYTES: usize = 1 << 20;
|
||||
|
||||
struct Tiff<'a> {
|
||||
b: &'a [u8],
|
||||
le: bool,
|
||||
/// Text bytes this read may still decode: duplicate tags can share one large blank value.
|
||||
text_left: std::cell::Cell<usize>,
|
||||
}
|
||||
|
||||
impl Tiff<'_> {
|
||||
fn u16(&self, o: usize) -> Option<u16> {
|
||||
let s = self.b.get(o..o.checked_add(2)?)?;
|
||||
Some(if self.le { u16::from_le_bytes([s[0], s[1]]) } else { u16::from_be_bytes([s[0], s[1]]) })
|
||||
}
|
||||
fn u32(&self, o: usize) -> Option<u32> {
|
||||
let s = self.b.get(o..o.checked_add(4)?)?;
|
||||
let a = [s[0], s[1], s[2], s[3]];
|
||||
Some(if self.le { u32::from_le_bytes(a) } else { u32::from_be_bytes(a) })
|
||||
}
|
||||
/// Entries of the IFD at `off`: (tag, type, count, value offset field position).
|
||||
fn ifd(&self, off: usize) -> Vec<(u16, u16, u32, usize)> {
|
||||
let Some(n) = self.u16(off) else { return Vec::new() };
|
||||
(0..n as usize)
|
||||
.filter_map(|k| {
|
||||
// Checked: offsets come from the file, and usize is 32 bits on wasm.
|
||||
let e = off.checked_add(2)?.checked_add(k * 12)?;
|
||||
Some((self.u16(e)?, self.u16(e.checked_add(2)?)?, self.u32(e.checked_add(4)?)?, e.checked_add(8)?))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn data_at(&self, typ: u16, count: u32, field: usize) -> Option<usize> {
|
||||
let size = match typ {
|
||||
1 | 2 | 6 | 7 => 1usize,
|
||||
3 | 8 => 2,
|
||||
4 | 9 | 11 => 4,
|
||||
5 | 10 | 12 => 8,
|
||||
_ => return None,
|
||||
}
|
||||
.checked_mul(usize::try_from(count).ok()?)?;
|
||||
let at = if size <= 4 { field } else { usize::try_from(self.u32(field)?).ok()? };
|
||||
// The whole value must lie inside the payload, not just its first element.
|
||||
self.b.get(at..at.checked_add(size)?)?;
|
||||
Some(at)
|
||||
}
|
||||
fn number(&self, typ: u16, count: u32, field: usize) -> Option<f64> {
|
||||
let at = self.data_at(typ, count, field)?;
|
||||
match typ {
|
||||
3 => self.u16(at).map(f64::from),
|
||||
4 => self.u32(at).map(f64::from),
|
||||
5 => {
|
||||
let (n, d) = (self.u32(at)?, self.u32(at.checked_add(4)?)?);
|
||||
(d != 0).then(|| n as f64 / d as f64)
|
||||
}
|
||||
10 => {
|
||||
let (n, d) = (self.u32(at)? as i32, self.u32(at.checked_add(4)?)? as i32);
|
||||
(d != 0).then(|| n as f64 / d as f64)
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
fn text(&self, typ: u16, count: u32, field: usize) -> Option<String> {
|
||||
#[cfg(test)]
|
||||
TEXT_DECODES.with(|c| c.set(c.get() + 1));
|
||||
if typ != 2 {
|
||||
return None;
|
||||
}
|
||||
let at = self.data_at(typ, count, field)?;
|
||||
let n = usize::try_from(count).ok()?;
|
||||
self.text_left.set(self.text_left.get().checked_sub(n)?);
|
||||
let s = self.b.get(at..at.checked_add(n)?)?;
|
||||
let s = String::from_utf8_lossy(s).trim_end_matches('\0').trim().to_string();
|
||||
(!s.is_empty()).then_some(s)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
thread_local!(static TEXT_DECODES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) });
|
||||
|
||||
/// Reads [`CameraInfo`] from a TIFF-structured EXIF payload (an `Exif\0\0` prefix is skipped).
|
||||
pub fn read(exif: &[u8]) -> CameraInfo {
|
||||
let b = exif.strip_prefix(b"Exif\0\0").unwrap_or(exif);
|
||||
let mut info = CameraInfo::default();
|
||||
let le = match b.get(..4) {
|
||||
Some([b'I', b'I', 42, 0]) => true,
|
||||
Some([b'M', b'M', 0, 42]) => false,
|
||||
_ => return info,
|
||||
};
|
||||
let t = Tiff { b, le, text_left: std::cell::Cell::new(MAX_TEXT_BYTES) };
|
||||
let Some(ifd0) = t.u32(4) else { return info };
|
||||
let mut queue = vec![ifd0 as usize];
|
||||
let mut seen = Vec::new();
|
||||
while let Some(off) = queue.pop() {
|
||||
if seen.contains(&off) || seen.len() > 8 {
|
||||
continue;
|
||||
}
|
||||
seen.push(off);
|
||||
for (tag, typ, count, field) in t.ifd(off) {
|
||||
match tag {
|
||||
// Duplicate TIFF text tags can point at the same large payload. Keep the first
|
||||
// recognized value and do not repeatedly decode/copy later duplicates.
|
||||
0x010F if info.make.is_none() => info.make = t.text(typ, count, field),
|
||||
0x0110 if info.model.is_none() => info.model = t.text(typ, count, field),
|
||||
0x829A => info.exposure_time = t.number(typ, count, field),
|
||||
0x829D => info.f_number = t.number(typ, count, field),
|
||||
0x8827 => info.iso = t.number(typ, count, field),
|
||||
0x920A => info.focal_length = t.number(typ, count, field),
|
||||
0xA405 => info.focal_length_35mm = t.number(typ, count, field).filter(|v| *v > 0.0),
|
||||
0xA434 if info.lens.is_none() => info.lens = t.text(typ, count, field),
|
||||
0x9003 if info.date_taken.is_none() => info.date_taken = t.text(typ, count, field),
|
||||
0x8769 => {
|
||||
if let Some(p) = t.u32(field) {
|
||||
queue.push(p as usize);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
info
|
||||
}
|
||||
|
||||
/// Builds a little-endian EXIF payload (used by tests and by synthetic fixtures).
|
||||
pub fn build(info: &CameraInfo) -> Vec<u8> {
|
||||
// IFD0: Make, Model, ExifIFD pointer; Exif IFD: the rest. Data area after the IFDs.
|
||||
let mut ifd0: Vec<(u16, u16, u32, Vec<u8>)> = Vec::new();
|
||||
let mut exif: Vec<(u16, u16, u32, Vec<u8>)> = Vec::new();
|
||||
let text = |s: &str| {
|
||||
let mut v = s.as_bytes().to_vec();
|
||||
v.push(0);
|
||||
v
|
||||
};
|
||||
let rational = |v: f64| {
|
||||
let d = 10000u32;
|
||||
let mut b = ((v * d as f64).round() as u32).to_le_bytes().to_vec();
|
||||
b.extend_from_slice(&d.to_le_bytes());
|
||||
b
|
||||
};
|
||||
if let Some(s) = &info.make {
|
||||
ifd0.push((0x010F, 2, s.len() as u32 + 1, text(s)));
|
||||
}
|
||||
if let Some(s) = &info.model {
|
||||
ifd0.push((0x0110, 2, s.len() as u32 + 1, text(s)));
|
||||
}
|
||||
if let Some(v) = info.exposure_time {
|
||||
exif.push((0x829A, 5, 1, rational(v)));
|
||||
}
|
||||
if let Some(v) = info.f_number {
|
||||
exif.push((0x829D, 5, 1, rational(v)));
|
||||
}
|
||||
if let Some(v) = info.iso {
|
||||
exif.push((0x8827, 3, 1, (v as u16).to_le_bytes().to_vec()));
|
||||
}
|
||||
if let Some(s) = &info.date_taken {
|
||||
exif.push((0x9003, 2, s.len() as u32 + 1, text(s)));
|
||||
}
|
||||
if let Some(v) = info.focal_length {
|
||||
exif.push((0x920A, 5, 1, rational(v)));
|
||||
}
|
||||
if let Some(v) = info.focal_length_35mm {
|
||||
exif.push((0xA405, 3, 1, (v as u16).to_le_bytes().to_vec()));
|
||||
}
|
||||
if let Some(s) = &info.lens {
|
||||
exif.push((0xA434, 2, s.len() as u32 + 1, text(s)));
|
||||
}
|
||||
let ifd_len = |n: usize| 2 + 12 * n + 4;
|
||||
let ifd0_off = 8usize;
|
||||
let n0 = ifd0.len() + 1;
|
||||
let exif_off = ifd0_off + ifd_len(n0);
|
||||
let mut data_off = exif_off + ifd_len(exif.len());
|
||||
let mut out = b"II*\0".to_vec();
|
||||
out.extend_from_slice(&(ifd0_off as u32).to_le_bytes());
|
||||
let mut data = Vec::new();
|
||||
let mut write_ifd = |out: &mut Vec<u8>, entries: &[(u16, u16, u32, Vec<u8>)], extra: Option<u32>| {
|
||||
let n = entries.len() + usize::from(extra.is_some());
|
||||
out.extend_from_slice(&(n as u16).to_le_bytes());
|
||||
for (tag, typ, count, bytes) in entries {
|
||||
out.extend_from_slice(&tag.to_le_bytes());
|
||||
out.extend_from_slice(&typ.to_le_bytes());
|
||||
out.extend_from_slice(&count.to_le_bytes());
|
||||
if bytes.len() <= 4 {
|
||||
let mut f = bytes.clone();
|
||||
f.resize(4, 0);
|
||||
out.extend_from_slice(&f);
|
||||
} else {
|
||||
out.extend_from_slice(&(data_off as u32).to_le_bytes());
|
||||
data.extend_from_slice(bytes);
|
||||
data_off += bytes.len();
|
||||
}
|
||||
}
|
||||
if let Some(p) = extra {
|
||||
out.extend_from_slice(&0x8769u16.to_le_bytes());
|
||||
out.extend_from_slice(&4u16.to_le_bytes());
|
||||
out.extend_from_slice(&1u32.to_le_bytes());
|
||||
out.extend_from_slice(&p.to_le_bytes());
|
||||
}
|
||||
out.extend_from_slice(&0u32.to_le_bytes());
|
||||
};
|
||||
write_ifd(&mut out, &ifd0, Some(exif_off as u32));
|
||||
write_ifd(&mut out, &exif, None);
|
||||
out.extend_from_slice(&data);
|
||||
out
|
||||
}
|
||||
Reference in new issue
Block a user