Remove lifetime and store a single element for bits_per_pixel

Author: kylebarron

src/ifd.rs

@@ -682,6 +682,10 @@ impl ImageFileDirectory {
     }
 
     fn get_predictor_info(&self) -> PredictorInfo {
+        if !self.bits_per_sample.windows(2).all(|w| w[0] == w[1]) {
+            panic!("bits_per_sample should be the same for all channels");
+        }
+
         PredictorInfo {
             endianness: self.endianness,
             image_width: self.image_width,
@@ -698,7 +702,7 @@ impl ImageFileDirectory {
             } else {
                 self.tile_height.unwrap()
             },
-            bits_per_sample: &self.bits_per_sample,
+            bits_per_sample: self.bits_per_sample[0],
             samples_per_pixel: self.samples_per_pixel,
             planar_configuration: self.planar_configuration,
         }

src/predictor.rs

@@ -34,7 +34,7 @@ impl Unpredict for NoPredictor {
         fix_endianness(
             &mut res[..],
             predictor_info.endianness,
-            predictor_info.bits_per_sample[0],
+            predictor_info.bits_per_sample,
         );
         Ok(res.into())
     }
@@ -54,7 +54,7 @@ impl Unpredict for HorizontalPredictor {
     ) -> AsyncTiffResult<Bytes> {
         let output_row_stride = predictor_info.output_row_stride(tile_x)?;
         let samples = predictor_info.samples_per_pixel as usize;
-        let bit_depth = predictor_info.bits_per_sample[0];
+        let bit_depth = predictor_info.bits_per_sample;
 
         let mut res = BytesMut::from(buffer);
         fix_endianness(&mut res[..], predictor_info.endianness, bit_depth);
@@ -152,7 +152,7 @@ impl Unpredict for FloatingPointPredictor {
         let mut res: BytesMut = BytesMut::zeroed(
             output_row_stride * predictor_info.chunk_height_pixels(tile_y)? as usize,
         );
-        let bit_depth = predictor_info.bits_per_sample[0] as usize;
+        let bit_depth = predictor_info.bits_per_sample;
         if predictor_info.chunk_width_pixels(tile_x)? == predictor_info.chunk_width {
             // no special padding handling
             let mut input = BytesMut::from(buffer);
@@ -173,7 +173,7 @@ impl Unpredict for FloatingPointPredictor {
             let mut input = BytesMut::from(buffer);
 
             let input_row_stride =
-                predictor_info.chunk_width as usize * predictor_info.bits_per_pixel() / 8;
+                predictor_info.chunk_width as usize * predictor_info.bits_per_sample as usize / 8;
             for (in_buf, out_buf) in input
                 .chunks_mut(input_row_stride)
                 .zip(res.chunks_mut(output_row_stride))
@@ -297,7 +297,7 @@ mod test {
         image_height: 7,
         chunk_width: 4,
         chunk_height: 4,
-        bits_per_sample: &[8],
+        bits_per_sample: 8,
         samples_per_pixel: 1,
         planar_configuration: crate::tiff::tags::PlanarConfiguration::Chunky,
     };
@@ -379,104 +379,104 @@ mod test {
         for (x,y, input, expected) in cases {
             println!("uints littleendian");
             predictor_info.endianness = Endianness::LittleEndian;
-            predictor_info.bits_per_sample = &[8];
+            predictor_info.bits_per_sample = 8;
             assert_eq!(-1i32 as u8, 255);
             println!("testing u8");
             let buffer = Bytes::from(input.iter().map(|v| *v as u8).collect::<Vec<_>>());
             let res = Bytes::from(expected.clone());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u16, u16::MAX);
             println!("testing u16");
-            predictor_info.bits_per_sample = &[16];
+            predictor_info.bits_per_sample = 16;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as u16).to_le_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as u16).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u32, u32::MAX);
             println!("testing u32");
-            predictor_info.bits_per_sample = &[32];
+            predictor_info.bits_per_sample = 32;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as u32).to_le_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as u32).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u64, u64::MAX);
             println!("testing u64");
-            predictor_info.bits_per_sample = &[64];
+            predictor_info.bits_per_sample = 64;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as u64).to_le_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as u64).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
 
             println!("ints littleendian");
-            predictor_info.bits_per_sample = &[8];
+            predictor_info.bits_per_sample = 8;
             println!("testing i8");
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as i8).to_le_bytes()).collect::<Vec<_>>());
             println!("{:?}", &buffer[..]);
             let res = Bytes::from(expected.clone());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap()[..], res[..]);
             println!("testing i16");
