added predictors

Author: feefladder

src/cog.rs

@@ -25,6 +25,7 @@ mod test {
 
     use crate::decoder::DecoderRegistry;
     use crate::metadata::{PrefetchBuffer, TiffMetadataReader};
+    use crate::predictor::RevPredictorRegistry;
     use crate::reader::{AsyncFileReader, ObjectReader};
 
     use super::*;
@@ -52,8 +53,9 @@ mod test {
 
         let ifd = &tiff.ifds[1];
         let decoder_registry = DecoderRegistry::default();
+        let predictor_registry = RevPredictorRegistry::default();
         let tile = ifd.fetch_tile(0, 0, reader.as_ref()).await.unwrap();
-        let tile = tile.decode(&decoder_registry).unwrap();
+        let tile = tile.decode(&decoder_registry, &predictor_registry).unwrap();
         std::fs::write("img.buf", tile).unwrap();
     }
 

src/error.rs

@@ -15,6 +15,10 @@ pub enum AsyncTiffError {
     #[error("General error: {0}")]
     General(String),
 
+    /// Tile index error
+    #[error("Tile index out of bounds: {0}, {1}")]
+    TileIndexError(u32, u32),
+
     /// IO Error.
     #[error(transparent)]
     IOError(#[from] std::io::Error),

src/ifd.rs

@@ -6,13 +6,13 @@ use num_enum::TryFromPrimitive;
 
 use crate::error::{AsyncTiffError, AsyncTiffResult};
 use crate::geo::{GeoKeyDirectory, GeoKeyTag};
-use crate::reader::AsyncFileReader;
+use crate::reader::{AsyncFileReader, Endianness};
 use crate::tiff::tags::{
     CompressionMethod, PhotometricInterpretation, PlanarConfiguration, Predictor, ResolutionUnit,
     SampleFormat, Tag,
 };
 use crate::tiff::{TiffError, Value};
-use crate::tile::Tile;
+use crate::tile::{PredictorInfo, Tile};
 
 const DOCUMENT_NAME: u16 = 269;
 
@@ -21,6 +21,8 @@ const DOCUMENT_NAME: u16 = 269;
 #[allow(dead_code)]
 #[derive(Debug, Clone)]
 pub struct ImageFileDirectory {
+    pub(crate) endianness: Endianness,
+
     pub(crate) new_subfile_type: Option<u32>,
 
     /// The number of columns in the image, i.e., the number of pixels per row.
@@ -143,7 +145,10 @@ pub struct ImageFileDirectory {
 
 impl ImageFileDirectory {
     /// Create a new ImageFileDirectory from tag data
-    pub fn from_tags(tag_data: HashMap<Tag, Value>) -> AsyncTiffResult<Self> {
+    pub fn from_tags(
+        tag_data: HashMap<Tag, Value>,
+        endianness: Endianness,
+    ) -> AsyncTiffResult<Self> {
         let mut new_subfile_type = None;
         let mut image_width = None;
         let mut image_height = None;
@@ -349,6 +354,7 @@ impl ImageFileDirectory {
             PlanarConfiguration::Chunky
         };
         Ok(Self {
+            endianness,
             new_subfile_type,
             image_width: image_width.expect("image_width not found"),
             image_height: image_height.expect("image_height not found"),
@@ -675,6 +681,30 @@ impl ImageFileDirectory {
         Some(offset as _..(offset + byte_count) as _)
     }
 
+    fn get_predictor_info(&self) -> PredictorInfo {
+        PredictorInfo {
+            endianness: self.endianness,
+            image_width: self.image_width,
+            image_height: self.image_height,
+            chunk_width: if self.tile_width.is_none() {
+                // we are stripped => image_width
+                self.image_width
+            } else {
+                self.tile_width.unwrap()
+            },
+            chunk_height: if self.tile_height.is_none() {
+                self.rows_per_strip
+                    .expect("no tile height and no rows_per_strip")
+            } else {
+                self.tile_height.unwrap()
+            },
+            bits_per_sample: &self.bits_per_sample,
+            samples_per_pixel: self.samples_per_pixel,
+            sample_format: &self.sample_format,
+            planar_configuration: self.planar_configuration,
+        }
+    }
+
     /// Fetch the tile located at `x` column and `y` row using the provided reader.
     pub async fn fetch_tile(
         &self,
@@ -689,6 +719,8 @@ impl ImageFileDirectory {
         Ok(Tile {
             x,
             y,
+            predictor: self.predictor.unwrap_or(Predictor::None),
+            predictor_info: self.get_predictor_info(),
             compressed_bytes,
             compression_method: self.compression,
             photometric_interpretation: self.photometric_interpretation,
@@ -724,6 +756,8 @@ impl ImageFileDirectory {
             let tile = Tile {
                 x,
                 y,
+                predictor: self.predictor.unwrap_or(Predictor::None),
+                predictor_info: self.get_predictor_info(),
                 compressed_bytes,
                 compression_method: self.compression,
                 photometric_interpretation: self.photometric_interpretation,

src/lib.rs

@@ -9,6 +9,7 @@ pub mod error;
 pub mod geo;
 mod ifd;
 pub mod metadata;
+pub mod predictor;
 pub mod tiff;
 mod tile;
 

src/metadata/reader.rs

@@ -226,7 +226,7 @@ impl ImageFileDirectoryReader {
             let (tag, value) = self.read_tag(fetch, tag_idx).await?;
             tags.insert(tag, value);
         }
-        ImageFileDirectory::from_tags(tags)
+        ImageFileDirectory::from_tags(tags, self.endianness)
     }
 
     /// Finish this reader, reading the byte offset of the next IFD
@@ -623,11 +623,14 @@ async fn read_tag_value<F: MetadataFetch>(
 
 #[cfg(test)]
 mod test {
+    use crate::{
+        metadata::{reader::read_tag, MetadataFetch},
+        reader::Endianness,
+        tiff::{tags::Tag, Value},
+    };
     use bytes::Bytes;
     use futures::FutureExt;
 
-    use super::*;
-
     impl MetadataFetch for Bytes {
         fn fetch(
             &self,