Add integration test for exif copy

This allows it to address the case of copying all EXIF data into a
separate file. And as soon as our decoder can handle files without any
image data (missing any stripoffsets, etc.) in ways that do not return
errors we can hopefully do the opposite and merge the data again.

.github/workflows/rust.yml

@@ -1,40 +1,94 @@
 name: Rust CI
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: ["1.48", stable, beta, nightly]
-        command: [build, test]
+        rust: ["1.85.0", stable, beta, nightly]
     steps:
     - uses: actions/checkout@v2
-    - run: rustup default ${{ matrix.rust }}
+
+    - uses: dtolnay/rust-toolchain@nightly
+      if: ${{ matrix.rust == '1.85.0' }}
+    - name: Generate Cargo.lock with minimal-version dependencies
+      if: ${{ matrix.rust == '1.85.0' }}
+      run: cargo -Zminimal-versions generate-lockfile
+
+    - uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: ${{ matrix.rust }}
+    - name: Cache Cargo Dependencies
+      uses: Swatinem/rust-cache@v2
+      with:
+        cache-on-failure: true
     - name: build
-      run: >
-        cargo build --verbose --no-default-features --features "$FEATURES"
+      run: cargo build -v
     - name: test
-      run: >
-        cargo test --tests --benches --no-default-features --features "$FEATURES"
-      if: ${{ matrix.rust != '1.48' }}
-      env:
-        FEATURES: ${{ matrix.features }}
+      if: ${{ matrix.rust != '1.85.0' }}
+      run: cargo test -v && cargo doc -v
+
+  features:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        feature: ["", deflate, jpeg, lzw, zstd, default, "default,zstd"]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: clippy
+    - name: Cargo check
+      run: cargo check --features "${{ matrix.feature }}" --no-default-features
+
+    - name: Cargo clippy
+      if: ${{ matrix.feature != '' }}
+      run: cargo clippy --no-deps --all-features --all-targets -- -D warnings
+
+  other_archs:
+    # github actions does not support 32-bit or big endian systems directly, but
+    # it does support QEMU. so we install qemu, then build and run the tests on
+    # emulated systems. NOTE: you can also use this approach to test locally.
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [powerpc-unknown-linux-gnu, i686-unknown-linux-gnu]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install or use cached cross-rs/cross
+        uses: baptiste0928/cargo-install@v2
+        with:
+          crate: cross
+      - name: Cache Cargo Dependencies
+        uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+          key: ${{ matrix.arch }}
+      - name: Start Docker (required for cross-rs)
+        run: sudo systemctl start docker
+      - name: Cross-Run Tests using QEMU
+        run: cross test --target ${{ matrix.arch }}
+
   rustfmt:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
+    - uses: dtolnay/rust-toolchain@stable
       with:
-        toolchain: stable
-        override: true
         components: rustfmt
     - name: Run rustfmt check
-      uses: actions-rs/cargo@v1
-      with:
-        command: fmt
-        args: -- --check
+      run: cargo fmt -- --check
 
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: clippy
+    - run: cargo clippy --all-features # TODO: enable "-- -D warnings" once all outstanding clippy lints are fixed

CHANGES.md

@@ -1,3 +1,231 @@
+# Version 0.11.1
+
+Fixes:
+- The enumeration types in `tags` are now all marked with a representation of
+  their underlying TIFF type (e.g. `repr(u16)`) and variants are explicitly
+  assigned their corresponding values. That is you may _read_ the raw
+  discriminant and interpret that as the value—except for `Unknown` variants.
+- The variants `RationalBig` and `SRationalBig` of `decoder::ifd::Value` are
+  deprecated as they have no corresponding TIFF type and were not constructed
+  during decoding.
+
+Additions:
+- Types in `tags` now generally implement `TiffValue` and can be handed to the
+  `DirectoryEncoder::write_tag` method. Unlike primitive types they do _not_
+  always implement the trait for slices of themselves.
+- Added `tags::ValueBuffer`, a byte-based buffer for tags with a runtime value
+  type and count.
+- Added `IfdDecoder::find_tag_{buf,bytes}` to read tag values into a
+  `ValueBuffer` or byte slice respectively without interpreting them
+  immediately within the Rust type system.
+- Added `DirectoryEncoder::write_{data,tag}_buf` that takes a `ValueBuffer`
+  instead of a statically typed argument.
+- Added `DirectoryEncoder::write_entry{,_buf,_bytes}` that encode their
+  argument into the file and return an `Entry` for later use, without
+  immediately adding a tag-entry pair to the directory.
+- The `TiffValue` trait is now implemented for several builtin `tags::*` types
+  or slices of them as appropriate for their use as values of their intended
+  TIFF tag.
+- The `TiffValue` trait is now implemented for `[T; N]` for all types that
+  implement it for slices.
+
+# Version 0.11.0
+
+- `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).
+- The decoder handles planar data, current limited to non-subsampled channels.
+  The `Decoder::read_image` method return planes one-after-another depending on
+  the size of the buffer that was passed.
+- `Decoder::read_image_to_buffer` now takes `&mut DecodingResult` and resizes
+  it according to the required layout. Previously, a borrowed `DecodingBuffer`
+  was passed which can be replaced by calling `as_bytes_mut` and
+  `read_image_bytes`.
+- Several methods of tags are now `const`. Note that does not guarantee any
+  particular value when calling these methods.
+
+Fixes:
+- Fix a bug in the uncompressed encoder that could lead to short writes, i.e.
+  data silently dropped when the underlying writer did not accept all data in a
+  single write call.
+- Encoding YCbCr data now writes the `ChromaSubsampling` tag as `(1, 1)` to
+  indicate no subsampling, instead of leaving it at its default of `(2, 2)`.
+- The decoder will reject subsampled YCbCr data as there is no upsampling
+  routine, except for JPEG compressed images where the JPEG decoders handles
+  this. Since the buffer in that case indicates a full-sized plane for all
+  color samples any future support for the tag will upsample all planes (at
+  least within this major version).
+
+Additions:
+- Added support for the `CieLab` color type.
+- Added `DecodingResult::resize_to` to create a buffer with a matching sample
+  type and dimensions.
+- Added `ByteOrder::native` to access the platform's native endianness.
+- Added `ByteOrder::convert` to change the byte-order of values in a byte
+  buffer, depending on their `Type` as described at runtime.
+- Added `DirectoryOffset::new` to encode a directory whose offset is known to
+  the caller but that has not been written through the encoder itself.
+- Added `Encoder::extra_samples` to encode images with more samples than their
+  color's trait implementation would otherwise suggest.
+- Added `DirectoryEncoder::extend_from` to encode multiple tag entries from a
+  directory whose values were written to the file by means outside the
+  encoder's control.
+- Added `Decoder::read_coding_unit_bytes` to retrieve data of corresponding
+  coordinates from potentially planar data, which is encoded in multiple chunks
+  of the file.
+
+# 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:
+- Added `ColorType::Multiband` and `ColorType::CMYKA`.
+- Added `Value::Byte` and `Value::SignedByte` to represent `u8` and `i8` tags.
+- Encoding can now use horizontal predictor.
+- The `Decoder::tag_iter` method allows iterating over all tags in the image.
+- Half precision floating point values are now supported during decoding.
+- ZStandard compression has been added as an additional compression method
+  during decoding, but requires the `zstd` feature flag.
+
+Changes:
+- Switched `u16` and `i16` values to be intepreted as `Value::Short` and
+  `Value::SignedShort` respectively.
+- Changed JPEG compression to use the `zune-jpeg` crate instead of
+  `jpeg-decoder`.
+- The `deflate`, `jpeg`, and `lzw` compression methods are now controlled by
+  (enabled by default) feature flags.
+
+Fixes:
+- Fixed a bug in 1 bit-per-pixel decoding.
+
+# Version 0.9.1
+
+New features:
+- Basic support for planar configuration.
+- Allow arbitrary number of samples as long as all have the same bit depth.
+
+Fixes:
+- Don't panic when parsing metadata when custom compression is used.
+
+# Version 0.9.0
+
+New features:
+* Added support for photometric interpretation `YCbCr` and added related
+  `ColorType`.
+
+Fixes:
+* Decoding tiled images calculates padding correctly when image width or height
+  is a multiple of tile size. It could previously corrupt the last tile per row
+  by skipping over data.
+
+# Version 0.8.1
+
+Changes:
+* The jpeg decoder gained to ability to utilize the Photometric Interpretation
+  directly instead of relying on a custom APP segment.
+
+Fixes:
+* A spurious error within the PackBits decoder lead to the incorrect results
+  (wrong bits or errors), based on the maximum size of reads from the
+  underlying reader.
+* Removed a panic path in jpeg decoding, when a feature such as photometric
+  interpretation is not supported. An error is returned instead.
+
+# Version 0.8.0
+
+Changes:
+* The minimum supported rust version is now indicated in `Cargo.toml`.
+* The enums `TiffFormatError` and `TiffUnsupportedError` are now
+  marked with the `#[non_exhaustive]` attribute. 
+* Additionally, tag related enums `Value`, `Tags`, `Type`, `CompressionMethod`,
+  `PhotometricInterpretation`, `PlanarConfiguration`, `Predictor`,
+  `ResolutionUnit`, `SampleFormat` are also changed.
+
+Removals:
+* Removed deprecated methods of `Decoder`: `init`, `read_jpeg`,
+  `read_strip_to_buffer`, `read_strip`, `read_tile`. The implicit chunk (row or
+  tile) index order could not be easily tracked by the caller. New separate
+  utility interfaces may be introduced at a later point, for now callers are
+  obligated to choose their own.
+
+Fixes:
+* Update to `jpeg_decoder = 0.3`.
+
+# Version 0.7.4
+
+New features:
+* Creating an encoder for invalid, zero-sized images is now rejected.
+
+Fixes:
+* Fix panic, in a case where decoding jpeg encoded images did not expect the
+  jpeg decoder to return an error.
+* Fix panic by validating `rows_per_strip` better, fixing a division-by-zero.
+
+# Version 0.7.3
+
+New features:
+* Allow decoder to access specific tiles by index.
+* Add support for floating point predictor.
+* Tiled jpeg file support.
+
+Changes:
+* Various refactoring and performance improvements.
+
+# Version 0.7.2
+
+New features:
+* Encoding with `ImageEncoder` now takes an optional compressor argument,
+  allowing compressed encoding. See the methods 
+  `TiffEncoder::{new_image,write_image}_with_compression`.
+* `jpeg_decoder` has been upgraded, now supports lossless JPEG.
+
+Changes:
+* Decoding now more consistently reads and interprets the initial IFD, instead
+  of performing _some_ interpretation lazily. (This change prepares fully lazy
+  and backwards seeking.)
+
 # Version 0.7.1
 
 New features:

Cargo.toml

@@ -1,29 +1,46 @@
 [package]
 name = "tiff"
-version = "0.7.1"
-authors = [
-    "ccgn",
-    "bvssvni <bvssvni@gmail.com>",
-    "nwin",
-    "TyOverby <ty@pre-alpha.com>",
-    "HeroicKatora",
-    "Calum",
-    "CensoredUsername <cens.username@gmail.com>",
-    "Robzz",
-    "birktj"]
+version = "0.11.1"
+edition = "2021"
+resolver = "2"
+
+# note: when changed, also update test runner in `.github/workflows/rust.yml`
+rust-version = "1.85.0"
+
 license = "MIT"
 description = "TIFF decoding and encoding library in pure Rust"
+authors = ["The image-rs Developers"]
+
 repository = "https://github.com/image-rs/image-tiff"
-exclude = ["tests/images/*", "tests/fuzz_images/*"]
-edition = "2018"
+categories = ["multimedia::images", "multimedia::encoding"]
+
+exclude = ["tests/images/*", "tests/fuzz_images/*", "tests/**/*.tif"]
 
 [dependencies]
-weezl = "0.1.0"
-jpeg = { package = "jpeg-decoder", version = "0.1.17", default-features = false }
-flate2 = "1.0.20"
+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 }
 
 [dev-dependencies]
 criterion = "0.3.1"
+# We may already depend on this via flate2
+crc32fast = "1.5"
+
+[features]
+default = ["deflate", "fax", "jpeg", "lzw"]
+
+# Compression algorithms
+deflate = ["dep:flate2"]
+fax = ["dep:fax34"]
+jpeg = ["dep:zune-jpeg"]
+lzw = ["dep:weezl"]
+zstd = ["dep:zstd"]
 
 [[bench]]
 name = "lzw"

README.md

@@ -1,5 +1,5 @@
 # image-tiff
