1use std::collections::HashMap;
17
18use super::super::{fnv60, AssetRef, AssetRole, Descriptors, Place, Processor, ProcessorOutput};
19
20#[derive(Debug, Clone, Default, PartialEq)]
22pub struct ImageMetadata {
23 pub datetime_unix: Option<i64>,
25 pub lat: Option<f64>,
27 pub lon: Option<f64>,
28 pub make: Option<String>,
29 pub model: Option<String>,
30 pub width: Option<u32>,
31 pub height: Option<u32>,
32}
33
34impl ImageMetadata {
35 pub fn has_any(&self) -> bool {
37 self.datetime_unix.is_some()
38 || self.lat.is_some()
39 || self.make.is_some()
40 || self.model.is_some()
41 || self.width.is_some()
42 }
43}
44
45#[derive(Debug, Clone, Default)]
49pub struct ImageProcessor;
50
51impl ImageProcessor {
52 pub fn extract(bytes: &[u8]) -> Option<ImageMetadata> {
55 let meta = if is_jpeg(bytes) {
56 parse_jpeg(bytes)
57 } else if is_png(bytes) {
58 parse_png(bytes)
59 } else {
60 ImageMetadata::default()
61 };
62 if meta.has_any() {
63 Some(meta)
64 } else {
65 None
66 }
67 }
68}
69
70impl Processor for ImageProcessor {
71 fn handles(&self, media_type: &str) -> bool {
72 matches!(media_type, "image/jpeg" | "image/jpg" | "image/png")
73 }
74
75 fn process(&self, asset_uri: &str, bytes: &[u8], _media_type: &str) -> ProcessorOutput {
76 let meta = ImageProcessor::extract(bytes).unwrap_or_default();
77
78 let mut topics = vec!["image".to_string()];
79 for m in meta.make.iter().chain(meta.model.iter()) {
80 let m = m.trim();
81 if !m.is_empty() {
82 topics.push(m.to_lowercase());
83 }
84 }
85
86 let place = match (meta.lat, meta.lon) {
87 (Some(lat), Some(lon)) => Some(Place {
88 label: format!("{lat:.5},{lon:.5}"),
92 lat: lat as f32,
93 lon: lon as f32,
94 }),
95 _ => None,
96 };
97
98 let descriptors = Descriptors {
99 topics,
100 depicts: Vec::new(), occurred_at: meta.datetime_unix,
102 place,
103 document_type: Some("image".to_string()),
104 ..Default::default()
105 };
106
107 let mut summary = String::from("image");
110 if let Some(t) = meta.datetime_unix {
111 summary.push_str(&format!("; taken@{t}"));
112 }
113 if let (Some(lat), Some(lon)) = (meta.lat, meta.lon) {
114 summary.push_str(&format!("; at {lat:.5},{lon:.5}"));
115 }
116 if let Some(m) = &meta.make {
117 summary.push_str(&format!("; make {m}"));
118 }
119 if let Some(m) = &meta.model {
120 summary.push_str(&format!("; model {m}"));
121 }
122 if let (Some(w), Some(h)) = (meta.width, meta.height) {
123 summary.push_str(&format!("; {w}x{h}"));
124 }
125
126 let meta_uri = format!("{asset_uri}#exif");
127 let derived = vec![AssetRef::new(
128 &meta_uri,
129 fnv60(summary.as_bytes()),
130 "text/plain",
131 AssetRole::Analysis,
132 )
133 .derived_from(asset_uri)];
134 let mut derived_bytes = HashMap::new();
135 derived_bytes.insert(meta_uri, summary.into_bytes());
136
137 ProcessorOutput {
138 derived,
139 derived_bytes,
140 descriptors,
141 flags: Vec::new(),
142 }
143 }
144}
145
146fn is_jpeg(b: &[u8]) -> bool {
149 b.len() >= 3 && b[0] == 0xFF && b[1] == 0xD8 && b[2] == 0xFF
150}
151fn is_png(b: &[u8]) -> bool {
152 b.len() >= 8 && b[..8] == [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]
153}
154
155fn parse_jpeg(b: &[u8]) -> ImageMetadata {
158 let mut i = 2; while i + 4 <= b.len() {
161 if b[i] != 0xFF {
162 break;
163 }
164 let marker = b[i + 1];
165 if marker == 0xD8 || marker == 0xD9 || (0xD0..=0xD7).contains(&marker) {
167 i += 2;
168 continue;
169 }
170 let seg_len = u16::from_be_bytes([b[i + 2], b[i + 3]]) as usize;
171 if seg_len < 2 || i + 2 + seg_len > b.len() {
172 break;
173 }
174 let seg = &b[i + 4..i + 2 + seg_len];
175 if marker == 0xE1 && seg.len() >= 6 && &seg[..6] == b"Exif\0\0" {
176 return parse_tiff(&seg[6..]);
177 }
178 if marker == 0xDA {
180 break;
181 }
182 i += 2 + seg_len;
183 }
184 ImageMetadata::default()
185}
186
187#[derive(Clone, Copy)]
190struct Tiff<'a> {
191 data: &'a [u8],
192 le: bool,
193}
194
195impl<'a> Tiff<'a> {
196 fn u16(&self, off: usize) -> Option<u16> {
197 let s = self.data.get(off..off + 2)?;
198 Some(if self.le {
199 u16::from_le_bytes([s[0], s[1]])
200 } else {
201 u16::from_be_bytes([s[0], s[1]])
202 })
203 }
204 fn u32(&self, off: usize) -> Option<u32> {
205 let s = self.data.get(off..off + 4)?;
206 Some(if self.le {
207 u32::from_le_bytes([s[0], s[1], s[2], s[3]])
208 } else {
209 u32::from_be_bytes([s[0], s[1], s[2], s[3]])
210 })
211 }
212}
213
214fn type_size(typ: u16) -> usize {
215 match typ {
216 1 | 2 | 6 | 7 => 1, 3 | 8 => 2, 4 | 9 | 11 => 4, 5 | 10 | 12 => 8, _ => 0,
221 }
222}
223
224struct Entry {
226 typ: u16,
227 count: u32,
228 value_off: usize,
230}
231
232fn parse_tiff(t: &[u8]) -> ImageMetadata {
233 let le = match t.get(..2) {
234 Some(b"II") => true,
235 Some(b"MM") => false,
236 _ => return ImageMetadata::default(),
237 };
238 let tiff = Tiff { data: t, le };
239 if tiff.u16(2) != Some(42) {
240 return ImageMetadata::default();
241 }
242 let ifd0 = match tiff.u32(4) {
243 Some(o) => o as usize,
244 None => return ImageMetadata::default(),
245 };
246
247 let mut meta = ImageMetadata::default();
248 let mut exif_ifd: Option<usize> = None;
249 let mut gps_ifd: Option<usize> = None;
250
251 walk_ifd(&tiff, ifd0, &mut |tag, e| match tag {
252 0x010F => meta.make = read_ascii(&tiff, e),
253 0x0110 => meta.model = read_ascii(&tiff, e),
254 0x0132 if meta.datetime_unix.is_none() => {
255 meta.datetime_unix = read_ascii(&tiff, e).and_then(|s| parse_exif_datetime(&s))
256 }
257 0x8769 => exif_ifd = read_long1(&tiff, e).map(|v| v as usize),
258 0x8825 => gps_ifd = read_long1(&tiff, e).map(|v| v as usize),
259 _ => {}
260 });
261
262 if let Some(off) = exif_ifd {
263 walk_ifd(&tiff, off, &mut |tag, e| match tag {
264 0x9003 => {
265 if let Some(dt) = read_ascii(&tiff, e).and_then(|s| parse_exif_datetime(&s)) {
267 meta.datetime_unix = Some(dt);
268 }
269 }
270 0xA002 => meta.width = read_long1(&tiff, e),
271 0xA003 => meta.height = read_long1(&tiff, e),
272 _ => {}
273 });
274 }
275
276 if let Some(off) = gps_ifd {
277 let mut lat_ref = None;
278 let mut lon_ref = None;
279 let mut lat = None;
280 let mut lon = None;
281 walk_ifd(&tiff, off, &mut |tag, e| match tag {
282 0x0001 => lat_ref = read_ascii(&tiff, e),
283 0x0002 => lat = read_gps_dms(&tiff, e),
284 0x0003 => lon_ref = read_ascii(&tiff, e),
285 0x0004 => lon = read_gps_dms(&tiff, e),
286 _ => {}
287 });
288 if let Some(mut v) = lat {
289 if lat_ref
290 .as_deref()
291 .map(|r| r.starts_with('S'))
292 .unwrap_or(false)
293 {
294 v = -v;
295 }
296 meta.lat = Some(v);
297 }
298 if let Some(mut v) = lon {
299 if lon_ref
300 .as_deref()
301 .map(|r| r.starts_with('W'))
302 .unwrap_or(false)
303 {
304 v = -v;
305 }
306 meta.lon = Some(v);
307 }
308 }
309
310 meta
311}
312
313fn walk_ifd(t: &Tiff<'_>, ifd_off: usize, f: &mut dyn FnMut(u16, &Entry)) {
316 let count = match t.u16(ifd_off) {
317 Some(c) => c as usize,
318 None => return,
319 };
320 for k in 0..count {
321 let e_off = ifd_off + 2 + k * 12;
322 let (tag, typ, cnt) = match (t.u16(e_off), t.u16(e_off + 2), t.u32(e_off + 4)) {
323 (Some(a), Some(b), Some(c)) => (a, b, c),
324 _ => return,
325 };
326 let sz = type_size(typ);
327 if sz == 0 {
328 continue;
329 }
330 let total = sz.saturating_mul(cnt as usize);
331 let value_off = if total <= 4 {
333 e_off + 8
334 } else {
335 match t.u32(e_off + 8) {
336 Some(o) => o as usize,
337 None => continue,
338 }
339 };
340 f(
341 tag,
342 &Entry {
343 typ,
344 count: cnt,
345 value_off,
346 },
347 );
348 }
349}
350
351fn read_ascii(t: &Tiff<'_>, e: &Entry) -> Option<String> {
352 if e.typ != 2 {
353 return None;
354 }
355 let n = e.count as usize;
356 let raw = t.data.get(e.value_off..e.value_off + n)?;
357 let end = raw.iter().position(|&b| b == 0).unwrap_or(raw.len());
358 let s = std::str::from_utf8(&raw[..end]).ok()?.trim().to_string();
359 if s.is_empty() {
360 None
361 } else {
362 Some(s)
363 }
364}
365
366fn read_long1(t: &Tiff<'_>, e: &Entry) -> Option<u32> {
368 match e.typ {
369 4 => t.u32(e.value_off),
370 3 => t.u16(e.value_off).map(|v| v as u32),
371 _ => None,
372 }
373}
374
375fn read_rational(t: &Tiff<'_>, off: usize) -> Option<f64> {
377 let num = t.u32(off)? as f64;
378 let den = t.u32(off + 4)? as f64;
379 if den == 0.0 {
380 Some(0.0)
381 } else {
382 Some(num / den)
383 }
384}
385
386fn read_gps_dms(t: &Tiff<'_>, e: &Entry) -> Option<f64> {
388 if e.typ != 5 || e.count < 3 {
389 return None;
390 }
391 let d = read_rational(t, e.value_off)?;
392 let m = read_rational(t, e.value_off + 8)?;
393 let s = read_rational(t, e.value_off + 16)?;
394 Some(d + m / 60.0 + s / 3600.0)
395}
396
397fn parse_exif_datetime(s: &str) -> Option<i64> {
399 let s = s.trim();
400 let (date, time) = match s.split_once(' ') {
402 Some((d, t)) => (d, Some(t)),
403 None => (s, None),
404 };
405 let mut dp = date.split(&[':', '-'][..]);
406 let y: i64 = dp.next()?.parse().ok()?;
407 let mo: i64 = dp.next()?.parse().ok()?;
408 let d: i64 = dp.next()?.parse().ok()?;
409 if !(1..=12).contains(&mo) || !(1..=31).contains(&d) {
410 return None;
411 }
412 let (mut h, mut mi, mut se) = (0i64, 0i64, 0i64);
413 if let Some(t) = time {
414 let mut tp = t.split(':');
415 h = tp.next()?.parse().ok()?;
416 mi = tp.next().and_then(|x| x.parse().ok()).unwrap_or(0);
417 se = tp.next().and_then(|x| x.parse().ok()).unwrap_or(0);
418 }
419 let _ = (&mut h, &mut mi, &mut se);
420 Some(days_from_civil(y, mo, d) * 86_400 + h * 3600 + mi * 60 + se)
421}
422
423fn days_from_civil(y: i64, m: i64, d: i64) -> i64 {
426 let y = y - (m <= 2) as i64;
427 let era = (if y >= 0 { y } else { y - 399 }) / 400;
428 let yoe = y - era * 400; let mp = if m > 2 { m - 3 } else { m + 9 }; let doy = (153 * mp + 2) / 5 + d - 1; let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; era * 146097 + doe - 719468
433}
434
435fn parse_png(b: &[u8]) -> ImageMetadata {
438 let mut meta = ImageMetadata::default();
439 let mut i = 8; while i + 8 <= b.len() {
442 let len = u32::from_be_bytes([b[i], b[i + 1], b[i + 2], b[i + 3]]) as usize;
443 let typ = match b.get(i + 4..i + 8) {
444 Some(t) => t,
445 None => break,
446 };
447 let data_start = i + 8;
448 let data_end = match data_start.checked_add(len) {
449 Some(e) if e <= b.len() => e,
450 _ => break,
451 };
452 let data = &b[data_start..data_end];
453 match typ {
454 b"IHDR" if data.len() >= 8 => {
455 meta.width = Some(u32::from_be_bytes([data[0], data[1], data[2], data[3]]));
456 meta.height = Some(u32::from_be_bytes([data[4], data[5], data[6], data[7]]));
457 }
458 b"tIME" if data.len() >= 7 && meta.datetime_unix.is_none() => {
459 let year = u16::from_be_bytes([data[0], data[1]]) as i64;
460 let (mo, d, h, mi, se) = (
461 data[2] as i64,
462 data[3] as i64,
463 data[4] as i64,
464 data[5] as i64,
465 data[6] as i64,
466 );
467 if (1..=12).contains(&mo) && (1..=31).contains(&d) {
468 meta.datetime_unix =
469 Some(days_from_civil(year, mo, d) * 86_400 + h * 3600 + mi * 60 + se);
470 }
471 }
472 b"eXIf" => {
473 let exif = parse_tiff(data);
474 if exif.has_any() {
475 let (w, h) = (meta.width, meta.height);
477 meta = exif;
478 meta.width = meta.width.or(w);
479 meta.height = meta.height.or(h);
480 }
481 }
482 b"IEND" => break,
483 _ => {}
484 }
485 i = data_end + 4; }
487 meta
488}
489
490#[cfg(test)]
491mod tests {
492 use super::super::super::{by_place, in_time_range, ingest_with};
493 use super::*;
494
495 fn tiff_with_datetime_and_gps() -> Vec<u8> {
498 let mut b = Vec::new();
501 b.extend_from_slice(b"II"); b.extend_from_slice(&42u16.to_le_bytes());
504 b.extend_from_slice(&8u32.to_le_bytes()); let exif_ifd = 38u32;
512 let gps_ifd = 56u32;
513 let heap = 110u32;
514
515 b.extend_from_slice(&2u16.to_le_bytes()); push_entry(&mut b, 0x8769, 4, 1, exif_ifd);
519 push_entry(&mut b, 0x8825, 4, 1, gps_ifd);
521 b.extend_from_slice(&0u32.to_le_bytes()); assert_eq!(b.len(), exif_ifd as usize);
523
524 let dt = b"2021:07:14 09:30:00\0"; let dt_off = heap;
527 b.extend_from_slice(&1u16.to_le_bytes());
528 push_entry(&mut b, 0x9003, 2, dt.len() as u32, dt_off); b.extend_from_slice(&0u32.to_le_bytes());
530 assert_eq!(b.len(), gps_ifd as usize);
531
532 let latref_inline = u32::from_le_bytes([b'N', 0, 0, 0]);
534 let lonref_inline = u32::from_le_bytes([b'E', 0, 0, 0]);
535 let lat_off = dt_off + dt.len() as u32; let lon_off = lat_off + 24; b.extend_from_slice(&4u16.to_le_bytes());
538 push_entry(&mut b, 0x0001, 2, 2, latref_inline); push_entry(&mut b, 0x0002, 5, 3, lat_off); push_entry(&mut b, 0x0003, 2, 2, lonref_inline); push_entry(&mut b, 0x0004, 5, 3, lon_off); b.extend_from_slice(&0u32.to_le_bytes());
543 assert_eq!(b.len(), heap as usize);
544
545 b.extend_from_slice(dt); push_rational(&mut b, 48, 1);
549 push_rational(&mut b, 51, 1);
550 push_rational(&mut b, 30, 1);
551 push_rational(&mut b, 2, 1);
553 push_rational(&mut b, 17, 1);
554 push_rational(&mut b, 40, 1);
555 b
556 }
557
558 fn push_entry(b: &mut Vec<u8>, tag: u16, typ: u16, count: u32, value: u32) {
559 b.extend_from_slice(&tag.to_le_bytes());
560 b.extend_from_slice(&typ.to_le_bytes());
561 b.extend_from_slice(&count.to_le_bytes());
562 b.extend_from_slice(&value.to_le_bytes());
563 }
564 fn push_rational(b: &mut Vec<u8>, num: u32, den: u32) {
565 b.extend_from_slice(&num.to_le_bytes());
566 b.extend_from_slice(&den.to_le_bytes());
567 }
568
569 fn jpeg_wrapping(tiff: &[u8]) -> Vec<u8> {
570 let mut b = vec![0xFF, 0xD8];
572 let payload_len = 2 + 6 + tiff.len(); b.extend_from_slice(&[0xFF, 0xE1]);
574 b.extend_from_slice(&(payload_len as u16).to_be_bytes());
575 b.extend_from_slice(b"Exif\0\0");
576 b.extend_from_slice(tiff);
577 b.extend_from_slice(&[0xFF, 0xD9]);
578 b
579 }
580
581 #[test]
582 fn exif_datetime_and_gps_become_timeline_and_map_facets() {
583 let tiff = tiff_with_datetime_and_gps();
584 let meta = parse_tiff(&tiff);
585 assert!(meta.datetime_unix.is_some(), "DateTimeOriginal parsed");
586 assert_eq!(meta.datetime_unix, Some(1_626_255_000));
588 let lat = meta.lat.expect("lat");
589 let lon = meta.lon.expect("lon");
590 assert!((lat - 48.858_333).abs() < 1e-4, "lat ≈ 48.8583, got {lat}");
591 assert!((lon - 2.294_444).abs() < 1e-4, "lon ≈ 2.2944, got {lon}");
592 }
593
594 #[test]
595 fn jpeg_photo_ingests_findable_by_time_and_place() {
596 let jpeg = jpeg_wrapping(&tiff_with_datetime_and_gps());
597 let proc = ImageProcessor;
598 assert!(proc.handles("image/jpeg"));
599 let r = ingest_with(&proc, "urn:photo:paris", "image/jpeg", 0xC0FFEE, &jpeg);
600 let subj = r.container.primary.subject();
601 let hits = in_time_range(&r.quins, 1_626_255_000 - 60, 1_626_255_000 + 60);
603 assert!(
604 hits.contains(&subj),
605 "photo findable on the timeline by its EXIF instant"
606 );
607 let place = format!("{:.5},{:.5}", 48.858_333_f32, 2.294_444_f32);
609 assert!(
610 by_place(&r.quins, &place).contains(&subj),
611 "photo findable at its GPS place"
612 );
613 }
614
615 #[test]
616 fn png_time_and_dimensions_are_read() {
617 let mut b = vec![0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
619 b.extend_from_slice(&13u32.to_be_bytes());
621 b.extend_from_slice(b"IHDR");
622 b.extend_from_slice(&640u32.to_be_bytes());
623 b.extend_from_slice(&480u32.to_be_bytes());
624 b.extend_from_slice(&[8, 2, 0, 0, 0]); b.extend_from_slice(&0u32.to_be_bytes()); b.extend_from_slice(&7u32.to_be_bytes());
628 b.extend_from_slice(b"tIME");
629 b.extend_from_slice(&2020u16.to_be_bytes());
630 b.extend_from_slice(&[1, 2, 3, 4, 5]);
631 b.extend_from_slice(&0u32.to_be_bytes()); b.extend_from_slice(&0u32.to_be_bytes());
634 b.extend_from_slice(b"IEND");
635 b.extend_from_slice(&0u32.to_be_bytes());
636
637 let meta = ImageProcessor::extract(&b).expect("png metadata");
638 assert_eq!(meta.width, Some(640));
639 assert_eq!(meta.height, Some(480));
640 assert_eq!(meta.datetime_unix, Some(1_577_934_245));
642 }
643}