Track non-image Directory sequence in Reader

A bit nasty, since we are storing the current Directory within the Image
instead of a separate attribute so we can not have one without the other
directly. Instead we prioritize with another attribute.

CHANGES.md

@@ -1,53 +1,3 @@
-# Version 0.10.4 (unreleased)
-
-- `Directory` now implements `FromIterator<(Tag, Value)>`.
-
-Changes:
-- The decoder now interprets the `ExtraSamples` tag. The sample count must now
-  more strict match the expected value with alpha channels only allowing for
-  explicitly denoted unassociated or associated alpha. This effects the
-  indicated color type when decoding images with additional samples indicated
-  as unspecified relation.  Previously, these may have been interpreted as
-  alpha by the total sample count (e.g. RgbA if 4 samples under a photometric
-  interpretation of RGB).
-
-# Version 0.10.3
-
-New features:
-- Group 4 `fax` is now recognized as a compression type and decoded.
-- A crate feature `fax` controls related dependencies, on by default.
-
-Changes:
-- The presence of PhotometricInterpretation::WhiteIsZero now returns an error
-  if the color type can not be inverted by the library where they were
-  previously silently ignored. Please report any missing color types.
-
-Fixes:
-- The PhotometricInterpretation::WhiteIsZero is now also applied to 1-bit
-  images, as well as 2-bit and 4-bit sample types where previously the presence
-  of this tag was ignored.
-
-# Version 0.10.2
-
-Republished 0.10.1, fixing an accidentally removed method (`Decoder::find_tag_unsigned_vec`).
-
-# Version 0.10.1
-
-New features:
- - Added a dedicated `Directory` type (#277)
- - Expose methods related to `Directory` publicly (#278)
- - Implement writing directories (#281, #283)
- - Add ICC (color profile) to the set of known tags (#287)
- - Added `Decoder.inner()` to access the underlying reader (#289)
- - Added methods for reading into a pre-allocated byte buffer (#285)
-
-Changes:
- - No longer perform color conversion when decoding embedded JPEG. This fixes decoding for JPEG images with alpha channel. (#274)
- - More lenient LZW decoding to match libtiff (#231)
-
-Fixes:
- - Fixed seeking multiple times in a row (#279)
-
 # Version 0.10.0
 
 New features:

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tiff"
-version = "0.10.3"
+version = "0.10.0"
 edition = "2021"
 resolver = "2"
 
@@ -20,24 +20,21 @@ exclude = ["tests/images/*", "tests/fuzz_images/*"]
 half = { version = "2.4.1" }
 quick-error = "2.0.1"
 
-# Rename to avoid confusion with the feature name.
-fax34 = { package = "fax", version = "0.2.6", optional = true }
 flate2 = { version = "1.0.20", optional = true }
 weezl = { version = "0.1.10", optional = true }
 zstd = { version = "0.13", optional = true }
-zune-jpeg = { version = "0.5.1", optional = true }
+zune-jpeg = { version = "0.4.17", optional = true }
 
 [dev-dependencies]
 criterion = "0.3.1"
 # We may already depend on this via flate2
-crc32fast = "1.5"
+crc32fast = "1"
 
 [features]
-default = ["deflate", "fax", "jpeg", "lzw"]
+default = ["deflate", "jpeg", "lzw"]
 
 # Compression algorithms
 deflate = ["dep:flate2"]
-fax = ["dep:fax34"]
 jpeg = ["dep:zune-jpeg"]
 lzw = ["dep:weezl"]
 zstd = ["dep:zstd"]

README.md

@@ -36,7 +36,6 @@ This table lists photometric interpretations and sample formats which are suppor
 | LZW      | ✓        | ✓        |
 | Deflate  | ✓        | ✓        |
 | PackBits | ✓        | ✓        |
-| Fax4     | ✓        | not yet  |
 | JPEG     | ✓        | not yet  |
 | ZSTD     | ✓        | not yet  |
 

examples/decode.rs

@@ -1,103 +0,0 @@
-use tiff::decoder::{BufferLayoutPreference, Decoder, DecodingBuffer, DecodingResult};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let Some(image) = std::env::args_os().nth(1) else {
-        eprintln!("Usage: decode FILE");
-        return Ok(());
-    };
-
-    let file = std::fs::File::open(image)?;
-    let io = std::io::BufReader::new(file);
-    let mut reader = Decoder::new(io)?;
-
-    let mut data = DecodingResult::I8(vec![]);
-
-    for i in 0u32.. {
-        let colortype = reader.colortype()?;
-        let dimensions = reader.dimensions()?;
-        let layout = reader.read_image_to_buffer(&mut data)?;
-
-        debug_planes(i, &mut data, &layout, &colortype, dimensions);
-
-        if !reader.more_images() {
-            break;
-        }
-
-        reader.next_image()?
-    }
-
-    Ok(())
-}
-
-fn debug_planes(
-    index: u32,
-    data: &mut DecodingResult,
-    layout: &BufferLayoutPreference,
-    colortype: &tiff::ColorType,
-    (width, height): (u32, u32),
-) {
-    let (depth, mut tupltype) = match colortype {
-        tiff::ColorType::Gray(_) => (1, "GRAYSCALE"),
-        tiff::ColorType::RGB(_) => (3, "RGB"),
-        tiff::ColorType::RGBA(_) => (4, "RGB_ALPHA"),
-        tiff::ColorType::Palette(_) => (1, "PALETTE"),
-        tiff::ColorType::CMYK(_) => (4, "CMYK"),
-        tiff::ColorType::Multiband { num_samples: 2, .. } => (2, "GRAYSCALE_ALPHA"),
-        _ => {
-            eprintln!("Unsupported color type for PAM output: {:?}", colortype);
-            return;
-        }
-    };
-
-    let maxval = match data.as_buffer(0) {
-        DecodingBuffer::U8(_) => u64::from(u8::MAX),
-        DecodingBuffer::U16(_) => u64::from(u16::MAX),
-        DecodingBuffer::U32(_) => u64::from(u32::MAX),
-        DecodingBuffer::U64(_) => u64::MAX,
-        // Eh, this is a good effort I guess.
-        DecodingBuffer::I8(items) => {
-            items.iter_mut().for_each(|v| *v = 0.max(*v));
-            u64::from(i8::MAX as u8)
-        }
-        DecodingBuffer::I16(items) => {
-            items.iter_mut().for_each(|v| *v = 0.max(*v));
-            u64::from(i16::MAX as u16)
-        }
-        DecodingBuffer::I32(items) => {
-            items.iter_mut().for_each(|v| *v = 0.max(*v));
-            u64::from(i32::MAX as u32)
-        }
-        DecodingBuffer::I64(items) => {
-            items.iter_mut().for_each(|v| *v = 0.max(*v));
-            i64::MAX as u64
-        }
-        // Not supported by PAM.
-        DecodingBuffer::F16(_) | DecodingBuffer::F32(_) | DecodingBuffer::F64(_) => return,
-    };
-
-    let byte_len = if layout.planes > 1 {
-        tupltype = "GRAYSCALE";
-        layout.plane_stride.unwrap().get()
-    } else {
-        data.as_buffer(0).byte_len()
-    };
-
-    // Write out this image's planes to PAM files.
-    let header = format!("P7\nWIDTH {width}\nHEIGHT {height}\nDEPTH {depth}\nMAXVAL {maxval}\nTUPLTYPE {tupltype}\nENDHDR\n");
-
-    for (plane, plane_data) in data
-        .as_buffer(0)
-        .as_bytes_mut()
-        .chunks_exact(byte_len)
-        .enumerate()
-    {
-        let filename = format!("image_{index:03}_plane_{plane:03}.pam");
-        let mut file = std::fs::File::create(filename).expect("Failed to create output file");
-
-        use std::io::Write;
-        file.write_all(header.as_bytes())
-            .expect("Failed to write PAM header");
-        file.write_all(plane_data)
-            .expect("Failed to write PAM data");
-    }
-}

src/decoder/ifd.rs

@@ -332,12 +332,6 @@ impl Value {
     }
 }
 
-/// A combination of type, count, and offset.
-///
-/// In a TIFF the data offset portion of an entry is used for inline data in case the length of the
-/// encoded value does not exceed the size of the offset field. Since the size of the offset field
-/// depends on the file kind (4 bytes for standard TIFF, 8 bytes for BigTIFF) the interpretation of
-/// this struct is only complete in combination with file metadata.
 #[derive(Clone)]
 pub struct Entry {
     type_: Type,
@@ -355,14 +349,12 @@ impl ::std::fmt::Debug for Entry {
 }
 
 impl Entry {
-    /// Create a new entry fit to be added to a standard TIFF IFD.
     pub fn new(type_: Type, count: u32, offset: [u8; 4]) -> Entry {
         let mut entry_off = [0u8; 8];
         entry_off[..4].copy_from_slice(&offset);
         Entry::new_u64(type_, count.into(), entry_off)
     }
 
-    /// Create a new entry with data for a Big TIFF IFD.
     pub fn new_u64(type_: Type, count: u64, offset: [u8; 8]) -> Entry {
         Entry {
             type_,
@@ -384,10 +376,7 @@ impl Entry {
     }
 
     /// Returns a mem_reader for the offset/value field
-    pub(crate) fn offset_field_reader(
+    fn r(&self, byte_order: ByteOrder) -> EndianReader<io::Cursor<Vec<u8>>> {
-        &self,
-        byte_order: ByteOrder,
-    ) -> EndianReader<io::Cursor<Vec<u8>>> {
         EndianReader::new(io::Cursor::new(self.offset.to_vec()), byte_order)
     }
 
@@ -403,25 +392,43 @@ impl Entry {
         }
 
         let bo = reader.byte_order;
-        let value_bytes = self.type_.value_bytes(self.count)?;
+
+        let tag_size = match self.type_ {
+            Type::BYTE | Type::SBYTE | Type::ASCII | Type::UNDEFINED => 1,
+            Type::SHORT | Type::SSHORT => 2,
+            Type::LONG | Type::SLONG | Type::FLOAT | Type::IFD => 4,
+            Type::LONG8
+            | Type::SLONG8
+            | Type::DOUBLE
+            | Type::RATIONAL
+            | Type::SRATIONAL
+            | Type::IFD8 => 8,
+        };
+
+        let value_bytes = match self.count.checked_mul(tag_size) {
+            Some(n) => n,
+            None => {
+                return Err(TiffError::LimitsExceeded);
+            }
+        };
 
         // Case 2: there is one value.
         if self.count == 1 {
             // 2a: the value is 5-8 bytes and we're in BigTiff mode.
             if bigtiff && value_bytes > 4 && value_bytes <= 8 {
                 return Ok(match self.type_ {
-                    Type::LONG8 => UnsignedBig(self.offset_field_reader(bo).read_u64()?),
+                    Type::LONG8 => UnsignedBig(self.r(bo).read_u64()?),
-                    Type::SLONG8 => SignedBig(self.offset_field_reader(bo).read_i64()?),
+                    Type::SLONG8 => SignedBig(self.r(bo).read_i64()?),
-                    Type::DOUBLE => Double(self.offset_field_reader(bo).read_f64()?),
+                    Type::DOUBLE => Double(self.r(bo).read_f64()?),
                     Type::RATIONAL => {
-                        let mut r = self.offset_field_reader(bo);
+                        let mut r = self.r(bo);
                         Rational(r.read_u32()?, r.read_u32()?)
                     }
                     Type::SRATIONAL => {
-                        let mut r = self.offset_field_reader(bo);
+                        let mut r = self.r(bo);
                         SRational(r.read_i32()?, r.read_i32()?)
                     }
-                    Type::IFD8 => IfdBig(self.offset_field_reader(bo).read_u64()?),
+                    Type::IFD8 => IfdBig(self.r(bo).read_u64()?),
                     Type::BYTE
                     | Type::SBYTE
                     | Type::ASCII
@@ -440,11 +447,11 @@ impl Entry {
                 Type::BYTE => Byte(self.offset[0]),
                 Type::SBYTE => SignedByte(self.offset[0] as i8),
                 Type::UNDEFINED => Byte(self.offset[0]),
-                Type::SHORT => Short(self.offset_field_reader(bo).read_u16()?),
+                Type::SHORT => Short(self.r(bo).read_u16()?),
-                Type::SSHORT => SignedShort(self.offset_field_reader(bo).read_i16()?),
+                Type::SSHORT => SignedShort(self.r(bo).read_i16()?),
-                Type::LONG => Unsigned(self.offset_field_reader(bo).read_u32()?),
+                Type::LONG => Unsigned(self.r(bo).read_u32()?),
-                Type::SLONG => Signed(self.offset_field_reader(bo).read_i32()?),
+                Type::SLONG => Signed(self.r(bo).read_i32()?),
-                Type::FLOAT => Float(self.offset_field_reader(bo).read_f32()?),
+                Type::FLOAT => Float(self.r(bo).read_f32()?),
                 Type::ASCII => {
                     if self.offset[0] == 0 {
                         Ascii("".to_string())
@@ -453,28 +460,28 @@ impl Entry {
                     }
                 }
                 Type::LONG8 => {
-                    reader.goto_offset(self.offset_field_reader(bo).read_u32()?.into())?;
+                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
                     UnsignedBig(reader.read_u64()?)
                 }
                 Type::SLONG8 => {
-                    reader.goto_offset(self.offset_field_reader(bo).read_u32()?.into())?;
+                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
                     SignedBig(reader.read_i64()?)
                 }
                 Type::DOUBLE => {
-                    reader.goto_offset(self.offset_field_reader(bo).read_u32()?.into())?;
+                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
                     Double(reader.read_f64()?)
                 }
                 Type::RATIONAL => {
-                    reader.goto_offset(self.offset_field_reader(bo).read_u32()?.into())?;
+                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
                     Rational(reader.read_u32()?, reader.read_u32()?)
                 }
                 Type::SRATIONAL => {
-                    reader.goto_offset(self.offset_field_reader(bo).read_u32()?.into())?;
+                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
                     SRational(reader.read_i32()?, reader.read_i32()?)
                 }
-                Type::IFD => Ifd(self.offset_field_reader(bo).read_u32()?),
+                Type::IFD => Ifd(self.r(bo).read_u32()?),
                 Type::IFD8 => {
-                    reader.goto_offset(self.offset_field_reader(bo).read_u32()?.into())?;
+                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
                     IfdBig(reader.read_u64()?)
                 }
             });
@@ -505,7 +512,7 @@ impl Entry {
                     ));
                 }
                 Type::SHORT => {
-                    let mut r = self.offset_field_reader(bo);
+                    let mut r = self.r(bo);
                     let mut v = Vec::new();
                     for _ in 0..self.count {
                         v.push(Short(r.read_u16()?));
@@ -513,7 +520,7 @@ impl Entry {
                     return Ok(List(v));
                 }
                 Type::SSHORT => {
-                    let mut r = self.offset_field_reader(bo);
+                    let mut r = self.r(bo);
                     let mut v = Vec::new();
                     for _ in 0..self.count {
                         v.push(SignedShort(r.read_i16()?));
@@ -521,7 +528,7 @@ impl Entry {
                     return Ok(List(v));
                 }
                 Type::LONG => {
-                    let mut r = self.offset_field_reader(bo);
+                    let mut r = self.r(bo);
                     let mut v = Vec::new();
                     for _ in 0..self.count {
                         v.push(Unsigned(r.read_u32()?));
@@ -529,7 +536,7 @@ impl Entry {
                     return Ok(List(v));
                 }
                 Type::SLONG => {
-                    let mut r = self.offset_field_reader(bo);
+                    let mut r = self.r(bo);
                     let mut v = Vec::new();
                     for _ in 0..self.count {
                         v.push(Signed(r.read_i32()?));
@@ -537,7 +544,7 @@ impl Entry {
                     return Ok(List(v));
                 }
                 Type::FLOAT => {
-                    let mut r = self.offset_field_reader(bo);
+                    let mut r = self.r(bo);
                     let mut v = Vec::new();
                     for _ in 0..self.count {
                         v.push(Float(r.read_f32()?));
@@ -545,7 +552,7 @@ impl Entry {
                     return Ok(List(v));
                 }
                 Type::IFD => {
-                    let mut r = self.offset_field_reader(bo);
+                    let mut r = self.r(bo);
                     let mut v = Vec::new();
                     for _ in 0..self.count {
                         v.push(Ifd(r.read_u32()?));
@@ -564,149 +571,74 @@ impl Entry {
         }
 
         // Case 4: there is more than one value, and it doesn't fit in the offset field.
-        let mut v;
-        self.set_reader_offset(bo, bigtiff, reader)?;
-
         match self.type_ {
-            Type::BYTE | Type::UNDEFINED => {
+            // TODO check if this could give wrong results
-                v = Self::vec_with_capacity(self.count, limits)?;
+            // at a different endianess of file/computer.
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+            Type::BYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    v.extend(bytes.iter().copied().map(Byte))
+                let mut buf = [0; 1];
-                })
+                reader.inner().read_exact(&mut buf)?;
-            }
+                Ok(UnsignedBig(u64::from(buf[0])))
-            Type::SBYTE => {
+            }),
-                v = Self::vec_with_capacity(self.count, limits)?;
+            Type::SBYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+                Ok(SignedBig(i64::from(reader.read_i8()?)))
-                    v.extend(bytes.iter().copied().map(|v| SignedByte(v as i8)))
+            }),
-                })
+            Type::SHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-            }
+                Ok(Short(reader.read_u16()?))
-            Type::SHORT => {
+            }),
-                v = Self::vec_with_capacity(self.count, limits)?;
+            Type::SSHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+                Ok(SignedShort(reader.read_i16()?))
-                    v.extend(
+            }),
-                        bytes
+            Type::LONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                            .chunks_exact(2)
+                Ok(Unsigned(reader.read_u32()?))
-                            .map(|ch| Short(u16::from_ne_bytes(ch.try_into().unwrap()))),
+            }),
-                    )
+            Type::SLONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                })
+                Ok(Signed(reader.read_i32()?))
-            }
+            }),
-            Type::SSHORT => {
+            Type::FLOAT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                v = Self::vec_with_capacity(self.count, limits)?;
+                Ok(Float(reader.read_f32()?))
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+            }),
-                    v.extend(
+            Type::DOUBLE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                        bytes
+                Ok(Double(reader.read_f64()?))
-                            .chunks_exact(2)
+            }),
-                            .map(|ch| SignedShort(i16::from_ne_bytes(ch.try_into().unwrap()))),
-                    )
-                })
-            }
-            Type::LONG => {
-                v = Self::vec_with_capacity(self.count, limits)?;
-                self.decode_values(self.count, self.type_, reader, |bytes| {
-                    v.extend(
-                        bytes
-                            .chunks_exact(4)
-                            .map(|ch| Unsigned(u32::from_ne_bytes(ch.try_into().unwrap()))),
-                    )
-                })
-            }
-            Type::SLONG => {
-                v = Self::vec_with_capacity(self.count, limits)?;
-                self.decode_values(self.count, self.type_, reader, |bytes| {
-                    v.extend(
-                        bytes
-                            .chunks_exact(4)
-                            .map(|ch| Signed(i32::from_ne_bytes(ch.try_into().unwrap()))),
-                    )
-                })
-            }
-            Type::FLOAT => {
-                v = Self::vec_with_capacity(self.count, limits)?;
-                self.decode_values(self.count, self.type_, reader, |bytes| {
-                    v.extend(
-                        bytes
-                            .chunks_exact(4)
-                            .map(|ch| Float(f32::from_ne_bytes(ch.try_into().unwrap()))),
-                    )
-                })
-            }
-            Type::DOUBLE => {
-                v = Self::vec_with_capacity(self.count, limits)?;
-                self.decode_values(self.count, self.type_, reader, |bytes| {
-                    v.extend(
-                        bytes
-                            .chunks_exact(8)
-                            .map(|ch| Double(f64::from_ne_bytes(ch.try_into().unwrap()))),
-                    )
-                })
-            }
             Type::RATIONAL => {
-                v = Self::vec_with_capacity(self.count, limits)?;
+                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+                    Ok(Rational(reader.read_u32()?, reader.read_u32()?))
-                    v.extend(bytes.chunks_exact(8).map(|ch| {
-                        Rational(
-                            u32::from_ne_bytes(ch[..4].try_into().unwrap()),
-                            u32::from_ne_bytes(ch[4..].try_into().unwrap()),
-                        )
-                    }))
                 })
             }
             Type::SRATIONAL => {
-                v = Self::vec_with_capacity(self.count, limits)?;
+                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+                    Ok(SRational(reader.read_i32()?, reader.read_i32()?))
-                    v.extend(bytes.chunks_exact(8).map(|ch| {
-                        SRational(
-                            i32::from_ne_bytes(ch[..4].try_into().unwrap()),
-                            i32::from_ne_bytes(ch[4..].try_into().unwrap()),
-                        )
-                    }))
                 })
             }
