It's working?

Author: alvinometric

src/jpeg.rs

@@ -1,5 +1,7 @@
+use crate::reader::ReadUtils;
 use crate::reader::read_iptc_data;
-use crate::{ReadUtils, tags};
+use crate::tags;
+
 use std::collections::HashMap;
 use std::error::Error;
 use tags::IPTCTag;

src/lib.rs

@@ -72,7 +72,7 @@ impl IPTC {
         if format == ImageFormat::Jpeg {
             data = JPEGReader::read_iptc(&buffer)?;
         } else if format == ImageFormat::Tiff {
-            println!("TIFF file detected");
+            println!("TIFF file detected, not all tags are supported");
             data = TIFFReader::read_iptc(&buffer)?;
         } else {
             println!("Unsupported file, only JPEG & Tiff files are supported");
@@ -81,18 +81,3 @@ impl IPTC {
         Ok(IPTC { data })
     }
 }
-
-trait ReadUtils {
-    fn read_u16be(&self, offset: usize) -> u16;
-    fn read_i16be(&self, offset: usize) -> i16;
-}
-
-impl ReadUtils for Vec<u8> {
-    fn read_u16be(&self, offset: usize) -> u16 {
-        ((self[offset] as u16) << 8) | (self[offset + 1] as u16)
-    }
-
-    fn read_i16be(&self, offset: usize) -> i16 {
-        ((self[offset] as i16) << 8) | (self[offset + 1] as i16)
-    }
-}

src/reader.rs

@@ -1,11 +1,26 @@
-use crate::{ReadUtils, tags};
+use crate::tags;
 use std::collections::HashMap;
 use std::error::Error;
 use tags::IPTCTag;
 use tags::{NULL_BLOCK, TagsMap};
 
 const FIELD_DELIMITER: u8 = 0x1c;
 
+pub trait ReadUtils {
+    fn read_u16be(&self, offset: usize) -> u16;
+    fn read_i16be(&self, offset: usize) -> i16;
+}
+
+impl ReadUtils for Vec<u8> {
+    fn read_u16be(&self, offset: usize) -> u16 {
+        ((self[offset] as u16) << 8) | (self[offset + 1] as u16)
+    }
+
+    fn read_i16be(&self, offset: usize) -> i16 {
+        ((self[offset] as i16) << 8) | (self[offset + 1] as i16)
+    }
+}
+
 #[derive(Debug)]
 struct Block {
     resource_id: i16,

src/tiff.rs

@@ -1,10 +1,10 @@
-use crate::{ReadUtils, tags};
+use crate::tags;
 use std::collections::HashMap;
 use std::error::Error;
 use std::io::Cursor;
 use tags::IPTCTag;
 use tiff::{
-    decoder::{Decoder, DecodingResult, ifd::Value},
+    decoder::{Decoder, ifd::Value},
     tags::Tag,
 };
 use xml::reader::{EventReader, XmlEvent};
@@ -18,6 +18,8 @@ impl TIFFReader {
 
         let tag_value = decoder.get_tag(Tag::Unknown(700))?;
 
+        // println!("Tag value: {:?}", tag_value);
+
         // Convert the tag value to bytes
         let bytes: Vec<u8> = match tag_value {
             Value::Byte(val) => vec![val],
@@ -32,34 +34,59 @@ impl TIFFReader {
             _ => vec![],
         };
 
-        println!("Bytes: {:?}", bytes);
+        // println!("Bytes: {:?}", bytes);
 
         // Parse the XMP data
         let data = read_xmp_data(&bytes)?;
-        println!("Data: {:?}", data);
 
-        Ok(data) // Return the parsed data instead of empty HashMap
+        Ok(data)
     }
 }
 
 fn read_xmp_data(data: &[u8]) -> Result<HashMap<IPTCTag, String>, Box<dyn Error>> {
+    // println!("Raw bytes: {:?}", data);
+    // println!("As string: {}", String::from_utf8_lossy(data));
+
     let parser = EventReader::new(Cursor::new(data));
     let mut iptc_data = HashMap::new();
     let mut current_tag: Option<IPTCTag> = None;
     let mut in_creator_seq = false;
 
     for event in parser {
         match event? {
-            XmlEvent::StartElement { name, .. } => match name.local_name.as_str() {
-                "creator" => in_creator_seq = true,
-                "li" if in_creator_seq => current_tag = Some(IPTCTag::ByLine),
-                "Caption" => current_tag = Some(IPTCTag::Caption),
-                "Description" => current_tag = Some(IPTCTag::Caption),
-                _ => {}
-            },
+            XmlEvent::StartElement {
+                name, attributes, ..
+            } => {
+                match name.local_name.as_str() {
+                    "creator" => in_creator_seq = true,
+                    "li" if in_creator_seq => current_tag = Some(IPTCTag::ByLine),
+                    "Description" => {
+                        // Look for photoshop:State and photoshop:Country in attributes
+                        for attr in attributes {
+                            if attr.name.prefix.as_deref() == Some("photoshop") {
+                                match attr.name.local_name.as_str() {
+                                    "State" => {
+                                        iptc_data.insert(IPTCTag::ProvinceOrState, attr.value);
+                                    }
+                                    "Country" => {
+                                        iptc_data.insert(
+                                            IPTCTag::CountryOrPrimaryLocationName,
+                                            attr.value,
+                                        );
+                                    }
+                                    _ => {}
+                                }
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
             XmlEvent::Characters(data) => {
                 if let Some(tag) = &current_tag {
-                    iptc_data.insert(tag.clone(), data);
+                    if !data.trim().is_empty() {
+                        iptc_data.insert(tag.clone(), data);
+                    }
                 }
             }
             XmlEvent::EndElement { name } => {

tests/DSC3003.jpg

@@ -0,0 +1,17 @@
+use std::error::Error;
+use std::path::Path;
+
+use iptc::IPTC;
+use iptc::IPTCTag;
+
+#[test]
+fn tiff_test() -> Result<(), Box<dyn Error>> {
+    // Tiff files should work too
+    let image_path = Path::new("tests/DSC3003.tif");
+    let iptc = IPTC::read_from_path(&image_path)?;
+
+    let province_or_state = iptc.get(IPTCTag::ProvinceOrState);
+    assert_eq!(province_or_state, "Ontario");
+
+    Ok(())
+}