-            predictor_info.bits_per_sample = &[16];
+            predictor_info.bits_per_sample = 16;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as i16).to_le_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as i16).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             println!("testing i32");
-            predictor_info.bits_per_sample = &[32];
+            predictor_info.bits_per_sample = 32;
             let buffer = Bytes::from(input.iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as i32).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             println!("testing i64");
-            predictor_info.bits_per_sample = &[64];
+            predictor_info.bits_per_sample = 64;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as i64).to_le_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as i64).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
 
             println!("uints bigendian");
             predictor_info.endianness = Endianness::BigEndian;
-            predictor_info.bits_per_sample = &[8];
+            predictor_info.bits_per_sample = 8;
             assert_eq!(-1i32 as u8, 255);
             println!("testing u8");
             let buffer = Bytes::from(input.iter().map(|v| *v as u8).collect::<Vec<_>>());
             let res = Bytes::from(expected.clone());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u16, u16::MAX);
             println!("testing u16");
-            predictor_info.bits_per_sample = &[16];
+            predictor_info.bits_per_sample = 16;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as u16).to_be_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as u16).to_ne_bytes()).collect::<Vec<_>>());
             println!("buffer: {:?}", &buffer[..]);
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap()[..], res[..]);
             assert_eq!(-1i32 as u32, u32::MAX);
             println!("testing u32");
-            predictor_info.bits_per_sample = &[32];
+            predictor_info.bits_per_sample = 32;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as u32).to_be_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as u32).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u64, u64::MAX);
             println!("testing u64");
-            predictor_info.bits_per_sample = &[64];
+            predictor_info.bits_per_sample = 64;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as u64).to_be_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as u64).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
 
             println!("ints bigendian");
-            predictor_info.bits_per_sample = &[8];
+            predictor_info.bits_per_sample = 8;
             assert_eq!(-1i32 as u8, 255);
             println!("testing i8");
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as i8).to_be_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.clone());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u16, u16::MAX);
             println!("testing i16");
-            predictor_info.bits_per_sample = &[16];
+            predictor_info.bits_per_sample = 16;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as i16).to_be_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as i16).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u32, u32::MAX);
             println!("testing i32");
