Implement iptc_metadata for TiffDecoder

Author: 1c3t3a

src/codecs/tiff.rs

@@ -9,7 +9,7 @@ use std::io::{self, BufRead, Cursor, Read, Seek, Write};
 use std::marker::PhantomData;
 use std::mem;
 
-use tiff::decoder::{Decoder, DecodingResult};
+use tiff::decoder::{Decoder, DecodingResult, ifd::Value};
 use tiff::tags::Tag;
 
 use crate::color::{ColorType, ExtendedColorType};
@@ -21,6 +21,8 @@ use crate::metadata::Orientation;
 use crate::{utils, ImageDecoder, ImageEncoder, ImageFormat};
 
 const TAG_XML_PACKET: Tag = Tag::Unknown(700);
+const TAG_PHOTOSHOP: Tag = Tag::Unknown(34377);
+const TAG_RICHTIFF_IPTC: Tag = Tag::Unknown(33723);
 
 /// Decoder for TIFF images.
 pub struct TiffDecoder<R>
@@ -284,6 +286,30 @@ impl<R: BufRead + Seek> ImageDecoder for TiffDecoder<R> {
             .map_err(ImageError::from_tiff_decode)
     }
 
+    fn iptc_metadata(&mut self) -> ImageResult<Option<Vec<u8>>> {
+        let Some(decoder) = &mut self.inner else {
+            return Ok(None);
+        };
+
+        if let Ok(value) = decoder.get_tag(TAG_PHOTOSHOP) {
+            let mut result = Vec::new();
+            value_to_bytes(value, &mut result)?;
+            return Ok(Some(result));
+        }
+
+        let value = match decoder.get_tag(TAG_RICHTIFF_IPTC) {
+            Ok(value) => value,
+            Err(tiff::TiffError::FormatError(tiff::TiffFormatError::RequiredTagNotFound(_))) => {
+                return Ok(None);
+            }
+            Err(err) => return Err(ImageError::from_tiff_decode(err)),
+        };
+
+        let mut result = Vec::new();
+        value_to_bytes(value, &mut result)?;
+        Ok(Some(result))
+    }
+
     fn orientation(&mut self) -> ImageResult<Orientation> {
         if let Some(decoder) = &mut self.inner {
             Ok(decoder
@@ -510,3 +536,42 @@ impl<W: Write + Seek> ImageEncoder for TiffEncoder<W> {
         self.encode(buf, width, height, color_type)
     }
 }
+
+/// This method converts a `Value` to a vector of bytes. A `Value` in Tiff can have different
+/// types, e.g. a byte, a short or a float. This method intents to convert all these types to
+/// a vector of bytes (e.g. a u32 can be represented as a [u8; 4]). However, since this is only
+/// intended to parse values stored in XMP, IPTC and EXIF metadata sections, we ignore / return
+/// an error on a few Values that don't make sense in this context (e.g. Value::Ifd).
+fn value_to_bytes(value: Value, bytes: &mut Vec<u8>) -> ImageResult<()> {
+    match value {
+        Value::Byte(byte) => bytes.push(byte),
+        Value::SignedByte(sbyte) => bytes.push(sbyte as u8),
+        Value::Short(short) => bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 2]>(short)),
+        Value::SignedShort(sshort) => {
+            bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 2]>(sshort))
+        }
+        Value::Signed(signed) => bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 4]>(signed)),
+        Value::SignedBig(big) => bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 8]>(big)),
+        Value::Unsigned(unsigned) => {
+            bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 4]>(unsigned))
+        }
+        Value::UnsignedBig(big) => bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 8]>(big)),
+        Value::Float(float) => bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 4]>(float)),
+        Value::Double(double) => bytes.extend_from_slice(&bytemuck::cast::<_, [u8; 8]>(double)),
+        Value::List(values) => {
+            for value in values {
+                value_to_bytes(value, bytes)?;
+            }
+        }
+        Value::Ascii(str) => bytes.extend_from_slice(str.as_bytes()),
+        _ => {
+            return Err(ImageError::Unsupported(
+                UnsupportedError::from_format_and_kind(
+                    ImageFormat::Tiff.into(),
+                    UnsupportedErrorKind::GenericFeature("unable to process metadata".to_owned()),
+                ),
+            ))
+        }
+    }
+    Ok(())
+}

tests/images/tiff/testsuite/l1_iptc.tiff

@@ -116,3 +116,22 @@ fn test_read_iptc_png() -> Result<(), image::ImageError> {
 
     Ok(())
 }
+
+#[test]
+#[cfg(feature = "tiff")]
+fn test_read_iptc_tiff() -> Result<(), image::ImageError> {
+    const IPTC_TIFF_PATH: &str = "tests/images/tiff/testsuite/l1_iptc.tiff";
+    const EXPECTED_METADATA: &[u8] = &[
+        28, 2, 90, 0, 8, 75, 105, 110, 103, 115, 116, 111, 110, 28, 2, 0, 0, 2, 0, 4,
+    ];
+
+    let img_path = PathBuf::from_str(IPTC_TIFF_PATH).unwrap();
+
+    let data = fs::read(img_path)?;
+    let mut tiff_decoder = TiffDecoder::new(std::io::Cursor::new(data))?;
+    let metadata = tiff_decoder.iptc_metadata()?;
+    assert!(metadata.is_some());
+    assert_eq!(EXPECTED_METADATA, metadata.unwrap());
+
+    Ok(())
+}