-            Type::LONG8 => {
+            Type::LONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                v = Self::vec_with_capacity(self.count, limits)?;
+                Ok(UnsignedBig(reader.read_u64()?))
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+            }),
-                    v.extend(
+            Type::SLONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                        bytes
+                Ok(SignedBig(reader.read_i64()?))
-                            .chunks_exact(8)
+            }),
-                            .map(|ch| UnsignedBig(u64::from_ne_bytes(ch.try_into().unwrap()))),
+            Type::IFD => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    )
+                Ok(Ifd(reader.read_u32()?))
-                })
+            }),
-            }
+            Type::IFD8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-            Type::SLONG8 => {
+                Ok(IfdBig(reader.read_u64()?))
-                v = Self::vec_with_capacity(self.count, limits)?;
+            }),
-                self.decode_values(self.count, self.type_, reader, |bytes| {
+            Type::UNDEFINED => {
-                    v.extend(
+                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                        bytes
+                    let mut buf = [0; 1];
-                            .chunks_exact(8)
+                    reader.inner().read_exact(&mut buf)?;
-                            .map(|ch| SignedBig(i64::from_ne_bytes(ch.try_into().unwrap()))),
+                    Ok(Byte(buf[0]))
-                    )
-                })
-            }
-            Type::IFD => {
-                v = Self::vec_with_capacity(self.count, limits)?;
-                self.decode_values(self.count, self.type_, reader, |bytes| {
-                    v.extend(
-                        bytes
-                            .chunks_exact(4)
-                            .map(|ch| Ifd(u32::from_ne_bytes(ch.try_into().unwrap()))),
-                    )
-                })
-            }
-            Type::IFD8 => {
-                v = Self::vec_with_capacity(self.count, limits)?;
-                self.decode_values(self.count, self.type_, reader, |bytes| {
-                    v.extend(
-                        bytes
-                            .chunks_exact(8)
-                            .map(|ch| IfdBig(u64::from_ne_bytes(ch.try_into().unwrap()))),
-                    )
                 })
             }
             Type::ASCII => {
                 let n = usize::try_from(self.count)?;
-
                 if n > limits.decoding_buffer_size {
-                    return Err(dbg!(TiffError::LimitsExceeded));
+                    return Err(TiffError::LimitsExceeded);
+                }
+
+                if bigtiff {
+                    reader.goto_offset(self.r(bo).read_u64()?)?
+                } else {
+                    reader.goto_offset(self.r(bo).read_u32()?.into())?
                 }
 
                 let mut out = vec![0; n];
@@ -715,81 +647,43 @@ impl Entry {
                 if let Some(first) = out.iter().position(|&b| b == 0) {
                     out.truncate(first);
                 }
-
+                Ok(Ascii(String::from_utf8(out)?))
-                return Ok(Ascii(String::from_utf8(out)?));
             }
-        }?;
+        }
-
-        Ok(List(v))
     }
 