-            predictor_info.bits_per_sample = &[32];
+            predictor_info.bits_per_sample = 32;
             let buffer = Bytes::from(input.iter().flat_map(|v| v.to_be_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as i32).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
             assert_eq!(-1i32 as u64, u64::MAX);
             println!("testing i64");
-            predictor_info.bits_per_sample = &[64];
+            predictor_info.bits_per_sample = 64;
             let buffer = Bytes::from(input.iter().flat_map(|v| (*v as i64).to_be_bytes()).collect::<Vec<_>>());
             let res = Bytes::from(expected.iter().flat_map(|v| (*v as i64).to_ne_bytes()).collect::<Vec<_>>());
             assert_eq!(p.fix_endianness_and_unpredict(buffer, &predictor_info, x, y).unwrap(), res);
@@ -501,7 +501,7 @@ mod test {
             image_height: 4+1,
             chunk_width: 4,
             chunk_height: 4,
-            bits_per_sample: &[16],
+            bits_per_sample: 16,
             samples_per_pixel: 1,
             planar_configuration: PlanarConfiguration::Chunky,
         };
@@ -530,7 +530,7 @@ mod test {
             image_height: 4+1,
             chunk_width: 4,
             chunk_height: 4,
-            bits_per_sample: &[16],
+            bits_per_sample: 16,
             samples_per_pixel: 1,
             planar_configuration: PlanarConfiguration::Chunky,
         };
@@ -558,7 +558,7 @@ mod test {
             image_height: 2 + 1,
             chunk_width: 2,
             chunk_height: 2,
-            bits_per_sample: &[32],
+            bits_per_sample: 32,
             samples_per_pixel: 1,
             planar_configuration: PlanarConfiguration::Chunky,
         };
@@ -592,7 +592,7 @@ mod test {
             image_height: 2 + 1,
             chunk_width: 2,
             chunk_height: 2,
-            bits_per_sample: &[64],
+            bits_per_sample: 64,
             samples_per_pixel: 1,
             planar_configuration: PlanarConfiguration::Chunky,
         };

src/tile.rs

@@ -17,7 +17,7 @@ use crate::tiff::{TiffError, TiffUnsupportedError};
 /// Also provides convenience functions
 ///
 #[derive(Debug, Clone, Copy)]
-pub(crate) struct PredictorInfo<'a> {
+pub(crate) struct PredictorInfo {
     /// endianness
     pub(crate) endianness: Endianness,
     /// width of the image in pixels
@@ -30,10 +30,10 @@ pub(crate) struct PredictorInfo<'a> {
     pub(crate) chunk_width: u32,
     /// chunk height in pixels
     pub(crate) chunk_height: u32,
-    /// bits per sample, as an array
+    /// bits per sample
     ///
-    /// Can also be a single value, in which case it applies to all samples
-    pub(crate) bits_per_sample: &'a [u16], // maybe say that we only support a single bits_per_sample?
+    /// We only support a single bits_per_sample across all samples
+    pub(crate) bits_per_sample: u16,
     /// number of samples per pixel
     pub(crate) samples_per_pixel: u16,
     /// planar configuration
@@ -42,7 +42,7 @@ pub(crate) struct PredictorInfo<'a> {
     pub(crate) planar_configuration: PlanarConfiguration,
 }
 
-impl PredictorInfo<'_> {
+impl PredictorInfo {
     /// chunk width in pixels, taking padding into account
     ///
     /// strips are considered image-width chunks
@@ -125,29 +125,30 @@ impl PredictorInfo<'_> {
 
     /// 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)
+        Ok((self.chunk_width_pixels(x)? as usize).saturating_mul(self.bits_per_sample as _) / 8)
     }
 
-    /// The total number of bits per pixel, taking into account possible different sample sizes
-    ///
-    /// 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.
-    ///
-    /// Libtiff and image-tiff do not support mixed bits per sample, but we give the possibility
-    /// unless you also have PlanarConfiguration::Planar, at which point the first is taken
-    pub fn bits_per_pixel(&self) -> usize {
-        match self.planar_configuration {
-            PlanarConfiguration::Chunky => {
-                if self.bits_per_sample.len() == 1 {
-                    self.samples_per_pixel as usize * self.bits_per_sample[0] as usize
-                } else {
-                    assert_eq!(self.samples_per_pixel as usize, self.bits_per_sample.len());
-                    self.bits_per_sample.iter().map(|v| *v as usize).product()
-                }
-            }
-            PlanarConfiguration::Planar => self.bits_per_sample[0] as usize,
-        }
-    }
+    // /// The total number of bits per pixel, taking into account possible different sample sizes
+    // ///
+    // /// 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.
+    // ///
+    // /// Libtiff and image-tiff do not support mixed bits per sample, but we give the possibility
+    // /// unless you also have PlanarConfiguration::Planar, at which point the first is taken
+    // pub fn bits_per_pixel(&self) -> usize {
+    //     self.bits_per_sample
+    //     match self.planar_configuration {
+    //         PlanarConfiguration::Chunky => {
+    //             if self.bits_per_sample.len() == 1 {
+    //                 self.samples_per_pixel as usize * self.bits_per_sample[0] as usize
+    //             } else {
+    //                 assert_eq!(self.samples_per_pixel as usize, self.bits_per_sample.len());
+    //                 self.bits_per_sample.iter().map(|v| *v as usize).product()
+    //             }
+    //         }
+    //         PlanarConfiguration::Planar => self.bits_per_sample[0] as usize,
+    //     }
+    // }
 
     /// The number of chunks in the horizontal (x) direction
     pub fn chunks_across(&self) -> u32 {
@@ -167,18 +168,18 @@ impl PredictorInfo<'_> {
 ///
 /// This is returned by `fetch_tile`.
 #[derive(Debug)]
-pub struct Tile<'a> {
+pub struct Tile {
     pub(crate) x: usize,
     pub(crate) y: usize,
     pub(crate) predictor: Predictor,
-    pub(crate) predictor_info: PredictorInfo<'a>,
+    pub(crate) predictor_info: PredictorInfo,
     pub(crate) compressed_bytes: Bytes,
     pub(crate) compression_method: CompressionMethod,
     pub(crate) photometric_interpretation: PhotometricInterpretation,
     pub(crate) jpeg_tables: Option<Bytes>,
 }
 
-impl Tile<'_> {
+impl Tile {
     /// The column index of this tile.
     pub fn x(&self) -> usize {
         self.x
@@ -268,11 +269,10 @@ mod test {
             image_height: 17,
             chunk_width: 8,
             chunk_height: 8,
-            bits_per_sample: &[8],
+            bits_per_sample: 8,
             samples_per_pixel: 1,
             planar_configuration: PlanarConfiguration::Chunky,
         };
-        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);