feat:tag_registry added tag registry core functionality

Author: feefladder

python/src/tiff.rs

@@ -37,7 +37,7 @@ impl PyTIFF {
                 .map_err(|err| PyFileNotFoundError::new_err(err.to_string()))?;
             let mut metadata_reader = TiffMetadataReader::try_open(&metadata_fetch).await.unwrap();
             let ifds = metadata_reader
-                .read_all_ifds(&metadata_fetch)
+                .read_all_ifds(&metadata_fetch, Default::default())
                 .await
                 .unwrap();
             let tiff = TIFF::new(ifds);

src/cog.rs

@@ -44,7 +44,7 @@ mod test {
             .await
             .unwrap();
         let ifds = metadata_reader
-            .read_all_ifds(&prefetch_reader)
+            .read_all_ifds(&prefetch_reader, Default::default())
             .await
             .unwrap();
         let tiff = TIFF::new(ifds);

src/ifd.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fmt::Debug;
 use std::ops::Range;
 use std::sync::Arc;
@@ -20,15 +20,18 @@ use crate::tile::Tile;
 const DOCUMENT_NAME: u16 = 269;
 
 /// Trait to implement for custom tags, such as Geo, EXIF, OME, etc
-pub trait ExtraTags: ExtraTagsCloneArc + std::any::Any + Debug {
+/// your type should also implement `Clone`
+// Send + Sync are required for Python, where `dyn ExtraTags` needs `Send` and `Sync`
+pub trait ExtraTags: ExtraTagsCloneArc + std::any::Any + Debug + Send + Sync {
     /// a list of tags this entry processes
     /// e.g. for Geo this would be [34735, 34736, 34737]
     fn tags(&self) -> &'static [Tag];
     /// process a single tag
     fn process_tag(&mut self, tag: u16, value: Value) -> AsyncTiffResult<()>;
 }
 
-//
+// we need to do a little dance to do an object-safe deep clone
+// https://stackoverflow.com/a/30353928/14681457
 pub trait ExtraTagsCloneArc {
     fn clone_arc(&self) -> Arc<dyn ExtraTags>;
 }
@@ -46,6 +49,11 @@ where
 pub struct ExtraTagsRegistry(HashMap<Tag, Arc<dyn ExtraTags>>);
 
 impl ExtraTagsRegistry {
+    /// Create a new, empty `ExtraTagsRegistry`
+    pub fn new() -> Self{
+        Self(HashMap::new())
+    }
+    /// Register an ExtraTags so their tags are parsed and stored in the ifd's `extra_tags``
     pub fn register(&mut self, tags: Arc<dyn ExtraTags>) -> AsyncTiffResult<()> {
         // check for duplicates
         for tag in tags.tags() {
@@ -59,6 +67,32 @@ impl ExtraTagsRegistry {
         }
         Ok(())
     }
+
+    /// deep clone so we have different registries per IFD
+    pub(crate) fn deep_clone(&self) -> Self {
+        let mut new_registry = ExtraTagsRegistry::new();
+
+
+        // we need to do some magic, because we can have multiple tags pointing to the same arc
+        let mut seen = HashSet::new();
+        for extra_tags in self.0.values() {
+            // only add if this is the first encountered reference to this arc
+            // (using thin pointer equality: https://stackoverflow.com/a/67114787/14681457 ; https://github.com/rust-lang/rust/issues/46139#issuecomment-346971153)
+            if seen.insert(Arc::as_ptr(extra_tags) as *const ()) {
+                if let Err(e) = new_registry.register(extra_tags.clone_arc()) {
+                    panic!("{e}");
+                }
+            }
+        }
+
+        new_registry
+    }
+}
+
+impl Default for ExtraTagsRegistry {
+    fn default() -> Self {
+        Self::new() // add e.g. geo tags later
+    }
 }
 
 /// An ImageFileDirectory representing Image content

src/metadata/mod.rs

@@ -40,7 +40,7 @@
 //!
 //! // Read all IFDs out of the source.
 //! let ifds = metadata_reader
-//!     .read_all_ifds(&prefetch_reader)
+//!     .read_all_ifds(&prefetch_reader, Default::default())
 //!     .await
 //!     .unwrap();
 //! # })

src/metadata/reader.rs

@@ -111,12 +111,13 @@ impl TiffMetadataReader {
     pub async fn read_next_ifd<F: MetadataFetch>(
         &mut self,
         fetch: &F,
+        extra_tags_registry: ExtraTagsRegistry,
     ) -> AsyncTiffResult<Option<ImageFileDirectory>> {
         if let Some(ifd_start) = self.next_ifd_offset {
             let ifd_reader =
                 ImageFileDirectoryReader::open(fetch, ifd_start, self.bigtiff, self.endianness)
                     .await?;
-            let ifd = ifd_reader.read(fetch).await?;
+            let ifd = ifd_reader.read(fetch, extra_tags_registry).await?;
             let next_ifd_offset = ifd_reader.finish(fetch).await?;
             self.next_ifd_offset = next_ifd_offset;
             Ok(Some(ifd))
@@ -129,9 +130,11 @@ impl TiffMetadataReader {
     pub async fn read_all_ifds<F: MetadataFetch>(
         &mut self,
         fetch: &F,
+        extra_tags_registry: ExtraTagsRegistry,
     ) -> AsyncTiffResult<Vec<ImageFileDirectory>> {
         let mut ifds = vec![];
-        while let Some(ifd) = self.read_next_ifd(fetch).await? {
+        // deep clone the extra_tags_registry so we can have different values
+        while let Some(ifd) = self.read_next_ifd(fetch, extra_tags_registry.deep_clone()).await? {
             ifds.push(ifd);
         }
         Ok(ifds)
@@ -158,8 +161,6 @@ pub struct ImageFileDirectoryReader {
     ifd_entry_byte_size: u64,
     /// The number of bytes that the value for the number of tags takes up.
     tag_count_byte_size: u64,
-    /// Registry for parsing extra tags
-    extra_tags_registry: ExtraTagsRegistry,
 }
 
 impl ImageFileDirectoryReader {
@@ -169,7 +170,6 @@ impl ImageFileDirectoryReader {
         ifd_start_offset: u64,
         bigtiff: bool,
         endianness: Endianness,
-        extra_tags_registry: ExtraTagsRegistry,
     ) -> AsyncTiffResult<Self> {
         let mut cursor = MetadataCursor::new_with_offset(fetch, endianness, ifd_start_offset);
 
@@ -198,7 +198,6 @@ impl ImageFileDirectoryReader {
             tag_count,
             tag_count_byte_size,
             ifd_start_offset,
-            extra_tags_registry,
         })
     }
 
@@ -225,13 +224,13 @@ impl ImageFileDirectoryReader {
     ///
     /// Keep in mind that you'll still need to call [`finish`][Self::finish] to get the byte offset
     /// of the next IFD.
-    pub async fn read<F: MetadataFetch>(&self, fetch: &F) -> AsyncTiffResult<ImageFileDirectory> {
+    pub async fn read<F: MetadataFetch>(&self, fetch: &F, extra_tags_registry: ExtraTagsRegistry) -> AsyncTiffResult<ImageFileDirectory> {
         let mut tags = HashMap::with_capacity(self.tag_count as usize);
         for tag_idx in 0..self.tag_count {
             let (tag, value) = self.read_tag(fetch, tag_idx).await?;
             tags.insert(tag, value);
         }
-        ImageFileDirectory::from_tags(tags, self.endianness, self.extra_tags_registry)
+        ImageFileDirectory::from_tags(tags, self.endianness, extra_tags_registry)
     }
 
     /// Finish this reader, reading the byte offset of the next IFD

tests/image_tiff/util.rs

@@ -14,6 +14,6 @@ pub(crate) async fn open_tiff(filename: &str) -> TIFF {
     let reader = Arc::new(ObjectReader::new(store.clone(), path.as_str().into()))
         as Arc<dyn AsyncFileReader>;
     let mut metadata_reader = TiffMetadataReader::try_open(&reader).await.unwrap();
-    let ifds = metadata_reader.read_all_ifds(&reader).await.unwrap();
+    let ifds = metadata_reader.read_all_ifds(&reader, Default::default()).await.unwrap();
     TIFF::new(ifds)
 }

tests/util/mod.rs

@@ -17,7 +17,7 @@ pub(crate) async fn open_remote_tiff(url: &str) -> TIFF {
         .await
         .unwrap();
     let ifds = metadata_reader
-        .read_all_ifds(&prefetch_reader)
+        .read_all_ifds(&prefetch_reader, Default::default())
         .await
         .unwrap();
     TIFF::new(ifds)