-[![Build Status](https://github.com/image-rs/image-tiff/workflows/Rust%20CI/badge.svg)](https://github.com/image-rs/image-tiff/actions)
+[![Build Status](https://github.com/image-rs/image-tiff/actions/workflows/rust.yml/badge.svg?branch=main)](https://github.com/image-rs/image-tiff/actions)
 [![Documentation](https://docs.rs/tiff/badge.svg)](https://docs.rs/tiff)
 [![Further crate info](https://img.shields.io/crates/v/tiff.svg)](https://crates.io/crates/tiff)
 
@@ -16,25 +16,29 @@ TIFF decoding and encoding library in pure Rust
 ### Formats
 This table lists photometric interpretations and sample formats which are supported for encoding and decoding. The entries are `ColorType` variants for which sample bit depths are supported. Only samples where all bit depths are equal are currently supported. For example, `RGB(8)` means that the bit depth [8, 8, 8] is supported and will be interpreted as an 8 bit per channel RGB color type.
 
-| `PhotometricInterpretation` | UINT Format | IEEEFP Format |
-|-|-|-|
-| `WhiteIsZero` | Gray(8\|16\|32\|64) | Gray(32\|64) |
-| `BlackIsZero` | Gray(8\|16\|32\|64) | Gray(32\|64) |
-| `RGB` | RGB(8\|16\|32\|64), RGBA(8\|16\|32\|64) | RGB(32\|64), RGBA(32\|64) |
-| `RGBPalette` | | |
-| `Mask` | | |
-| `CMYK` | CMYK(8\|16\|32\|64) | CMYK(32\|64) |
-| `YCbCr` | | |
-| `CIELab` | | |
+| `PhotometricInterpretation` | UINT Format                             | IEEEFP Format             |
+| --------------------------- | --------------------------------------- | ------------------------- |
+| `WhiteIsZero`               | Gray(8\|16\|32\|64)                     | Gray(32\|64)              |
+| `BlackIsZero`               | Gray(8\|16\|32\|64)                     | Gray(32\|64)              |
+| `RGB`                       | RGB(8\|16\|32\|64), RGBA(8\|16\|32\|64) | RGB(32\|64), RGBA(32\|64) |
+| `RGBPalette`                |                                         |                           |
+| `Mask`                      |                                         |                           |
+| `CMYK`                      | CMYK(8\|16\|32\|64)                     | CMYK(32\|64)              |
+| `CMYKA`                     | CMYKA(8)                                |                           |
+| `YCbCr`                     |                                         |                           |
+| `CIELab`                    |                                         |                           |
 
 ### Compressions
 
-| | Decoding | Encoding |
-|-|-|-|
-| None | ✓ | ✓ |
-| LZW | ✓ | |
-| Deflate | ✓ | |
-| PackBits | ✓ | |
+|          | Decoding | Encoding |
+| -------- | -------- | -------- |
+| None     | ✓        | ✓        |
+| LZW      | ✓        | ✓        |
+| Deflate  | ✓        | ✓        |
+| PackBits | ✓        | ✓        |
+| Fax4     | ✓        | not yet  |
+| JPEG     | ✓        | not yet  |
+| ZSTD     | ✓        | not yet  |
 
 
 ## Not yet supported

benches/lzw.rs

@@ -33,7 +33,7 @@ fn main() {
                 def.data,
                 |b, input| b.iter(|| read_image(input)),
             );
-    };
+    }
 
     let mut c = Criterion::default().configure_from_args();
     let mut group = c.benchmark_group("tiff-lzw");

examples/decode.rs

@@ -0,0 +1,103 @@
+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/bytecast.rs

@@ -10,8 +10,13 @@
 //! the unsafe code guidelines).
 //!
 //! TODO: Would like to use std-lib here.
+// Until we implement predictors for f16, we don't need f16_as_ne_bytes. (Due to the macro we do
+// not apply this directly to the functions). And rust-version is not new enough for `expect`.
+#![allow(dead_code)]
 use std::{mem, slice};
 
+use half::f16;
+
 macro_rules! integral_slice_as_bytes{($int:ty, $const:ident $(,$mut:ident)*) => {
     pub(crate) fn $const(slice: &[$int]) -> &[u8] {
         assert!(mem::align_of::<$int>() <= mem::size_of::<$int>());
@@ -31,4 +36,5 @@ integral_slice_as_bytes!(i32, i32_as_ne_bytes, i32_as_ne_mut_bytes);
 integral_slice_as_bytes!(u64, u64_as_ne_bytes, u64_as_ne_mut_bytes);
 integral_slice_as_bytes!(i64, i64_as_ne_bytes, i64_as_ne_mut_bytes);
 integral_slice_as_bytes!(f32, f32_as_ne_bytes, f32_as_ne_mut_bytes);
+integral_slice_as_bytes!(f16, f16_as_ne_bytes, f16_as_ne_mut_bytes);
 integral_slice_as_bytes!(f64, f64_as_ne_bytes, f64_as_ne_mut_bytes);

src/decoder/cycles.rs

@@ -0,0 +1,169 @@
+use crate::{tags::IfdPointer, TiffError, TiffFormatError};
+use std::collections::HashMap;
+
+/// The IFD structure of a TIFF file should be limited to a forest of entries, and a tree when we
+/// only consider having a primary IFD and its children. There is up to one primary child of a node
+/// that is the `next` entry in an IFD itself. Since we offer iteration over this chain we want to
+/// detect when a new edge would introduce a cycle, such that callers can be guaranteed to
+/// terminate iteration at some point even in malicious images.
+///
+/// However, we are not necessarily visiting the IFDs in their topological order.
+///
+/// Since we only consider one child, we run union find to assign each pointer to a known chain.
+/// Then, when we insert a new edge we check if they belong to the same component.
+#[derive(Default, Debug)]
+pub struct IfdCycles {
+    /// The root of each component union.
+    component_union: HashMap<ComponentId, ComponentId>,
+    links: HashMap<IfdPointer, u64>,
+    chains: HashMap<IfdPointer, ComponentId>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+struct ComponentId(u64);
+
+impl IfdCycles {
+    pub fn new() -> Self {
+        IfdCycles::default()
+    }
+
+    pub fn insert_next(
+        &mut self,
+        from: IfdPointer,
+        to: Option<IfdPointer>,
+    ) -> Result<bool, TiffError> {
+        let to_offset = to.map_or(0, |p| p.0);
+
+        // For some reason we got
+        match self.links.get(&from) {
+            Some(existing) if *existing == to_offset => return Ok(false),
+            // We got here twice with two different reads of the same IFD. That is .. unusual and
+            // we interpret it as a cycle.
+            Some(_) => return Err(TiffError::FormatError(TiffFormatError::CycleInOffsets)),
+            None => self.links.insert(from, to_offset),
+        };
+
+        self.ensure_node(from);
+
+        if let Some(to) = to {
+            self.ensure_node(to);
+
+            let parent = self.nominal_component(from);
+            let child = self.nominal_component(to);
+
+            if parent == child {
+                return Err(TiffError::FormatError(TiffFormatError::CycleInOffsets));
+            }
+
+            self.component_union.insert(child, parent);
+        }
+
+        Ok(true)
+    }
+
+    fn ensure_node(&mut self, ifd: IfdPointer) {
+        self.chains.entry(ifd).or_insert_with(|| {
+            let id = ComponentId(self.component_union.len() as u64);
+            self.component_union.insert(id, id);
+            id
+        });
+    }
+
+    fn nominal_component(&mut self, node: IfdPointer) -> ComponentId {
+        let id = self.chains[&node];
+
+        let nomimal = {
+            let mut iter = id;
+
+            loop {
+                let parent = self.component_union[&iter];
+
+                if parent == iter {
+                    break parent;
+                }
+
+                iter = parent;
+            }
+        };
+
+        if nomimal != id {
+            // Compress.
+            let mut iter = id;
+
+            loop {
+                let parent = self.component_union[&iter];
+
+                if parent == iter {
+                    break;
+                }
+
+                self.component_union.insert(iter, nomimal);
+                iter = parent;
+            }
+        }
+
+        nomimal
+    }
+}
+
+#[test]
+fn cycles_are_detected() {
+    let mut cycles = IfdCycles::new();
+
+    cycles
+        .insert_next(IfdPointer(0x20), Some(IfdPointer(0x800)))
+        .expect("non-existing link is valid");
+
+    cycles
+        .insert_next(IfdPointer(0x800), Some(IfdPointer(0x20)))
+        .expect_err("cycle must be detected");
+}
+
+#[test]
+fn reflective_cycle() {
+    let mut cycles = IfdCycles::new();
+
+    cycles
+        .insert_next(IfdPointer(0x20), Some(IfdPointer(0x20)))
+        .expect_err("self-referential cycle must be detected");
+}
+
+#[test]
+fn late_cycle() {
+    let mut cycles = IfdCycles::new();
+
+    cycles
+        .insert_next(IfdPointer(0x20), Some(IfdPointer(0x40)))
+        .expect("non-existing link is valid");
+
+    cycles
+        .insert_next(IfdPointer(0x60), Some(IfdPointer(0x80)))
+        .expect("non-existing link is valid");
+    cycles
+        .insert_next(IfdPointer(0x80), Some(IfdPointer(0x20)))
+        .expect("non-existing link is valid");
+
+    cycles
+        .insert_next(IfdPointer(0x40), Some(IfdPointer(0x60)))
+        .expect_err("non-existing link is valid");
+}
+
+#[test]
+fn odd_cycle() {
+    let mut cycles = IfdCycles::new();
+
+    cycles
+        .insert_next(IfdPointer(0x20), Some(IfdPointer(0x40)))
+        .expect("non-existing link is valid");
+
+    cycles
+        .insert_next(IfdPointer(0x60), Some(IfdPointer(0x80)))
+        .expect("non-existing link is valid");
+    cycles
+        .insert_next(IfdPointer(0x80), Some(IfdPointer(0x20)))
+        .expect("non-existing link is valid");
+
+    cycles
+        .insert_next(IfdPointer(0x40), Some(IfdPointer(0x80)))
+        .expect_err("non-existing link is valid");
+}

src/decoder/stream.rs

@@ -1,49 +1,49 @@
 //! All IO functionality needed for TIFF decoding
+use std::io::{self, BufRead, BufReader, Read, Seek, Take};
 
-use std::io::{self, Read, Seek};
-
-/// Byte order of the TIFF file.
-#[derive(Clone, Copy, Debug)]
-pub enum ByteOrder {
-    /// little endian byte order
-    LittleEndian,
-    /// big endian byte order
-    BigEndian,
-}
+pub use crate::tags::ByteOrder;
 
 /// Reader that is aware of the byte order.
-pub trait EndianReader: Read {
-    /// Byte order that should be adhered to
-    fn byte_order(&self) -> ByteOrder;
+#[derive(Debug)]
+pub struct EndianReader<R> {
+    reader: R,
+    pub(crate) byte_order: ByteOrder,
+}
+
+impl<R: Read> EndianReader<R> {
+    pub fn new(reader: R, byte_order: ByteOrder) -> Self {
+        Self { reader, byte_order }
+    }
+
+    pub fn inner(&mut self) -> &mut R {
+        &mut self.reader
+    }
+
+    pub fn goto_offset(&mut self, offset: u64) -> io::Result<()>
+    where
+        R: Seek,
+    {
+        self.reader.seek(io::SeekFrom::Start(offset))?;
+        Ok(())
+    }
 
     /// Reads an u16
     #[inline(always)]
-    fn read_u16(&mut self) -> Result<u16, io::Error> {
+    pub fn read_u16(&mut self) -> Result<u16, io::Error> {
         let mut n = [0u8; 2];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(match self.byte_order {
             ByteOrder::LittleEndian => u16::from_le_bytes(n),
             ByteOrder::BigEndian => u16::from_be_bytes(n),
         })
     }
 
-    /// Reads an i8
-    #[inline(always)]
-    fn read_i8(&mut self) -> Result<i8, io::Error> {
-        let mut n = [0u8; 1];
-        self.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)]
-    fn read_i16(&mut self) -> Result<i16, io::Error> {
+    pub fn read_i16(&mut self) -> Result<i16, io::Error> {
         let mut n = [0u8; 2];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(match self.byte_order {
             ByteOrder::LittleEndian => i16::from_le_bytes(n),
             ByteOrder::BigEndian => i16::from_be_bytes(n),
         })
@@ -51,10 +51,10 @@ pub trait EndianReader: Read {
 
     /// Reads an u32
     #[inline(always)]
-    fn read_u32(&mut self) -> Result<u32, io::Error> {
+    pub fn read_u32(&mut self) -> Result<u32, io::Error> {
         let mut n = [0u8; 4];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(match self.byte_order {
             ByteOrder::LittleEndian => u32::from_le_bytes(n),
             ByteOrder::BigEndian => u32::from_be_bytes(n),
         })
@@ -62,10 +62,10 @@ pub trait EndianReader: Read {
 
     /// Reads an i32
     #[inline(always)]
-    fn read_i32(&mut self) -> Result<i32, io::Error> {
+    pub fn read_i32(&mut self) -> Result<i32, io::Error> {
         let mut n = [0u8; 4];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(match self.byte_order {
             ByteOrder::LittleEndian => i32::from_le_bytes(n),
             ByteOrder::BigEndian => i32::from_be_bytes(n),
         })
@@ -73,10 +73,10 @@ pub trait EndianReader: Read {
 
     /// Reads an u64
     #[inline(always)]
-    fn read_u64(&mut self) -> Result<u64, io::Error> {
+    pub fn read_u64(&mut self) -> Result<u64, io::Error> {
         let mut n = [0u8; 8];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(match self.byte_order {
             ByteOrder::LittleEndian => u64::from_le_bytes(n),
             ByteOrder::BigEndian => u64::from_be_bytes(n),
         })
@@ -84,10 +84,10 @@ pub trait EndianReader: Read {
 
     /// Reads an i64
     #[inline(always)]
-    fn read_i64(&mut self) -> Result<i64, io::Error> {
+    pub fn read_i64(&mut self) -> Result<i64, io::Error> {
         let mut n = [0u8; 8];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(match self.byte_order {
             ByteOrder::LittleEndian => i64::from_le_bytes(n),
             ByteOrder::BigEndian => i64::from_be_bytes(n),
         })
@@ -95,10 +95,10 @@ pub trait EndianReader: Read {
 
     /// Reads an f32
     #[inline(always)]
-    fn read_f32(&mut self) -> Result<f32, io::Error> {
+    pub fn read_f32(&mut self) -> Result<f32, io::Error> {
         let mut n = [0u8; 4];
-        self.read_exact(&mut n)?;
-        Ok(f32::from_bits(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(f32::from_bits(match self.byte_order {
             ByteOrder::LittleEndian => u32::from_le_bytes(n),
             ByteOrder::BigEndian => u32::from_be_bytes(n),
         }))
@@ -106,262 +106,251 @@ pub trait EndianReader: Read {
 
     /// Reads an f64
     #[inline(always)]
-    fn read_f64(&mut self) -> Result<f64, io::Error> {
+    pub fn read_f64(&mut self) -> Result<f64, io::Error> {
         let mut n = [0u8; 8];
-        self.read_exact(&mut n)?;
-        Ok(f64::from_bits(match self.byte_order() {
+        self.reader.read_exact(&mut n)?;
+        Ok(f64::from_bits(match self.byte_order {
             ByteOrder::LittleEndian => u64::from_le_bytes(n),
             ByteOrder::BigEndian => u64::from_be_bytes(n),
         }))
     }
 }
 
-///
-/// # READERS
-///
+//
+// # READERS
+//
 
-///
-/// ## Deflate Reader
-///
+/// Type alias for the deflate Reader
+#[cfg(feature = "deflate")]
+pub type DeflateReader<R> = flate2::read::ZlibDecoder<R>;
 
-pub type DeflateReader<'r, R> = flate2::read::ZlibDecoder<&'r mut SmartReader<R>>;
-
-///
-/// ## LZW Reader
-///
+//
+// ## LZW Reader
+//
 
 /// Reader that decompresses LZW streams
-pub struct LZWReader {
-    buffer: io::Cursor<Vec<u8>>,
+#[cfg(feature = "lzw")]
+pub struct LZWReader<R: Read> {
+    reader: BufReader<Take<R>>,
+    decoder: weezl::decode::Decoder,
 }
 
-impl LZWReader {
+#[cfg(feature = "lzw")]
+impl<R: Read> LZWReader<R> {
     /// Wraps a reader
-    pub fn new<R>(
-        reader: &mut SmartReader<R>,
-        compressed_length: usize,
-        max_uncompressed_length: usize,
-    ) -> io::Result<(usize, LZWReader)>
-    where
-        R: Read + Seek,
-    {
-        let mut compressed = vec![0; compressed_length as usize];
-        reader.read_exact(&mut compressed[..])?;
-        let mut uncompressed = vec![0; max_uncompressed_length];
-        let mut decoder = weezl::decode::Decoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8);
+    pub fn new(reader: R, compressed_length: usize) -> LZWReader<R> {
+        let configuration =
+            weezl::decode::Configuration::with_tiff_size_switch(weezl::BitOrder::Msb, 8)
+                .with_yield_on_full_buffer(true);
+        Self {
+            reader: BufReader::with_capacity(
+                (32 * 1024).min(compressed_length),
+                reader.take(u64::try_from(compressed_length).unwrap()),
+            ),
+            decoder: configuration.build(),
+        }
+    }
+}
 
-        let mut bytes_read = 0;
-        let mut bytes_written = 0;
-
-        while bytes_written < max_uncompressed_length {
-            let result = decoder.decode_bytes(
-                &compressed[bytes_read..],
-                &mut uncompressed[bytes_written..],
-            );
-            bytes_read += result.consumed_in;
-            bytes_written += result.consumed_out;
+#[cfg(feature = "lzw")]
+impl<R: Read> Read for LZWReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        loop {
+            let result = self.decoder.decode_bytes(self.reader.fill_buf()?, buf);
+            self.reader.consume(result.consumed_in);
 
             match result.status {
-                Ok(weezl::LzwStatus::Ok) => {}
-                Ok(weezl::LzwStatus::Done) => break,
+                Ok(weezl::LzwStatus::Ok) => {
+                    if result.consumed_out == 0 {
+                        continue;
+                    } else {
+                        return Ok(result.consumed_out);
+                    }
+                }
                 Ok(weezl::LzwStatus::NoProgress) => {
                     return Err(io::Error::new(
                         io::ErrorKind::UnexpectedEof,
                         "no lzw end code found",
-                    ))
+                    ));
+                }
+                Ok(weezl::LzwStatus::Done) => {
+                    return Ok(result.consumed_out);
                 }
                 Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidData, err)),
             }
         }
-
-        uncompressed.resize(bytes_written, 0);
-        Ok((
-            uncompressed.len(),
-            LZWReader {
-                buffer: io::Cursor::new(uncompressed),
-            },
-        ))
     }
 }
 
-impl Read for LZWReader {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.buffer.read(buf)
-    }
+//
+// ## PackBits Reader
+//
+
+/// Internal state machine for the PackBitsReader.
+enum PackBitsReaderState {
+    Header,
+    Literal,
+    Repeat { value: u8 },
 }
 
-///
-/// ## JPEG Reader (for "new-style" JPEG format (TIFF compression tag 7))
-///
-
-pub(crate) struct JpegReader {
-    buffer: io::Cursor<Vec<u8>>,
+/// Reader that unpacks Apple's `PackBits` format
+pub struct PackBitsReader<R: Read> {
+    reader: Take<R>,
+    state: PackBitsReaderState,
+    count: usize,
 }
-impl JpegReader {
-    /// Constructs new JpegReader wrapping a SmartReader.
-    /// Because JPEG compression in TIFF allows to save quantization and/or huffman tables in one
-    /// central location, the constructor accepts this data as `jpeg_tables` here containing either
-    /// or both.
-    /// These `jpeg_tables` are simply prepended to the remaining jpeg image data.
-    /// Because these `jpeg_tables` start with a `SOI` (HEX: `0xFFD8`) or __start of image__ marker
-    /// which is also at the beginning of the remaining JPEG image data and would
-    /// confuse the JPEG renderer, one of these has to be taken off. In this case the first two
-    /// bytes of the remaining JPEG data is removed because it follows `jpeg_tables`.
-    /// Similary, `jpeg_tables` ends with a `EOI` (HEX: `0xFFD9`) or __end of image__ marker,
-    /// this has to be removed as well (last two bytes of `jpeg_tables`).
 
-    pub fn new<R>(
-        reader: &mut SmartReader<R>,
-        length: u32,
-        jpeg_tables: &Option<Vec<u8>>,
-    ) -> io::Result<JpegReader>
-    where
-        R: Read + Seek,
-    {
-        // Read jpeg image data
-        let mut segment = vec![0; length as usize];
-        reader.read_exact(&mut segment[..])?;
-
-        match jpeg_tables {
-            Some(tables) => {
-                assert!(
-                    tables.len() >= 2,
-                    "jpeg_tables, if given, must be at least 2 bytes long. Got {:?}",
-                    tables
-                );
-
-                assert!(
-                    length >= 2,
-                    "if jpeg_tables is given, length must be at least 2 bytes long, got {}",
-                    length
-                );
-
-                let mut jpeg_data = tables.clone();
-                let truncated_length = jpeg_data.len() - 2;
-                jpeg_data.truncate(truncated_length);
-                jpeg_data.extend_from_slice(&segment[2..]);
-
-                Ok(JpegReader {
-                    buffer: io::Cursor::new(jpeg_data),
-                })
-            }
-            None => Ok(JpegReader {
-                buffer: io::Cursor::new(segment),
-            }),
+impl<R: Read> PackBitsReader<R> {
+    /// Wraps a reader
+    pub fn new(reader: R, length: u64) -> Self {
+        Self {
+            reader: reader.take(length),
+            state: PackBitsReaderState::Header,
+            count: 0,
         }
     }
 }
 
-impl Read for JpegReader {
-    // #[inline]
+impl<R: Read> Read for PackBitsReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.buffer.read(buf)
-    }
-}
-
-///
-/// ## PackBits Reader
-///
-
-/// Reader that unpacks Apple's `PackBits` format
-pub struct PackBitsReader {
-    buffer: io::Cursor<Vec<u8>>,
-}
-
-impl PackBitsReader {
-    /// Wraps a reader
-    pub fn new<R: Read + Seek>(
-        mut reader: R,
-        length: usize,
-    ) -> io::Result<(usize, PackBitsReader)> {
-        let mut buffer = Vec::new();
-        let mut header: [u8; 1] = [0];
-        let mut data: [u8; 1] = [0];
-
-        let mut bytes_read = 0;
-        while bytes_read < length {
-            reader.read_exact(&mut header)?;
-            bytes_read += 1;
-
+        while let PackBitsReaderState::Header = self.state {
+            if self.reader.limit() == 0 {
+                return Ok(0);
+            }
+            let mut header: [u8; 1] = [0];
+            self.reader.read_exact(&mut header)?;
             let h = header[0] as i8;
-            if h >= -127 && h <= -1 {
-                let new_len = buffer.len() + (1 - h as isize) as usize;
-                reader.read_exact(&mut data)?;
-                buffer.resize(new_len, data[0]);
-                bytes_read += 1;
+            if (-127..=-1).contains(&h) {
+                let mut data: [u8; 1] = [0];
+                self.reader.read_exact(&mut data)?;
+                self.state = PackBitsReaderState::Repeat { value: data[0] };
+                self.count = (1 - h as isize) as usize;
             } else if h >= 0 {
-                let num_vals = h as usize + 1;
-                let start = buffer.len();
-                buffer.resize(start + num_vals, 0);
-                reader.read_exact(&mut buffer[start..])?;
-                bytes_read += num_vals
+                self.state = PackBitsReaderState::Literal;
+                self.count = h as usize + 1;
             } else {
                 // h = -128 is a no-op.
             }
         }
 
-        Ok((
-            buffer.len(),
-            PackBitsReader {
-                buffer: io::Cursor::new(buffer),
-            },
-        ))
+        let length = buf.len().min(self.count);
+        let actual = match self.state {
+            PackBitsReaderState::Literal => self.reader.read(&mut buf[..length])?,
+            PackBitsReaderState::Repeat { value } => {
+                for b in &mut buf[..length] {
+                    *b = value;
+                }
+
+                length
+            }
+            PackBitsReaderState::Header => unreachable!(),
+        };
+
+        self.count -= actual;
+        if self.count == 0 {
+            self.state = PackBitsReaderState::Header;
+        }
+        Ok(actual)
     }
 }
 
-impl Read for PackBitsReader {
-    #[inline]
+#[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> {
-        self.buffer.read(buf)
-    }
-}
+        // 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)?;
 
-///
-/// ## SmartReader Reader
-///
+            match next {
+                fax34::decoder::DecodeStatus::End => (),
+                fax34::decoder::DecodeStatus::Incomplete => {
+                    self.y += 1;
 
-/// Reader that is aware of the byte order.
-#[derive(Debug)]
-pub struct SmartReader<R>
-where
-    R: Read,
-{
-    reader: R,
-    pub byte_order: ByteOrder,
-}
+                    // 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);
 
-impl<R> SmartReader<R>
-where
-    R: Read,
-{
-    /// Wraps a reader
-    pub fn wrap(reader: R, byte_order: ByteOrder) -> SmartReader<R> {
-        SmartReader { reader, byte_order }
-    }
-}
+                    let buffer = self.line_buf.get_mut();
+                    buffer.resize(usize::from(self.width).div_ceil(8), 0u8);
 
-impl<R> EndianReader for SmartReader<R>
-where
-    R: Read,
-{
-    #[inline(always)]
-    fn byte_order(&self) -> ByteOrder {
-        self.byte_order
-    }
-}
+                    let target = &mut buffer[..];
 
-impl<R: Read> Read for SmartReader<R> {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.reader.read(buf)
-    }
-}
+                    // 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,
+                    });
 
-impl<R: Read + Seek> Seek for SmartReader<R> {
-    #[inline]
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        self.reader.seek(pos)
+                    // 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)
     }
 }
 
@@ -378,7 +367,7 @@ mod test {
         let encoded_len = encoded.len();
 
         let buff = io::Cursor::new(encoded);
-        let (_, mut decoder) = PackBitsReader::new(buff, encoded_len).unwrap();
+        let mut decoder = PackBitsReader::new(buff, encoded_len as u64);
 
         let mut decoded = Vec::new();
         decoder.read_to_end(&mut decoded).unwrap();

src/decoder/tag_reader.rs

@@ -0,0 +1,105 @@
+use std::io::{Read, Seek};
+
+use crate::{
+    tags::{Tag, ValueBuffer},
+    Directory, TiffError, TiffFormatError, TiffResult,
+};
+
+use super::ifd::{Entry, Value};
+use super::ValueReader;
+
+pub(crate) struct TagReader<'lt, R: EntryDecoder + ?Sized> {
+    pub(crate) decoder: &'lt mut R,
+    pub(crate) ifd: &'lt Directory,
+}
+
+pub(crate) trait EntryDecoder {
+    /// Turn an entry into a value by fetching the required bytes in the stream.
+    fn entry_val(&mut self, entry: &Entry) -> TiffResult<Value>;
+    /// Fill a  `ValueBuffer` by fetching the required bytes.
+    fn entry_buf(&mut self, entry: &Entry, _: &mut ValueBuffer) -> TiffResult<()>;
+    /// Fill the prefix of the buffer and return the actual bytes. Start interpreting the inner
+    /// value at `offset`.
+    fn entry_raw(&mut self, entry: &Entry, _: &mut [u8], offset: u64) -> TiffResult<usize>;
+}
+
+impl<R: Seek + Read> EntryDecoder for ValueReader<R> {
+    fn entry_val(&mut self, entry: &Entry) -> TiffResult<Value> {
+        entry.val(&self.limits, self.bigtiff, &mut self.reader)
+    }
+
+    fn entry_buf(&mut self, entry: &Entry, buf: &mut ValueBuffer) -> TiffResult<()> {
+        entry.buffered_value(buf, &self.limits, self.bigtiff, &mut self.reader)
+    }
+
+    fn entry_raw(&mut self, entry: &Entry, buf: &mut [u8], offset: u64) -> TiffResult<usize> {
+        entry.raw_value_at(buf, self.bigtiff, &mut self.reader, offset)
+    }
+}
+
+impl<'a, R: EntryDecoder + ?Sized> TagReader<'a, R> {
+    pub(crate) fn find_tag(&mut self, tag: Tag) -> TiffResult<Option<Value>> {
+        let entry = match self.ifd.get(tag) {
+            None => return Ok(None),
+            Some(entry) => entry.clone(),
+        };
+
+        self.decoder.entry_val(&entry).map(Some)
+    }
+
+    /// Find a tag and fill the provided buffer with its raw data.
+    ///
+    /// Returns the entry of the tag if found. This signals that the buffer was overwritten.
+    /// Otherwise the buffer is preserved as-is.
+    pub(crate) fn find_tag_buf(
+        &mut self,
+        tag: Tag,
+        buf: &mut ValueBuffer,
+    ) -> TiffResult<Option<Entry>> {
+        let entry = match self.ifd.get(tag) {
+            None => return Ok(None),
+            Some(entry) => entry.clone(),
+        };
+
+        self.decoder.entry_buf(&entry, buf)?;
+        Ok(Some(entry))
+    }
+
+    pub(crate) fn find_tag_raw(
+        &mut self,
+        tag: Tag,
+        buf: &mut [u8],
+        at: u64,
+    ) -> TiffResult<Option<usize>> {
+        let entry = match self.ifd.get(tag) {
+            None => return Ok(None),
+            Some(entry) => entry.clone(),
+        };
+
+        let len = self.decoder.entry_raw(&entry, buf, at)?;
+        Ok(Some(len))
+    }
+
+    pub(crate) fn require_tag(&mut self, tag: Tag) -> TiffResult<Value> {
+        match self.find_tag(tag)? {
+            Some(val) => Ok(val),
+            None => Err(TiffError::FormatError(
+                TiffFormatError::RequiredTagNotFound(tag),
+            )),
+        }
+    }
+
+    pub fn find_tag_uint_vec<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<Option<Vec<T>>> {
+        self.find_tag(tag)?
+            .map(|v| v.into_u64_vec())
+            .transpose()?
+            .map(|v| {
+                v.into_iter()
+                    .map(|u| {
+                        T::try_from(u).map_err(|_| TiffFormatError::InvalidTagValueType(tag).into())
+                    })
+                    .collect()
+            })
+            .transpose()
+    }
+}

src/directory.rs

@@ -0,0 +1,196 @@
+use core::fmt;
+use std::{collections::BTreeMap, num::NonZeroU64};
+
+use crate::{
+    decoder::ifd::Entry,
+    tags::{IfdPointer, Tag},
+};
+
+/// An Image File Directory (IFD).
+///
+/// A directory is a map of [`Tag`]s to [`Value`](crate::decoder::ifd::Value)s. The values are
+/// stored anywhere in the file, with the directory containing the offsets and length of the
+/// associated values for each tag present in the directory.
+///
+/// A directory can be created with with
+/// [`Decoder::read_directory`](crate::decoder::Decoder::read_directory) or as an empty directory
+/// to be extended with entries. A directory may be used with
+/// [`Decoder::read_directory_tags`](crate::decoder::Decoder::read_directory_tags) to read the
+/// values associated with tags from an underlying file.
+#[doc(alias = "IFD")]
+pub struct Directory {
+    /// There are at most `u16::MAX` entries in any single directory, the count is stored as a
+    /// 2-byte value. The order in the file is implied to be ascending by tag value (the decoder
+    /// does not mind unordered entries).
+    pub(crate) entries: BTreeMap<u16, Entry>,
+    pub(crate) next_ifd: Option<NonZeroU64>,
+}
+
+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 {
+        Directory {
+            entries: BTreeMap::new(),
+            next_ifd: None,
+        }
+    }
+
+    /// Retrieve the value associated with a tag.
+    pub fn get(&self, tag: Tag) -> Option<&Entry> {
+        self.entries.get(&tag.to_u16())
+    }
+
+    /// Check if the directory contains a specified tag.
+    pub fn contains(&self, tag: Tag) -> bool {
+        self.entries.contains_key(&tag.to_u16())
+    }
+
+    /// Iterate over all known and unknown tags in this directory.
+    pub fn iter(&self) -> impl Iterator<Item = (Tag, &Entry)> + '_ {
+        self.entries
+            .iter()
+            .map(|(k, v)| (Tag::from_u16_exhaustive(*k), v))
+    }
+
+    /// Insert additional entries into the directory.
+    ///
+    /// Note that a directory can contain at most `u16::MAX` values. There may be one entry that
+    /// does not fit into the directory. This entry is silently ignored (please check [`Self::len`]
+    /// to detect the condition). Providing a tag multiple times or a tag that already exists
+    /// within this directory overwrites the entry.
+    pub fn extend(&mut self, iter: impl IntoIterator<Item = (Tag, Entry)>) {
+        // Code size conscious extension, avoid monomorphic extensions with the assumption of these
+        // not being performance sensitive in practice. (Maybe we have a polymorphic interface for
+        // the crate usage in the future.
+        self.extend_inner(iter.into_iter().by_ref())
+    }
+
+    /// Get the number of entries.
+    pub fn len(&self) -> usize {
+        // The keys are `u16`. Since IFDs are required to have at least one entry this would have
+        // been a trivial thing to do in the specification by storing it minus one but alas. In
+        // BigTIFF the count is stored as 8-bit anyways.
+        self.entries.len()
+    }
+
+    /// Check if there are any entries in this directory. Note that an empty directory can not be
+    /// encoded in the file, it must contain at least one entry.
+    pub fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// Get the pointer to the next IFD, if it was defined.
+    pub fn next(&self) -> Option<IfdPointer> {
+        self.next_ifd.map(|n| IfdPointer(n.get()))
+    }
+
+    pub fn set_next(&mut self, next: Option<IfdPointer>) {
+        self.next_ifd = next.and_then(|n| NonZeroU64::new(n.0));
+    }
+
+    fn extend_inner(&mut self, iter: &mut dyn Iterator<Item = (Tag, Entry)>) {
+        for (tag, entry) in iter {
+            // If the tag is already present, it will be overwritten.
+            let map_entry = self.entries.entry(tag.to_u16());
+
+            match map_entry {
+                std::collections::btree_map::Entry::Vacant(vacant_entry) => {
+                    vacant_entry.insert(entry);
+                }
+                std::collections::btree_map::Entry::Occupied(mut occupied_entry) => {
+                    occupied_entry.insert(entry);
+                }
+            }
+        }
+    }
+
+    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 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Directory")
+            .field(
+                "entries",
+                &self.entries.iter().map(|(k, v)| (Tag::from_u16(*k), v)),
+            )
+            .field("next_ifd", &self.next_ifd)
+            .finish()
+    }
+}
+
+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;
+    use crate::{decoder::ifd::Entry, tags::Tag};
+
+    #[test]
+    fn directory_multiple_entries() {
+        let mut dir = Directory::empty();
+        assert_eq!(dir.len(), 0);
+
+        dir.extend((0..=u16::MAX).map(|i| {
+            let tag = Tag::Unknown(1);
+            let entry = Entry::new_u64(crate::tags::Type::BYTE, i.into(), [0; 8]);
+            (tag, entry)
+        }));
+
+        assert_eq!(dir.len(), 1, "Only one tag was ever modified");
+
+        assert_eq!(
+            dir.get(Tag::Unknown(1))
+                .expect("tag 1 should be present after this chain")
+                .count(),
+            u16::MAX.into()
+        );
+    }
+
+    #[test]
+    fn iteration_order() {
+        let mut dir = Directory::empty();
+        assert_eq!(dir.len(), 0);
+
+        let fake_entry = Entry::new_u64(crate::tags::Type::BYTE, 0, [0; 8]);
+        dir.extend((0..32).map(|i| {
+            let tag = Tag::Unknown(i);
+            let entry = fake_entry.clone();
+            (tag, entry)
+        }));
+
+        let iter_order: Vec<u16> = dir.iter().map(|(tag, _e)| tag.to_u16()).collect();
+        assert_eq!(
+            iter_order,
+            (0..32).collect::<Vec<_>>(),
+            "Tags must be in ascending order according to the specification"
+        );
+    }
+}

src/encoder/colortype.rs

@@ -1,5 +1,31 @@
 use crate::tags::{PhotometricInterpretation, SampleFormat};
 
+macro_rules! integer_horizontal_predict {
+    () => {
+        fn horizontal_predict(row: &[Self::Inner], result: &mut Vec<Self::Inner>) {
+            let sample_size = Self::SAMPLE_FORMAT.len();
+
+            if row.len() < sample_size {
+                debug_assert!(false);
+                return;
+            }
+
+            let (start, rest) = row.split_at(sample_size);
+
+            result.extend_from_slice(start);
+            if result.capacity() - result.len() < rest.len() {
+                return;
+            }
+
+            result.extend(
+                row.into_iter()
+                    .zip(rest)
+                    .map(|(prev, current)| current.wrapping_sub(*prev)),
+            );
+        }
+    };
+}
+
 /// Trait for different colortypes that can be encoded.
 pub trait ColorType {
     /// The type of each sample of this colortype
@@ -10,6 +36,8 @@ pub trait ColorType {
     const BITS_PER_SAMPLE: &'static [u16];
     /// The value of the tiff tag `SampleFormat`
     const SAMPLE_FORMAT: &'static [SampleFormat];
+
+    fn horizontal_predict(row: &[Self::Inner], result: &mut Vec<Self::Inner>);
 }
 
 pub struct Gray8;
@@ -18,6 +46,8 @@ impl ColorType for Gray8 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[8];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
+
+    integer_horizontal_predict!();
 }
 
 pub struct GrayI8;
@@ -26,6 +56,8 @@ impl ColorType for GrayI8 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[8];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int];
+
+    integer_horizontal_predict!();
 }
 
 pub struct Gray16;
@@ -34,6 +66,8 @@ impl ColorType for Gray16 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[16];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
+
+    integer_horizontal_predict!();
 }
 
 pub struct GrayI16;
@@ -42,6 +76,8 @@ impl ColorType for GrayI16 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[16];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int];
+
+    integer_horizontal_predict!();
 }
 
 pub struct Gray32;
@@ -50,6 +86,8 @@ impl ColorType for Gray32 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
+
+    integer_horizontal_predict!();
 }
 
 pub struct GrayI32;
@@ -58,6 +96,8 @@ impl ColorType for GrayI32 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int];
+
+    integer_horizontal_predict!();
 }
 
 pub struct Gray32Float;
@@ -66,6 +106,10 @@ impl ColorType for Gray32Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP];
+
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
 }
 
 pub struct Gray64;
@@ -74,6 +118,8 @@ impl ColorType for Gray64 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
+
+    integer_horizontal_predict!();
 }
 
 pub struct GrayI64;
@@ -82,6 +128,8 @@ impl ColorType for GrayI64 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Int];
+
+    integer_horizontal_predict!();
 }
 
 pub struct Gray64Float;
@@ -90,6 +138,10 @@ impl ColorType for Gray64Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP];
+
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
 }
 
 pub struct RGB8;
@@ -98,6 +150,8 @@ impl ColorType for RGB8 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGB16;
@@ -106,6 +160,8 @@ impl ColorType for RGB16 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGB32;
@@ -114,6 +170,8 @@ impl ColorType for RGB32 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGB32Float;
@@ -122,6 +180,9 @@ impl ColorType for RGB32Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 3];
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
 }
 
 pub struct RGB64;
@@ -130,6 +191,8 @@ impl ColorType for RGB64 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGB64Float;
@@ -138,6 +201,9 @@ impl ColorType for RGB64Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 3];
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
 }
 
 pub struct RGBA8;
@@ -146,6 +212,8 @@ impl ColorType for RGBA8 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8, 8];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGBA16;
@@ -154,6 +222,8 @@ impl ColorType for RGBA16 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16, 16];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGBA32;
@@ -162,6 +232,8 @@ impl ColorType for RGBA32 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGBA32Float;
@@ -170,6 +242,9 @@ impl ColorType for RGBA32Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
 }
 
 pub struct RGBA64;
@@ -178,6 +253,8 @@ impl ColorType for RGBA64 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct RGBA64Float;
@@ -186,6 +263,9 @@ impl ColorType for RGBA64Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
 }
 
 pub struct CMYK8;
@@ -194,6 +274,8 @@ impl ColorType for CMYK8 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8, 8];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct CMYK16;
@@ -202,6 +284,8 @@ impl ColorType for CMYK16 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16, 16];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct CMYK32;
@@ -210,6 +294,8 @@ impl ColorType for CMYK32 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct CMYK32Float;
@@ -218,6 +304,10 @@ impl ColorType for CMYK32Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
+
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
 }
 
 pub struct CMYK64;
@@ -226,6 +316,8 @@ impl ColorType for CMYK64 {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+
+    integer_horizontal_predict!();
 }
 
 pub struct CMYK64Float;
@@ -234,4 +326,28 @@ impl ColorType for CMYK64Float {
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
+
+    fn horizontal_predict(_: &[Self::Inner], _: &mut Vec<Self::Inner>) {
+        unreachable!()
+    }
+}
+
+pub struct YCbCr8;
+impl ColorType for YCbCr8 {
+    type Inner = u8;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::YCbCr;
+    const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+
+    integer_horizontal_predict!();
+}
+
+pub struct CMYKA8;
+impl ColorType for CMYKA8 {
+    type Inner = u8;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
+    const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8, 8, 8];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 5];
+
+    integer_horizontal_predict!();
 }

src/encoder/compression/deflate.rs

@@ -0,0 +1,78 @@
+use crate::encoder::compression::*;
+use flate2::{write::ZlibEncoder, Compression as FlateCompression};
+
+/// The Deflate algorithm used to compress image data in TIFF files.
+#[derive(Debug, Clone, Copy)]
+pub struct Deflate {
+    level: FlateCompression,
+}
+
+/// The level of compression used by the Deflate algorithm.
+/// It allows trading compression ratio for compression speed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[non_exhaustive]
+#[derive(Default)]
+pub enum DeflateLevel {
+    /// The fastest possible compression mode.
+    Fast = 1,
+    /// The conserative choice between speed and ratio.
+    #[default]
+    Balanced = 6,
+    /// The best compression available with Deflate.
+    Best = 9,
+}
+
+impl Deflate {
+    /// Create a new deflate compressor with a specific level of compression.
+    pub fn with_level(level: DeflateLevel) -> Self {
+        Self {
+            level: FlateCompression::new(level as u32),
+        }
+    }
+}
+
+impl Default for Deflate {
+    fn default() -> Self {
+        Self::with_level(DeflateLevel::default())
+    }
+}
+
+impl Compression for Deflate {
+    const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::Deflate;
+
+    fn get_algorithm(&self) -> Compressor {
+        Compressor::Deflate(*self)
+    }
+}
+
+impl CompressionAlgorithm for Deflate {
+    fn write_to<W: Write>(&mut self, writer: &mut W, bytes: &[u8]) -> Result<u64, io::Error> {
+        let mut encoder = ZlibEncoder::new(writer, self.level);
+        encoder.write_all(bytes)?;
+        encoder.try_finish()?;
+        Ok(encoder.total_out())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::encoder::compression::tests::TEST_DATA;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_deflate() {
+        const EXPECTED_COMPRESSED_DATA: [u8; 64] = [
+            0x78, 0x9C, 0x15, 0xC7, 0xD1, 0x0D, 0x80, 0x20, 0x0C, 0x04, 0xD0, 0x55, 0x6E, 0x02,
+            0xA7, 0x71, 0x81, 0xA6, 0x41, 0xDA, 0x28, 0xD4, 0xF4, 0xD0, 0xF9, 0x81, 0xE4, 0xFD,
+            0xBC, 0xD3, 0x9C, 0x58, 0x04, 0x1C, 0xE9, 0xBD, 0xE2, 0x8A, 0x84, 0x5A, 0xD1, 0x7B,
+            0xE7, 0x97, 0xF4, 0xF8, 0x08, 0x8D, 0xF6, 0x66, 0x21, 0x3D, 0x3A, 0xE4, 0xA9, 0x91,
+            0x3E, 0xAC, 0xF1, 0x98, 0xB9, 0x70, 0x17, 0x13,
+        ];
+
+        let mut compressed_data = Vec::<u8>::new();
+        let mut writer = Cursor::new(&mut compressed_data);
+        Deflate::default().write_to(&mut writer, TEST_DATA).unwrap();
+        assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice());
+    }
+}

src/encoder/compression/lzw.rs

@@ -0,0 +1,46 @@
+use crate::encoder::compression::*;
+use weezl::encode::Encoder as LZWEncoder;
+
+/// The LZW algorithm used to compress image data in TIFF files.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct Lzw;
+
+impl Compression for Lzw {
+    const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::LZW;
+
+    fn get_algorithm(&self) -> Compressor {
+        Compressor::Lzw(*self)
+    }
+}
+
+impl CompressionAlgorithm for Lzw {
+    fn write_to<W: Write>(&mut self, writer: &mut W, bytes: &[u8]) -> Result<u64, io::Error> {
+        let mut encoder = LZWEncoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8);
+        let result = encoder.into_stream(writer).encode_all(bytes);
+        let byte_count = result.bytes_written as u64;
+        result.status.map(|_| byte_count)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::encoder::compression::tests::TEST_DATA;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_lzw() {
+        const EXPECTED_COMPRESSED_DATA: [u8; 63] = [
+            0x80, 0x15, 0x0D, 0x06, 0x93, 0x98, 0x82, 0x08, 0x20, 0x30, 0x88, 0x0E, 0x67, 0x43,
+            0x91, 0xA4, 0xDC, 0x67, 0x10, 0x19, 0x8D, 0xE7, 0x21, 0x01, 0x8C, 0xD0, 0x65, 0x31,
+            0x9A, 0xE1, 0xD1, 0x03, 0xB1, 0x86, 0x1A, 0x6F, 0x3A, 0xC1, 0x4C, 0x66, 0xF3, 0x69,
+            0xC0, 0xE4, 0x65, 0x39, 0x9C, 0xCD, 0x26, 0xF3, 0x74, 0x20, 0xD8, 0x67, 0x89, 0x9A,
+            0x4E, 0x86, 0x83, 0x69, 0xCC, 0x5D, 0x01,
+        ];
+
+        let mut compressed_data = Vec::<u8>::new();
+        let mut writer = Cursor::new(&mut compressed_data);
+        Lzw.write_to(&mut writer, TEST_DATA).unwrap();
+        assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice());
+    }
+}

src/encoder/compression/mod.rs

@@ -0,0 +1,70 @@
+use crate::tags::CompressionMethod;
+use std::io::{self, Write};
+
+#[cfg(feature = "deflate")]
+mod deflate;
+#[cfg(feature = "lzw")]
+mod lzw;
+mod packbits;
+mod uncompressed;
+
+#[cfg(feature = "deflate")]
+pub use self::deflate::{Deflate, DeflateLevel};
+
+#[cfg(feature = "lzw")]
+pub use self::lzw::Lzw;
+
+pub use self::packbits::Packbits;
+pub use self::uncompressed::Uncompressed;
+
+/// An algorithm used for compression
+pub trait CompressionAlgorithm {
+    /// The algorithm writes data directly into the writer.
+    /// It returns the total number of bytes written.
+    fn write_to<W: Write>(&mut self, writer: &mut W, bytes: &[u8]) -> Result<u64, io::Error>;
+}
+
+/// An algorithm used for compression with associated enums and optional configurations.
+pub trait Compression: CompressionAlgorithm {
+    /// The corresponding tag to the algorithm.
+    const COMPRESSION_METHOD: CompressionMethod;
+
+    /// Method to optain a type that can store each variant of comression algorithm.
+    fn get_algorithm(&self) -> Compressor;
+}
+
+/// An enum to store each compression algorithm.
+#[non_exhaustive]
+pub enum Compressor {
+    Uncompressed(Uncompressed),
+    #[cfg(feature = "lzw")]
+    Lzw(Lzw),
+    #[cfg(feature = "deflate")]
+    Deflate(Deflate),
+    Packbits(Packbits),
+}
+
+impl Default for Compressor {
+    /// The default compression strategy does not apply any compression.
+    fn default() -> Self {
+        Compressor::Uncompressed(Uncompressed)
+    }
+}
+
+impl CompressionAlgorithm for Compressor {
+    fn write_to<W: Write>(&mut self, writer: &mut W, bytes: &[u8]) -> Result<u64, io::Error> {
+        match self {
+            Compressor::Uncompressed(algorithm) => algorithm.write_to(writer, bytes),
+            #[cfg(feature = "lzw")]
+            Compressor::Lzw(algorithm) => algorithm.write_to(writer, bytes),
+            #[cfg(feature = "deflate")]
+            Compressor::Deflate(algorithm) => algorithm.write_to(writer, bytes),
+            Compressor::Packbits(algorithm) => algorithm.write_to(writer, bytes),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    pub const TEST_DATA: &[u8] = b"This is a string for checking various compression algorithms.";
+}

src/encoder/compression/packbits.rs

@@ -0,0 +1,204 @@
+use crate::encoder::compression::*;
+use std::io::{BufWriter, Error, ErrorKind};
+
+/// Compressor that uses the Packbits[^note] algorithm to compress bytes.
+///
+/// [^note]: PackBits is often ineffective on continuous tone images,
+///          including many grayscale images. In such cases, it is better
+///          to leave the image uncompressed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct Packbits;
+
+impl Compression for Packbits {
+    const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::PackBits;
+
+    fn get_algorithm(&self) -> Compressor {
+        Compressor::Packbits(*self)
+    }
+}
+
+impl CompressionAlgorithm for Packbits {
+    fn write_to<W: Write>(&mut self, writer: &mut W, bytes: &[u8]) -> Result<u64, io::Error> {
+        // Inspired by https://github.com/skirridsystems/packbits
+
+        const MIN_REPT: u8 = 3; // Minimum run to compress between differ blocks
+        const MAX_BYTES: u8 = 128; // Maximum number of bytes that can be encoded in a header byte
+
+        // Encoding for header byte based on number of bytes represented.
+        fn encode_diff(n: u8) -> u8 {
+            n - 1
+        }
+        fn encode_rept(n: u8) -> u8 {
+            let var = 256 - (n - 1) as u16;
+            var as u8
+        }
+
+        fn write_u8<W: Write>(writer: &mut W, byte: u8) -> Result<u64, Error> {
+            writer.write(&[byte]).map(|byte_count| byte_count as u64)
+        }
+
+        let mut bufwriter = BufWriter::new(writer);
+        let mut bytes_written = 0u64; // The number of bytes written into the writer
+        let mut offset: Option<u64> = None; // The index of the first byte written into the writer
+
+        let mut src_index: usize = 0; // Index of the current byte
+        let mut src_count = bytes.len(); //The number of bytes remaining to be compressed
+
+        let mut in_run = false; // Indication whether counting of similar bytes is performed
+        let mut run_index = 0u8; // Distance into pending bytes that a run starts
+
+        let mut bytes_pending = 0u8; // Bytes looked at but not yet output
+        let mut pending_index = 0usize; // Index of the first pending byte
+
+        let mut curr_byte: u8; // Byte currently being considered
+        let mut last_byte: u8; // Previous byte
+
+        // Need at least one byte to compress
+        if src_count == 0 {
+            return Err(Error::new(ErrorKind::WriteZero, "write zero"));
+        }
+
+        // Prime compressor with first character.
+        last_byte = bytes[src_index];
+        src_index += 1;
+        bytes_pending += 1;
+
+        while src_count - 1 != 0 {
+            src_count -= 1;
+            curr_byte = bytes[src_index];
+            src_index += 1;
+            bytes_pending += 1;
+
+            if in_run {
+                if (curr_byte != last_byte) || (bytes_pending > MAX_BYTES) {
+                    offset.get_or_insert(write_u8(&mut bufwriter, encode_rept(bytes_pending - 1))?);
+                    write_u8(&mut bufwriter, last_byte)?;
+                    bytes_written += 2;
+
+                    bytes_pending = 1;
+                    pending_index = src_index - 1;
+                    run_index = 0;
+                    in_run = false;
+                }
+            } else if bytes_pending > MAX_BYTES {
+                // We have as much differing data as we can output in one chunk.
+                // Output MAX_BYTES leaving one byte.
+                offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?);
+                bufwriter.write_all(&bytes[pending_index..pending_index + MAX_BYTES as usize])?;
+                bytes_written += 1 + MAX_BYTES as u64;
+
+                pending_index += MAX_BYTES as usize;
+                bytes_pending -= MAX_BYTES;
+                run_index = bytes_pending - 1; // A run could start here
+            } else if curr_byte == last_byte {
+                if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) {
+                    // This is a worthwhile run
+                    if run_index != 0 {
+                        // Flush differing data out of input buffer
+                        offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?);
+                        bufwriter
+                            .write_all(&bytes[pending_index..pending_index + run_index as usize])?;
+                        bytes_written += 1 + run_index as u64;
+                    }
+                    bytes_pending -= run_index; // Length of run
+                    in_run = true;
+                }
+            } else {
+                run_index = bytes_pending - 1; // A run could start here
+            }
+            last_byte = curr_byte;
+        }
+
+        // Output the remainder
+        if in_run {
+            bytes_written += 2;
+            offset.get_or_insert(write_u8(&mut bufwriter, encode_rept(bytes_pending))?);
+            write_u8(&mut bufwriter, last_byte)?;
+        } else {
+            bytes_written += 1 + bytes_pending as u64;
+            offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(bytes_pending))?);
+            bufwriter.write_all(&bytes[pending_index..pending_index + bytes_pending as usize])?;
+        }
+
+        bufwriter.flush()?;
+        Ok(bytes_written)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::encoder::compression::tests::TEST_DATA;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_packbits_single_byte() {
+        // compress single byte
+        const UNCOMPRESSED_DATA: [u8; 1] = [0x3F];
+        const EXPECTED_COMPRESSED_DATA: [u8; 2] = [0x00, 0x3F];
+
+        let mut compressed_data = Vec::<u8>::new();
+        let mut writer = Cursor::new(&mut compressed_data);
+        Packbits.write_to(&mut writer, &UNCOMPRESSED_DATA).unwrap();
+        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
+    }
+
+    #[test]
+    fn test_packbits_rept() {
+        // compress buffer with repetitive sequence
+        const UNCOMPRESSED_DATA: &[u8] =
+            b"This strrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrring hangs.";
+        const EXPECTED_COMPRESSED_DATA: &[u8] = b"\x06This st\xD1r\x09ing hangs.";
+
+        let mut compressed_data = Vec::<u8>::new();
+        let mut writer = Cursor::new(&mut compressed_data);
+        Packbits.write_to(&mut writer, UNCOMPRESSED_DATA).unwrap();
+        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
+    }
+
+    #[test]
+    fn test_packbits_large_rept_nonrept() {
+        // compress buffer with large repetitive and non-repetitive sequence
+        let mut data = b"This st".to_vec();
+        for _i in 0..158 {
+            data.push(b'r');
+        }
+        data.extend_from_slice(b"ing hangs.");
+        for i in 0..158 {
+            data.push(i);
+        }
+
+        const EXPECTED_COMPRESSED_DATA: [u8; 182] = [
+            0x06, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x74, 0x81, 0x72, 0xE3, 0x72, 0x7F, 0x69,
+            0x6E, 0x67, 0x20, 0x68, 0x61, 0x6E, 0x67, 0x73, 0x2E, 0x00, 0x01, 0x02, 0x03, 0x04,
+            0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
+            0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
+            0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E,
+            0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C,
+            0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
+            0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+            0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+            0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74,
+            0x75, 0x27, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81,
+            0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
+            0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
+        ];
+
+        let mut compressed_data = Vec::<u8>::new();
+        let mut writer = Cursor::new(&mut compressed_data);
+        Packbits.write_to(&mut writer, data.as_slice()).unwrap();
+        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
+    }
+
+    #[test]
+    fn test_packbits() {
+        // compress teststring
+        const EXPECTED_COMPRESSED_DATA: &[u8] =
+            b"\x3CThis is a string for checking various compression algorithms.";
+
+        let mut compressed_data = Vec::<u8>::new();
+        let mut writer = Cursor::new(&mut compressed_data);
+        Packbits.write_to(&mut writer, TEST_DATA).unwrap();
+        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
+    }
+}

