incorporated feedback

Author: feefladder

python/README.md

@@ -31,10 +31,10 @@ primary_ifd.geo_key_directory.projected_type
 # 26918
 # (EPSG code)
 
-primary_ifd.sample_format
+primary_ifd.sample_format[0]
 # [<SampleFormat.Uint: 1>, <SampleFormat.Uint: 1>, <SampleFormat.Uint: 1>]
 
-primary_ifd.bits_per_sample
+primary_ifd.bits_per_sample[0]
 # [8, 8, 8]
 
 tile = await tiff.fetch_tile(0, 0, 4)
@@ -75,9 +75,9 @@ primary_ifd.geo_key_directory.citation
 # EPSG code
 primary_ifd.geo_key_directory.projected_type
 
-primary_ifd.sample_format[0]
+primary_ifd.sample_format
 # <SampleFormat.Uint: 1>
-primary_ifd.bits_per_sample[0]
+primary_ifd.bits_per_sample
 # 16
 
 tile = await tiff.fetch_tile(0, 0, 0)

src/cog.rs

@@ -25,7 +25,6 @@ mod test {
 
     use crate::decoder::DecoderRegistry;
     use crate::metadata::{PrefetchBuffer, TiffMetadataReader};
-    use crate::predictor::RevPredictorRegistry;
     use crate::reader::{AsyncFileReader, ObjectReader};
 
     use super::*;
@@ -53,9 +52,8 @@ 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, &predictor_registry).unwrap();
+        let tile = tile.decode(&decoder_registry, &ifd).unwrap();
         std::fs::write("img.buf", tile).unwrap();
     }
 

src/ifd.rs

@@ -12,7 +12,7 @@ use crate::tiff::tags::{
     SampleFormat, Tag,
 };
 use crate::tiff::{TiffError, Value};
-use crate::tile::{PredictorInfo, Tile};
+use crate::tile::Tile;
 
 const DOCUMENT_NAME: u16 = 269;
 
@@ -190,15 +190,18 @@ impl ImageFileDirectory {
 
         let mut other_tags = HashMap::new();
 
-        // for x in tag_data.into_iter() {
-
-        // }
         tag_data.into_iter().try_for_each(|(tag, value)| {
             match tag {
                 Tag::NewSubfileType => new_subfile_type = Some(value.into_u32()?),
                 Tag::ImageWidth => image_width = Some(value.into_u32()?),
                 Tag::ImageLength => image_height = Some(value.into_u32()?),
-                Tag::BitsPerSample => bits_per_sample = Some(value.into_u16_vec()?),
+                Tag::BitsPerSample => bits_per_sample = Some({
+                    let values = value.into_u16_vec()?;
+                    if values.iter().any(|v| *v != values[0]) {
+                        return Err(TiffError::UnsupportedError(crate::tiff::TiffUnsupportedError::InconsistentBitsPerSample(values)));
+                    }
+                    values
+                }),
                 Tag::Compression => {
                     compression = Some(CompressionMethod::from_u16_exhaustive(value.into_u16()?))
                 }
@@ -241,12 +244,11 @@ impl ImageFileDirectory {
                 Tag::ExtraSamples => extra_samples = Some(value.into_u16_vec()?),
                 Tag::SampleFormat => {
                     let values = value.into_u16_vec()?;
-                    sample_format = Some(
-                        values
-                            .into_iter()
-                            .map(SampleFormat::from_u16_exhaustive)
-                            .collect(),
-                    );
+                    // we don't support mixed sample formats
+                    if values.iter().any(|v| *v!= values[0]) {
+                        return Err(TiffError::UnsupportedError(crate::tiff::TiffUnsupportedError::UnsupportedSampleFormat(values.iter().map(|v| SampleFormat::from_u16_exhaustive(*v)).collect())));
+                    }
+                    sample_format = Some(values.iter().map(|v| SampleFormat::from_u16_exhaustive(*v)).collect());
                 }
                 Tag::JPEGTables => jpeg_tables = Some(value.into_u8_vec()?.into()),
                 Tag::Copyright => copyright = Some(value.into_string()?),
@@ -681,30 +683,6 @@ 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,
@@ -719,12 +697,7 @@ 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,
-            jpeg_tables: self.jpeg_tables.clone(),
         })
     }
 
@@ -756,12 +729,7 @@ 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,
-                jpeg_tables: self.jpeg_tables.clone(),
             };
             tiles.push(tile);
         }
@@ -775,4 +743,132 @@ impl ImageFileDirectory {
         let y_count = (self.image_height as f64 / self.tile_height? as f64).ceil();
         Some((x_count as usize, y_count as usize))
     }
