LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M3.1: lightcraft-meta EXIF/XMP/IPTC
Brandon Thomascbe9d8989a58
diff --git a/Cargo.lock b/Cargo.lockindex d844d9f74..d6b9c0208 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -143,6 +143,14 @@ dependencies = [[[package]]name = "lightcraft-meta"version = "0.1.0"+dependencies = [+ "lightcraft-geom",+ "lightcraft-tiff",+ "proptest",+ "quick-xml",+ "serde",+ "serde_json",+][[package]]name = "lightcraft-raster"@@ -238,6 +246,15 @@ version = "1.2.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"+[[package]]+name = "quick-xml"+version = "0.38.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"+dependencies = [+ "memchr",+]+[[package]]name = "quote"version = "1.0.47"diff --git a/Cargo.toml b/Cargo.tomlindex 29847fce9..4344166a6 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -35,6 +35,10 @@ rayon = "1"proptest = "1"bytemuck = { version = "1", features = ["derive"] }+# formats+quick-xml = "0.38"+miniz_oxide = "0.8"+# codecsimage = { version = "0.25", default-features = false, features = ["png", "jpeg", "tiff", "webp"] }diff --git a/crates/meta/Cargo.toml b/crates/meta/Cargo.tomlindex 8161325b0..0ef8903d2 100644--- a/crates/meta/Cargo.toml+++ b/crates/meta/Cargo.toml@@ -9,3 +9,11 @@ description = "LightCraft metadata: EXIF, XMP, IPTC (L1)"workspace = true[dependencies]+lightcraft-tiff = { workspace = true }+lightcraft-geom = { workspace = true }+serde = { workspace = true }+quick-xml = { workspace = true }++[dev-dependencies]+proptest = { workspace = true }+serde_json = { workspace = true }diff --git a/crates/meta/README.md b/crates/meta/README.mdnew file mode 100644index 000000000..83ee9e601--- /dev/null+++ b/crates/meta/README.md@@ -0,0 +1,41 @@+# lightcraft-meta (L1)++Photo metadata: EXIF, XMP (read + write), IPTC-IIM, and the containers that carry them.++## API++| Function | Purpose |+|---|---|+| `read_exif(&[u8]) -> Metadata` | TIFF-structured Exif block (whole TIFF/DNG/raw file, or JPEG APP1 payload with/without `Exif\0\0`). `try_read_exif` reports header errors. |+| `from_tiff(&Tiff) -> Metadata` | Same, from an already parsed stream (used by `lightcraft-raw`). |+| `embedded(&[u8]) -> Embedded` | Sniffs JPEG / PNG / WebP / TIFF and returns the Exif, XMP (+ extended XMP), ICC and IPTC blocks. `jpeg_segments`, `png_chunks`, `webp_chunks` are the per-container walkers. |+| `parse_xmp(&str) -> Result<XmpData>` | Metadata + the opaque `lc:settings` JSON + every property (`prefix:name`, structs flattened as `a:b/c:d`). |+| `write_xmp(&Metadata, Option<&str>) -> String` | Complete `<?xpacket?>` packet; the second argument is LightCraft's full develop settings JSON. |+| `parse_iptc(&[u8]) -> Metadata` | IIM record 2: title (2:5), keywords (2:25), by-line (2:80), copyright (2:116), caption (2:120), date/time created (2:55/2:60). |+| `extract(&[u8]) -> Metadata` | Everything for a whole file. Precedence: EXIF → IPTC fills gaps → XMP overrides user fields (rating, label, title, caption, artist, copyright, keywords, GPS) and fills the rest. |++`Metadata` carries camera (make, model, serial, software), lens (make, model, serial, specification), capture+(date-time with UTC offset and milliseconds, exposure time, f-number, ISO incl. extended ISO, focal length and+35 mm equivalent, flash, exposure bias, program, metering, white balance), orientation, GPS, dimensions and the+user fields (artist, copyright, title, caption, keywords, hierarchical keywords, rating −1…5, colour label).++## XMP namespaces++Written: `dc`, `xmp`, `photoshop`, `exif`, `exifEX`, `tiff`, `lr` (`hierarchicalSubject`) and ours,+`lc` = `http://ns.lightcraft.app/lc/1.0/` (`lc:settings`, an opaque JSON string). Reading canonicalises+prefixes by namespace URI, handles attribute and element forms, `rdf:Seq`/`Bag`/`Alt` (x-default first),+`rdf:parseType="Resource"` and nested-description structs, predefined and numeric entities. Nesting depth+and node count are limited.++## Robustness++No panics on malformed input: proptests feed random bytes to every container walker and random text to the+XMP parser; truncation tests cut a sample JPEG at every byte.++## Sources++CIPA DC-008 (Exif 2.32), TIFF 6.0, Adobe DNG 1.7 (tag numbers), ISO 16684-1 / Adobe XMP Specification+Parts 1–3 (packet, RDF serialisation, standard schemas, JPEG extended XMP), IPTC-IIM 4.2 and the IPTC Photo+Metadata Standard, ITU-T T.81 (JPEG markers), ICC.1 (APP2 embedding), PNG Specification 3rd ed. (`eXIf`,+`iTXt`), the WebP RIFF container specification, Adobe Photoshop File Format Specification (image resource+blocks). XML parsing: `quick-xml` (MIT). No third-party metadata code was consulted.diff --git a/crates/meta/src/container.rs b/crates/meta/src/container.rsnew file mode 100644index 000000000..87bf51149--- /dev/null+++ b/crates/meta/src/container.rs@@ -0,0 +1,304 @@+//! Locating metadata blocks inside image containers.+//!+//! - JPEG (ITU-T T.81 marker structure): APP1 `Exif\0\0`, APP1 `http://ns.adobe.com/xap/1.0/\0` (XMP),+//! APP1 `http://ns.adobe.com/xmp/extension/\0` (extended XMP, reassembled), APP2 `ICC_PROFILE\0`+//! (multi-chunk, reassembled in sequence order), APP13 `Photoshop 3.0\0` 8BIM resource 0x0404 (IPTC-IIM).+//! - PNG (PNG spec 3rd ed.): `eXIf`, `iTXt` with keyword `XML:com.adobe.xmp` (uncompressed).+//! - WebP (RIFF container spec): `EXIF`, `XMP `, `ICCP` chunks.+//! - TIFF-based files (TIFF, DNG and most raws): the whole file is the Exif block; XMP (700), ICC (34675) and+//! IPTC (33723) from IFD0.++use lightcraft_tiff::{Tiff, tags};++/// Metadata blocks found in a file.+#[derive(Clone, Debug, Default, PartialEq, Eq)]+pub struct Embedded {+ /// TIFF-structured Exif block (without the `Exif\0\0` prefix).+ pub exif: Option<Vec<u8>>,+ /// XMP packet (the main one; extended XMP is appended by [`Embedded::xmp_extended`]).+ pub xmp: Option<String>,+ /// Extended XMP (JPEG only), reassembled.+ pub xmp_extended: Option<String>,+ pub icc: Option<Vec<u8>>,+ /// IPTC-IIM stream.+ pub iptc: Option<Vec<u8>>,+}++/// Sniff the container and collect its metadata blocks. Unknown containers yield an empty result.+pub fn embedded(bytes: &[u8]) -> Embedded {+ if bytes.starts_with(&[0xff, 0xd8]) {+ jpeg_segments(bytes)+ } else if bytes.starts_with(b"\x89PNG\r\n\x1a\n") {+ png_chunks(bytes)+ } else if bytes.len() >= 12 && &bytes[..4] == b"RIFF" && &bytes[8..12] == b"WEBP" {+ webp_chunks(bytes)+ } else if let Ok(t) = Tiff::parse(bytes) {+ let ifd0 = &t.ifds[0];+ Embedded {+ exif: Some(bytes.to_vec()),+ xmp: ifd0.bytes(tags::XMP).map(|b| String::from_utf8_lossy(b).into_owned()),+ xmp_extended: None,+ icc: ifd0.bytes(tags::ICC_PROFILE).map(|b| b.to_vec()),+ iptc: ifd0.value(tags::IPTC_NAA).map(|v| match v {+ lightcraft_tiff::Value::Byte(b) | lightcraft_tiff::Value::Undefined(b) => b.clone(),+ other => lightcraft_tiff::writer::encode(t.order, other),+ }),+ }+ } else {+ Embedded::default()+ }+}++const XMP_SIG: &[u8] = b"http://ns.adobe.com/xap/1.0/\0";+const XMP_EXT_SIG: &[u8] = b"http://ns.adobe.com/xmp/extension/\0";++/// Walk JPEG markers up to SOS and collect APP1 Exif / XMP, APP2 ICC and APP13 IPTC.+pub fn jpeg_segments(b: &[u8]) -> Embedded {+ let mut out = Embedded::default();+ if !b.starts_with(&[0xff, 0xd8]) {+ return out;+ }+ let mut icc_parts: Vec<(u8, Vec<u8>)> = Vec::new();+ let mut ext: Vec<(u32, Vec<u8>)> = Vec::new();+ let mut i = 2usize;+ while i + 4 <= b.len() {+ if b[i] != 0xff {+ break;+ }+ let marker = b[i + 1];+ if marker == 0xff {+ i += 1; // fill byte+ continue;+ }+ if marker == 0xd8 || (0xd0..=0xd7).contains(&marker) || marker == 0x01 {+ i += 2;+ continue;+ }+ if marker == 0xd9 || marker == 0xda {+ break;+ }+ let len = u16::from_be_bytes([b[i + 2], b[i + 3]]) as usize;+ if len < 2 {+ break;+ }+ let end = (i + 2 + len).min(b.len());+ let payload = &b[i + 4..end];+ match marker {+ 0xe1 if payload.starts_with(b"Exif\0") && out.exif.is_none() => out.exif = Some(payload.get(6..).unwrap_or(&[]).to_vec()),+ 0xe1 if payload.starts_with(XMP_SIG) && out.xmp.is_none() => {+ out.xmp = Some(String::from_utf8_lossy(&payload[XMP_SIG.len()..]).into_owned());+ }+ 0xe1 if payload.starts_with(XMP_EXT_SIG) => {+ // GUID (32) + full length (4) + offset (4) + data+ let p = &payload[XMP_EXT_SIG.len()..];+ if p.len() >= 40 {+ let off = u32::from_be_bytes([p[36], p[37], p[38], p[39]]);+ ext.push((off, p[40..].to_vec()));+ }+ }+ 0xe2 if payload.starts_with(b"ICC_PROFILE\0") && payload.len() >= 14 => icc_parts.push((payload[12], payload[14..].to_vec())),+ 0xed if payload.starts_with(b"Photoshop 3.0\0") && out.iptc.is_none() => out.iptc = photoshop_iptc(&payload[14..]),+ _ => {}+ }+ i = end;+ }+ if !icc_parts.is_empty() {+ icc_parts.sort_by_key(|p| p.0);+ out.icc = Some(icc_parts.into_iter().flat_map(|p| p.1).collect());+ }+ if !ext.is_empty() {+ ext.sort_by_key(|p| p.0);+ out.xmp_extended = Some(String::from_utf8_lossy(&ext.into_iter().flat_map(|p| p.1).collect::<Vec<u8>>()).into_owned());+ }+ out+}++/// IPTC-IIM block (resource 0x0404) from a Photoshop image-resource stream (`8BIM` records).+fn photoshop_iptc(mut b: &[u8]) -> Option<Vec<u8>> {+ while b.len() >= 12 && &b[..4] == b"8BIM" {+ let id = u16::from_be_bytes([b[4], b[5]]);+ let name_len = b[6] as usize;+ let name_total = (1 + name_len).next_multiple_of(2);+ let size_at = 6 + name_total;+ let size = u32::from_be_bytes(b.get(size_at..size_at + 4)?.try_into().ok()?) as usize;+ let data_at = size_at + 4;+ let data = b.get(data_at..data_at.checked_add(size)?)?;+ if id == 0x0404 {+ return Some(data.to_vec());+ }+ b = b.get(data_at + size.next_multiple_of(2)..)?;+ }+ None+}++/// PNG chunks: `eXIf`, uncompressed `iTXt` XMP.+pub fn png_chunks(b: &[u8]) -> Embedded {+ let mut out = Embedded::default();+ let mut i = 8usize;+ while i + 12 <= b.len() {+ let len = u32::from_be_bytes([b[i], b[i + 1], b[i + 2], b[i + 3]]) as usize;+ let typ = &b[i + 4..i + 8];+ let Some(data) = b.get(i + 8..(i + 8).saturating_add(len)) else { break };+ match typ {+ b"eXIf" => out.exif = Some(crate::strip_exif_header(data).to_vec()),+ b"iTXt" if data.starts_with(b"XML:com.adobe.xmp\0") => {+ // keyword\0 compression-flag compression-method language\0 translated\0 text+ let rest = &data[18..];+ if rest.len() >= 2 && rest[0] == 0 {+ let rest = &rest[2..];+ let mut parts = rest.splitn(3, |&c| c == 0);+ let (_, _, text) = (parts.next(), parts.next(), parts.next());+ if let Some(t) = text {+ out.xmp = Some(String::from_utf8_lossy(t).into_owned());+ }+ }+ }+ b"IEND" => break,+ _ => {}+ }+ i += 12 + len;+ }+ out+}++/// WebP RIFF chunks `EXIF`, `XMP `, `ICCP`.+pub fn webp_chunks(b: &[u8]) -> Embedded {+ let mut out = Embedded::default();+ let mut i = 12usize;+ while i + 8 <= b.len() {+ let id = &b[i..i + 4];+ let len = u32::from_le_bytes([b[i + 4], b[i + 5], b[i + 6], b[i + 7]]) as usize;+ let Some(data) = b.get(i + 8..(i + 8).saturating_add(len)) else { break };+ match id {+ b"EXIF" => out.exif = Some(crate::strip_exif_header(data).to_vec()),+ b"XMP " => out.xmp = Some(String::from_utf8_lossy(data).into_owned()),+ b"ICCP" => out.icc = Some(data.to_vec()),+ _ => {}+ }+ i += 8 + len + (len & 1);+ }+ out+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::exif::tests::sample_exif;+ use lightcraft_tiff::ByteOrder;++ fn seg(marker: u8, payload: &[u8]) -> Vec<u8> {+ let mut v = vec![0xff, marker];+ v.extend_from_slice(&((payload.len() + 2) as u16).to_be_bytes());+ v.extend_from_slice(payload);+ v+ }++ pub(crate) fn sample_jpeg() -> Vec<u8> {+ let mut j = vec![0xff, 0xd8];+ j.extend(seg(0xe0, b"JFIF\0\x01\x02\0\0\x01\0\x01\0\0"));+ let mut exif = b"Exif\0\0".to_vec();+ exif.extend(sample_exif(ByteOrder::Big));+ j.extend(seg(0xe1, &exif));+ let meta = crate::Metadata { title: Some("Sunset".into()), rating: Some(4), ..Default::default() };+ let mut xmp = XMP_SIG.to_vec();+ xmp.extend(crate::write_xmp(&meta, Some("{\"exposure\":1.5}")).into_bytes());+ j.extend(seg(0xe1, &xmp));+ // ICC in two chunks, out of order+ j.extend(seg(0xe2, b"ICC_PROFILE\0\x02\x02WORLD"));+ j.extend(seg(0xe2, b"ICC_PROFILE\0\x01\x02HELLO"));+ // IPTC+ let iim = crate::iptc::tests::sample_iim();+ let mut ps = b"Photoshop 3.0\0".to_vec();+ ps.extend_from_slice(b"8BIM\x04\x0c\0\0");+ ps.extend_from_slice(&2u32.to_be_bytes());+ ps.extend_from_slice(&[1, 2]);+ ps.extend_from_slice(b"8BIM\x04\x04\0\0");+ ps.extend_from_slice(&(iim.len() as u32).to_be_bytes());+ ps.extend_from_slice(&iim);+ j.extend(seg(0xed, &ps));+ j.extend_from_slice(&[0xff, 0xda, 0, 2, 1, 2, 3, 0xff, 0xd9]);+ j+ }++ #[test]+ fn jpeg_blocks() {+ let j = sample_jpeg();+ let e = jpeg_segments(&j);+ assert_eq!(e.icc.as_deref(), Some(&b"HELLOWORLD"[..]));+ assert!(e.xmp.as_deref().unwrap().contains("Sunset"));+ assert!(e.iptc.is_some());+ let m = crate::extract(&j);+ assert_eq!(m.iso, Some(400));+ assert_eq!(m.title.as_deref(), Some("Sunset"));+ assert_eq!(m.rating, Some(4)); // XMP overrides EXIF rating 3+ assert_eq!(m.keywords, vec!["alpha".to_string(), "beta".to_string()]); // from IPTC+ assert_eq!(m.caption.as_deref(), Some("A caption"));+ }++ #[test]+ fn jpeg_extended_xmp() {+ let mut j = vec![0xff, 0xd8];+ for (off, part) in [(5u32, &b"world"[..]), (0, b"hello")] {+ let mut p = XMP_EXT_SIG.to_vec();+ p.extend_from_slice(&[b'A'; 32]);+ p.extend_from_slice(&10u32.to_be_bytes());+ p.extend_from_slice(&off.to_be_bytes());+ p.extend_from_slice(part);+ j.extend(seg(0xe1, &p));+ }+ assert_eq!(jpeg_segments(&j).xmp_extended.as_deref(), Some("helloworld"));+ }++ #[test]+ fn png_and_webp() {+ let exif = sample_exif(ByteOrder::Little);+ let mut p = b"\x89PNG\r\n\x1a\n".to_vec();+ let mut chunk = |typ: &[u8], data: &[u8]| {+ p.extend_from_slice(&(data.len() as u32).to_be_bytes());+ p.extend_from_slice(typ);+ p.extend_from_slice(data);+ p.extend_from_slice(&[0; 4]);+ };+ chunk(b"eXIf", &exif);+ let mut itxt = b"XML:com.adobe.xmp\0\0\0\0\0".to_vec();+ itxt.extend(crate::write_xmp(&crate::Metadata { label: Some("Red".into()), ..Default::default() }, None).into_bytes());+ chunk(b"iTXt", &itxt);+ chunk(b"IEND", &[]);+ let m = crate::extract(&p);+ assert_eq!(m.iso, Some(400));+ assert_eq!(m.label.as_deref(), Some("Red"));++ let mut w = b"RIFF\0\0\0\0WEBP".to_vec();+ let mut body = |id: &[u8], data: &[u8]| {+ w.extend_from_slice(id);+ w.extend_from_slice(&(data.len() as u32).to_le_bytes());+ w.extend_from_slice(data);+ if data.len() % 2 == 1 {+ w.push(0);+ }+ };+ body(b"VP8X", &[0; 10]);+ body(b"ICCP", b"abc");+ let mut ex = b"Exif\0\0".to_vec();+ ex.extend_from_slice(&exif);+ body(b"EXIF", &ex);+ let e = webp_chunks(&w);+ assert_eq!(e.icc.as_deref(), Some(&b"abc"[..]));+ assert_eq!(crate::extract(&w).f_number, Some(2.8));+ }++ #[test]+ fn tiff_file_is_its_own_exif() {+ let t = sample_exif(ByteOrder::Big);+ assert_eq!(crate::extract(&t).model.as_deref(), Some("Model X"));+ assert_eq!(embedded(b"not an image"), Embedded::default());+ }++ #[test]+ fn truncated_containers_do_not_panic() {+ let j = sample_jpeg();+ for n in 0..j.len() {+ let _ = crate::extract(&j[..n]);+ }+ }+}diff --git a/crates/meta/src/datetime.rs b/crates/meta/src/datetime.rsnew file mode 100644index 000000000..ed77ee9ea--- /dev/null+++ b/crates/meta/src/datetime.rs@@ -0,0 +1,204 @@+//! Capture date/time with optional UTC offset (Exif `DateTimeOriginal` + `OffsetTimeOriginal`, ISO 8601 in XMP).++use serde::{Deserialize, Serialize};++/// A civil date-time as recorded by the camera; `offset_minutes` is the UTC offset when known.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]+pub struct DateTime {+ pub year: u16,+ pub month: u8,+ pub day: u8,+ pub hour: u8,+ pub minute: u8,+ pub second: u8,+ /// Sub-second part in milliseconds.+ pub millis: u16,+ pub offset_minutes: Option<i16>,+}++fn num(s: &str) -> Option<u32> {+ if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {+ return None;+ }+ s.parse().ok()+}++impl DateTime {+ fn valid(self) -> Option<Self> {+ let ok = (1..=12).contains(&self.month)+ && (1..=31).contains(&self.day)+ && self.hour < 24+ && self.minute < 60+ && self.second < 61+ && self.year > 0+ && self.offset_minutes.is_none_or(|o| o.abs() <= 18 * 60);+ ok.then_some(self)+ }++ /// Exif form `YYYY:MM:DD HH:MM:SS` (also tolerates `-` date separators and a missing time).+ pub fn parse_exif(s: &str) -> Option<DateTime> {+ let s = s.trim().trim_end_matches('\0');+ let (d, t) = s.split_once([' ', 'T']).unwrap_or((s, ""));+ let dp: Vec<&str> = d.split([':', '-']).collect();+ if dp.len() != 3 {+ return None;+ }+ let tp: Vec<&str> = if t.is_empty() { vec![] } else { t.split(':').collect() };+ let g = |v: &Vec<&str>, i: usize| v.get(i).map(|x| num(x.trim())).unwrap_or(Some(0));+ DateTime {+ year: num(dp[0])?.try_into().ok()?,+ month: num(dp[1])?.try_into().ok()?,+ day: num(dp[2])?.try_into().ok()?,+ hour: g(&tp, 0)?.try_into().ok()?,+ minute: g(&tp, 1)?.try_into().ok()?,+ second: g(&tp, 2)?.try_into().ok()?,+ millis: 0,+ offset_minutes: None,+ }+ .valid()+ }++ /// Exif `OffsetTime*` form `+HH:MM` / `-HH:MM` (or `Z`).+ pub fn parse_offset(s: &str) -> Option<i16> {+ let s = s.trim().trim_end_matches('\0');+ if s == "Z" {+ return Some(0);+ }+ let (sign, rest) = match s.as_bytes().first()? {+ b'+' => (1, &s[1..]),+ b'-' => (-1, &s[1..]),+ _ => return None,+ };+ let (h, m) = match rest.split_once(':') {+ Some((h, m)) => (num(h)?, num(m)?),+ None if rest.len() == 4 => (num(&rest[..2])?, num(&rest[2..])?),+ None => (num(rest)?, 0),+ };+ if h > 18 || m > 59 {+ return None;+ }+ Some(sign * (h * 60 + m) as i16)+ }++ /// Set the sub-second part from an Exif `SubSecTime*` string (digits are a decimal fraction).+ pub fn with_subsec(mut self, s: &str) -> DateTime {+ let digits: String = s.trim().chars().take_while(|c| c.is_ascii_digit()).take(3).collect();+ if !digits.is_empty() {+ let v: u16 = digits.parse().unwrap_or(0);+ self.millis = v * 10u16.pow(3 - digits.len() as u32);+ }+ self+ }++ /// ISO 8601 (XMP date): `YYYY`, `YYYY-MM`, `YYYY-MM-DD`, `YYYY-MM-DDThh:mm[:ss[.s+]][TZD]`.+ pub fn parse_iso(s: &str) -> Option<DateTime> {+ let s = s.trim();+ let (d, t) = s.split_once('T').unwrap_or((s, ""));+ let dp: Vec<&str> = d.split('-').collect();+ let year = num(dp.first()?)?.try_into().ok()?;+ let month = dp.get(1).map(|m| num(m)).unwrap_or(Some(1))?.try_into().ok()?;+ let day = dp.get(2).map(|m| num(m)).unwrap_or(Some(1))?.try_into().ok()?;+ if dp.len() > 3 {+ return None;+ }+ let mut dt = DateTime { year, month, day, ..Default::default() };+ if !t.is_empty() {+ let (clock, off) = match t.find(['Z', '+', '-']) {+ Some(i) => (&t[..i], Some(&t[i..])),+ None => (t, None),+ };+ let cp: Vec<&str> = clock.split(':').collect();+ dt.hour = num(cp.first()?)?.try_into().ok()?;+ dt.minute = num(cp.get(1)?)?.try_into().ok()?;+ if let Some(sec) = cp.get(2) {+ let (whole, frac) = sec.split_once('.').unwrap_or((sec, ""));+ dt.second = num(whole)?.try_into().ok()?;+ dt = dt.with_subsec(frac);+ }+ if let Some(o) = off {+ dt.offset_minutes = Some(Self::parse_offset(o)?);+ }+ }+ dt.valid()+ }++ /// Exif form `YYYY:MM:DD HH:MM:SS`.+ pub fn to_exif(&self) -> String {+ format!("{:04}:{:02}:{:02} {:02}:{:02}:{:02}", self.year, self.month, self.day, self.hour, self.minute, self.second)+ }++ /// ISO 8601 with milliseconds when non-zero and the offset when known.+ pub fn to_iso(&self) -> String {+ let mut s = format!("{:04}-{:02}-{:02}T{:02}:{:02}:{:02}", self.year, self.month, self.day, self.hour, self.minute, self.second);+ if self.millis != 0 {+ s += &format!(".{:03}", self.millis);+ }+ if let Some(o) = self.offset_minutes {+ let sign = if o < 0 { '-' } else { '+' };+ s += &format!("{sign}{:02}:{:02}", o.abs() / 60, o.abs() % 60);+ }+ s+ }++ /// Seconds since 1970-01-01T00:00:00 of the civil time (UTC when the offset is known, else "local" seconds).+ pub fn unix_seconds(&self) -> i64 {+ // days from civil (proleptic Gregorian), Howard Hinnant's public-domain algorithm+ let (y, m, d) = (self.year as i64 - if self.month <= 2 { 1 } else { 0 }, self.month as i64, self.day as i64);+ let era = y.div_euclid(400);+ let yoe = y - era * 400;+ let doy = (153 * (m + if m > 2 { -3 } else { 9 }) + 2) / 5 + d - 1;+ let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;+ let days = era * 146097 + doe - 719468;+ days * 86400 + self.hour as i64 * 3600 + self.minute as i64 * 60 + self.second as i64 - self.offset_minutes.unwrap_or(0) as i64 * 60+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn exif_forms() {+ let d = DateTime::parse_exif("2024:06:01 13:45:59").unwrap();+ assert_eq!((d.year, d.month, d.day, d.hour, d.minute, d.second), (2024, 6, 1, 13, 45, 59));+ assert_eq!(d.to_exif(), "2024:06:01 13:45:59");+ assert!(DateTime::parse_exif("0000:00:00 00:00:00").is_none());+ assert!(DateTime::parse_exif(" : : : : ").is_none());+ assert!(DateTime::parse_exif("2024:13:01 00:00:00").is_none());+ assert_eq!(DateTime::parse_exif("2024-06-01").unwrap().hour, 0);+ assert_eq!(DateTime::parse_exif("2024:06:01 13:45:59").unwrap().with_subsec("5").millis, 500);+ assert_eq!(DateTime::parse_exif("2024:06:01 13:45:59").unwrap().with_subsec("0123").millis, 12);+ }++ #[test]+ fn offsets() {+ assert_eq!(DateTime::parse_offset("+02:00"), Some(120));+ assert_eq!(DateTime::parse_offset("-05:30"), Some(-330));+ assert_eq!(DateTime::parse_offset("Z"), Some(0));+ assert_eq!(DateTime::parse_offset("+0930"), Some(570));+ assert_eq!(DateTime::parse_offset(" : "), None);+ assert_eq!(DateTime::parse_offset("+99:00"), None);+ }++ #[test]+ fn iso_roundtrip() {+ for s in ["2024-06-01T13:45:59", "2024-06-01T13:45:59.250+02:00", "1999-12-31T23:59:00-05:30", "2024-02-29T00:00:00Z"] {+ let d = DateTime::parse_iso(s).unwrap();+ let again = DateTime::parse_iso(&d.to_iso()).unwrap();+ assert_eq!(d, again, "{s}");+ }+ assert_eq!(DateTime::parse_iso("2024-02-29T00:00:00Z").unwrap().to_iso(), "2024-02-29T00:00:00+00:00");+ let d = DateTime::parse_iso("2019").unwrap();+ assert_eq!((d.year, d.month, d.day), (2019, 1, 1));+ assert_eq!(DateTime::parse_iso("2019-07-04T10:11").unwrap().minute, 11);+ assert!(DateTime::parse_iso("nonsense").is_none());+ assert!(DateTime::parse_iso("2019-07-04Tab:cd").is_none());+ }++ #[test]+ fn unix() {+ assert_eq!(DateTime::parse_iso("1970-01-01T00:00:00Z").unwrap().unix_seconds(), 0);+ assert_eq!(DateTime::parse_iso("2000-03-01T00:00:00Z").unwrap().unix_seconds(), 951868800);+ assert_eq!(DateTime::parse_iso("2000-03-01T02:00:00+02:00").unwrap().unix_seconds(), 951868800);+ }+}diff --git a/crates/meta/src/exif.rs b/crates/meta/src/exif.rsnew file mode 100644index 000000000..a480c0491--- /dev/null+++ b/crates/meta/src/exif.rs@@ -0,0 +1,255 @@+//! Exif / TIFF tags → [`Metadata`] (CIPA DC-008 Exif 2.32, TIFF 6.0, DNG 1.7 tag semantics).++use crate::{DateTime, Flash, Gps, Metadata, Orientation};+use lightcraft_tiff::{Ifd, Tiff, TiffError, tags as t};++/// Strip an `Exif\0\0` (or `Exif\0\xff`) prefix as found in JPEG APP1 and some WebP `EXIF` chunks.+pub fn strip_exif_header(b: &[u8]) -> &[u8] {+ if b.len() >= 6 && &b[..4] == b"Exif" && b[4] == 0 { &b[6..] } else { b }+}++/// Read metadata from a TIFF-structured Exif block (a whole TIFF/DNG/raw file, or the payload of a JPEG APP1+/// Exif segment with or without the `Exif\0\0` prefix). Malformed input yields whatever could be read.+pub fn read_exif(bytes: &[u8]) -> Metadata {+ try_read_exif(bytes).unwrap_or_default()+}++/// Like [`read_exif`] but reports a structurally invalid TIFF header / IFD0.+pub fn try_read_exif(bytes: &[u8]) -> Result<Metadata, TiffError> {+ let tiff = Tiff::parse(strip_exif_header(bytes))?;+ Ok(from_tiff(&tiff))+}++fn text(ifd: Option<&Ifd>, tag: u16) -> Option<String> {+ let s = ifd?.string(tag)?;+ let s = s.trim().to_string();+ (!s.is_empty() && !s.bytes().all(|b| b == b' ' || b == 0)).then_some(s)+}++fn pos(v: Option<f64>) -> Option<f64> {+ v.filter(|x| x.is_finite() && *x > 0.0)+}++/// Build [`Metadata`] from a parsed TIFF stream (IFD0 + Exif + GPS; DNG tags as fallbacks).+pub fn from_tiff(tiff: &Tiff) -> Metadata {+ let ifd0 = tiff.ifds.first();+ let exif = tiff.exif();+ let gps = tiff.gps();+ let either = |tag: u16| exif.and_then(|e| e.value(tag)).or_else(|| ifd0.and_then(|i| i.value(tag)));+ let mut m = Metadata {+ make: text(ifd0, t::MAKE),+ model: text(ifd0, t::MODEL).or_else(|| text(ifd0, t::UNIQUE_CAMERA_MODEL)),+ software: text(ifd0, t::SOFTWARE),+ artist: text(ifd0, t::ARTIST),+ copyright: text(ifd0, t::COPYRIGHT),+ caption: text(ifd0, t::IMAGE_DESCRIPTION),+ serial_number: text(exif, t::BODY_SERIAL_NUMBER).or_else(|| text(ifd0, t::CAMERA_SERIAL_NUMBER)),+ lens_make: text(exif, t::LENS_MAKE),+ lens_model: text(exif, t::LENS_MODEL),+ lens_serial_number: text(exif, t::LENS_SERIAL_NUMBER),+ ..Default::default()+ };+ // Exif requires LensSpecification/LensInfo as 4 rationals.+ let spec = exif.and_then(|e| e.f64s(t::LENS_SPECIFICATION)).or_else(|| ifd0.and_then(|i| i.f64s(t::LENS_INFO)));+ if let Some(s) = spec.filter(|s| s.len() == 4 && s[0] > 0.0) {+ m.lens_spec = Some([s[0], s[1], s[2], s[3]]);+ }+ m.orientation = ifd0.and_then(|i| i.u16(t::ORIENTATION)).filter(|v| (1..=8).contains(v)).map(Orientation::from_exif);+ m.rating = ifd0.and_then(|i| i.i64(t::RATING)).map(|r| r.clamp(-1, 5) as i8);++ m.exposure_time = pos(either(t::EXPOSURE_TIME).and_then(|v| v.get_f64(0)))+ .or_else(|| exif.and_then(|e| e.f64(t::SHUTTER_SPEED_VALUE)).filter(|v| v.abs() < 64.0).map(|tv| 2f64.powf(-tv)));+ m.f_number = pos(either(t::F_NUMBER).and_then(|v| v.get_f64(0)))+ .or_else(|| exif.and_then(|e| e.f64(t::APERTURE_VALUE)).filter(|v| v.abs() < 64.0).map(|av| 2f64.powf(av / 2.0)));+ let iso = either(t::ISO_SPEED).and_then(|v| v.get_u64(0)).filter(|&v| v > 0);+ let iso_ext = exif.and_then(|e| e.u64(t::RECOMMENDED_EXPOSURE_INDEX).or_else(|| e.u64(t::ISO_SPEED_RATINGS_EXT))).filter(|&v| v > 0);+ m.iso = match (iso, iso_ext) {+ (Some(65535), Some(x)) | (None, Some(x)) => Some(x),+ (Some(v), _) => Some(v),+ _ => None,+ }+ .map(|v| v.min(u32::MAX as u64) as u32);+ m.focal_length = pos(either(t::FOCAL_LENGTH).and_then(|v| v.get_f64(0)));+ m.focal_length_35mm = pos(exif.and_then(|e| e.f64(t::FOCAL_LENGTH_35MM)));+ m.exposure_bias = exif.and_then(|e| e.f64(t::EXPOSURE_BIAS)).filter(|v| v.is_finite() && v.abs() < 100.0);+ m.exposure_program = exif.and_then(|e| e.u16(t::EXPOSURE_PROGRAM));+ m.metering_mode = exif.and_then(|e| e.u16(t::METERING_MODE));+ m.white_balance = exif.and_then(|e| e.u16(t::WHITE_BALANCE));+ m.flash = exif.and_then(|e| e.u16(t::FLASH)).map(|raw| Flash { fired: raw & 1 != 0, raw });++ // capture time: DateTimeOriginal, then DateTimeDigitized, then IFD0 DateTime+ let candidates = [+ (exif, t::DATE_TIME_ORIGINAL, t::OFFSET_TIME_ORIGINAL, t::SUBSEC_TIME_ORIGINAL),+ (exif, t::DATE_TIME_DIGITIZED, t::OFFSET_TIME_DIGITIZED, t::SUBSEC_TIME_DIGITIZED),+ (ifd0, t::DATE_TIME, t::OFFSET_TIME, t::SUBSEC_TIME),+ ];+ for (ifd, dt_tag, off_tag, sub_tag) in candidates {+ if let Some(mut dt) = text(ifd, dt_tag).and_then(|s| DateTime::parse_exif(&s)) {+ if let Some(s) = text(exif, sub_tag) {+ dt = dt.with_subsec(&s);+ }+ dt.offset_minutes = text(exif, off_tag).and_then(|s| DateTime::parse_offset(&s));+ m.capture_time = Some(dt);+ break;+ }+ }++ m.width = exif.and_then(|e| e.u32(t::PIXEL_X_DIMENSION)).filter(|&v| v > 0).or_else(|| ifd0.and_then(|i| i.u32(t::IMAGE_WIDTH)));+ m.height = exif.and_then(|e| e.u32(t::PIXEL_Y_DIMENSION)).filter(|&v| v > 0).or_else(|| ifd0.and_then(|i| i.u32(t::IMAGE_LENGTH)));++ m.gps = gps.and_then(read_gps);+ if let Some(iptc) = ifd0.and_then(|i| i.value(t::IPTC_NAA)) {+ // IPTC-NAA is often typed LONG; re-serialise to bytes in file order.+ let bytes = match iptc {+ lightcraft_tiff::Value::Byte(b) | lightcraft_tiff::Value::Undefined(b) => b.clone(),+ other => lightcraft_tiff::writer::encode(tiff.order, other),+ };+ m.fill_missing(&crate::parse_iptc(&bytes));+ }+ if let Some(x) = ifd0.and_then(|i| i.bytes(t::XMP)).map(String::from_utf8_lossy)+ && let Ok(x) = crate::parse_xmp(&x)+ {+ m.overlay_user_fields(&x.metadata);+ m.fill_missing(&x.metadata);+ }+ m+}++fn dms(ifd: &Ifd, tag: u16) -> Option<f64> {+ let v = ifd.f64s(tag)?;+ let d = *v.first()?;+ let deg = d + v.get(1).copied().unwrap_or(0.0) / 60.0 + v.get(2).copied().unwrap_or(0.0) / 3600.0;+ deg.is_finite().then_some(deg)+}++fn read_gps(g: &Ifd) -> Option<Gps> {+ let mut lat = dms(g, t::GPS_LATITUDE)?;+ let mut lon = dms(g, t::GPS_LONGITUDE)?;+ if g.string(t::GPS_LATITUDE_REF).is_some_and(|s| s.starts_with('S')) {+ lat = -lat;+ }+ if g.string(t::GPS_LONGITUDE_REF).is_some_and(|s| s.starts_with('W')) {+ lon = -lon;+ }+ if !(-90.0..=90.0).contains(&lat) || !(-180.0..=180.0).contains(&lon) {+ return None;+ }+ let altitude = g.f64(t::GPS_ALTITUDE).filter(|a| a.is_finite()).map(|a| if g.u32(t::GPS_ALTITUDE_REF) == Some(1) { -a } else { a });+ Some(Gps { latitude: lat, longitude: lon, altitude })+}++#[cfg(test)]+pub(crate) mod tests {+ use super::*;+ use lightcraft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value};++ pub(crate) fn sample_exif(order: ByteOrder) -> Vec<u8> {+ let mut exif = IfdBuilder::new();+ exif.set(t::EXPOSURE_TIME, Value::Rational(vec![(1, 250)]));+ exif.set(t::F_NUMBER, Value::Rational(vec![(28, 10)]));+ exif.set(t::ISO_SPEED, Value::Short(vec![400]));+ exif.set(t::DATE_TIME_ORIGINAL, Value::Ascii("2023:07:14 18:30:05".into()));+ exif.set(t::OFFSET_TIME_ORIGINAL, Value::Ascii("+02:00".into()));+ exif.set(t::SUBSEC_TIME_ORIGINAL, Value::Ascii("42".into()));+ exif.set(t::EXPOSURE_BIAS, Value::SRational(vec![(-2, 3)]));+ exif.set(t::METERING_MODE, Value::Short(vec![5]));+ exif.set(t::FLASH, Value::Short(vec![0x19]));+ exif.set(t::FOCAL_LENGTH, Value::Rational(vec![(50, 1)]));+ exif.set(t::FOCAL_LENGTH_35MM, Value::Short(vec![75]));+ exif.set(t::WHITE_BALANCE, Value::Short(vec![0]));+ exif.set(t::EXPOSURE_PROGRAM, Value::Short(vec![3]));+ exif.set(t::LENS_MAKE, Value::Ascii("LensCo".into()));+ exif.set(t::LENS_MODEL, Value::Ascii("50mm F1.8".into()));+ exif.set(t::BODY_SERIAL_NUMBER, Value::Ascii("12345".into()));+ exif.set(t::LENS_SPECIFICATION, Value::Rational(vec![(50, 1), (50, 1), (18, 10), (18, 10)]));+ exif.set(t::PIXEL_X_DIMENSION, Value::Long(vec![6000]));+ exif.set(t::PIXEL_Y_DIMENSION, Value::Long(vec![4000]));+ let mut gps = IfdBuilder::new();+ gps.set(t::GPS_LATITUDE_REF, Value::Ascii("S".into()));+ gps.set(t::GPS_LATITUDE, Value::Rational(vec![(33, 1), (51, 1), (3564, 100)]));+ gps.set(t::GPS_LONGITUDE_REF, Value::Ascii("E".into()));+ gps.set(t::GPS_LONGITUDE, Value::Rational(vec![(151, 1), (12, 1), (4032, 100)]));+ gps.set(t::GPS_ALTITUDE_REF, Value::Byte(vec![1]));+ gps.set(t::GPS_ALTITUDE, Value::Rational(vec![(125, 10)]));+ let mut ifd0 = IfdBuilder::new();+ ifd0.set(t::MAKE, Value::Ascii("Maker Inc.".into()));+ ifd0.set(t::MODEL, Value::Ascii("Model X ".into()));+ ifd0.set(t::ORIENTATION, Value::Short(vec![6]));+ ifd0.set(t::ARTIST, Value::Ascii("Jane".into()));+ ifd0.set(t::COPYRIGHT, Value::Ascii("(c) Jane".into()));+ ifd0.set(t::RATING, Value::Short(vec![3]));+ ifd0.set_child(t::EXIF_IFD, exif);+ ifd0.set_child(t::GPS_IFD, gps);+ TiffWriter::new(order, false).write(&[ifd0]).unwrap()+ }++ #[test]+ fn reads_all_fields() {+ for order in [ByteOrder::Little, ByteOrder::Big] {+ let m = read_exif(&sample_exif(order));+ assert_eq!(m.make.as_deref(), Some("Maker Inc."));+ assert_eq!(m.model.as_deref(), Some("Model X"));+ assert_eq!(m.exposure_time, Some(0.004));+ assert_eq!(m.f_number, Some(2.8));+ assert_eq!(m.iso, Some(400));+ let dt = m.capture_time.unwrap();+ assert_eq!(dt.to_iso(), "2023-07-14T18:30:05.420+02:00");+ assert!((m.exposure_bias.unwrap() + 0.6667).abs() < 1e-3);+ assert_eq!(m.metering_mode, Some(5));+ assert_eq!(m.flash, Some(Flash { fired: true, raw: 0x19 }));+ assert_eq!(m.focal_length, Some(50.0));+ assert_eq!(m.focal_length_35mm, Some(75.0));+ assert_eq!(m.orientation, Some(Orientation::Rotate90));+ assert_eq!(m.lens_model.as_deref(), Some("50mm F1.8"));+ assert_eq!(m.lens_make.as_deref(), Some("LensCo"));+ assert_eq!(m.serial_number.as_deref(), Some("12345"));+ assert_eq!(m.lens_spec, Some([50.0, 50.0, 1.8, 1.8]));+ assert_eq!((m.width, m.height), (Some(6000), Some(4000)));+ assert_eq!(m.artist.as_deref(), Some("Jane"));+ assert_eq!(m.rating, Some(3));+ let g = m.gps.unwrap();+ assert!((g.latitude + 33.8599).abs() < 1e-4, "{g:?}");+ assert!((g.longitude - 151.2112).abs() < 1e-4);+ assert_eq!(g.altitude, Some(-12.5));+ }+ }++ #[test]+ fn exif_prefix_and_garbage() {+ let mut b = b"Exif\0\0".to_vec();+ b.extend(sample_exif(ByteOrder::Little));+ assert_eq!(read_exif(&b).iso, Some(400));+ assert_eq!(read_exif(b"garbage"), Metadata::default());+ assert!(try_read_exif(b"garbage").is_err());+ }++ #[test]+ fn apex_fallbacks_and_extended_iso() {+ let mut exif = IfdBuilder::new();+ exif.set(t::SHUTTER_SPEED_VALUE, Value::SRational(vec![(8, 1)]));+ exif.set(t::APERTURE_VALUE, Value::Rational(vec![(4, 1)]));+ exif.set(t::ISO_SPEED, Value::Short(vec![65535]));+ exif.set(t::RECOMMENDED_EXPOSURE_INDEX, Value::Long(vec![102400]));+ let mut ifd0 = IfdBuilder::new();+ ifd0.set(t::DATE_TIME, Value::Ascii("2020:01:02 03:04:05".into()));+ ifd0.set_child(t::EXIF_IFD, exif);+ let m = read_exif(&TiffWriter::default().write(&[ifd0]).unwrap());+ assert_eq!(m.exposure_time, Some(1.0 / 256.0));+ assert_eq!(m.f_number, Some(4.0));+ assert_eq!(m.iso, Some(102400));+ assert_eq!(m.capture_time.unwrap().to_exif(), "2020:01:02 03:04:05");+ }++ #[test]+ fn xmp_in_ifd0_overrides_user_fields() {+ let mut meta = Metadata { rating: Some(5), title: Some("From XMP".into()), ..Default::default() };+ meta.keywords = vec!["a".into()];+ let x = crate::write_xmp(&meta, None);+ let mut ifd0 = IfdBuilder::new();+ ifd0.set(t::RATING, Value::Short(vec![1]));+ ifd0.set(t::XMP, Value::Byte(x.into_bytes()));+ let m = read_exif(&TiffWriter::default().write(&[ifd0]).unwrap());+ assert_eq!(m.rating, Some(5));+ assert_eq!(m.title.as_deref(), Some("From XMP"));+ }+}diff --git a/crates/meta/src/iptc.rs b/crates/meta/src/iptc.rsnew file mode 100644index 000000000..24955748f--- /dev/null+++ b/crates/meta/src/iptc.rs@@ -0,0 +1,124 @@+//! IPTC-IIM (Information Interchange Model 4.2) — the record-2 datasets people still carry in JPEGs.+//!+//! Stream of `0x1C record dataset size(u16 BE, or extended) data` tags. Text is UTF-8 when the record-1+//! `CodedCharacterSet` (1:90) is `ESC % G`, otherwise decoded as UTF-8 when valid and Latin-1 otherwise.++use crate::{DateTime, Metadata};++fn decode(b: &[u8], utf8: bool) -> String {+ match std::str::from_utf8(b) {+ Ok(s) => s.trim_end_matches('\0').trim().to_string(),+ Err(_) if utf8 => String::from_utf8_lossy(b).trim().to_string(),+ Err(_) => b.iter().map(|&c| c as char).collect::<String>().trim().to_string(),+ }+}++/// Parse an IIM stream into the fields [`Metadata`] carries (title, keywords, artist, copyright, caption,+/// creation date/time).+pub fn parse_iptc(b: &[u8]) -> Metadata {+ let mut m = Metadata::default();+ let mut utf8 = false;+ let mut date: Option<String> = None;+ let mut time: Option<String> = None;+ let mut i = 0usize;+ while i + 5 <= b.len() {+ if b[i] != 0x1c {+ break;+ }+ let (rec, ds) = (b[i + 1], b[i + 2]);+ let mut size = u16::from_be_bytes([b[i + 3], b[i + 4]]) as usize;+ let mut at = i + 5;+ if size & 0x8000 != 0 {+ // extended dataset: next (size & 0x7fff) bytes hold the length+ let n = size & 0x7fff;+ if n == 0 || n > 4 || at + n > b.len() {+ break;+ }+ size = b[at..at + n].iter().fold(0usize, |a, &c| (a << 8) | c as usize);+ at += n;+ }+ let Some(data) = b.get(at..at.saturating_add(size)) else { break };+ match (rec, ds) {+ (1, 90) => utf8 = data == b"\x1b%G",+ (2, 5) => m.title = Some(decode(data, utf8)).filter(|s| !s.is_empty()),+ (2, 25) => {+ let k = decode(data, utf8);+ if !k.is_empty() && !m.keywords.contains(&k) {+ m.keywords.push(k);+ }+ }+ (2, 80) => m.artist = Some(decode(data, utf8)).filter(|s| !s.is_empty()),+ (2, 116) => m.copyright = Some(decode(data, utf8)).filter(|s| !s.is_empty()),+ (2, 120) => m.caption = Some(decode(data, utf8)).filter(|s| !s.is_empty()),+ (2, 55) => date = Some(decode(data, utf8)),+ (2, 60) => time = Some(decode(data, utf8)),+ _ => {}+ }+ i = at + size;+ }+ if let Some(d) = date.filter(|d| d.len() == 8 && d.bytes().all(|c| c.is_ascii_digit())) {+ let mut s = format!("{}-{}-{}", &d[..4], &d[4..6], &d[6..8]);+ if let Some(t) = time.filter(|t| t.is_ascii() && t.len() >= 6 && t[..6].bytes().all(|c| c.is_ascii_digit())) {+ s += &format!("T{}:{}:{}", &t[..2], &t[2..4], &t[4..6]);+ if t.len() >= 11 {+ s += &format!("{}:{}", &t[6..9], &t[9..11]);+ }+ }+ m.capture_time = DateTime::parse_iso(&s);+ }+ m+}++#[cfg(test)]+pub(crate) mod tests {+ use super::*;++ fn ds(out: &mut Vec<u8>, rec: u8, ds: u8, data: &[u8]) {+ out.extend_from_slice(&[0x1c, rec, ds]);+ out.extend_from_slice(&(data.len() as u16).to_be_bytes());+ out.extend_from_slice(data);+ }++ pub(crate) fn sample_iim() -> Vec<u8> {+ let mut v = Vec::new();+ ds(&mut v, 1, 90, b"\x1b%G");+ ds(&mut v, 2, 0, &[0, 4]);+ ds(&mut v, 2, 5, "Tïtle".as_bytes());+ ds(&mut v, 2, 25, b"alpha");+ ds(&mut v, 2, 25, b"beta");+ ds(&mut v, 2, 25, b"alpha");+ ds(&mut v, 2, 80, b"Photographer");+ ds(&mut v, 2, 116, b"CC0");+ ds(&mut v, 2, 120, b"A caption");+ ds(&mut v, 2, 55, b"20210304");+ ds(&mut v, 2, 60, b"101112+0100");+ v+ }++ #[test]+ fn parses_record2() {+ let m = parse_iptc(&sample_iim());+ assert_eq!(m.title.as_deref(), Some("Tïtle"));+ assert_eq!(m.keywords, vec!["alpha".to_string(), "beta".to_string()]);+ assert_eq!(m.artist.as_deref(), Some("Photographer"));+ assert_eq!(m.copyright.as_deref(), Some("CC0"));+ assert_eq!(m.caption.as_deref(), Some("A caption"));+ assert_eq!(m.capture_time.unwrap().to_iso(), "2021-03-04T10:11:12+01:00");+ }++ #[test]+ fn latin1_and_extended_and_garbage() {+ let mut v = Vec::new();+ ds(&mut v, 2, 5, &[0x43, 0xe9]); // "Cé" in Latin-1+ v.extend_from_slice(&[0x1c, 2, 120, 0x80, 0x02, 0x00, 0x03]);+ v.extend_from_slice(b"abc");+ let m = parse_iptc(&v);+ assert_eq!(m.title.as_deref(), Some("Cé"));+ assert_eq!(m.caption.as_deref(), Some("abc"));+ let s = sample_iim();+ for n in 0..s.len() {+ let _ = parse_iptc(&s[..n]);+ }+ assert_eq!(parse_iptc(&[0x1c, 2, 5, 0xff, 0xff]), Metadata::default());+ }+}diff --git a/crates/meta/src/lib.rs b/crates/meta/src/lib.rsindex 45278f224..936fb21eb 100644--- a/crates/meta/src/lib.rs+++ b/crates/meta/src/lib.rs@@ -1 +1,274 @@+//! Photo metadata for LightCraft: EXIF (TIFF/raw files, JPEG APP1, PNG `eXIf`, WebP `EXIF`), XMP packets+//! (read + write, standard namespaces plus our own `lc:` namespace) and basic IPTC-IIM.+//!+//! Entry points:+//! - [`read_exif`] — a TIFF-structured Exif block → [`Metadata`]; [`from_tiff`] for an already parsed stream.+//! - [`embedded`] / [`jpeg_segments`] / [`png_chunks`] / [`webp_chunks`] — locate Exif / XMP / ICC / IPTC blocks.+//! - [`parse_xmp`] / [`write_xmp`] — XMP packets (interchange fields + the opaque `lc:settings` JSON).+//! - [`parse_iptc`] — IPTC-IIM record 2 datasets.+//! - [`extract`] — all of the above for a whole file (JPEG, PNG, WebP, TIFF/DNG/raw).#![forbid(unsafe_code)]++mod container;+mod datetime;+mod exif;+mod iptc;+mod xmp;++pub use container::{Embedded, embedded, jpeg_segments, png_chunks, webp_chunks};+pub use datetime::DateTime;+pub use exif::{from_tiff, read_exif, strip_exif_header, try_read_exif};+pub use iptc::parse_iptc;+pub use lightcraft_geom::Orientation;+pub use xmp::{LC_NS, XmpData, XmpError, parse_xmp, write_xmp};++use serde::{Deserialize, Serialize};++/// GPS position (WGS 84). Latitude/longitude in signed decimal degrees (north / east positive).+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]+pub struct Gps {+ pub latitude: f64,+ pub longitude: f64,+ /// Metres above sea level (negative below).+ pub altitude: Option<f64>,+}++/// Exif `Flash` value decoded.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+pub struct Flash {+ pub fired: bool,+ /// The raw Exif `Flash` bit field.+ pub raw: u16,+}++/// Everything LightCraft shows or searches about a photo. All fields are optional; unknown = `None`/empty.+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+pub struct Metadata {+ // camera+ pub make: Option<String>,+ pub model: Option<String>,+ pub serial_number: Option<String>,+ pub software: Option<String>,+ // lens+ pub lens_make: Option<String>,+ pub lens_model: Option<String>,+ pub lens_serial_number: Option<String>,+ /// Min/max focal length (mm) and min/max f-number at those, as in Exif `LensSpecification`.+ pub lens_spec: Option<[f64; 4]>,+ // capture+ pub capture_time: Option<DateTime>,+ /// Seconds.+ pub exposure_time: Option<f64>,+ pub f_number: Option<f64>,+ pub iso: Option<u32>,+ /// Millimetres.+ pub focal_length: Option<f64>,+ pub focal_length_35mm: Option<f64>,+ pub flash: Option<Flash>,+ /// EV.+ pub exposure_bias: Option<f64>,+ /// Exif `ExposureProgram` code.+ pub exposure_program: Option<u16>,+ /// Exif `MeteringMode` code.+ pub metering_mode: Option<u16>,+ /// Exif `WhiteBalance` (0 auto, 1 manual).+ pub white_balance: Option<u16>,+ pub orientation: Option<Orientation>,+ pub gps: Option<Gps>,+ /// Pixel dimensions as recorded (not oriented).+ pub width: Option<u32>,+ pub height: Option<u32>,+ // descriptive / user+ pub artist: Option<String>,+ pub copyright: Option<String>,+ pub title: Option<String>,+ pub caption: Option<String>,+ pub keywords: Vec<String>,+ /// Hierarchical keywords, `|`-separated paths (`lr:hierarchicalSubject` convention).+ pub hierarchical_keywords: Vec<String>,+ /// -1 = rejected, 0 = unrated, 1..=5 stars.+ pub rating: Option<i8>,+ /// Colour label name (e.g. "Red").+ pub label: Option<String>,+}++macro_rules! fill {+ ($self:ident, $o:ident, $($f:ident),*) => { $( if $self.$f.is_none() { $self.$f = $o.$f.clone(); } )* };+}+macro_rules! overlay {+ ($self:ident, $o:ident, $($f:ident),*) => { $( if $o.$f.is_some() { $self.$f = $o.$f.clone(); } )* };+}++impl Metadata {+ /// Fill every empty field of `self` from `other`.+ pub fn fill_missing(&mut self, other: &Metadata) {+ fill!(+ self,+ other,+ make,+ model,+ serial_number,+ software,+ lens_make,+ lens_model,+ lens_serial_number,+ lens_spec,+ capture_time,+ exposure_time,+ f_number,+ iso,+ focal_length,+ focal_length_35mm,+ flash,+ exposure_bias,+ exposure_program,+ metering_mode,+ white_balance,+ orientation,+ gps,+ width,+ height,+ artist,+ copyright,+ title,+ caption,+ rating,+ label+ );+ if self.keywords.is_empty() {+ self.keywords = other.keywords.clone();+ }+ if self.hierarchical_keywords.is_empty() {+ self.hierarchical_keywords = other.hierarchical_keywords.clone();+ }+ }++ /// Replace the user-editable fields (rating, label, title, caption, artist, copyright, keywords, GPS) with+ /// `other`'s where `other` has them — the XMP-over-EXIF precedence rule.+ pub fn overlay_user_fields(&mut self, other: &Metadata) {+ overlay!(self, other, rating, label, title, caption, artist, copyright, gps);+ if !other.keywords.is_empty() {+ self.keywords = other.keywords.clone();+ }+ if !other.hierarchical_keywords.is_empty() {+ self.hierarchical_keywords = other.hierarchical_keywords.clone();+ }+ }++ /// Exposure time formatted like cameras show it: `1/250`, `0.5`, `2″`.+ pub fn exposure_display(&self) -> Option<String> {+ let t = self.exposure_time?;+ if t.is_nan() || t <= 0.0 {+ return None;+ }+ Some(if t < 0.3 {+ format!("1/{}", (1.0 / t).round())+ } else if t < 1.0 {+ format!("{}", (t * 10.0).round() / 10.0)+ } else {+ format!("{}″", (t * 10.0).round() / 10.0)+ })+ }++ /// Human name of the metering mode.+ pub fn metering_name(&self) -> Option<&'static str> {+ Some(match self.metering_mode? {+ 1 => "Average",+ 2 => "Center-weighted average",+ 3 => "Spot",+ 4 => "Multi-spot",+ 5 => "Pattern",+ 6 => "Partial",+ 255 => "Other",+ _ => "Unknown",+ })+ }++ /// Human name of the exposure program.+ pub fn exposure_program_name(&self) -> Option<&'static str> {+ Some(match self.exposure_program? {+ 1 => "Manual",+ 2 => "Program AE",+ 3 => "Aperture-priority AE",+ 4 => "Shutter speed priority AE",+ 5 => "Creative (slow speed)",+ 6 => "Action (high speed)",+ 7 => "Portrait",+ 8 => "Landscape",+ 9 => "Bulb",+ _ => "Not defined",+ })+ }+}++/// Read everything we understand from a whole file (JPEG, PNG, WebP, TIFF-based incl. DNG/raw).+/// Precedence: EXIF, then IPTC fills gaps, then XMP overrides user fields and fills the rest.+pub fn extract(bytes: &[u8]) -> Metadata {+ let e = embedded(bytes);+ let mut m = e.exif.as_deref().map(read_exif).unwrap_or_default();+ if let Some(i) = e.iptc.as_deref() {+ m.fill_missing(&parse_iptc(i));+ }+ if let Some(x) = e.xmp.as_deref().and_then(|x| parse_xmp(x).ok()) {+ m.overlay_user_fields(&x.metadata);+ m.fill_missing(&x.metadata);+ }+ m+}++/// Lenient number parsing used by XMP/IPTC: `"28/10"`, `"2.8"`, `"+0.7"`.+pub(crate) fn parse_number(s: &str) -> Option<f64> {+ let s = s.trim();+ if let Some((n, d)) = s.split_once('/') {+ let (n, d) = (n.trim().parse::<f64>().ok()?, d.trim().parse::<f64>().ok()?);+ return (d != 0.0).then_some(n / d).filter(|v| v.is_finite());+ }+ s.parse::<f64>().ok().filter(|v| v.is_finite())+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn numbers() {+ assert_eq!(parse_number("28/10"), Some(2.8));+ assert_eq!(parse_number(" +0.7 "), Some(0.7));+ assert_eq!(parse_number("1/0"), None);+ assert_eq!(parse_number("abc"), None);+ assert_eq!(parse_number("inf"), None);+ }++ #[test]+ fn exposure_display() {+ let mut m = Metadata { exposure_time: Some(1.0 / 250.0), ..Default::default() };+ assert_eq!(m.exposure_display().as_deref(), Some("1/250"));+ m.exposure_time = Some(0.5);+ assert_eq!(m.exposure_display().as_deref(), Some("0.5"));+ m.exposure_time = Some(2.0);+ assert_eq!(m.exposure_display().as_deref(), Some("2″"));+ m.exposure_time = Some(0.0);+ assert_eq!(m.exposure_display(), None);+ }++ #[test]+ fn merge_rules() {+ let mut a = Metadata { make: Some("A".into()), rating: Some(1), ..Default::default() };+ let b = Metadata { make: Some("B".into()), model: Some("M".into()), rating: Some(4), keywords: vec!["k".into()], ..Default::default() };+ a.fill_missing(&b);+ assert_eq!(a.make.as_deref(), Some("A"));+ assert_eq!(a.model.as_deref(), Some("M"));+ assert_eq!(a.rating, Some(1));+ a.overlay_user_fields(&b);+ assert_eq!(a.rating, Some(4));+ assert_eq!(a.make.as_deref(), Some("A"));+ assert_eq!(a.keywords, vec!["k".to_string()]);+ }++ #[test]+ fn names() {+ let m = Metadata { metering_mode: Some(5), exposure_program: Some(3), ..Default::default() };+ assert_eq!(m.metering_name(), Some("Pattern"));+ assert_eq!(m.exposure_program_name(), Some("Aperture-priority AE"));+ }+}diff --git a/crates/meta/src/xmp.rs b/crates/meta/src/xmp.rsnew file mode 100644index 000000000..3fa3c7e31--- /dev/null+++ b/crates/meta/src/xmp.rs@@ -0,0 +1,611 @@+//! XMP packets (ISO 16684-1 / Adobe XMP Specification Part 1–2): read and write.+//!+//! Reading builds a small namespace-resolved tree with `quick-xml`, then collects every property of every+//! `rdf:Description` (attribute form, element form, `rdf:Seq`/`rdf:Bag`/`rdf:Alt` arrays, `rdf:parseType="Resource"`+//! and nested-description structs, flattened as `parent/field`). Prefixes are canonicalised by namespace URI, so+//! a packet that binds `http://purl.org/dc/elements/1.1/` to `foo:` still yields `dc:title`.+//!+//! Writing emits the interchange subset in standard namespaces (dc, xmp, photoshop, exif, exifEX, tiff, lr) and+//! LightCraft's full develop settings as an opaque JSON string in `lc:settings`.++use crate::{DateTime, Flash, Gps, Metadata, Orientation, parse_number};+use quick_xml::escape::escape;+use quick_xml::events::Event;+use std::collections::BTreeMap;++/// LightCraft's XMP namespace URI (prefix `lc`).+pub const LC_NS: &str = "http://ns.lightcraft.app/lc/1.0/";++const NAMESPACES: &[(&str, &str)] = &[+ ("x", "adobe:ns:meta/"),+ ("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"),+ ("dc", "http://purl.org/dc/elements/1.1/"),+ ("xmp", "http://ns.adobe.com/xap/1.0/"),+ ("xmpRights", "http://ns.adobe.com/xap/1.0/rights/"),+ ("photoshop", "http://ns.adobe.com/photoshop/1.0/"),+ ("exif", "http://ns.adobe.com/exif/1.0/"),+ ("exifEX", "http://cipa.jp/exif/1.0/"),+ ("tiff", "http://ns.adobe.com/tiff/1.0/"),+ ("aux", "http://ns.adobe.com/exif/1.0/aux/"),+ ("lr", "http://ns.adobe.com/lightroom/1.0/"),+ ("Iptc4xmpCore", "http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/"),+ ("lc", LC_NS),+];++/// XMP read failure.+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum XmpError {+ Xml(String),+ /// Nesting / size limits exceeded.+ TooComplex,+}++impl std::fmt::Display for XmpError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ XmpError::Xml(e) => write!(f, "XMP is not well-formed XML: {e}"),+ XmpError::TooComplex => write!(f, "XMP packet too deeply nested or too large"),+ }+ }+}++impl std::error::Error for XmpError {}++/// Result of [`parse_xmp`].+#[derive(Clone, Debug, Default, PartialEq)]+pub struct XmpData {+ pub metadata: Metadata,+ /// The opaque `lc:settings` JSON string, if present.+ pub lc_settings: Option<String>,+ /// Every property found, keyed `prefix:name` (struct fields as `prefix:name/prefix:field`); arrays keep+ /// item order, language alternatives put `x-default` first.+ pub properties: BTreeMap<String, Vec<String>>,+}++#[derive(Debug, Default)]+struct Node {+ name: String,+ attrs: Vec<(String, String)>,+ children: Vec<Node>,+ text: String,+}++impl Node {+ fn attr(&self, n: &str) -> Option<&str> {+ self.attrs.iter().find(|(k, _)| k == n).map(|(_, v)| v.as_str())+ }+}++const MAX_DEPTH: usize = 64;+const MAX_NODES: usize = 200_000;++fn canonical(qname: &str, scopes: &[Vec<(String, String)>]) -> String {+ let (prefix, local) = qname.split_once(':').unwrap_or(("", qname));+ if prefix == "xml" || prefix == "xmlns" {+ return qname.to_string();+ }+ let uri = scopes.iter().rev().flat_map(|s| s.iter().rev()).find(|(p, _)| p == prefix).map(|(_, u)| u.as_str());+ match uri {+ Some(u) => match NAMESPACES.iter().find(|(_, nu)| *nu == u) {+ Some((p, _)) => format!("{p}:{local}"),+ None if prefix.is_empty() => local.to_string(),+ None => qname.to_string(),+ },+ None => qname.to_string(),+ }+}++fn entity(name: &str) -> Option<char> {+ Some(match name {+ "lt" => '<',+ "gt" => '>',+ "amp" => '&',+ "quot" => '"',+ "apos" => '\'',+ _ => {+ let n = name.strip_prefix('#')?;+ let v = match n.strip_prefix(['x', 'X']) {+ Some(h) => u32::from_str_radix(h, 16).ok()?,+ None => n.parse().ok()?,+ };+ char::from_u32(v)?+ }+ })+}++/// Unescape attribute values (predefined + numeric references; unknown references kept verbatim).+fn unescape_attr(s: &str) -> String {+ let mut out = String::with_capacity(s.len());+ let mut rest = s;+ while let Some(i) = rest.find('&') {+ out.push_str(&rest[..i]);+ rest = &rest[i..];+ match rest.find(';').and_then(|j| entity(&rest[1..j]).map(|c| (c, j))) {+ Some((c, j)) => {+ out.push(c);+ rest = &rest[j + 1..];+ }+ None => {+ out.push('&');+ rest = &rest[1..];+ }+ }+ }+ out.push_str(rest);+ out+}++fn parse_tree(s: &str) -> Result<Node, XmpError> {+ let mut reader = quick_xml::Reader::from_str(s);+ reader.config_mut().check_end_names = false;+ let mut stack: Vec<Node> = vec![Node { name: "#root".into(), ..Default::default() }];+ let mut scopes: Vec<Vec<(String, String)>> = vec![vec![("xml".into(), "http://www.w3.org/XML/1998/namespace".into())]];+ let mut count = 0usize;+ loop {+ let ev = reader.read_event().map_err(|e| XmpError::Xml(e.to_string()))?;+ match ev {+ Event::Start(ref e) | Event::Empty(ref e) => {+ count += 1;+ if count > MAX_NODES || stack.len() > MAX_DEPTH {+ return Err(XmpError::TooComplex);+ }+ let mut scope = Vec::new();+ let mut raw_attrs = Vec::new();+ for a in e.attributes().with_checks(false).flatten() {+ let k = String::from_utf8_lossy(a.key.as_ref()).into_owned();+ let v = unescape_attr(&String::from_utf8_lossy(&a.value));+ if k == "xmlns" {+ scope.push((String::new(), v));+ } else if let Some(p) = k.strip_prefix("xmlns:") {+ scope.push((p.to_string(), v));+ } else {+ raw_attrs.push((k, v));+ }+ }+ scopes.push(scope);+ let name = canonical(&String::from_utf8_lossy(e.name().as_ref()), &scopes);+ let attrs = raw_attrs.into_iter().map(|(k, v)| (canonical(&k, &scopes), v)).collect();+ let node = Node { name, attrs, ..Default::default() };+ if matches!(ev, Event::Empty(_)) {+ scopes.pop();+ if let Some(parent) = stack.last_mut() {+ parent.children.push(node);+ }+ } else {+ stack.push(node);+ }+ }+ Event::End(_) => {+ if stack.len() > 1 {+ let n = stack.pop().expect("len > 1");+ scopes.pop();+ if let Some(parent) = stack.last_mut() {+ parent.children.push(n);+ }+ }+ }+ Event::Text(t) => {+ if let Some(top) = stack.last_mut() {+ top.text.push_str(&t.decode().map_err(|e| XmpError::Xml(e.to_string()))?);+ }+ }+ Event::CData(t) => {+ if let Some(top) = stack.last_mut() {+ top.text.push_str(&String::from_utf8_lossy(&t));+ }+ }+ Event::GeneralRef(r) => {+ let name = String::from_utf8_lossy(&r).into_owned();+ if let Some(top) = stack.last_mut() {+ match entity(&name) {+ Some(c) => top.text.push(c),+ None => {+ top.text.push('&');+ top.text.push_str(&name);+ top.text.push(';');+ }+ }+ }+ }+ Event::Eof => break,+ _ => {}+ }+ }+ // close unterminated elements leniently+ while stack.len() > 1 {+ let n = stack.pop().expect("len > 1");+ stack.last_mut().expect("root").children.push(n);+ }+ Ok(stack.pop().expect("root"))+}++fn is_rdf_meta_attr(k: &str) -> bool {+ matches!(k, "rdf:about" | "rdf:ID" | "rdf:nodeID" | "xml:lang" | "rdf:parseType" | "rdf:resource" | "rdf:datatype") || k.starts_with("xmlns")+}++fn collect_description(d: &Node, prefix: &str, props: &mut BTreeMap<String, Vec<String>>) {+ for (k, v) in &d.attrs {+ if !is_rdf_meta_attr(k) {+ props.entry(format!("{prefix}{k}")).or_default().push(v.clone());+ }+ }+ for c in &d.children {+ collect_property(c, prefix, props);+ }+}++fn collect_property(p: &Node, prefix: &str, props: &mut BTreeMap<String, Vec<String>>) {+ let key = format!("{prefix}{}", p.name);+ if let Some(arr) = p.children.iter().find(|c| matches!(c.name.as_str(), "rdf:Seq" | "rdf:Bag" | "rdf:Alt")) {+ let mut items: Vec<(bool, String)> = arr+ .children+ .iter()+ .filter(|li| li.name == "rdf:li")+ .map(|li| {+ (li.attr("xml:lang") == Some("x-default"), li.attr("rdf:resource").map(str::to_string).unwrap_or_else(|| li.text.trim().to_string()))+ })+ .collect();+ if arr.name == "rdf:Alt" {+ items.sort_by_key(|(default, _)| !*default);+ }+ props.entry(key).or_default().extend(items.into_iter().map(|(_, v)| v));+ return;+ }+ let struct_prefix = format!("{key}/");+ if p.attr("rdf:parseType") == Some("Resource") {+ for c in &p.children {+ collect_property(c, &struct_prefix, props);+ }+ return;+ }+ if let Some(d) = p.children.iter().find(|c| c.name == "rdf:Description") {+ collect_description(d, &struct_prefix, props);+ return;+ }+ let field_attrs: Vec<&(String, String)> = p.attrs.iter().filter(|(k, _)| !is_rdf_meta_attr(k)).collect();+ if !field_attrs.is_empty() && p.children.is_empty() && p.text.trim().is_empty() {+ for (k, v) in field_attrs {+ props.entry(format!("{struct_prefix}{k}")).or_default().push(v.clone());+ }+ return;+ }+ let v = p.attr("rdf:resource").map(str::to_string).unwrap_or_else(|| p.text.trim().to_string());+ props.entry(key).or_default().push(v);+}++fn find_descriptions<'a>(n: &'a Node, out: &mut Vec<&'a Node>) {+ if n.name == "rdf:Description" {+ out.push(n);+ return;+ }+ for c in &n.children {+ find_descriptions(c, out);+ }+}++/// XMP GPS coordinate `DDD,MM,SSk` or `DDD,MM.mmk` (k = N/S/E/W) → signed degrees.+fn parse_gps_coord(s: &str) -> Option<f64> {+ let s = s.trim();+ let dir = s.chars().last()?;+ let body = &s[..s.len() - dir.len_utf8()];+ let parts: Vec<f64> = body.split(',').map(|p| p.trim().parse::<f64>().ok()).collect::<Option<_>>()?;+ let v = match parts.as_slice() {+ [d] => *d,+ [d, m] => d + m / 60.0,+ [d, m, sec] => d + m / 60.0 + sec / 3600.0,+ _ => return None,+ };+ let v = match dir.to_ascii_uppercase() {+ 'N' | 'E' => v,+ 'S' | 'W' => -v,+ _ => return None,+ };+ v.is_finite().then_some(v)+}++fn fmt_gps_coord(v: f64, pos: char, neg: char) -> String {+ let a = v.abs();+ let d = a.trunc();+ let m = (a - d) * 60.0;+ format!("{},{:.6}{}", d as i64, m, if v < 0.0 { neg } else { pos })+}++/// Parse an XMP packet (with or without the `<?xpacket?>` wrapper / `x:xmpmeta` element).+pub fn parse_xmp(s: &str) -> Result<XmpData, XmpError> {+ let s = s.trim_start_matches('\u{feff}');+ let tree = parse_tree(s)?;+ let mut descs = Vec::new();+ find_descriptions(&tree, &mut descs);+ let mut props = BTreeMap::new();+ for d in descs {+ collect_description(d, "", &mut props);+ }+ let first = |k: &str| props.get(k).and_then(|v| v.first()).map(|s| s.trim().to_string()).filter(|s| !s.is_empty());+ let num = |k: &str| first(k).and_then(|s| parse_number(&s));+ let mut m = Metadata {+ make: first("tiff:Make"),+ model: first("tiff:Model"),+ serial_number: first("exifEX:BodySerialNumber").or_else(|| first("aux:SerialNumber")),+ software: first("xmp:CreatorTool"),+ lens_make: first("exifEX:LensMake"),+ lens_model: first("exifEX:LensModel").or_else(|| first("aux:Lens")),+ lens_serial_number: first("exifEX:LensSerialNumber").or_else(|| first("aux:LensSerialNumber")),+ exposure_time: num("exif:ExposureTime").filter(|v| *v > 0.0),+ f_number: num("exif:FNumber").filter(|v| *v > 0.0),+ focal_length: num("exif:FocalLength").filter(|v| *v > 0.0),+ focal_length_35mm: num("exif:FocalLengthIn35mmFilm").filter(|v| *v > 0.0),+ exposure_bias: num("exif:ExposureBiasValue"),+ exposure_program: num("exif:ExposureProgram").map(|v| v as u16),+ metering_mode: num("exif:MeteringMode").map(|v| v as u16),+ white_balance: num("exif:WhiteBalance").map(|v| v as u16),+ orientation: num("tiff:Orientation").map(|v| v as u16).filter(|v| (1..=8).contains(v)).map(Orientation::from_exif),+ width: num("tiff:ImageWidth").or_else(|| num("exif:PixelXDimension")).map(|v| v as u32),+ height: num("tiff:ImageLength").or_else(|| num("exif:PixelYDimension")).map(|v| v as u32),+ title: first("dc:title"),+ caption: first("dc:description"),+ copyright: first("dc:rights"),+ rating: num("xmp:Rating").map(|v| v.round().clamp(-1.0, 5.0) as i8),+ label: first("xmp:Label"),+ ..Default::default()+ };+ m.iso = num("exif:ISOSpeedRatings").or_else(|| num("exifEX:PhotographicSensitivity")).filter(|v| *v > 0.0).map(|v| v as u32);+ if let Some(v) = props.get("exif:ISOSpeedRatings").and_then(|v| v.first()).and_then(|s| parse_number(s)) {+ m.iso = Some(v as u32);+ }+ if let Some(spec) = props.get("exifEX:LensSpecification").filter(|v| v.len() == 4) {+ let v: Vec<f64> = spec.iter().filter_map(|s| parse_number(s)).collect();+ if v.len() == 4 {+ m.lens_spec = Some([v[0], v[1], v[2], v[3]]);+ }+ }+ if let Some(creators) = props.get("dc:creator").filter(|c| !c.is_empty()) {+ m.artist = Some(creators.join("; "));+ }+ m.keywords = props.get("dc:subject").cloned().unwrap_or_default().into_iter().filter(|k| !k.is_empty()).collect();+ m.hierarchical_keywords = props.get("lr:hierarchicalSubject").cloned().unwrap_or_default().into_iter().filter(|k| !k.is_empty()).collect();+ m.capture_time =+ ["exif:DateTimeOriginal", "photoshop:DateCreated", "xmp:CreateDate"].iter().find_map(|k| first(k).and_then(|s| DateTime::parse_iso(&s)));+ if let Some(fired) = first("exif:Flash/exif:Fired") {+ let b = |k: &str| first(k).is_some_and(|s| s.eq_ignore_ascii_case("true"));+ let n = |k: &str| num(k).unwrap_or(0.0) as u16;+ let fired = fired.eq_ignore_ascii_case("true");+ let raw = fired as u16+ | (n("exif:Flash/exif:Return") & 3) << 1+ | (n("exif:Flash/exif:Mode") & 3) << 3+ | (b("exif:Flash/exif:Function") as u16) << 5+ | (b("exif:Flash/exif:RedEyeMode") as u16) << 6;+ m.flash = Some(Flash { fired, raw });+ }+ if let (Some(lat), Some(lon)) =+ (first("exif:GPSLatitude").and_then(|s| parse_gps_coord(&s)), first("exif:GPSLongitude").and_then(|s| parse_gps_coord(&s)))+ {+ let altitude = num("exif:GPSAltitude").map(|a| if first("exif:GPSAltitudeRef").as_deref() == Some("1") { -a } else { a });+ m.gps = Some(Gps { latitude: lat, longitude: lon, altitude });+ }+ let lc_settings = props.get("lc:settings").and_then(|v| v.first()).cloned();+ Ok(XmpData { metadata: m, lc_settings, properties: props })+}++fn frac(v: f64) -> String {+ if v > 0.0 && v < 1.0 {+ let inv = 1.0 / v;+ if (inv - inv.round()).abs() < 1e-6 {+ return format!("1/{}", inv.round() as u64);+ }+ }+ let (n, d) = lightcraft_tiff::writer::rational(v);+ format!("{n}/{d}")+}++fn sfrac(v: f64) -> String {+ let (n, d) = lightcraft_tiff::writer::srational(v);+ format!("{n}/{d}")+}++/// Serialise the interchange subset of `meta` (plus `lc_settings`, an opaque JSON string, in `lc:settings`)+/// as a complete XMP packet.+pub fn write_xmp(meta: &Metadata, lc_settings: Option<&str>) -> String {+ let mut simple: Vec<(&str, String)> = Vec::new();+ let mut push = |k: &'static str, v: Option<String>| {+ if let Some(v) = v {+ simple.push((k, v));+ }+ };+ push("tiff:Make", meta.make.clone());+ push("tiff:Model", meta.model.clone());+ push("tiff:Orientation", meta.orientation.map(|o| o.to_exif().to_string()));+ push("tiff:ImageWidth", meta.width.map(|v| v.to_string()));+ push("tiff:ImageLength", meta.height.map(|v| v.to_string()));+ push("xmp:CreatorTool", meta.software.clone());+ push("xmp:Rating", meta.rating.map(|v| v.to_string()));+ push("xmp:Label", meta.label.clone());+ push("exif:DateTimeOriginal", meta.capture_time.map(|d| d.to_iso()));+ push("photoshop:DateCreated", meta.capture_time.map(|d| d.to_iso()));+ push("exif:ExposureTime", meta.exposure_time.map(frac));+ push("exif:FNumber", meta.f_number.map(frac));+ push("exif:FocalLength", meta.focal_length.map(frac));+ push("exif:FocalLengthIn35mmFilm", meta.focal_length_35mm.map(|v| format!("{}", v.round() as i64)));+ push("exif:ExposureBiasValue", meta.exposure_bias.map(sfrac));+ push("exif:ExposureProgram", meta.exposure_program.map(|v| v.to_string()));+ push("exif:MeteringMode", meta.metering_mode.map(|v| v.to_string()));+ push("exif:WhiteBalance", meta.white_balance.map(|v| v.to_string()));+ push("exifEX:BodySerialNumber", meta.serial_number.clone());+ push("exifEX:LensMake", meta.lens_make.clone());+ push("exifEX:LensModel", meta.lens_model.clone());+ push("exifEX:LensSerialNumber", meta.lens_serial_number.clone());+ if let Some(g) = meta.gps {+ push("exif:GPSLatitude", Some(fmt_gps_coord(g.latitude, 'N', 'S')));+ push("exif:GPSLongitude", Some(fmt_gps_coord(g.longitude, 'E', 'W')));+ if let Some(a) = g.altitude {+ push("exif:GPSAltitude", Some(frac(a.abs())));+ push("exif:GPSAltitudeRef", Some(if a < 0.0 { "1" } else { "0" }.into()));+ }+ }+ push("lc:settings", lc_settings.map(str::to_string));++ let mut x = String::new();+ x.push_str("<?xpacket begin=\"\u{feff}\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n");+ x.push_str("<x:xmpmeta xmlns:x=\"adobe:ns:meta/\" x:xmptk=\"LightCraft\">\n");+ x.push_str(" <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n");+ x.push_str(" <rdf:Description rdf:about=\"\"");+ for (p, u) in NAMESPACES.iter().skip(2) {+ x.push_str(&format!("\n xmlns:{p}=\"{u}\""));+ }+ x.push_str(">\n");+ for (k, v) in &simple {+ x.push_str(&format!(" <{k}>{}</{k}>\n", escape(v.as_str())));+ }+ let array = |x: &mut String, k: &str, kind: &str, items: &[String], lang: bool| {+ if items.is_empty() {+ return;+ }+ x.push_str(&format!(" <{k}>\n <rdf:{kind}>\n"));+ for it in items {+ if lang {+ x.push_str(&format!(" <rdf:li xml:lang=\"x-default\">{}</rdf:li>\n", escape(it.as_str())));+ } else {+ x.push_str(&format!(" <rdf:li>{}</rdf:li>\n", escape(it.as_str())));+ }+ }+ x.push_str(&format!(" </rdf:{kind}>\n </{k}>\n"));+ };+ let one = |v: &Option<String>| v.iter().cloned().collect::<Vec<_>>();+ array(&mut x, "dc:title", "Alt", &one(&meta.title), true);+ array(&mut x, "dc:description", "Alt", &one(&meta.caption), true);+ array(&mut x, "dc:rights", "Alt", &one(&meta.copyright), true);+ array(&mut x, "dc:creator", "Seq", &one(&meta.artist), false);+ array(&mut x, "dc:subject", "Bag", &meta.keywords, false);+ array(&mut x, "lr:hierarchicalSubject", "Bag", &meta.hierarchical_keywords, false);+ array(&mut x, "exif:ISOSpeedRatings", "Seq", &meta.iso.map(|v| vec![v.to_string()]).unwrap_or_default(), false);+ if let Some(s) = meta.lens_spec {+ array(&mut x, "exifEX:LensSpecification", "Seq", &s.iter().map(|&v| frac(v)).collect::<Vec<_>>(), false);+ }+ if let Some(f) = meta.flash {+ let r = f.raw;+ let tf = |b: bool| if b { "True" } else { "False" };+ x.push_str(&format!(+ " <exif:Flash rdf:parseType=\"Resource\">\n <exif:Fired>{}</exif:Fired>\n <exif:Return>{}</exif:Return>\n <exif:Mode>{}</exif:Mode>\n <exif:Function>{}</exif:Function>\n <exif:RedEyeMode>{}</exif:RedEyeMode>\n </exif:Flash>\n",+ tf(f.fired),+ (r >> 1) & 3,+ (r >> 3) & 3,+ tf(r & 0x20 != 0),+ tf(r & 0x40 != 0)+ ));+ }+ x.push_str(" </rdf:Description>\n </rdf:RDF>\n</x:xmpmeta>\n<?xpacket end=\"w\"?>");+ x+}++#[cfg(test)]+mod tests {+ use super::*;++ fn full() -> Metadata {+ Metadata {+ make: Some("Maker & Sons".into()),+ model: Some("X <1>".into()),+ serial_number: Some("SN1".into()),+ software: Some("LightCraft".into()),+ lens_make: Some("L".into()),+ lens_model: Some("24-70mm".into()),+ lens_serial_number: Some("LS".into()),+ lens_spec: Some([24.0, 70.0, 2.8, 2.8]),+ capture_time: DateTime::parse_iso("2022-05-06T07:08:09.123-04:00"),+ exposure_time: Some(1.0 / 125.0),+ f_number: Some(5.6),+ iso: Some(800),+ focal_length: Some(35.0),+ focal_length_35mm: Some(52.0),+ flash: Some(Flash { fired: true, raw: 0x59 }),+ exposure_bias: Some(-1.0 / 3.0),+ exposure_program: Some(2),+ metering_mode: Some(3),+ white_balance: Some(1),+ orientation: Some(Orientation::Rotate270),+ gps: Some(Gps { latitude: 48.858222, longitude: -2.2945, altitude: Some(-3.5) }),+ width: Some(8000),+ height: Some(6000),+ artist: Some("Ann \"Photo\" Lee".into()),+ copyright: Some("© 2022".into()),+ title: Some("Tïtle".into()),+ caption: Some("Line one\nline two".into()),+ keywords: vec!["tree".into(), "sky & sea".into()],+ hierarchical_keywords: vec!["Places|France|Paris".into()],+ rating: Some(-1),+ label: Some("Green".into()),+ }+ }++ #[test]+ fn roundtrip_all_fields() {+ let m = full();+ let json = r#"{"version":1,"exposure":0.5,"note":"<&>"}"#;+ let x = write_xmp(&m, Some(json));+ let d = parse_xmp(&x).unwrap();+ assert_eq!(d.lc_settings.as_deref(), Some(json));+ let mut got = d.metadata.clone();+ // floats go through rationals+ assert!((got.exposure_bias.unwrap() + 1.0 / 3.0).abs() < 1e-5);+ got.exposure_bias = m.exposure_bias;+ let g = got.gps.unwrap();+ assert!((g.latitude - 48.858222).abs() < 1e-6 && (g.longitude + 2.2945).abs() < 1e-6, "{g:?}");+ got.gps = m.gps;+ assert_eq!(got, m);+ }++ #[test]+ fn empty_metadata_roundtrip() {+ let x = write_xmp(&Metadata::default(), None);+ let d = parse_xmp(&x).unwrap();+ assert_eq!(d.metadata, Metadata::default());+ assert_eq!(d.lc_settings, None);+ }++ #[test]+ fn attribute_form_foreign_prefixes_and_structs() {+ let x = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">+ <rdf:Description rdf:about="" xmlns:a="http://ns.adobe.com/xap/1.0/" xmlns:d="http://purl.org/dc/elements/1.1/"+ xmlns:e="http://ns.adobe.com/exif/1.0/" a:Rating="4" a:Label="Blue" e:FNumber="40/10" e:GPSLatitude="10,30N" e:GPSLongitude="20,15,36W">+ <d:title><rdf:Alt><rdf:li xml:lang="de">Titel</rdf:li><rdf:li xml:lang="x-default">Title & more é</rdf:li></rdf:Alt></d:title>+ <e:Flash><rdf:Description e:Fired="False" e:Mode="2"/></e:Flash>+ <d:subject><rdf:Bag><rdf:li>k1</rdf:li><rdf:li>k2</rdf:li></rdf:Bag></d:subject>+ </rdf:Description></rdf:RDF></x:xmpmeta>"#;+ let d = parse_xmp(x).unwrap();+ let m = d.metadata;+ assert_eq!(m.rating, Some(4));+ assert_eq!(m.label.as_deref(), Some("Blue"));+ assert_eq!(m.f_number, Some(4.0));+ assert_eq!(m.title.as_deref(), Some("Title & more é"));+ assert_eq!(m.keywords, vec!["k1".to_string(), "k2".to_string()]);+ assert_eq!(m.flash, Some(Flash { fired: false, raw: 0x10 }));+ let g = m.gps.unwrap();+ assert!((g.latitude - 10.5).abs() < 1e-9);+ assert!((g.longitude + 20.26).abs() < 1e-9);+ assert_eq!(d.properties["dc:title"], vec!["Title & more é".to_string(), "Titel".to_string()]);+ }++ #[test]+ fn malformed_inputs() {+ assert!(parse_xmp("<a><b></a>").is_ok() || parse_xmp("<a><b></a>").is_err());+ assert_eq!(parse_xmp("").unwrap().metadata, Metadata::default());+ assert_eq!(parse_xmp("not xml at all").unwrap().metadata, Metadata::default());+ let deep = "<a>".repeat(1000);+ assert_eq!(parse_xmp(&deep), Err(XmpError::TooComplex));+ let x = write_xmp(&full(), Some("{}"));+ for n in (0..x.len()).step_by(7) {+ if x.is_char_boundary(n) {+ let _ = parse_xmp(&x[..n]);+ }+ }+ }++ #[test]+ fn gps_coords() {+ assert_eq!(parse_gps_coord("45,30N"), Some(45.5));+ assert_eq!(parse_gps_coord("45,30,36S"), Some(-45.51));+ assert_eq!(parse_gps_coord("45X"), None);+ assert_eq!(parse_gps_coord(""), None);+ assert_eq!(parse_gps_coord("é"), None);+ assert_eq!(fmt_gps_coord(-45.51, 'N', 'S'), "45,30.600000S");+ }+}diff --git a/crates/meta/tests/robust.rs b/crates/meta/tests/robust.rsnew file mode 100644index 000000000..679fc49dc--- /dev/null+++ b/crates/meta/tests/robust.rs@@ -0,0 +1,36 @@+use lightcraft_meta::{Metadata, extract, parse_iptc, parse_xmp, read_exif, write_xmp};+use proptest::prelude::*;++proptest! {+ #![proptest_config(ProptestConfig { cases: 1500, .. ProptestConfig::default() })]++ #[test]+ fn random_containers_never_panic(mut data in proptest::collection::vec(any::<u8>(), 0..600), kind in 0usize..5) {+ let heads: [&[u8]; 5] = [b"\xff\xd8\xff\xe1", b"\x89PNG\r\n\x1a\n", b"RIFF\0\0\0\0WEBP", b"II*\0", b"MM\0*"];+ let h = heads[kind];+ if data.len() >= h.len() {+ data[..h.len()].copy_from_slice(h);+ }+ let _ = extract(&data);+ let _ = read_exif(&data);+ let _ = parse_iptc(&data);+ }++ #[test]+ fn random_text_xmp_never_panics(s in ".{0,400}") {+ let _ = parse_xmp(&s);+ }++ #[test]+ fn user_text_roundtrips(title in "[a-zA-Z0-9 &<>\"'éü€;|/\\\\]{1,40}", kw in proptest::collection::vec("[a-zA-Z0-9 &<>\"'|]{1,12}", 0..5), rating in -1i8..=5) {+ let title = title.trim().to_string();+ prop_assume!(!title.is_empty());+ let kw: Vec<String> = kw.into_iter().map(|k| k.trim().to_string()).filter(|k| !k.is_empty()).collect();+ let m = Metadata { title: Some(title.clone()), keywords: kw.clone(), rating: Some(rating), ..Default::default() };+ let d = parse_xmp(&write_xmp(&m, Some(&title))).unwrap();+ prop_assert_eq!(d.metadata.title, Some(title.clone()));+ prop_assert_eq!(d.metadata.keywords, kw);+ prop_assert_eq!(d.metadata.rating, Some(rating));+ prop_assert_eq!(d.lc_settings, Some(title));+ }+}