src/encoder/compression/uncompressed.rs

@@ -0,0 +1,34 @@
+use crate::encoder::compression::*;
+
+/// The default algorithm which does not compress at all.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct Uncompressed;
+
+impl Compression for Uncompressed {
+    const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::None;
+
+    fn get_algorithm(&self) -> Compressor {
+        Compressor::Uncompressed(*self)
+    }
+}
+
+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)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::encoder::compression::tests::TEST_DATA;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_no_compression() {
+        let mut compressed_data = Vec::<u8>::new();
+        let mut writer = Cursor::new(&mut compressed_data);
+        Uncompressed.write_to(&mut writer, TEST_DATA).unwrap();
+        assert_eq!(TEST_DATA, compressed_data);
+    }
+}

src/encoder/tag_filter.rs

@@ -0,0 +1,256 @@
+use crate::tags::{PhotometricInterpretation, PlanarConfiguration};
+
+/// A filter of tags copied in
+/// [`DirectoryEncoder::write_metadata_from`][`super::DirectoryEncoder::write_metadata_from`].
+pub struct TagFilter {
+    filter_level: FilterLevel,
+}
+
+impl TagFilter {
+    /// Return a filter that allows all tags from metadata subdirectories.
+    pub fn allow_all_in_subdirectories() -> &'static TagFilter {
+        static INSTANCE: TagFilter = TagFilter {
+            filter_level: FilterLevel::All,
+        };
+        &INSTANCE
+    }
+
+    /// Return a filter that has an explicit allow list of tags, for each of a known list of
+    /// metadata subdirectories.
+    pub fn only_known_tags() -> &'static TagFilter {
+        static INSTANCE: TagFilter = TagFilter {
+            filter_level: FilterLevel::Known,
+        };
+        &INSTANCE
+    }
+
+    /// FIXME: take a configuration by which to filter out complete metadata kinds.
+    /// FIXME: when we iterate over a whole directory of tags, this iteration is more expensive
+    /// than necessary. Tags within a directory should be ordered. We can thus perform a binary set
+    /// join which is more efficient than checking the individual filter on each. Does not matter
+    /// much in most cases though.
+    pub(crate) fn filter_primary(&self, tag: u16) -> Level {
+        let as_exif = self.filter_primary_exif(tag);
+
+        if !matches!(as_exif, Level::Unknown) {
+            return as_exif;
+        }
+
+        let as_gps = self.filter_primary_gps(tag);
+
+        if !matches!(as_gps, Level::Unknown) {
+            return as_gps;
+        }
+
+        let as_icc = self.filter_icc(tag);
+
+        if !matches!(as_icc, Level::Unknown) {
+            return as_icc;
+        }
+
+        Level::Unknown
+    }
+
+    /// As per EXIF V3.0 tags, Primary Image (0th IFD).
+    pub(crate) fn filter_primary_exif(&self, tag: u16) -> Level {
+        match tag {
+            // width, height, etc
+            0x0100..=0x0103 => Level::SampleLayout,
+            // photometric interpretation
+            0x0106 => Level::SampleLayout,
+            // data tied to the camera and customized description, potentially PI.
+            0x010f..=0x0110 => Level::Value,
+            // strip offsets
+            0x0111 => Level::SampleLayout,
+            // orientation
+            0x0112 => Level::Value,
+            // strip byte counts, samples
+            0x0115..=0x0117 => Level::SampleLayout,
+            // pixel dimensions (ratio). Should be generic enough.
+            0x011a..=0x011b => Level::Value,
+            // planar configuration
+            0x011c => Level::Photometric(Photometric::Planar),
+            // units for 0x011a,0x011b
+            0x0128 => Level::Value,
+            // transfer function
+            0x012d => Level::Photometric(Photometric::All),
+            // file data time, software pipeline. I'm wary of privacy implications.
+            0x0131..=0x0132 => Level::Value,
+            // artist, clearly PI unless you explicitly wish it to be attributed.
+            0x013b => Level::Value,
+            // Whitepoint, Chromaticities
+            0x013e..=0x013f => Level::Photometric(Photometric::All),
+            // The table lists these as Not allowed for anything but we may have a choice here for
+            // older models of images.
+            0x0201..=0x0202 => Level::Special(Special::JpegThumbnail),
+            0x0211..=0x0213 => Level::Photometric(Photometric::YCbCr),
+            0x0214 => Level::Photometric(Photometric::All),
+            // Copyright holder (not same as artist).
+            0x8298 => Level::Value,
+            0x8769 => Level::Ifd(SubifdKind::ExifPrivate),
+            _ => Level::Unknown,
+        }
+    }
+
+    pub(crate) fn filter_primary_gps(&self, tag: u16) -> Level {
+        match tag {
+            0x8825 => Level::Ifd(SubifdKind::Gps),
+            _ => Level::Unknown,
+        }
+    }
+
+    pub(crate) fn filter_icc(&self, tag: u16) -> Level {
+        match tag {
+            0x8ff3 => Level::Value,
+            _ => Level::Unknown,
+        }
+    }
+
+    pub(crate) fn filter_exif_private(&self, tag: u16) -> Level {
+        match tag {
+            // Maybe this is not personal identifying but some equipment may be very specifically
+            // known through these. And it's not critical to displaying it correctly.
+            0x829a => Level::Value,
+            0x829d => Level::Value,
+            0x8822 => Level::Value,
+            0x8824 => Level::Value,
+            0x8827 => Level::Value,
+            // Opto-electric coefficients
+            0x8828 => Level::Value,
+            0x8830..=0x8835 => Level::Value,
+            0x9000 => Level::Value,
+            0x9003..=0x9004 => Level::Value,
+            0x9010..=0x9012 => Level::Value,
+            // Not allowed for uncompressed data!
+            0x9101..=0x9102 => Level::Special(Special::CompressedExclusive),
+            0x9201..=0x9209 => Level::Value,
+            0x920a => Level::Value,
+            0x9214 => Level::Value,
+            0x927c => Level::Value,
+            0x9286 => Level::Value,
+            0x9290..=0x9292 => Level::Value,
+            0x9400..=0x9405 => Level::Value,
+            0xa000 => Level::Value,
+            0xa001 => Level::Photometric(Photometric::All),
+            0xa002..=0xa003 => Level::Special(Special::CompressedExclusive),
+            0xa004 => Level::Value,
+            0xa005 => Level::Ifd(SubifdKind::Interoperability),
+            0xa20b..=0xa20c => Level::Value,
+            0xa20e..=0xa210 => Level::Value,
+            0xa214..=0xa215 => Level::Value,
+            0xa217 => Level::Value,
+            0xa300..=0xa302 => Level::Value,
+            0xa401..=0xa40c => Level::Value,
+            0xa420 => Level::Value,
+            0xa430..=0xa43c => Level::Value,
+            0xa460..=0xa462 => Level::Value,
+            0xa500 => Level::Photometric(Photometric::All),
+            _ => Level::Unknown,
+        }
+    }
+
+    pub(crate) fn filter_gps_private(&self, tag: u16) -> Level {
+        match tag {
+            0x0000..=0x001f => Level::Value,
+            _ => Level::Unknown,
+        }
+    }
+
+    pub(crate) fn should_keep_for_image_writer(
+        &self,
+        level: Level,
+        target: &super::EncodeMetadataApplicability,
+    ) -> Choice {
+        match level {
+            Level::Unknown if matches!(self.filter_level, FilterLevel::All) => Choice::Filtered,
+            // Sample Layout is controlled by the writer (dimensions, color type, …). Do not copy!
+            Level::SampleLayout => Choice::Discard,
+            Level::Ifd(subifd_kind) => Choice::Descend(subifd_kind),
+            Level::Photometric(photometric) => {
+                match (photometric, target.planar, target.photometric) {
+                    (Photometric::All, _, _) => Choice::Ok,
+                    (Photometric::Planar, Some(PlanarConfiguration::Planar) | None, _) => {
+                        Choice::Ok
+                    }
+                    (Photometric::YCbCr, _, Some(PhotometricInterpretation::YCbCr) | None) => {
+                        Choice::Ok
+                    }
+                    _ => Choice::Discard,
+                }
+            }
+            Level::Value => Choice::Ok,
+            Level::Special(special) => Choice::Special(special),
+            _ => Choice::Discard,
+        }
+    }
+}
+
+pub(crate) enum Choice {
+    Ok,
+    Descend(SubifdKind),
+    /// Tag is inapplicable to be copied.
+    Discard,
+    /// Tag was chosen not to be copied.
+    Filtered,
+    Special(Special),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum FilterLevel {
+    All,
+    Known,
+}
+
+/// The level of support for a value.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Level {
+    Unknown,
+    /// Value describes the image data layout, which we will not want to write into the encoder's
+    /// directory where the image data is written later.
+    ///
+    /// These are treated as privacy preserving.
+    SampleLayout,
+    /// Value is an IFD and must be copied by making a subdirectory.
+    ///
+    /// These are treated as privacy preserving, independent of the tags within the subdirectory
+    /// which may not be. (For instance the presence of an empty directory is fine but we will omit
+    /// a GPS anyways).
+    Ifd(SubifdKind),
+    /// Value is related to photometric interpretation and should not be copied when the target
+    /// does not match the expected interpretation.
+    ///
+    /// These are *generally* treated as privacy preserving.
+    Photometric(Photometric),
+    /// This is a value we know of.
+    /// FIXME: we do not differentiate by personal identifiable information and otherwise which is
+    /// quite important for some variations of copying metadata.
+    Value,
+    /// We recognize the tag but it can not be copied by itself through normal means.
+    ///
+    /// Privacy treatment depends on the tag.
+    Special(Special),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Photometric {
+    All,
+    /// Do not copy for non-planar data.
+    Planar,
+    /// Do not copy for non-YCbCr data.
+    YCbCr,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum SubifdKind {
+    ExifPrivate,
+    Gps,
+    Interoperability,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Special {
+    /// Thumbnail which we regard as PI since we do not deep-clean the JPEG structure.
+    JpegThumbnail,
+    /// May only occur in compressed (JPEG APP segments) data.
+    CompressedExclusive,
+}

src/encoder/tiff_value.rs

@@ -1,18 +1,42 @@
-use std::io::Write;
+use std::{borrow::Cow, io::Write, slice::from_ref};
 
-use crate::{bytecast, tags::Type, TiffError, TiffFormatError, TiffResult};
+use crate::{bytecast, tags, tags::Type, TiffError, TiffFormatError, TiffResult};
 
 use super::writer::TiffWriter;
 
 /// Trait for types that can be encoded in a tiff file
+#[diagnostic::on_unimplemented(
+    message = "the type `{Self}` does not implement `TiffValue`",
+    note = "the trait is implemented for primitive types (`u8`, `i16`, `f32`, etc.)",
+    note = "the trait is implemented for shared references to values",
+    note = "the trait is implemented for slices, pass them by reference (e.g. `&[u8]`)",
+    note = "the trait is implemented for arrays if it is implemented for a slice",
+    note = "values in a `Vec` or `Box` should be dereferenced, e.g. `&vec[..]`"
+)]
 pub trait TiffValue {
     const BYTE_LEN: u8;
     const FIELD_TYPE: Type;
+
+    // FIXME: If we want this to mean 'count' in the sense of `Entry` it should return `u32` or
+    // `u64`, probably the latter with `convert_offset` taking care of the check against `u32::MAX`
+    // for classic tiff.
     fn count(&self) -> usize;
+
     fn bytes(&self) -> usize {
         self.count() * usize::from(Self::BYTE_LEN)
     }
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()>;
+
+    /// 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]>;
+
+    /// Write this value to a TiffWriter.
+    /// While the default implementation will work in all cases, it may require unnecessary allocations.
+    /// The written bytes of any custom implementation MUST be the same as yielded by `self.data()`.
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_bytes(&self.data())?;
+        Ok(())
+    }
 }
 
 impl TiffValue for [u8] {
@@ -23,9 +47,8 @@ impl TiffValue for [u8] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        writer.write_bytes(self)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(self)
     }
 }
 