-    fn vec_with_capacity(
+    #[inline]
+    fn decode_offset<R, F>(
+        &self,
         value_count: u64,
+        bo: ByteOrder,
+        bigtiff: bool,
         limits: &super::Limits,
-    ) -> Result<Vec<Value>, TiffError> {
+        reader: &mut EndianReader<R>,
+        decode_fn: F,
+    ) -> TiffResult<Value>
+    where
+        R: Read + Seek,
+        F: Fn(&mut EndianReader<R>) -> TiffResult<Value>,
+    {
         let value_count = usize::try_from(value_count)?;
-
         if value_count > limits.decoding_buffer_size / mem::size_of::<Value>() {
             return Err(TiffError::LimitsExceeded);
         }
 
-        Ok(Vec::with_capacity(value_count))
+        let mut v = Vec::with_capacity(value_count);
-    }
 
-    fn set_reader_offset<R>(
-        &self,
-        bo: ByteOrder,
-        bigtiff: bool,
-        reader: &mut EndianReader<R>,
-    ) -> TiffResult<()>
-    where
-        R: Read + Seek,
-    {
         let offset = if bigtiff {
-            self.offset_field_reader(bo).read_u64()?
+            self.r(bo).read_u64()?
         } else {
-            self.offset_field_reader(bo).read_u32()?.into()
+            self.r(bo).read_u32()?.into()
         };
-
         reader.goto_offset(offset)?;
 
-        Ok(())
+        for _ in 0..value_count {
-    }
+            v.push(decode_fn(reader)?)
-
-    #[inline]
-    fn decode_values<R, F>(
-        &self,
-        value_count: u64,
-        type_: Type,
-        reader: &mut EndianReader<R>,
-        mut collect: F,
-    ) -> TiffResult<()>
-    where
-        R: Read + Seek,
-        F: FnMut(&[u8]),
-    {
-        let mut total_bytes = type_.value_bytes(value_count)?;
-        let mut buffer = [0u8; 512];
-
-        let buf_unit = usize::from(type_.byte_len());
-        let mul_of_ty = buffer.len() / buf_unit * buf_unit;
-
-        let cls = type_.endian_bytes();
-        let native = ByteOrder::native();
-
-        while total_bytes > 0 {
-            // `now <= mul_of_ty < 512` so casting is mathematical
-            let now = total_bytes.min(mul_of_ty as u64);
-            total_bytes -= now;
-
-            let buffer = &mut buffer[..now as usize];
-            reader.inner().read_exact(buffer)?;
-
-            reader.byte_order.convert_endian_bytes(cls, buffer, native);
-            collect(buffer);
         }
-
+        Ok(List(v))
-        Ok(())
     }
 }
 

src/decoder/image.rs

@@ -4,14 +4,13 @@ use super::tag_reader::TagReader;
 use super::ChunkType;
 use super::{predict_f16, predict_f32, predict_f64, ValueReader};
 use crate::tags::{
-    CompressionMethod, ExtraSamples, PhotometricInterpretation, PlanarConfiguration, Predictor,
+    CompressionMethod, PhotometricInterpretation, PlanarConfiguration, Predictor, SampleFormat, Tag,
-    SampleFormat, Tag,
 };
 use crate::{
     ColorType, Directory, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError,
 };
-
 use std::io::{self, Cursor, Read, Seek};
+use std::num::NonZeroUsize;
 use std::sync::Arc;
 
 #[derive(Debug)]
@@ -69,11 +68,6 @@ pub(crate) struct Image {
     pub height: u32,
     pub bits_per_sample: u8,
     pub samples: u16,
-    /// The `ExtraSamples`, defaulting to empty if not given.
-    pub extra_samples: Vec<ExtraSamples>,
-    /// Number of samples that belong to the photometric interpretation, samples except
-    /// `ExtraSamples` (338, 0x0152) tag.
-    pub photometric_samples: u16,
     pub sample_format: SampleFormat,
     pub photometric_interpretation: PhotometricInterpretation,
     pub compression_method: CompressionMethod,
@@ -87,50 +81,24 @@ pub(crate) struct Image {
     pub chunk_bytes: Vec<u64>,
 }
 
-/// Describes how to read a tile-aligned portion of the image.
-#[derive(Clone)]
-pub(crate) struct ReadoutLayout {
-    /// The planar configuration, which applies to both the underlying image and the output buffer.
-    /// This may be relaxed if we find a clean enough way to provide it.
-    pub planar_config: PlanarConfiguration,
-
-    /// The sample interpretation (interpret with planar_config).
-    pub color: ColorType,
-    /// The number of bytes from one row to another.
-    pub minimum_row_stride: usize,
-    /// The format of samples (assumed uniform for now, same with depth of `ColorType`).
-    pub sample_format: SampleFormat,
-
-    /// Number of bytes to advance in output per row.
-    pub row_stride: usize,
-    /// Number of bytes to advance in output per chunk in width.
-    pub chunk_row_stride: usize,
-    /// Number of bytes to advance in output per chunk in height.
-    pub chunk_col_stride: usize,
-    /// Number of bytes in output from one plane to another.
-    pub plane_stride: usize,
-
-    /// Bits per sample in the encoded data.
-    pub tiff_bits_per_sample: u8,
-    /// Number of samples in the encoded data.
-    pub tiff_samples: u16,
-    /// Dimensions of the underlying rectangular chunks (tile or strips).
-    pub tiff_chunk_dimensions: (u32, u32),
-    /// Number of bytes in the underlying data with all samples per row of chunks.
-    pub tiff_row_bytes: usize,
-
-    /// Chunks until wrapping to the next row of chunks.
-    pub chunks_across: u32,
-    /// Chunks to advance to get to the next plane of chunks.
-    pub chunks_per_plane: u32,
-}
-
 impl Image {
     pub fn from_reader<R: Read + Seek>(
         decoder: &mut ValueReader<R>,
         ifd: Directory,
     ) -> TiffResult<Image> {
-        let mut tag_reader = TagReader { decoder, ifd: &ifd };
+        let img = Self::from_ref(decoder, &ifd)?;
+
+        Ok(Image {
+            ifd: Some(ifd),
+            ..img
+        })
+    }
+
+    pub(crate) fn from_ref<R: Read + Seek>(
+        decoder: &mut ValueReader<R>,
+        ifd: &Directory,
+    ) -> TiffResult<Image> {
+        let mut tag_reader = TagReader { decoder, ifd };
 
         let width = tag_reader.require_tag(Tag::ImageWidth)?.into_u32()?;
         let height = tag_reader.require_tag(Tag::ImageLength)?.into_u32()?;
@@ -177,30 +145,10 @@ impl Image {
             .map(Value::into_u16)
             .transpose()?
             .unwrap_or(1);
-
         if samples == 0 {
             return Err(TiffFormatError::SamplesPerPixelIsZero.into());
         }
 
-        let extra_samples = match tag_reader.find_tag(Tag::ExtraSamples)? {
-            Some(n) => n.into_u16_vec()?,
-            None => vec![],
-        };
-
-        let extra_samples = extra_samples
-            .into_iter()
-            .map(|x| ExtraSamples::from_u16(x).unwrap_or(ExtraSamples::Unspecified))
-            .collect::<Vec<_>>();
-
-        let photometric_samples = match usize::from(samples).checked_sub(extra_samples.len()) {
-            None => {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::InconsistentSizesEncountered,
-                ));
-            }
-            Some(n) => n as u16,
-        };
-
         let sample_format = match tag_reader.find_tag_uint_vec(Tag::SampleFormat)? {
             Some(vals) => {
                 let sample_format: Vec<_> = vals
@@ -208,15 +156,12 @@ impl Image {
                     .map(SampleFormat::from_u16_exhaustive)
                     .collect();
 
-                let Some(format) = sample_format.first().copied() else {
-                    // Reject empty sample formats
-                    return Err(TiffFormatError::InvalidTagValueType(Tag::SampleFormat).into());
-                };
                 // TODO: for now, only homogenous formats across samples are supported.
-                if !sample_format.iter().all(|&s| s == format) {
+                if !sample_format.windows(2).all(|s| s[0] == s[1]) {
                     return Err(TiffUnsupportedError::UnsupportedSampleFormat(sample_format).into());
                 }
-                format
+
+                sample_format[0]
             }
             None => SampleFormat::Uint,
         };
@@ -227,7 +172,7 @@ impl Image {
 
         // 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.
-        if bits_per_sample.len() != usize::from(samples) && bits_per_sample.len() != 1 {
+        if bits_per_sample.len() != samples.into() && bits_per_sample.len() != 1 {
             return Err(TiffError::FormatError(
                 TiffFormatError::InconsistentSizesEncountered,
             ));
@@ -355,13 +300,11 @@ impl Image {
         };
 
         Ok(Image {
-            ifd: Some(ifd),
+            ifd: None,
             width,
             height,
             bits_per_sample: bits_per_sample[0],
             samples,
-            extra_samples,
-            photometric_samples,
             sample_format,
             photometric_interpretation,
             compression_method,
@@ -377,19 +320,15 @@ impl Image {
     }
 
     pub(crate) fn colortype(&self) -> TiffResult<ColorType> {
-        let is_alpha_extra_samples = matches!(
-            self.extra_samples.as_slice(),
-            [ExtraSamples::AssociatedAlpha, ..] | [ExtraSamples::UnassociatedAlpha, ..]
-        );
-
         match self.photometric_interpretation {
-            PhotometricInterpretation::RGB => match self.photometric_samples {
+            PhotometricInterpretation::RGB => match self.samples {
-                3 => Ok(if is_alpha_extra_samples {
+                3 => Ok(ColorType::RGB(self.bits_per_sample)),
-                    ColorType::RGBA(self.bits_per_sample)
-                } else {
-                    ColorType::RGB(self.bits_per_sample)
-                }),
                 4 => Ok(ColorType::RGBA(self.bits_per_sample)),
+                // FIXME: We should _ignore_ other components. In particular:
+                // > Beware of extra components. Some TIFF files may have more components per pixel
+                // than you think. A Baseline TIFF reader must skip over them gracefully,using the
+                // values of the SamplesPerPixel and BitsPerSample fields.
+                // > -- TIFF 6.0 Specification, Section 7, Additional Baseline requirements.
                 _ => Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::InterpretationWithBits(
                         self.photometric_interpretation,
@@ -397,12 +336,8 @@ impl Image {
                     ),
                 )),
             },
-            PhotometricInterpretation::CMYK => match self.photometric_samples {
+            PhotometricInterpretation::CMYK => match self.samples {
-                4 => Ok(if is_alpha_extra_samples {
+                4 => Ok(ColorType::CMYK(self.bits_per_sample)),
-                    ColorType::CMYKA(self.bits_per_sample)
-                } else {
-                    ColorType::CMYK(self.bits_per_sample)
-                }),
                 5 => Ok(ColorType::CMYKA(self.bits_per_sample)),
                 _ => Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::InterpretationWithBits(
@@ -411,7 +346,7 @@ impl Image {
                     ),
                 )),
             },
-            PhotometricInterpretation::YCbCr => match self.photometric_samples {
+            PhotometricInterpretation::YCbCr => match self.samples {
                 3 => Ok(ColorType::YCbCr(self.bits_per_sample)),
                 _ => Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::InterpretationWithBits(
@@ -420,13 +355,7 @@ impl Image {
                     ),
                 )),
             },
-            // TODO: treatment of WhiteIsZero is not quite consistent with `invert_colors` that is
-            // later called when that interpretation is read. That function does not support
-            // Multiband as a color type and will error. It's unclear how to resolve that exactly.
             PhotometricInterpretation::BlackIsZero | PhotometricInterpretation::WhiteIsZero => {
-                // Note: compatibility with previous implementation requires us to return extra
-                // samples as `Multiband`. For gray images however the better choice would be
-                // returning a `Gray` color, i.e. matching on `photometric_samples` instead.
                 match self.samples {
                     1 => Ok(ColorType::Gray(self.bits_per_sample)),
                     _ => Ok(ColorType::Multiband {
@@ -447,13 +376,27 @@ impl Image {
         }
     }
 
+    pub(crate) fn minimum_row_stride(&self, dims: (u32, u32)) -> Option<NonZeroUsize> {
+        let (width, height) = dims;
+
+        let row_stride = u64::from(width)
+            .saturating_mul(self.samples_per_pixel() as u64)
+            .saturating_mul(self.bits_per_sample as u64)
+            .div_ceil(8);
+
+        // Note: row stride should be smaller than the len if we have an actual buffer. If there
+        // are no pixels in the buffer (height _or_ width is 0) then the stride is not well defined
+        // and we return `None`.
+        (height > 0)
+            .then_some(row_stride as usize)
+            .and_then(NonZeroUsize::new)
+    }
+
     fn create_reader<'r, R: 'r + Read>(
         reader: R,
         compression_method: CompressionMethod,
         compressed_length: u64,
-        // FIXME: these should be `expect` attributes or we choose another way of passing them.
+        #[allow(unused_variables)] jpeg_tables: Option<&[u8]>,
-        #[cfg_attr(not(feature = "jpeg"), allow(unused_variables))] jpeg_tables: Option<&[u8]>,
-        #[cfg_attr(not(feature = "fax"), allow(unused_variables))] dimensions: (u32, u32),
     ) -> TiffResult<Box<dyn Read + 'r>> {
         Ok(match compression_method {
             CompressionMethod::None => Box::new(reader),
@@ -505,14 +448,13 @@ impl Image {
                 let mut jpeg_data = Vec::new();
                 jpeg_reader.read_to_end(&mut jpeg_data)?;
 
-                let mut decoder =
+                let mut decoder = zune_jpeg::JpegDecoder::new(jpeg_data);
-                    zune_jpeg::JpegDecoder::new(zune_core::bytestream::ZCursor::new(jpeg_data));
                 let mut options: zune_core::options::DecoderOptions = Default::default();
 
                 // Disable color conversion by setting the output colorspace to the input
                 // colorspace.
                 decoder.decode_headers()?;
-                if let Some(colorspace) = decoder.input_colorspace() {
+                if let Some(colorspace) = decoder.get_input_colorspace() {
                     options = options.jpeg_set_out_colorspace(colorspace);
                 }
 
@@ -522,12 +464,6 @@ impl Image {
 
                 Box::new(Cursor::new(data))
             }
-            #[cfg(feature = "fax")]
-            CompressionMethod::Fax4 => Box::new(super::stream::Group4Reader::new(
-                dimensions,
-                reader,
-                compressed_length,
-            )?),
             method => {
                 return Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::UnsupportedCompressionMethod(method),
@@ -543,25 +479,18 @@ impl Image {
     /// 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) -> u16 {
+    pub(crate) fn samples_per_pixel(&self) -> usize {
         match self.planar_config {
-            PlanarConfiguration::Chunky => self.samples,
+            PlanarConfiguration::Chunky => self.samples.into(),
-            PlanarConfiguration::Planar => 1,
-        }
-    }
-
-    pub(crate) fn samples_per_out_texel(&self, color: ColorType) -> u16 {
-        match self.planar_config {
-            PlanarConfiguration::Chunky => color.num_samples(),
             PlanarConfiguration::Planar => 1,
         }
     }
 
     /// Number of strips per pixel.
-    pub(crate) fn strips_per_pixel(&self) -> u16 {
+    pub(crate) fn strips_per_pixel(&self) -> usize {
         match self.planar_config {
             PlanarConfiguration::Chunky => 1,
-            PlanarConfiguration::Planar => self.samples,
+            PlanarConfiguration::Planar => self.samples.into(),
         }
     }
 
@@ -599,90 +528,14 @@ impl Image {
         }
     }
 
-    pub(crate) fn readout_for_image(&self) -> TiffResult<ReadoutLayout> {
-        let Image { width, height, .. } = *self;
-        self.readout_for_size(width, height)
-    }
-
-    /// Get the layout for reading out a tile-aligned portion of the image.
-    ///
-    /// The provided width and height should be less than or equal to the image dimensions.
-    pub(crate) fn readout_for_size(&self, width: u32, height: u32) -> TiffResult<ReadoutLayout> {
-        let color = self.colortype()?;
-
-        let tiff_samples = self.samples_per_pixel();
-        let tiff_bits_per_sample = self.bits_per_sample;
-        let data_samples = self.samples_per_out_texel(color);
-        let tiff_chunk_dimensions = self.chunk_dimensions()?;
-        let strips_per_pixel = self.strips_per_pixel();
-
-        let data_dimensions = (width, height);
-
-        let tiff_row_bits = (u64::from(tiff_chunk_dimensions.0) * u64::from(tiff_bits_per_sample))
-            .checked_mul(u64::from(tiff_samples))
-            .ok_or(TiffError::LimitsExceeded)?;
-        let tiff_row_bytes: usize = tiff_row_bits.div_ceil(8).try_into()?;
-
-        let chunk_row_bits = (u64::from(tiff_chunk_dimensions.0) * u64::from(tiff_bits_per_sample))
-            .checked_mul(u64::from(data_samples))
-            .ok_or(TiffError::LimitsExceeded)?;
-        let chunk_row_bytes: usize = chunk_row_bits.div_ceil(8).try_into()?;
-
-        let data_row_bits = (u64::from(data_dimensions.0) * u64::from(tiff_bits_per_sample))
-            .checked_mul(u64::from(data_samples))
-            .ok_or(TiffError::LimitsExceeded)?;
-        let data_row_bytes: usize = data_row_bits.div_ceil(8).try_into()?;
-
-        let chunk_col_stride: usize = data_row_bits
-            .div_ceil(8)
-            .checked_mul(u64::from(tiff_chunk_dimensions.1))
-            .ok_or(TiffError::LimitsExceeded)?
-            .try_into()?;
-
-        let plane_stride: usize = data_row_bits
-            .div_ceil(8)
-            .checked_mul(u64::from(data_dimensions.1))
-            .ok_or(TiffError::LimitsExceeded)?
-            .try_into()?;
-
-        let minimum_row_stride = data_row_bytes;
-
-        let chunks_across: u32 = data_dimensions.0.div_ceil(tiff_chunk_dimensions.0);
-        let chunks_per_plane = (self.chunk_offsets.len() as u32) / u32::from(strips_per_pixel);
-
-        // We would not get an offset in byte units, sorry, no bit interleaving in the output.
-        if chunks_across > 1 && chunk_row_bits % 8 != 0 {
-            return Err(TiffError::UnsupportedError(
-                TiffUnsupportedError::MisalignedTileBoundaries,
-            ));
-        }
-
-        Ok(ReadoutLayout {
-            planar_config: self.planar_config,
-            color,
-            minimum_row_stride,
-            sample_format: self.sample_format,
-            row_stride: data_row_bytes,
-            chunk_row_stride: chunk_row_bytes,
-            chunk_col_stride,
-            plane_stride,
-            tiff_bits_per_sample,
-            tiff_samples,
-            tiff_chunk_dimensions,
-            tiff_row_bytes,
-            chunks_across,
-            chunks_per_plane,
-        })
-    }
-
     pub(crate) fn chunk_data_dimensions(&self, chunk_index: u32) -> TiffResult<(u32, u32)> {
         let dims = self.chunk_dimensions()?;
 
         match self.chunk_type {
             ChunkType::Strip => {
-                let rows_per_strip = dims.1;
+                let strip_attrs = self.strip_decoder.as_ref().unwrap();
-                let strips_per_band = self.height.div_ceil(rows_per_strip);
+                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))
@@ -711,7 +564,7 @@ impl Image {
         &self,
         reader: &mut ValueReader<impl Read>,
         buf: &mut [u8],
-        layout: &ReadoutLayout,
+        output_row_stride: usize,
         chunk_index: u32,
     ) -> TiffResult<()> {
         let ValueReader {
@@ -721,10 +574,10 @@ impl Image {
         } = reader;
 
         let byte_order = reader.byte_order;
+        let reader = reader.inner();
 
         // Validate that the color type is supported.
-        let color_type = layout.color;
+        let color_type = self.colortype()?;
-
         match color_type {
             ColorType::RGB(n)
             | ColorType::RGBA(n)
@@ -786,7 +639,6 @@ impl Image {
                 .ok_or(TiffError::FormatError(
                     TiffFormatError::InconsistentSizesEncountered,
                 ))?;
-
         if *compressed_bytes > limits.intermediate_buffer_size as u64 {
             return Err(TiffError::LimitsExceeded);
         }
@@ -794,39 +646,33 @@ impl Image {
         let compression_method = self.compression_method;
         let photometric_interpretation = self.photometric_interpretation;
         let predictor = self.predictor;
+        let samples = self.samples_per_pixel();
 
-        let samples = layout.tiff_samples;
-        let data_samples = layout.samples_per_out_texel();
-
-        // We have two dimensions: the 2d rectangle of encoded data and the 2d rectangle this
-        // takes up in the output. Each has an associated count of bits per pixel. The first
-        // dimension, i.e. a ''row'', is the number of pixels that are encoded with bit packing
-        // while the second is the byte-padded array of each so encoded slices.
-        //
-        // During decoding we map the relevant bits from one to the other.
         let chunk_dims = self.chunk_dimensions()?;
         let data_dims = self.chunk_data_dimensions(chunk_index)?;
 
-        let chunk_row_bytes: usize = layout.tiff_row_bytes;
+        let chunk_row_bits = (u64::from(chunk_dims.0) * u64::from(self.bits_per_sample))
-        let data_row_bytes: usize = layout.chunk_row_bytes(data_dims.0)?;
+            .checked_mul(samples as u64)
+            .ok_or(TiffError::LimitsExceeded)?;
+        let chunk_row_bytes: usize = chunk_row_bits.div_ceil(8).try_into()?;
+
+        let data_row_bits = (u64::from(data_dims.0) * u64::from(self.bits_per_sample))
+            .checked_mul(samples as u64)
+            .ok_or(TiffError::LimitsExceeded)?;
+        let data_row_bytes: usize = data_row_bits.div_ceil(8).try_into()?;
 
         // TODO: Should these return errors instead?
-        assert!(layout.minimum_row_stride >= data_row_bytes);
+        assert!(output_row_stride >= data_row_bytes);
-        assert!(buf.len() >= layout.row_stride * (data_dims.1 as usize - 1) + data_row_bytes);
+        assert!(buf.len() >= output_row_stride * (data_dims.1 as usize - 1) + data_row_bytes);
-
-        let is_all_bits = samples == data_samples;
-        let is_output_chunk_rows = layout.row_stride == chunk_row_bytes;
 
         let mut reader = Self::create_reader(
-            reader.inner(),
+            reader,
             compression_method,
             *compressed_bytes,
             self.jpeg_tables.as_deref().map(|a| &**a),
-            chunk_dims,
         )?;
 
-        if is_output_chunk_rows && is_all_bits {
+        if output_row_stride == chunk_row_bytes {
-            // Here we can read directly into the output buffer itself.
             let tile = &mut buf[..chunk_row_bytes * data_dims.1 as usize];
             reader.read_exact(tile)?;
 
@@ -839,15 +685,14 @@ impl Image {
                     predictor,
                 );
             }
-
             if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                super::invert_colors(tile, color_type, self.sample_format)?;
+                super::invert_colors(tile, color_type, self.sample_format);
             }
         } else if chunk_row_bytes > data_row_bytes && self.predictor == Predictor::FloatingPoint {
             // The floating point predictor shuffles the padding bytes into the encoded output, so
             // this case is handled specially when needed.
             let mut encoded = vec![0u8; chunk_row_bytes];
-            for row in buf.chunks_mut(layout.row_stride).take(data_dims.1 as usize) {
+            for row in buf.chunks_mut(output_row_stride).take(data_dims.1 as usize) {
                 reader.read_exact(&mut encoded)?;
 
                 let row = &mut row[..data_row_bytes];
@@ -858,19 +703,14 @@ impl Image {
                     _ => unreachable!(),
                 }
                 if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                    super::invert_colors(row, color_type, self.sample_format)?;
+                    super::invert_colors(row, color_type, self.sample_format);
                 }
             }
-        } else if is_all_bits {
+        } else {
-            // We read row-by-row but each row fits in its output buffer.
+            for row in buf.chunks_mut(output_row_stride).take(data_dims.1 as usize) {
-            for row in buf.chunks_mut(layout.row_stride).take(data_dims.1 as usize) {
                 let row = &mut row[..data_row_bytes];
-                let used = data_row_bytes.min(chunk_row_bytes);
+                reader.read_exact(row)?;
 
-                // Two ways how we get here: we have more bytes in our chunk data than in the image
-                // we are to read. Then we need to skip the rest of the data. Or we have a bigger
-                // row stride than the chunk contains data, then we  need to fill only the front.
-                reader.read_exact(&mut row[..used])?;
                 // Skip horizontal padding
                 if chunk_row_bytes > data_row_bytes {
                     let len = u64::try_from(chunk_row_bytes - data_row_bytes)?;
@@ -884,183 +724,12 @@ impl Image {
                     byte_order,
                     predictor,
                 );
-
                 if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                    super::invert_colors(row, color_type, self.sample_format)?;
+                    super::invert_colors(row, color_type, self.sample_format);
-                }
-            }
-        } else {
-            // The encoded data potentially takes up more space than the output data so we must be
-            // prepared to discard some of it. That decision is bit-by-bit.
-            let bits_per_pixel = u32::from(self.bits_per_sample) * u32::from(self.samples);
-            // Assumes the photometric samples are always the start.. This is slightly problematic.
-            // To expand spport we should instead have different methods of transforming the read
-            // buffer data, not only the `compact_photometric_bytes` method below and then choose
-            // from the right one with supplied parameters. Then we can also bit-for-bit copy with
-            // a selection for better performance.
-            let photometric_bit_end = u32::from(self.bits_per_sample) * data_samples as u32;
-
-            debug_assert!(bits_per_pixel >= photometric_bit_end);
-
-            if bits_per_pixel % 8 != 0 || photometric_bit_end % 8 != 0 {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::InterpretationWithBits(
-                        self.photometric_interpretation,
-                        vec![self.bits_per_sample; self.samples as usize],
-                    ),
-                ));
-            }
-
-            let photo_range = photometric_bit_end / 8..bits_per_pixel / 8;
-            let mut encoded = vec![0u8; chunk_row_bytes];
-            for row in buf.chunks_mut(layout.row_stride).take(data_dims.1 as usize) {
-                reader.read_exact(&mut encoded)?;
-
-                Self::compact_photometric_bytes(&mut encoded, row, &photo_range);
-
-                super::fix_endianness_and_predict(
-                    row,
-                    color_type.bit_depth(),
-                    samples,
-                    byte_order,
-                    predictor,
-                );
-
-                if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                    super::invert_colors(row, color_type, self.sample_format)?;
                 }
             }
         }
 
         Ok(())
     }
-
-    /// Turn a contiguous buffer of a whole number of raw sample arrays into a whole number of
-    /// photometric sample arrays by removing the extra samples in-between.
-    fn compact_photometric_bytes(
-        raw: &mut [u8],
-        row: &mut [u8],
-        photo_range: &std::ops::Range<u32>,
-    ) {
-        raw.chunks_exact_mut(photo_range.end as usize)
-            .zip(row.chunks_exact_mut(photo_range.start as usize))
-            .for_each(|(src, dst)| {
-                dst.copy_from_slice(&src[..photo_range.start as usize]);
-            });
-    }
-}
-
-impl ReadoutLayout {
-    pub(crate) fn samples_per_out_texel(&self) -> u16 {
-        match self.planar_config {
-            PlanarConfiguration::Chunky => self.color.num_samples(),
-            PlanarConfiguration::Planar => 1,
-        }
-    }
-
-    // For a concrete chunk, which may be a partial border chunk, the byte length of one row of its
-    // pixel data.
-    pub(crate) fn chunk_row_bytes(&self, width: u32) -> TiffResult<usize> {
-        let data_samples = self.samples_per_out_texel();
-        let data_row_bits = (u64::from(width) * u64::from(self.tiff_bits_per_sample))
-            .checked_mul(u64::from(data_samples))
-            .ok_or(TiffError::LimitsExceeded)?;
-        Ok(data_row_bits.div_ceil(8).try_into()?)
-    }
-
-    pub(crate) fn set_row_stride(&mut self, row_stride: usize) -> Result<(), TiffError> {
-        if row_stride < self.minimum_row_stride {
-            return Err(TiffError::UsageError(
-                UsageError::InsufficientOutputRowStride {
-                    needed: self.minimum_row_stride,
-                    requested: row_stride,
-                },
-            ));
-        }
-
-        let data_row_bytes = u64::try_from(row_stride)?;
-
-        let chunk_col_stride = data_row_bytes
-            .checked_mul(u64::from(self.tiff_chunk_dimensions.1))
-            .ok_or(TiffError::LimitsExceeded)?
-            .try_into()?;
-
-        let height = self.plane_stride.checked_div(self.row_stride);
-
-        let plane_stride = height
-            .and_then(|h| data_row_bytes.checked_mul(h as u64))
-            // If height was zero, or the previous stride was zero, there are no bytes in a plane
-            .unwrap_or(0)
-            .try_into()?;
-
-        self.row_stride = row_stride;
-        self.chunk_col_stride = chunk_col_stride;
-        self.plane_stride = plane_stride;
-
-        Ok(())
-    }
-
-    /// Reduce this down to the layout of the output planes.
-    pub(crate) fn to_plane_layout(&self) -> Result<PlaneLayout, TiffError> {
-        let num_planes = self.color.num_samples() / self.samples_per_out_texel();
-
-        // Using the standard range iterator as checked_add on steroids.
-        //
-        // Note: for supporting subsampling, adjust as required.
-        let mut offset = (0..=usize::MAX).step_by(self.plane_stride);
-
-        let plane_offsets = offset.by_ref().take(usize::from(num_planes)).collect();
-
-        // Get the past-the-end of the last plane.
-        //
-        // This also verifies the `take` above was not short.
-        let Some(total_bytes) = offset.next() else {
-            return Err(TiffError::LimitsExceeded);
-        };
-
-        Ok(PlaneLayout {
-            plane_offsets,
-            total_bytes,
-            readout: self.clone(),
-        })
-    }
-}
-
-/// A `ReadoutLayout` with pre-calculated plane information.
-pub(crate) struct PlaneLayout {
-    /// The underlying readout layout.
-    pub readout: ReadoutLayout,
-    /// Buffer offset from one plane of output to the next.
-    pub plane_offsets: Vec<usize>,
-    /// Total number of bytes for all planes in given order.
-    pub total_bytes: usize,
-}
-
-impl PlaneLayout {
-    /// Return the number of planes to extract into the provided buffer.
-    pub(crate) fn used_planes(&self, buffer: &[impl Sized]) -> TiffResult<u16> {
-        self.readout.assert_min_layout(buffer)?;
-        let buffer_len = core::mem::size_of_val(buffer);
-
-        // Note: with differently sized planes this is dependent on the plane.
-        let last_plane_start = buffer_len.checked_sub(self.readout.plane_stride);
-
-        // Find how many planes fit into the output buffer.
-        let used_plane_offsets = self
-            .plane_offsets
-            .iter()
-            .enumerate()
-            // Find the first plane that would not fit completely at its offset.
-            .skip_while(|(_, &offset)| last_plane_start >= Some(offset))
-            .nth(0)
-            // If all planes fit, use all of them.
-            .map_or(self.plane_offsets.len(), |(idx, _)| idx);
-
-        debug_assert!(
-            used_plane_offsets <= usize::from(u16::MAX),
-            "Planes limited by number of samples, which is encoded as u16"
-        );
-
-        Ok(used_plane_offsets as u16)
-    }
 }

src/decoder/stream.rs

@@ -1,7 +1,15 @@
 //! All IO functionality needed for TIFF decoding
+
 use std::io::{self, BufRead, BufReader, Read, Seek, Take};
 
-pub use crate::tags::ByteOrder;
+/// Byte order of the TIFF file.
+#[derive(Clone, Copy, Debug)]
+pub enum ByteOrder {
+    /// little endian byte order
+    LittleEndian,
+    /// big endian byte order
+    BigEndian,
+}
 
 /// Reader that is aware of the byte order.
 #[derive(Debug)]
@@ -38,6 +46,17 @@ impl<R: Read> EndianReader<R> {
         })
     }
 
+    /// Reads an i8
+    #[inline(always)]
+    pub fn read_i8(&mut self) -> Result<i8, io::Error> {
+        let mut n = [0u8; 1];
+        self.reader.read_exact(&mut n)?;
+        Ok(match self.byte_order {
+            ByteOrder::LittleEndian => i8::from_le_bytes(n),
+            ByteOrder::BigEndian => i8::from_be_bytes(n),
+        })
+    }
+
     /// Reads an i16
     #[inline(always)]
     pub fn read_i16(&mut self) -> Result<i16, io::Error> {
@@ -168,6 +187,9 @@ impl<R: Read> Read for LZWReader<R> {
                     }
                 }
                 Ok(weezl::LzwStatus::NoProgress) => {
+                    assert_eq!(result.consumed_in, 0);
+                    assert_eq!(result.consumed_out, 0);
+                    assert!(self.reader.buffer().is_empty());
                     return Err(io::Error::new(
                         io::ErrorKind::UnexpectedEof,
                         "no lzw end code found",
@@ -254,106 +276,6 @@ impl<R: Read> Read for PackBitsReader<R> {
     }
 }
 
-#[cfg(feature = "fax")]
-pub struct Group4Reader<R: Read> {
-    decoder: fax34::decoder::Group4Decoder<io::Bytes<io::BufReader<io::Take<R>>>>,
-    line_buf: io::Cursor<Vec<u8>>,
-    height: u16,
-    width: u16,
-    y: u16,
-}
-
-#[cfg(feature = "fax")]
-impl<R: Read> Group4Reader<R> {
-    pub fn new(
-        dimensions: (u32, u32),
-        reader: R,
-        compressed_length: u64,
-    ) -> crate::TiffResult<Self> {
-        let width = u16::try_from(dimensions.0)?;
-        let height = u16::try_from(dimensions.1)?;
-
-        Ok(Self {
-            decoder: fax34::decoder::Group4Decoder::new(
-                io::BufReader::new(reader.take(compressed_length)).bytes(),
-                width,
-            )?,
-            line_buf: io::Cursor::new(Vec::with_capacity(width.into())),
-            width,
-            height,
-            y: 0,
-        })
-    }
-}
-
-#[cfg(feature = "fax")]
-impl<R: Read> Read for Group4Reader<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        // Either we have not read any line or we are at the end of a line.
-        if self.line_buf.position() as usize == self.line_buf.get_ref().len()
-            && self.y < self.height
-        {
-            let next = self.decoder.advance().map_err(std::io::Error::other)?;
-
-            match next {
-                fax34::decoder::DecodeStatus::End => (),
-                fax34::decoder::DecodeStatus::Incomplete => {
-                    self.y += 1;
-
-                    // We known `transitions` yields exactly `self.width` items (per doc).
-                    // FIXME: performance. We do not need an individual pixel iterator, filling
-                    // memory especially for long runs can be much quicker. The `transitions` are
-                    // the positions at which each run-length ends, i.e. the prefix sum of run
-                    // lengths. Runs in fax4 start with white.
-                    let transitions = fax34::decoder::pels(self.decoder.transition(), self.width);
-
-                    let buffer = self.line_buf.get_mut();
-                    buffer.resize(usize::from(self.width).div_ceil(8), 0u8);
-
-                    let target = &mut buffer[..];
-
-                    // Note: it may seem strange to treat black as 0b1 and white as 0b0 despite all
-                    // our streams by default decoding as-if PhotometricInterpretation::BlackIsMin.
-                    // This is however consistent with libtiff. It seems that fax4's "White"
-                    // differs from what libtiff thinks of as "White". For content, a line of data
-                    // is in runlength encoding of white-black-white-black always starting with
-                    // white. In libtiff, the loop always does both colors in one go and the
-                    // structure is:
-                    //
-                    // ```
-                    // for (; runs < erun; runs += 2)
-                    //   // white run
-                    //       do { *lp++ = 0L; } while (…)
-                    //   // black run
-                    //       do { *lp++ = -1L; } while (…)
-                    // ```
-                    //
-                    // So indeed the Fax4::White run is implemented by filling with zeros.
-                    let mut bits = transitions.map(|c| match c {
-                        fax34::Color::Black => true,
-                        fax34::Color::White => false,
-                    });
-
-                    // Assemble bits in MSB as per our library representation for buffer.
-                    for byte in target {
-                        let mut val = 0;
-
-                        for (idx, bit) in bits.by_ref().take(8).enumerate() {
-                            val |= u8::from(bit) << (7 - idx % 8);
-                        }
-
-                        *byte = val;
-                    }
-
-                    self.line_buf.set_position(0);
-                }
-            }
-        }
-
-        self.line_buf.read(buf)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

src/directory.rs

@@ -29,7 +29,7 @@ pub struct Directory {
 impl Directory {
     /// Create a directory in an initial state without entries. Note that an empty directory can
     /// not be encoded in a file, it must contain at least one entry.
-    pub fn empty() -> Self {
+    pub const fn empty() -> Self {
         Directory {
             entries: BTreeMap::new(),
             next_ifd: None,
@@ -104,28 +104,6 @@ impl Directory {
             }
         }
     }
-
-    pub(crate) fn encoded_len<K: crate::encoder::TiffKind>(&self) -> u64 {
-        let (len_count, len_offset);
-
-        match std::mem::size_of::<K::OffsetType>() {
-            offset @ 4 => {
-                // non-BigTiff uses a `u16` here.
-                len_count = 2;
-                len_offset = offset as u64;
-            }
-            offset => {
-                let offset = offset as u64;
-                // assuming BigTIFF
-                len_count = offset;
-                len_offset = offset;
-            }
-        }
-
-        // Each entry is 12 bytes in classic TIFF, 20 bytes in BigTIFF.
-        let entry_bytes = 4 + 2 * len_offset;
-        len_count + entry_bytes * self.entries.len() as u64 + len_offset
-    }
 }
 
 impl fmt::Debug for Directory {
@@ -140,14 +118,6 @@ impl fmt::Debug for Directory {
     }
 }
 
-impl core::iter::FromIterator<(Tag, Entry)> for Directory {
-    fn from_iter<T: IntoIterator<Item = (Tag, Entry)>>(iter: T) -> Self {
-        let mut dir = Directory::empty();
-        dir.extend(iter);
-        dir
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::Directory;

src/encoder/compression/uncompressed.rs

@@ -14,7 +14,7 @@ impl Compression for Uncompressed {
 
 impl CompressionAlgorithm for Uncompressed {
     fn write_to<W: Write>(&mut self, writer: &mut W, bytes: &[u8]) -> Result<u64, io::Error> {
-        writer.write_all(bytes).map(|()| bytes.len() as u64)
+        writer.write(bytes).map(|byte_count| byte_count as u64)
     }
 }
 

src/encoder/mod.rs

@@ -11,7 +11,7 @@ use std::{
 use crate::{
     decoder::ifd::Entry,
     error::{TiffResult, UsageError},
-    tags::{CompressionMethod, ExtraSamples, IfdPointer, ResolutionUnit, SampleFormat, Tag, Type},
+    tags::{CompressionMethod, IfdPointer, ResolutionUnit, SampleFormat, Tag, Type},
     Directory, TiffError, TiffFormatError,
 };
 
@@ -37,9 +37,8 @@ pub type Predictor = crate::tags::Predictor;
 #[cfg(feature = "deflate")]
 pub type DeflateLevel = compression::DeflateLevel;
 
-#[derive(Clone, Copy, PartialEq, Default)]
+#[derive(Clone, Copy, PartialEq)]
 pub enum Compression {
-    #[default]
     Uncompressed,
     #[cfg(feature = "lzw")]
     Lzw,
@@ -48,6 +47,12 @@ pub enum Compression {
     Packbits,
 }
 
+impl Default for Compression {
+    fn default() -> Self {
+        Self::Uncompressed
+    }
+}
+
 impl Compression {
     fn tag(&self) -> CompressionMethod {
         match self {
@@ -74,10 +79,10 @@ impl Compression {
 
 /// Encoder for Tiff and BigTiff files.
 ///
-/// With this type you can get a [`DirectoryEncoder`] or a [`ImageEncoder`]
+/// With this type you can get a `DirectoryEncoder` or a `ImageEncoder`
 /// to encode Tiff/BigTiff ifd directories with images.
 ///
-/// See [`DirectoryEncoder`] and [`ImageEncoder`].
+/// See `DirectoryEncoder` and `ImageEncoder`.
 ///
 /// # Examples
 /// ```
@@ -171,7 +176,7 @@ impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {
         Self::chain_directory(&mut self.writer, &mut self.last_ifd_chain)
     }
 
-    /// Create a [`DirectoryEncoder`] to encode an ifd (directory).
+    /// Create a [`DirectoryEncoder`] to encode an ifd directory.
     ///
     /// The caller is responsible for ensuring that the directory is a valid image in the main TIFF
     /// IFD sequence. To encode additional directories that are not linked into the sequence, use
@@ -180,7 +185,7 @@ impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {
         Self::chain_directory(&mut self.writer, &mut self.last_ifd_chain)
     }
 
-    /// Create a [`DirectoryEncoder`] to encode a non-image directory.
+    /// Create a [`DirectoryEncoder`] to encode an ifd directory.
     ///
     /// The directory is not linked into the sequence of directories. For instance, encode Exif
     /// directories or SubIfd directories with this method.
@@ -193,7 +198,7 @@ impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {
         &mut self,
         width: u32,
         height: u32,
-    ) -> TiffResult<ImageEncoder<'_, W, C, K>> {
+    ) -> TiffResult<ImageEncoder<W, C, K>> {
         let encoder = Self::chain_directory(&mut self.writer, &mut self.last_ifd_chain)?;
         ImageEncoder::new(encoder, width, height, self.compression, self.predictor)
     }
@@ -244,12 +249,6 @@ pub struct DirectoryEncoder<'a, W: 'a + Write + Seek, K: TiffKind> {
 }
 
 /// The offset of an encoded directory in the file.
-///
-/// Both the `offset` and `pointer` field are a complete description of the start offset of the
-/// dictionary which is used to point to it. The struct also describes the extent covered by the
-/// encoding of the directory. The constructors [`new`][DirectoryOffset::new] allow the checked
-/// conversion. Note that even though the offsets are public do not expect their information to
-/// propagate when modified.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct DirectoryOffset<K: TiffKind> {
     /// The start of the directory as a Tiff value.
@@ -261,9 +260,7 @@ pub struct DirectoryOffset<K: TiffKind> {
     pub offset: K::OffsetType,
     /// The start of the directory as a pure offset.
     pub pointer: IfdPointer,
-    /// The offset of its sequence link field, in our private representation. Before exposing this
+    /// The offset of its sequence link field, in our private representation.
-    /// make sure that we don't want any invariants (e.g. pointer being smaller than this). The
-    /// type should be fine.
     ifd_chain: NonZeroU64,
     /// The kind of Tiff file the offset is for.
     kind: PhantomData<K>,
@@ -321,17 +318,6 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
         Ok(offset)
     }
 
-    /// Insert previously written key-value entries.
-    ///
-    /// It is the caller's responsibility to ensure that the data referred to by the entries is
-    /// actually (or will be) written to the file. Note that small values are necessarily inline in
-    /// the entry, the size limit depends on the Tiff kind. So do not confuse a directory from a
-    /// BigTiff in a standard tiff or the other way around.
-    pub fn extend_from(&mut self, dir: &Directory) {
-        let entries = dir.iter().map(|(tag, val)| (tag, val.clone()));
-        self.directory.extend(entries);
-    }
-
     /// Define the parent directory.
     ///
     /// Each directory has an offset based link to its successor, forming a linked list in the
@@ -348,11 +334,6 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
         Ok(())
     }
 
-    /// Write the IFD to the file and return the offset it is written to.
-    ///
-    /// The offset can be used as the value, or as part of a list of values, in the entry of
-    /// another directory. If you're constructing the entry directly you'll want to use an
-    /// appropriate type variant for this such as [`Type::IFD`].
     pub fn finish_with_offsets(mut self) -> TiffResult<DirectoryOffset<K>> {
         self.finish_internal()
     }
@@ -506,7 +487,6 @@ pub struct ImageEncoder<'a, W: 'a + Write + Seek, C: ColorType, K: TiffKind> {
     row_samples: u64,
     width: u32,
     height: u32,
-    extra_samples: Vec<u16>,
     rows_per_strip: u64,
     strip_offsets: Vec<K::OffsetType>,
     strip_byte_count: Vec<K::OffsetType>,
@@ -563,6 +543,9 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind> ImageEncoder<'a, W, T,
         encoder.write_tag(Tag::Compression, compression.tag().to_u16())?;
         encoder.write_tag(Tag::Predictor, predictor.to_u16())?;
 
+        encoder.write_tag(Tag::BitsPerSample, <T>::BITS_PER_SAMPLE)?;
+        let sample_format: Vec<_> = <T>::SAMPLE_FORMAT.iter().map(|s| s.to_u16()).collect();
+        encoder.write_tag(Tag::SampleFormat, &sample_format[..])?;
         encoder.write_tag(Tag::PhotometricInterpretation, <T>::TIFF_VALUE.to_u16())?;
 
         encoder.write_tag(Tag::RowsPerStrip, u32::try_from(rows_per_strip)?)?;
@@ -581,7 +564,6 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind> ImageEncoder<'a, W, T,
             strip_idx: 0,
             row_samples,
             rows_per_strip,
-            extra_samples: vec![],
             width,
             height,
             strip_offsets: Vec::new(),
@@ -593,27 +575,6 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind> ImageEncoder<'a, W, T,
         })
     }
 
-    pub fn extra_samples(&mut self, extra: &[ExtraSamples]) -> Result<(), TiffError> {
-        if self.strip_idx != 0 {
-            return Err(TiffError::UsageError(
-                UsageError::ReconfiguredAfterImageWrite,
-            ));
-        }
-
-        let samples = self.extra_samples.len() + extra.len() + <T>::BITS_PER_SAMPLE.len();
-        let row_samples = u64::from(self.width) * u64::try_from(samples)?;
-
-        self.extra_samples
-            .extend(extra.iter().map(ExtraSamples::to_u16));
-
-        self.encoder
-            .write_tag(Tag::ExtraSamples, &self.extra_samples[..])?;
-
-        self.row_samples = row_samples;
-
-        Ok(())
-    }
-
     /// Number of samples the next strip should have.
     pub fn next_strip_sample_count(&self) -> u64 {
         if self.strip_idx >= self.strip_count {
@@ -751,39 +712,6 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind> ImageEncoder<'a, W, T,
     }
 
     fn finish_internal(&mut self) -> TiffResult<DirectoryOffset<K>> {
-        if self.extra_samples.is_empty() {
-            self.encoder
-                .write_tag(Tag::BitsPerSample, <T>::BITS_PER_SAMPLE)?;
-        } else {
-            let mut sample_format: Vec<_> = <T>::BITS_PER_SAMPLE.to_vec();
-            let replicated =
-                core::iter::repeat(<T>::BITS_PER_SAMPLE[0]).take(self.extra_samples.len());
-            sample_format.extend(replicated);
-
-            self.encoder
-                .write_tag(Tag::BitsPerSample, &sample_format[..])?;
-
-            self.encoder.write_tag(
-                Tag::SamplesPerPixel,
-                u16::try_from(<T>::BITS_PER_SAMPLE.len() + self.extra_samples.len())?,
-            )?;
-        }
-
-        let mut sample_format: Vec<_> = <T>::SAMPLE_FORMAT.iter().map(|s| s.to_u16()).collect();
-        let extra_format = sample_format
-            .first()
-            .copied()
-            // Frankly should not occur, we have no sample format without at least one entry. We
-            // would need an interface upgrade to handle this however. Either decide to support
-            // heterogeneous sample formats or a way to provide fallback that is used for purely
-            // extra samples and not provided via a slice used for samples themselves.
-            .unwrap_or(SampleFormat::Void.to_u16());
-
-        sample_format.extend(core::iter::repeat(extra_format).take(self.extra_samples.len()));
-
-        self.encoder
-            .write_tag(Tag::SampleFormat, &sample_format[..])?;
-
         self.encoder
             .write_tag(Tag::StripOffsets, K::convert_slice(&self.strip_offsets))?;
         self.encoder.write_tag(
@@ -863,71 +791,6 @@ pub trait TiffKind {
     fn convert_slice(slice: &[Self::OffsetType]) -> &Self::OffsetArrayType;
 }
 
-impl<K: TiffKind> DirectoryOffset<K> {
-    /// Construct the directory pointer information from its raw offset.
-    ///
-    /// Fails in these cases:
-    ///
-    /// - if start offset is too large to be represented with the chosen TIFF format, i.e. a value
-    ///   larger than [`u32::MAX`] with a standard tiff which is only valid in a BigTiff. This
-    ///   returns [`TiffError::IntSizeError`].
-    /// - the extent of the directory would overflow the file length. This returns a
-    ///   [`TiffError::UsageError`].
-    ///
-    /// The library does *not* validate the contents or offset in any way, it just performs the
-    /// necessary math assuming the data is an accurate representation of existing content.
-    ///
-    /// # Examples
-    ///
-    /// If you have any custom way of writing a directory to a file that can not go through the
-    /// usual [`TiffEncoder::extra_directory`] then you can reconstruct the offset information as
-    /// long as you provide all the necessary data to the library. You can then use it as a parent
-    /// directory, i.e. have the library overwrite its `next` field.
-    ///
-    /// ```
-    /// use tiff::{
-    ///     encoder::{TiffEncoder, DirectoryOffset},
-    ///     Directory,
-    ///     tags::IfdPointer,
-    /// };
-    ///
-    /// # let mut file = std::io::Cursor::new(Vec::new());
-    /// let mut tiff = TiffEncoder::new(&mut file)?;
-    ///
-    /// // … some custom data writes, assume we know where a directory was written
-    /// # fn reconstruction_of_your_directory() -> Directory { Directory::from_iter([]) }
-    /// let known_offset = IfdPointer(1024);
-    /// let known_contents: Directory = reconstruction_of_your_directory();
-    ///
-    /// let reconstructed = DirectoryOffset::new(known_offset, &known_contents)?;
-    ///
-    /// // Now we can use it as if the directory was written by the `TiffEncoder` itself.
-    /// let mut chain = tiff.extra_directory()?;
-    /// chain.set_parent(&reconstructed);
-    /// chain.finish_with_offsets()?;
-    ///
-    /// # Ok::<_, tiff::TiffError>(())
-    /// ```
-    pub fn new(pointer: IfdPointer, dir: &Directory) -> TiffResult<Self> {
-        let offset = K::convert_offset(pointer.0)?;
-        let encoded = dir.encoded_len::<K>();
-        let offset_field_offset = encoded - mem::size_of_val(&offset) as u64;
-
-        let ifd_chain = pointer
-            .0
-            .checked_add(offset_field_offset)
-            .and_then(NonZeroU64::new)
-            .ok_or(TiffError::UsageError(UsageError::ZeroIfdPointer))?;
-
-        Ok(DirectoryOffset {
-            pointer,
-            offset,
-            ifd_chain,
-            kind: PhantomData,
-        })
-    }
-}
-
 /// Create a standard Tiff file.
 pub struct TiffKindStandard;
 
@@ -996,33 +859,3 @@ impl TiffKind for TiffKindBig {
         slice
     }
 }
-
-#[test]
-fn directory_offset_new_equivalent_to_writing() {
-    type K = TiffKindStandard;
-
-    let dir = Directory::from_iter(vec![
-        (
-            Tag::ImageWidth,
-            Entry::new(Type::LONG, 1, 100u32.to_ne_bytes()),
-        ),
-        (
-            Tag::ImageLength,
-            Entry::new(Type::LONG, 1, 200u32.to_ne_bytes()),
-        ),
-    ]);
-
-    let data = std::io::Cursor::new(vec![]);
-    let mut file = TiffEncoder::new(data).unwrap();
-
-    let mut as_dir_encoder = file.extra_directory().unwrap();
-    as_dir_encoder.extend_from(&dir);
-    let dir_extent = as_dir_encoder.finish_with_offsets().unwrap();
-
-    // Check we can recreate the extent had we written ourselves.
-    let synth = DirectoryOffset::<K>::new(dir_extent.pointer, &dir).unwrap();
-
-    assert_eq!(synth.pointer, dir_extent.pointer);
-    assert_eq!(synth.offset, dir_extent.offset);
-    assert_eq!(synth.ifd_chain, dir_extent.ifd_chain);
-}

src/encoder/tiff_value.rs

@@ -15,7 +15,7 @@ pub trait TiffValue {
 
     /// Access this value as an contiguous sequence of bytes.
     /// If their is no trivial representation, allocate it on the heap.
-    fn data(&self) -> Cow<'_, [u8]>;
+    fn data(&self) -> Cow<[u8]>;
 
     /// Write this value to a TiffWriter.
     /// While the default implementation will work in all cases, it may require unnecessary allocations.
@@ -34,7 +34,7 @@ impl TiffValue for [u8] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(self)
     }
 }
@@ -47,7 +47,7 @@ impl TiffValue for [i8] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i8_as_ne_bytes(self))
     }
 }
@@ -60,7 +60,7 @@ impl TiffValue for [u16] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u16_as_ne_bytes(self))
     }
 }
@@ -73,7 +73,7 @@ impl TiffValue for [i16] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i16_as_ne_bytes(self))
     }
 }
@@ -86,7 +86,7 @@ impl TiffValue for [u32] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u32_as_ne_bytes(self))
     }
 }
@@ -99,7 +99,7 @@ impl TiffValue for [i32] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i32_as_ne_bytes(self))
     }
 }
@@ -112,7 +112,7 @@ impl TiffValue for [u64] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u64_as_ne_bytes(self))
     }
 }
@@ -125,7 +125,7 @@ impl TiffValue for [i64] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i64_as_ne_bytes(self))
     }
 }
@@ -138,7 +138,7 @@ impl TiffValue for [f32] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         // We write using native endian so this should be safe
         Cow::Borrowed(bytecast::f32_as_ne_bytes(self))
     }
@@ -152,7 +152,7 @@ impl TiffValue for [f64] {
         self.len()
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         // We write using native endian so this should be safe
         Cow::Borrowed(bytecast::f64_as_ne_bytes(self))
     }
@@ -171,7 +171,7 @@ impl TiffValue for u8 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(from_ref(self))
     }
 }
@@ -189,7 +189,7 @@ impl TiffValue for i8 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i8_as_ne_bytes(from_ref(self)))
     }
 }
@@ -207,7 +207,7 @@ impl TiffValue for u16 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u16_as_ne_bytes(from_ref(self)))
     }
 }
