Skip to main content

qualia_core_db/hypermedia/processors/
image.rs

1//! **ImageProcessor** — derive searchability from a photo's *own* embedded
2//! metadata (EXIF / PNG chunks). Model-free and deterministic: it reads what
3//! the camera already wrote into the file.
4//!
5//! This is the engine behind "the events of a day/period on a timeline or a
6//! map — travelling, with locations, photos": a JPEG's `DateTimeOriginal`
7//! becomes the asset's `occurred_at` (timeline anchor) and its GPS tags become
8//! a [`Place`] with real coordinates (map pin). Camera make/model become
9//! topics. No pixels are interpreted.
10//!
11//! **Honest boundary.** *What the image depicts* (object/scene recognition) and
12//! OCR are a **vision-model** concern — that is the [`Processor`] plug-in point
13//! for the `qualia-vision` engine, not something this metadata reader fabricates.
14//! It derives `depicts` **only** from tags the file itself carries, never guesses.
15
16use std::collections::HashMap;
17
18use super::super::{fnv60, AssetRef, AssetRole, Descriptors, Place, Processor, ProcessorOutput};
19
20/// Metadata read out of an image's own header — none of it inferred from pixels.
21#[derive(Debug, Clone, Default, PartialEq)]
22pub struct ImageMetadata {
23    /// Capture instant (unix seconds, naive-UTC — EXIF carries no timezone).
24    pub datetime_unix: Option<i64>,
25    /// GPS latitude / longitude in signed decimal degrees.
26    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    /// `true` when `any` present.
36    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/// A real, **model-free** image processor: extracts EXIF (JPEG) / PNG metadata
46/// → timeline + map facets. The depicted-subject / OCR path is a vision-model
47/// plug-in, not faked here.
48#[derive(Debug, Clone, Default)]
49pub struct ImageProcessor;
50
51impl ImageProcessor {
52    /// Parse an image's embedded metadata (JPEG EXIF or PNG chunks). Returns
53    /// `None` if the bytes are not a recognised image or carry no metadata.
54    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                // No reverse-geocoding here (that needs an external gazetteer —
89                // a plug-in). The coordinate string is the honest place label;
90                // the map view uses the real lat/lon below.
91                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(), // vision-model plug-in point — never guessed
101            occurred_at: meta.datetime_unix,
102            place,
103            document_type: Some("image".to_string()),
104            ..Default::default()
105        };
106
107        // A human-readable, searchable metadata derivation of the original — what
108        // makes an otherwise-opaque photo findable by meaning.
109        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
146// ── format sniffing ─────────────────────────────────────────────────────────
147
148fn 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
155// ── JPEG: find the APP1/Exif segment, parse the TIFF/IFD tree ────────────────
156
157fn parse_jpeg(b: &[u8]) -> ImageMetadata {
158    // Walk JPEG marker segments looking for APP1 (0xFFE1) carrying "Exif\0\0".
159    let mut i = 2; // skip SOI (FFD8)
160    while i + 4 <= b.len() {
161        if b[i] != 0xFF {
162            break;
163        }
164        let marker = b[i + 1];
165        // Standalone markers (RSTn, SOI, EOI, TEM) have no length.
166        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        // Stop at start-of-scan; EXIF always precedes it.
179        if marker == 0xDA {
180            break;
181        }
182        i += 2 + seg_len;
183    }
184    ImageMetadata::default()
185}
186
187// ── TIFF/EXIF IFD parser ─────────────────────────────────────────────────────
188
189#[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, // BYTE, ASCII, SBYTE, UNDEFINED
217        3 | 8 => 2,         // SHORT, SSHORT
218        4 | 9 | 11 => 4,    // LONG, SLONG, FLOAT
219        5 | 10 | 12 => 8,   // RATIONAL, SRATIONAL, DOUBLE
220        _ => 0,
221    }
222}
223
224/// One IFD entry, resolved to where its value bytes live.
225struct Entry {
226    typ: u16,
227    count: u32,
228    /// Absolute offset (into the TIFF buffer) of the value bytes.
229    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                // DateTimeOriginal takes precedence over IFD0 DateTime.
266                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
313/// Iterate an IFD's entries, calling `f(tag, entry)` for each with a resolved
314/// value offset. Bounds-checked; a malformed IFD simply yields fewer entries.
315fn 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        // Value is inline in the 4-byte field when it fits, else `field` is an offset.
332        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
366/// Read a single LONG or SHORT value (used for IFD pointers and dimensions).
367fn 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
375/// Read a RATIONAL at `off` as f64 (num/den).
376fn 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
386/// GPS coordinate: three RATIONALs (deg, min, sec) → signed decimal degrees.
387fn 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
397/// Parse EXIF `"YYYY:MM:DD HH:MM:SS"` to unix seconds (naive UTC — EXIF has no tz).
398fn parse_exif_datetime(s: &str) -> Option<i64> {
399    let s = s.trim();
400    // Expect at least the date; time is optional.
401    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
423/// Days since the unix epoch for a civil (proleptic Gregorian) date.
424/// Howard Hinnant's algorithm.
425fn 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; // [0, 399]
429    let mp = if m > 2 { m - 3 } else { m + 9 }; // [0, 11]
430    let doy = (153 * mp + 2) / 5 + d - 1; // [0, 365]
431    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; // [0, 146096]
432    era * 146097 + doe - 719468
433}
434
435// ── PNG: tIME chunk + optional eXIf chunk ─────────────────────────────────────
436
437fn parse_png(b: &[u8]) -> ImageMetadata {
438    let mut meta = ImageMetadata::default();
439    let mut i = 8; // skip signature
440                   // First chunk is IHDR: width/height are the first two u32 of its data.
441    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                    // eXIf wins for datetime/gps/make/model; keep IHDR dims.
476                    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; // skip CRC
486    }
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    /// Build a minimal little-endian TIFF/EXIF blob with DateTimeOriginal + GPS,
496    /// then confirm the processor turns it into timeline + map facets.
497    fn tiff_with_datetime_and_gps() -> Vec<u8> {
498        // Layout: header(8) | IFD0 | EXIF-IFD | GPS-IFD | value heap.
499        // We hand-place offsets. All little-endian.
500        let mut b = Vec::new();
501        // --- header ---
502        b.extend_from_slice(b"II"); // little-endian
503        b.extend_from_slice(&42u16.to_le_bytes());
504        b.extend_from_slice(&8u32.to_le_bytes()); // IFD0 at offset 8
505
506        // We will compute offsets as we go. Reserve fixed positions:
507        // IFD0 at 8: 2 entries (Exif ptr, GPS ptr) + next=0 → 2 + 2*12 + 4 = 30 bytes → ends at 38.
508        // EXIF-IFD at 38: 1 entry (DateTimeOriginal) → 2 + 12 + 4 = 18 → ends at 56.
509        // GPS-IFD at 56: 4 entries (latRef, lat, lonRef, lon) → 2 + 4*12 + 4 = 54 → ends at 110.
510        // value heap starts at 110.
511        let exif_ifd = 38u32;
512        let gps_ifd = 56u32;
513        let heap = 110u32;
514
515        // --- IFD0 (offset 8) ---
516        b.extend_from_slice(&2u16.to_le_bytes()); // entry count
517                                                  // Exif IFD pointer (tag 0x8769, LONG, count1)
518        push_entry(&mut b, 0x8769, 4, 1, exif_ifd);
519        // GPS IFD pointer (tag 0x8825, LONG, count1)
520        push_entry(&mut b, 0x8825, 4, 1, gps_ifd);
521        b.extend_from_slice(&0u32.to_le_bytes()); // next IFD = 0
522        assert_eq!(b.len(), exif_ifd as usize);
523
524        // --- EXIF IFD (offset 38) ---
525        let dt = b"2021:07:14 09:30:00\0"; // 20 bytes → on heap
526        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); // DateTimeOriginal ASCII
529        b.extend_from_slice(&0u32.to_le_bytes());
530        assert_eq!(b.len(), gps_ifd as usize);
531
532        // --- GPS IFD (offset 56) ---
533        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; // after datetime on heap
536        let lon_off = lat_off + 24; // 3 rationals = 24 bytes
537        b.extend_from_slice(&4u16.to_le_bytes());
538        push_entry(&mut b, 0x0001, 2, 2, latref_inline); // GPSLatitudeRef 'N'
539        push_entry(&mut b, 0x0002, 5, 3, lat_off); // GPSLatitude (3 rationals)
540        push_entry(&mut b, 0x0003, 2, 2, lonref_inline); // GPSLongitudeRef 'E'
541        push_entry(&mut b, 0x0004, 5, 3, lon_off); // GPSLongitude (3 rationals)
542        b.extend_from_slice(&0u32.to_le_bytes());
543        assert_eq!(b.len(), heap as usize);
544
545        // --- value heap (offset 110) ---
546        b.extend_from_slice(dt); // datetime string
547                                 // lat = 48° 51' 30" (≈ Paris 48.858333)
548        push_rational(&mut b, 48, 1);
549        push_rational(&mut b, 51, 1);
550        push_rational(&mut b, 30, 1);
551        // lon = 2° 17' 40" (≈ 2.294444)
552        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        // FFD8 SOI | FFE1 APP1 [len][Exif\0\0][tiff] | FFD9 EOI
571        let mut b = vec![0xFF, 0xD8];
572        let payload_len = 2 + 6 + tiff.len(); // len field + "Exif\0\0" + tiff
573        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        // 2021-07-14 09:30:00 UTC = 1626255000
587        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        // On the timeline: a window around the capture instant finds the photo.
602        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        // On the map: the coordinate-labelled place finds it.
608        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        // 8-byte sig | IHDR(len13) | tIME(len7) | IEND
618        let mut b = vec![0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
619        // IHDR
620        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]); // bit depth, colour, etc.
625        b.extend_from_slice(&0u32.to_be_bytes()); // fake CRC
626                                                  // tIME = 2020-01-02 03:04:05
627        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()); // fake CRC
632                                                  // IEND
633        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        // 2020-01-02 03:04:05 UTC = 1577934245
641        assert_eq!(meta.datetime_unix, Some(1_577_934_245));
642    }
643}