@@ -37,10 +60,8 @@ impl TiffValue for [i8] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        let slice = bytecast::i8_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i8_as_ne_bytes(self))
     }
 }
 
@@ -52,10 +73,8 @@ impl TiffValue for [u16] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        let slice = bytecast::u16_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u16_as_ne_bytes(self))
     }
 }
 
@@ -67,10 +86,8 @@ impl TiffValue for [i16] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        let slice = bytecast::i16_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i16_as_ne_bytes(self))
     }
 }
 
@@ -82,10 +99,8 @@ impl TiffValue for [u32] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        let slice = bytecast::u32_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u32_as_ne_bytes(self))
     }
 }
 
@@ -97,10 +112,8 @@ impl TiffValue for [i32] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        let slice = bytecast::i32_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i32_as_ne_bytes(self))
     }
 }
 
@@ -112,10 +125,8 @@ impl TiffValue for [u64] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        let slice = bytecast::u64_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u64_as_ne_bytes(self))
     }
 }
 
@@ -127,10 +138,8 @@ impl TiffValue for [i64] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        let slice = bytecast::i64_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i64_as_ne_bytes(self))
     }
 }
 
@@ -142,11 +151,9 @@ impl TiffValue for [f32] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        // We write using nativeedian so this sould be safe
-        let slice = bytecast::f32_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        // We write using native endian so this should be safe
+        Cow::Borrowed(bytecast::f32_as_ne_bytes(self))
     }
 }
 
@@ -158,75 +165,9 @@ impl TiffValue for [f64] {
         self.len()
     }
 
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        // We write using nativeedian so this sould be safe
-        let slice = bytecast::f64_as_ne_bytes(self);
-        writer.write_bytes(slice)?;
-        Ok(())
-    }
-}
-
-impl TiffValue for [Ifd] {
-    const BYTE_LEN: u8 = 4;
-    const FIELD_TYPE: Type = Type::IFD;
-
-    fn count(&self) -> usize {
-        self.len()
-    }
-
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        for x in self {
-            x.write(writer)?;
-        }
-        Ok(())
-    }
-}
-
-impl TiffValue for [Ifd8] {
-    const BYTE_LEN: u8 = 8;
-    const FIELD_TYPE: Type = Type::IFD8;
-
-    fn count(&self) -> usize {
-        self.len()
-    }
-
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        for x in self {
-            x.write(writer)?;
-        }
-        Ok(())
-    }
-}
-
-impl TiffValue for [Rational] {
-    const BYTE_LEN: u8 = 8;
-    const FIELD_TYPE: Type = Type::RATIONAL;
-
-    fn count(&self) -> usize {
-        self.len()
-    }
-
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        for x in self {
-            x.write(writer)?;
-        }
-        Ok(())
-    }
-}
-
-impl TiffValue for [SRational] {
-    const BYTE_LEN: u8 = 8;
-    const FIELD_TYPE: Type = Type::SRATIONAL;
-
-    fn count(&self) -> usize {
-        self.len()
-    }
-
-    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        for x in self {
-            x.write(writer)?;
-        }
-        Ok(())
+    fn data(&self) -> Cow<'_, [u8]> {
+        // We write using native endian so this should be safe
+        Cow::Borrowed(bytecast::f64_as_ne_bytes(self))
     }
 }
 
@@ -242,6 +183,10 @@ impl TiffValue for u8 {
         writer.write_u8(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(from_ref(self))
+    }
 }
 
 impl TiffValue for i8 {
@@ -256,6 +201,10 @@ impl TiffValue for i8 {
         writer.write_i8(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i8_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for u16 {
@@ -270,6 +219,10 @@ impl TiffValue for u16 {
         writer.write_u16(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u16_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for i16 {
@@ -284,6 +237,10 @@ impl TiffValue for i16 {
         writer.write_i16(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i16_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for u32 {
@@ -298,6 +255,10 @@ impl TiffValue for u32 {
         writer.write_u32(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for i32 {
@@ -312,6 +273,10 @@ impl TiffValue for i32 {
         writer.write_i32(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i32_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for u64 {
@@ -326,6 +291,10 @@ impl TiffValue for u64 {
         writer.write_u64(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for i64 {
@@ -340,6 +309,10 @@ impl TiffValue for i64 {
         writer.write_i64(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i64_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for f32 {
@@ -354,6 +327,10 @@ impl TiffValue for f32 {
         writer.write_f32(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::f32_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for f64 {
@@ -368,6 +345,10 @@ impl TiffValue for f64 {
         writer.write_f64(*self)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::f64_as_ne_bytes(from_ref(self)))
+    }
 }
 
 impl TiffValue for Ifd {
@@ -382,6 +363,10 @@ impl TiffValue for Ifd {
         writer.write_u32(self.0)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(&self.0)))
+    }
 }
 
 impl TiffValue for Ifd8 {
@@ -396,6 +381,10 @@ impl TiffValue for Ifd8 {
         writer.write_u64(self.0)?;
         Ok(())
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(&self.0)))
+    }
 }
 
 impl TiffValue for Rational {
@@ -411,6 +400,14 @@ impl TiffValue for Rational {
         writer.write_u32(self.d)?;
         Ok(())
     }
+
+    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));
+            [first_dword, second_dword].concat()
+        })
+    }
 }
 
 impl TiffValue for SRational {
@@ -426,6 +423,14 @@ impl TiffValue for SRational {
         writer.write_i32(self.d)?;
         Ok(())
     }
+
+    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));
+            [first_dword, second_dword].concat()
+        })
+    }
 }
 
 impl TiffValue for str {
@@ -445,9 +450,150 @@ impl TiffValue for str {
             Err(TiffError::FormatError(TiffFormatError::InvalidTag))
         }
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Owned({
+            if self.is_ascii() && !self.bytes().any(|b| b == 0) {
+                let bytes: &[u8] = self.as_bytes();
+                [bytes, &[0]].concat()
+            } else {
+                vec![]
+            }
+        })
+    }
 }
 
-impl<'a, T: TiffValue + ?Sized> TiffValue for &'a T {
+// FIXME: held up on reading the discriminant for all but the unknown variant.
+//
+// It needs to have `repr(u16)` to have a defined layout and then we may read the tag from its
+// value representation by casting a u16 pointer to a pointer to the enum type.
+//     unsafe { *<*const _>::from(self).cast::<u16>() }
+// But that is quite unsafe and needs careful review to maintain the safety requirements. Maybe we
+// could get `bytemuck` to add a trait for this (it has `TransparentWrapper`) with a derive for
+// enum types that have an explicit repr.
+//
+// This would allow returning borrowed data in more cases. For all types without an unknown, in all
+// cases including as slices, and for all types with and unknown variant when we have a single
+// value (either returning a borrowed discriminant or a borrowed value within `Unknown`).
+impl TiffValue for tags::CompressionMethod {
+    const BYTE_LEN: u8 = <u16 as TiffValue>::BYTE_LEN;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        let bytes = self.to_u16().to_ne_bytes();
+        Cow::Owned(bytes.to_vec())
+    }
+}
+
+impl TiffValue for tags::PhotometricInterpretation {
+    const BYTE_LEN: u8 = <u16 as TiffValue>::BYTE_LEN;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        self.to_u16().to_ne_bytes().to_vec().into()
+    }
+}
+
+impl TiffValue for tags::PlanarConfiguration {
+    const BYTE_LEN: u8 = 2;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        self.to_u16().to_ne_bytes().to_vec().into()
+    }
+}
+
+impl TiffValue for tags::Predictor {
+    const BYTE_LEN: u8 = <u16 as TiffValue>::BYTE_LEN;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        self.to_u16().to_ne_bytes().to_vec().into()
+    }
+}
+
+impl TiffValue for tags::ResolutionUnit {
+    const BYTE_LEN: u8 = <u16 as TiffValue>::BYTE_LEN;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        self.to_u16().to_ne_bytes().to_vec().into()
+    }
+}
+
+/// This is implemented for slices as the `SampleFormat` tag takes a count of `N`.
+///
+/// Use `core::slice::from_ref` if you really need to write a single element.
+///
+/// See: <https://web.archive.org/web/20191120220815/https://www.awaresystems.be/imaging/tiff/tifftags/sampleformat.html>
+impl TiffValue for [tags::SampleFormat] {
+    const BYTE_LEN: u8 = <u16 as TiffValue>::BYTE_LEN;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        let mut buf: Vec<u8> = Vec::with_capacity(self.len() * 2);
+        for x in self {
+            buf.extend_from_slice(&x.to_u16().to_ne_bytes());
+        }
+        Cow::Owned(buf)
+    }
+}
+
+/// This is implemented for slices as the `ExtraSamples` tag takes a count of `N`.
+///
+/// Use `core::slice::from_ref` if you really need to write a single element.
+///
+/// See: <https://web.archive.org/web/20191120220815/https://www.awaresystems.be/imaging/tiff/tifftags/extrasamples.html>
+impl TiffValue for [tags::ExtraSamples] {
+    const BYTE_LEN: u8 = <u16 as TiffValue>::BYTE_LEN;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        let mut buf: Vec<u8> = Vec::with_capacity(self.len() * 2);
+        for x in self {
+            buf.extend_from_slice(&x.to_u16().to_ne_bytes());
+        }
+        Cow::Owned(buf)
+    }
+}
+
+// If you pass `&Vec<_>` then you'd get at first sight the  complaint:
+//
+//  `Vec<T>` does not implement `TiffValue`
+//
+// and a list of implementations of `TiffValue` that are quite unrelated. That is not very helpful.
+// We do not *want* `Vec` to implement the trait as an owning type, instead you should pass a
+// reference to a slice. The error message is further customized in the diagnostics of the trait.
+#[diagnostic::do_not_recommend]
+impl<T: TiffValue + ?Sized> TiffValue for &'_ T {
     const BYTE_LEN: u8 = T::BYTE_LEN;
     const FIELD_TYPE: Type = T::FIELD_TYPE;
 
@@ -458,8 +604,66 @@ impl<'a, T: TiffValue + ?Sized> TiffValue for &'a T {
     fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
         (*self).write(writer)
     }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        T::data(self)
+    }
 }
 
