feat(exif): add EntryValue::NaiveDateTime #38 #39

Author: mindeng

src/exif/exif_exif.rs

@@ -1,3 +1,5 @@
+use std::fmt::Debug;
+
 use nom::{
     branch::alt, bytes::streaming::tag, combinator, number::Endianness, sequence, IResult, Needed,
 };
@@ -155,7 +157,7 @@ impl From<ExifIter> for Exif {
 }
 
 /// TIFF Header
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 pub(crate) struct TiffHeader {
     pub endian: Endianness,
     pub ifd0_offset: u32,
@@ -170,6 +172,20 @@ impl Default for TiffHeader {
     }
 }
 
+impl Debug for TiffHeader {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let endian_str = match self.endian {
+            Endianness::Big => "Big",
+            Endianness::Little => "Little",
+            Endianness::Native => "Native",
+        };
+        f.debug_struct("TiffHeader")
+            .field("endian", &endian_str)
+            .field("ifd0_offset", &format!("{:#x}", self.ifd0_offset))
+            .finish()
+    }
+}
+
 pub(crate) const IFD_ENTRY_SIZE: usize = 12;
 
 impl TiffHeader {

src/exif/exif_iter.rs

@@ -41,6 +41,11 @@ pub(crate) fn input_into_iter(
                 return Err(crate::Error::ParseFailed("no enough bytes".into()));
             }
 
+            tracing::debug!(
+                ?header,
+                data_len = format!("{:#x}", input.len()),
+                "TIFF header parsed"
+            );
             (header, start)
         }
     };
@@ -895,23 +900,38 @@ mod tests {
     use crate::file::MimeImage;
     use crate::slice::SubsliceRange;
     use crate::testkit::read_sample;
+    use crate::Exif;
     use test_case::test_case;
 
-    #[test_case("exif.jpg", "+08:00", MimeImage::Jpeg)]
-    #[test_case("broken.jpg", "", MimeImage::Jpeg)]
-    #[test_case("exif.heic", "+08:00", MimeImage::Heic)]
-    #[test_case("tif.tif", "", MimeImage::Tiff)]
-    #[test_case("fujifilm_x_t1_01.raf.meta", "", MimeImage::Raf)]
-    fn exif_iter_tz(path: &str, tz: &str, img_type: MimeImage) {
+    #[test_case("exif.jpg", "+08:00", "2023-07-09T20:36:33+08:00", MimeImage::Jpeg)]
+    #[test_case("exif-no-tz.jpg", "", "2023-07-09 20:36:33", MimeImage::Jpeg)]
+    #[test_case("broken.jpg", "-", "2014-09-21 15:51:22", MimeImage::Jpeg)]
+    #[test_case("exif.heic", "+08:00", "2022-07-22T21:26:32+08:00", MimeImage::Heic)]
+    #[test_case("tif.tif", "-", "-", MimeImage::Tiff)]
+    #[test_case(
+        "fujifilm_x_t1_01.raf.meta",
+        "-",
+        "2014-01-30 12:49:13",
+        MimeImage::Raf
+    )]
+    fn exif_iter_tz(path: &str, tz: &str, time: &str, img_type: MimeImage) {
         let buf = read_sample(path).unwrap();
         let (data, _) = extract_exif_with_mime(img_type, &buf, None).unwrap();
         let subslice_in_range = data.and_then(|x| buf.subslice_in_range(x)).unwrap();
         let iter = input_into_iter((buf, subslice_in_range), None).unwrap();
-        let expect = if tz.is_empty() {
+        let expect = if tz == "-" {
             None
         } else {
             Some(tz.to_string())
         };
         assert_eq!(iter.tz, expect);
+        let exif: Exif = iter.into();
+        let value = exif.get(crate::ExifTag::DateTimeOriginal);
+        if time == "-" {
+            assert!(value.is_none());
+        } else {
+            let value = value.unwrap();
+            assert_eq!(value.to_string(), time);
+        }
     }
 }

src/parser.rs