+
+
+    /// width of a chunk (strip or tile)
+    /// 
+    /// In case of tile, this is [`Tag::TileWidth`], otherwise [`Tag::ImageWidth`]
+    pub fn chunk_width(&self) -> u32 {
+        if self.tile_width.is_none() {
+            // we are stripped => image_width
+            self.image_width
+        } else {
+            self.tile_width.unwrap()
+        }
+    }
+
+    /// Height of a chunk (strip or tile)
+    /// 
+    /// in case of tile, this is [`Tag::TileLength`], otherwise [`Tag::RowsPerStrip`]
+    /// 
+    /// # Panics
+    /// 
+    /// if neither `tile_height` or `rows_per_strip` is found
+    pub fn chunk_height(&self) -> u32 {
+        if self.tile_height.is_none() {
+            self.rows_per_strip
+                .expect("no tile height and no rows_per_strip")
+        } else {
+            self.tile_height.unwrap()
+        }
+    }
+
+    /// chunk width in pixels, taking padding into account
+    ///
+    /// strips are considered image-width chunks
+    pub fn chunk_width_pixels(&self, x: u32) -> AsyncTiffResult<u32> {
+        if x >= self.chunks_across() {
+            Err(crate::error::AsyncTiffError::TileIndexError(
+                x,
+                self.chunks_across(),
+            ))
+        } else if x == self.chunks_across() - 1 {
+            // last chunk
+            Ok(self.image_width - self.chunk_width() * x)
+        } else {
+            Ok(self.chunk_width())
+        }
+    }
+
+    /// chunk height in pixels, taking padding into account
+    pub fn chunk_height_pixels(&self, y: u32) -> AsyncTiffResult<u32> {
+        if y >= self.chunks_down() {
+            Err(crate::error::AsyncTiffError::TileIndexError(
+                y,
+                self.chunks_down(),
+            ))
+        } else if y == self.chunks_down() - 1 {
+            // last chunk
+            Ok(self.image_height - self.chunk_height() * y)
+        } else {
+            Ok(self.chunk_height())
+        }
+    }
+
+    /// get the output row stride in bytes, taking padding into account
+    pub fn output_row_stride(&self, x: u32) -> AsyncTiffResult<usize> {
+        Ok((self.chunk_width_pixels(x)? as usize).saturating_mul(self.bits_per_pixel()) / 8)
+    }
+
+    /// The total number of bits per pixel.
+    ///
+    /// Technically bits_per_sample.len() should be *equal* to samples, but libtiff also allows
+    /// it to be a single value that applies to all samples.
+    pub fn bits_per_pixel(&self) -> usize {
+        match self.planar_configuration {
+            PlanarConfiguration::Chunky => {
+                self.samples_per_pixel as usize * self.bits_per_sample[0] as usize
+            }
+            PlanarConfiguration::Planar => self.bits_per_sample[0] as usize,
+        }
+    }
+
+    /// The number of chunks in the horizontal (x) direction
+    pub fn chunks_across(&self) -> u32 {
+        self.image_width.div_ceil(self.chunk_width())
+    }
+
+    /// The number of chunks in the vertical (y) direction
+    pub fn chunks_down(&self) -> u32 {
+        self.image_height.div_ceil(self.chunk_height())
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use std::collections::HashMap;
+
+    use crate::{
+        reader::Endianness,
+        tiff::{tags::{PlanarConfiguration, Tag, PhotometricInterpretation}, Value}, ImageFileDirectory,
+    };
+
+    // use super::PredictorInfo;
+
+    #[test]
+    fn test_chunk_width_pixels() {
+        let mut hmap = HashMap::new();
+        hmap.insert(Tag::ImageWidth, Value::Unsigned(15));
+        hmap.insert(Tag::ImageLength, Value::Unsigned(17));
+        hmap.insert(Tag::TileWidth, Value::Unsigned(8));
+        hmap.insert(Tag::TileLength, Value::Unsigned(8));
+        hmap.insert(Tag::BitsPerSample, Value::Short(8));
+        hmap.insert(Tag::SamplesPerPixel, Value::Short(1));
+        hmap.insert(Tag::PlanarConfiguration, Value::Short(PlanarConfiguration::Chunky.to_u16()));
+        hmap.insert(Tag::PhotometricInterpretation, Value::Short(PhotometricInterpretation::BlackIsZero.to_u16()));
+        let info = ImageFileDirectory::from_tags(hmap, Endianness::LittleEndian).unwrap();
+        assert_eq!(info.bits_per_pixel(), 8);
+        assert_eq!(info.chunks_across(), 2);
+        assert_eq!(info.chunks_down(), 3);
+        assert_eq!(info.chunk_width_pixels(0).unwrap(), info.chunk_width());
+        assert_eq!(info.chunk_width_pixels(1).unwrap(), 7);
+        info.chunk_width_pixels(2).unwrap_err();
+        assert_eq!(info.chunk_height_pixels(0).unwrap(), info.chunk_height());
+        assert_eq!(info.chunk_height_pixels(2).unwrap(), 1);
+        info.chunk_height_pixels(3).unwrap_err();
+        assert_eq!(info.output_row_stride(0).unwrap(), info.chunk_width() as _); //single-byte samples
+        assert_eq!(info.output_row_stride(1).unwrap(), 7);
+        info.output_row_stride(2).unwrap_err();
+    }
 }

src/lib.rs

@@ -15,4 +15,4 @@ mod tile;
 
 pub use cog::TIFF;
 pub use ifd::ImageFileDirectory;
-pub use tile::{PredictorInfo, Tile};
+pub use tile::Tile;