+/// An array is treated like a slice of the same length.
+impl<T, const N: usize> TiffValue for [T; N]
+where
+    [T]: TiffValue,
+{
+    const BYTE_LEN: u8 = <[T]>::BYTE_LEN;
+    const FIELD_TYPE: Type = <[T]>::FIELD_TYPE;
+
+    fn count(&self) -> usize {
+        self.as_slice().count()
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        self.as_slice().write(writer)
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        self.as_slice().data()
+    }
+}
+
+macro_rules! impl_tiff_value_for_contiguous_sequence {
+    ($inner_type:ty; $bytes:expr; $field_type:expr) => {
+        impl $crate::encoder::TiffValue for [$inner_type] {
+            const BYTE_LEN: u8 = $bytes;
+            const FIELD_TYPE: Type = $field_type;
+
+            fn count(&self) -> usize {
+                self.len()
+            }
+
+            fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+                for x in self {
+                    x.write(writer)?;
+                }
+                Ok(())
+            }
+
+            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());
+                }
+                Cow::Owned(buf)
+            }
+        }
+    };
+}
+
+impl_tiff_value_for_contiguous_sequence!(Ifd; 4; Type::IFD);
+impl_tiff_value_for_contiguous_sequence!(Ifd8; 8; Type::IFD8);
+impl_tiff_value_for_contiguous_sequence!(Rational; 8; Type::RATIONAL);
+impl_tiff_value_for_contiguous_sequence!(SRational; 8; Type::SRATIONAL);
+
 /// Type to represent tiff values of type `IFD`
 #[derive(Clone)]
 pub struct Ifd(pub u32);

src/encoder/writer.rs

@@ -1,3 +1,4 @@
+use crate::encoder::compression::*;
 use crate::error::TiffResult;
 use std::io::{self, Seek, SeekFrom, Write};
 