@@ -524,6 +524,7 @@ mod tests {
     #[case("embedded-in-heic.mov", Track)]
     #[case("exif.heic", Exif)]
     #[case("exif.jpg", Exif)]
+    #[case("exif-no-tz.jpg", Exif)]
     #[case("fujifilm_x_t1_01.raf.meta", Exif)]
     #[case("meta.mov", Track)]
     #[case("meta.mp4", Track)]

src/values.rs

@@ -1,8 +1,6 @@
 use std::{fmt::Display, string::FromUtf8Error};
 
-use chrono::{
-    offset::LocalResult, DateTime, FixedOffset, Local, NaiveDateTime, Offset, TimeZone as _, Utc,
-};
+use chrono::{DateTime, FixedOffset, NaiveDateTime, Offset, Utc};
 
 use nom::{multi::many_m_n, number::Endianness, AsChar};
 #[cfg(feature = "json_dump")]
@@ -13,6 +11,7 @@ use crate::ExifTag;
 
 /// Represent a parsed entry value.
 #[derive(Debug, Clone, PartialEq)]
+#[non_exhaustive]
 pub enum EntryValue {
     Text(String),
     URational(URational),
@@ -32,6 +31,7 @@ pub enum EntryValue {
     F64(f64),
 
     Time(DateTime<FixedOffset>),
+    NaiveDateTime(NaiveDateTime),
     Undefined(Vec<u8>),
 
     URationalArray(Vec<URational>),
@@ -141,18 +141,14 @@ impl EntryValue {
                 let s = get_cstr(data).map_err(|e| Error::InvalidData(e.to_string()))?;
 
                 let t = if let Some(tz) = tz {
-                    let s = format!("{s} {tz}");
-                    DateTime::parse_from_str(&s, "%Y:%m:%d %H:%M:%S %z")?
+                    let tz = repair_tz_str(tz);
+                    let ss = format!("{s} {tz}");
+                    match DateTime::parse_from_str(&ss, "%Y:%m:%d %H:%M:%S %z") {
+                        Ok(t) => t,
+                        Err(_) => return Ok(EntryValue::NaiveDateTime(parse_naive_time(s)?)),
+                    }
                 } else {
-                    let t = NaiveDateTime::parse_from_str(&s, "%Y:%m:%d %H:%M:%S")?;
-                    let t = Local.from_local_datetime(&t);
-                    let t = if let LocalResult::Single(t) = t {
-                        Ok(t)
-                    } else {
-                        Err(Error::InvalidData(format!("parse time failed: {s}")))
-                    }?;
-
-                    t.with_timezone(t.offset())
+                    return Ok(EntryValue::NaiveDateTime(parse_naive_time(s)?));
                 };
 
                 return Ok(EntryValue::Time(t));
@@ -370,6 +366,30 @@ impl EntryValue {
         }
     }
 }
+fn parse_naive_time(s: String) -> Result<NaiveDateTime, ParseEntryError> {
+    let t = NaiveDateTime::parse_from_str(&s, "%Y:%m:%d %H:%M:%S")?;
+    Ok(t)
+}
+// fn parse_time_with_local_tz(s: String) -> Result<DateTime<FixedOffset>, ParseEntryError> {
+//     let t = NaiveDateTime::parse_from_str(&s, "%Y:%m:%d %H:%M:%S")?;
+//     let t = Local.from_local_datetime(&t);
+//     let t = if let LocalResult::Single(t) = t {
+//         Ok(t)
+//     } else {
+//         Err(Error::InvalidData(format!("parse time failed: {s}")))
+//     }?;
+//     Ok(t.with_timezone(t.offset()))
+// }
+
+fn repair_tz_str(tz: &str) -> String {
+    if let Some(idx) = tz.find(":") {
+        if tz[idx..].len() < 3 {
+            // Add tailed 0
+            return format!("{tz}0");
+        }
+    }
+    tz.into()
+}
 
 /// # Exif Data format
 ///
@@ -457,6 +477,7 @@ impl Display for EntryValue {
             EntryValue::U8(v) => Display::fmt(&v, f),
             EntryValue::I8(v) => Display::fmt(&v, f),
             EntryValue::Time(v) => Display::fmt(&v.to_rfc3339(), f),
+            EntryValue::NaiveDateTime(v) => Display::fmt(&v.format("%Y-%m-%d %H:%M:%S"), f),
             EntryValue::Undefined(v) => {
                 // Display up to MAX_DISPLAY_NUM components, and replace the rest with ellipsis
                 const MAX_DISPLAY_NUM: usize = 8;