@@ -225,7 +225,7 @@ impl TiffValue for i16 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i16_as_ne_bytes(from_ref(self)))
     }
 }
@@ -243,7 +243,7 @@ impl TiffValue for u32 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(self)))
     }
 }
@@ -261,7 +261,7 @@ impl TiffValue for i32 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i32_as_ne_bytes(from_ref(self)))
     }
 }
@@ -279,7 +279,7 @@ impl TiffValue for u64 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(self)))
     }
 }
@@ -297,7 +297,7 @@ impl TiffValue for i64 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::i64_as_ne_bytes(from_ref(self)))
     }
 }
@@ -315,7 +315,7 @@ impl TiffValue for f32 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::f32_as_ne_bytes(from_ref(self)))
     }
 }
@@ -333,7 +333,7 @@ impl TiffValue for f64 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::f64_as_ne_bytes(from_ref(self)))
     }
 }
@@ -351,7 +351,7 @@ impl TiffValue for Ifd {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(&self.0)))
     }
 }
@@ -369,7 +369,7 @@ impl TiffValue for Ifd8 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(&self.0)))
     }
 }
@@ -388,7 +388,7 @@ impl TiffValue for Rational {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Owned({
             let first_dword = bytecast::u32_as_ne_bytes(from_ref(&self.n));
             let second_dword = bytecast::u32_as_ne_bytes(from_ref(&self.d));
@@ -411,7 +411,7 @@ impl TiffValue for SRational {
         Ok(())
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Owned({
             let first_dword = bytecast::i32_as_ne_bytes(from_ref(&self.n));
             let second_dword = bytecast::i32_as_ne_bytes(from_ref(&self.d));
@@ -438,7 +438,7 @@ impl TiffValue for str {
         }
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         Cow::Owned({
             if self.is_ascii() && !self.bytes().any(|b| b == 0) {
                 let bytes: &[u8] = self.as_bytes();
@@ -462,7 +462,7 @@ impl<T: TiffValue + ?Sized> TiffValue for &'_ T {
         (*self).write(writer)
     }
 
-    fn data(&self) -> Cow<'_, [u8]> {
+    fn data(&self) -> Cow<[u8]> {
         T::data(self)
     }
 }
@@ -484,7 +484,7 @@ macro_rules! impl_tiff_value_for_contiguous_sequence {
                 Ok(())
             }
 
-            fn data(&self) -> Cow<'_, [u8]> {
+            fn data(&self) -> Cow<[u8]> {
                 let mut buf: Vec<u8> = Vec::with_capacity(Self::BYTE_LEN as usize * self.len());
                 for x in self {
                     buf.extend_from_slice(&x.data());

src/encoder/writer.rs

@@ -190,64 +190,3 @@ impl<W: Seek> TiffWriter<W> {
         Ok(())
     }
 }
-
-#[test]
-fn encoder_on_short_writes() {
-    struct ShortWriter<T> {
-        inner: T,
-    }
-
-    impl<T: std::io::Write> std::io::Write for ShortWriter<T> {
-        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-            let lower_bound = buf.len().min(1);
-            let lower = buf.len().saturating_sub(1).max(lower_bound);
-
-            self.inner.write(&buf[..lower])
-        }
-
-        fn flush(&mut self) -> std::io::Result<()> {
-            self.inner.flush()
-        }
-    }
-
-    impl<T: std::io::Seek> std::io::Seek for ShortWriter<T> {
-        fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
-            self.inner.seek(pos)
-        }
-    }
-
-    let mut write = ShortWriter {
-        inner: std::io::Cursor::new(vec![0u8; 0]),
-    };
-
-    let imgdata = vec![42u8; 100 * 100];
-    let mut data = crate::decoder::DecodingResult::U8(vec![]);
-
-    for comp in [
-        super::Compression::Uncompressed,
-        super::Compression::Packbits,
-    ] {
-        write.inner.set_position(0);
-        write.inner.get_mut().clear();
-
-        {
-            let mut tiff_writer = super::TiffEncoder::new(&mut write)
-                .unwrap()
-                .with_compression(comp);
-
-            tiff_writer
-                .write_image::<super::Gray8>(100, 100, &imgdata)
-                .unwrap();
-        }
-
-        write.inner.set_position(0);
-        let mut tiff_reader = crate::decoder::Decoder::new(&mut write.inner).unwrap();
-        let _layout = tiff_reader.read_image_to_buffer(&mut data).unwrap();
-
-        assert!(
-            matches!(&data, crate::decoder::DecodingResult::U8(v) if *v == imgdata),
-            "{data:?} @ {}",
-            data.as_buffer(0).byte_len()
-        );
-    }
-}

src/error.rs

@@ -175,12 +175,6 @@ quick_error! {
         InvalidChunkIndex(index: u32) {
             display("invalid chunk index ({index}) requested")
         }
-        InvalidPlaneIndex(index: u16) {
-            display("invalid plane index ({index}) requested")
-        }
-        InvalidCodingUnit(index: u32, have: u32) {
-            display("out of bounds coding unit ({index}) requested, only {have} available")
-        }
         PredictorCompressionMismatch {
             display("requested predictor is not compatible with the requested compression")
         }
@@ -193,15 +187,6 @@ quick_error! {
         InsufficientOutputBufferSize { needed: usize, provided: usize } {
             display("the borrowed output buffer is not large enough for the decoded data, needed {needed} but have {provided}")
         }
-        InsufficientOutputRowStride { needed: usize, requested: usize } {
-            display("the provided output row stride would alias rows of decoded data, needed {needed} but have {requested}")
-        }
-        ZeroIfdPointer {
-            display("the offset 0 can not point to a valid IFD")
-        }
-        ReconfiguredAfterImageWrite {
-            display("attempted to reconfigure the encoder after image writing has started")
-        }
     }
 }
 

src/lib.rs

@@ -61,18 +61,4 @@ impl ColorType {
             | ColorType::Multiband { bit_depth: b, .. } => b,
         }
     }
-
-    fn num_samples(&self) -> u16 {
-        match *self {
-            ColorType::Gray(_) => 1,
-            ColorType::RGB(_) => 3,
-            ColorType::Palette(_) => 1,
-            ColorType::GrayA(_) => 2,
-            ColorType::RGBA(_) => 4,
-            ColorType::CMYK(_) => 4,
-            ColorType::CMYKA(_) => 5,
-            ColorType::YCbCr(_) => 3,
-            ColorType::Multiband { num_samples, .. } => num_samples,
-        }
-    }
 }

src/tags.rs

@@ -193,45 +193,6 @@ pub enum Type(u16) {
 }
 }
 
-impl Type {
-    pub(crate) fn byte_len(&self) -> u8 {
-        match *self {
-            Type::BYTE | Type::SBYTE | Type::ASCII | Type::UNDEFINED => 1,
-            Type::SHORT | Type::SSHORT => 2,
-            Type::LONG | Type::SLONG | Type::FLOAT | Type::IFD => 4,
-            Type::LONG8
-            | Type::SLONG8
-            | Type::DOUBLE
-            | Type::RATIONAL
-            | Type::SRATIONAL
-            | Type::IFD8 => 8,
-        }
-    }
-
-    pub(crate) fn value_bytes(&self, count: u64) -> Result<u64, crate::error::TiffError> {
-        let tag_size = u64::from(self.byte_len());
-
-        match count.checked_mul(tag_size) {
-            Some(n) => Ok(n),
-            None => Err(crate::error::TiffError::LimitsExceeded),
-        }
-    }
-
-    pub(crate) fn endian_bytes(self) -> EndianBytes {
-        match self {
-            Type::BYTE | Type::SBYTE | Type::ASCII | Type::UNDEFINED => EndianBytes::One,
-            Type::SHORT | Type::SSHORT => EndianBytes::Two,
-            Type::LONG
-            | Type::SLONG
-            | Type::FLOAT
-            | Type::IFD
-            | Type::RATIONAL
-            | Type::SRATIONAL => EndianBytes::Four,
-            Type::LONG8 | Type::SLONG8 | Type::DOUBLE | Type::IFD8 => EndianBytes::Eight,
-        }
-    }
-}
-
 tags! {
 /// See [TIFF compression tags](https://www.awaresystems.be/imaging/tiff/tifftags/compression.html)
 /// for reference.
@@ -310,90 +271,3 @@ pub enum SampleFormat(u16) unknown(
     Void = 4,
 }
 }
-
-tags! {
-pub enum ExtraSamples(u16) {
-    /// There is no specified association between the sample and the image.
-    Unspecified = 0,
-    /// The sample is associated alpha, i.e. pre-multiplied color.
-    AssociatedAlpha = 1,
-    /// The sample is unassociated alpha such as a mask. There might be more than one such sample.
-    UnassociatedAlpha = 2,
-}
-}
-
-/// Byte order of the TIFF file.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ByteOrder {
-    /// little endian byte order
-    LittleEndian,
-    /// big endian byte order
-    BigEndian,
-}
-
-impl ByteOrder {
-    /// Get the byte order representing the running target.
-    ///
-    /// The infallibility of this method represents the fact that only little and big endian
-    /// systems are supported by the library. No mixed endian and no other weird stuff. (Note: as
-    /// of Rust 1.90 this is a tautology as Rust itself only has those two kinds).
-    pub const fn native() -> Self {
-        match () {
-            #[cfg(target_endian = "little")]
-            () => ByteOrder::LittleEndian,
-            #[cfg(target_endian = "big")]
-            () => ByteOrder::BigEndian,
-            #[cfg(not(any(target_endian = "big", target_endian = "little")))]
-            () => compile_error!("Unsupported target"),
-        }
-    }
-
-    /// Given a typed buffer, convert its contents to the specified byte order in-place.
-    ///
-    /// The buffer is assumed to represent an array of the given type. If the length of the buffer
-    /// is not divisible into an integer number of values, the behavior for the remaining bytes it
-    /// not specified.
-    pub fn convert(self, ty: Type, buffer: &mut [u8], to: ByteOrder) {
-        self.convert_endian_bytes(ty.endian_bytes(), buffer, to)
-    }
-
-    pub(crate) fn convert_endian_bytes(self, cls: EndianBytes, buffer: &mut [u8], to: ByteOrder) {
-        if self == to {
-            return;
-        }
-
-        // FIXME: at MSRV 1.89 or higher use `slice::as_chunks_mut`.
-        match cls {
-            EndianBytes::One => {
-                // No change needed
-            }
-            EndianBytes::Two => {
-                for chunk in buffer.chunks_exact_mut(2) {
-                    let chunk: &mut [u8; 2] = chunk.try_into().unwrap();
-                    *chunk = u16::from_be_bytes(*chunk).to_le_bytes();
-                }
-            }
-            EndianBytes::Four => {
-                for chunk in buffer.chunks_exact_mut(4) {
-                    let chunk: &mut [u8; 4] = chunk.try_into().unwrap();
-                    *chunk = u32::from_be_bytes(*chunk).to_le_bytes();
-                }
-            }
-            EndianBytes::Eight => {
-                for chunk in buffer.chunks_exact_mut(8) {
-                    let chunk: &mut [u8; 8] = chunk.try_into().unwrap();
-                    *chunk = u64::from_be_bytes(*chunk).to_le_bytes();
-                }
-            }
-        }
-    }
-}
-
-/// The size of individual byte-order corrected elements.
-#[derive(Clone, Copy)]
-pub(crate) enum EndianBytes {
-    One,
-    Two,
-    Four,
-    Eight,
-}

tests/decode_images.rs

@@ -672,51 +672,3 @@ fn bytes_gray_f32() {
         byte_order_u32,
     );
 }
-
-#[test]
-#[cfg(feature = "fax")]
-fn test_fax4() {
-    test_image_sum_u8("fax4.tiff", ColorType::Gray(1), 7802706);
-}
-
-#[test]
-#[cfg(feature = "fax")]
-fn test_fax4_white_is_min() {
-    test_image_sum_u8("imagemagick_group4.tiff", ColorType::Gray(1), 3742820);
-}
-
-#[test]
-fn write_extra_bits_image() {
-    use tiff::{encoder, tags::ExtraSamples};
-
-    let path = PathBuf::from(TEST_IMAGE_DIR).join("extra_bits_rgb_8b.tiff");
-    let img_file = File::create(path).expect("Cannot find test image!");
-
-    let mut encoder = encoder::TiffEncoder::new(img_file).expect("Cannot create encoder");
-    let mut img = encoder.new_image::<encoder::colortype::RGB8>(8, 8).unwrap();
-
-    img.extra_samples(&[ExtraSamples::Unspecified]).unwrap();
-
-    // all pixels are supposed to be 0, the extra is 1
-    let data: [u8; 256] = core::array::from_fn(|i| (i as u8 % 4).saturating_sub(2));
-
-    img.write_data(&data)
-        .expect("correct amount of data to write");
-}
-
-#[test]
-fn extra_bits_gray() {
-    test_image_sum_u8(
-        "extra_bits_gray_8b.tiff",
-        ColorType::Multiband {
-            bit_depth: 8,
-            num_samples: 2,
-        },
-        64,
-    );
-}
-
-#[test]
-fn extra_bits_rgb() {
-    test_image_sum_u8("extra_bits_rgb_8b.tiff", ColorType::RGB(8), 0);
-}

tests/decode_planes.rs

@@ -1,76 +0,0 @@
-use tiff::decoder::{Decoder, TiffCodingUnit};
-
-use std::fs::File;
-use std::path::PathBuf;
-
-const TEST_IMAGE_DIR: &str = "./tests/images/";
-
-#[test]
-fn read_all_planes() {
-    let path = PathBuf::from(TEST_IMAGE_DIR).join("planar-rgb-u8.tif");
-    let file = File::open(path).unwrap();
-    let io = std::io::BufReader::new(file);
-
-    let mut tif = Decoder::new(io).unwrap();
-    let layout = tif.image_buffer_layout().unwrap();
-    assert_eq!(layout.planes, 3);
-    let plane_stride = layout.plane_stride.map_or(0, |x| x.get());
-
-    eprintln!("{:?}", layout);
-    let mut buffer = vec![0u8; layout.complete_len];
-    tif.read_image_bytes(&mut buffer).unwrap();
-
-    // Mainly you can see: these are different and non-zero. Otherwise these magic constants just
-    // depend on the file itself that is being used.
-    const PLANE_EXCPECTED_SUMS: [u32; 3] = [15417630, 13007788, 11103530];
-
-    for (plane, expected) in (0..layout.planes).zip(PLANE_EXCPECTED_SUMS) {
-        let plane_data = &buffer[plane_stride * plane..][..layout.len];
-        let sum: u32 = plane_data.iter().copied().map(u32::from).sum();
-        assert_eq!(sum, expected);
-    }
-}
-
-#[test]
-fn read_first_coding_unit() {
-    let path = PathBuf::from(TEST_IMAGE_DIR).join("planar-rgb-u8.tif");
-    let file = File::open(path).unwrap();
-    let io = std::io::BufReader::new(file);
-
-    let mut tif = Decoder::new(io).unwrap();
-    let layout = tif.image_coding_unit_layout(TiffCodingUnit(0)).unwrap();
-
-    assert_eq!(layout.planes, 3);
-    let plane_stride = layout.plane_stride.map_or(0, |x| x.get());
-    eprintln!("{:?}", layout);
-    let mut buffer = vec![0u8; layout.complete_len];
-
-    struct Expected {
-        plane_sums: [u32; 3],
-        unit: TiffCodingUnit,
-    }
-
-    // Mainly you can see: these are different and non-zero. Otherwise these magic constants just
-    // depend on the file itself that is being used. Also this varies by what unit we are reading.
-    const PLANE_EXCPECTED_SUMS: [Expected; 2] = [
-        Expected {
-            plane_sums: [856853, 767686, 688532],
-            unit: TiffCodingUnit(0),
-        },
-        Expected {
-            plane_sums: [883679, 797329, 711086],
-            unit: TiffCodingUnit(1),
-        },
-    ];
-
-    for expected in PLANE_EXCPECTED_SUMS {
-        tif.read_coding_unit_bytes(expected.unit, &mut buffer)
-            .unwrap();
-
-        for (plane, expected) in (0..layout.planes).zip(expected.plane_sums) {
-            let plane_data = &buffer[plane_stride * plane..][..layout.len];
-            let sum: u32 = plane_data.iter().copied().map(u32::from).sum();
-            assert_eq!(sum, expected);
-        }
-    }
-}

tests/encode_images.rs

@@ -57,7 +57,7 @@ fn encode_decode() {
                 ),
                 (Tag::Compression, ifd::Value::Short(1)),
                 (Tag::PhotometricInterpretation, ifd::Value::Short(2)),
-                (Tag::StripOffsets, ifd::Value::Unsigned(35)),
+                (Tag::StripOffsets, ifd::Value::Unsigned(47)),
                 (Tag::SamplesPerPixel, ifd::Value::Short(3)),
                 (Tag::RowsPerStrip, ifd::Value::Unsigned(3334)),
                 (Tag::StripByteCounts, ifd::Value::Unsigned(30000)),
@@ -81,10 +81,7 @@ fn encode_decode() {
             decoder.get_tag(Tag::Artist).unwrap(),
             ifd::Value::Ascii("Image-tiff".into())
         );
-
+        if let DecodingResult::U8(img_res) = decoder.read_image().unwrap() {
-        let mut buffer = tiff::decoder::DecodingResult::U8(vec![]);
-        let _layout = decoder.read_image_to_buffer(&mut buffer).unwrap();
-        if let tiff::decoder::DecodingResult::U8(img_res) = buffer {
             assert_eq!(image_data, img_res);
         } else {
             panic!("Wrong data type");
@@ -164,9 +161,7 @@ fn encode_decode_big() {
             decoder.get_tag(Tag::Artist).unwrap(),
             ifd::Value::Ascii("Image-tiff".into())
         );
-        let mut buffer = tiff::decoder::DecodingResult::U8(vec![]);
+        if let DecodingResult::U8(img_res) = decoder.read_image().unwrap() {
-        let _layout = decoder.read_image_to_buffer(&mut buffer).unwrap();
-        if let DecodingResult::U8(img_res) = buffer {
             assert_eq!(image_data, img_res);
         } else {
             panic!("Wrong data type");
@@ -240,7 +235,6 @@ const TEST_IMAGE_DIR: &str = "./tests/images/";
 
 macro_rules! test_roundtrip {
     ($name:ident, $buffer:ident, $buffer_ty:ty) => {
-        #[track_caller]
         fn $name<C: colortype::ColorType<Inner = $buffer_ty>>(
             file: &str,
             expected_type: ColorType,
@@ -250,10 +244,7 @@ macro_rules! test_roundtrip {
             let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
             assert_eq!(decoder.colortype().unwrap(), expected_type);
 
-            let mut buffer = tiff::decoder::DecodingResult::U8(vec![]);
+            let image_data = match decoder.read_image().unwrap() {
-            decoder.read_image_to_buffer(&mut buffer).unwrap();
-
-            let image_data = match buffer {
                 DecodingResult::$buffer(res) => res,
                 _ => panic!("Wrong data type"),
             };
@@ -267,11 +258,9 @@ macro_rules! test_roundtrip {
             }
             file.seek(SeekFrom::Start(0)).unwrap();
             {
-                let mut buffer = tiff::decoder::DecodingResult::U8(vec![]);
                 let mut decoder = Decoder::new(&mut file).unwrap();
-                decoder.read_image_to_buffer(&mut buffer).unwrap();
+                if let DecodingResult::$buffer(img_res) = decoder.read_image().unwrap() {
-                if let DecodingResult::$buffer(img_res) = buffer {
+                    assert_eq!(image_data, img_res);
-                    assert_eq!(*image_data, img_res);
                 } else {
                     panic!("Wrong data type");
                 }

tests/subsubifds.rs

@@ -1,4 +1,7 @@
-use tiff::decoder::Decoder;
+use tiff::{
+    decoder::Decoder,
+    tags::{IfdPointer, Tag},
+};
 
 // This file has the following IFD structure:
 //
@@ -39,3 +42,128 @@ fn decode_seek_chain() {
     assert_eq!(Some(offset2), decoder.ifd_pointer());
     assert!(!decoder.more_images());
 }
+
+#[test]
+fn decode_seek_recover() {
+    let file = File::open(TEST_IMAGE_SUBIFD).expect("Cannot open test image");
+    let mut decoder = Decoder::new(file).expect("Invalid format to create decoder");
+
+    // Remember the offsets in the first iteration.
+    let offset0 = decoder.ifd_pointer().expect("First IFD pointer not found");
+    decoder.next_image().unwrap();
+    let offset1 = decoder.ifd_pointer().expect("Second IFD pointer not found");
+    decoder.next_image().unwrap();
+    let offset2 = decoder.ifd_pointer().expect("Third IFD pointer not found");
+
+    // oops!
+    let fails = decoder.restart_at_image(IfdPointer(0xdead_beef));
+    assert!(fails.is_err());
+
+    // However we can recover by restarting our seek.
+    decoder
+        .restart_at_image(offset0)
+        .expect("Failed to restart IFDs from first image");
+    assert_eq!(Some(offset0), decoder.ifd_pointer());
+    decoder.next_image().unwrap();
+    assert_eq!(Some(offset1), decoder.ifd_pointer());
+    decoder.next_image().unwrap();
+    assert_eq!(Some(offset2), decoder.ifd_pointer());
+}
+
+#[test]
+fn decode_seek_directory() {
+    let file = File::open(TEST_IMAGE_SUBIFD).expect("Cannot open test image");
+    let mut decoder = Decoder::new(file).expect("Invalid format to create decoder");
+
+    let offset = decoder.ifd_pointer().expect("First IFD pointer not found");
+    let img0 = decoder.read_image().unwrap();
+
+    decoder.next_image().unwrap();
+    let img1 = decoder.read_image().unwrap();
+    assert_ne!(img0, img1);
+
+    {
+        // Due to the special test file structure.
+        let subifd = decoder
+            .get_tag(Tag::SubIfd)
+            .unwrap()
+            .into_ifd_vec()
+            .unwrap()[0];
+
+        // Let's try to manually interpret this as an image.
+        decoder
+            .restart_at_directory(subifd)
+            .expect("Failed to restart IFDs at SubIfd");
+        decoder
+            .current_directory_as_image()
+            .expect("Failed to read SubIfd image");
+
+        assert_eq!(decoder.dimensions().unwrap(), (32, 32));
+        let subimage = decoder.read_image().unwrap();
+        // Verify we did not accidentally read another image.
+        assert_ne!(img0, subimage);
+        assert_ne!(img1, subimage);
+    }
+
+    // And finally, seek back to the first image.
+    decoder
+        .restart_at_image(offset)
+        .expect("First IFD no longer readable");
+    assert_eq!(Some(offset), decoder.ifd_pointer());
+
+    let img0_try2 = decoder.read_image().unwrap();
+    assert_eq!(img0, img0_try2);
+}
+
+#[test]
+fn decode_subifds() {
+    let explore_chain = |decoder: &mut Decoder<_>, subifds: &mut Vec<_>| {
+        let mut len = 0usize;
+
+        loop {
+            len += 1;
+
+            if let Ok(subifd) = decoder.get_tag(Tag::SubIfd) {
+                let prelen = subifds.len();
+                subifds.extend(subifd.into_ifd_vec().expect("Failed to decode SubIfd tag"));
+                eprintln!("New roots: {:?}", &subifds[prelen..]);
+            } else {
+                eprintln!("No roots");
+            }
+
+            if !decoder.more_images() {
+                break;
+            }
+
+            decoder.next_image().unwrap();
+        }
+
+        len
+    };
+
+    let file = File::open(TEST_IMAGE_SUBIFD).expect("Cannot open test image");
+    let mut decoder = Decoder::new(file).expect("Invalid format to create decoder");
+
+    let mut subifds = vec![];
+    let mut chain_lengths = vec![];
+    chain_lengths.push(explore_chain(&mut decoder, &mut subifds));
+
+    while !subifds.is_empty() {
+        let root = subifds.remove(0);
+        let manual_directory = decoder.read_directory(root).unwrap();
+        eprintln!("Manual directory: {:?}", manual_directory);
+
+        decoder.restart_at_directory(root).unwrap();
+        let prelen = subifds.len();
+        chain_lengths.push(explore_chain(&mut decoder, &mut subifds));
+        eprintln!("Chains roots: {:?}", &subifds[prelen..]);
+    }
+
+    // Traversal Order in this graph:
+    // Image 0 -> Image 1 -> Image 2
+    //            |-> Image 3
+    //            |-> Image 4 -> Image 5
+    //            |              \-> Image 7 -> Image 8
+    //            \-> Image 6
+    assert_eq!(chain_lengths, [3, 1, 2, 1, 2]);
+}