@@ -42,87 +43,130 @@ pub fn write_bigtiff_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<
 pub struct TiffWriter<W> {
     writer: W,
     offset: u64,
+    byte_count: u64,
+    compressor: Compressor,
 }
 
 impl<W: Write> TiffWriter<W> {
     pub fn new(writer: W) -> Self {
-        Self { writer, offset: 0 }
+        Self {
+            writer,
+            offset: 0,
+            byte_count: 0,
+            compressor: Compressor::default(),
+        }
+    }
+
+    pub fn set_compression(&mut self, compressor: Compressor) {
+        self.compressor = compressor;
+    }
+
+    pub fn reset_compression(&mut self) {
+        self.compressor = Compressor::default();
     }
 
     pub fn offset(&self) -> u64 {
         self.offset
     }
 
+    pub(crate) fn previous_ifd_pointer<K: super::TiffKind>(&self) -> u64 {
+        self.offset() - core::mem::size_of::<K::OffsetType>() as u64
+    }
+
+    pub fn last_written(&self) -> u64 {
+        self.byte_count
+    }
+
     pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), io::Error> {
-        self.writer.write_all(bytes)?;
-        self.offset += bytes.len() as u64;
+        self.byte_count = self.compressor.write_to(&mut self.writer, bytes)?;
+        self.offset += self.byte_count;
         Ok(())
     }
 
     pub fn write_u8(&mut self, n: u8) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 1;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
         Ok(())
     }
 
     pub fn write_i8(&mut self, n: i8) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 1;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
         Ok(())
     }
 
     pub fn write_u16(&mut self, n: u16) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 2;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn write_i16(&mut self, n: i16) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 2;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn write_u32(&mut self, n: u32) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 4;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn write_i32(&mut self, n: i32) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 4;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn write_u64(&mut self, n: u64) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 8;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn write_i64(&mut self, n: i64) -> Result<(), io::Error> {
-        self.writer.write_all(&n.to_ne_bytes())?;
-        self.offset += 8;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &n.to_ne_bytes())?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn write_f32(&mut self, n: f32) -> Result<(), io::Error> {
-        self.writer.write_all(&u32::to_ne_bytes(n.to_bits()))?;
-        self.offset += 4;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &u32::to_ne_bytes(n.to_bits()))?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn write_f64(&mut self, n: f64) -> Result<(), io::Error> {
-        self.writer.write_all(&u64::to_ne_bytes(n.to_bits()))?;
-        self.offset += 8;
+        self.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &u64::to_ne_bytes(n.to_bits()))?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
@@ -142,7 +186,68 @@ impl<W: Write> TiffWriter<W> {
 impl<W: Seek> TiffWriter<W> {
     pub fn goto_offset(&mut self, offset: u64) -> Result<(), io::Error> {
         self.offset = offset;
-        self.writer.seek(SeekFrom::Start(offset as u64))?;
+        self.writer.seek(SeekFrom::Start(offset))?;
         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

@@ -1,260 +1,220 @@
-use std::error::Error;
-use std::fmt;
 use std::io;
 use std::str;
 use std::string;
 
-use crate::decoder::{ifd::Value, ChunkType};
+use quick_error::quick_error;
+
+use crate::decoder::ChunkType;
+use crate::tags::Type;
 use crate::tags::{
     CompressionMethod, PhotometricInterpretation, PlanarConfiguration, SampleFormat, Tag,
 };
 use crate::ColorType;
 
-/// Tiff error kinds.
-#[derive(Debug)]
-pub enum TiffError {
-    /// The Image is not formatted properly.
-    FormatError(TiffFormatError),
+quick_error! {
+    /// Tiff error kinds.
+    #[derive(Debug)]
+    pub enum TiffError {
+        /// The Image is not formatted properly.
+        FormatError(err: TiffFormatError) {
+            display("format error: {err}")
+            from()
+            source(err)
+        }
+        /// The Decoder does not support features required by the image.
+        UnsupportedError(err: TiffUnsupportedError) {
+            display("unsupported error: {err}")
+            from()
+            source(err)
+        }
+        /// An I/O Error occurred while decoding the image.
+        IoError(err: io::Error) {
+            display("{err}")
+            from()
+            source(err)
+        }
+        /// The Limits of the Decoder is exceeded.
+        LimitsExceeded {
+            display("decoder limits exceeded")
+        }
+        /// An integer conversion to or from a platform size failed.
+        IntSizeError {
+            display("platform or format size limits exceeded")
+        }
+        /// The image does not support the requested operation
+        UsageError(err: UsageError) {
+            display("usage error: {err}")
+            from()
+            source(err)
+        }
+    }
+}
 
+quick_error! {
+    /// The image is not formatted properly.
+    ///
+    /// This indicates that the encoder producing the image might behave incorrectly or that the
+    /// input file has been corrupted.
+    #[derive(Debug, Clone, PartialEq)]
+    #[non_exhaustive]
+    pub enum TiffFormatError {
+        TiffSignatureNotFound {
+            display("TIFF signature not found")
+        }
+        TiffSignatureInvalid {
+            display("TIFF signature invalid")
+        }
+        ImageFileDirectoryNotFound {
+            display("image file directory not found")
+        }
+        InconsistentSizesEncountered {
+            display("inconsistent sizes encountered")
+        }
+        InvalidDimensions(width: u32, height: u32) {
+            display("invalid dimensions: {width}x{height}")
+        }
+        InvalidTag {
+            display("image contains invalid tag")
+        }
+        InvalidTagValueType(tag: Tag) {
+            display("tag `{tag:?}` did not have the expected value type")
+        }
+        RequiredTagNotFound(tag: Tag) {
+            display("required tag `{tag:?}` not found")
+        }
+        UnknownPredictor(pred: u16) {
+            display("unknown predictor “{pred}” encountered")
+        }
+        UnknownPlanarConfiguration(cfg: u16) {
+            display("unknown planar configuration “{cfg}”")
+        }
+        InvalidTypeForTag {
+            display("tag has invalid type")
+        }
+        InvalidCountForTag(tag: Tag, len: usize) {
+            display("tag `{tag:?}` with incorrect number of elements ({len}) encountered")
+        }
+        StripTileTagConflict {
+            display("file should contain either (StripByteCounts and StripOffsets) or (TileByteCounts and TileOffsets), other combination was found")
+        }
+        CycleInOffsets {
+            display("file contained a cycle in the list of IFDs")
+        }
+        SamplesPerPixelIsZero {
+            display("samples per pixel is zero")
+        }
+        CompressedDataCorrupt(message: String) {
+            display("compressed data is corrupt: {message}")
+        }
+    }
+}
+
+quick_error! {
     /// The Decoder does not support features required by the image.
-    UnsupportedError(TiffUnsupportedError),
-
-    /// An I/O Error occurred while decoding the image.
-    IoError(io::Error),
-
-    /// The Limits of the Decoder is exceeded.
-    LimitsExceeded,
-
-    /// An integer conversion to or from a platform size failed, either due to
-    /// limits of the platform size or limits of the format.
-    IntSizeError,
-
-    /// The image does not support the requested operation
-    UsageError(UsageError),
-}
-
-/// The image is not formatted properly.
-///
-/// This indicates that the encoder producing the image might behave incorrectly or that the input
-/// file has been corrupted.
-///
-/// The list of variants may grow to incorporate errors of future features. Matching against this
-/// exhaustively is not covered by interface stability guarantees.
-#[derive(Debug, Clone, PartialEq)]
-pub enum TiffFormatError {
-    TiffSignatureNotFound,
-    TiffSignatureInvalid,
-    ImageFileDirectoryNotFound,
-    InconsistentSizesEncountered,
-    UnexpectedCompressedData {
-        actual_bytes: usize,
-        required_bytes: usize,
-    },
-    InconsistentStripSamples {
-        actual_samples: usize,
-        required_samples: usize,
-    },
-    InvalidTag,
-    InvalidTagValueType(Tag),
-    RequiredTagNotFound(Tag),
-    UnknownPredictor(u16),
-    ByteExpected(Value),
-    UnsignedIntegerExpected(Value),
-    SignedIntegerExpected(Value),
-    Format(String),
-    RequiredTagEmpty(Tag),
-    StripTileTagConflict,
-    CycleInOffsets,
-    #[doc(hidden)]
-    /// Do not match against this variant. It may get removed.
-    __NonExhaustive,
-}
-
-impl fmt::Display for TiffFormatError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        use self::TiffFormatError::*;
-        match *self {
-            TiffSignatureNotFound => write!(fmt, "TIFF signature not found."),
-            TiffSignatureInvalid => write!(fmt, "TIFF signature invalid."),
-            ImageFileDirectoryNotFound => write!(fmt, "Image file directory not found."),
-            InconsistentSizesEncountered => write!(fmt, "Inconsistent sizes encountered."),
-            UnexpectedCompressedData {
-                actual_bytes,
-                required_bytes,
-            } => {
-                write!(
-                    fmt,
-                    "Decompression returned different amount of bytes than expected: got {}, expected {}.",
-                    actual_bytes, required_bytes
-                )
-            }
-            InconsistentStripSamples {
-                actual_samples,
-                required_samples,
-            } => {
-                write!(
-                    fmt,
-                    "Inconsistent elements in strip: got {}, expected {}.",
-                    actual_samples, required_samples
-                )
-            }
-            InvalidTag => write!(fmt, "Image contains invalid tag."),
-            InvalidTagValueType(ref tag) => {
-                write!(fmt, "Tag `{:?}` did not have the expected value type.", tag)
-            }
-            RequiredTagNotFound(ref tag) => write!(fmt, "Required tag `{:?}` not found.", tag),
-            UnknownPredictor(ref predictor) => {
-                write!(fmt, "Unknown predictor “{}” encountered", predictor)
-            }
-            ByteExpected(ref val) => write!(fmt, "Expected byte, {:?} found.", val),
-            UnsignedIntegerExpected(ref val) => {
-                write!(fmt, "Expected unsigned integer, {:?} found.", val)
-            }
-            SignedIntegerExpected(ref val) => {
-                write!(fmt, "Expected signed integer, {:?} found.", val)
-            }
-            Format(ref val) => write!(fmt, "Invalid format: {:?}.", val),
-            RequiredTagEmpty(ref val) => write!(fmt, "Required tag {:?} was empty.", val),
-            StripTileTagConflict => write!(fmt, "File should contain either (StripByteCounts and StripOffsets) or (TileByteCounts and TileOffsets), other combination was found."),
-            CycleInOffsets => write!(fmt, "File contained a cycle in the list of IFDs"),
-            __NonExhaustive => unreachable!(),
+    ///
+    /// This only captures known failures for which the standard either does not require support or an
+    /// implementation has been planned but not yet completed. Some variants may become unused over
+    /// time and will then get deprecated before being removed.
+    #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+    #[non_exhaustive]
+    pub enum TiffUnsupportedError {
+        FloatingPointPredictor(color_type: ColorType) {
+            display("floating point predictor for {color_type:?} is unsupported")
+        }
+        HorizontalPredictor(color_type: ColorType) {
+            display("horizontal predictor for {color_type:?} is unsupported")
+        }
+        InconsistentBitsPerSample(bits_per_sample: Vec<u8>) {
+            display("inconsistent bits per sample: {bits_per_sample:?}")
+        }
+        InterpretationWithBits(interpretation: PhotometricInterpretation, bits_per_sample: Vec<u8>) {
+            display("Photometric interpretation {interpretation:?} with bits per sample {bits_per_sample:?} is unsupported")
+        }
+        UnknownInterpretation {
+            display("unknown photometric interpretation")
+        }
+        UnknownCompressionMethod {
+            display("unknown compression method")
+        }
+        UnsupportedCompressionMethod(method: CompressionMethod) {
+            display("compression method {method:?} is unsupported")
+        }
+        UnsupportedSampleDepth(depth: u8) {
+            display("{depth} samples per pixel is unsupported")
+        }
+        UnsupportedSampleFormat(sample_format: Vec<SampleFormat>) {
+            display("sample format {sample_format:?} is unsupported")
+        }
+        UnsupportedColorType(color_type: ColorType) {
+            display("color type {color_type:?} is unsupported")
+        }
+        UnsupportedBitsPerChannel(bits_per_channel: u8) {
+            display("{bits_per_channel} bits per channel not supported")
+        }
+        UnsupportedPlanarConfig(planar: Option<PlanarConfiguration>) {
+            display("unsupported planar configuration “{planar:?}”")
+        }
+        UnsupportedDataType {
+            display("unsupported data type.")
+        }
+        UnsupportedInterpretation(interpretation: PhotometricInterpretation) {
+            display("unsupported photometric interpretation \"{interpretation:?}\"")
+        }
+        ChromaSubsampling {
+            display("chroma subsampling of YCbCr color is unsupported")
+        }
+        MisalignedTileBoundaries {
+            display("tile rows are not aligned to byte boundaries")
         }
     }
 }
 
-/// The Decoder does not support features required by the image.
-///
-/// This only captures known failures for which the standard either does not require support or an
-/// implementation has been planned but not yet completed. Some variants may become unused over
-/// time and will then get deprecated before being removed.
-///
-/// The list of variants may grow. Matching against this exhaustively is not covered by interface
-/// stability guarantees.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum TiffUnsupportedError {
-    HorizontalPredictor(ColorType),
-    InterpretationWithBits(PhotometricInterpretation, Vec<u8>),
-    UnknownInterpretation,
-    UnknownCompressionMethod,
-    UnsupportedCompressionMethod(CompressionMethod),
-    UnsupportedSampleDepth(u8),
-    UnsupportedSampleFormat(Vec<SampleFormat>),
-    UnsupportedColorType(ColorType),
-    UnsupportedBitsPerChannel(u8),
-    UnsupportedPlanarConfig(Option<PlanarConfiguration>),
-    UnsupportedDataType,
-    #[doc(hidden)]
-    /// Do not match against this variant. It may get removed.
-    __NonExhaustive,
-}
-
-impl fmt::Display for TiffUnsupportedError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        use self::TiffUnsupportedError::*;
-        match *self {
-            HorizontalPredictor(color_type) => write!(
-                fmt,
-                "Horizontal predictor for {:?} is unsupported.",
-                color_type
-            ),
-            InterpretationWithBits(ref photometric_interpretation, ref bits_per_sample) => write!(
-                fmt,
-                "{:?} with {:?} bits per sample is unsupported",
-                photometric_interpretation, bits_per_sample
-            ),
-            UnknownInterpretation => write!(
-                fmt,
-                "The image is using an unknown photometric interpretation."
-            ),
-            UnknownCompressionMethod => write!(fmt, "Unknown compression method."),
-            UnsupportedCompressionMethod(method) => {
-                write!(fmt, "Compression method {:?} is unsupported", method)
-            }
-            UnsupportedSampleDepth(samples) => {
-                write!(fmt, "{} samples per pixel is unsupported.", samples)
-            }
-            UnsupportedSampleFormat(ref formats) => {
-                write!(fmt, "Sample format {:?} is unsupported.", formats)
-            }
-            UnsupportedColorType(color_type) => {
-                write!(fmt, "Color type {:?} is unsupported", color_type)
-            }
-            UnsupportedBitsPerChannel(bits) => {
-                write!(fmt, "{} bits per channel not supported", bits)
-            }
-            UnsupportedPlanarConfig(config) => {
-                write!(fmt, "Unsupported planar configuration “{:?}”.", config)
-            }
-            UnsupportedDataType => write!(fmt, "Unsupported data type."),
-            __NonExhaustive => unreachable!(),
+quick_error! {
+    /// User attempted to use the Decoder in a way that is incompatible with a specific image.
+    ///
+    /// For example: attempting to read a tile from a stripped image.
+    #[derive(Debug)]
+    #[non_exhaustive]
+    pub enum UsageError {
+        InvalidChunkType(expected: ChunkType, actual: ChunkType) {
+            display("requested operation is only valid for images with chunk encoding of type {expected:?} but got {actual:?}")
         }
-    }
-}
-
-/// User attempted to use the Decoder in a way that is incompatible with a specific image.
-///
-/// For example: attempting to read a tile from a stripped image.
-#[derive(Debug)]
-pub enum UsageError {
-    InvalidChunkType(ChunkType, ChunkType),
-}
-
-impl fmt::Display for UsageError {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use self::UsageError::*;
-        match *self {
-            InvalidChunkType(expected, actual) => {
-                write!(
-                    fmt,
-                    "Requested operation is only valid for images with chunk encoding of type: {:?}, got {:?}.",
-                    expected, actual
-                )
-            }
+        InvalidChunkIndex(index: u32) {
+            display("invalid chunk index ({index}) requested")
         }
-    }
-}
-
-impl fmt::Display for TiffError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        match *self {
-            TiffError::FormatError(ref e) => write!(fmt, "Format error: {}", e),
-            TiffError::UnsupportedError(ref f) => write!(
-                fmt,
-                "The Decoder does not support the \
-                 image format `{}`",
-                f
-            ),
-            TiffError::IoError(ref e) => e.fmt(fmt),
-            TiffError::LimitsExceeded => write!(fmt, "The Decoder limits are exceeded"),
-            TiffError::IntSizeError => write!(fmt, "Platform or format size limits exceeded"),
-            TiffError::UsageError(ref e) => write!(fmt, "Usage error: {}", e),
+        InvalidPlaneIndex(index: u16) {
+            display("invalid plane index ({index}) requested")
         }
-    }
-}
-
-impl Error for TiffError {
-    fn description(&self) -> &str {
-        match *self {
-            TiffError::FormatError(..) => "Format error",
-            TiffError::UnsupportedError(..) => "Unsupported error",
-            TiffError::IoError(..) => "IO error",
-            TiffError::LimitsExceeded => "Decoder limits exceeded",
-            TiffError::IntSizeError => "Platform or format size limits exceeded",
-            TiffError::UsageError(..) => "Invalid usage",
+        InvalidCodingUnit(index: u32, have: u32) {
+            display("out of bounds coding unit ({index}) requested, only {have} available")
         }
-    }
-
-    fn cause(&self) -> Option<&dyn Error> {
-        match *self {
-            TiffError::IoError(ref e) => Some(e),
-            _ => None,
+        PredictorCompressionMismatch {
+            display("requested predictor is not compatible with the requested compression")
+        }
+        PredictorIncompatible {
+            display("the requested predictor is not compatible with the image's format")
+        }
+        PredictorUnavailable {
+            display("the requested predictor is not available")
+        }
+        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")
+        }
+        ByteOrderMismatch {
+            display("attempted to use data with a byte order that does not match the required one")
+        }
+        MismatchedEntryLength {ty: Type, found: usize } {
+            display("the length of data is not a multiple of the size of the type {ty:?}, found {found}")
         }
-    }
-}
-
-impl From<io::Error> for TiffError {
-    fn from(err: io::Error) -> TiffError {
-        TiffError::IoError(err)
     }
 }
 
@@ -270,23 +230,25 @@ impl From<string::FromUtf8Error> for TiffError {
     }
 }
 
-impl From<TiffFormatError> for TiffError {
-    fn from(err: TiffFormatError) -> TiffError {
-        TiffError::FormatError(err)
-    }
-}
-
-impl From<TiffUnsupportedError> for TiffError {
-    fn from(err: TiffUnsupportedError) -> TiffError {
-        TiffError::UnsupportedError(err)
-    }
-}
-
 impl From<std::num::TryFromIntError> for TiffError {
     fn from(_err: std::num::TryFromIntError) -> TiffError {
         TiffError::IntSizeError
     }
 }
 
+#[cfg(feature = "lzw")]
+impl From<weezl::LzwError> for TiffError {
+    fn from(err: weezl::LzwError) -> TiffError {
+        TiffError::FormatError(TiffFormatError::CompressedDataCorrupt(err.to_string()))
+    }
+}
+
+#[cfg(feature = "jpeg")]
+impl From<zune_jpeg::errors::DecodeErrors> for TiffError {
+    fn from(err: zune_jpeg::errors::DecodeErrors) -> Self {
+        TiffError::FormatError(TiffFormatError::CompressedDataCorrupt(err.to_string()))
+    }
+}
+
 /// Result of an image decoding/encoding process
 pub type TiffResult<T> = Result<T, TiffError>;

src/lib.rs

@@ -4,21 +4,21 @@
 //! lossless and lossy compression.
 //!
 //! # Related Links
-//! * <https://www.adobe.io/open/standards/TIFF.html> - The TIFF specification
-
-extern crate jpeg;
-extern crate weezl;
+//! * <https://web.archive.org/web/20210108073850/https://www.adobe.io/open/standards/TIFF.html> - The TIFF specification
 
 mod bytecast;
 pub mod decoder;
+mod directory;
 pub mod encoder;
 mod error;
 pub mod tags;
 
+pub use self::directory::Directory;
 pub use self::error::{TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError};
 
 /// An enumeration over supported color types and their bit depths
 #[derive(Copy, PartialEq, Eq, Debug, Clone, Hash)]
+#[non_exhaustive]
 pub enum ColorType {
     /// Pixel is grayscale
     Gray(u8),
@@ -37,4 +37,47 @@ pub enum ColorType {
 
     /// Pixel is CMYK
     CMYK(u8),
+
+    /// Pixel is CMYK with an alpha channel
+    CMYKA(u8),
+
+    /// Pixel is YCbCr
+    YCbCr(u8),
+
+    /// Pixel is CIE L*a*b* (ICC LAb)
+    Lab(u8),
+
+    /// Pixel has multiple bands/channels
+    Multiband { bit_depth: u8, num_samples: u16 },
+}
+impl ColorType {
+    fn bit_depth(&self) -> u8 {
+        match *self {
+            ColorType::Gray(b)
+            | ColorType::RGB(b)
+            | ColorType::Palette(b)
+            | ColorType::GrayA(b)
+            | ColorType::RGBA(b)
+            | ColorType::CMYK(b)
+            | ColorType::CMYKA(b)
+            | ColorType::YCbCr(b)
+            | ColorType::Lab(b)
+            | 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::Lab(_) => 3,
+            ColorType::Multiband { num_samples, .. } => num_samples,
+        }
+    }
 }

src/tags.rs

@@ -1,28 +1,29 @@
+use crate::encoder::TiffValue;
+
 macro_rules! tags {
     {
         // Permit arbitrary meta items, which include documentation.
         $( #[$enum_attr:meta] )*
-        $vis:vis enum $name:ident($ty:tt) $(unknown($unknown_doc:literal))* {
+        $vis:vis enum $name:ident($ty:tt) $(unknown(#[$unknown_meta:meta] $unknown_doc:ident))* {
             // Each of the `Name = Val,` permitting documentation.
             $($(#[$ident_attr:meta])* $tag:ident = $val:expr,)*
         }
     } => {
         $( #[$enum_attr] )*
         #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+        #[non_exhaustive]
+        #[repr($ty)]
         pub enum $name {
-            $($(#[$ident_attr])* $tag,)*
-            // FIXME: switch to non_exhaustive once stabilized and compiler requirement new enough
-            #[doc(hidden)]
-            __NonExhaustive,
+            $($(#[$ident_attr])* $tag = $val,)*
             $(
-                #[doc = $unknown_doc]
+                #[$unknown_meta]
                 Unknown($ty),
             )*
         }
 
         impl $name {
             #[inline(always)]
-            fn __from_inner_type(n: $ty) -> Result<Self, $ty> {
+            const fn __from_inner_type(n: $ty) -> Result<Self, $ty> {
                 match n {
                     $( $val => Ok($name::$tag), )*
                     n => Err(n),
@@ -30,11 +31,10 @@ macro_rules! tags {
             }
 
             #[inline(always)]
-            fn __to_inner_type(&self) -> $ty {
+            const fn __to_inner_type(&self) -> $ty {
                 match *self {
                     $( $name::$tag => $val, )*
-                    $( $name::Unknown(n) => { $unknown_doc; n }, )*
-                    $name::__NonExhaustive => unreachable!(),
+                    $( $name::Unknown($unknown_doc) => { $unknown_doc }, )*
                 }
             }
         }
@@ -42,23 +42,28 @@ macro_rules! tags {
         tags!($name, $ty, $($unknown_doc)*);
     };
     // For u16 tags, provide direct inherent primitive conversion methods.
-    ($name:tt, u16, $($unknown_doc:literal)*) => {
+    ($name:tt, u16, $($unknown_doc:ident)*) => {
         impl $name {
             #[inline(always)]
-            pub fn from_u16(val: u16) -> Option<Self> {
-                Self::__from_inner_type(val).ok()
+            pub const fn from_u16(val: u16) -> Option<Self> {
+                match Self::__from_inner_type(val) {
+                    Ok(v) => Some(v),
+                    Err(_) => None,
+                }
             }
 
             $(
             #[inline(always)]
-            pub fn from_u16_exhaustive(val: u16) -> Self {
-                $unknown_doc;
-                Self::__from_inner_type(val).unwrap_or_else(|_| $name::Unknown(val))
+            pub const fn from_u16_exhaustive($unknown_doc: u16) -> Self {
+                match Self::__from_inner_type($unknown_doc) {
+                    Ok(v) => v,
+                    Err(_) => $name::Unknown($unknown_doc),
+                }
             }
             )*
 
             #[inline(always)]
-            pub fn to_u16(&self) -> u16 {
+            pub const fn to_u16(&self) -> u16 {
                 Self::__to_inner_type(self)
             }
         }
@@ -71,7 +76,10 @@ macro_rules! tags {
 // Note: These tags appear in the order they are mentioned in the TIFF reference
 tags! {
 /// TIFF tags
-pub enum Tag(u16) unknown("A private or extension tag") {
+pub enum Tag(u16) unknown(
+    /// A private or extension tag
+    unknown
+) {
     // Baseline tags:
     Artist = 315,
     // grayscale images PhotometricInterpretation 1 or 3
@@ -81,7 +89,6 @@ pub enum Tag(u16) unknown("A private or extension tag") {
     // palette-color images (PhotometricInterpretation 3)
     ColorMap = 320, // TODO add support
     Compression = 259, // TODO add support for 2 and 32773
-    Copyright = 33_432,
     DateTime = 306,
     ExtraSamples = 338, // TODO add support
     FillOrder = 266, // TODO add support
@@ -117,23 +124,51 @@ pub enum Tag(u16) unknown("A private or extension tag") {
     TileLength = 323,
     TileOffsets = 324,
     TileByteCounts = 325,
+    SubIfd = 330,
     // Data Sample Format
     SampleFormat = 339,
     SMinSampleValue = 340, // TODO add support
     SMaxSampleValue = 341, // TODO add support
     // JPEG
     JPEGTables = 347,
+    // Subsampling
+    #[doc(alias = "YCbCrSubsampling")]
+    ChromaSubsampling = 530, // TODO add support
+    #[doc(alias = "YCbCrPositioning")]
+    ChromaPositioning = 531, // TODO add support
     // GeoTIFF
     ModelPixelScaleTag = 33550, // (SoftDesk)
     ModelTransformationTag = 34264, // (JPL Carto Group)
     ModelTiepointTag = 33922, // (Intergraph)
+    // <https://web.archive.org/web/20131111073619/http://www.exif.org/Exif2-1.PDF>
+    // *Do note its typo in the Decimal id*
+    Copyright = 33_432,
+    // <https://web.archive.org/web/20131111073619/http://www.exif.org/Exif2-1.PDF>
+    ExifDirectory = 0x8769,
+    // <https://web.archive.org/web/20131111073619/http://www.exif.org/Exif2-1.PDF>
+    GpsDirectory = 0x8825,
+    // <https://www.color.org/technotes/ICC-Technote-ProfileEmbedding.pdf>
+    IccProfile = 34675,
     GeoKeyDirectoryTag = 34735, // (SPOT)
     GeoDoubleParamsTag = 34736, // (SPOT)
     GeoAsciiParamsTag = 34737, // (SPOT)
+    ExifVersion = 0x9000,
     GdalNodata = 42113, // Contains areas with missing data
 }
 }
 
+/// Identifies the offset of an IFD.
+///
+/// This is represented as a 64-bit integer but only BigTIFF can utilize the bits. It is encoded
+/// as 32-bit unsigned value ([`Type::LONG`]) in regular TIFF files and as 64-bit unsigned value
+/// ([`Type::IFD8`]) in BigTIFF files.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+// We could be using `NonZeroU64` here but I find that this complicates semantics. This type
+// represents the integer value stored as a value in a tag. The semantics of treating `0` as an end
+// marker are imposed by the IFD. (It's unclear if Pointer tags such as Exif would allow `0` but in
+// practice it just returns garbage and the validity does not matter greatly to us).
+pub struct IfdPointer(pub u64);
+
 tags! {
 /// The type of an IFD entry (a 2 byte field).
 pub enum Type(u16) {
@@ -172,10 +207,52 @@ 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.
-pub enum CompressionMethod(u16) {
+pub enum CompressionMethod(u16) unknown(
+    /// A custom compression method
+    unknown
+) {
     None = 1,
     Huffman = 2,
     Fax3 = 3,
@@ -187,6 +264,9 @@ pub enum CompressionMethod(u16) {
     Deflate = 8,
     OldDeflate = 0x80B2,
     PackBits = 0x8005,
+
+    // Self-assigned by libtiff
+    ZSTD = 0xC350,
 }
 }
 
@@ -200,6 +280,8 @@ pub enum PhotometricInterpretation(u16) {
     CMYK = 5,
     YCbCr = 6,
     CIELab = 8,
+    IccLab = 9,
+    ItuLab = 10,
 }
 }
 
@@ -212,8 +294,15 @@ pub enum PlanarConfiguration(u16) {
 
 tags! {
 pub enum Predictor(u16) {
+    /// No changes were made to the data
     None = 1,
+    /// The images' rows were processed to contain the difference of each pixel from the previous one.
+    ///
+    /// This means that instead of having in order `[r1, g1. b1, r2, g2 ...]` you will find
+    /// `[r1, g1, b1, r2-r1, g2-g1, b2-b1, r3-r2, g3-g2, ...]`
     Horizontal = 2,
+    /// Not currently supported
+    FloatingPoint = 3,
 }
 }
 
@@ -227,10 +316,276 @@ pub enum ResolutionUnit(u16) {
 }
 
 tags! {
-pub enum SampleFormat(u16) unknown("An unknown extension sample format") {
+pub enum SampleFormat(u16) unknown(
+    /// An unknown extension sample format
+    unknown
+) {
     Uint = 1,
     Int = 2,
     IEEEFP = 3,
     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,
+}
+}
+
+/// A value represented as in-memory bytes with flexible byteorder.
+pub struct ValueBuffer {
+    /// The raw bytes of the value.
+    bytes: Vec<u8>,
+
+    /// The type of the value.
+    ty: Type,
+
+    /// The number of items, as `bytes` may be oversized while holding bytes that are initialized
+    /// but not used by any value.
+    count: u64,
+
+    /// The byte order of the value.
+    byte_order: ByteOrder,
+}
+
+impl ValueBuffer {
+    /// A value with a count of zero.
+    ///
+    /// The byte order is set to the native byte order of the platform.
+    pub fn empty(ty: Type) -> Self {
+        ValueBuffer {
+            bytes: vec![],
+            ty,
+            count: 0,
+            byte_order: ByteOrder::native(),
+        }
+    }
+
+    /// Create a value with native byte order from in-memory data.
+    pub fn from_value<T: TiffValue>(value: &T) -> Self {
+        ValueBuffer {
+            bytes: value.data().into_owned(),
+            ty: <T as TiffValue>::FIELD_TYPE,
+            count: value.count() as u64,
+            byte_order: ByteOrder::native(),
+        }
+    }
+
+    pub fn byte_order(&self) -> ByteOrder {
+        self.byte_order
+    }
+
+    pub fn data_type(&self) -> Type {
+        self.ty
+    }
+
+    /// The count of items in the value.
+    pub fn count(&self) -> u64 {
+        debug_assert!({
+            self.ty
+                .value_bytes(self.count)
+                .is_ok_and(|n| n <= self.bytes.len() as u64)
+        });
+
+        self.count
+    }
+
+    /// View the underlying raw bytes of this value.
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.bytes[..self.assumed_len_from_count()]
+    }
+
+    /// View the underlying mutable raw bytes of this value.
+    pub fn as_bytes_mut(&mut self) -> &mut [u8] {
+        let len = self.assumed_len_from_count();
+        &mut self.bytes[..len]
+    }
+
+    /// See [`Value::into_ifd_pointer`](crate::decoder::ifd::Value::into_ifd_pointer).
+    pub(crate) fn as_ifd_pointer(&self) -> Option<IfdPointer> {
+        if self.count != 1 {
+            return None;
+        }
+
+        match self.ty {
+            // See [`ifd::Value::into_ifd_pointer`] there is enough legacy that uses `LONG` to
+            // refer to an offset into the file with the meaning of a directory pointer. That is
+            // rather annoying but legacy and not a big deal.
+            Type::IFD | Type::LONG => {
+                let mut buf = [0u8; 4];
+                buf.copy_from_slice(&self.bytes[..4]);
+                ByteOrder::native().convert(Type::IFD, &mut buf, self.byte_order);
+                Some(IfdPointer(u32::from_ne_bytes(buf).into()))
+            }
+            Type::IFD8 => {
+                let mut buf = [0u8; 8];
+                buf.copy_from_slice(&self.bytes[..8]);
+                ByteOrder::native().convert(Type::IFD8, &mut buf, self.byte_order);
+                Some(IfdPointer(u64::from_ne_bytes(buf)))
+            }
+            _ => None,
+        }
+    }
+
+    /// Change the byte order of the value representation.
+    pub fn set_byte_order(&mut self, byte_order: ByteOrder) {
+        let len = self.assumed_len_from_count();
+
+        self.byte_order
+            .convert(self.ty, &mut self.bytes[..len], byte_order);
+
+        self.byte_order = byte_order;
+    }
+
+    /// Prepare the internal for a value `to_len` bytes long.
+    ///
+    /// Shrinks the allocation if it is far too large or extends it if it is too small. In either
+    /// case ensures that at least `to_len` bytes are initialized for [`Self::raw_bytes_mut`].
+    pub(crate) fn prepare_length(&mut self, to_len: usize) {
+        if to_len > self.bytes.len() {
+            self.bytes.resize(to_len, 0);
+        }
+
+        if self.bytes.len() < to_len / 2 {
+            self.bytes.truncate(to_len);
+            self.bytes.shrink_to_fit();
+        }
+    }
+
+    /// Internal method to change the type and count while re-interpreting the byte buffer.
+    ///
+    /// Should only be called after writing bytes to the internal buffer prepared with
+    /// `Self::prepare_length`.
+    pub(crate) fn assume_type(&mut self, ty: Type, count: u64, bo: ByteOrder) {
+        debug_assert!({
+            ty.value_bytes(count)
+                .is_ok_and(|n| n <= self.bytes.len() as u64)
+        });
+
+        self.byte_order = bo;
+        self.ty = ty;
+        self.count = count;
+    }
+
+    pub(crate) fn raw_bytes_mut(&mut self) -> &mut [u8] {
+        &mut self.bytes
+    }
+
+    fn assumed_len_from_count(&self) -> usize {
+        usize::from(self.ty.byte_len()) * self.count as usize
+    }
+}
+
+/// 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,
+}
+
+#[test]
+fn convert_ifd_u32() {
+    let mut value = ValueBuffer::from_value(&crate::encoder::Ifd(0x42));
+
+    for bo in [ByteOrder::BigEndian, ByteOrder::LittleEndian] {
+        value.set_byte_order(bo);
+
+        let ptr = value
+            .as_ifd_pointer()
+            .expect("Should be convertible to IfdPointer");
+
+        // Should be in host byte order again.
+        assert_eq!(ptr.0, 0x42);
+    }
+}
+
+#[test]
+fn convert_ifd_long8() {
+    let mut value = ValueBuffer::from_value(&crate::encoder::Ifd8(0x42));
+
+    for bo in [ByteOrder::BigEndian, ByteOrder::LittleEndian] {
+        value.set_byte_order(bo);
+
+        let ptr = value
+            .as_ifd_pointer()
+            .expect("Should be convertible to IfdPointer");
+
+        // Should be in host byte order again.
+        assert_eq!(ptr.0, 0x42);
+    }
+}

tests/COPYRIGHT

@@ -0,0 +1,4 @@
+subsubifd.tif:
+  url: https://data.kitware.com/api/v1/file/hashsum/sha512/372ca32735c8a8fdbe2286dabead9e779da63f10ba81eda84625e5273f76d74ca1a47a978f67e9c00c12f7f72009c7b2c07a641e643bb0c463812f4ae7f15d6e/download
+  credit: https://github.com/DigitalSlideArchive/tifftools/commit/4d00c70dbce828262f86c1431f7c66b1748965ac
+  license: CC0

tests/decode_fp16_images.rs

@@ -0,0 +1,195 @@
+extern crate tiff;
+
+use tiff::decoder::{Decoder, DecodingResult};
+use tiff::ColorType;
+
+use std::fs::File;
+use std::path::PathBuf;
+
+const TEST_IMAGE_DIR: &str = "./tests/images/";
+
+/// Test a basic all white image
+#[test]
+fn test_white_ieee_fp16() {
+    let filenames = ["white-fp16.tiff"];
+
+    for filename in filenames.iter() {
+        let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
+        let img_file = File::open(path).expect("Cannot find test image!");
+        let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+        if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
+            for p in img {
+                assert!(p == half::f16::from_f32_const(1.0));
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+/// Test a single black pixel, to make sure scaling is ok
+#[test]
+fn test_one_black_pixel_ieee_fp16() {
+    let filenames = ["single-black-fp16.tiff"];
+
+    for filename in filenames.iter() {
+        let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
+        let img_file = File::open(path).expect("Cannot find test image!");
+        let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+        if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
+            for (i, p) in img.iter().enumerate() {
+                if i == 0 {
+                    assert!(p < &half::f16::from_f32_const(0.001));
+                } else {
+                    assert!(p == &half::f16::from_f32_const(1.0));
+                }
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+/// Test white with horizontal differencing predictor
+#[test]
+fn test_pattern_horizontal_differencing_ieee_fp16() {
+    let filenames = ["white-fp16-pred2.tiff"];
+
+    for filename in filenames.iter() {
+        let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
+        let img_file = File::open(path).expect("Cannot find test image!");
+        let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+        if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
+            // 0, 2, 5, 8, 12, 16, 255 are black
+            let black = [0, 2, 5, 8, 12, 16, 255];
+            for (i, p) in img.iter().enumerate() {
+                if black.contains(&i) {
+                    assert!(p < &half::f16::from_f32_const(0.001));
+                } else {
+                    assert!(p == &half::f16::from_f32_const(1.0));
+                }
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+/// Test white with floating point predictor
+#[test]
+fn test_pattern_predictor_ieee_fp16() {
+    let filenames = ["white-fp16-pred3.tiff"];
+
+    for filename in filenames.iter() {
+        let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
+        let img_file = File::open(path).expect("Cannot find test image!");
+        let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+        if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
+            // 0, 2, 5, 8, 12, 16, 255 are black
+            let black = [0, 2, 5, 8, 12, 16, 255];
+            for (i, p) in img.iter().enumerate() {
+                if black.contains(&i) {
+                    assert!(p < &half::f16::from_f32_const(0.001));
+                } else {
+                    assert!(p == &half::f16::from_f32_const(1.0));
+                }
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+/// Test several random images
+/// we'rell compare against a pnm file, that scales from 0 (for 0.0) to 65767 (for 1.0)
+#[test]
+fn test_predictor_ieee_fp16() {
+    // first parse pnm, skip the first 4 \n
+    let pnm_path = PathBuf::from(TEST_IMAGE_DIR).join("random-fp16.pgm");
+    let pnm_bytes = std::fs::read(pnm_path).expect("Failed to read expected PNM file");
+
+    // PGM looks like this:
+    // ---
+    // P5
+    // #Created with GIMP
+    // 16 16
+    // 65535
+    // ... <big-endian bytes>
+    // ---
+    // get index of 4th \n
+    let byte_start = pnm_bytes
+        .iter()
+        .enumerate()
+        .filter(|(_, &v)| v == b'\n')
+        .map(|(i, _)| i)
+        .nth(3)
+        .expect("Must be 4 \\n's");
+
+    let pnm_values: Vec<f32> = pnm_bytes[(byte_start + 1)..]
+        .chunks(2)
+        .map(|slice| {
+            let bts = [slice[0], slice[1]];
+            (u16::from_be_bytes(bts) as f32) / (u16::MAX as f32)
+        })
+        .collect();
+    assert!(pnm_values.len() == 256);
+
+    let filenames = [
+        "random-fp16-pred2.tiff",
+        "random-fp16-pred3.tiff",
+        "random-fp16.tiff",
+    ];
+
+    for filename in filenames.iter() {
+        let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
+        let img_file = File::open(path).expect("Cannot find test image!");
+        let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (16, 16)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+        if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
+            for (exp, found) in std::iter::zip(pnm_values.iter(), img.iter()) {
+                assert!((exp - found.to_f32()).abs() < 0.0001);
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}

tests/decode_geotiff_images.rs

@@ -0,0 +1,63 @@
+extern crate tiff;
+
+use tiff::decoder::{Decoder, DecodingResult};
+use tiff::tags::Tag;
+use tiff::ColorType;
+
+use std::fs::File;
+use std::path::PathBuf;
+
+const TEST_IMAGE_DIR: &str = "./tests/images";
+
+#[test]
+fn test_geo_tiff() {
+    let filenames = ["geo-5b.tif"];
+    for filename in filenames.iter() {
+        let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
+        let img_file = File::open(path).expect("Cannot find test image!");
+        let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+        decoder = decoder.with_limits(tiff::decoder::Limits::unlimited());
+
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (10, 10)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Multiband {
+                bit_depth: 16,
+                num_samples: 5
+            }
+        );
+        assert_eq!(
+            decoder
+                .get_tag_u64(Tag::StripOffsets)
+                .expect("Cannot get StripOffsets"),
+            418
+        );
+        assert_eq!(
+            decoder
+                .get_tag_u64(Tag::RowsPerStrip)
+                .expect("Cannot get RowsPerStrip"),
+            10
+        );
+        assert_eq!(
+            decoder
+                .get_tag_u64(Tag::StripByteCounts)
+                .expect("Cannot get StripByteCounts"),
+            1000
+        );
+        assert_eq!(
+            decoder
+                .get_tag(Tag::ModelPixelScaleTag)
+                .expect("Cannot get pixel scale")
+                .into_f64_vec()
+                .expect("Cannot get pixel scale"),
+            vec![60.0, 60.0, 0.0]
+        );
+        let DecodingResult::I16(data) = decoder.read_image().unwrap() else {
+            panic!("Cannot read band data")
+        };
+        assert_eq!(data.len(), 500);
+    }
+}

tests/decode_images.rs

@@ -4,6 +4,7 @@ use tiff::decoder::{ifd, Decoder, DecodingResult};
 use tiff::ColorType;
 
 use std::fs::File;
+use std::io::{Read, Seek};
 use std::path::PathBuf;
 
 const TEST_IMAGE_DIR: &str = "./tests/images/";
@@ -45,12 +46,12 @@ fn test_image_color_type_unsupported(file: &str, expected_type: ColorType) {
     let img_file = File::open(path).expect("Cannot find test image!");
     let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
     assert_eq!(decoder.colortype().unwrap(), expected_type);
-    assert!(match decoder.read_image() {
+    assert!(matches!(
+        decoder.read_image(),
         Err(tiff::TiffError::UnsupportedError(
             tiff::TiffUnsupportedError::UnsupportedColorType(_),
-        )) => true,
-        _ => false,
-    });
+        ))
+    ));
 }
 
 #[test]
@@ -172,7 +173,7 @@ fn test_string_tags() {
                 &s,
                 "GraphicsMagick 1.2 unreleased Q16 http://www.GraphicsMagick.org/"
             ),
-            _ => assert!(false),
+            other => unreachable!("Expected Ascii tag from file, got {other:?}"),
         };
     }
 }
@@ -216,6 +217,11 @@ fn issue_69() {
 //assert!(img_res.is_ok());
 //}
 
+#[test]
+fn test_tiled_gray_i1() {
+    test_image_sum_u8("tiled-gray-i1.tif", ColorType::Gray(1), 30531);
+}
+
 #[test]
 fn test_tiled_rgb_u8() {
     test_image_sum_u8("tiled-rgb-u8.tif", ColorType::RGB(8), 39528948);
@@ -226,6 +232,54 @@ fn test_tiled_rect_rgb_u8() {
     test_image_sum_u8("tiled-rect-rgb-u8.tif", ColorType::RGB(8), 62081032);
 }
 
+#[test]
+fn test_inner_access() {
+    let path = PathBuf::from(TEST_IMAGE_DIR).join("tiled-rect-rgb-u8.tif");
+    let img_file = File::open(path).expect("Cannot find test image!");
+    let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+    assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
+
+    let c = decoder
+        .get_tag(tiff::tags::Tag::Compression)
+        .unwrap()
+        .into_u16()
+        .unwrap();
+    assert_eq!(c, tiff::tags::CompressionMethod::None.to_u16());
+
+    // Because the image is uncompressed, reading the first tile directly with the inner reader
+    // should yield the same result as reading it with the decoder's read_chunk method.
+    let first_offset = decoder
+        .get_tag_u32_vec(tiff::tags::Tag::TileOffsets)
+        .unwrap()
+        .into_iter()
+        .next()
+        .unwrap();
+    let first_byte_count = decoder
+        .get_tag_u32_vec(tiff::tags::Tag::TileByteCounts)
+        .unwrap()
+        .into_iter()
+        .next()
+        .unwrap();
+    decoder
+        .inner()
+        .seek(std::io::SeekFrom::Start(first_offset as u64))
+        .expect("Cannot seek to tile offset");
+    let mut buf = vec![0; first_byte_count as usize];
+    decoder
+        .inner()
+        .read_exact(&mut buf)
+        .expect("Cannot read tile data");
+    let raw_sum: u64 = buf.into_iter().map(<u64>::from).sum();
+
+    match decoder.read_chunk(0).unwrap() {
+        DecodingResult::U8(chunk) => {
+            let sum: u64 = chunk.into_iter().map(<u64>::from).sum();
+            assert_eq!(sum, raw_sum);
+        }
+        _ => panic!("Wrong bit depth"),
+    }
+}
+
 /* #[test]
 fn test_tiled_jpeg_rgb_u8() {
     test_image_sum_u8("tiled-jpeg-rgb-u8.tif", ColorType::RGB(8), 93031606);
@@ -275,7 +329,7 @@ fn test_tiled_incremental() {
     assert_eq!(tiles as usize, sums.len());
 
     for tile in 0..tiles {
-        match decoder.read_tile().unwrap() {
+        match decoder.read_chunk(tile).unwrap() {
             DecodingResult::U8(res) => {
                 let sum: u64 = res.into_iter().map(<u64>::from).sum();
                 assert_eq!(sum, sums[tile as usize]);
@@ -285,6 +339,51 @@ fn test_tiled_incremental() {
     }
 }
 
+#[test]
+fn test_planar_rgb_u8() {
+    test_image_sum_u8("planar-rgb-u8.tif", ColorType::RGB(8), 15417630);
+}
+
+#[test]
+fn test_read_planar_bands() {
+    // gdal_translate tiled-rgb-u8.tif planar-rgb-u8.tif -co INTERLEAVE=BAND -co COMPRESS=LZW -co PROFILE=BASELINE
+    let file = "planar-rgb-u8.tif";
+    let expected_type = ColorType::RGB(8);
+
+    let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
+    let img_file = File::open(path).expect("Cannot find test image!");
+    let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+    assert_eq!(decoder.colortype().unwrap(), expected_type);
+
+    let chunks = decoder.strip_count().unwrap();
+    assert_eq!(chunks as usize, 72);
+
+    // convert -quiet planar-rgb-u8.tif[0] -crop 1x1+0+0 txt:
+    // 0,0: (73,51,30)  #49331E  srgb(73,51,30)
+
+    // 1st band (red)
+    match decoder.read_chunk(0).unwrap() {
+        DecodingResult::U8(chunk) => {
+            assert_eq!(chunk[0], 73);
+        }
+        _ => panic!("Wrong bit depth"),
+    }
+    // 2nd band (green)
+    match decoder.read_chunk(chunks / 3).unwrap() {
+        DecodingResult::U8(chunk) => {
+            assert_eq!(chunk[0], 51);
+        }
+        _ => panic!("Wrong bit depth"),
+    }
+    // 3rd band (blue)
+    match decoder.read_chunk(chunks / 3 * 2).unwrap() {
+        DecodingResult::U8(chunk) => {
+            assert_eq!(chunk[0], 30);
+        }
+        _ => panic!("Wrong bit depth"),
+    }
+}
+
 #[test]
 fn test_div_zero() {
     use tiff::{TiffError, TiffFormatError};
@@ -301,7 +400,7 @@ fn test_div_zero() {
 
     match err {
         TiffError::FormatError(TiffFormatError::StripTileTagConflict) => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
+        unexpected => panic!("Unexpected error {unexpected}"),
     }
 }
 
@@ -319,12 +418,12 @@ fn test_too_many_value_bytes() {
 
     match error {
         tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
+        unexpected => panic!("Unexpected error {unexpected}"),
     }
 }
 
 #[test]
-fn test_bad_strip_count() {
+fn fuzzer_testcase5() {
     let image = [
         73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 100, 0, 0, 0, 1, 1, 4, 0, 1, 0, 0,
         0, 158, 0, 0, 251, 3, 1, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,
@@ -333,18 +432,11 @@ fn test_bad_strip_count() {
         178, 178, 178,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::IntSizeError => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
-fn test_too_big_buffer_size() {
+fn fuzzer_testcase1() {
     let image = [
         73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 99, 255, 255, 254, 1, 1, 4, 0, 1,
         0, 0, 0, 158, 0, 0, 251, 3, 1, 3, 255, 254, 255, 255, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0,
@@ -353,18 +445,11 @@ fn test_too_big_buffer_size() {
         178,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
-fn test_stripped_image_overflow() {
+fn fuzzer_testcase6() {
     let image = [
         73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 100, 0, 0, 148, 1, 1, 4, 0, 1, 0,
         0, 0, 158, 0, 0, 251, 3, 1, 3, 255, 254, 255, 255, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0,
@@ -373,14 +458,7 @@ fn test_stripped_image_overflow() {
         178, 178,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
@@ -392,18 +470,11 @@ fn oom() {
         0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 178, 48, 178, 178, 178, 178, 162, 178,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
-fn oom_2() {
+fn fuzzer_testcase4() {
     let image = [
         73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 40, 1, 0, 0,
         0, 158, 0, 0, 251, 3, 1, 3, 0, 1, 0, 0, 0, 5, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,
@@ -411,21 +482,11 @@ fn oom_2() {
         0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 48, 178, 178, 178, 0, 1, 0, 13, 13,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
-fn invalid_jpeg_tag() {
-    use tiff::tags;
-    use tiff::{TiffError, TiffFormatError};
-
+fn fuzzer_testcase2() {
     let image = [
         73, 73, 42, 0, 8, 0, 0, 0, 15, 0, 0, 254, 44, 1, 0, 0, 0, 0, 0, 32, 0, 0, 0, 1, 4, 0, 1, 0,
         0, 0, 0, 1, 0, 0, 91, 1, 1, 0, 0, 0, 0, 0, 242, 4, 0, 0, 0, 22, 0, 56, 77, 0, 77, 1, 0, 0,
@@ -437,21 +498,11 @@ fn invalid_jpeg_tag() {
         73,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        TiffError::FormatError(TiffFormatError::InvalidTagValueType(tags::Tag::JPEGTables)) => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
 fn invalid_jpeg_tag_2() {
-    use tiff::tags;
-    use tiff::{TiffError, TiffFormatError};
-
     let image = [
         73, 73, 42, 0, 8, 0, 0, 0, 16, 0, 254, 0, 4, 0, 1, 0, 0, 0, 0, 0, 0, 242, 0, 1, 4, 0, 1, 0,
         0, 0, 0, 129, 16, 0, 1, 1, 4, 0, 1, 0, 0, 0, 214, 0, 0, 248, 253, 1, 3, 0, 1, 0, 0, 0, 64,
@@ -463,20 +514,11 @@ fn invalid_jpeg_tag_2() {
         0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 36, 73, 73, 0, 42, 36, 36, 36, 36, 0, 0, 8, 0,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        TiffError::FormatError(TiffFormatError::InvalidTagValueType(tags::Tag::JPEGTables)) => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
-fn multiple_images_strip_height() {
-    use tiff::TiffError;
-
+fn fuzzer_testcase3() {
     let image = [
         73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 2, 0, 0, 0, 61, 1, 9, 0, 46, 22,
         128, 0, 0, 0, 0, 1, 6, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 17, 1, 4, 0, 27, 0, 0, 0, 0, 0, 0,
@@ -485,15 +527,7 @@ fn multiple_images_strip_height() {
         255, 255,
     ];
 
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let _ = decoder.read_image().unwrap();
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        TiffError::IntSizeError => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
+    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
 }
 
 #[test]
@@ -515,7 +549,7 @@ fn timeout() {
 
     match error {
         TiffError::FormatError(TiffFormatError::CycleInOffsets) => {}
-        e => panic!("Unexpected error {:?}", e),
+        e => panic!("Unexpected error {e:?}"),
     }
 }
 
@@ -523,3 +557,166 @@ fn timeout() {
 fn test_no_rows_per_strip() {
     test_image_sum_u8("no_rows_per_strip.tiff", ColorType::RGB(8), 99448840);
 }
+
+#[test]
+fn test_predictor_3_rgb_f32() {
+    test_image_sum_f32("predictor-3-rgb-f32.tif", ColorType::RGB(32), 54004.33);
+}
+
+#[test]
+fn test_predictor_3_gray_f32() {
+    test_image_sum_f32("predictor-3-gray-f32.tif", ColorType::Gray(32), 20008.275);
+}
+
+#[test]
+#[cfg(feature = "zstd")]
+fn test_zstd_compression() {
+    // gdal_translate -co COMPRESS=ZSTD -co ZSTD_LEVEL=20 int16.tif int16_zstd.tif
+    test_image_sum_i16("int16_zstd.tif", ColorType::Gray(16), 354396);
+}
+
+fn test_image_bytes(
+    file: &str,
+    expected: &[(ColorType, u32)],
+    // Represent all samples as little endian, ensuring check sums on all platforms.
+    normalize_byte_order: fn(&mut [u8]),
+) {
+    let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
+    let img_file = File::open(path).expect("Cannot find test image!");
+    let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+
+    let mut buffer = vec![0u8; 0];
+    for (idx, &(expected_type, expected_crc)) in expected.iter().enumerate() {
+        if idx > 0 {
+            decoder
+                .next_image()
+                .expect("mismatched number of directories");
+        }
+
+        assert_eq!(decoder.colortype().unwrap(), expected_type);
+        let layout = decoder
+            .image_buffer_layout()
+            .expect("Cannot describe buffer layout");
+
+        buffer.resize(layout.len, 0u8);
+        decoder.read_image_bytes(&mut buffer).unwrap();
+        normalize_byte_order(&mut buffer);
+
+        // Well almost a crc..
+        assert_eq!(crc32fast::hash(&buffer), expected_crc);
+    }
+}
+
+fn byte_order_u16(bytes: &mut [u8]) {
+    for chunk in bytes.chunks_exact_mut(2) {
+        let n = u16::from_ne_bytes(chunk.try_into().unwrap());
+        chunk.copy_from_slice(&n.to_le_bytes());
+    }
+}
+
+fn byte_order_u32(bytes: &mut [u8]) {
+    for chunk in bytes.chunks_exact_mut(4) {
+        let n = u32::from_ne_bytes(chunk.try_into().unwrap());
+        chunk.copy_from_slice(&n.to_le_bytes());
+    }
+}
+
+fn byte_order_u64(bytes: &mut [u8]) {
+    for chunk in bytes.chunks_exact_mut(8) {
+        let n = u64::from_ne_bytes(chunk.try_into().unwrap());
+        chunk.copy_from_slice(&n.to_le_bytes());
+    }
+}
+
+#[test]
+fn bytes_cmyk_3c_8b() {
+    test_image_bytes(
+        "cmyk-3c-8b.tiff",
+        &[(ColorType::CMYK(8), 2935032230)],
+        |_| (),
+    );
+}
+
+#[test]
+fn bytes_gray_16b() {
+    test_image_bytes(
+        "minisblack-1c-16b.tiff",
+        &[(ColorType::Gray(16), 3524597615)],
+        byte_order_u16,
+    );
+}
+
+#[test]
+fn bytes_gray_32b() {
+    test_image_bytes(
+        "gradient-1c-32b.tiff",
+        &[(ColorType::Gray(32), 2257036530)],
+        byte_order_u32,
+    );
+}
+
+#[test]
+fn bytes_gray_u64() {
+    test_image_bytes(
+        "gradient-1c-64b.tiff",
+        &[(ColorType::Gray(64), 2156547113)],
+        byte_order_u64,
+    );
+}
+
+#[test]
+fn bytes_gray_f32() {
+    test_image_bytes(
+        "gradient-1c-32b-float.tiff",
+        &[(ColorType::Gray(32), 3232356730)],
+        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

@@ -0,0 +1,76 @@
+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

@@ -36,11 +36,55 @@ fn encode_decode() {
         let mut decoder = Decoder::new(&mut file).unwrap();
         assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
         assert_eq!(decoder.dimensions().unwrap(), (100, 100));
+
+        let mut all_tags = decoder
+            .tag_iter()
+            .filter_map(Result::ok)
+            .collect::<Vec<_>>();
+        all_tags.sort_by_key(|(t, _)| t.to_u16());
+        assert_eq!(
+            all_tags,
+            vec![
+                (Tag::ImageWidth, ifd::Value::Unsigned(100)),
+                (Tag::ImageLength, ifd::Value::Unsigned(100)),
+                (
+                    Tag::BitsPerSample,
+                    ifd::Value::List(vec![
+                        ifd::Value::Short(8),
+                        ifd::Value::Short(8),
+                        ifd::Value::Short(8)
+                    ])
+                ),
+                (Tag::Compression, ifd::Value::Short(1)),
+                (Tag::PhotometricInterpretation, ifd::Value::Short(2)),
+                (Tag::StripOffsets, ifd::Value::Unsigned(35)),
+                (Tag::SamplesPerPixel, ifd::Value::Short(3)),
+                (Tag::RowsPerStrip, ifd::Value::Unsigned(3334)),
+                (Tag::StripByteCounts, ifd::Value::Unsigned(30000)),
+                (Tag::XResolution, ifd::Value::Rational(1, 1)),
+                (Tag::YResolution, ifd::Value::Rational(1, 1)),
+                (Tag::ResolutionUnit, ifd::Value::Short(1)),
+                (Tag::Artist, ifd::Value::Ascii("Image-tiff".into())),
+                (Tag::Predictor, ifd::Value::Short(1)),
+                (
+                    Tag::SampleFormat,
+                    ifd::Value::List(vec![
+                        ifd::Value::Short(1),
+                        ifd::Value::Short(1),
+                        ifd::Value::Short(1)
+                    ])
+                ),
+            ]
+        );
+
         assert_eq!(
             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");
@@ -75,11 +119,54 @@ fn encode_decode_big() {
         let mut decoder = Decoder::new(&mut file).unwrap();
         assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
         assert_eq!(decoder.dimensions().unwrap(), (100, 100));
+
+        let mut all_tags = decoder
+            .tag_iter()
+            .filter_map(Result::ok)
+            .collect::<Vec<_>>();
+        all_tags.sort_by_key(|(t, _)| t.to_u16());
+        assert_eq!(
+            all_tags,
+            vec![
+                (Tag::ImageWidth, ifd::Value::Unsigned(100)),
+                (Tag::ImageLength, ifd::Value::Unsigned(100)),
+                (
+                    Tag::BitsPerSample,
+                    ifd::Value::List(vec![
+                        ifd::Value::Short(8),
+                        ifd::Value::Short(8),
+                        ifd::Value::Short(8)
+                    ])
+                ),
+                (Tag::Compression, ifd::Value::Short(1)),
+                (Tag::PhotometricInterpretation, ifd::Value::Short(2)),
+                (Tag::StripOffsets, ifd::Value::UnsignedBig(27)),
+                (Tag::SamplesPerPixel, ifd::Value::Short(3)),
+                (Tag::RowsPerStrip, ifd::Value::Unsigned(3334)),
+                (Tag::StripByteCounts, ifd::Value::UnsignedBig(30000)),
+                (Tag::XResolution, ifd::Value::Rational(1, 1)),
+                (Tag::YResolution, ifd::Value::Rational(1, 1)),
+                (Tag::ResolutionUnit, ifd::Value::Short(1)),
+                (Tag::Artist, ifd::Value::Ascii("Image-tiff".into())),
+                (Tag::Predictor, ifd::Value::Short(1)),
+                (
+                    Tag::SampleFormat,
+                    ifd::Value::List(vec![
+                        ifd::Value::Short(1),
+                        ifd::Value::Short(1),
+                        ifd::Value::Short(1)
+                    ])
+                ),
+            ]
+        );
+
         assert_eq!(
             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 DecodingResult::U8(img_res) = buffer {
             assert_eq!(image_data, img_res);
         } else {
             panic!("Wrong data type");
@@ -94,6 +181,7 @@ fn test_encode_ifd() {
     {
         let mut tiff = TiffEncoder::new(&mut data).unwrap();
         let mut image_encoder = tiff.new_image::<colortype::Gray8>(1, 1).unwrap();
+        image_encoder.write_strip(&[1]).unwrap();
         let encoder = image_encoder.encoder();
 
         // Use the "reusable" tags section as per the TIFF6 spec
@@ -152,6 +240,7 @@ 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,
@@ -161,7 +250,10 @@ macro_rules! test_roundtrip {
             let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
             assert_eq!(decoder.colortype().unwrap(), expected_type);
 
-            let image_data = match decoder.read_image().unwrap() {
+            let mut buffer = tiff::decoder::DecodingResult::U8(vec![]);
+            decoder.read_image_to_buffer(&mut buffer).unwrap();
+
+            let image_data = match buffer {
                 DecodingResult::$buffer(res) => res,
                 _ => panic!("Wrong data type"),
             };
@@ -175,9 +267,11 @@ 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();
-                if let DecodingResult::$buffer(img_res) = decoder.read_image().unwrap() {
-                    assert_eq!(image_data, img_res);
+                decoder.read_image_to_buffer(&mut buffer).unwrap();
+                if let DecodingResult::$buffer(img_res) = buffer {
+                    assert_eq!(*image_data, img_res);
                 } else {
                     panic!("Wrong data type");
                 }
@@ -187,7 +281,9 @@ macro_rules! test_roundtrip {
 }
 
 test_roundtrip!(test_u8_roundtrip, U8, u8);
+test_roundtrip!(test_i8_roundtrip, I8, i8);
 test_roundtrip!(test_u16_roundtrip, U16, u16);
+test_roundtrip!(test_i16_roundtrip, I16, i16);
 test_roundtrip!(test_u32_roundtrip, U32, u32);
 test_roundtrip!(test_u64_roundtrip, U64, u64);
 test_roundtrip!(test_f32_roundtrip, F32, f32);
@@ -198,6 +294,11 @@ fn test_gray_u8_roundtrip() {
     test_u8_roundtrip::<colortype::Gray8>("minisblack-1c-8b.tiff", ColorType::Gray(8));
 }
 
+#[test]
+fn test_gray_i8_roundtrip() {
+    test_i8_roundtrip::<colortype::GrayI8>("minisblack-1c-i8b.tiff", ColorType::Gray(8));
+}
+
 #[test]
 fn test_rgb_u8_roundtrip() {
     test_u8_roundtrip::<colortype::RGB8>("rgb-3c-8b.tiff", ColorType::RGB(8));
@@ -208,11 +309,21 @@ fn test_cmyk_u8_roundtrip() {
     test_u8_roundtrip::<colortype::CMYK8>("cmyk-3c-8b.tiff", ColorType::CMYK(8));
 }
 
+#[test]
+fn test_cmyka_u8_roundtrip() {
+    test_u8_roundtrip::<colortype::CMYKA8>("cmyk-4c-8b.tiff", ColorType::CMYKA(8));
+}
+
 #[test]
 fn test_gray_u16_roundtrip() {
     test_u16_roundtrip::<colortype::Gray16>("minisblack-1c-16b.tiff", ColorType::Gray(16));
 }
 
+#[test]
+fn test_gray_i16_roundtrip() {
+    test_i16_roundtrip::<colortype::GrayI16>("minisblack-1c-i16b.tiff", ColorType::Gray(16));
+}
+
 #[test]
 fn test_rgb_u16_roundtrip() {
     test_u16_roundtrip::<colortype::RGB16>("rgb-3c-16b.tiff", ColorType::RGB(16));
@@ -263,6 +374,11 @@ fn test_gray_f64_roundtrip() {
     test_f64_roundtrip::<colortype::Gray64Float>("gradient-1c-64b-float.tiff", ColorType::Gray(64));
 }
 
+#[test]
+fn test_ycbcr_u8_roundtrip() {
+    test_u8_roundtrip::<colortype::YCbCr8>("tiled-jpeg-ycbcr.tif", ColorType::YCbCr(8));
+}
+
 trait AssertDecode {
     fn assert_tag_u32(&mut self, tag: u16) -> u32;
     fn assert_tag_u32_vec(&mut self, tag: u16) -> Vec<u32>;
@@ -320,6 +436,7 @@ fn test_multiple_byte() {
     {
         let mut tiff = TiffEncoder::new(&mut data).unwrap();
         let mut image_encoder = tiff.new_image::<colortype::Gray8>(1, 1).unwrap();
+        image_encoder.write_strip(&[1]).unwrap();
         let encoder = image_encoder.encoder();
 
         encoder.write_tag(Tag::Unknown(65000), &[1_u8][..]).unwrap();
@@ -360,6 +477,7 @@ fn test_signed() {
     {
         let mut tiff = TiffEncoder::new(&mut data).unwrap();
         let mut image_encoder = tiff.new_image::<colortype::Gray8>(1, 1).unwrap();
+        image_encoder.write_strip(&[1]).unwrap();
         let encoder = image_encoder.encoder();
 
         //Use the "reusable" tags section as per the TIFF6 spec
@@ -512,10 +630,64 @@ fn test_rows_per_strip() {
 
         for i in 0..50 {
             let img2 = [i; 2 * 100];
-            match decoder.read_strip().unwrap() {
+            match decoder.read_chunk(i as u32).unwrap() {
                 DecodingResult::U8(data) => assert_eq!(&img2[..], &data[..]),
-                other => panic!("Incorrect strip type {:?}", other),
+                other => panic!("Incorrect strip type {other:?}"),
             }
         }
     }
 }
+
+#[test]
+fn test_auxiliary_directory() {
+    const ARTIST: &str = "Auxiliary-tiff";
+
+    let mut data = Cursor::new(Vec::new());
+    let mut tiff = TiffEncoder::new(&mut data).unwrap();
+
+    {
+        let mut image_encoder = tiff.new_image::<colortype::Gray8>(1, 1).unwrap();
+        image_encoder.write_strip(&[1]).unwrap();
+    }
+
+    let exif = {
+        let mut extra = tiff.extra_directory().unwrap();
+        extra.write_tag(Tag::Artist, ARTIST).unwrap();
+        extra.finish_with_offsets().unwrap()
+    };
+
+    {
+        let mut image_encoder = tiff.new_image::<colortype::Gray8>(2, 1).unwrap();
+        image_encoder.write_strip(&[1, 2]).unwrap();
+        let encoder = image_encoder.encoder();
+        encoder.write_tag(Tag::ExifDirectory, exif.offset).unwrap();
+    }
+
+    data.set_position(0);
+    let mut decoder = Decoder::new(&mut data).unwrap();
+
+    {
+        assert_eq!(decoder.dimensions().unwrap(), (1, 1));
+        let _ = decoder.read_image().unwrap();
+    }
+
+    {
+        decoder.next_image().unwrap();
+        assert_eq!(decoder.dimensions().unwrap(), (2, 1));
+        let _ = decoder.read_image().unwrap();
+
+        let exif_location = decoder
+            .get_tag(Tag::ExifDirectory)
+            .expect("second directory missing Exif")
+            .into_ifd_pointer()
+            .expect("exif directory is not an IFD pointer");
+
+        let exif = decoder.read_directory(exif_location).unwrap();
+
+        let artist = decoder
+            .read_directory_tags(&exif)
+            .get_tag_ascii_string(Tag::Artist)
+            .expect("EXIF directory missing artist tag");
+        assert_eq!(artist, ARTIST);
+    }
+}

tests/encode_images_with_compression.rs

@@ -0,0 +1,158 @@
+extern crate tiff;
+
+use std::io::{Cursor, Seek, Write};
+use tiff::{
+    decoder::{Decoder, DecodingResult},
+    encoder::{
+        colortype::{self, ColorType},
+        compression::*,
+        Compression, TiffEncoder, TiffValue,
+    },
+};
+
+trait TestImage<const NUM_CHANNELS: usize>: From<Vec<<Self::Color as ColorType>::Inner>> {
+    const WIDTH: u32;
+    const HEIGHT: u32;
+    type Color: ColorType;
+
+    fn reference_data(&self) -> &[<Self::Color as ColorType>::Inner];
+    fn generate_pixel(x: u32, y: u32) -> [<Self::Color as ColorType>::Inner; NUM_CHANNELS];
+
+    fn compress<W: Write + Seek>(&self, encoder: &mut TiffEncoder<W>)
+    where
+        [<Self::Color as ColorType>::Inner]: TiffValue,
+    {
+        let image = encoder
+            .new_image::<Self::Color>(Self::WIDTH, Self::HEIGHT)
+            .unwrap();
+        image.write_data(self.reference_data()).unwrap();
+    }
+
+    fn generate() -> Self {
+        assert_eq!(
+            Self::Color::BITS_PER_SAMPLE.len(),
+            NUM_CHANNELS,
+            "Incompatible color type"
+        );
+
+        let mut data = Vec::with_capacity((Self::WIDTH * Self::HEIGHT) as usize * NUM_CHANNELS);
+        for x in 0..Self::WIDTH {
+            for y in 0..Self::HEIGHT {
+                data.extend(IntoIterator::into_iter(Self::generate_pixel(x, y)));
+            }
+        }
+        Self::from(data)
+    }
+}
+
+struct TestImageColor(Vec<u16>);
+
+impl From<Vec<u16>> for TestImageColor {
+    fn from(value: Vec<u16>) -> Self {
+        Self(value)
+    }
+}
+
+impl TestImage<3> for TestImageColor {
+    const WIDTH: u32 = 1;
+    const HEIGHT: u32 = 7;
+    type Color = colortype::RGB16;
+
+    fn reference_data(&self) -> &[u16] {
+        &self.0
+    }
+
+    fn generate_pixel(x: u32, y: u32) -> [<Self::Color as ColorType>::Inner; 3] {
+        let val = (x + y) % <Self::Color as ColorType>::Inner::MAX as u32;
+        [val as <Self::Color as ColorType>::Inner; 3]
+    }
+}
+
+struct TestImageGrayscale(Vec<u8>);
+
+impl From<Vec<u8>> for TestImageGrayscale {
+    fn from(value: Vec<u8>) -> Self {
+        Self(value)
+    }
+}
+
+impl TestImage<1> for TestImageGrayscale {
+    const WIDTH: u32 = 21;
+    const HEIGHT: u32 = 10;
+    type Color = colortype::Gray8;
+
+    fn reference_data(&self) -> &[u8] {
+        &self.0
+    }
+
+    fn generate_pixel(x: u32, y: u32) -> [<Self::Color as ColorType>::Inner; 1] {
+        let val = (x + y) % <Self::Color as ColorType>::Inner::MAX as u32;
+        [val as <Self::Color as ColorType>::Inner]
+    }
+}
+
+fn encode_decode_with_compression(compression: Compression) {
+    let mut data = Cursor::new(Vec::new());
+
+    let image_rgb = TestImageColor::generate();
+    let image_grayscale = TestImageGrayscale::generate();
+
+    // Encode tiff with compression
+    {
+        // Create a multipage image with 2 images
+        let mut encoder = TiffEncoder::new(&mut data)
+            .unwrap()
+            .with_compression(compression);
+        image_rgb.compress(&mut encoder);
+        image_grayscale.compress(&mut encoder);
+    }
+
+    // Decode tiff
+    data.set_position(0);
+    {
+        let mut decoder = Decoder::new(data).unwrap();
+
+        // Check the RGB image
+        assert_eq!(
+            match decoder.read_image() {
+                Ok(DecodingResult::U16(image_data)) => image_data,
+                unexpected => panic!("Descoding RGB failed: {unexpected:?}"),
+            },
+            image_rgb.reference_data()
+        );
+
+        // Check the grayscale image
+        decoder.next_image().unwrap();
+        assert_eq!(
+            match decoder.read_image() {
+                Ok(DecodingResult::U8(image_data)) => image_data,
+                unexpected => panic!("Decoding grayscale failed: {unexpected:?}"),
+            },
+            image_grayscale.reference_data()
+        );
+    }
+}
+
+#[test]
+fn encode_decode_without_compression() {
+    encode_decode_with_compression(Compression::Uncompressed);
+}
+
+#[test]
+#[cfg(feature = "lzw")]
+fn encode_decode_with_lzw() {
+    encode_decode_with_compression(Compression::Lzw);
+}
+
+#[test]
+#[cfg(feature = "deflate")]
+fn encode_decode_with_deflate() {
+    encode_decode_with_compression(Compression::Deflate(DeflateLevel::Fast));
+    encode_decode_with_compression(Compression::Deflate(DeflateLevel::Balanced));
+    encode_decode_with_compression(Compression::Deflate(DeflateLevel::Best));
+}
+
+#[test]
+fn encode_decode_with_packbits() {
+    encode_decode_with_compression(Compression::Packbits);
+}

tests/metadata.rs

@@ -0,0 +1,37 @@
+use tiff::{
+    decoder::Decoder,
+    encoder::{colortype::Gray8, EncodeMetadataOptions, TiffEncoder},
+    tags::Tag,
+};
+
+#[test]
+fn copies_exif_data() {
+    let src = std::path::PathBuf::from(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/images/predictor-3-gray-f32.tif"
+    ));
+
+    let src = std::fs::File::open(src).unwrap();
+    let mut src = Decoder::new(src).unwrap();
+
+    let mut data = std::io::Cursor::new(vec![]);
+    {
+        let mut dst = TiffEncoder::new(&mut data).unwrap();
+        let mut img = dst.new_image::<Gray8>(1, 1).unwrap();
+
+        let report = img
+            .write_metadata_copy_from(&mut src, EncodeMetadataOptions::default())
+            .unwrap();
+
+        assert_eq!(report.copied, 8);
+        assert_eq!(report.filtered, 0, "There are no tags we do not recognize");
+        img.write_data(&[0x80]).unwrap();
+    }
+
+    data.set_position(0);
+
+    {
+        let mut roundtrip = Decoder::new(data).unwrap();
+        assert!(roundtrip.find_tag(Tag::DateTime).unwrap().is_some());
+    }
+}

tests/predict.rs

@@ -0,0 +1,231 @@
+extern crate tiff;
+
+use tiff::decoder::{Decoder, DecodingResult};
+use tiff::encoder::{colortype, Predictor, TiffEncoder};
+use tiff::ColorType;
+
+use std::fs::File;
+use std::io::{Cursor, Seek, SeekFrom};
+use std::path::PathBuf;
+
+const TEST_IMAGE_DIR: &str = "./tests/images/";
+
+macro_rules! test_predict {
+    ($name:ident, $buffer:ident, $buffer_ty:ty) => {
+        fn $name<C: colortype::ColorType<Inner = $buffer_ty>>(
+            file: &str,
+            expected_type: ColorType,
+        ) {
+            let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
+            let file = File::open(path).expect("Cannot find test image!");
+            let mut decoder = Decoder::new(file).expect("Cannot create decoder!");
+
+            assert_eq!(decoder.colortype().unwrap(), expected_type);
+            let image_data = match decoder.read_image().unwrap() {
+                DecodingResult::$buffer(res) => res,
+                _ => panic!("Wrong data type"),
+            };
+
+            let mut predicted = Vec::with_capacity(image_data.len());
+            C::horizontal_predict(&image_data, &mut predicted);
+
+            let sample_size = C::SAMPLE_FORMAT.len();
+
+            (0..sample_size).for_each(|i| {
+                assert_eq!(predicted[i], image_data[i]);
+            });
+
+            (sample_size..image_data.len()).for_each(|i| {
+                predicted[i] = predicted[i].wrapping_add(predicted[i - sample_size]);
+                assert_eq!(predicted[i], image_data[i]);
+            });
+        }
+    };
+}
+
+test_predict!(test_u8_predict, U8, u8);
+test_predict!(test_i8_predict, I8, i8);
+test_predict!(test_u16_predict, U16, u16);
+test_predict!(test_i16_predict, I16, i16);
+test_predict!(test_u32_predict, U32, u32);
+test_predict!(test_u64_predict, U64, u64);
+
+#[test]
+fn test_gray_u8_predict() {
+    test_u8_predict::<colortype::Gray8>("minisblack-1c-8b.tiff", ColorType::Gray(8));
+}
+
+#[test]
+fn test_gray_i8_predict() {
+    test_i8_predict::<colortype::GrayI8>("minisblack-1c-i8b.tiff", ColorType::Gray(8));
+}
+
+#[test]
+fn test_rgb_u8_predict() {
+    test_u8_predict::<colortype::RGB8>("rgb-3c-8b.tiff", ColorType::RGB(8));
+}
+
+#[test]
+fn test_cmyk_u8_predict() {
+    test_u8_predict::<colortype::CMYK8>("cmyk-3c-8b.tiff", ColorType::CMYK(8));
+}
+
+#[test]
+fn test_gray_u16_predict() {
+    test_u16_predict::<colortype::Gray16>("minisblack-1c-16b.tiff", ColorType::Gray(16));
+}
+
+#[test]
+fn test_gray_i16_predict() {
+    test_i16_predict::<colortype::GrayI16>("minisblack-1c-i16b.tiff", ColorType::Gray(16));
+}
+
+#[test]
+fn test_rgb_u16_predict() {
+    test_u16_predict::<colortype::RGB16>("rgb-3c-16b.tiff", ColorType::RGB(16));
+}
+
+#[test]
+fn test_cmyk_u16_predict() {
+    test_u16_predict::<colortype::CMYK16>("cmyk-3c-16b.tiff", ColorType::CMYK(16));
+}
+
+#[test]
+fn test_gray_u32_predict() {
+    test_u32_predict::<colortype::Gray32>("gradient-1c-32b.tiff", ColorType::Gray(32));
+}
+
+#[test]
+fn test_rgb_u32_predict() {
+    test_u32_predict::<colortype::RGB32>("gradient-3c-32b.tiff", ColorType::RGB(32));
+}
+
+#[test]
+fn test_gray_u64_predict() {
+    test_u64_predict::<colortype::Gray64>("gradient-1c-64b.tiff", ColorType::Gray(64));
+}
+
+#[test]
+fn test_rgb_u64_predict() {
+    test_u64_predict::<colortype::RGB64>("gradient-3c-64b.tiff", ColorType::RGB(64));
+}
+
+#[test]
+fn test_ycbcr_u8_predict() {
+    test_u8_predict::<colortype::YCbCr8>("tiled-jpeg-ycbcr.tif", ColorType::YCbCr(8));
+}
+
+macro_rules! test_predict_roundtrip {
+    ($name:ident, $buffer:ident, $buffer_ty:ty) => {
+        fn $name<C: colortype::ColorType<Inner = $buffer_ty>>(
+            file: &str,
+            expected_type: ColorType,
+        ) {
+            let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
+            let img_file = File::open(path).expect("Cannot find test image!");
+            let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
+            assert_eq!(decoder.colortype().unwrap(), expected_type);
+
+            let image_data = match decoder.read_image().unwrap() {
+                DecodingResult::$buffer(res) => res,
+                _ => panic!("Wrong data type"),
+            };
+
+            let mut file = Cursor::new(Vec::new());
+            {
+                let mut tiff = TiffEncoder::new(&mut file)
+                    .unwrap()
+                    .with_predictor(Predictor::Horizontal);
+
+                let (width, height) = decoder.dimensions().unwrap();
+                tiff.write_image::<C>(width, height, &image_data).unwrap();
+            }
+            file.seek(SeekFrom::Start(0)).unwrap();
+            {
+                let mut decoder = Decoder::new(&mut file).unwrap();
+                if let DecodingResult::$buffer(img_res) =
+                    decoder.read_image().expect("Decoding image failed")
+                {
+                    assert_eq!(image_data, img_res);
+                } else {
+                    panic!("Wrong data type");
+                }
+            }
+        }
+    };
+}
+
+test_predict_roundtrip!(test_u8_predict_roundtrip, U8, u8);
+test_predict_roundtrip!(test_i8_predict_roundtrip, I8, i8);
+test_predict_roundtrip!(test_u16_predict_roundtrip, U16, u16);
+test_predict_roundtrip!(test_i16_predict_roundtrip, I16, i16);
+test_predict_roundtrip!(test_u32_predict_roundtrip, U32, u32);
+test_predict_roundtrip!(test_u64_predict_roundtrip, U64, u64);
+
+#[test]
+fn test_gray_u8_predict_roundtrip() {
+    test_u8_predict_roundtrip::<colortype::Gray8>("minisblack-1c-8b.tiff", ColorType::Gray(8));
+}
+
+#[test]
+fn test_gray_i8_predict_roundtrip() {
+    test_i8_predict_roundtrip::<colortype::GrayI8>("minisblack-1c-i8b.tiff", ColorType::Gray(8));
+}
+
+#[test]
+fn test_rgb_u8_predict_roundtrip() {
+    test_u8_predict_roundtrip::<colortype::RGB8>("rgb-3c-8b.tiff", ColorType::RGB(8));
+}
+
+#[test]
+fn test_cmyk_u8_predict_roundtrip() {
+    test_u8_predict_roundtrip::<colortype::CMYK8>("cmyk-3c-8b.tiff", ColorType::CMYK(8));
+}
+
+#[test]
+fn test_gray_u16_predict_roundtrip() {
+    test_u16_predict_roundtrip::<colortype::Gray16>("minisblack-1c-16b.tiff", ColorType::Gray(16));
+}
+
+#[test]
+fn test_gray_i16_predict_roundtrip() {
+    test_i16_predict_roundtrip::<colortype::GrayI16>(
+        "minisblack-1c-i16b.tiff",
+        ColorType::Gray(16),
+    );
+}
+
+#[test]
+fn test_rgb_u16_predict_roundtrip() {
+    test_u16_predict_roundtrip::<colortype::RGB16>("rgb-3c-16b.tiff", ColorType::RGB(16));
+}
+
+#[test]
+fn test_cmyk_u16_predict_roundtrip() {
+    test_u16_predict_roundtrip::<colortype::CMYK16>("cmyk-3c-16b.tiff", ColorType::CMYK(16));
+}
+
+#[test]
+fn test_gray_u32_predict_roundtrip() {
+    test_u32_predict_roundtrip::<colortype::Gray32>("gradient-1c-32b.tiff", ColorType::Gray(32));
+}
+
+#[test]
+fn test_rgb_u32_predict_roundtrip() {
+    test_u32_predict_roundtrip::<colortype::RGB32>("gradient-3c-32b.tiff", ColorType::RGB(32));
+}
+
+#[test]
+fn test_gray_u64_predict_roundtrip() {
+    test_u64_predict_roundtrip::<colortype::Gray64>("gradient-1c-64b.tiff", ColorType::Gray(64));
+}
+
+#[test]
+fn test_rgb_u64_predict_roundtrip() {
+    test_u64_predict_roundtrip::<colortype::RGB64>("gradient-3c-64b.tiff", ColorType::RGB(64));
+}
+
+#[test]
+fn test_ycbcr_u8_predict_roundtrip() {
+    test_u8_predict_roundtrip::<colortype::YCbCr8>("tiled-jpeg-ycbcr.tif", ColorType::YCbCr(8));
+}

tests/subsubifds.rs

@@ -0,0 +1,41 @@
+use tiff::decoder::Decoder;
+
+// This file has the following IFD structure:
+//
+// ```
+// IFD -> IFD -> IFD
+//        |-> IFD
+//        |-> IFD -> IFD
+//        |          \-> IFD -> IFD
+//        \-> IFD
+// ```
+//
+// where the main chain of IFD has 3 images, the second of which has several sub-IFDs and some have
+// more nested IFDs.
+const TEST_IMAGE_SUBIFD: &str = "./tests/subsubifds.tif";
+use std::fs::File;
+
+#[test]
+fn decode_seek_chain() {
+    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");
+    assert!(!decoder.more_images());
+
+    // Ensure we can seek, to do this again.
+    decoder
+        .seek_to_image(0)
+        .expect("Failed to seek to 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());
+    assert!(!decoder.more_images());
+}