Merge pull request #199 from pka/planar-config

Basic support for planar configuration

src/decoder/image.rs

@@ -3,7 +3,9 @@ use super::stream::{ByteOrder, DeflateReader, JpegReader, LZWReader, PackBitsRea
 use super::tag_reader::TagReader;
 use super::{fp_predict_f32, fp_predict_f64, DecodingBuffer, Limits};
 use super::{stream::SmartReader, ChunkType};
-use crate::tags::{CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag};
+use crate::tags::{
+    CompressionMethod, PhotometricInterpretation, PlanarConfiguration, Predictor, SampleFormat, Tag,
+};
 use crate::{ColorType, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError};
 use std::convert::{TryFrom, TryInto};
 use std::io::{self, Cursor, Read, Seek};
@@ -71,6 +73,7 @@ pub(crate) struct Image {
     pub predictor: Predictor,
     pub jpeg_tables: Option<Arc<Vec<u8>>>,
     pub chunk_type: ChunkType,
+    pub planar_config: PlanarConfiguration,
     pub strip_decoder: Option<StripDecodeState>,
     pub tile_attributes: Option<TileAttributes>,
     pub chunk_offsets: Vec<u64>,
@@ -173,6 +176,23 @@ impl Image {
             .transpose()?
             .unwrap_or(Predictor::None);
 
+        let planar_config = tag_reader
+            .find_tag(Tag::PlanarConfiguration)?
+            .map(Value::into_u16)
+            .transpose()?
+            .map(|p| {
+                PlanarConfiguration::from_u16(p).ok_or(TiffError::FormatError(
+                    TiffFormatError::UnknownPlanarConfiguration(p),
+                ))
+            })
+            .transpose()?
+            .unwrap_or(PlanarConfiguration::Chunky);
+
+        let planes = match planar_config {
+            PlanarConfiguration::Chunky => 1,
+            PlanarConfiguration::Planar => samples,
+        };
+
         let chunk_type;
         let chunk_offsets;
         let chunk_bytes;
@@ -206,7 +226,7 @@ impl Image {
                 if chunk_offsets.len() != chunk_bytes.len()
                     || rows_per_strip == 0
                     || u32::try_from(chunk_offsets.len())?
-                        != height.saturating_sub(1) / rows_per_strip + 1
+                        != (height.saturating_sub(1) / rows_per_strip + 1) * planes as u32
                 {
                     return Err(TiffError::FormatError(
                         TiffFormatError::InconsistentSizesEncountered,
@@ -245,7 +265,8 @@ impl Image {
 
                 let tile = tile_attributes.as_ref().unwrap();
                 if chunk_offsets.len() != chunk_bytes.len()
-                    || chunk_offsets.len() != tile.tiles_down() * tile.tiles_across()
+                    || chunk_offsets.len()
+                        != tile.tiles_down() * tile.tiles_across() * planes as usize
                 {
                     return Err(TiffError::FormatError(
                         TiffFormatError::InconsistentSizesEncountered,
@@ -271,6 +292,7 @@ impl Image {
             jpeg_tables,
             predictor,
             chunk_type,
+            planar_config,
             strip_decoder,
             tile_attributes,
             chunk_offsets,
@@ -395,6 +417,28 @@ impl Image {
         })
     }
 
+    /// Samples per pixel within chunk.
+    ///
+    /// In planar config, samples are stored in separate strips/chunks, also called bands.
+    ///
+    /// Example with `bits_per_sample = [8, 8, 8]` and `PhotometricInterpretation::RGB`:
+    /// * `PlanarConfiguration::Chunky` -> 3 (RGBRGBRGB...)
+    /// * `PlanarConfiguration::Planar` -> 1 (RRR...) (GGG...) (BBB...)
+    pub(crate) fn samples_per_pixel(&self) -> usize {
+        match self.planar_config {
+            PlanarConfiguration::Chunky => self.bits_per_sample.len(),
+            PlanarConfiguration::Planar => 1,
+        }
+    }
+
+    /// Number of strips per pixel.
+    pub(crate) fn strips_per_pixel(&self) -> usize {
+        match self.planar_config {
+            PlanarConfiguration::Chunky => 1,
+            PlanarConfiguration::Planar => self.bits_per_sample.len(),
+        }
+    }
+
     pub(crate) fn chunk_file_range(&self, chunk: u32) -> TiffResult<(u64, u64)> {
         let file_offset = self
             .chunk_offsets
@@ -434,7 +478,10 @@ impl Image {
 
         match self.chunk_type {
             ChunkType::Strip => {
-                let strip_height_without_padding = chunk_index
+                let strip_attrs = self.strip_decoder.as_ref().unwrap();
+                let strips_per_band =
+                    self.height.saturating_sub(1) / strip_attrs.rows_per_strip + 1;
+                let strip_height_without_padding = (chunk_index % strips_per_band)
                     .checked_mul(dims.1)
                     .and_then(|x| self.height.checked_sub(x))
                     .ok_or(TiffError::UsageError(UsageError::InvalidChunkIndex(
@@ -528,7 +575,7 @@ impl Image {
         let compression_method = self.compression_method;
         let photometric_interpretation = self.photometric_interpretation;
         let predictor = self.predictor;
-        let samples = self.bits_per_sample.len();
+        let samples = self.samples_per_pixel();
 
         let chunk_dims = self.chunk_dimensions()?;
         let data_dims = self.chunk_data_dimensions(chunk_index)?;