doc typo

Upgrade zstd to 0.14

.github/workflows/fuzz.yml

@@ -0,0 +1,85 @@
+name: Fuzz
+
+on:
+  push:
+    branches: [main]
+  schedule:
+    - cron: '0 3 * * *'
+  workflow_dispatch:
+    inputs:
+      duration:
+        description: 'Seconds per fuzz target'
+        required: false
+        default: '300'
+
+concurrency:
+  group: fuzz-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  fuzz:
+    name: Fuzz (${{ matrix.target }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+          - decode_comprehensive
+          - decode_image
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: fuzz-${{ matrix.target }}
+          cache-directories: fuzz/target
+
+      - name: Install cargo-fuzz
+        run: cargo install cargo-fuzz --locked
+
+      - name: Determine duration
+        id: duration
+        run: |
+          if [ "${{ github.event_name }}" = "schedule" ]; then
+            echo "seconds=300" >> "$GITHUB_OUTPUT"
+          elif [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "seconds=${{ github.event.inputs.duration || '300' }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "seconds=60" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Seed corpus
+        run: |
+          mkdir -p fuzz/corpus/${{ matrix.target }}
+          cp fuzz/regression/* fuzz/corpus/${{ matrix.target }}/ 2>/dev/null || true
+          cp fuzz/seed_corpus/${{ matrix.target }}/* fuzz/corpus/${{ matrix.target }}/ 2>/dev/null || true
+
+      - name: Fuzz ${{ matrix.target }}
+        run: |
+          cargo +nightly fuzz run ${{ matrix.target }} \
+            -- -max_total_time=${{ steps.duration.outputs.seconds }} \
+               -dict=fuzz/tiff.dict \
+               -rss_limit_mb=2048
+
+      - name: Upload crashes
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: fuzz-crashes-${{ matrix.target }}
+          path: fuzz/artifacts/
+          retention-days: 30
+
+  regression:
+    name: Fuzz regression
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Build
+        run: cargo build
+      - name: Regression seeds
+        run: |
+          if [ -d fuzz/regression ] && [ "$(ls fuzz/regression/ 2>/dev/null | wc -l)" -gt 0 ]; then
+            cargo test --test fuzz_regression 2>/dev/null || echo "No regression test found — seeds exist but no test harness"
+          fi

.github/workflows/rust.yml

@@ -0,0 +1,114 @@
+name: Rust CI
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust: ["1.88.0", stable, beta, nightly]
+    steps:
+    - uses: actions/checkout@v6
+
+    - uses: dtolnay/rust-toolchain@nightly
+      if: ${{ matrix.rust == '1.88.0' }}
+    - name: Generate Cargo.lock with minimal-version dependencies
+      if: ${{ matrix.rust == '1.88.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 -v
+    - name: test
+      if: ${{ matrix.rust != '1.88.0' }}
+      run: cargo test -v && cargo doc -v
+
+  test-platforms:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest, macos-26-intel, windows-latest, windows-11-arm]
+    steps:
+    - uses: actions/checkout@v6
+    - uses: dtolnay/rust-toolchain@stable
+    - name: Cache Cargo Dependencies
+      uses: Swatinem/rust-cache@v2
+      with:
+        cache-on-failure: true
+    - name: test
+      run: cargo test -v
+
+  features:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        feature: ["", deflate, jpeg, lzw, zstd, default, "default,zstd"]
+    steps:
+    - uses: actions/checkout@v6
+    - 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@v6
+      - uses: taiki-e/install-action@cross
+      - name: Cache Cargo Dependencies
+        uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+          key: ${{ matrix.arch }}
+      - name: Cross-Run Tests using QEMU
+        run: cross test --target ${{ matrix.arch }}
+
+  msrv:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: dtolnay/rust-toolchain@stable
+    - uses: taiki-e/install-action@cargo-hack
+    - name: Check MSRV
+      run: cargo hack check --rust-version
+
+  rustfmt:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: rustfmt
+    - name: Run rustfmt check
+      run: cargo fmt -- --check
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: clippy
+    - run: cargo clippy --all-features --all-targets -- -D warnings

.gitignore

@@ -1,4 +1,6 @@
-
 /target/
 **/*.rs.bk
 Cargo.lock
+tests/benches/corpus/
+.idea
+.agentbridge

.travis.yml

@@ -1,6 +0,0 @@
-language: rust
-rust:
-    - 1.34.2
-    - stable
-    - beta
-    - nightly

CHANGES.md

@@ -1,3 +1,392 @@
+# Version 0.12.0 (unreleased)
+
+Fixes:
+- Decoding a tiled image whose width is not a multiple of the tile width no
+  longer corrupts the columns below the right border tiles when extra samples
+  are discarded (e.g. RGB with an unspecified extra sample). The horizontal
+  tile padding was written past the end of the output row, spilling into the
+  leftmost columns of the following row.
+
+Additions:
+- Added the `TiffHeader` type. It can be used to create a `Decoder` in a state
+  before the first IFD and allows opening files at an arbitrary first IFD
+  offset rather than one indicated by an encoded header at the start.
+
+Changes:
+- The IFD iteration methods on `Decoder` (`next_image`, `seek_to_image`, etc)
+  now come with a strong error guarantee. They will not modify the current
+  directory state if they fail. This includes the failure to interpret an IFD
+  as a supported image in the case of `*_image` variants.
+
+Compatibility:
+- Changed how tiled TIFF files are detected. The presence of a TileWidth OR
+  TileHeight/TileLength tag now marks an image as tiled. Data is no retrieved
+  from either StripOffsets or TileOffsets with the latter taking precedence.
+  This is closer to the behavior of libtiff.
+
+# Version 0.11.3
+
+Additions:
+- Added support for `webp` compression (as per GDAL) under the `webp` feature flag (default: off).
+- Added `Decoder::image_ifd`, creating an `IfdDecoder` of the current IFD.
+- Added `IfdDecoder::directory`, returning the `Directory` underlying it.
+- Added `LowerHex` and `UpwerHex` implementations for `IfdPointer`.
+
+Notes:
+- A new example `tiff-ls` demonstrates use of the new features.
+
+# Version 0.11.2
+
+Changes:
+- Planar files can now be read with `Decoder::read_image_to_buffer` if the
+  limits allow for such a large buffer size. Previously only the first plane
+  was read and the decoder will attempt a fallback to this behavior if the
+  limits do not allow all planes to be allocated.
+
+Fixes:
+- An off-by-one error in a `debug_assert` of `ValueBuffer` caused its use in
+  `IfdDecoder::find_tag_buf` to panic outside release mode when the buffer
+  exactly matched the required size.
+
+Additions:
+- The methods `ColorType::{num_samples, bit_depth}` are now public. This
+  promises that we only have homogeneous color depths in this major version.
+
+# 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:
+* Encoding signed integer formats is now supported.
+* Extensive fuzzing with `cargo fuzz`.
+
+Changes:
+* Tile decoding should be a little faster, requires one less intermediate buffer.
+* Images whose IFDs form a cycle due to their offsets will now raise an error
+  when the cycle would be entered (jumping back should still be supported).
+
+Fixes:
+* Fixed a regression that caused conflict between strips and tile images,
+  causing errors in decoding some images.
+* Use checked integer arithmetic in limit calculations, fixes overflows.
+* IFD Tags are now always cleared between images.
+* Found by fuzzing: Several memory limit overflows; JPEG now correctly
+  validates offsets and a minimum size of its table; Check upper limit of strip
+  byte size correctly;
+
+Notes:
+Our CI has warned that this version no longer builds on `1.34.2` out of the
+box. We're still committed to the MSRV on this major version yet one
+dependency—`flate2`—has already bumped it in a SemVer compatible version of its
+own. This is out-of-our-control (cargo's dependency resolution does not allow
+us to address this in a reasonable manner).
+
+This can be address this by pinning the version of `flate2` to `1.0.21` in your
+own files. However, you should understand that this puts you in considerable
+maintenance debt as you will no longer receive any updates for this dependency
+and any package that _requires_ a new version of the `1.0` series would be
+incompatible with this requirement (cargo might yell at you very loudly).
+
+# Version 0.7.0
+
+New features:
+* Support for encoding BigTiff ([#122](https://github.com/image-rs/image-tiff/pull/122))
+  * _Breaking:_ Encoder types now have a generic parameter to differentiate BigTiff and standard Tiff encoding. Defaults to standard Tiff.
+* Basic tile decoding ([#125](https://github.com/image-rs/image-tiff/pull/125))
+  * _Breaking:_ There is a new `TiffError::UsageError` variant.
+* Support for datatypes `Int8` and `Int16` ([#114](https://github.com/image-rs/image-tiff/pull/114))
+  * _Breaking:_ `DecodingResult` and `DecodingBuffer` have the two new variants `I8` and `I16`.
+* Support for `i32` arrays ([#118](https://github.com/image-rs/image-tiff/pull/118/files))
+  * _Breaking:_ `DecodingResult` and `DecodingBuffer` have a new `I32` variant.
+* Support for `Ifd` and `IfdBig` tag types and `I64` data type ([#119](https://github.com/image-rs/image-tiff/pull/119))
+  * _Breaking:_ `DecodingResult` and `DecodingBuffer` have a new `I64` variant.
+* Add `SMinSampleValue` and `SMaxSampleValue` ([#123](https://github.com/image-rs/image-tiff/pull/123))
+
+Changes:
+* Improve deflate support ([#132](https://github.com/image-rs/image-tiff/pull/132))
+  * Switch to streaming decompression via `flate2`. Aside from performance improvements and lower RAM consumption, this fixes a bug where `max_uncompressed_length` was precalculated for a single tile but then used as a hard limit on the whole data, failing to decompress any tiled images.
+  * Add support for new `Deflate` tag in addition to `OldDeflate`.
+* _Breaking:_ Remove `InflateError`, which is no longer needed with `flate2` ([#134](https://github.com/image-rs/image-tiff/pull/134))
+* _Breaking:_ Support for `MinIsWhite` is restricted to unsigned and floating
+  point values. This is expected to be be re-added once some contradictory
+  interpretation regarding semantics for signed values is resolved.
+
+Fixes:
+* Validate that ASCII tags are valid ASCII and end with a null byte ([#121](https://github.com/image-rs/image-tiff/pull/121))
+
+Internal:
+* Simplify decompression logic ([#126](https://github.com/image-rs/image-tiff/pull/126))
+* Simplify `expand_strip` ([#128](https://github.com/image-rs/image-tiff/pull/128))
+
+# Version 0.6.1
+
+New features:
+* Support for reading `u16` and ascii string tags.
+* Added `Limits::unlimited` for disabling all limits.
+* Added `ImageEncoder::rows_per_strip` to overwrite the default.
+
+Changes:
+* The default strip size for chunked encoding is now 1MB, up from 8KB. This
+  should lead to more efficient decoding and compression.
+
+Fixes:
+* Fixed a bug where LZW compressed strips could not be decoded, instead
+  returning an error `Inconsistent sizes encountered`.
+* Reading a tag with a complex type and a single value returns the proper Value
+  variant, instead of a vector with one entry.
+
+# Version 0.6.0
+
+New features:
+* Support for decoding BigTIFF with 64-bit offsets
+* The value types byte, `f32`, `f64` are now recognized
+* Support for Modern JPEG encoded images
+
+Improvements:
+* Better support for adding auxiliary tags before encoding image data
+* Switched to lzw decoder library `weezl` for performance
+* The `ColorType` trait now supports `SAMPLE_ENCODING` hints
+
+Fixes:
+* Fixed decoding of inline ASCII in tags
+* Fixed handling after null terminator in ASCII data
+* Recognize tile and sample format tags
+
+# Version 0.5.0
+
+* Added support for 32-bit and 64-bit decoded values.
+* Added CMYK(16|32|64) color type support.
+* Check many internal integer conversions to increase stability. This should
+  only lead to images being reported as faulty that would previously silently
+  break platform limits. If there are any false positives, please report them.
+* Remove an erroneous check of decoded length in lzw compressed images.
+
 # Version 0.4.0
 
 * Several enumerations are now non_exhaustive for future extensions.

Cargo.toml

@@ -1,22 +1,71 @@
 [package]
-name = "tiff"
-version = "0.4.0"
-authors = [
-    "ccgn",
-    "bvssvni <bvssvni@gmail.com>",
-    "nwin",
-    "TyOverby <ty@pre-alpha.com>",
-    "HeroicKatora",
-    "Calum",
-    "CensoredUsername <cens.username@gmail.com>",
-    "Robzz",
-    "birktj"]
+name = "ndbioimage-tiff"
+version = "0.11.3"
+edition = "2021"
+
+# note: when changed, also update test runner in `.github/workflows/rust.yml`
+rust-version = "1.88.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/*"]
+categories = ["multimedia::images", "multimedia::encoding"]
+
+exclude = ["tests/images/*", "tests/fuzz_images/*", "tests/**/*.tif"]
+
+[lib]
+name = "tiff"
 
 [dependencies]
-byteorder = "1.2"
-lzw = "0.10"
-miniz_oxide = "0.3"
+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.2.1", optional = true }
+zstd = { version = "0.14", optional = true }
+zrip-decode = { version = "0.8.2", features = ["paranoid"], optional = true }
+zune-jpeg = { version = "0.5.1", optional = true }
+image-webp = {version = "0.2.4", optional = true }
+
+[dev-dependencies]
+criterion = "0.3.1"
+# We may already depend on this via flate2
+crc32fast = "1.5"
+libtest-mimic = "0.8.1"
+walkdir = "2.5"
+
+[features]
+default = ["deflate", "fax", "jpeg", "lzw"]
+
+# Compression algorithms
+deflate = ["dep:flate2"]
+fax = ["dep:fax34"]
+jpeg = ["dep:zune-jpeg"]
+lzw = ["dep:weezl"]
+webp = ["dep:image-webp"]
+zstd = ["dep:zstd"]
+# Fully safe Rust but somewhat slower Zstd decoding.
+# When both zstd and zstd-safe-rust are enabled, zstd takes precedence.
+zstd-safe-rust = ["dep:zrip-decode"]
+
+[[bench]]
+name = "lzw"
+harness = false
+
+[[bench]]
+name = "encode"
+harness = false
+
+[[bench]]
+name = "decode"
+harness = false
+
+
+[[test]]
+name = "decode_libtiffpic"
+path = "tests/decode_libtiffpic.rs"
+harness = false

README.md

@@ -1,39 +1,46 @@
 # image-tiff
-[![Build Status](https://travis-ci.org/image-rs/image-tiff.svg?branch=master)](https://travis-ci.org/image-rs/image-tiff)
+[![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)
 
 TIFF decoding and encoding library in pure Rust
 
+Forked from https://github.com/image-rs/image-tiff. Changes: read images containing RGBPalette frames, ignoring colormaps.
+
 ## Supported
 
 ### Features
 - Baseline spec (other than formats and tags listed below as not supported)
 - Multipage
+- BigTIFF
 - Incremental decoding
 
 ### 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) | |
-| `BlackIsZero` | Gray(8\|16\|32\|64) | |
-| `RGB` | RGB(8\|16\|32\|64), RGBA(8\|16\|32\|64) | |
+| --------------------------- | --------------------------------------- | ------------------------- |
+| `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`                      | CMYK(8\|16\|32\|64)                     | CMYK(32\|64)              |
+| `CMYKA`                     | CMYKA(8)                                |                           |
 | `YCbCr`                     |                                         |                           |
 | `CIELab`                    |                                         |                           |
 
 ### Compressions
 
 |          | Decoding | Encoding |
-|-|-|-|
+| -------- | -------- | -------- |
 | None     | ✓        | ✓        |
-| LZW | ✓ | |
-| Deflate | ✓ | |
-| PackBits | ✓ | |
+| LZW      | ✓        | ✓        |
+| Deflate  | ✓        | ✓        |
+| PackBits | ✓        | ✓        |
+| Fax4     | ✓        | not yet  |
+| JPEG     | ✓        | not yet  |
+| ZSTD     | ✓        | not yet  |
 
 
 ## Not yet supported
@@ -43,4 +50,11 @@ Formats and interpretations not listed above or with empty entries are unsupport
 - Baseline tags
   - `ExtraSamples`
 - Extension tags
-- BigTIFF
+
+## Fuzzing
+
+This crate uses [cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz) in order to test the image parser.
+
+After installing it with `cargo install cargo-fuzz` on a nightly rustc, the
+fuzzing harness can be run with recommended settings using 
+`cargo fuzz run decode_comprehensive -snone -- -dict=fuzz/tiff.dict -timeout=5`.

benches/decode.rs

@@ -0,0 +1,461 @@
+extern crate criterion;
+extern crate tiff;
+
+use criterion::{black_box, Criterion, Throughput};
+use std::io::Cursor;
+use tiff::decoder::Decoder;
+use tiff::encoder::colortype::{Gray16, Gray8, RGB32Float, RGB16, RGB8, RGBA8};
+use tiff::encoder::{Compression, Predictor, TiffEncoder};
+
+const WIDTH: u32 = 2048;
+const HEIGHT: u32 = 2048;
+
+// === Corpus paths (real photo-based TIFFs) ===
+// Set TIFF_BENCH_DIR / TIFF_GEOTIFF_DIR env vars to a directory containing the corpus files.
+// If the files are not found, the corresponding benchmarks are silently skipped.
+// The corpus can be generated with vips/imagemagick from any large photo; see the benchmark
+// names for the expected filenames and compression settings.
+const CORPUS_DIR: &str = "tests/benches/corpus";
+
+fn bench_dir() -> String {
+    std::env::var("TIFF_BENCH_DIR").unwrap_or_else(|_| CORPUS_DIR.to_string())
+}
+
+fn geotiff_dir() -> String {
+    std::env::var("TIFF_GEOTIFF_DIR").unwrap_or_else(|_| CORPUS_DIR.to_string())
+}
+
+/// Load a file from the corpus directory, returning None if not found.
+fn load_corpus(dir: &str, name: &str) -> Option<Vec<u8>> {
+    let path = format!("{}/{}", dir, name);
+    std::fs::read(&path).ok()
+}
+
+fn decode_tiff_bytes(data: &[u8]) {
+    let cursor = Cursor::new(data);
+    let mut decoder = Decoder::open(black_box(cursor)).unwrap();
+    decoder.next_image().unwrap();
+    decoder.read_image().unwrap();
+}
+
+// === Synthetic image generators ===
+
+fn generate_rgb8(w: u32, h: u32) -> Vec<u8> {
+    (0..w * h * 3)
+        .map(|i| ((i * 7 + i / w * 3) & 0xFF) as u8)
+        .collect()
+}
+
+fn generate_rgba8(w: u32, h: u32) -> Vec<u8> {
+    (0..w * h * 4)
+        .map(|i| ((i * 11 + i / w * 5) & 0xFF) as u8)
+        .collect()
+}
+
+fn generate_gray8(w: u32, h: u32) -> Vec<u8> {
+    (0..w * h)
+        .map(|i| ((i * 7 + i / w * 3) & 0xFF) as u8)
+        .collect()
+}
+
+fn generate_rgb16(w: u32, h: u32) -> Vec<u16> {
+    (0..w * h * 3)
+        .map(|i| ((i * 257 + i / w * 131) & 0xFFFF) as u16)
+        .collect()
+}
+
+fn generate_gray16(w: u32, h: u32) -> Vec<u16> {
+    (0..w * h)
+        .map(|i| ((i * 257 + i / w * 131) & 0xFFFF) as u16)
+        .collect()
+}
+
+fn generate_rgb_f32(w: u32, h: u32) -> Vec<f32> {
+    let mut data = Vec::with_capacity((w * h * 3) as usize);
+    for y in 0..h {
+        for x in 0..w {
+            let fx = x as f32 / w as f32;
+            let fy = y as f32 / h as f32;
+            data.push(fx * 0.5 + fy * 0.3);
+            data.push(fy * 0.7 + fx * 0.2);
+            data.push((fx + fy) * 0.25);
+        }
+    }
+    data
+}
+
+// === Synthetic encoders (strip-only, encoder doesn't support tiles) ===
+
+fn encode<C: tiff::encoder::colortype::ColorType>(
+    data: &[C::Inner],
+    w: u32,
+    h: u32,
+    compression: Compression,
+    predictor: Predictor,
+) -> Vec<u8>
+where
+    [C::Inner]: tiff::encoder::TiffValue,
+{
+    let mut buf = Cursor::new(Vec::new());
+    TiffEncoder::new(&mut buf)
+        .unwrap()
+        .with_predictor(predictor)
+        .with_compression(compression)
+        .write_image::<C>(w, h, data)
+        .unwrap();
+    buf.into_inner()
+}
+
+fn main() {
+    let mut c = Criterion::default().configure_from_args();
+    let bd = bench_dir();
+    let gd = geotiff_dir();
+
+    // ========================================================================
+    // PART 1: Real photo corpus (5616x3744, ~21MP)
+    // ========================================================================
+    // Raw pixel sizes for throughput calculation:
+    //   RGB8:  5616*3744*3 = 63,078,912
+    //   RGB16: 5616*3744*6 = 126,157,824
+    //   F32x3: 5616*3744*12 = 252,315,648
+    //   Gray8: 5616*3744*1 = 21,026,304
+    //   GrayF32: 5616*3744*4 = 84,105,216
+    //   Palette8: 5616*3744*1 = 21,026,304 (output)
+
+    struct CorpusBench {
+        file: &'static str,
+        name: &'static str,
+        raw_bytes: u64,
+    }
+
+    let photo_benches = [
+        // Strip-based
+        CorpusBench {
+            file: "photo-rgb8-none.tif",
+            name: "strip-rgb8-none",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-rgb8-packbits.tif",
+            name: "strip-rgb8-packbits",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-rgb8-lzw.tif",
+            name: "strip-rgb8-lzw",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-rgb8-lzw-hpred.tif",
+            name: "strip-rgb8-lzw-hpred",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-rgb8-deflate-hpred.tif",
+            name: "strip-rgb8-deflate-hpred",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-rgb16-deflate-hpred.tif",
+            name: "strip-rgb16-deflate-hpred",
+            raw_bytes: 126_157_824,
+        },
+        CorpusBench {
+            file: "photo-gray8-lzw.tif",
+            name: "strip-gray8-lzw",
+            raw_bytes: 21_026_304,
+        },
+        CorpusBench {
+            file: "photo-gray8-deflate-hpred.tif",
+            name: "strip-gray8-deflate-hpred",
+            raw_bytes: 21_026_304,
+        },
+        CorpusBench {
+            file: "photo-rgb-f32-deflate-fpred.tif",
+            name: "strip-rgb-f32-deflate-fpred",
+            raw_bytes: 252_315_648,
+        },
+        CorpusBench {
+            file: "photo-gray-f32-deflate-fpred.tif",
+            name: "strip-gray-f32-deflate-fpred",
+            raw_bytes: 84_105_216,
+        },
+        CorpusBench {
+            file: "photo-palette8-lzw.tif",
+            name: "strip-palette8-lzw",
+            raw_bytes: 21_026_304,
+        },
+        CorpusBench {
+            file: "scan-bilevel-fax4.tif",
+            name: "strip-bilevel-fax4",
+            raw_bytes: 5616 * 3744 / 8,
+        },
+        // Tiled
+        CorpusBench {
+            file: "photo-rgb8-lzw-hpred-tiled256.tif",
+            name: "tiled256-rgb8-lzw-hpred",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-rgb8-deflate-hpred-tiled256.tif",
+            name: "tiled256-rgb8-deflate-hpred",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-rgb8-jpeg-tiled256.tif",
+            name: "tiled256-rgb8-jpeg",
+            raw_bytes: 63_078_912,
+        },
+        CorpusBench {
+            file: "photo-gray-f32-deflate-fpred-tiled512.tif",
+            name: "tiled512-gray-f32-deflate-fpred",
+            raw_bytes: 84_105_216,
+        },
+    ];
+
+    {
+        let mut group = c.benchmark_group("photo-21mp");
+        group.sample_size(10);
+
+        for bench in &photo_benches {
+            if let Some(data) = load_corpus(&bd, bench.file) {
+                group.throughput(Throughput::Bytes(bench.raw_bytes));
+                let data_ref = &data;
+                group.bench_function(bench.name, |b| b.iter(|| decode_tiff_bytes(data_ref)));
+            }
+        }
+
+        group.finish();
+    }
+
+    // ========================================================================
+    // PART 2: GeoTIFF (real tiled DEM data)
+    // ========================================================================
+
+    let geotiff_benches = [
+        // Copernicus DEM: 3600x3600, tiled 1024x1024, Gray f32, deflate + fpredict
+        CorpusBench {
+            file: "Copernicus_DSM_COG_10_N40_00_W075_00_DEM.tif",
+            name: "copernicus-dem-f32-deflate-fpred-1024tile",
+            raw_bytes: 3600 * 3600 * 4,
+        },
+        // USGS DEM: 3612x3612, tiled 512x512, Gray f32, LZW + fpredict
+        CorpusBench {
+            file: "USGS_1_n40w075.tif",
+            name: "usgs-dem-f32-lzw-fpred-512tile",
+            raw_bytes: 3612 * 3612 * 4,
+        },
+    ];
+
+    {
+        let mut group = c.benchmark_group("geotiff");
+        group.sample_size(10);
+
+        for bench in &geotiff_benches {
+            if let Some(data) = load_corpus(&gd, bench.file) {
+                group.throughput(Throughput::Bytes(bench.raw_bytes));
+                let data_ref = &data;
+                group.bench_function(bench.name, |b| b.iter(|| decode_tiff_bytes(data_ref)));
+            }
+        }
+
+        group.finish();
+    }
+
+    // ========================================================================
+    // PART 3: Synthetic (2048x2048, controlled comparisons)
+    // ========================================================================
+
+    let rgb8 = generate_rgb8(WIDTH, HEIGHT);
+    let rgba8 = generate_rgba8(WIDTH, HEIGHT);
+    let gray8 = generate_gray8(WIDTH, HEIGHT);
+    let rgb16 = generate_rgb16(WIDTH, HEIGHT);
+    let gray16 = generate_gray16(WIDTH, HEIGHT);
+    let rgb_f32 = generate_rgb_f32(WIDTH, HEIGHT);
+
+    let raw_rgb8 = (WIDTH * HEIGHT * 3) as u64;
+    let raw_rgba8 = (WIDTH * HEIGHT * 4) as u64;
+    let raw_gray8 = (WIDTH * HEIGHT) as u64;
+    let raw_rgb16 = (WIDTH * HEIGHT * 6) as u64;
+    let raw_gray16 = (WIDTH * HEIGHT * 2) as u64;
+    let raw_f32x3 = (WIDTH * HEIGHT * 12) as u64;
+
+    // --- Uncompressed baseline ---
+    {
+        let mut group = c.benchmark_group("synth-uncompressed");
+        group.sample_size(10);
+
+        let t = encode::<RGB8>(
+            &rgb8,
+            WIDTH,
+            HEIGHT,
+            Compression::Uncompressed,
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb8))
+            .bench_function("rgb8", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGBA8>(
+            &rgba8,
+            WIDTH,
+            HEIGHT,
+            Compression::Uncompressed,
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgba8))
+            .bench_function("rgba8", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<Gray8>(
+            &gray8,
+            WIDTH,
+            HEIGHT,
+            Compression::Uncompressed,
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_gray8))
+            .bench_function("gray8", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB16>(
+            &rgb16,
+            WIDTH,
+            HEIGHT,
+            Compression::Uncompressed,
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb16))
+            .bench_function("rgb16", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<Gray16>(
+            &gray16,
+            WIDTH,
+            HEIGHT,
+            Compression::Uncompressed,
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_gray16))
+            .bench_function("gray16", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        group.finish();
+    }
+
+    // --- Predictor overhead isolation (deflate-1, with vs without predictor) ---
+    {
+        let mut group = c.benchmark_group("synth-predictor");
+        group.sample_size(10);
+
+        let t = encode::<RGB8>(
+            &rgb8,
+            WIDTH,
+            HEIGHT,
+            Compression::Deflate(1),
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb8))
+            .bench_function("rgb8-deflate-none", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB8>(
+            &rgb8,
+            WIDTH,
+            HEIGHT,
+            Compression::Deflate(1),
+            Predictor::Horizontal,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb8))
+            .bench_function("rgb8-deflate-hpred", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB16>(
+            &rgb16,
+            WIDTH,
+            HEIGHT,
+            Compression::Deflate(1),
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb16))
+            .bench_function("rgb16-deflate-none", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB16>(
+            &rgb16,
+            WIDTH,
+            HEIGHT,
+            Compression::Deflate(1),
+            Predictor::Horizontal,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb16))
+            .bench_function("rgb16-deflate-hpred", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB32Float>(
+            &rgb_f32,
+            WIDTH,
+            HEIGHT,
+            Compression::Deflate(1),
+            Predictor::None,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_f32x3))
+            .bench_function("rgb-f32-deflate-none", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB32Float>(
+            &rgb_f32,
+            WIDTH,
+            HEIGHT,
+            Compression::Deflate(1),
+            Predictor::FloatingPoint,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_f32x3))
+            .bench_function("rgb-f32-deflate-fpred", |b| {
+                b.iter(|| decode_tiff_bytes(&t))
+            });
+
+        group.finish();
+    }
+
+    // --- LZW vs Deflate comparison ---
+    {
+        let mut group = c.benchmark_group("synth-compression");
+        group.sample_size(10);
+
+        let t = encode::<RGB8>(
+            &rgb8,
+            WIDTH,
+            HEIGHT,
+            Compression::Deflate(1),
+            Predictor::Horizontal,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb8))
+            .bench_function("rgb8-deflate-hpred", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB8>(
+            &rgb8,
+            WIDTH,
+            HEIGHT,
+            Compression::Lzw,
+            Predictor::Horizontal,
+        );
+        group
+            .throughput(Throughput::Bytes(raw_rgb8))
+            .bench_function("rgb8-lzw-hpred", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB8>(&rgb8, WIDTH, HEIGHT, Compression::Lzw, Predictor::None);
+        group
+            .throughput(Throughput::Bytes(raw_rgb8))
+            .bench_function("rgb8-lzw-none", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        let t = encode::<RGB8>(&rgb8, WIDTH, HEIGHT, Compression::Packbits, Predictor::None);
+        group
+            .throughput(Throughput::Bytes(raw_rgb8))
+            .bench_function("rgb8-packbits", |b| b.iter(|| decode_tiff_bytes(&t)));
+
+        group.finish();
+    }
+}

benches/encode.rs

@@ -0,0 +1,44 @@
+extern crate criterion;
+extern crate tiff;
+
+use criterion::{black_box, Criterion, Throughput};
+use std::io::Cursor;
+use tiff::encoder::colortype::RGB32Float;
+use tiff::encoder::{Compression, Predictor, TiffEncoder};
+
+const WIDTH: u32 = 500;
+const HEIGHT: u32 = 500;
+
+fn encode_image_f32_float_predictor_deflate(data: &[f32]) {
+    let mut buf = Cursor::new(Vec::with_capacity(WIDTH as usize * HEIGHT as usize * 4));
+    TiffEncoder::new(&mut buf)
+        .unwrap()
+        .with_predictor(Predictor::FloatingPoint)
+        .with_compression(Compression::Deflate(1))
+        .write_image::<RGB32Float>(WIDTH, HEIGHT, black_box(data))
+        .unwrap();
+}
+
+fn main() {
+    // Generate synthetic f32 image data with a gradient pattern
+    let data: Vec<f32> = (0..WIDTH as usize * HEIGHT as usize * 3)
+        .map(|i| {
+            let pixel = i / 3;
+            let x = (pixel % WIDTH as usize) as f32 / WIDTH as f32;
+            let y = (pixel / WIDTH as usize) as f32 / HEIGHT as f32;
+            x * 0.5 + y * 0.5
+        })
+        .collect();
+
+    let mut c = Criterion::default().configure_from_args();
+    let mut group = c.benchmark_group("tiff-encode");
+
+    group
+        .sample_size(20)
+        .throughput(Throughput::Bytes(
+            (WIDTH as u64) * (HEIGHT as u64) * 3 * std::mem::size_of::<f32>() as u64,
+        ))
+        .bench_function("f32-float-predictor-deflate-fast", |b| {
+            b.iter(|| encode_image_f32_float_predictor_deflate(&data))
+        });
+}

benches/lzw.rs

@@ -0,0 +1,81 @@
+extern crate criterion;
+extern crate tiff;
+
+use criterion::{
+    black_box, measurement::Measurement, BenchmarkGroup, BenchmarkId, Criterion, Throughput,
+};
+use tiff::decoder::Decoder;
+
+fn read_image(image: &[u8]) {
+    let image = std::io::Cursor::new(image);
+    let decoder = Decoder::open(black_box(image));
+    let mut reader = decoder.unwrap();
+    while reader.more_images() {
+        reader.next_directory().unwrap();
+        reader.read_image().unwrap();
+    }
+}
+
+fn main() {
+    struct BenchDef {
+        data: &'static [u8],
+        id: &'static str,
+        sample_size: usize,
+    }
+
+    fn run_bench_def<M: Measurement>(group: &mut BenchmarkGroup<M>, def: BenchDef) {
+        group
+            .sample_size(def.sample_size)
+            .throughput(Throughput::Bytes(def.data.len() as u64))
+            .bench_with_input(
+                BenchmarkId::new(def.id, def.data.len()),
+                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");
+
+    macro_rules! data_file {
+        ($name:literal) => {
+            include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), $name))
+        };
+    }
+
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: data_file!("/tests/images/issue_69_lzw.tiff"),
+            id: "issue-69-lzw.tif",
+            sample_size: 500,
+        },
+    );
+
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: data_file!("/tests/benches/kodim02-lzw.tif"),
+            id: "kodim02-lzw.tif",
+            sample_size: 20,
+        },
+    );
+
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: data_file!("/tests/benches/kodim07-lzw.tif"),
+            id: "kodim07-lzw.tif",
+            sample_size: 20,
+        },
+    );
+
+    run_bench_def(
+        &mut group,
+        BenchDef {
+            data: data_file!("/tests/benches/Transparency-lzw.tif"),
+            id: "Transparency-lzw.tif",
+            sample_size: 20,
+        },
+    );
+}

examples/decode.rs

@@ -0,0 +1,235 @@
+use tiff::decoder::{BufferLayoutPreference, Decoder, DecodingSampleBuffer, DecodingSampleSlice};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let Some(image) = std::env::args_os().nth(1) else {
+        eprintln!("Usage: decode FILE [--lenient]");
+        return Ok(());
+    };
+
+    let lenient = std::env::args().nth(2).as_deref() == Some("--lenient");
+
+    let file = std::fs::File::open(image)?;
+    let io = std::io::BufReader::new(file);
+    let mut reader = Decoder::open(io)?.with_lenient(lenient);
+
+    let mut data = DecodingSampleBuffer::I8(vec![]);
+
+    for i in 0u32.. {
+        if !reader.more_images() {
+            break;
+        }
+
+        reader.next_directory()?;
+
+        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);
+    }
+
+    Ok(())
+}
+
+fn debug_planes(
+    index: u32,
+    data: &mut DecodingSampleBuffer,
+    layout: &BufferLayoutPreference,
+    colortype: &tiff::ColorType,
+    (width, height): (u32, u32),
+) {
+    match data {
+        DecodingSampleBuffer::F16(v) => {
+            let samples = v
+                .iter()
+                .map(|&f| (f64::from(f) * f64::from(u16::MAX)) as u16)
+                .collect::<Vec<_>>();
+            *data = DecodingSampleBuffer::U16(samples);
+        }
+        DecodingSampleBuffer::F32(v) => {
+            let samples = v
+                .iter()
+                .map(|&f| (f64::from(f) * f64::from(u16::MAX)) as u16)
+                .collect::<Vec<_>>();
+            *data = DecodingSampleBuffer::U16(samples);
+        }
+        DecodingSampleBuffer::F64(v) => {
+            let samples = v
+                .iter()
+                .map(|&f| (f * f64::from(u16::MAX)) as u16)
+                .collect::<Vec<_>>();
+            *data = DecodingSampleBuffer::U16(samples);
+        }
+        _ => {}
+    }
+
+    let (depth, mut tupltype) = match colortype {
+        // Note: we will expand, so this is in fact not BLACKANDWHITE
+        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;
+        }
+    };
+
+    // Number of samples in a line and number of sample lines in the image, depending on whether
+    // they are planar or not. This determines the layout of the image buffer when expanding bit
+    // packed samples to a full byte (we support power-of-two sample sizes, positive and negative,
+    // but only those).
+    let (swidth, sheight) = if layout.planes > 1 {
+        (
+            u64::from(width) * u64::from(colortype.num_samples()),
+            u64::from(height),
+        )
+    } else {
+        (
+            u64::from(width),
+            u64::from(height) * u64::from(colortype.num_samples()),
+        )
+    };
+
+    let mut fallback_buffer;
+    let maxval = match data.as_buffer(0) {
+        // `U8` is also our representation of bit-packed color. PAM uses the smallest number of
+        // *bytes* needed to represent a sample but we must also adhere to maxval. We could explode
+        // them here (e.g. represent 1-bit as `{0, 1}`) but we'd also set `maxval` accordingly and
+        // this requires tupltype to be `BLACKANDWHITE` so introducing a bunch of complexity. If
+        // you want to do that in your real code, go ahead.
+        DecodingSampleSlice::U8(buf) => match colortype.bit_depth() {
+            8 => u64::from(u8::MAX),
+            4 => {
+                fallback_buffer = vec![0; (swidth * sheight) as usize];
+                expand_4bit(buf, swidth, &mut fallback_buffer);
+                *data = DecodingSampleBuffer::U8(fallback_buffer);
+                u64::from(u8::MAX)
+            }
+            2 => {
+                fallback_buffer = vec![0; (swidth * sheight) as usize];
+                expand_2bit(buf, swidth, &mut fallback_buffer);
+                *data = DecodingSampleBuffer::U8(fallback_buffer);
+                u64::from(u8::MAX)
+            }
+            1 => {
+                fallback_buffer = vec![0; (swidth * sheight) as usize];
+                expand_1bit(buf, swidth, &mut fallback_buffer);
+                *data = DecodingSampleBuffer::U8(fallback_buffer);
+                u64::from(u8::MAX)
+            }
+            _ => {
+                eprintln!(
+                    "Unsupported bit depth for U8 buffer: {}",
+                    colortype.bit_depth()
+                );
+                return;
+            }
+        },
+        DecodingSampleSlice::U16(_) => u64::from(u16::MAX),
+        DecodingSampleSlice::U32(_) => u64::from(u32::MAX),
+        DecodingSampleSlice::U64(_) => u64::MAX,
+        // Eh, this is a good effort I guess.
+        DecodingSampleSlice::I8(items) => {
+            items.iter_mut().for_each(|v| *v = 0.max(*v));
+            u64::from(i8::MAX as u8)
+        }
+        DecodingSampleSlice::I16(items) => {
+            items.iter_mut().for_each(|v| *v = 0.max(*v));
+            u64::from(i16::MAX as u16)
+        }
+        DecodingSampleSlice::I32(items) => {
+            items.iter_mut().for_each(|v| *v = 0.max(*v));
+            u64::from(i32::MAX as u32)
+        }
+        DecodingSampleSlice::I64(items) => {
+            items.iter_mut().for_each(|v| *v = 0.max(*v));
+            i64::MAX as u64
+        }
+        // Not supported by PAM.
+        DecodingSampleSlice::F16(_) | DecodingSampleSlice::F32(_) | DecodingSampleSlice::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");
+    }
+}
+
+/// Put exactly the ith `SCALE`-bit chunk of `val` into the least significant bits.
+#[inline(always)]
+fn bits_extract<const SCALE: u8>(val: u8, i: u8) -> u8 {
+    // Shift left to discard high bits, then right to bring desired bits down. This way also
+    // conveniently avoids all cases of overflow.
+    (val << (i * SCALE)) >> (8 - SCALE)
+}
+
+fn expand_1bit(from: &[u8], samples_per_padded: u64, into: &mut [u8]) {
+    let stride = samples_per_padded.div_ceil(8);
+
+    let from_row = from.chunks_exact(stride as usize);
+    let into_row = into.chunks_exact_mut(samples_per_padded as usize);
+
+    for (from_row, into_row) in from_row.zip(into_row) {
+        for (into, &from) in into_row.chunks_mut(8).zip(from_row) {
+            let data =
+                core::array::from_fn::<u8, 8, _>(|i| 0xff * bits_extract::<1>(from, i as u8));
+            into.copy_from_slice(&data[..into.len()]);
+        }
+    }
+}
+
+fn expand_2bit(from: &[u8], samples_per_padded: u64, into: &mut [u8]) {
+    let stride = samples_per_padded.div_ceil(4);
+
+    let from_row = from.chunks_exact(stride as usize);
+    let into_row = into.chunks_exact_mut(samples_per_padded as usize);
+
+    for (from_row, into_row) in from_row.zip(into_row) {
+        for (into, &from) in into_row.chunks_mut(4).zip(from_row) {
+            let data =
+                core::array::from_fn::<u8, 4, _>(|i| 0xaa * bits_extract::<2>(from, i as u8));
+            into.copy_from_slice(&data[..into.len()]);
+        }
+    }
+}
+
+fn expand_4bit(from: &[u8], samples_per_padded: u64, into: &mut [u8]) {
+    let stride = samples_per_padded.div_ceil(2);
+
+    let from_row = from.chunks_exact(stride as usize);
+    let into_row = into.chunks_exact_mut(samples_per_padded as usize);
+
+    for (from_row, into_row) in from_row.zip(into_row) {
+        for (into, &from) in into_row.chunks_mut(2).zip(from_row) {
+            let data =
+                core::array::from_fn::<u8, 2, _>(|i| 0x88 * bits_extract::<4>(from, i as u8));
+            into.copy_from_slice(&data[..into.len()]);
+        }
+    }
+}

examples/profile_decode.rs

@@ -0,0 +1,130 @@
+//! Profiling helper: encodes and decodes several TIFF configurations.
+//! Run under callgrind: `valgrind --tool=callgrind target/release/examples/profile_decode`
+use std::io::Cursor;
+use tiff::decoder::Decoder;
+use tiff::encoder::colortype::{Gray8, RGB32Float, RGB16, RGB8};
+use tiff::encoder::{Compression, Predictor, TiffEncoder};
+
+const WIDTH: u32 = 2048;
+const HEIGHT: u32 = 2048;
+const ITERS: usize = 3;
+
+fn generate_rgb8(w: u32, h: u32) -> Vec<u8> {
+    (0..w * h * 3).map(|i| (i % 256) as u8).collect()
+}
+
+fn generate_rgb16(w: u32, h: u32) -> Vec<u16> {
+    (0..w * h * 3).map(|i| (i % 65536) as u16).collect()
+}
+
+fn generate_rgb_f32(w: u32, h: u32) -> Vec<f32> {
+    (0..w * h * 3)
+        .map(|i| (i as f32) / (w * h * 3) as f32)
+        .collect()
+}
+
+fn generate_gray8(w: u32, h: u32) -> Vec<u8> {
+    (0..w * h).map(|i| (i % 256) as u8).collect()
+}
+
+fn encode<C: tiff::encoder::colortype::ColorType>(
+    data: &[C::Inner],
+    w: u32,
+    h: u32,
+    compression: Compression,
+    predictor: Predictor,
+) -> Vec<u8>
+where
+    [C::Inner]: tiff::encoder::TiffValue,
+{
+    let mut buf = Cursor::new(Vec::new());
+    TiffEncoder::new(&mut buf)
+        .unwrap()
+        .with_predictor(predictor)
+        .with_compression(compression)
+        .write_image::<C>(w, h, data)
+        .unwrap();
+    buf.into_inner()
+}
+
+fn decode(data: &[u8]) {
+    let cursor = Cursor::new(data);
+    let mut decoder = Decoder::open(cursor).unwrap();
+    decoder.next_image().unwrap();
+    let _ = decoder.read_image().unwrap();
+}
+
+fn main() {
+    let rgb8 = generate_rgb8(WIDTH, HEIGHT);
+    let rgb16 = generate_rgb16(WIDTH, HEIGHT);
+    let rgb_f32 = generate_rgb_f32(WIDTH, HEIGHT);
+    let gray8 = generate_gray8(WIDTH, HEIGHT);
+
+    let cases: Vec<(&str, Vec<u8>)> = vec![
+        (
+            "deflate-rgb8-hpredict",
+            encode::<RGB8>(
+                &rgb8,
+                WIDTH,
+                HEIGHT,
+                Compression::Deflate(1),
+                Predictor::Horizontal,
+            ),
+        ),
+        (
+            "deflate-gray8-hpredict",
+            encode::<Gray8>(
+                &gray8,
+                WIDTH,
+                HEIGHT,
+                Compression::Deflate(1),
+                Predictor::Horizontal,
+            ),
+        ),
+        (
+            "deflate-rgb16-hpredict",
+            encode::<RGB16>(
+                &rgb16,
+                WIDTH,
+                HEIGHT,
+                Compression::Deflate(1),
+                Predictor::Horizontal,
+            ),
+        ),
+        (
+            "deflate-rgb-f32-fpredict",
+            encode::<RGB32Float>(
+                &rgb_f32,
+                WIDTH,
+                HEIGHT,
+                Compression::Deflate(1),
+                Predictor::FloatingPoint,
+            ),
+        ),
+        (
+            "lzw-rgb8-no-pred",
+            encode::<RGB8>(&rgb8, WIDTH, HEIGHT, Compression::Lzw, Predictor::None),
+        ),
+        (
+            "lzw-rgb8-hpredict",
+            encode::<RGB8>(
+                &rgb8,
+                WIDTH,
+                HEIGHT,
+                Compression::Lzw,
+                Predictor::Horizontal,
+            ),
+        ),
+    ];
+
+    for (name, tiff_data) in &cases {
+        eprintln!(
+            "=== Profiling: {} ({} bytes encoded) ===",
+            name,
+            tiff_data.len()
+        );
+        for _ in 0..ITERS {
+            decode(tiff_data);
+        }
+    }
+}

examples/tiff-ls.rs

@@ -0,0 +1,121 @@
+use std::borrow::Cow;
+
+use tiff::decoder::Decoder;
+
+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::open(io)?;
+
+    while reader.more_images() {
+        reader.next_directory()?;
+        ls_dir(&mut reader);
+    }
+
+    Ok(())
+}
+
+fn ls_dir<R: std::io::Read + std::io::Seek>(reader: &mut Decoder<R>) {
+    if let Some(ifd) = reader.ifd_pointer() {
+        println!("Directory at {ifd:x}");
+    }
+
+    println!("Name\tHex\tType\tCount");
+    let ifd = reader.current_ifd();
+
+    for (tag, entry) in ifd.directory().iter() {
+        let name: &'static str = match tag {
+            tiff::tags::Tag::Artist => "Artist",
+            tiff::tags::Tag::BitsPerSample => "BitsPerSample",
+            tiff::tags::Tag::CellLength => "CellLength",
+            tiff::tags::Tag::CellWidth => "CellWidth",
+            tiff::tags::Tag::ColorMap => "ColorMap",
+            tiff::tags::Tag::Compression => "Compression",
+            tiff::tags::Tag::DateTime => "DateTime",
+            tiff::tags::Tag::ExtraSamples => "ExtraSamples",
+            tiff::tags::Tag::FillOrder => "FillOrder",
+            tiff::tags::Tag::FreeByteCounts => "FreeByteCounts",
+            tiff::tags::Tag::FreeOffsets => "FreeOffsets",
+            tiff::tags::Tag::GrayResponseCurve => "GrayResponseCurve",
+            tiff::tags::Tag::GrayResponseUnit => "GrayResponseUnit",
+            tiff::tags::Tag::HostComputer => "HostComputer",
+            tiff::tags::Tag::ImageDescription => "ImageDescription",
+            tiff::tags::Tag::ImageLength => "ImageLength",
+            tiff::tags::Tag::ImageWidth => "ImageWidth",
+            tiff::tags::Tag::Make => "Make",
+            tiff::tags::Tag::MaxSampleValue => "MaxSampleValue",
+            tiff::tags::Tag::MinSampleValue => "MinSampleValue",
+            tiff::tags::Tag::Model => "Model",
+            tiff::tags::Tag::NewSubfileType => "NewSubfileType",
+            tiff::tags::Tag::Orientation => "Orientation",
+            tiff::tags::Tag::PhotometricInterpretation => "PhotometricInterpretation",
+            tiff::tags::Tag::PlanarConfiguration => "PlanarConfiguration",
+            tiff::tags::Tag::ResolutionUnit => "ResolutionUnit",
+            tiff::tags::Tag::RowsPerStrip => "RowsPerStrip",
+            tiff::tags::Tag::SamplesPerPixel => "SamplesPerPixel",
+            tiff::tags::Tag::Software => "Software",
+            tiff::tags::Tag::StripByteCounts => "StripByteCounts",
+            tiff::tags::Tag::StripOffsets => "StripOffsets",
+            tiff::tags::Tag::SubfileType => "SubfileType",
+            tiff::tags::Tag::Threshholding => "Threshholding",
+            tiff::tags::Tag::XResolution => "XResolution",
+            tiff::tags::Tag::YResolution => "YResolution",
+            tiff::tags::Tag::Predictor => "Predictor",
+            tiff::tags::Tag::TileWidth => "TileWidth",
+            tiff::tags::Tag::TileLength => "TileLength",
+            tiff::tags::Tag::TileOffsets => "TileOffsets",
+            tiff::tags::Tag::TileByteCounts => "TileByteCounts",
+            tiff::tags::Tag::SubIfd => "SubIfd",
+            tiff::tags::Tag::SampleFormat => "SampleFormat",
+            tiff::tags::Tag::SMinSampleValue => "SMinSampleValue",
+            tiff::tags::Tag::SMaxSampleValue => "SMaxSampleValue",
+            tiff::tags::Tag::JPEGTables => "JPEGTables",
+            tiff::tags::Tag::ChromaSubsampling => "ChromaSubsampling",
+            tiff::tags::Tag::ChromaPositioning => "ChromaPositioning",
+            tiff::tags::Tag::ModelPixelScaleTag => "ModelPixelScaleTag",
+            tiff::tags::Tag::ModelTransformationTag => "ModelTransformationTag",
+            tiff::tags::Tag::ModelTiepointTag => "ModelTiepointTag",
+            tiff::tags::Tag::Copyright => "Copyright",
+            tiff::tags::Tag::ExifDirectory => "ExifDirectory",
+            tiff::tags::Tag::GpsDirectory => "GpsDirectory",
+            tiff::tags::Tag::IccProfile => "IccProfile",
+            tiff::tags::Tag::GeoKeyDirectoryTag => "GeoKeyDirectoryTag",
+            tiff::tags::Tag::GeoDoubleParamsTag => "GeoDoubleParamsTag",
+            tiff::tags::Tag::GeoAsciiParamsTag => "GeoAsciiParamsTag",
+            tiff::tags::Tag::ExifVersion => "ExifVersion",
+            tiff::tags::Tag::GdalNodata => "GdalNodata",
+            _ => "<unknown>",
+        };
+
+        let ty: Cow<'static, str> = match entry.field_type() {
+            tiff::tags::Type::BYTE => "u8".into(),
+            tiff::tags::Type::ASCII => "ascii".into(),
+            tiff::tags::Type::SHORT => "u16".into(),
+            tiff::tags::Type::LONG => "u32".into(),
+            tiff::tags::Type::RATIONAL => "r32".into(),
+            tiff::tags::Type::SBYTE => "i8".into(),
+            tiff::tags::Type::UNDEFINED => "byte".into(),
+            tiff::tags::Type::SSHORT => "s16".into(),
+            tiff::tags::Type::SLONG => "s32".into(),
+            tiff::tags::Type::SRATIONAL => "sr32".into(),
+            tiff::tags::Type::FLOAT => "f32".into(),
+            tiff::tags::Type::DOUBLE => "f64".into(),
+            tiff::tags::Type::IFD => "ifd32".into(),
+            tiff::tags::Type::LONG8 => "u64".into(),
+            tiff::tags::Type::SLONG8 => "i64".into(),
+            tiff::tags::Type::IFD8 => "ifd64".into(),
+            other => format!("{:x}", other.to_u16()).into(),
+        };
+
+        eprintln!(
+            "{name:16}\t{tag:4x}\t{ty}\t{count}",
+            tag = tag.to_u16(),
+            count = entry.count(),
+        );
+    }
+}

fuzz/.gitignore

@@ -0,0 +1,3 @@
+target
+corpus
+artifacts

fuzz/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "tiff-fuzz"
+version = "0.0.0"
+authors = ["Automatically generated"]
+publish = false
+edition = "2018"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+
+[dependencies.tiff]
+path = ".."
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "decode_comprehensive"
+path = "fuzz_targets/decode_comprehensive.rs"
+test = false
+doc = false

fuzz/fuzz_targets/decode_comprehensive.rs

@@ -0,0 +1,96 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use std::io::{Cursor, Read, Seek};
+use tiff::decoder::{Decoder, Limits};
+use tiff::tags::Tag;
+
+fuzz_target!(|data: &[u8]| {
+    // Standalone header parse (separate code path from Decoder::open)
+    let _ = tiff::decoder::TiffHeader::parse(Cursor::new(data));
+
+    let mut decoder = match Decoder::open(Cursor::new(data)) {
+        Ok(d) => d,
+        Err(_) => return,
+    };
+
+    let mut limits = Limits::default();
+    limits.decoding_buffer_size = 512 * 1024;
+    limits.ifd_value_size = 64 * 1024;
+    limits.intermediate_buffer_size = 512 * 1024;
+    decoder = decoder.with_limits(limits);
+
+    // Probe first IFD (opened but image not yet parsed)
+    probe_directory(&mut decoder);
+
+    // Linear IFD iteration via next_directory — tolerates invalid
+    // intermediate IFDs that aren't decodable as images
+    let mut ifd_count = 1u32;
+    while decoder.more_images() && ifd_count < 8 {
+        if decoder.next_directory().is_err() {
+            break;
+        }
+        probe_directory(&mut decoder);
+        ifd_count += 1;
+    }
+
+    // Random-access traversal via seek (different code path: find_nth_ifd
+    // re-walks the IFD chain from the start each time)
+    for i in 0..ifd_count.min(4) as usize {
+        if decoder.seek_to_directory(i).is_ok() {
+            probe_directory(&mut decoder);
+        }
+        // seek_to_image eagerly parses the directory as an Image
+        let _ = decoder.seek_to_image(i);
+    }
+});
+
+fn probe_directory<R: Read + Seek>(decoder: &mut Decoder<R>) {
+    // Tag iteration — exercises value parsing for every tag in the IFD
+    for result in decoder.current_ifd().tag_iter() {
+        let _ = result;
+    }
+
+    // SubIFD / EXIF / GPS directory traversal — exercises read_directory
+    // with potentially adversarial offsets
+    if let Ok(Some(val)) = decoder.current_ifd().find_tag(Tag::SubIfd) {
+        if let Ok(ptrs) = val.into_ifd_vec() {
+            for ptr in ptrs.into_iter().take(4) {
+                let _ = decoder.read_directory(ptr);
+            }
+        }
+    }
+    for tag in [Tag::ExifDirectory, Tag::GpsDirectory] {
+        if let Ok(Some(val)) = decoder.current_ifd().find_tag(tag) {
+            if let Ok(ptr) = val.into_ifd_pointer() {
+                let _ = decoder.read_directory(ptr);
+            }
+        }
+    }
+
+    // Image-level probing — dimensions() triggers ensure_image,
+    // which lazily parses the directory as an Image
+    if decoder.dimensions().is_ok() {
+        let _ = decoder.colortype();
+        let _ = decoder.color_map();
+        let _ = decoder.get_chunk_type();
+        let _ = decoder.chunk_dimensions();
+        let _ = decoder.strip_count();
+        let _ = decoder.tile_count();
+        let _ = decoder.image_buffer_layout();
+        let _ = decoder.image_chunk_buffer_layout(0);
+
+        // Chunk reads at boundaries — first and last exercise
+        // different offset calculations
+        let _ = decoder.read_chunk(0);
+        let chunk_count = decoder
+            .strip_count()
+            .or_else(|_| decoder.tile_count())
+            .unwrap_or(0);
+        if chunk_count > 1 {
+            let _ = decoder.read_chunk(chunk_count - 1);
+        }
+
+        // Full image decode
+        let _ = decoder.read_image();
+    }
+}

fuzz/tiff.dict

@@ -0,0 +1,139 @@
+# === File headers ===
+
+# Classic TIFF (LE, BE)
+"\x49\x49\x2A\x00"
+"\x4D\x4D\x00\x2A"
+# BigTIFF (LE, BE) — version 43, 8-byte offsets, different parsing paths
+"\x49\x49\x2B\x00\x08\x00\x00\x00"
+"\x4D\x4D\x00\x2B\x00\x08\x00\x00"
+
+# === IFD field type codes (2-byte LE) ===
+# Decoder switches on these; wrong types exercise error paths
+
+"\x01\x00"
+"\x02\x00"
+"\x03\x00"
+"\x04\x00"
+"\x05\x00"
+"\x06\x00"
+"\x07\x00"
+"\x08\x00"
+"\x09\x00"
+"\x0A\x00"
+"\x0B\x00"
+"\x0C\x00"
+"\x0D\x00"
+"\x10\x00"
+"\x11\x00"
+"\x12\x00"
+
+# === IFD tag numbers (2-byte LE) ===
+
+# 256=ImageWidth 257=ImageLength 258=BitsPerSample
+"\x00\x01"
+"\x01\x01"
+"\x02\x01"
+# 259=Compression 262=PhotometricInterpretation
+"\x03\x01"
+"\x06\x01"
+# 273=StripOffsets 274=Orientation
+"\x11\x01"
+"\x12\x01"
+# 277=SamplesPerPixel 278=RowsPerStrip 279=StripByteCounts
+"\x15\x01"
+"\x16\x01"
+"\x17\x01"
+# 282=XResolution 283=YResolution 284=PlanarConfiguration
+"\x1A\x01"
+"\x1B\x01"
+"\x1C\x01"
+# 317=Predictor 320=ColorMap
+"\x3D\x01"
+"\x40\x01"
+# 322=TileWidth 323=TileLength 324=TileOffsets 325=TileByteCounts
+"\x42\x01"
+"\x43\x01"
+"\x44\x01"
+"\x45\x01"
+# 330=SubIfd 338=ExtraSamples 339=SampleFormat
+"\x4A\x01"
+"\x52\x01"
+"\x53\x01"
+# 347=JPEGTables 530=ChromaSubsampling
+"\x5B\x01"
+"\x12\x02"
+# 34665=ExifDirectory 34675=IccProfile 34853=GpsDirectory
+"\x69\x87"
+"\x73\x87"
+"\x25\x88"
+
+# === IFD tag numbers (2-byte BE) ===
+
+"\x01\x00"
+"\x01\x01"
+"\x01\x02"
+"\x01\x03"
+"\x01\x06"
+"\x01\x11"
+"\x01\x12"
+"\x01\x15"
+"\x01\x16"
+"\x01\x17"
+"\x01\x1A"
+"\x01\x1B"
+"\x01\x1C"
+"\x01\x3D"
+"\x01\x40"
+"\x01\x42"
+"\x01\x43"
+"\x01\x44"
+"\x01\x45"
+"\x01\x4A"
+"\x01\x52"
+"\x01\x53"
+"\x01\x5B"
+"\x02\x12"
+"\x87\x69"
+"\x87\x73"
+"\x88\x25"
+
+# === Compression codes (4-byte LE inline SHORT values) ===
+# These are the values stored in the IFD entry for tag 259
+
+# 1=None 2=Huffman 3=Fax3 4=Fax4 5=LZW
+"\x01\x00\x00\x00"
+"\x02\x00\x00\x00"
+"\x03\x00\x00\x00"
+"\x04\x00\x00\x00"
+"\x05\x00\x00\x00"
+# 6=OldJPEG 7=ModernJPEG 8=Deflate
+"\x06\x00\x00\x00"
+"\x07\x00\x00\x00"
+"\x08\x00\x00\x00"
+# 0x8005=PackBits 0x80B2=OldDeflate
+"\x05\x80\x00\x00"
+"\xB2\x80\x00\x00"
+
+# === Useful small values (4-byte LE) ===
+# BitsPerSample=16, =32 (8 already covered as Deflate compression above)
+
+"\x10\x00\x00\x00"
+"\x20\x00\x00\x00"
+
+# === Minimal IFD entries (12-byte LE: tag + type SHORT + count 1 + value) ===
+# These let the fuzzer splice complete valid entries into an IFD
+
+# ImageWidth=1
+"\x00\x01\x03\x00\x01\x00\x00\x00\x01\x00\x00\x00"
+# ImageLength=1
+"\x01\x01\x03\x00\x01\x00\x00\x00\x01\x00\x00\x00"
+# BitsPerSample=8
+"\x02\x01\x03\x00\x01\x00\x00\x00\x08\x00\x00\x00"
+# Compression=None
+"\x03\x01\x03\x00\x01\x00\x00\x00\x01\x00\x00\x00"
+# PhotometricInterpretation=BlackIsZero
+"\x06\x01\x03\x00\x01\x00\x00\x00\x01\x00\x00\x00"
+# SamplesPerPixel=1
+"\x15\x01\x03\x00\x01\x00\x00\x00\x01\x00\x00\x00"
+# RowsPerStrip=1
+"\x16\x01\x03\x00\x01\x00\x00\x00\x01\x00\x00\x00"

src/bytecast.rs

@@ -0,0 +1,40 @@
+//! Trivial, internal byte transmutation.
+//!
+//! A dependency like bytemuck would give us extra assurance of the safety but overall would not
+//! reduce the amount of total unsafety. We don't use it in the interface where the traits would
+//! really become useful.
+//!
+//! SAFETY: These are benign casts as we apply them to fixed size integer types only. All of them
+//! are naturally aligned, valid for all bit patterns and their alignment is surely at most their
+//! size (we assert the latter fact since it is 'implementation defined' if following the letter of
+//! 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>());
+        unsafe { slice::from_raw_parts(slice.as_ptr() as *const u8, mem::size_of_val(slice)) }
+    }
+    $(pub(crate) fn $mut(slice: &mut [$int]) -> &mut [u8] {
+        assert!(mem::align_of::<$int>() <= mem::size_of::<$int>());
+        unsafe { slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut u8, mem::size_of_val(slice)) }
+    })*
+}}
+
+integral_slice_as_bytes!(i8, i8_as_ne_bytes, i8_as_ne_mut_bytes);
+integral_slice_as_bytes!(u16, u16_as_ne_bytes, u16_as_ne_mut_bytes);
+integral_slice_as_bytes!(i16, i16_as_ne_bytes, i16_as_ne_mut_bytes);
+integral_slice_as_bytes!(u32, u32_as_ne_bytes, u32_as_ne_mut_bytes);
+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/buffer.rs

@@ -0,0 +1,410 @@
+use half::f16;
+use std::alloc::{Layout, LayoutError};
+
+use crate::{
+    bytecast,
+    decoder::{BufferLayoutPreference, Limits},
+    error::{TiffError, TiffResult, TiffUnsupportedError},
+    tags::{ByteOrder, EndianBytes, SampleFormat},
+};
+
+/// Result of a decoding process
+#[derive(Debug)]
+pub enum DecodingSampleBuffer {
+    /// A vector of unsigned bytes
+    U8(Vec<u8>),
+    /// A vector of unsigned words
+    U16(Vec<u16>),
+    /// A vector of 32 bit unsigned ints
+    U32(Vec<u32>),
+    /// A vector of 64 bit unsigned ints
+    U64(Vec<u64>),
+    /// A vector of 16 bit IEEE floats (held in u16)
+    F16(Vec<f16>),
+    /// A vector of 32 bit IEEE floats
+    F32(Vec<f32>),
+    /// A vector of 64 bit IEEE floats
+    F64(Vec<f64>),
+    /// A vector of 8 bit signed ints
+    I8(Vec<i8>),
+    /// A vector of 16 bit signed ints
+    I16(Vec<i16>),
+    /// A vector of 32 bit signed ints
+    I32(Vec<i32>),
+    /// A vector of 64 bit signed ints
+    I64(Vec<i64>),
+}
+
+impl DecodingSampleBuffer {
+    /// Reallocate the buffer to decode all planes of the indicated layout.
+    pub fn resize_to(
+        &mut self,
+        buffer: &BufferLayoutPreference,
+        limits: &Limits,
+    ) -> Result<(), TiffError> {
+        let sample_type = buffer.sample_type.ok_or(TiffError::UnsupportedError(
+            TiffUnsupportedError::UnknownInterpretation,
+        ))?;
+
+        let extent = sample_type.extent_for_bytes(buffer.complete_len);
+        self.resize_to_extent(extent, limits)
+    }
+
+    pub(crate) fn resize_to_extent(
+        &mut self,
+        extent: DecodingExtent,
+        limits: &Limits,
+    ) -> Result<(), TiffError> {
+        // FIXME: we *can* reuse the allocation sometimes.
+        *self = extent.to_result_buffer(limits)?;
+        Ok(())
+    }
+
+    fn new<T: Default + Copy>(
+        size: usize,
+        limits: &Limits,
+        from_fn: fn(Vec<T>) -> Self,
+    ) -> TiffResult<DecodingSampleBuffer> {
+        if size > limits.decoding_buffer_size / core::mem::size_of::<T>() {
+            Err(TiffError::LimitsExceeded)
+        } else {
+            Ok(from_fn(vec![T::default(); size]))
+        }
+    }
+
+    fn new_u8(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::U8)
+    }
+
+    fn new_u16(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::U16)
+    }
+
+    fn new_u32(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::U32)
+    }
+
+    fn new_u64(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::U64)
+    }
+
+    fn new_f32(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::F32)
+    }
+
+    fn new_f64(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::F64)
+    }
+
+    fn new_f16(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::F16)
+    }
+
+    fn new_i8(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::I8)
+    }
+
+    fn new_i16(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::I16)
+    }
+
+    fn new_i32(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::I32)
+    }
+
+    fn new_i64(size: usize, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        Self::new(size, limits, DecodingSampleBuffer::I64)
+    }
+
+    /// Get a view of this buffer starting from the nth _sample_ of the current type.
+    pub fn as_buffer(&mut self, start: usize) -> DecodingSampleSlice<'_> {
+        match *self {
+            DecodingSampleBuffer::U8(ref mut buf) => DecodingSampleSlice::U8(&mut buf[start..]),
+            DecodingSampleBuffer::U16(ref mut buf) => DecodingSampleSlice::U16(&mut buf[start..]),
+            DecodingSampleBuffer::U32(ref mut buf) => DecodingSampleSlice::U32(&mut buf[start..]),
+            DecodingSampleBuffer::U64(ref mut buf) => DecodingSampleSlice::U64(&mut buf[start..]),
+            DecodingSampleBuffer::F16(ref mut buf) => DecodingSampleSlice::F16(&mut buf[start..]),
+            DecodingSampleBuffer::F32(ref mut buf) => DecodingSampleSlice::F32(&mut buf[start..]),
+            DecodingSampleBuffer::F64(ref mut buf) => DecodingSampleSlice::F64(&mut buf[start..]),
+            DecodingSampleBuffer::I8(ref mut buf) => DecodingSampleSlice::I8(&mut buf[start..]),
+            DecodingSampleBuffer::I16(ref mut buf) => DecodingSampleSlice::I16(&mut buf[start..]),
+            DecodingSampleBuffer::I32(ref mut buf) => DecodingSampleSlice::I32(&mut buf[start..]),
+            DecodingSampleBuffer::I64(ref mut buf) => DecodingSampleSlice::I64(&mut buf[start..]),
+        }
+    }
+
+    pub fn sample_type(&self) -> DecodingSampleType {
+        match *self {
+            DecodingSampleBuffer::U8(_) => DecodingSampleType::U8,
+            DecodingSampleBuffer::U16(_) => DecodingSampleType::U16,
+            DecodingSampleBuffer::U32(_) => DecodingSampleType::U32,
+            DecodingSampleBuffer::U64(_) => DecodingSampleType::U64,
+            DecodingSampleBuffer::F16(_) => DecodingSampleType::F16,
+            DecodingSampleBuffer::F32(_) => DecodingSampleType::F32,
+            DecodingSampleBuffer::F64(_) => DecodingSampleType::F64,
+            DecodingSampleBuffer::I8(_) => DecodingSampleType::I8,
+            DecodingSampleBuffer::I16(_) => DecodingSampleType::I16,
+            DecodingSampleBuffer::I32(_) => DecodingSampleType::I32,
+            DecodingSampleBuffer::I64(_) => DecodingSampleType::I64,
+        }
+    }
+
+    /// Change the endianess of buffered data.
+    ///
+    /// This utility may be used to prepare a buffer for consumption by methods taking raw bytes or
+    /// after filling the buffer with raw bytes.
+    ///
+    /// After this, interpreting the buffer on the host may no longer produce any reasonable
+    /// results. For instance, floats in the wrong byte order may produce a `NaN` with varying
+    /// payloads. Despite unexpected result however, this operation is always sound.
+    pub fn convert_endian(&mut self, from: ByteOrder, to: ByteOrder) {
+        self.as_buffer(0).convert_endian(from, to)
+    }
+}
+
+// A buffer for image decoding
+pub enum DecodingSampleSlice<'a> {
+    /// A slice of unsigned bytes
+    U8(&'a mut [u8]),
+    /// A slice of unsigned words
+    U16(&'a mut [u16]),
+    /// A slice of 32 bit unsigned ints
+    U32(&'a mut [u32]),
+    /// A slice of 64 bit unsigned ints
+    U64(&'a mut [u64]),
+    /// A slice of 16 bit IEEE floats
+    F16(&'a mut [f16]),
+    /// A slice of 32 bit IEEE floats
+    F32(&'a mut [f32]),
+    /// A slice of 64 bit IEEE floats
+    F64(&'a mut [f64]),
+    /// A slice of 8 bits signed ints
+    I8(&'a mut [i8]),
+    /// A slice of 16 bits signed ints
+    I16(&'a mut [i16]),
+    /// A slice of 32 bits signed ints
+    I32(&'a mut [i32]),
+    /// A slice of 64 bits signed ints
+    I64(&'a mut [i64]),
+}
+
+impl<'a> DecodingSampleSlice<'a> {
+    pub fn as_bytes(&self) -> &[u8] {
+        match self {
+            DecodingSampleSlice::U8(buf) => buf,
+            DecodingSampleSlice::I8(buf) => bytecast::i8_as_ne_bytes(buf),
+            DecodingSampleSlice::U16(buf) => bytecast::u16_as_ne_bytes(buf),
+            DecodingSampleSlice::I16(buf) => bytecast::i16_as_ne_bytes(buf),
+            DecodingSampleSlice::U32(buf) => bytecast::u32_as_ne_bytes(buf),
+            DecodingSampleSlice::I32(buf) => bytecast::i32_as_ne_bytes(buf),
+            DecodingSampleSlice::U64(buf) => bytecast::u64_as_ne_bytes(buf),
+            DecodingSampleSlice::I64(buf) => bytecast::i64_as_ne_bytes(buf),
+            DecodingSampleSlice::F16(buf) => bytecast::f16_as_ne_bytes(buf),
+            DecodingSampleSlice::F32(buf) => bytecast::f32_as_ne_bytes(buf),
+            DecodingSampleSlice::F64(buf) => bytecast::f64_as_ne_bytes(buf),
+        }
+    }
+
+    pub fn as_bytes_mut(&mut self) -> &mut [u8] {
+        match self {
+            DecodingSampleSlice::U8(buf) => buf,
+            DecodingSampleSlice::I8(buf) => bytecast::i8_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::U16(buf) => bytecast::u16_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::I16(buf) => bytecast::i16_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::U32(buf) => bytecast::u32_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::I32(buf) => bytecast::i32_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::U64(buf) => bytecast::u64_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::I64(buf) => bytecast::i64_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::F16(buf) => bytecast::f16_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::F32(buf) => bytecast::f32_as_ne_mut_bytes(buf),
+            DecodingSampleSlice::F64(buf) => bytecast::f64_as_ne_mut_bytes(buf),
+        }
+    }
+
+    pub fn reborrow(&mut self) -> DecodingSampleSlice<'_> {
+        match self {
+            DecodingSampleSlice::U8(items) => DecodingSampleSlice::U8(items),
+            DecodingSampleSlice::I8(items) => DecodingSampleSlice::I8(items),
+            DecodingSampleSlice::U16(items) => DecodingSampleSlice::U16(items),
+            DecodingSampleSlice::I16(items) => DecodingSampleSlice::I16(items),
+            DecodingSampleSlice::U32(items) => DecodingSampleSlice::U32(items),
+            DecodingSampleSlice::I32(items) => DecodingSampleSlice::I32(items),
+            DecodingSampleSlice::U64(items) => DecodingSampleSlice::U64(items),
+            DecodingSampleSlice::I64(items) => DecodingSampleSlice::I64(items),
+            DecodingSampleSlice::F16(items) => DecodingSampleSlice::F16(items),
+            DecodingSampleSlice::F32(items) => DecodingSampleSlice::F32(items),
+            DecodingSampleSlice::F64(items) => DecodingSampleSlice::F64(items),
+        }
+    }
+
+    pub fn sample_type(&self) -> DecodingSampleType {
+        match *self {
+            DecodingSampleSlice::U8(_) => DecodingSampleType::U8,
+            DecodingSampleSlice::U16(_) => DecodingSampleType::U16,
+            DecodingSampleSlice::U32(_) => DecodingSampleType::U32,
+            DecodingSampleSlice::U64(_) => DecodingSampleType::U64,
+            DecodingSampleSlice::F16(_) => DecodingSampleType::F16,
+            DecodingSampleSlice::F32(_) => DecodingSampleType::F32,
+            DecodingSampleSlice::F64(_) => DecodingSampleType::F64,
+            DecodingSampleSlice::I8(_) => DecodingSampleType::I8,
+            DecodingSampleSlice::I16(_) => DecodingSampleType::I16,
+            DecodingSampleSlice::I32(_) => DecodingSampleType::I32,
+            DecodingSampleSlice::I64(_) => DecodingSampleType::I64,
+        }
+    }
+
+    /// Change the endianess of referenced data.
+    ///
+    /// This utility may be used to prepare a buffer for consumption by methods taking raw bytes or
+    /// after filling the buffer with raw bytes.
+    ///
+    /// After this, interpreting the buffer on the host may no longer produce any reasonable
+    /// results. For instance, floats in the wrong byte order may produce a `NaN` with varying
+    /// payloads. Despite unexpected result however, this operation is always sound.
+    pub fn convert_endian(&mut self, from: ByteOrder, to: ByteOrder) {
+        let byte_unit = self.sample_type().endian_bytes();
+        from.convert_endian_bytes(byte_unit, self.as_bytes_mut(), to);
+    }
+
+    pub fn byte_len(&self) -> usize {
+        self.as_bytes().len()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum DecodingSampleType {
+    U8,
+    U16,
+    U32,
+    U64,
+    F16,
+    F32,
+    F64,
+    I8,
+    I16,
+    I32,
+    I64,
+}
+
+impl DecodingSampleType {
+    pub fn sample_format(self) -> SampleFormat {
+        match self {
+            DecodingSampleType::U8 => SampleFormat::Uint,
+            DecodingSampleType::U16 => SampleFormat::Uint,
+            DecodingSampleType::U32 => SampleFormat::Uint,
+            DecodingSampleType::U64 => SampleFormat::Uint,
+            DecodingSampleType::F16 => SampleFormat::IEEEFP,
+            DecodingSampleType::F32 => SampleFormat::IEEEFP,
+            DecodingSampleType::F64 => SampleFormat::IEEEFP,
+            DecodingSampleType::I8 => SampleFormat::Int,
+            DecodingSampleType::I16 => SampleFormat::Int,
+            DecodingSampleType::I32 => SampleFormat::Int,
+            DecodingSampleType::I64 => SampleFormat::Int,
+        }
+    }
+
+    pub(crate) fn extent_for_bytes(self, bytes: usize) -> DecodingExtent {
+        match self {
+            DecodingSampleType::U8 => DecodingExtent::U8(bytes),
+            DecodingSampleType::U16 => DecodingExtent::U16(bytes.div_ceil(2)),
+            DecodingSampleType::U32 => DecodingExtent::U32(bytes.div_ceil(4)),
+            DecodingSampleType::U64 => DecodingExtent::U64(bytes.div_ceil(8)),
+            DecodingSampleType::I8 => DecodingExtent::I8(bytes),
+            DecodingSampleType::I16 => DecodingExtent::I16(bytes.div_ceil(2)),
+            DecodingSampleType::I32 => DecodingExtent::I32(bytes.div_ceil(4)),
+            DecodingSampleType::I64 => DecodingExtent::I64(bytes.div_ceil(8)),
+            DecodingSampleType::F16 => DecodingExtent::F16(bytes.div_ceil(2)),
+            DecodingSampleType::F32 => DecodingExtent::F32(bytes.div_ceil(4)),
+            DecodingSampleType::F64 => DecodingExtent::F64(bytes.div_ceil(8)),
+        }
+    }
+
+    fn endian_bytes(self) -> EndianBytes {
+        use EndianBytes::*;
+
+        match self {
+            DecodingSampleType::U8 => One,
+            DecodingSampleType::U16 => Two,
+            DecodingSampleType::U32 => Four,
+            DecodingSampleType::U64 => Eight,
+            DecodingSampleType::F16 => Two,
+            DecodingSampleType::F32 => Four,
+            DecodingSampleType::F64 => Eight,
+            DecodingSampleType::I8 => One,
+            DecodingSampleType::I16 => Two,
+            DecodingSampleType::I32 => Four,
+            DecodingSampleType::I64 => Eight,
+        }
+    }
+}
+
+/// The count and matching discriminant for a `DecodingBuffer`.
+#[derive(Clone)]
+pub(crate) enum DecodingExtent {
+    U8(usize),
+    U16(usize),
+    U32(usize),
+    U64(usize),
+    F16(usize),
+    F32(usize),
+    F64(usize),
+    I8(usize),
+    I16(usize),
+    I32(usize),
+    I64(usize),
+}
+
+impl DecodingExtent {
+    pub(crate) fn to_result_buffer(&self, limits: &Limits) -> TiffResult<DecodingSampleBuffer> {
+        match *self {
+            DecodingExtent::U8(count) => DecodingSampleBuffer::new_u8(count, limits),
+            DecodingExtent::U16(count) => DecodingSampleBuffer::new_u16(count, limits),
+            DecodingExtent::U32(count) => DecodingSampleBuffer::new_u32(count, limits),
+            DecodingExtent::U64(count) => DecodingSampleBuffer::new_u64(count, limits),
+            DecodingExtent::F16(count) => DecodingSampleBuffer::new_f16(count, limits),
+            DecodingExtent::F32(count) => DecodingSampleBuffer::new_f32(count, limits),
+            DecodingExtent::F64(count) => DecodingSampleBuffer::new_f64(count, limits),
+            DecodingExtent::I8(count) => DecodingSampleBuffer::new_i8(count, limits),
+            DecodingExtent::I16(count) => DecodingSampleBuffer::new_i16(count, limits),
+            DecodingExtent::I32(count) => DecodingSampleBuffer::new_i32(count, limits),
+            DecodingExtent::I64(count) => DecodingSampleBuffer::new_i64(count, limits),
+        }
+    }
+
+    pub(crate) fn preferred_layout(self) -> TiffResult<Layout> {
+        fn overflow(_: LayoutError) -> TiffError {
+            TiffError::LimitsExceeded
+        }
+
+        match self {
+            DecodingExtent::U8(count) => Layout::array::<u8>(count),
+            DecodingExtent::U16(count) => Layout::array::<u16>(count),
+            DecodingExtent::U32(count) => Layout::array::<u32>(count),
+            DecodingExtent::U64(count) => Layout::array::<u64>(count),
+            DecodingExtent::F16(count) => Layout::array::<f16>(count),
+            DecodingExtent::F32(count) => Layout::array::<f32>(count),
+            DecodingExtent::F64(count) => Layout::array::<f64>(count),
+            DecodingExtent::I8(count) => Layout::array::<i8>(count),
+            DecodingExtent::I16(count) => Layout::array::<i16>(count),
+            DecodingExtent::I32(count) => Layout::array::<i32>(count),
+            DecodingExtent::I64(count) => Layout::array::<i64>(count),
+        }
+        .map_err(overflow)
+    }
+
+    pub(crate) fn sample_type(&self) -> DecodingSampleType {
+        match *self {
+            DecodingExtent::U8(_) => DecodingSampleType::U8,
+            DecodingExtent::U16(_) => DecodingSampleType::U16,
+            DecodingExtent::U32(_) => DecodingSampleType::U32,
+            DecodingExtent::U64(_) => DecodingSampleType::U64,
+            DecodingExtent::F16(_) => DecodingSampleType::F16,
+            DecodingExtent::F32(_) => DecodingSampleType::F32,
+            DecodingExtent::F64(_) => DecodingSampleType::F64,
+            DecodingExtent::I8(_) => DecodingSampleType::I8,
+            DecodingExtent::I16(_) => DecodingSampleType::I16,
+            DecodingExtent::I32(_) => DecodingSampleType::I32,
+            DecodingExtent::I64(_) => DecodingSampleType::I64,
+        }
+    }
+}

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(Clone, 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/entry_reader.rs

@@ -0,0 +1,362 @@
+use std::io::{self, Cursor, Read, Seek};
+
+use crate::{
+    decoder::{ifd::Entry, stream::EndianReader, ValueReader},
+    tags::{ByteOrder, IfdPointer, Type},
+    TiffResult,
+};
+
+pub struct EntryBytesReader<'lt, R> {
+    inner: &'lt mut EndianReader<R>,
+    variant: Variant,
+}
+
+const OFFSET_BUFFER_LEN: usize = 8;
+
+enum Variant {
+    Immediate {
+        /// An in-value reader if the offset field contains the data. Note that we rotate it to the
+        /// back of this buffer, not the front, so that `Cursor` already contains the right end.
+        /// We do not let you seek back beyond our start.
+        data: Cursor<[u8; OFFSET_BUFFER_LEN]>,
+        value_bytes: u8,
+    },
+    InFile {
+        // the length relative to the base so we can seek relative without querying the position.
+        value_bytes: u64,
+        remainder: u64,
+        base: u64,
+    },
+}
+
+impl<'lt, R> EntryBytesReader<'lt, R> {
+    pub(super) fn from_entry(inner: &'lt mut ValueReader<R>, entry: Entry) -> TiffResult<Self>
+    where
+        R: Read + Seek,
+    {
+        let offset: [_; OFFSET_BUFFER_LEN] = *entry.offset_raw();
+        let limit = if inner.bigtiff { 8 } else { 4 };
+        assert!(limit as usize <= OFFSET_BUFFER_LEN);
+
+        let value_bytes = entry.field_type().value_bytes(entry.count())?;
+
+        if value_bytes <= limit {
+            // We move the data to the back of the array whereas it is in the front right now.
+            let mut value = offset;
+            value.rotate_left(value_bytes as usize);
+            let mut cursor = Cursor::new(value);
+            cursor.set_position(OFFSET_BUFFER_LEN as u64 - value_bytes);
+
+            Ok(EntryBytesReader {
+                inner: &mut inner.reader,
+                variant: Variant::Immediate {
+                    data: cursor,
+                    value_bytes: value_bytes as u8,
+                },
+            })
+        } else {
+            // remainder > limit >= 0 so this is an unreachable panic.
+            let pointer = if inner.bigtiff {
+                let mut offset = offset;
+
+                inner
+                    .reader
+                    .byte_order
+                    .convert(Type::IFD8, &mut offset[..], ByteOrder::native());
+
+                IfdPointer(u64::from_ne_bytes(offset))
+            } else {
+                let mut offset = *offset.first_chunk::<4>().unwrap();
+
+                inner
+                    .reader
+                    .byte_order
+                    .convert(Type::IFD, &mut offset[..], ByteOrder::native());
+
+                let offset = u32::from_ne_bytes(offset);
+                IfdPointer(u64::from(offset))
+            };
+
+            inner.reader.goto_offset(pointer.0)?;
+
+            Ok(EntryBytesReader {
+                inner: &mut inner.reader,
+                variant: Variant::InFile {
+                    value_bytes,
+                    remainder: value_bytes,
+                    base: pointer.0,
+                },
+            })
+        }
+    }
+}
+
+impl<R: Read> Read for EntryBytesReader<'_, R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        match &mut self.variant {
+            Variant::Immediate { data, .. } => data.read(buf),
+            Variant::InFile { remainder, .. } => {
+                let bound = usize::try_from(*remainder).unwrap_or(usize::MAX);
+                let avail = buf.len().min(bound);
+                let read = self.inner.inner().read(&mut buf[..avail])?;
+
+                // On a well-behaved `Read`: read <= avail <= bound <=(mathematical) remainder
+                let consume = read as u64;
+                *remainder -= consume;
+                Ok(read)
+            }
+        }
+    }
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        match &mut self.variant {
+            Variant::Immediate { data, .. } => data.read_exact(buf),
+            Variant::InFile { remainder, .. } => {
+                let bound = usize::try_from(*remainder).unwrap_or(usize::MAX);
+
+                // Fail early if we would be sure to over-read.
+                if buf.len() > bound {
+                    return Err(io::Error::new(
+                        io::ErrorKind::UnexpectedEof,
+                        "Tiff value shorter than the requested buffer size",
+                    ));
+                }
+
+                // since buf.len() <= bound <=(mathematical) remainder
+                let consume = buf.len() as u64;
+                self.inner.inner().read_exact(buf)?;
+                *remainder -= consume;
+
+                Ok(())
+            }
+        }
+    }
+}
+
+impl<R: Read + Seek> Seek for EntryBytesReader<'_, R> {
+    fn seek(&mut self, offset: io::SeekFrom) -> io::Result<u64> {
+        let (value_bytes, remainder) = match &self.variant {
+            Variant::Immediate { data, value_bytes } => {
+                let remainder = data.get_ref().len() as u64 - data.position();
+                (*value_bytes as u64, remainder)
+            }
+            &Variant::InFile {
+                value_bytes,
+                remainder,
+                base: _,
+            } => (value_bytes, remainder),
+        };
+
+        // Normalize to an offset from the start
+        let offset_from_start = match offset {
+            io::SeekFrom::Start(n) => Some(n),
+            io::SeekFrom::Current(n) => {
+                let front = value_bytes - remainder;
+                front.checked_add_signed(n)
+            }
+            io::SeekFrom::End(n) => value_bytes.checked_add_signed(n),
+        };
+
+        let Some((offset, remainder)) = offset_from_start.and_then(|n| {
+            let remainder = value_bytes.checked_sub(n)?;
+            Some((n, remainder))
+        }) else {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "seek out of bounds of entry value",
+            ));
+        };
+
+        match &mut self.variant {
+            Variant::Immediate { data, .. } => {
+                let start = OFFSET_BUFFER_LEN as u64 - value_bytes;
+                data.set_position(start + offset);
+                Ok(offset)
+            }
+            &mut Variant::InFile { base, .. } => {
+                // We checked this against overflow on construction. Ignore the offset we get.
+                self.inner
+                    .inner()
+                    .seek(io::SeekFrom::Start(base + offset))?;
+
+                self.variant = Variant::InFile {
+                    value_bytes,
+                    remainder,
+                    base,
+                };
+
+                Ok(offset)
+            }
+        }
+    }
+
+    fn stream_position(&mut self) -> io::Result<u64> {
+        Ok(match &self.variant {
+            Variant::Immediate { data, value_bytes } => {
+                // Recall the value is at the end of the buffer.
+                let from_end = OFFSET_BUFFER_LEN as u64 - data.position();
+                u64::from(*value_bytes) - from_end
+            }
+            // Note: we might think about using the inner `stream_position` here. However that
+            // exposes something interesting: If the internal stream is modified concurrently from
+            // another instance (e.g. a shared `File`) then we may lose track of it anyways.
+            // Especially the `Read` implementation is not bounded on `Seek` so it could not
+            // acquire the position. And it should not since that is just a different form of race
+            // where we risk the position being modified by a different thread just as well.
+            //
+            // So in the interest of least surprise we just assume that we can track the position
+            // accurately here and that the inner reader uses for instance `read_at` consistently.
+            // We own the value (or mutable reference) it after all.
+            //
+            // Also this one MUST be compatible with `seek(SeekFrom::Current(0))` as per trait
+            // defintion—so at least keep those consistent if changing anything.
+            &Variant::InFile {
+                remainder,
+                value_bytes,
+                ..
+            } => value_bytes - remainder,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{decoder::Decoder, encoder, tags};
+    use std::io::{Read as _, Seek as _, SeekFrom};
+
+    #[test]
+    fn can_seek_tag_bytes() -> Result<(), crate::error::TiffError> {
+        let file = std::fs::File::open(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/tests/images/int8_rgb.tif"
+        ))
+        .unwrap();
+
+        let mut decoder = Decoder::open(file).unwrap();
+        decoder.next_directory().unwrap();
+
+        let mut buffer = crate::tags::ValueBuffer::default();
+
+        decoder
+            .current_ifd()
+            .find_tag_buf(tags::Tag::StripByteCounts, &mut buffer)
+            .expect("some strip byte count is present");
+
+        let bytes_of_value = buffer.as_bytes().len() as u64;
+
+        let mut reader = decoder
+            .read_tag(tags::Tag::StripByteCounts)?
+            .expect("some strip byte count is present");
+
+        let mut data = vec![];
+        reader.read_to_end(&mut data)?;
+
+        // `ValueBuffer` also stores its data in the file endianess until converted.
+        assert_eq!(reader.stream_position()?, bytes_of_value);
+        assert_eq!(buffer.as_bytes(), data);
+
+        reader.seek(SeekFrom::Start(0))?;
+        assert_eq!(reader.stream_position()?, 0);
+        reader.read_to_end(&mut data)?;
+        assert_eq!(reader.stream_position()?, bytes_of_value);
+
+        let (first, second) = data.split_at(bytes_of_value as usize);
+        assert_eq!(first, second);
+
+        Ok(())
+    }
+
+    #[test]
+    #[allow(clippy::seek_from_current)] // We want to test that functionality.
+    fn seek_from_end() -> Result<(), crate::error::TiffError> {
+        const ARTIST: &str = "99 little bugs in the code";
+
+        let data = {
+            let mut data = std::io::Cursor::new(vec![]);
+            let mut encoder = encoder::TiffEncoder::new(&mut data)?;
+
+            let mut dir = encoder.image_directory()?;
+            dir.write_tag(tags::Tag::Artist, ARTIST)?;
+            dir.finish()?;
+
+            data.into_inner()
+        };
+
+        let file = std::io::Cursor::new(data);
+        let mut decoder = Decoder::open(file).unwrap();
+        decoder.next_directory().unwrap();
+
+        let mut reader = decoder
+            .read_tag(tags::Tag::Artist)?
+            .expect("the artist is present?");
+
+        let mut value = vec![];
+        reader.read_to_end(&mut value)?;
+
+        let (&nul, value) = value.split_last().unwrap();
+        assert_eq!(value, ARTIST.as_bytes());
+        assert_eq!(nul, b'\0');
+
+        assert_eq!(reader.seek(SeekFrom::End(0))?, ARTIST.len() as u64 + 1);
+        assert!(reader.seek(SeekFrom::End(1)).is_err());
+        assert_eq!(reader.stream_position()?, ARTIST.len() as u64 + 1);
+
+        // Check relative seeks by comparing against the "code"
+        let code_offset = reader.seek(SeekFrom::End(-5))?;
+        let mut is_code = [0u8; 4];
+        reader.read_exact(&mut is_code)?;
+        assert_eq!(is_code, *value.last_chunk::<4>().unwrap());
+
+        assert_eq!(reader.seek(SeekFrom::Start(0))?, 0);
+        assert_eq!(reader.stream_position()?, 0);
+        assert_eq!(reader.seek(SeekFrom::Current(0))?, 0);
+        assert_eq!(reader.stream_position()?, 0);
+        assert!(reader.seek(SeekFrom::Current(-1)).is_err());
+        assert_eq!(reader.stream_position()?, 0);
+
+        reader.seek(SeekFrom::Start(code_offset))?;
+        reader.read_exact(&mut is_code)?;
+        assert_eq!(reader.stream_position()?, ARTIST.len() as u64);
+        assert_eq!(is_code, *value.last_chunk::<4>().unwrap());
+
+        Ok(())
+    }
+
+    /// Check that the reader from an `offset` field also works.
+    #[test]
+    fn read_from_offset() -> Result<(), crate::error::TiffError> {
+        let data = {
+            let mut data = std::io::Cursor::new(vec![]);
+            let mut encoder = encoder::TiffEncoder::new(&mut data)?;
+
+            let mut dir = encoder.image_directory()?;
+            dir.write_tag(
+                tags::Tag::PlanarConfiguration,
+                tags::PlanarConfiguration::Planar,
+            )?;
+            dir.finish()?;
+
+            data.into_inner()
+        };
+
+        let file = std::io::Cursor::new(data);
+        let mut decoder = Decoder::open(file).unwrap();
+        decoder.next_directory().unwrap();
+        let bo = decoder.byte_order();
+
+        let mut reader = decoder
+            .read_tag(tags::Tag::PlanarConfiguration)?
+            .expect("some artist is present");
+
+        let mut buf = [0; 2];
+        reader.read_exact(&mut buf)?;
+
+        bo.convert(tags::Type::SHORT, &mut buf, tags::ByteOrder::BigEndian);
+        assert_eq!(buf, [0, 2]);
+
+        // Check relative seeks, this item is only two bytes long.
+        assert!(reader.seek(SeekFrom::End(-3)).is_err());
+
+        Ok(())
+    }
+}

src/decoder/logluv.rs

@@ -0,0 +1,545 @@
+use std::io::{Read, Take};
+
+use crate::TiffError;
+
+pub struct LogLuv24<R> {
+    reader: Take<R>,
+    /// The required buffer size. We only decompressed all samples at once.
+    chunk_sz: usize,
+}
+
+impl<R> LogLuv24<R> {
+    pub fn new(reader: R, n: u64, npixels: u32) -> Result<Self, TiffError>
+    where
+        R: Read,
+    {
+        let chunk_sz = usize::try_from(
+            u64::from(npixels)
+                .checked_mul(4 * 3)
+                .ok_or(TiffError::LimitsExceeded)?,
+        )?;
+
+        let reader = reader.take(n);
+        Ok(LogLuv24 { reader, chunk_sz })
+    }
+
+    fn expand_buf(buf: &mut [u8]) {
+        let data_len = buf.len() / 4;
+
+        for i in (0..data_len / 3).rev() {
+            let ch = buf.as_chunks_mut::<3>().0[i];
+            let [a, b, c] = ch.map(u32::from);
+
+            let raw = a << 16 | b << 8 | c;
+            let l = (raw >> 14) & 0x3ff;
+            let uv = decode_quantized_uv(raw & 0x3fff);
+
+            let by = dequantize_24_luma(l);
+            let (u, v) = dequantize_24(uv);
+
+            let s = 1. / (6. * u - 16. * v + 12.);
+            let x = 9. * u * s;
+            let y = 4. * v * s;
+
+            let bx = x / y * by;
+            let bz = (1. - x - y) / y * by;
+
+            let [r, g, b] = xyz_to_rgb([bx, by, bz]);
+
+            let into = &mut buf.as_chunks_mut::<12>().0[i];
+            into[0..4].copy_from_slice(&f32::to_ne_bytes(r));
+            into[4..8].copy_from_slice(&f32::to_ne_bytes(g));
+            into[8..12].copy_from_slice(&f32::to_ne_bytes(b));
+        }
+    }
+}
+
+impl<R: Read> Read for LogLuv24<R> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        self.read_exact(buf)?;
+        Ok(buf.len())
+    }
+
+    // FIXME: this is the interface we have for compressed chunks but it is not optimal for what we
+    // want. Note `fill_buf` is not super helpful since it does not guarantee any size of the
+    // filled buffer but we need 24-bits at a time. Two code paths is even more awkward.
+    fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
+        if !buf.len().is_multiple_of(self.chunk_sz) {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!(
+                    "buffer size {0} must match the chunk size for compression method SGILog24 {1}",
+                    buf.len(),
+                    self.chunk_sz,
+                ),
+            ));
+        }
+
+        let data_len = buf.len() / 4;
+        self.reader.read_exact(&mut buf[..data_len])?;
+        Self::expand_buf(buf);
+
+        Ok(())
+    }
+}
+
+fn packbits_decode<R: Read, const N: usize>(
+    reader: &mut R,
+    buf: &mut [[u8; N]],
+) -> std::io::Result<()> {
+    let expected = buf.len();
+    for offset in (0..N).rev() {
+        let mut i = 0;
+        let mut code = [0u8; 1];
+
+        while let Some(pixels) = buf.get_mut(i..) {
+            if pixels.is_empty() {
+                break;
+            }
+
+            let pixels = pixels.iter_mut();
+            reader.read_exact(&mut code)?;
+            let [repeat] = code;
+
+            if repeat >= 128 {
+                reader.read_exact(&mut code)?;
+                let [value] = code;
+                let rc = (repeat - 128) + 2;
+
+                for (_, px) in (0..rc).zip(pixels) {
+                    px[offset] = value;
+                }
+
+                i += usize::from(rc);
+            } else {
+                for (_, px) in (0..repeat).zip(pixels) {
+                    reader.read_exact(&mut code)?;
+                    let [value] = code;
+                    px[offset] = value;
+                }
+
+                i += usize::from(repeat);
+            }
+        }
+
+        if i < expected {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::UnexpectedEof,
+                "PackBits RLE decoded fewer pixels than expected",
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+pub struct LogLuv32<R> {
+    reader: Take<R>,
+    /// The required buffer size. We only decompressed all samples at once.
+    chunk_sz: usize,
+}
+
+impl<R: Read> LogLuv32<R> {
+    pub fn new(reader: R, n: u64, npixels: u32) -> Result<Self, TiffError> {
+        let chunk_sz = usize::try_from(
+            u64::from(npixels)
+                .checked_mul(4 * 3)
+                .ok_or(TiffError::LimitsExceeded)?,
+        )?;
+
+        let reader = reader.take(n);
+        Ok(LogLuv32 { reader, chunk_sz })
+    }
+
+    fn decode_rle_row(&mut self, row: &mut [u8]) -> std::io::Result<()>
+    where
+        R: Read,
+    {
+        // 32-bit per pixel format.
+        let n_pixels = self.chunk_sz / 12;
+        // buffer for reading (using only 32-bit per pixel)
+        let raw = &mut row.as_chunks_mut::<4>().0[..n_pixels];
+        packbits_decode::<_, 4>(&mut self.reader, raw)?;
+
+        Ok(())
+    }
+
+    fn expand_row(row: &mut [u8]) {
+        let uvscale = 1.0 / 410.0;
+        let n_pixels = row.len() / 12;
+
+        // Work backwards, the 32-bit compressed raw data is at the front of the row buffer and
+        // this avoids overwriting data before we read it.
+        for i in (0..n_pixels).rev() {
+            let raw = row.as_chunks_mut::<4>().0[i];
+
+            let l = u16::from(raw[0]) << 8 | u16::from(raw[1]);
+            let by = log16_to_y(l);
+
+            let u = uvscale * (f32::from(raw[2]) + 0.5);
+            let v = uvscale * (f32::from(raw[3]) + 0.5);
+
+            let s = 1. / (6. * u - 16. * v + 12.);
+            let x = 9. * u * s;
+            let y = 4. * v * s;
+
+            let bx = x / y * by;
+            let bz = (1. - x - y) / y * by;
+
+            let [r, g, b] = xyz_to_rgb([bx, by, bz]);
+            let into = &mut row.as_chunks_mut::<12>().0[i];
+            into[0..4].copy_from_slice(&f32::to_ne_bytes(r));
+            into[4..8].copy_from_slice(&f32::to_ne_bytes(g));
+            into[8..12].copy_from_slice(&f32::to_ne_bytes(b));
+        }
+    }
+}
+
+impl<R: Read> Read for LogLuv32<R> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        self.read_exact(buf)?;
+        Ok(buf.len())
+    }
+
+    // FIXME: See `LogLuv24::read_exact`
+    fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
+        for row in buf.chunks_exact_mut(self.chunk_sz) {
+            self.decode_rle_row(row)?;
+            Self::expand_row(row);
+        }
+
+        Ok(())
+    }
+}
+
+/// Pack-Bits like encoding for a single 16-bit log-L sample.
+pub struct LogLuv16<R> {
+    reader: Take<R>,
+    /// The required buffer size. We only decompressed all samples at once.
+    chunk_sz: usize,
+}
+
+impl<R: Read> LogLuv16<R> {
+    pub fn new(reader: R, n: u64, npixels: u32) -> Result<Self, TiffError> {
+        let chunk_sz = usize::try_from(
+            u64::from(npixels)
+                .checked_mul(4)
+                .ok_or(TiffError::LimitsExceeded)?,
+        )?;
+
+        let reader = reader.take(n);
+        Ok(LogLuv16 { reader, chunk_sz })
+    }
+
+    fn decode_rle_row(&mut self, row: &mut [u8]) -> std::io::Result<()>
+    where
+        R: Read,
+    {
+        // 32-bit per pixel format.
+        let n_pixels = self.chunk_sz / 4;
+        // buffer for reading (16-bit per pixel)
+        let raw = &mut row.as_chunks_mut::<2>().0[..n_pixels];
+        packbits_decode::<_, 2>(&mut self.reader, raw)?;
+
+        Ok(())
+    }
+
+    fn expand_row(row: &mut [u8]) {
+        let n_pixels = row.len() / 4;
+
+        // Work backwards, the 32-bit compressed raw data is at the front of the row buffer and
+        // this avoids overwriting data before we read it.
+        for i in (0..n_pixels).rev() {
+            let raw = row.as_chunks_mut::<2>().0[i];
+
+            let l = u16::from(raw[0]) << 8 | u16::from(raw[1]);
+            let by = log16_to_y(l);
+
+            let into = &mut row.as_chunks_mut::<4>().0[i];
+            into[0..4].copy_from_slice(&f32::to_ne_bytes(by));
+        }
+    }
+}
+
+impl<R: Read> Read for LogLuv16<R> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        self.read_exact(buf)?;
+        Ok(buf.len())
+    }
+
+    // FIXME: See `LogLuv24::read_exact`
+    fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
+        for row in buf.chunks_exact_mut(self.chunk_sz) {
+            self.decode_rle_row(row)?;
+            Self::expand_row(row);
+        }
+
+        Ok(())
+    }
+}
+
+// Table information from: `libtiff`, 1997 by Greg Ward Larson, SGI
+#[doc(alias = "UV_SQSIZ")]
+const UV_QUANTIZATION_WIDTH: f32 = 0.003500;
+
+// The `v` value corresonding to the bottom most row (quantized v' = 0).
+const UV_VSTART: f32 = 0.016940;
+
+/// Number of distinct 'u' rows, each at a different v level. Each is quantized individually with
+/// the first quantization level starting at its `ustart` and `UV_QUANTIZATION_WIDTH` wide.
+const UV_NVS: usize = 163;
+
+/// Contrary to the original C code we calculate the dependent values (cumulative sum).
+struct UvRow {
+    ustart: f32,
+    num_us: u16,
+}
+
+#[rustfmt::skip]
+const UV_ROWS: [UvRow; UV_NVS] = [
+    UvRow { ustart: 0.247663, num_us: 4, },
+    UvRow { ustart: 0.243779, num_us: 6, },
+    UvRow { ustart: 0.241684, num_us: 7, },
+    UvRow { ustart: 0.237874, num_us: 9, },
+    UvRow { ustart: 0.235906, num_us: 10, },
+    UvRow { ustart: 0.232153, num_us: 12, },
+    UvRow { ustart: 0.228352, num_us: 14, },
+    UvRow { ustart: 0.226259, num_us: 15, },
+    UvRow { ustart: 0.222371, num_us: 17, },
+    UvRow { ustart: 0.220410, num_us: 18, },
+    UvRow { ustart: 0.214710, num_us: 21, },
+    UvRow { ustart: 0.212714, num_us: 22, },
+    UvRow { ustart: 0.210721, num_us: 23, },
+    UvRow { ustart: 0.204976, num_us: 26, },
+    UvRow { ustart: 0.202986, num_us: 27, },
+    UvRow { ustart: 0.199245, num_us: 29, },
+    UvRow { ustart: 0.195525, num_us: 31, },
+    UvRow { ustart: 0.193560, num_us: 32, },
+    UvRow { ustart: 0.189878, num_us: 34, },
+    UvRow { ustart: 0.186216, num_us: 36, },
+    UvRow { ustart: 0.186216, num_us: 36, },
+    UvRow { ustart: 0.182592, num_us: 38, },
+    UvRow { ustart: 0.179003, num_us: 40, },
+    UvRow { ustart: 0.175466, num_us: 42, },
+    UvRow { ustart: 0.172001, num_us: 44, },
+    UvRow { ustart: 0.172001, num_us: 44, },
+    UvRow { ustart: 0.168612, num_us: 46, },
+    UvRow { ustart: 0.168612, num_us: 46, },
+    UvRow { ustart: 0.163575, num_us: 49, },
+    UvRow { ustart: 0.158642, num_us: 52, },
+    UvRow { ustart: 0.158642, num_us: 52, },
+    UvRow { ustart: 0.158642, num_us: 52, },
+    UvRow { ustart: 0.153815, num_us: 55, },
+    UvRow { ustart: 0.153815, num_us: 55, },
+    UvRow { ustart: 0.149097, num_us: 58, },
+    UvRow { ustart: 0.149097, num_us: 58, },
+    UvRow { ustart: 0.142746, num_us: 62, },
+    UvRow { ustart: 0.142746, num_us: 62, },
+    UvRow { ustart: 0.142746, num_us: 62, },
+    UvRow { ustart: 0.138270, num_us: 65, },
+    UvRow { ustart: 0.138270, num_us: 65, },
+    UvRow { ustart: 0.138270, num_us: 65, },
+    UvRow { ustart: 0.132166, num_us: 69, },
+    UvRow { ustart: 0.132166, num_us: 69, },
+    UvRow { ustart: 0.126204, num_us: 73, },
+    UvRow { ustart: 0.126204, num_us: 73, },
+    UvRow { ustart: 0.126204, num_us: 73, },
+    UvRow { ustart: 0.120381, num_us: 77, },
+    UvRow { ustart: 0.120381, num_us: 77, },
+    UvRow { ustart: 0.120381, num_us: 77, },
+    UvRow { ustart: 0.120381, num_us: 77, },
+    UvRow { ustart: 0.112962, num_us: 82, },
+    UvRow { ustart: 0.112962, num_us: 82, },
+    UvRow { ustart: 0.112962, num_us: 82, },
+    UvRow { ustart: 0.107450, num_us: 86, },
+    UvRow { ustart: 0.107450, num_us: 86, },
+    UvRow { ustart: 0.107450, num_us: 86, },
+    UvRow { ustart: 0.107450, num_us: 86, },
+    UvRow { ustart: 0.100343, num_us: 91, },
+    UvRow { ustart: 0.100343, num_us: 91, },
+    UvRow { ustart: 0.100343, num_us: 91, },
+    UvRow { ustart: 0.095126, num_us: 95, },
+    UvRow { ustart: 0.095126, num_us: 95, },
+    UvRow { ustart: 0.095126, num_us: 95, },
+    UvRow { ustart: 0.095126, num_us: 95, },
+    UvRow { ustart: 0.088276, num_us: 100, },
+    UvRow { ustart: 0.088276, num_us: 100, },
+    UvRow { ustart: 0.088276, num_us: 100, },
+    UvRow { ustart: 0.088276, num_us: 100, },
+    UvRow { ustart: 0.081523, num_us: 105, },
+    UvRow { ustart: 0.081523, num_us: 105, },
+    UvRow { ustart: 0.081523, num_us: 105, },
+    UvRow { ustart: 0.081523, num_us: 105, },
+    UvRow { ustart: 0.074861, num_us: 110, },
+    UvRow { ustart: 0.074861, num_us: 110, },
+    UvRow { ustart: 0.074861, num_us: 110, },
+    UvRow { ustart: 0.074861, num_us: 110, },
+    UvRow { ustart: 0.068290, num_us: 115, },
+    UvRow { ustart: 0.068290, num_us: 115, },
+    UvRow { ustart: 0.068290, num_us: 115, },
+    UvRow { ustart: 0.068290, num_us: 115, },
+    UvRow { ustart: 0.063573, num_us: 119, },
+    UvRow { ustart: 0.063573, num_us: 119, },
+    UvRow { ustart: 0.063573, num_us: 119, },
+    UvRow { ustart: 0.063573, num_us: 119, },
+    UvRow { ustart: 0.057219, num_us: 124, },
+    UvRow { ustart: 0.057219, num_us: 124, },
+    UvRow { ustart: 0.057219, num_us: 124, },
+    UvRow { ustart: 0.057219, num_us: 124, },
+    UvRow { ustart: 0.050985, num_us: 129, },
+    UvRow { ustart: 0.050985, num_us: 129, },
+    UvRow { ustart: 0.050985, num_us: 129, },
+    UvRow { ustart: 0.050985, num_us: 129, },
+    UvRow { ustart: 0.050985, num_us: 129, },
+    UvRow { ustart: 0.044859, num_us: 134, },
+    UvRow { ustart: 0.044859, num_us: 134, },
+    UvRow { ustart: 0.044859, num_us: 134, },
+    UvRow { ustart: 0.044859, num_us: 134, },
+    UvRow { ustart: 0.040571, num_us: 138, },
+    UvRow { ustart: 0.040571, num_us: 138, },
+    UvRow { ustart: 0.040571, num_us: 138, },
+    UvRow { ustart: 0.040571, num_us: 138, },
+    UvRow { ustart: 0.036339, num_us: 142, },
+    UvRow { ustart: 0.036339, num_us: 142, },
+    UvRow { ustart: 0.036339, num_us: 142, },
+    UvRow { ustart: 0.036339, num_us: 142, },
+    UvRow { ustart: 0.032139, num_us: 146, },
+    UvRow { ustart: 0.032139, num_us: 146, },
+    UvRow { ustart: 0.032139, num_us: 146, },
+    UvRow { ustart: 0.032139, num_us: 146, },
+    UvRow { ustart: 0.027947, num_us: 150, },
+    UvRow { ustart: 0.027947, num_us: 150, },
+    UvRow { ustart: 0.027947, num_us: 150, },
+    UvRow { ustart: 0.023739, num_us: 154, },
+    UvRow { ustart: 0.023739, num_us: 154, },
+    UvRow { ustart: 0.023739, num_us: 154, },
+    UvRow { ustart: 0.023739, num_us: 154, },
+    UvRow { ustart: 0.019504, num_us: 158, },
+    UvRow { ustart: 0.019504, num_us: 158, },
+    UvRow { ustart: 0.019504, num_us: 158, },
+    UvRow { ustart: 0.016976, num_us: 161, },
+    UvRow { ustart: 0.016976, num_us: 161, },
+    UvRow { ustart: 0.016976, num_us: 161, },
+    UvRow { ustart: 0.016976, num_us: 161, },
+    UvRow { ustart: 0.012639, num_us: 165, },
+    UvRow { ustart: 0.012639, num_us: 165, },
+    UvRow { ustart: 0.012639, num_us: 165, },
+    UvRow { ustart: 0.009991, num_us: 168, },
+    UvRow { ustart: 0.009991, num_us: 168, },
+    UvRow { ustart: 0.009991, num_us: 168, },
+    UvRow { ustart: 0.009016, num_us: 170, },
+    UvRow { ustart: 0.009016, num_us: 170, },
+    UvRow { ustart: 0.009016, num_us: 170, },
+    UvRow { ustart: 0.006217, num_us: 173, },
+    UvRow { ustart: 0.006217, num_us: 173, },
+    UvRow { ustart: 0.005097, num_us: 175, },
+    UvRow { ustart: 0.005097, num_us: 175, },
+    UvRow { ustart: 0.005097, num_us: 175, },
+    UvRow { ustart: 0.003909, num_us: 177, },
+    UvRow { ustart: 0.003909, num_us: 177, },
+    UvRow { ustart: 0.002340, num_us: 177, },
+    UvRow { ustart: 0.002389, num_us: 170, },
+    UvRow { ustart: 0.001068, num_us: 164, },
+    UvRow { ustart: 0.001653, num_us: 157, },
+    UvRow { ustart: 0.000717, num_us: 150, },
+    UvRow { ustart: 0.001614, num_us: 143, },
+    UvRow { ustart: 0.000270, num_us: 136, },
+    UvRow { ustart: 0.000484, num_us: 129, },
+    UvRow { ustart: 0.001103, num_us: 123, },
+    UvRow { ustart: 0.001242, num_us: 115, },
+    UvRow { ustart: 0.001188, num_us: 109, },
+    UvRow { ustart: 0.001011, num_us: 103, },
+    UvRow { ustart: 0.000709, num_us: 97, },
+    UvRow { ustart: 0.000301, num_us: 89, },
+    UvRow { ustart: 0.002416, num_us: 82, },
+    UvRow { ustart: 0.003251, num_us: 76, },
+    UvRow { ustart: 0.003246, num_us: 69, },
+    UvRow { ustart: 0.004141, num_us: 62, },
+    UvRow { ustart: 0.005963, num_us: 55, },
+    UvRow { ustart: 0.008839, num_us: 47, },
+    UvRow { ustart: 0.010490, num_us: 40, },
+    UvRow { ustart: 0.016994, num_us: 31, },
+    UvRow { ustart: 0.023659, num_us: 21, },
+];
+
+const UV_CUMULATIVE: [u16; UV_NVS] = {
+    let mut arr = [0u16; UV_NVS];
+    let mut sum = 0;
+    let mut i = 0;
+    while i < UV_NVS {
+        arr[i] = sum;
+        sum += UV_ROWS[i].num_us;
+        i += 1;
+    }
+    arr
+};
+
+const UV_NDIVS: u16 = UV_CUMULATIVE[UV_NVS - 1] + UV_ROWS[UV_NVS - 1].num_us;
+
+fn decode_quantized_uv(uv: u32) -> (u8, u8) {
+    if uv >= UV_NDIVS as u32 {
+        return (0, 0);
+    }
+
+    // Find the start of the row, or the index after that.
+    let v_index = match UV_CUMULATIVE.binary_search(&(uv as u16)) {
+        Ok(n) => n,
+        Err(n) => n - 1,
+    };
+
+    let u_index = uv as u16 - UV_CUMULATIVE[v_index];
+    (u_index as u8, v_index as u8)
+}
+
+fn dequantize_24_luma(l: u32) -> f32 {
+    if l == 0 {
+        0.0
+    } else {
+        let le = (l & 0x3ff) as f32;
+        let exponent = ((le / 64.0).floor() as i32) - 24;
+        let mantissa = le - (exponent as f32 + 24.0) * 64.0;
+        (mantissa + 64.0) / 64.0 * 2f32.powi(exponent)
+    }
+}
+
+fn dequantize_24((u, v): (u8, u8)) -> (f32, f32) {
+    let v_f = UV_VSTART + (v as f32) * UV_QUANTIZATION_WIDTH;
+    let u_row = &UV_ROWS[v as usize];
+    let u_f = u_row.ustart + (u as f32) * UV_QUANTIZATION_WIDTH;
+    (u_f, v_f)
+}
+
+fn log16_to_y(l: u16) -> f32 {
+    if l == 0 {
+        return 0.0;
+    }
+
+    let le = f32::from(l & 0x7fff);
+    //     Y = exp(M_LN2 / 256. * (Le + .5) - M_LN2 * 64.);
+    let y = (std::f32::consts::LN_2 / 256.0 * (le + 0.5) - std::f32::consts::LN_2 * 64.0).exp();
+
+    if l & 0x8000 != 0 {
+        -y
+    } else {
+        y
+    }
+}
+
+fn xyz_to_rgb([l, u, v]: [f32; 3]) -> [f32; 3] {
+    // XYZ to sRGB primaries at D65
+    let r = 3.2404542 * l + -1.5371385 * u + -0.4985314 * v;
+    let g = -0.969266 * l + 1.8760108 * u + 0.0415560 * v;
+    let b = 0.0556434 * l + -0.2040259 * u + 1.0572252 * v;
+    [r, g, b]
+}
+
+#[test]
+fn test_decode_quantized_uv() {
+    // Test some known values from the original C code.
+    assert_eq!(decode_quantized_uv(0), (0, 0));
+    assert_eq!(decode_quantized_uv(3), (3, 0));
+    assert_eq!(decode_quantized_uv(4), (0, 1));
+    assert_eq!(decode_quantized_uv(9), (5, 1));
+    assert_eq!(decode_quantized_uv(16288), (20, 162));
+    assert_eq!(decode_quantized_uv(16289), (0, 0)); // Out of range
+}

src/decoder/stream.rs

@@ -1,319 +1,585 @@
 //! All IO functionality needed for TIFF decoding
+#[cfg(feature = "webp")]
+use std::io::Cursor;
+use std::io::{self, BufRead, BufReader, Read, Seek, Take};
 
-use crate::error::{TiffError, TiffResult};
-use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
-use lzw;
-use miniz_oxide::inflate;
-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> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u16::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u16::<BigEndian>(self),
-        }
-    }
-
-    #[inline(always)]
-    fn read_u16_into(&mut self, buffer: &mut [u16]) -> Result<(), io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => {
-                <Self as ReadBytesExt>::read_u16_into::<LittleEndian>(self, buffer)
-            }
-            ByteOrder::BigEndian => {
-                <Self as ReadBytesExt>::read_u16_into::<BigEndian>(self, buffer)
-            }
-        }
+    pub fn read_u16(&mut self) -> Result<u16, io::Error> {
+        let mut n = [0u8; 2];
+        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 i16
     #[inline(always)]
-    fn read_i16(&mut self) -> Result<i16, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_i16::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_i16::<BigEndian>(self),
-        }
+    pub fn read_i16(&mut self) -> Result<i16, io::Error> {
+        let mut n = [0u8; 2];
+        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),
+        })
     }
 
     /// Reads an u32
     #[inline(always)]
-    fn read_u32(&mut self) -> Result<u32, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u32::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u32::<BigEndian>(self),
-        }
-    }
-
-    #[inline(always)]
-    fn read_u32_into(&mut self, buffer: &mut [u32]) -> Result<(), io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => {
-                <Self as ReadBytesExt>::read_u32_into::<LittleEndian>(self, buffer)
-            }
-            ByteOrder::BigEndian => {
-                <Self as ReadBytesExt>::read_u32_into::<BigEndian>(self, buffer)
-            }
-        }
-    }
-
-    /// Reads an u64
-    #[inline(always)]
-    fn read_u64(&mut self) -> Result<u64, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u64::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u64::<BigEndian>(self),
-        }
-    }
-
-    #[inline(always)]
-    fn read_u64_into(&mut self, buffer: &mut [u64]) -> Result<(), io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => {
-                <Self as ReadBytesExt>::read_u64_into::<LittleEndian>(self, buffer)
-            }
-            ByteOrder::BigEndian => {
-                <Self as ReadBytesExt>::read_u64_into::<BigEndian>(self, buffer)
-            }
-        }
+    pub fn read_u32(&mut self) -> Result<u32, io::Error> {
+        let mut n = [0u8; 4];
+        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),
+        })
     }
 
     /// Reads an i32
     #[inline(always)]
-    fn read_i32(&mut self) -> Result<i32, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_i32::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_i32::<BigEndian>(self),
+    pub fn read_i32(&mut self) -> Result<i32, io::Error> {
+        let mut n = [0u8; 4];
+        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),
+        })
     }
+
+    /// Reads an u64
+    #[inline(always)]
+    pub fn read_u64(&mut self) -> Result<u64, io::Error> {
+        let mut n = [0u8; 8];
+        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),
+        })
+    }
+
+    /// Reads an i64
+    #[inline(always)]
+    pub fn read_i64(&mut self) -> Result<i64, io::Error> {
+        let mut n = [0u8; 8];
+        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),
+        })
+    }
+
+    /// Reads an f32
+    #[inline(always)]
+    pub fn read_f32(&mut self) -> Result<f32, io::Error> {
+        let mut n = [0u8; 4];
+        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),
+        }))
+    }
+
+    /// Reads an f64
+    #[inline(always)]
+    pub fn read_f64(&mut self) -> Result<f64, io::Error> {
+        let mut n = [0u8; 8];
+        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),
+        }))
     }
 }
 
-/// Reader that decompresses DEFLATE streams
-pub struct DeflateReader {
-    buffer: io::Cursor<Vec<u8>>,
-    byte_order: ByteOrder,
-}
+//
+// # READERS
+//
 
-impl DeflateReader {
-    pub fn new<R: Read + Seek>(
-        reader: &mut SmartReader<R>,
-        max_uncompressed_length: usize,
-    ) -> TiffResult<(usize, Self)> {
-        let byte_order = reader.byte_order;
-        let mut compressed = Vec::new();
-        reader.read_to_end(&mut compressed)?;
+/// Type alias for the deflate Reader
+#[cfg(feature = "deflate")]
+pub type DeflateReader<R> = flate2::read::ZlibDecoder<R>;
 
-        // TODO: Implement streaming compression, and remove this (temporary) and somewhat
-        // misleading workaround.
-        if compressed.len() > max_uncompressed_length {
-            return Err(TiffError::LimitsExceeded);
-        }
-
-        let uncompressed =
-            inflate::decompress_to_vec_zlib(&compressed).map_err(TiffError::from_inflate_status)?;
-
-        Ok((
-            uncompressed.len(),
-            Self {
-                byte_order,
-                buffer: io::Cursor::new(uncompressed),
-            },
-        ))
-    }
-}
-
-impl Read for DeflateReader {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.buffer.read(buf)
-    }
-}
-
-impl EndianReader for DeflateReader {
-    fn byte_order(&self) -> ByteOrder {
-        self.byte_order
-    }
-}
+//
+// ## LZW Reader
+//
 
 /// Reader that decompresses LZW streams
-pub struct LZWReader {
-    buffer: io::Cursor<Vec<u8>>,
-    byte_order: ByteOrder,
+#[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 order = reader.byte_order;
-        let mut compressed = vec![0; compressed_length as usize];
-        reader.read_exact(&mut compressed[..])?;
-        let mut uncompressed = Vec::with_capacity(max_uncompressed_length);
-        let mut decoder = lzw::DecoderEarlyChange::new(lzw::MsbReader::new(), 8);
-        let mut bytes_read = 0;
-        while bytes_read < compressed_length && uncompressed.len() < max_uncompressed_length {
-            let (len, bytes) = decoder.decode_bytes(&compressed[bytes_read..])?;
-            bytes_read += len;
-            uncompressed.extend_from_slice(bytes);
-        }
+    pub fn new(reader: R, compressed_length: usize) -> LZWReader<R> {
+        let mut buffered = BufReader::with_capacity(
+            (32 * 1024).min(compressed_length),
+            reader.take(u64::try_from(compressed_length).unwrap()),
+        );
 
-        let bytes = uncompressed.len();
-        Ok((
-            bytes,
-            LZWReader {
-                buffer: io::Cursor::new(uncompressed),
-                byte_order: order,
-            },
-        ))
+        // `Compression = 5` covers both the current LZW variant and the pre-TIFF-6.0
+        // "old-style" one, with no tag to distinguish them. New-style is MSB-first with
+        // the "early change" code-size switch, and its stream begins with the Clear code
+        // (256) -> first byte 0x80. Old-style is LSB-first *without* the early change
+        // (GIF-style increment timing), and begins with 0x00 followed by a byte with bit
+        // 0 set. This is the heuristic libtiff uses to select its compatibility decoder;
+        // on a short/failed peek we default to the modern variant.
+        let old_style = matches!(
+            buffered.fill_buf(),
+            Ok(head) if head.len() >= 2 && head[0] == 0x00 && head[1] & 0x01 != 0
+        );
+
+        let configuration = if old_style {
+            weezl::decode::Configuration::new(weezl::BitOrder::Lsb, 8)
+        } else {
+            weezl::decode::Configuration::with_tiff_size_switch(weezl::BitOrder::Msb, 8)
+        }
+        .with_yield_on_full_buffer(true);
+
+        Self {
+            reader: buffered,
+            decoder: configuration.build(),
+        }
     }
 }
 
-impl Read for LZWReader {
-    #[inline]
+#[cfg(feature = "lzw")]
+impl<R: Read> Read for LZWReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.buffer.read(buf)
+        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) => {
+                    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)),
+            }
+        }
     }
 }
 
-impl EndianReader for LZWReader {
-    #[inline(always)]
-    fn byte_order(&self) -> ByteOrder {
-        self.byte_order
-    }
+//
+// ## PackBits Reader
+//
+
+/// Internal state machine for the PackBitsReader.
+enum PackBitsReaderState {
+    Header,
+    Literal,
+    Repeat { value: u8 },
 }
 
 /// Reader that unpacks Apple's `PackBits` format
-pub struct PackBitsReader {
-    buffer: io::Cursor<Vec<u8>>,
-    byte_order: ByteOrder,
+pub struct PackBitsReader<R: Read> {
+    reader: Take<R>,
+    state: PackBitsReaderState,
+    count: usize,
 }
 
-impl PackBitsReader {
+impl<R: Read> PackBitsReader<R> {
     /// Wraps a reader
-    pub fn new<R: Read + Seek>(
-        mut reader: R,
-        byte_order: ByteOrder,
-        length: usize,
-    ) -> io::Result<(usize, PackBitsReader)> {
-        let mut buffer = Vec::new();
-        let mut read: usize = 0;
-        while read < length {
-            let lread = read_packbits_run(&mut reader, &mut buffer)?;
-            if lread == 0 {
-                return Err(io::ErrorKind::UnexpectedEof.into());
+    pub fn new(reader: R, length: u64) -> Self {
+        Self {
+            reader: reader.take(length),
+            state: PackBitsReaderState::Header,
+            count: 0,
         }
-            read += lread;
-        }
-        Ok((
-            buffer.len(),
-            PackBitsReader {
-                buffer: io::Cursor::new(buffer),
-                byte_order,
-            },
-        ))
     }
 }
 
-fn read_packbits_run<R: Read + Seek>(reader: &mut R, buffer: &mut Vec<u8>) -> io::Result<usize> {
+impl<R: Read> Read for PackBitsReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        while let PackBitsReaderState::Header = self.state {
+            if self.reader.limit() == 0 {
+                return Ok(0);
+            }
             let mut header: [u8; 1] = [0];
-
-    let bytes = reader.read(&mut header)?;
-
-    match bytes {
-        0 => Ok(0),
-        _ => match header[0] as i8 {
-            -128 => Ok(1),
-            h if h >= -127 && h <= -1 => {
-                let new_len = buffer.len() + (1 - h as isize) as usize;
-                reader.read_exact(&mut header)?;
-                buffer.resize(new_len, header[0]);
-                Ok(2)
+            self.reader.read_exact(&mut header)?;
+            let h = header[0] as i8;
+            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 {
+                self.state = PackBitsReaderState::Literal;
+                self.count = h as usize + 1;
+            } else {
+                // h = -128 is a no-op.
             }
-            h => {
-                let num_vals = h as usize + 1;
-                let start = buffer.len();
-                buffer.resize(start + num_vals, 0);
-                reader.read_exact(&mut buffer[start..])?;
-                Ok(num_vals + 1)
         }
-        },
+
+        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]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.buffer.read(buf)
-    }
+/// Iterator adapter that reverses bits in each byte for FillOrder=2 (LSB-to-MSB).
+#[cfg(feature = "fax")]
+type FaxBytes<R> =
+    core::iter::Map<io::Bytes<io::BufReader<io::Take<R>>>, fn(io::Result<u8>) -> io::Result<u8>>;
+
+#[cfg(feature = "fax")]
+fn fax_byte_iter<R: Read>(reader: R, len: u64, fill_order: u16) -> FaxBytes<R> {
+    let map_fn: fn(io::Result<u8>) -> io::Result<u8> = if fill_order == 2 {
+        |r| r.map(u8::reverse_bits)
+    } else {
+        |r| r
+    };
+    io::BufReader::new(reader.take(len)).bytes().map(map_fn)
 }
 
-impl EndianReader for PackBitsReader {
-    #[inline(always)]
-    fn byte_order(&self) -> ByteOrder {
-        self.byte_order
-    }
+#[cfg(feature = "fax")]
+pub struct Group4Reader<R: Read> {
+    decoder: fax34::decoder::Group4Decoder<FaxBytes<R>>,
+    line_buf: io::Cursor<Vec<u8>>,
+    height: u32,
+    width: u16,
+    y: u32,
 }
 
-/// Reader that is aware of the byte order.
-#[derive(Debug)]
-pub struct SmartReader<R>
-where
-    R: Read + Seek,
-{
+#[cfg(feature = "fax")]
+impl<R: Read> Group4Reader<R> {
+    pub fn new(
+        dimensions: (u32, u32),
         reader: R,
-    pub byte_order: ByteOrder,
-}
+        compressed_length: u64,
+        fill_order: u16,
+    ) -> crate::TiffResult<Self> {
+        let width = u16::try_from(dimensions.0)?;
+        let height = dimensions.1;
 
-impl<R> SmartReader<R>
-where
-    R: Read + Seek,
-{
-    /// Wraps a reader
-    pub fn wrap(reader: R, byte_order: ByteOrder) -> SmartReader<R> {
-        SmartReader { reader, byte_order }
+        Ok(Self {
+            decoder: fax34::decoder::Group4Decoder::new(
+                fax_byte_iter(reader, compressed_length, fill_order),
+                width,
+            )?,
+            line_buf: io::Cursor::new(Vec::with_capacity(width.into())),
+            width,
+            height,
+            y: 0,
+        })
     }
 }
 
-impl<R> EndianReader for SmartReader<R>
-where
-    R: Read + Seek,
-{
-    #[inline(always)]
-    fn byte_order(&self) -> ByteOrder {
-        self.byte_order
-    }
-}
-
-impl<R: Read + Seek> Read for SmartReader<R> {
-    #[inline]
+#[cfg(feature = "fax")]
+impl<R: Read> Read for Group4Reader<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.reader.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)?;
+
+            match next {
+                fax34::decoder::DecodeStatus::End => (),
+                fax34::decoder::DecodeStatus::Incomplete => {
+                    self.y += 1;
+
+                    // We known `transitions` yields exactly `self.width` items (per doc).
+                    // FIXME: performance. We do not need an individual pixel iterator, filling
+                    // memory especially for long runs can be much quicker. The `transitions` are
+                    // the positions at which each run-length ends, i.e. the prefix sum of run
+                    // lengths. Runs in fax4 start with white.
+                    let transitions = fax34::decoder::pels(self.decoder.transition(), self.width);
+
+                    let buffer = self.line_buf.get_mut();
+                    buffer.resize(usize::from(self.width).div_ceil(8), 0u8);
+
+                    let target = &mut buffer[..];
+
+                    // Note: it may seem strange to treat black as 0b1 and white as 0b0 despite all
+                    // our streams by default decoding as-if PhotometricInterpretation::BlackIsMin.
+                    // This is however consistent with libtiff. It seems that fax4's "White"
+                    // differs from what libtiff thinks of as "White". For content, a line of data
+                    // is in runlength encoding of white-black-white-black always starting with
+                    // white. In libtiff, the loop always does both colors in one go and the
+                    // structure is:
+                    //
+                    // ```
+                    // for (; runs < erun; runs += 2)
+                    //   // white run
+                    //       do { *lp++ = 0L; } while (…)
+                    //   // black run
+                    //       do { *lp++ = -1L; } while (…)
+                    // ```
+                    //
+                    // So indeed the Fax4::White run is implemented by filling with zeros.
+                    let mut bits = transitions.map(|c| match c {
+                        fax34::Color::Black => true,
+                        fax34::Color::White => false,
+                    });
+
+                    // Assemble bits in MSB as per our library representation for buffer.
+                    for byte in target {
+                        let mut val = 0;
+
+                        for (idx, bit) in bits.by_ref().take(8).enumerate() {
+                            val |= u8::from(bit) << (7 - idx % 8);
+                        }
+
+                        *byte = val;
+                    }
+
+                    self.line_buf.set_position(0);
+                }
+            }
+        }
+
+        self.line_buf.read(buf)
     }
 }
 
-impl<R: Read + Seek> Seek for SmartReader<R> {
-    #[inline]
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        self.reader.seek(pos)
+/// Owning byte reader for Group 3 decoding: the compressed data is consumed
+/// into an iterator so the reader doesn't borrow the buffer.
+#[cfg(feature = "fax")]
+type OwnedBitReader = fax34::ByteReader<
+    core::iter::Map<std::vec::IntoIter<u8>, fn(u8) -> Result<u8, std::convert::Infallible>>,
+>;
+
+/// Decodes CCITT Group 3 (T.4) 1D compressed data line by line.
+///
+/// The fax crate's `Group3Decoder` has a bug where `new()` doesn't consume the
+/// initial EOL marker, causing its lookup tables to destructively consume bits
+/// from the EOL when trying to decode run-length codes. We work around this by
+/// using the crate's lower-level `white::decode` / `black::decode` functions
+/// and handling EOL markers ourselves.
+#[cfg(feature = "fax")]
+pub struct Group3Reader {
+    reader: OwnedBitReader,
+    line_buf: io::Cursor<Vec<u8>>,
+    height: u32,
+    width: u16,
+    y: u32,
+}
+
+#[cfg(feature = "fax")]
+impl Group3Reader {
+    pub fn new<R: Read>(
+        dimensions: (u32, u32),
+        reader: R,
+        compressed_length: u64,
+        fill_order: u16,
+    ) -> crate::TiffResult<Self> {
+        let width = u16::try_from(dimensions.0)?;
+        let height = dimensions.1;
+
+        // Buffer all compressed data and apply FillOrder bit reversal
+        let mut compressed = vec![0u8; compressed_length as usize];
+        reader.take(compressed_length).read_exact(&mut compressed)?;
+        if fill_order == 2 {
+            for b in &mut compressed {
+                *b = b.reverse_bits();
+            }
+        }
+
+        // Create an owning bit reader (Vec consumed by into_iter, no borrow issues)
+        let map_fn: fn(u8) -> Result<u8, std::convert::Infallible> = Ok;
+        let mut bit_reader = fax34::ByteReader::new(compressed.into_iter().map(map_fn)).unwrap();
+
+        // Skip fill bits + initial EOL marker
+        Self::skip_eol(&mut bit_reader);
+
+        Ok(Self {
+            reader: bit_reader,
+            line_buf: io::Cursor::new(Vec::with_capacity(width.into())),
+            width,
+            height,
+            y: 0,
+        })
+    }
+
+    /// Skip zero fill bits followed by the terminating '1' bit of an EOL code.
+    fn skip_eol(reader: &mut impl fax34::BitReader) {
+        while reader.peek(1) == Some(0) {
+            let _ = reader.consume(1);
+        }
+        if reader.peek(1) == Some(1) {
+            let _ = reader.consume(1);
+        }
+    }
+
+    /// Decode a full run-length value (terminal + optional makeup codes).
+    fn with_markup<R: fax34::BitReader>(
+        decoder: fn(&mut R) -> Option<u16>,
+        reader: &mut R,
+    ) -> Option<u16> {
+        let mut sum = 0u16;
+        while let Some(n) = decoder(reader) {
+            sum = sum.checked_add(n)?;
+            if n < 64 {
+                return Some(sum);
+            }
+        }
+        None
+    }
+}
+
+#[cfg(feature = "fax")]
+impl Read for Group3Reader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        if self.line_buf.position() as usize == self.line_buf.get_ref().len()
+            && self.y < self.height
+        {
+            // Decode one line of alternating white/black run-lengths
+            let mut transitions = Vec::new();
+            let mut a0 = 0u16;
+            let mut is_white = true;
+            loop {
+                let run = if is_white {
+                    Self::with_markup(fax34::maps::white::decode, &mut self.reader)
+                } else {
+                    Self::with_markup(fax34::maps::black::decode, &mut self.reader)
+                };
+                match run {
+                    Some(len) => {
+                        a0 = match a0.checked_add(len) {
+                            Some(v) => v,
+                            None => break, // overflow = corrupt data
+                        };
+                        transitions.push(a0);
+                        is_white = !is_white;
+                    }
+                    None => break,
+                }
+            }
+
+            self.y += 1;
+
+            // Convert transitions to packed bilevel output
+            let bytes_per_line = usize::from(self.width).div_ceil(8);
+            let buffer = self.line_buf.get_mut();
+            buffer.clear();
+            buffer.resize(bytes_per_line, 0u8);
+
+            let pels = fax34::decoder::pels(&transitions, self.width);
+            for (i, c) in pels.enumerate() {
+                if c == fax34::Color::Black {
+                    buffer[i / 8] |= 1 << (7 - (i % 8));
+                }
+            }
+            self.line_buf.set_position(0);
+
+            // Skip fill bits + line-ending EOL
+            Self::skip_eol(&mut self.reader);
+        }
+
+        self.line_buf.read(buf)
+    }
+}
+
+#[cfg(feature = "webp")]
+pub struct WebPReader {
+    inner: Cursor<Vec<u8>>,
+}
+
+#[cfg(feature = "webp")]
+impl WebPReader {
+    pub fn new<R: Read + Seek>(
+        reader: R,
+        compressed_length: u64,
+        samples: u16,
+    ) -> crate::TiffResult<Self> {
+        let mut decoder =
+            image_webp::WebPDecoder::new(io::BufReader::new(reader.take(compressed_length)))
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        if !(samples == 4 || (samples == 3 && !decoder.has_alpha())) {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "bad sample count for WebP compressed data",
+            )
+            .into());
+        }
+
+        let total_bytes =
+            samples as usize * decoder.dimensions().0 as usize * decoder.dimensions().1 as usize;
+        let mut data = vec![0; total_bytes];
+
+        decoder
+            .read_image(&mut data)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        // Add a fully opaque alpha channel if needed
+        if samples == 4 && !decoder.has_alpha() {
+            for i in (0..(total_bytes / 4)).rev() {
+                data[i * 4 + 3] = 255;
+                data[i * 4 + 2] = data[i * 3 + 2];
+                data[i * 4 + 1] = data[i * 3 + 1];
+                data[i * 4] = data[i * 3];
+            }
+        }
+
+        Ok(Self {
+            inner: Cursor::new(data),
+        })
+    }
+}
+
+#[cfg(feature = "webp")]
+impl Read for WebPReader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(buf)
     }
 }
 
@@ -330,8 +596,7 @@ mod test {
         let encoded_len = encoded.len();
 
         let buff = io::Cursor::new(encoded);
-        let (_, mut decoder) =
-            PackBitsReader::new(buff, ByteOrder::LittleEndian, 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,197 @@
+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")]
+#[derive(Clone)]
+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(),
+            u64::from(u16::MAX)
+        );
+    }
+
+    #[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,4 +1,126 @@
-use tags::PhotometricInterpretation;
+use crate::tags::{PhotometricInterpretation, SampleFormat};
+
+/// Apply floating-point predictor encoding to a row of floating-point samples.
+///
+/// The floating-point predictor works by:
+/// 1. Converting each value to big-endian bytes
+/// 2. Shuffling bytes so all first bytes are together, all second bytes, etc.
+/// 3. Applying byte-level horizontal difference (wrapping_sub) across the entire buffer
+///
+/// The decoder reverses this by:
+/// 1. Applying cumulative sum (wrapping_add) on the entire byte stream
+/// 2. De-shuffling bytes back into float values
+macro_rules! fp_predict {
+    ($name:ident, $float_type:ty) => {
+        fn $name(row: &[$float_type], samples: usize, result: &mut Vec<u8>) {
+            const BYTE_SIZE: usize = core::mem::size_of::<$float_type>();
+            let num_values = row.len();
+            let byte_count = num_values * BYTE_SIZE;
+            let start_len = result.len();
+
+            // Allocate zeroed space so we can write to arbitrary positions
+            result.resize(start_len + byte_count, 0);
+            let output = &mut result[start_len..];
+
+            // Step 1 & 2: Convert to big-endian and scatter bytes
+            for (i, &value) in row.iter().enumerate() {
+                let bytes = value.to_be_bytes();
+                for b in 0..BYTE_SIZE {
+                    output[b * num_values + i] = bytes[b];
+                }
+            }
+
+            // Step 3: Apply byte-level horizontal difference across the entire buffer.
+            // The prediction spans across quarter boundaries, just like the decoder's cumulative sum.
+            //
+            // We process elements in reverse in batches of 16 to enable autovectorization.
+            // Reverse order ensures that when we compute output[i] - output[i-samples],
+            // the value at output[i-samples] hasn't been overwritten yet (critical when
+            // samples < 16, which is the common case: 1, 3, 4, 5).
+            //
+            // 8 bits * 16 = 128 bits, the width of a typical SIMD register.
+            // Even if the target has no vector instructions, this still benefits from
+            // instruction-level parallelism, since unlike in decoding, all subtractions
+            // within a chunk are truly independent of each other.
+            let output = &mut result[start_len..byte_count + start_len];
+            let diff_len = byte_count - samples;
+            let remainder_len = diff_len % 16;
+            // Process full 16-byte chunks in reverse.
+            // We iterate from the end so that predecessor values (at lower indices)
+            // are still in their original state when we read them.
+            let mut chunk_end = byte_count;
+            while chunk_end >= samples + remainder_len + 16 {
+                let chunk_start = chunk_end - 16;
+                let prev_start = chunk_start - samples;
+
+                // Read all values in the chunk and their predecessors first.
+                // This makes all subtractions below independent, enabling vectorization.
+                let curr: [u8; 16] = output[chunk_start..chunk_end].try_into().unwrap();
+                let prev: [u8; 16] = output[prev_start..prev_start + 16].try_into().unwrap();
+
+                let chunk = &mut output[chunk_start..chunk_end];
+                chunk[0] = curr[0].wrapping_sub(prev[0]);
+                chunk[1] = curr[1].wrapping_sub(prev[1]);
+                chunk[2] = curr[2].wrapping_sub(prev[2]);
+                chunk[3] = curr[3].wrapping_sub(prev[3]);
+                chunk[4] = curr[4].wrapping_sub(prev[4]);
+                chunk[5] = curr[5].wrapping_sub(prev[5]);
+                chunk[6] = curr[6].wrapping_sub(prev[6]);
+                chunk[7] = curr[7].wrapping_sub(prev[7]);
+                chunk[8] = curr[8].wrapping_sub(prev[8]);
+                chunk[9] = curr[9].wrapping_sub(prev[9]);
+                chunk[10] = curr[10].wrapping_sub(prev[10]);
+                chunk[11] = curr[11].wrapping_sub(prev[11]);
+                chunk[12] = curr[12].wrapping_sub(prev[12]);
+                chunk[13] = curr[13].wrapping_sub(prev[13]);
+                chunk[14] = curr[14].wrapping_sub(prev[14]);
+                chunk[15] = curr[15].wrapping_sub(prev[15]);
+
+                chunk_end = chunk_start;
+            }
+            // Handle the leading remainder that doesn't fill a complete chunk of 16.
+            // This must be done last (after the reverse chunk loop) because these are
+            // the lowest indices, and the chunks above may read predecessor values
+            // from this range.
+            for i in (samples..samples + remainder_len).rev() {
+                output[i] = output[i].wrapping_sub(output[i - samples]);
+            }
+        }
+    };
+}
+
+fp_predict!(fp_predict_f32, f32);
+fp_predict!(fp_predict_f64, f64);
+
+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)),
+            );
+        }
+
+        fn floating_point_predict(_: &[Self::Inner], _: &mut Vec<u8>) {
+            unreachable!("floating-point predictor is only valid for floating-point sample types")
+        }
+    };
+}
 
 /// Trait for different colortypes that can be encoded.
 pub trait ColorType {
@@ -8,6 +130,14 @@ pub trait ColorType {
     const TIFF_VALUE: PhotometricInterpretation;
     /// The value of the tiff tag `BitsPerSample`
     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>);
+
+    /// Apply floating-point predictor encoding to a row of samples.
+    /// This is only implemented for floating-point types; integer types will panic.
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>);
 }
 
 pub struct Gray8;
@@ -15,6 +145,19 @@ impl ColorType for Gray8 {
     type Inner = u8;
     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;
+impl ColorType for GrayI8 {
+    type Inner = i8;
+    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;
@@ -22,6 +165,19 @@ impl ColorType for Gray16 {
     type Inner = u16;
     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;
+impl ColorType for GrayI16 {
+    type Inner = i16;
+    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;
@@ -29,6 +185,35 @@ impl ColorType for Gray32 {
     type Inner = u32;
     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;
+impl ColorType for GrayI32 {
+    type Inner = i32;
+    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;
+impl ColorType for Gray32Float {
+    type Inner = f32;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f32(row, Self::SAMPLE_FORMAT.len(), result)
+    }
 }
 
 pub struct Gray64;
@@ -36,6 +221,35 @@ impl ColorType for Gray64 {
     type Inner = u64;
     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;
+impl ColorType for GrayI64 {
+    type Inner = i64;
+    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;
+impl ColorType for Gray64Float {
+    type Inner = f64;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f64(row, Self::SAMPLE_FORMAT.len(), result)
+    }
 }
 
 pub struct RGB8;
@@ -43,6 +257,9 @@ impl ColorType for RGB8 {
     type Inner = u8;
     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;
@@ -50,6 +267,9 @@ impl ColorType for RGB16 {
     type Inner = u16;
     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;
@@ -57,6 +277,25 @@ impl ColorType for RGB32 {
     type Inner = u32;
     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;
+impl ColorType for RGB32Float {
+    type Inner = f32;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f32(row, Self::SAMPLE_FORMAT.len(), result)
+    }
 }
 
 pub struct RGB64;
@@ -64,6 +303,25 @@ impl ColorType for RGB64 {
     type Inner = u64;
     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;
+impl ColorType for RGB64Float {
+    type Inner = f64;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f64(row, Self::SAMPLE_FORMAT.len(), result)
+    }
 }
 
 pub struct RGBA8;
@@ -71,6 +329,9 @@ impl ColorType for RGBA8 {
     type Inner = u8;
     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;
@@ -78,20 +339,61 @@ impl ColorType for RGBA16 {
     type Inner = u16;
     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;
 impl ColorType for RGBA32 {
-    type Inner = u16;
+    type Inner = u32;
     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;
+impl ColorType for RGBA32Float {
+    type Inner = f32;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f32(row, Self::SAMPLE_FORMAT.len(), result)
+    }
 }
 
 pub struct RGBA64;
 impl ColorType for RGBA64 {
-    type Inner = u16;
+    type Inner = u64;
     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;
+impl ColorType for RGBA64Float {
+    type Inner = f64;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f64(row, Self::SAMPLE_FORMAT.len(), result)
+    }
 }
 
 pub struct CMYK8;
@@ -99,6 +401,9 @@ impl ColorType for CMYK8 {
     type Inner = u8;
     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;
@@ -106,6 +411,9 @@ impl ColorType for CMYK16 {
     type Inner = u16;
     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;
@@ -113,6 +421,25 @@ impl ColorType for CMYK32 {
     type Inner = u32;
     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;
+impl ColorType for CMYK32Float {
+    type Inner = f32;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f32(row, Self::SAMPLE_FORMAT.len(), result)
+    }
 }
 
 pub struct CMYK64;
@@ -120,4 +447,43 @@ impl ColorType for CMYK64 {
     type Inner = u64;
     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;
+impl ColorType for CMYK64Float {
+    type Inner = f64;
+    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!("horizontal predictor is not valid for floating-point sample types")
+    }
+
+    fn floating_point_predict(row: &[Self::Inner], result: &mut Vec<u8>) {
+        fp_predict_f64(row, Self::SAMPLE_FORMAT.len(), result)
+    }
+}
+
+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,69 @@
+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,
+}
+
+impl Deflate {
+    /// Create a new deflate compressor with a specific level of compression.
+    ///
+    /// The valid levels are 1 through 9 inclusive. The default level is 6.
+    ///
+    /// - `1` stands for light but fast compression
+    /// - `6` is the recommended balanced default
+    /// - `9` is maximum compression ratio at the cost of slow encoding
+    pub fn with_level(level: u8) -> Self {
+        Self {
+            level: FlateCompression::new(level as u32),
+        }
+    }
+}
+
+impl Default for Deflate {
+    fn default() -> Self {
+        Self::with_level(6)
+    }
+}
+
+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;
+
+#[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/tiff_value.rs

@@ -0,0 +1,687 @@
+use std::{borrow::Cow, io::Write, slice::from_ref};
+
+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)
+    }
+
+    /// 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] {
+    const BYTE_LEN: u8 = 1;
+    const FIELD_TYPE: Type = Type::BYTE;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(self)
+    }
+}
+
+impl TiffValue for [i8] {
+    const BYTE_LEN: u8 = 1;
+    const FIELD_TYPE: Type = Type::SBYTE;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i8_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [u16] {
+    const BYTE_LEN: u8 = 2;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u16_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [i16] {
+    const BYTE_LEN: u8 = 2;
+    const FIELD_TYPE: Type = Type::SSHORT;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i16_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [u32] {
+    const BYTE_LEN: u8 = 4;
+    const FIELD_TYPE: Type = Type::LONG;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u32_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [i32] {
+    const BYTE_LEN: u8 = 4;
+    const FIELD_TYPE: Type = Type::SLONG;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i32_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [u64] {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::LONG8;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u64_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [i64] {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::SLONG8;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i64_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [f32] {
+    const BYTE_LEN: u8 = 4;
+    const FIELD_TYPE: Type = Type::FLOAT;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        // We write using native endian so this should be safe
+        Cow::Borrowed(bytecast::f32_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for [f64] {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::DOUBLE;
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        // We write using native endian so this should be safe
+        Cow::Borrowed(bytecast::f64_as_ne_bytes(self))
+    }
+}
+
+impl TiffValue for u8 {
+    const BYTE_LEN: u8 = 1;
+    const FIELD_TYPE: Type = Type::BYTE;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u8(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(from_ref(self))
+    }
+}
+
+impl TiffValue for i8 {
+    const BYTE_LEN: u8 = 1;
+    const FIELD_TYPE: Type = Type::SBYTE;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i8(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i8_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for u16 {
+    const BYTE_LEN: u8 = 2;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u16(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u16_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for i16 {
+    const BYTE_LEN: u8 = 2;
+    const FIELD_TYPE: Type = Type::SSHORT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i16(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i16_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for u32 {
+    const BYTE_LEN: u8 = 4;
+    const FIELD_TYPE: Type = Type::LONG;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u32(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for i32 {
+    const BYTE_LEN: u8 = 4;
+    const FIELD_TYPE: Type = Type::SLONG;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i32(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i32_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for u64 {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::LONG8;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u64(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for i64 {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::SLONG8;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i64(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::i64_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for f32 {
+    const BYTE_LEN: u8 = 4;
+    const FIELD_TYPE: Type = Type::FLOAT;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_f32(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::f32_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for f64 {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::DOUBLE;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_f64(*self)?;
+        Ok(())
+    }
+
+    fn data(&self) -> Cow<'_, [u8]> {
+        Cow::Borrowed(bytecast::f64_as_ne_bytes(from_ref(self)))
+    }
+}
+
+impl TiffValue for Ifd {
+    const BYTE_LEN: u8 = 4;
+    const FIELD_TYPE: Type = Type::IFD;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        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 {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::IFD8;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        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 {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::RATIONAL;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u32(self.n)?;
+        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 {
+    const BYTE_LEN: u8 = 8;
+    const FIELD_TYPE: Type = Type::SRATIONAL;
+
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i32(self.n)?;
+        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 {
+    const BYTE_LEN: u8 = 1;
+    const FIELD_TYPE: Type = Type::ASCII;
+
+    fn count(&self) -> usize {
+        self.len() + 1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        if self.is_ascii() && !self.bytes().any(|b| b == 0) {
+            writer.write_bytes(self.as_bytes())?;
+            writer.write_u8(0)?;
+            Ok(())
+        } else {
+            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![]
+            }
+        })
+    }
+}
+
+// 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;
+
+    fn count(&self) -> usize {
+        (*self).count()
+    }
+
+    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(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct Ifd(pub u32);
+
+/// Type to represent tiff values of type `IFD8`
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct Ifd8(pub u64);
+
+/// Type to represent tiff values of type `RATIONAL`
+#[derive(Debug, Copy, Clone)]
+pub struct Rational {
+    pub n: u32,
+    pub d: u32,
+}
+
+/// Type to represent tiff values of type `SRATIONAL`
+#[derive(Debug, Copy, Clone)]
+pub struct SRational {
+    pub n: i32,
+    pub d: i32,
+}

src/encoder/writer.rs

@@ -1,100 +1,178 @@
-use error::TiffResult;
-use byteorder::{BigEndian, ByteOrder, LittleEndian, NativeEndian, WriteBytesExt};
+use crate::encoder::compression::*;
+use crate::error::TiffResult;
 use std::io::{self, Seek, SeekFrom, Write};
 
-pub trait TiffByteOrder: ByteOrder {
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()>;
-}
+pub fn write_tiff_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
+    #[cfg(target_endian = "little")]
+    let boi: u8 = 0x49;
+    #[cfg(not(target_endian = "little"))]
+    let boi: u8 = 0x4d;
 
-impl TiffByteOrder for LittleEndian {
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        writer.writer.write_u16::<LittleEndian>(0x4949)?;
-        writer.writer.write_u16::<LittleEndian>(42)?;
+    writer.writer.write_all(&[boi, boi])?;
+    writer.writer.write_all(&42u16.to_ne_bytes())?;
     writer.offset += 4;
 
     Ok(())
-    }
 }
 
-impl TiffByteOrder for BigEndian {
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        writer.writer.write_u16::<BigEndian>(0x4d4d)?;
-        writer.writer.write_u16::<BigEndian>(42)?;
-        writer.offset += 4;
+/// Writes a BigTiff header, excluding the IFD offset field.
+///
+/// Writes the byte order, version number, offset byte size, and zero constant fields. Does
+// _not_ write the offset to the first IFD, this should be done by the caller.
+pub fn write_bigtiff_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
+    #[cfg(target_endian = "little")]
+    let boi: u8 = 0x49;
+    #[cfg(not(target_endian = "little"))]
+    let boi: u8 = 0x4d;
+
+    // byte order indication
+    writer.writer.write_all(&[boi, boi])?;
+    // version number
+    writer.writer.write_all(&43u16.to_ne_bytes())?;
+    // bytesize of offsets (pointer size)
+    writer.writer.write_all(&8u16.to_ne_bytes())?;
+    // always 0
+    writer.writer.write_all(&0u16.to_ne_bytes())?;
+
+    // we wrote 8 bytes, so set the internal offset accordingly
+    writer.offset += 8;
 
     Ok(())
-    }
 }
 
 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_u8(n)?;
-        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_i8(n)?;
-        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_u16::<NativeEndian>(n)?;
-        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_i16::<NativeEndian>(n)?;
-        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_u32::<NativeEndian>(n)?;
-        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_i32::<NativeEndian>(n)?;
-        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_u64::<NativeEndian>(n)?;
-        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.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.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.byte_count = self
+            .compressor
+            .write_to(&mut self.writer, &u64::to_ne_bytes(n.to_bits()))?;
+        self.offset += self.byte_count;
 
         Ok(())
     }
 
     pub fn pad_word_boundary(&mut self) -> Result<(), io::Error> {
-        if self.offset % 4 != 0 {
+        if !self.offset.is_multiple_of(4) {
             let padding = [0, 0, 0];
             let padd_len = 4 - (self.offset % 4);
             self.writer.write_all(&padding[..padd_len as usize])?;
@@ -108,7 +186,70 @@ 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::DecodingSampleBuffer::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::open(&mut write.inner).unwrap();
+        tiff_reader.next_image().unwrap();
+        let _layout = tiff_reader.read_image_to_buffer(&mut data).unwrap();
+
+        assert!(
+            matches!(&data, crate::decoder::DecodingSampleBuffer::U8(v) if *v == imgdata),
+            "{data:?} @ {}",
+            data.as_buffer(0).byte_len()
+        );
+    }
+}

src/error.rs

@@ -1,207 +1,229 @@
-use std::error::Error;
-use std::fmt;
 use std::io;
+use std::str;
 use std::string;
 
-use decoder::ifd::{Value};
-use tags::{CompressionMethod, PhotometricInterpretation, PlanarConfiguration, Tag};
-use miniz_oxide::inflate::TINFLStatus;
-use ColorType;
+use quick_error::quick_error;
 
-/// Tiff error kinds.
-#[derive(Debug)]
-pub enum TiffError {
+use crate::decoder::ChunkType;
+use crate::tags::Type;
+use crate::tags::{
+    CompressionMethod, PhotometricInterpretation, PlanarConfiguration, SampleFormat, Tag,
+};
+use crate::ColorType;
+
+quick_error! {
+    /// Tiff error kinds.
+    #[derive(Debug)]
+    pub enum TiffError {
         /// The Image is not formatted properly.
-    FormatError(TiffFormatError),
-
+        FormatError(err: TiffFormatError) {
+            display("format error: {err}")
+            from()
+            source(err)
+        }
         /// The Decoder does not support features required by the image.
-    UnsupportedError(TiffUnsupportedError),
-
+        UnsupportedError(err: TiffUnsupportedError) {
+            display("unsupported error: {err}")
+            from()
+            source(err)
+        }
         /// An I/O Error occurred while decoding the image.
-    IoError(io::Error),
-
+        IoError(err: io::Error) {
+            display("{err}")
+            from()
+            source(err)
+        }
         /// 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 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, Eq, Hash)]
-pub enum TiffFormatError {
-    TiffSignatureNotFound,
-    TiffSignatureInvalid,
-    ImageFileDirectoryNotFound,
-    InconsistentSizesEncountered,
-    InvalidTag,
-    InvalidTagValueType(Tag),
-    RequiredTagNotFound(Tag),
-    UnknownPredictor(u16),
-    UnsignedIntegerExpected(Value),
-    SignedIntegerExpected(Value),
-    InflateError(InflateError),
-    #[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."),
-            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)
+        LimitsExceeded {
+            display("decoder limits exceeded")
         }
-            UnsignedIntegerExpected(ref val) => {
-                write!(fmt, "Expected unsigned integer, {:?} found.", val)
+        /// An integer conversion to or from a platform size failed.
+        IntSizeError {
+            display("platform or format size limits exceeded")
         }
-            SignedIntegerExpected(ref val) => {
-                write!(fmt, "Expected signed integer, {:?} found.", val)
-            }
-            InflateError(_) => write!(fmt, "Failed to decode inflate data."),
-            __NonExhaustive => unreachable!(),
+        /// The image does not support the requested operation
+        UsageError(err: UsageError) {
+            display("usage error: {err}")
+            from()
+            source(err)
         }
     }
 }
 
-/// Decompression failed due to faulty compressed data.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct InflateError {
-    status: TINFLStatus,
-}
-
-impl InflateError {
-    pub(crate) fn new(status: TINFLStatus) -> Self {
-        Self { status }
+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")
         }
-}
-
-impl TiffError {
-    pub(crate) fn from_inflate_status(status: TINFLStatus) -> Self {
-        TiffError::FormatError(TiffFormatError::InflateError(InflateError::new(status)))
+        TiffSignatureInvalid {
+            display("TIFF signature invalid")
         }
-}
-
-/// 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),
-    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)
+        ImageFileDirectoryNotFound {
+            display("image file directory not found")
         }
-            UnsupportedSampleDepth(samples) => {
-                write!(fmt, "{} samples per pixel is unsupported.", samples)
+        InconsistentSizesEncountered {
+            display("inconsistent sizes encountered")
         }
-            UnsupportedColorType(color_type) => {
-                write!(fmt, "Color type {:?} is unsupported", color_type)
+        IncorrectChunkCount {expected: u32, found: u32} {
+            display("incorrect number of chunk offsets encoded for the tile count of the image, expected {expected} but found {found}")
         }
-            UnsupportedBitsPerChannel(bits) => {
-                write!(fmt, "{} bits per channel not supported", bits)
+        InvalidDimensions(width: u32, height: u32) {
+            display("invalid dimensions: {width}x{height}")
         }
-            UnsupportedPlanarConfig(config) => {
-                write!(fmt, "Unsupported planar configuration “{:?}”.", config)
+        InvalidTag {
+            display("image contains invalid tag")
         }
-            UnsupportedDataType => write!(fmt, "Unsupported data type."),
-            __NonExhaustive => unreachable!(),
+        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}")
         }
     }
 }
 
-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"),
+quick_error! {
+    /// 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.
+    #[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")
         }
     }
 }
 
-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",
+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:?}")
         }
+        InvalidChunkIndex(index: u32) {
+            display("invalid chunk index ({index}) requested")
         }
-
-    fn cause(&self) -> Option<&dyn Error> {
-        match *self {
-            TiffError::IoError(ref e) => Some(e),
-            _ => None,
+        InvalidPlaneIndex(index: u16) {
+            display("invalid plane index ({index}) requested")
+        }
+        InvalidCodingUnit(index: u32, have: u32) {
+            display("out of bounds coding unit ({index}) requested, only {have} available")
+        }
+        PredictorCompressionMismatch {
+            display("requested predictor is not compatible with the requested compression")
+        }
+        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)
+impl From<str::Utf8Error> for TiffError {
+    fn from(_err: str::Utf8Error) -> TiffError {
+        TiffError::FormatError(TiffFormatError::InvalidTag)
     }
 }
 
@@ -211,23 +233,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
-//! * <http://partners.adobe.com/public/developer/tiff/index.html> - The TIFF specification
-
-extern crate byteorder;
-extern crate lzw;
-extern crate miniz_oxide;
+//! * <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::error::{InflateError, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError};
+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,49 @@ 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 {
+    /// The number of bits used to store each sample.
+    pub 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,
+        }
+    }
+
+    /// The number of samples in each representation of a single color.
+    pub 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,30 @@
+use crate::encoder::TiffValue;
+use core::fmt;
+
 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,40 +32,55 @@ 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 }, )*
                 }
             }
         }
 
-        tags!($name, $ty);
+        tags!($name, $ty, $($unknown_doc)*);
     };
     // For u16 tags, provide direct inherent primitive conversion methods.
-    ($name:tt, u16) => {
+    ($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 to_u16(&self) -> u16 {
+            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 const fn to_u16(&self) -> u16 {
                 Self::__to_inner_type(self)
             }
         }
     };
     // For other tag types, do nothing for now. With concat_idents one could
     // provide inherent conversion methods for all types.
-    ($name:tt, $ty:tt) => {};
+    ($name:tt, $ty:tt, $($unknown_doc:literal)*) => {};
 }
 
 // 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
@@ -73,7 +90,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
@@ -105,49 +121,184 @@ pub enum Tag(u16) unknown("A private or extension tag") {
     YResolution = 283,
     // Advanced tags
     Predictor = 317,
+    TileWidth = 322,
+    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
 }
 }
 
-impl Tag {
-    pub fn from_u16_exhaustive(val: u16) -> Self {
-        Self::from_u16(val).unwrap_or_else(|| Tag::Unknown(val))
+/// 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);
+
+impl fmt::LowerHex for IfdPointer {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(&self.0, f)
+    }
+}
+
+impl core::fmt::UpperHex for IfdPointer {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::UpperHex::fmt(&self.0, f)
     }
 }
 
 tags! {
 /// The type of an IFD entry (a 2 byte field).
 pub enum Type(u16) {
+    /// 8-bit unsigned integer
     BYTE = 1,
+    /// 8-bit byte that contains a 7-bit ASCII code; the last byte must be zero
     ASCII = 2,
+    /// 16-bit unsigned integer
     SHORT = 3,
+    /// 32-bit unsigned integer
     LONG = 4,
+    /// Fraction stored as two 32-bit unsigned integers
     RATIONAL = 5,
+    /// 8-bit signed integer
     SBYTE = 6,
+    /// 8-bit byte that may contain anything, depending on the field
+    UNDEFINED = 7,
+    /// 16-bit signed integer
     SSHORT = 8,
+    /// 32-bit signed integer
     SLONG = 9,
+    /// Fraction stored as two 32-bit signed integers
     SRATIONAL = 10,
+    /// 32-bit IEEE floating point
+    FLOAT = 11,
+    /// 64-bit IEEE floating point
+    DOUBLE = 12,
+    /// 32-bit unsigned integer (offset)
+    IFD = 13,
     /// BigTIFF 64-bit unsigned integer
     LONG8 = 16,
+    /// BigTIFF 64-bit signed integer
+    SLONG8 = 17,
+    /// BigTIFF 64-bit unsigned integer (offset)
+    IFD8 = 18,
 }
 }
 
+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! {
-pub enum CompressionMethod(u16) {
+/// See [TIFF compression tags](https://www.awaresystems.be/imaging/tiff/tifftags/compression.html)
+/// for reference.
+pub enum CompressionMethod(u16) unknown(
+    /// A custom compression method
+    unknown
+) {
     None = 1,
     Huffman = 2,
     Fax3 = 3,
     Fax4 = 4,
     LZW = 5,
     JPEG = 6,
+    // "Extended JPEG" or "new JPEG" style
+    ModernJPEG = 7,
     Deflate = 8,
     OldDeflate = 0x80B2,
     PackBits = 0x8005,
+
+    // Self-assigned by libtiff
+    ZSTD = 0xC350,
+
+    // Self-assigned by libtiff
+    WebP = 0xC351,
+
+    // Self-assigned by libtiff/SGI
+    // A packbit like scheme on specific 32-bit samples (16 sint luma, 8 sint u,v). Only really
+    // compatible with PhotometricInterpretation CIELogLuv.
+    SgiLog = 34676,
+    // A packbit like scheme on specific 24-bit samples (10 packed bits luma, 14-bit uv index).
+    // Only really compatible with PhotometricInterpretation CIELogLuv.
+    SgiLog24 = 34677,
 }
 }
 
 tags! {
-pub enum PhotometricInterpretation(u16) {
+pub enum PhotometricInterpretation(u16) unknown(
+    /// A private or extension tag
+    unknown
+) {
     WhiteIsZero = 0,
     BlackIsZero = 1,
     RGB = 2,
@@ -155,7 +306,41 @@ pub enum PhotometricInterpretation(u16) {
     TransparencyMask = 4,
     CMYK = 5,
     YCbCr = 6,
+    /// Biased Lab with all coefficients stored as unsigned integers.
     CIELab = 8,
+    IccLab = 9,
+    ItuLab = 10,
+    /// Logarithmic L* color space,
+    ///
+    /// see: <https://web.archive.org/web/20250121120358/https://www.anyhere.com/gward/pixformat/tiffluv.html>
+    /// References: <https://doi.org/10.2352/CIC.1998.6.1.art00046>
+    ///
+    /// The `uv` coordinates are based on:
+    ///
+    /// ```text
+    /// (6*u - 16*v + 12) * (-2x + 12y + 3) = 36
+    ///
+    /// u' = 4x / ( -2x + 12y + 3 )
+    /// v' = 9y / ( -2x + 12y + 3 )
+    /// x = 9u' / (6u' - 16v' + 12)
+    /// y = 4v' / (6u' - 16v' + 12)
+    /// ```
+    ///
+    /// Since `(-2x + 12y + 3) <= 15` it holds `(6u' - 16v' + 12) >= 36/15` for all XYZ colors
+    /// which makes the back transform to `xyY` well-defined. Also `v' <= 9/15 = 0.6` and also
+    /// by practical means `u' <= 2/3`.
+    ///
+    /// The compression format that is supposed to be used with this constrains them as well. It
+    /// encodes each component as a 16-bit unsigned integer scaled and clamped to a quantization
+    /// using 256 out of 410 levels or an index into a table based on a quantization to 177 levels
+    /// each `0.0035` (~1/286) wide and 163 levels of `v` (same quantization width).
+    ///
+    /// > Larson, G.W., ``Overcoming Gamut and Dynamic Range Limitations in Digital Images,'' Proceedings of the Sixth Color Imaging Conference, November 1998.
+    CIELogL = 32844,
+    /// Logarithmic L*u'v' color space,
+    ///
+    /// See references under [`Self::CIELogL`].
+    CIELogLuv = 32845,
 }
 }
 
@@ -168,12 +353,21 @@ 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,
+    /// Floating-point predictor for IEEE floating-point sample types.
+    ///
+    /// This predictor byte-shuffles the data and applies byte-level horizontal differencing.
+    FloatingPoint = 3,
 }
 }
 
-tags!{
+tags! {
 /// Type to represent resolution units
 pub enum ResolutionUnit(u16) {
     None = 1,
@@ -181,3 +375,285 @@ pub enum ResolutionUnit(u16) {
     Centimeter = 3,
 }
 }
+
+tags! {
+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.
+    ///
+    /// This is equivalent to calling [`Self::set_value`] on a newly created buffer.
+    ///
+    /// # Example
+    ///
+    /// Create a buffer representing a particular tag's value:
+    ///
+    /// ```
+    /// use tiff::tags::{ByteOrder, CompressionMethod, ValueBuffer};
+    ///
+    /// // A buffer with initial content, for instance a tag's value.
+    /// let buffer = ValueBuffer::from_value(&CompressionMethod::ModernJPEG);
+    /// assert_eq!(buffer.as_bytes().len(), 2);
+    ///
+    /// // Note that depends on host endianess which of these holds:
+    /// assert!(buffer.as_bytes() == [0, 7] || buffer.as_bytes() == [7, 0]);
+    /// ```
+    pub fn from_value<T: TiffValue + ?Sized>(value: &T) -> Self {
+        ValueBuffer {
+            bytes: value.data().into_owned(),
+            ty: <T as TiffValue>::FIELD_TYPE,
+            count: value.count() as u64,
+            byte_order: ByteOrder::native(),
+        }
+    }
+
+    /// Set the buffer to the defined value.
+    ///
+    /// The previous data is erased. This converts the value's representation to the byte order of
+    /// the buffer in the process (which is a no-op if the buffer uses host byte order).
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use tiff::tags::{ByteOrder, CompressionMethod, ValueBuffer};
+    ///
+    /// // A buffer with initial content, for instance a tag's value.
+    /// let mut buffer = ValueBuffer::from_value(&CompressionMethod::JPEG);
+    /// assert_eq!(buffer.as_bytes().len(), 2);
+    ///
+    /// // Ensure a host-independent byte order for the following representation.
+    /// buffer.set_byte_order(ByteOrder::LittleEndian);
+    /// // slices and arrays of primitives are a possible `TiffValue`
+    /// buffer.set_value(&[0, 1, 42u16]);
+    ///
+    /// // The little endian representation of these numbers (2 bytes each)
+    /// assert_eq!(buffer.as_bytes(), [0, 0, 1, 0, 42, 0]);
+    /// ```
+    pub fn set_value<T: TiffValue + ?Sized>(&mut self, value: &T) {
+        self.bytes.clear();
+
+        match value.data() {
+            std::borrow::Cow::Borrowed(slice) => self.bytes.extend_from_slice(slice),
+            std::borrow::Cow::Owned(ref mut data) => self.bytes.append(data),
+        }
+
+        self.ty = <T as TiffValue>::FIELD_TYPE;
+        self.count = value.count() as u64;
+
+        ByteOrder::native().convert(self.ty, &mut self.bytes, self.byte_order);
+    }
+
+    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]
+    }
+
+    /// 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
+    }
+}
+
+/// Create an empty value buffer with `Byte` type. This type choice is arbitrary.
+impl Default for ValueBuffer {
+    fn default() -> Self {
+        ValueBuffer::empty(Type::BYTE)
+    }
+}
+
+/// 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;
+        }
+
+        match cls {
+            EndianBytes::One => {
+                // No change needed
+            }
+            EndianBytes::Two => {
+                for chunk in buffer.as_chunks_mut::<2>().0 {
+                    *chunk = u16::from_be_bytes(*chunk).to_le_bytes();
+                }
+            }
+            EndianBytes::Four => {
+                for chunk in buffer.as_chunks_mut::<4>().0 {
+                    *chunk = u32::from_be_bytes(*chunk).to_le_bytes();
+                }
+            }
+            EndianBytes::Eight => {
+                for chunk in buffer.as_chunks_mut::<8>().0 {
+                    *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,
+}
+
+/// Defines how directories are laid out in the file.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TiffVariant {
+    /// TIFF-V6.0 with 32-bit offsets and counts.
+    Standard,
+    /// Extended TIFF with 64-bit offsets and counts and long directories.
+    BigTiff,
+}

tests/COPYRIGHT

@@ -0,0 +1,12 @@
+subsubifd.tif:
+  url: https://data.kitware.com/api/v1/file/hashsum/sha512/372ca32735c8a8fdbe2286dabead9e779da63f10ba81eda84625e5273f76d74ca1a47a978f67e9c00c12f7f72009c7b2c07a641e643bb0c463812f4ae7f15d6e/download
+  credit: https://github.com/DigitalSlideArchive/tifftools/commit/4d00c70dbce828262f86c1431f7c66b1748965ac
+  license: CC0
+usda/*.tif
+  url: https://registry.opendata.aws/naip/index.html
+  credit: NAIP on AWS was accessed on 2026-01-28 from https://registry.opendata.aws/naip.
+  license: Public Domain
+libtiffpic/
+  url: https://download.osgeo.org/libtiff/
+  credit: libtiff
+  license: CC0

tests/benches/README.md

@@ -0,0 +1,4 @@
+Copyrights:
+
+kodim*.png: Eastman Kodak Company, released for unrestricted use
+Transparency.png: Public Domain, according to Wikimedia

tests/decode_bigtiff_images.rs

@@ -0,0 +1,47 @@
+extern crate tiff;
+
+use tiff::decoder::Decoder;
+use tiff::tags::Tag;
+use tiff::ColorType;
+
+use std::fs::File;
+use std::path::PathBuf;
+
+const TEST_IMAGE_DIR: &str = "./tests/images/bigtiff";
+
+#[test]
+fn test_big_tiff() {
+    let filenames = ["BigTIFF.tif", "BigTIFFMotorola.tif", "BigTIFFLong.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::open(img_file).expect("Cannot create decoder");
+        decoder.next_image().expect("Cannot read image");
+
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (64, 64)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::RGB(8)
+        );
+
+        let mut ifd = decoder.current_ifd();
+        assert_eq!(
+            ifd.get_tag_u64(Tag::StripOffsets)
+                .expect("Cannot get StripOffsets"),
+            16
+        );
+        assert_eq!(
+            ifd.get_tag_u64(Tag::RowsPerStrip)
+                .expect("Cannot get RowsPerStrip"),
+            64
+        );
+        assert_eq!(
+            ifd.get_tag_u64(Tag::StripByteCounts)
+                .expect("Cannot get StripByteCounts"),
+            12288
+        )
+    }
+}

tests/decode_fp16_images.rs

@@ -0,0 +1,210 @@
+extern crate tiff;
+
+use tiff::decoder::{Decoder, DecodingSampleBuffer};
+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::open(img_file).expect("Cannot create decoder");
+        decoder.next_image().expect("Cannot read image");
+
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+
+        if let DecodingSampleBuffer::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::open(img_file).expect("Cannot create decoder");
+        decoder.next_image().expect("Cannot read image");
+
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+
+        if let DecodingSampleBuffer::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::open(img_file).expect("Cannot create decoder");
+        decoder.next_image().expect("Cannot read image");
+
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+
+        if let DecodingSampleBuffer::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::open(img_file).expect("Cannot create decoder");
+        decoder.next_image().expect("Cannot read image");
+
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (256, 256)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+
+        if let DecodingSampleBuffer::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::open(img_file).expect("Cannot create decoder");
+        decoder.next_image().expect("Cannot read image");
+
+        assert_eq!(
+            decoder.dimensions().expect("Cannot get dimensions"),
+            (16, 16)
+        );
+        assert_eq!(
+            decoder.colortype().expect("Cannot get colortype"),
+            ColorType::Gray(16)
+        );
+
+        if let DecodingSampleBuffer::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,80 @@
+extern crate tiff;
+
+use tiff::decoder::{Decoder, DecodingSampleBuffer};
+use tiff::tags::Tag;
+use tiff::ColorType;
+
+use std::fs::File;
+use std::path::PathBuf;
+
+const TEST_IMAGE_DIR: &str = "./tests/geotiff";
+
+#[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::open(img_file).expect("Cannot create decoder");
+        decoder = decoder.with_limits(tiff::decoder::Limits::unlimited());
+        decoder.next_image().expect("Cannot read image");
+
+        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
+            }
+        );
+
+        let mut ifd = decoder.current_ifd();
+        assert_eq!(
+            ifd.get_tag_u64(Tag::StripOffsets)
+                .expect("Cannot get StripOffsets"),
+            418
+        );
+        assert_eq!(
+            ifd.get_tag_u64(Tag::RowsPerStrip)
+                .expect("Cannot get RowsPerStrip"),
+            10
+        );
+        assert_eq!(
+            ifd.get_tag_u64(Tag::StripByteCounts)
+                .expect("Cannot get StripByteCounts"),
+            1000
+        );
+        assert_eq!(
+            ifd.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 DecodingSampleBuffer::I16(data) = decoder.read_image().unwrap() else {
+            panic!("Cannot read band data")
+        };
+        assert_eq!(data.len(), 500);
+    }
+}
+
+#[cfg(feature = "webp")]
+#[test]
+fn test_webp_tiff() {
+    let filenames = ["usda_naip_256_webp_z3.tif"];
+    let mut buffer = DecodingSampleBuffer::U8(vec![]);
+
+    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::open(img_file).expect("Cannot create decoder");
+
+        while decoder.more_images() {
+            decoder.next_image().unwrap();
+            decoder.read_image_to_buffer(&mut buffer).unwrap();
+        }
+    }
+}

tests/decode_libtiffpic.rs

@@ -0,0 +1,364 @@
+use std::collections::HashMap;
+use std::{fs::File, path};
+
+use tiff::decoder::{Decoder, DecodingSampleBuffer};
+use tiff::tags::{ByteOrder, Type};
+use tiff::ColorType;
+
+use libtest_mimic::{Arguments, Failed, Trial};
+use walkdir::WalkDir;
+
+const REFERENCE_DIR: &str = "tests/libtiffpic";
+
+// `find test/libtiffpic -type f | sort`
+//
+// Each entry maps a file path to its expected behavior:
+//   None           = not a TIFF file, skip entirely
+//   Some(0)        = TIFF with unsupported features, decode-only smoke test
+//   Some(nonzero)  = TIFF with full CRC32 hash verification of decoded output
+const FILES: &[(&str, Option<u32>)] = &[
+    ("tests/libtiffpic/caspian.tif", Some(0x4ea8d4e4)),
+    ("tests/libtiffpic/cramps.tif", Some(0xdfa2fba4)),
+    ("tests/libtiffpic/cramps-tile.tif", Some(0xdfa2fba4)),
+    ("tests/libtiffpic/CVS/Entries", None),
+    ("tests/libtiffpic/CVS/Repository", None),
+    ("tests/libtiffpic/CVS/Root", None),
+    ("tests/libtiffpic/depth/CVS/Entries", None),
+    ("tests/libtiffpic/depth/CVS/Repository", None),
+    ("tests/libtiffpic/depth/CVS/Root", None),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-02.tif",
+        Some(0x1c90f515),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-04.tif",
+        Some(0x0f4813cb),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-06.tif",
+        Some(0xf0c0a901),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-08.tif",
+        Some(0xe797b15b),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-10.tif",
+        Some(0xdee442ec),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-12.tif",
+        Some(0x4810c4e9),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-14.tif",
+        Some(0x7e03cf03),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-16.tif",
+        Some(0x8e0add32),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-24.tif",
+        Some(0x5cf29313),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-minisblack-32.tif",
+        Some(0x80025eee),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-palette-02.tif",
+        Some(0xaeb21cff),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-palette-04.tif",
+        Some(0x339d428b),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-palette-08.tif",
+        Some(0xb6b203e9),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-palette-16.tif",
+        Some(0x4e02308f),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-02.tif",
+        Some(0x8f16cf35),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-04.tif",
+        Some(0x95e97f94),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-08.tif",
+        Some(0x98134e7c),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-10.tif",
+        Some(0xa2ad8f4d),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-12.tif",
+        Some(0xfad187fc),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-14.tif",
+        Some(0x93fdc170),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-16.tif",
+        Some(0x25e1066b),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-24.tif",
+        Some(0x25cdf743),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-contig-32.tif",
+        Some(0x195dde9c),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-02.tif",
+        Some(0xcc0281ca),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-04.tif",
+        Some(0x867134b2),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-08.tif",
+        Some(0x2341af83),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-10.tif",
+        Some(0x79211047),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-12.tif",
+        Some(0x14a0ff72),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-14.tif",
+        Some(0xc077389d),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-16.tif",
+        Some(0xd0849282),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-24.tif",
+        Some(0x433d333b),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-rgb-planar-32.tif",
+        Some(0xd0780b23),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-separated-contig-08.tif",
+        Some(0x97fb03a6),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-separated-contig-16.tif",
+        Some(0xb6ee0135),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-separated-planar-08.tif",
+        Some(0x502e93fa),
+    ),
+    (
+        "tests/libtiffpic/depth/flower-separated-planar-16.tif",
+        Some(0x50e580d9),
+    ),
+    ("tests/libtiffpic/depth/genimages", None),
+    ("tests/libtiffpic/depth/README.txt", None),
+    ("tests/libtiffpic/depth/summary.txt", None),
+    ("tests/libtiffpic/dscf0013.tif", Some(0)), // unsupported YCbCr chroma subsampling
+    ("tests/libtiffpic/fax2d.tif", Some(0xc2f30c6f)),
+    // No support for direct CCITT Group 3 1D format
+    ("tests/libtiffpic/g3test.g3", None),
+    ("tests/libtiffpic/g3test.tif", Some(0x304b606b)),
+    ("tests/libtiffpic/jello.tif", Some(0xb03dbda9)),
+    ("tests/libtiffpic/jim___ah.tif", Some(0x81a27b7f)),
+    ("tests/libtiffpic/jim___cg.tif", Some(0xfd31747c)),
+    ("tests/libtiffpic/jim___dg.tif", Some(0x8c6a5e8f)),
+    ("tests/libtiffpic/jim___gg.tif", Some(0x8c6a5e8f)),
+    ("tests/libtiffpic/ladoga.tif", Some(0x9b118511)),
+    ("tests/libtiffpic/off_l16.tif", Some(0)), // LogLuv decoder output varies across platforms
+    ("tests/libtiffpic/off_luv24.tif", Some(0x2bee71a2)),
+    ("tests/libtiffpic/off_luv32.tif", Some(0)), // LogLuv decoder output varies across platforms
+    ("tests/libtiffpic/oxford.tif", Some(0x355d2e3e)),
+    ("tests/libtiffpic/pc260001.tif", Some(0xdb56b753)),
+    ("tests/libtiffpic/quad-jpeg.tif", Some(0xcba22475)),
+    ("tests/libtiffpic/quad-lzw.tif", Some(0x6055f9ee)), // old-style (LSB) LZW
+    ("tests/libtiffpic/quad-tile.tif", Some(0x6055f9ee)),
+    ("tests/libtiffpic/README", None),
+    ("tests/libtiffpic/smallliz.tif", Some(0)), // unsupported YCbCr chroma subsampling
+    ("tests/libtiffpic/strike.tif", Some(0x016b0f6a)),
+    ("tests/libtiffpic/text.tif", Some(0)), // unsupported compression
+    ("tests/libtiffpic/ycbcr-cat.tif", Some(0)), // unsupported YCbCr chroma subsampling
+    ("tests/libtiffpic/zackthecat.tif", Some(0)), // unsupported YCbCr chroma subsampling
+];
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.iter().any(|a| a == "--print-hashes") {
+        print_reference_hashes();
+        return;
+    }
+
+    let mut candidates: HashMap<_, _> = FILES.iter().copied().collect();
+    let mut trials = Vec::new();
+
+    for entry in WalkDir::new(REFERENCE_DIR) {
+        let entry = entry.unwrap();
+
+        if !entry.file_type().is_file() {
+            continue;
+        }
+
+        let Some(path) = entry.path().to_str() else {
+            continue;
+        };
+        let path = path.replace(std::path::MAIN_SEPARATOR, "/"); // always use UNIX path separators
+
+        // Mark this path as consumed in either case by removing it.
+        let Some(expected_hash) = candidates.remove(path.as_str()) else {
+            panic!("File {} not in reference list", path);
+        };
+
+        // None = non-image file, skip
+        let Some(expected_hash) = expected_hash else {
+            continue;
+        };
+
+        let path = path.to_string();
+        trials.push(Trial::test(
+            path.to_string(),
+            move || -> Result<(), Failed> { decode_and_verify(&path, expected_hash) },
+        ));
+    }
+
+    if !candidates.is_empty() {
+        for (path, _) in candidates {
+            eprintln!("Reference file {} not found in directory walk", path);
+        }
+
+        panic!("Some reference files were not found");
+    }
+
+    let args = Arguments::from_args();
+    libtest_mimic::run(&args, trials).exit();
+}
+
+/// Map DecodingResult variant to a TIFF Type for byte-order normalization.
+fn sample_type_of(result: &DecodingSampleBuffer) -> Type {
+    match result {
+        DecodingSampleBuffer::U8(_) => Type::BYTE,
+        DecodingSampleBuffer::I8(_) => Type::SBYTE,
+        DecodingSampleBuffer::U16(_) => Type::SHORT,
+        DecodingSampleBuffer::I16(_) => Type::SSHORT,
+        DecodingSampleBuffer::U32(_) => Type::LONG,
+        DecodingSampleBuffer::I32(_) => Type::SLONG,
+        DecodingSampleBuffer::F32(_) => Type::FLOAT,
+        DecodingSampleBuffer::U64(_) => Type::LONG8,
+        DecodingSampleBuffer::I64(_) => Type::SLONG8,
+        DecodingSampleBuffer::F64(_) => Type::DOUBLE,
+        DecodingSampleBuffer::F16(_) => Type::SHORT, // f16 is 2 bytes like SHORT
+    }
+}
+
+/// Hash color type into the hasher (discriminant + fields).
+fn hash_color_type(hasher: &mut crc32fast::Hasher, color_type: ColorType) {
+    match color_type {
+        ColorType::Gray(n) => hasher.update(&[0, n]),
+        ColorType::RGB(n) => hasher.update(&[1, n]),
+        ColorType::Palette(n) => hasher.update(&[2, n]),
+        ColorType::GrayA(n) => hasher.update(&[3, n]),
+        ColorType::RGBA(n) => hasher.update(&[4, n]),
+        ColorType::CMYK(n) => hasher.update(&[5, n]),
+        ColorType::CMYKA(n) => hasher.update(&[6, n]),
+        ColorType::YCbCr(n) => hasher.update(&[7, n]),
+        ColorType::Lab(n) => hasher.update(&[8, n]),
+        ColorType::Multiband {
+            bit_depth,
+            num_samples,
+        } => {
+            hasher.update(&[9, bit_depth]);
+            hasher.update(&num_samples.to_le_bytes());
+        }
+        other => panic!("compute_tiff_hash: unhandled ColorType {other:?}"),
+    }
+}
+
+/// Compute a CRC32 hash of the full decoded TIFF output using read_image_to_buffer.
+///
+/// Hashes per page: page index, dimensions, color type, TIFF sample type tag,
+/// and decoded sample data normalized to little-endian byte order.
+fn compute_hash(path: &std::path::Path) -> Result<u32, tiff::TiffError> {
+    let img_file = File::open(path)?;
+    let mut decoder = Decoder::open(img_file)?;
+    let mut hasher = crc32fast::Hasher::new();
+    let mut buffer = DecodingSampleBuffer::U8(vec![]);
+
+    let mut page = 0u32;
+    while decoder.more_images() {
+        decoder.next_image()?;
+        let (width, height) = decoder.dimensions()?;
+        let color_type = decoder.colortype()?;
+        let _layout = decoder.read_image_to_buffer(&mut buffer)?;
+
+        hasher.update(&page.to_le_bytes());
+        hasher.update(&width.to_le_bytes());
+        hasher.update(&height.to_le_bytes());
+        hash_color_type(&mut hasher, color_type);
+
+        let sample_type = sample_type_of(&buffer);
+        hasher.update(&sample_type.to_u16().to_le_bytes());
+
+        let mut buf = buffer.as_buffer(0);
+        let bytes = buf.as_bytes_mut();
+        ByteOrder::native().convert(sample_type, bytes, ByteOrder::LittleEndian);
+        hasher.update(bytes);
+
+        page += 1;
+    }
+
+    hasher.update(&page.to_le_bytes());
+    Ok(hasher.finalize())
+}
+
+fn decode_and_verify(path: &str, expected_hash: u32) -> Result<(), Failed> {
+    let full_path = path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(path);
+
+    if expected_hash == 0 {
+        // Smoke test: try to decode, tolerate errors (unsupported formats)
+        let _ = compute_hash(&full_path);
+        return Ok(());
+    }
+
+    let actual_hash = compute_hash(&full_path)
+        .map_err(|e| Failed::from(format!("Decoding failed for {path}: {e}")))?;
+
+    if actual_hash != expected_hash {
+        return Err(Failed::from(format!(
+            "{path}: expected hash 0x{expected_hash:08x} but got 0x{actual_hash:08x}"
+        )));
+    }
+
+    Ok(())
+}
+
+/// Print reference hashes for all decodable files (use --print-hashes).
+fn print_reference_hashes() {
+    for &(path, expected) in FILES {
+        if expected.is_none() {
+            continue;
+        }
+        let full_path = path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(path);
+        match compute_hash(&full_path) {
+            Ok(hash) => eprintln!("(\"{path}\", Some(0x{hash:08x})),"),
+            Err(e) => eprintln!("// {path}: FAILED: {e}"),
+        }
+    }
+}

tests/decode_planes.rs

@@ -0,0 +1,126 @@
+use tiff::decoder::{Decoder, DecodingSampleBuffer, Limits, 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::open(io).unwrap();
+
+    tif.next_image().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::open(io).unwrap();
+
+    tif.next_image().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);
+        }
+    }
+}
+
+#[test]
+fn read_planes_by_limits() {
+    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 limits = Limits::default();
+    let mut buffer = DecodingSampleBuffer::U8(vec![]);
+
+    // Make room for 1 plane.
+    let mut tif = Decoder::open(io).unwrap();
+    tif = tif.with_limits({
+        limits.decoding_buffer_size = 374 * 499;
+        limits.clone()
+    });
+
+    tif.next_image().unwrap();
+    tif.read_image_to_buffer(&mut buffer).unwrap();
+    assert_eq!(buffer.as_buffer(0).byte_len(), 374 * 499);
+
+    // Make room for 2 planes.
+    tif = tif.with_limits({
+        limits.decoding_buffer_size = 374 * 499 * 2;
+        limits.clone()
+    });
+
+    tif.read_image_to_buffer(&mut buffer).unwrap();
+    assert_eq!(buffer.as_buffer(0).byte_len(), 374 * 499);
+
+    // Make room for 3 planes.
+    tif = tif.with_limits({
+        limits.decoding_buffer_size = 374 * 499 * 3;
+        limits.clone()
+    });
+
+    tif.read_image_to_buffer(&mut buffer).unwrap();
+    assert_eq!(buffer.as_buffer(0).byte_len(), 374 * 499 * 3);
+
+    // Make room for 4 planes?
+    tif = tif.with_limits({
+        limits.decoding_buffer_size = 374 * 499 * 4;
+        limits.clone()
+    });
+
+    tif.read_image_to_buffer(&mut buffer).unwrap();
+    assert_eq!(buffer.as_buffer(0).byte_len(), 374 * 499 * 3);
+}

tests/encode_images.rs

@@ -1,9 +1,9 @@
 extern crate tiff;
 
-use tiff::decoder::{Decoder, DecodingResult};
-use tiff::encoder::{colortype, TiffEncoder, SRational};
-use tiff::ColorType;
+use tiff::decoder::{ifd, Decoder, DecodingSampleBuffer};
+use tiff::encoder::{colortype, Ifd, Ifd8, Predictor, SRational, TiffEncoder};
 use tiff::tags::Tag;
+use tiff::ColorType;
 
 use std::fs::File;
 use std::io::{Cursor, Seek, SeekFrom};
@@ -24,15 +24,70 @@ fn encode_decode() {
     {
         let mut tiff = TiffEncoder::new(&mut file).unwrap();
 
-        tiff.write_image::<colortype::RGB8>(100, 100, &image_data)
+        let mut image = tiff.new_image::<colortype::RGB8>(100, 100).unwrap();
+        image
+            .encoder()
+            .write_tag(Tag::Artist, "Image-tiff")
             .unwrap();
+        image.write_data(&image_data).unwrap();
     }
     {
         file.seek(SeekFrom::Start(0)).unwrap();
-        let mut decoder = Decoder::new(&mut file).unwrap();
+        let mut decoder = Decoder::open(&mut file).unwrap();
+        decoder.next_image().unwrap();
+
         assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
         assert_eq!(decoder.dimensions().unwrap(), (100, 100));
-        if let DecodingResult::U8(img_res) = decoder.read_image().unwrap() {
+
+        let mut all_tags = decoder
+            .current_ifd()
+            .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.current_ifd().get_tag(Tag::Artist).unwrap(),
+            ifd::Value::Ascii("Image-tiff".into())
+        );
+
+        let mut buffer = tiff::decoder::DecodingSampleBuffer::U8(vec![]);
+        let _layout = decoder.read_image_to_buffer(&mut buffer).unwrap();
+        if let tiff::decoder::DecodingSampleBuffer::U8(img_res) = buffer {
             assert_eq!(image_data, img_res);
         } else {
             panic!("Wrong data type");
@@ -40,6 +95,141 @@ fn encode_decode() {
     }
 }
 
+#[test]
+fn encode_decode_big() {
+    let mut image_data = Vec::new();
+    for x in 0..100 {
+        for y in 0..100u8 {
+            let val = x + y;
+            image_data.push(val);
+            image_data.push(val);
+            image_data.push(val);
+        }
+    }
+    let mut file = Cursor::new(Vec::new());
+    {
+        let mut tiff = TiffEncoder::new_big(&mut file).unwrap();
+
+        let mut image = tiff.new_image::<colortype::RGB8>(100, 100).unwrap();
+        image
+            .encoder()
+            .write_tag(Tag::Artist, "Image-tiff")
+            .unwrap();
+        image.write_data(&image_data).unwrap();
+    }
+    {
+        file.seek(SeekFrom::Start(0)).unwrap();
+        let mut decoder = Decoder::open(&mut file).unwrap();
+        decoder.next_image().unwrap();
+
+        assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
+        assert_eq!(decoder.dimensions().unwrap(), (100, 100));
+
+        let mut all_tags = decoder
+            .current_ifd()
+            .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.current_ifd().get_tag(Tag::Artist).unwrap(),
+            ifd::Value::Ascii("Image-tiff".into())
+        );
+        let mut buffer = tiff::decoder::DecodingSampleBuffer::U8(vec![]);
+        let _layout = decoder.read_image_to_buffer(&mut buffer).unwrap();
+        if let DecodingSampleBuffer::U8(img_res) = buffer {
+            assert_eq!(image_data, img_res);
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+#[test]
+fn test_encode_ifd() {
+    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 encoder = image_encoder.encoder();
+
+        // Use the "reusable" tags section as per the TIFF6 spec
+        encoder.write_tag(Tag::Unknown(65000), Ifd(42u32)).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65001), &[Ifd(100u32)][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65002), &[Ifd(1u32), Ifd(2u32), Ifd(3u32)][..])
+            .unwrap();
+
+        encoder.write_tag(Tag::Unknown(65010), Ifd8(43u64)).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65011), &[Ifd8(100u64)][..])
+            .unwrap();
+        encoder
+            .write_tag(
+                Tag::Unknown(65012),
+                &[Ifd8(1u64), Ifd8(2u64), Ifd8(3u64)][..],
+            )
+            .unwrap();
+    }
+
+    // Rewind the cursor for reading
+    data.set_position(0);
+
+    {
+        let mut decoder = Decoder::open(&mut data).unwrap();
+        decoder.next_image().unwrap();
+
+        assert_eq!(decoder.assert_tag_u32(65000), 42);
+        assert_eq!(decoder.assert_tag_u32_vec(65000), [42]);
+        assert_eq!(decoder.assert_tag_u32_vec(65001), [100]);
+        assert_eq!(decoder.assert_tag_u32_vec(65002), [1, 2, 3]);
+
+        assert_eq!(decoder.assert_tag_u64(65010), 43);
+        assert_eq!(decoder.assert_tag_u64_vec(65010), [43]);
+        assert_eq!(decoder.assert_tag_u64_vec(65011), [100]);
+        assert_eq!(decoder.assert_tag_u64_vec(65012), [1, 2, 3]);
+    }
+}
+
 #[test]
 /// Test that attempting to encode when the input buffer is undersized returns
 /// an error rather than panicking.
@@ -58,14 +248,23 @@ const TEST_IMAGE_DIR: &str = "./tests/images/";
 
 macro_rules! test_roundtrip {
     ($name:ident, $buffer:ident, $buffer_ty:ty) => {
-        fn $name<C: colortype::ColorType<Inner=$buffer_ty>>(file: &str, expected_type: ColorType) {
+        #[track_caller]
+        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");
+            let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
+            decoder.next_image().unwrap();
+
             assert_eq!(decoder.colortype().unwrap(), expected_type);
 
-            let image_data = match decoder.read_image().unwrap() {
-                DecodingResult::$buffer(res) => res,
+            let mut buffer = tiff::decoder::DecodingSampleBuffer::U8(vec![]);
+            decoder.read_image_to_buffer(&mut buffer).unwrap();
+
+            let image_data = match buffer {
+                DecodingSampleBuffer::$buffer(res) => res,
                 _ => panic!("Wrong data type"),
             };
 
@@ -74,14 +273,16 @@ macro_rules! test_roundtrip {
                 let mut tiff = TiffEncoder::new(&mut file).unwrap();
 
                 let (width, height) = decoder.dimensions().unwrap();
-                tiff.write_image::<C>(width, height, &image_data)
-                    .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().unwrap() {
-                    assert_eq!(image_data, img_res);
+                let mut buffer = tiff::decoder::DecodingSampleBuffer::U8(vec![]);
+                let mut decoder = Decoder::open(&mut file).unwrap();
+                decoder.next_image().unwrap();
+                decoder.read_image_to_buffer(&mut buffer).unwrap();
+                if let DecodingSampleBuffer::$buffer(img_res) = buffer {
+                    assert_eq!(*image_data, img_res);
                 } else {
                     panic!("Wrong data type");
                 }
@@ -91,15 +292,24 @@ 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);
+test_roundtrip!(test_f64_roundtrip, F64, f64);
 
 #[test]
 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));
@@ -110,11 +320,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));
@@ -145,6 +365,239 @@ fn test_rgb_u64_roundtrip() {
     test_u64_roundtrip::<colortype::RGB64>("gradient-3c-64b.tiff", ColorType::RGB(64));
 }
 
+#[test]
+fn test_gray_f32_roundtrip() {
+    test_f32_roundtrip::<colortype::Gray32Float>("gradient-1c-32b-float.tiff", ColorType::Gray(32));
+}
+
+#[test]
+fn test_rgb_f32_roundtrip() {
+    test_f32_roundtrip::<colortype::RGB32Float>("gradient-3c-32b-float.tiff", ColorType::RGB(32));
+}
+
+#[test]
+fn test_cmyk_f32_roundtrip() {
+    test_f32_roundtrip::<colortype::CMYK32Float>("cmyk-3c-32b-float.tiff", ColorType::CMYK(32));
+}
+
+#[test]
+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));
+}
+
+/// Test that encoding with the floating-point predictor works correctly
+/// and can be decoded back to the original data.
+#[test]
+fn test_gray_f32_floating_point_predictor() {
+    // Generate test data: a gradient of f32 values
+    let width = 32u32;
+    let height = 32u32;
+    let mut image_data: Vec<f32> = Vec::with_capacity((width * height) as usize);
+    for y in 0..height {
+        for x in 0..width {
+            // Create a gradient pattern
+            image_data.push((x as f32 + y as f32 * 0.1) / 100.0);
+        }
+    }
+
+    let mut file = Cursor::new(Vec::new());
+    {
+        let mut tiff = TiffEncoder::new(&mut file)
+            .unwrap()
+            .with_predictor(Predictor::FloatingPoint);
+        tiff.write_image::<colortype::Gray32Float>(width, height, &image_data)
+            .unwrap();
+    }
+
+    file.seek(SeekFrom::Start(0)).unwrap();
+    {
+        let mut decoder = Decoder::open(&mut file).unwrap();
+        decoder.next_image().unwrap();
+        assert_eq!(decoder.colortype().unwrap(), ColorType::Gray(32));
+
+        let mut buffer = DecodingSampleBuffer::F32(vec![]);
+        decoder.read_image_to_buffer(&mut buffer).unwrap();
+        if let DecodingSampleBuffer::F32(img_res) = buffer {
+            assert_eq!(image_data.len(), img_res.len());
+            for (orig, decoded) in image_data.iter().zip(img_res.iter()) {
+                assert_eq!(
+                    *orig, *decoded,
+                    "Mismatch at value: orig={}, decoded={}",
+                    orig, decoded
+                );
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+/// Test floating-point predictor with RGB f32 data
+#[test]
+fn test_rgb_f32_floating_point_predictor() {
+    let width = 16u32;
+    let height = 16u32;
+    let mut image_data: Vec<f32> = Vec::with_capacity((width * height * 3) as usize);
+    for y in 0..height {
+        for x in 0..width {
+            // RGB pattern
+            image_data.push(x as f32 / width as f32); // R
+            image_data.push(y as f32 / height as f32); // G
+            image_data.push((x + y) as f32 / (width + height) as f32); // B
+        }
+    }
+
+    let mut file = Cursor::new(Vec::new());
+    {
+        let mut tiff = TiffEncoder::new(&mut file)
+            .unwrap()
+            .with_predictor(Predictor::FloatingPoint);
+        tiff.write_image::<colortype::RGB32Float>(width, height, &image_data)
+            .unwrap();
+    }
+
+    file.seek(SeekFrom::Start(0)).unwrap();
+    {
+        let mut decoder = Decoder::open(&mut file).unwrap();
+        decoder.next_image().unwrap();
+        assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(32));
+
+        let mut buffer = DecodingSampleBuffer::F32(vec![]);
+        decoder.read_image_to_buffer(&mut buffer).unwrap();
+        if let DecodingSampleBuffer::F32(img_res) = buffer {
+            assert_eq!(image_data.len(), img_res.len());
+            for (i, (orig, decoded)) in image_data.iter().zip(img_res.iter()).enumerate() {
+                assert_eq!(
+                    *orig, *decoded,
+                    "Mismatch at index {}: orig={}, decoded={}",
+                    i, orig, decoded
+                );
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+/// Test floating-point predictor with f64 data
+#[test]
+fn test_gray_f64_floating_point_predictor() {
+    let width = 16u32;
+    let height = 16u32;
+    let mut image_data: Vec<f64> = Vec::with_capacity((width * height) as usize);
+    for y in 0..height {
+        for x in 0..width {
+            image_data.push((x as f64 + y as f64 * 0.1) / 100.0);
+        }
+    }
+
+    let mut file = Cursor::new(Vec::new());
+    {
+        let mut tiff = TiffEncoder::new(&mut file)
+            .unwrap()
+            .with_predictor(Predictor::FloatingPoint);
+        tiff.write_image::<colortype::Gray64Float>(width, height, &image_data)
+            .unwrap();
+    }
+
+    file.seek(SeekFrom::Start(0)).unwrap();
+    {
+        let mut decoder = Decoder::open(&mut file).unwrap();
+        decoder.next_image().unwrap();
+        assert_eq!(decoder.colortype().unwrap(), ColorType::Gray(64));
+
+        let mut buffer = DecodingSampleBuffer::F64(vec![]);
+        decoder.read_image_to_buffer(&mut buffer).unwrap();
+        if let DecodingSampleBuffer::F64(img_res) = buffer {
+            assert_eq!(image_data.len(), img_res.len());
+            for (orig, decoded) in image_data.iter().zip(img_res.iter()) {
+                assert_eq!(
+                    *orig, *decoded,
+                    "Mismatch: orig={}, decoded={}",
+                    orig, decoded
+                );
+            }
+        } else {
+            panic!("Wrong data type");
+        }
+    }
+}
+
+trait AssertDecode {
+    fn assert_tag_u32(&mut self, tag: u16) -> u32;
+    fn assert_tag_u32_vec(&mut self, tag: u16) -> Vec<u32>;
+    fn assert_tag_i32(&mut self, tag: u16) -> i32;
+    fn assert_tag_i32_vec(&mut self, tag: u16) -> Vec<i32>;
+    fn assert_tag_u64(&mut self, tag: u16) -> u64;
+    fn assert_tag_u64_vec(&mut self, tag: u16) -> Vec<u64>;
+    fn assert_tag_i64(&mut self, tag: u16) -> i64;
+    fn assert_tag_i64_vec(&mut self, tag: u16) -> Vec<i64>;
+}
+
+impl<R: std::io::Read + std::io::Seek> AssertDecode for Decoder<R> {
+    fn assert_tag_u32(&mut self, tag: u16) -> u32 {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_u32()
+            .unwrap()
+    }
+    fn assert_tag_u32_vec(&mut self, tag: u16) -> Vec<u32> {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_u32_vec()
+            .unwrap()
+    }
+    fn assert_tag_i32(&mut self, tag: u16) -> i32 {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_i32()
+            .unwrap()
+    }
+    fn assert_tag_i32_vec(&mut self, tag: u16) -> Vec<i32> {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_i32_vec()
+            .unwrap()
+    }
+    fn assert_tag_u64(&mut self, tag: u16) -> u64 {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_u64()
+            .unwrap()
+    }
+    fn assert_tag_u64_vec(&mut self, tag: u16) -> Vec<u64> {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_u64_vec()
+            .unwrap()
+    }
+    fn assert_tag_i64(&mut self, tag: u16) -> i64 {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_i64()
+            .unwrap()
+    }
+    fn assert_tag_i64_vec(&mut self, tag: u16) -> Vec<i64> {
+        self.current_ifd()
+            .get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_i64_vec()
+            .unwrap()
+    }
+}
+
 #[test]
 fn test_multiple_byte() {
     let mut data = Cursor::new(Vec::new());
@@ -152,24 +605,34 @@ 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();
-        encoder.write_tag(Tag::Unknown(65001), &[1_u8, 2][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65002), &[1_u8, 2, 3][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65003), &[1_u8, 2, 3, 4][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65004), &[1_u8, 2, 3, 4, 5][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65001), &[1_u8, 2][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65002), &[1_u8, 2, 3][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65003), &[1_u8, 2, 3, 4][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65004), &[1_u8, 2, 3, 4, 5][..])
+            .unwrap();
     }
 
     data.set_position(0);
     {
-        let mut decoder = Decoder::new(&mut data).unwrap();
+        let mut decoder = Decoder::open(&mut data).unwrap();
+        decoder.next_image().unwrap();
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_u32_vec().unwrap(), [1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_u32_vec().unwrap(), [1, 2]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_u32_vec().unwrap(), [1, 2, 3]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_u32_vec().unwrap(), [1, 2, 3, 4]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_u32_vec().unwrap(), [1, 2, 3, 4, 5]);
+        assert_eq!(decoder.assert_tag_u32_vec(65000), [1]);
+        assert_eq!(decoder.assert_tag_u32_vec(65001), [1, 2]);
+        assert_eq!(decoder.assert_tag_u32_vec(65002), [1, 2, 3]);
+        assert_eq!(decoder.assert_tag_u32_vec(65003), [1, 2, 3, 4]);
+        assert_eq!(decoder.assert_tag_u32_vec(65004), [1, 2, 3, 4, 5]);
     }
 }
 
@@ -177,56 +640,98 @@ fn test_multiple_byte() {
 /// Test writing signed tags from TIFF 6.0
 fn test_signed() {
     let mut data = Cursor::new(Vec::new());
+    fn make_srational(i: i32) -> SRational {
+        SRational { n: i, d: 100 }
+    }
 
     {
         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
         encoder.write_tag(Tag::Unknown(65000), -1_i8).unwrap();
-        encoder.write_tag(Tag::Unknown(65001), &[-1_i8][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65002), &[-1_i8, 2][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65003), &[-1_i8, 2, -3][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65004), &[-1_i8, 2, -3, 4][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65005), &[-1_i8, 2, -3, 4, -5][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65001), &[-1_i8][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65002), &[-1_i8, 2][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65003), &[-1_i8, 2, -3][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65004), &[-1_i8, 2, -3, 4][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65005), &[-1_i8, 2, -3, 4, -5][..])
+            .unwrap();
 
         encoder.write_tag(Tag::Unknown(65010), -1_i16).unwrap();
         encoder.write_tag(Tag::Unknown(65011), -1_i16).unwrap();
-        encoder.write_tag(Tag::Unknown(65012), &[-1_i16, 2][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65013), &[-1_i16, 2, -3][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65012), &[-1_i16, 2][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65013), &[-1_i16, 2, -3][..])
+            .unwrap();
 
         encoder.write_tag(Tag::Unknown(65020), -1_i32).unwrap();
-        encoder.write_tag(Tag::Unknown(65021), &[-1_i32][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65022), &[-1_i32, 2][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65021), &[-1_i32][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65022), &[-1_i32, 2][..])
+            .unwrap();
 
-        encoder.write_tag(Tag::Unknown(65030), SRational { n: -1, d: 100 }).unwrap();
-        encoder.write_tag(Tag::Unknown(65031), &[SRational { n: -1, d: 100 }, SRational { n: 2, d: 100 }][..]).unwrap();
+        encoder.write_tag(Tag::Unknown(65030), -1_i64).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65031), &[-1_i64][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65032), &[-1_i64, 2][..])
+            .unwrap();
+
+        encoder
+            .write_tag(Tag::Unknown(65040), make_srational(-1))
+            .unwrap();
+        encoder
+            .write_tag(
+                Tag::Unknown(65041),
+                &[make_srational(-1), make_srational(2)][..],
+            )
+            .unwrap();
     }
 
     //Rewind the cursor for reading
     data.set_position(0);
     {
-        let mut decoder = Decoder::new(&mut data).unwrap();
+        let mut decoder = Decoder::open(&mut data).unwrap();
+        decoder.next_image().unwrap();
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_i32().unwrap(), -1, );
-        assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_i32_vec().unwrap(), [-1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_i32_vec().unwrap(), [-1, 2]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3, 4]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65005)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3, 4, -5], );
+        assert_eq!(decoder.assert_tag_i32(65000), -1);
+        assert_eq!(decoder.assert_tag_i32_vec(65001), [-1]);
+        assert_eq!(decoder.assert_tag_i32_vec(65002), [-1, 2]);
+        assert_eq!(decoder.assert_tag_i32_vec(65003), [-1, 2, -3]);
+        assert_eq!(decoder.assert_tag_i32_vec(65004), [-1, 2, -3, 4]);
+        assert_eq!(decoder.assert_tag_i32_vec(65005), [-1, 2, -3, 4, -5],);
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65010)).unwrap().into_i32().unwrap(), -1);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65011)).unwrap().into_i32_vec().unwrap(), [-1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65012)).unwrap().into_i32_vec().unwrap(), [-1, 2]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65013)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3]);
+        assert_eq!(decoder.assert_tag_i32(65010), -1);
+        assert_eq!(decoder.assert_tag_i32_vec(65011), [-1]);
+        assert_eq!(decoder.assert_tag_i32_vec(65012), [-1, 2]);
+        assert_eq!(decoder.assert_tag_i32_vec(65013), [-1, 2, -3]);
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65020)).unwrap().into_i32().unwrap(), -1);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65021)).unwrap().into_i32_vec().unwrap(), [-1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65022)).unwrap().into_i32_vec().unwrap(), [-1, 2]);
+        assert_eq!(decoder.assert_tag_i32(65020), -1);
+        assert_eq!(decoder.assert_tag_i32_vec(65021), [-1]);
+        assert_eq!(decoder.assert_tag_i32_vec(65022), [-1, 2]);
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65030)).unwrap().into_i32_vec().unwrap(), [-1, 100]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65031)).unwrap().into_i32_vec().unwrap(), [-1_i32, 100, 2, 100]);
+        assert_eq!(decoder.assert_tag_i64(65030), -1);
+        assert_eq!(decoder.assert_tag_i64_vec(65031), [-1]);
+        assert_eq!(decoder.assert_tag_i64_vec(65032), [-1, 2]);
+
+        assert_eq!(decoder.assert_tag_i32_vec(65040), [-1, 100]);
+        assert_eq!(decoder.assert_tag_i32_vec(65041), [-1_i32, 100, 2, 100]);
     }
 }
 
@@ -241,22 +746,129 @@ fn test_multipage_image() {
 
         // write first grayscale image (2x2 16-bit)
         let img1: Vec<u16> = [1, 2, 3, 4].to_vec();
-        img_encoder.write_image::<colortype::Gray16>(2, 2, &img1[..]).unwrap();
+        img_encoder
+            .write_image::<colortype::Gray16>(2, 2, &img1[..])
+            .unwrap();
         // write second grayscale image (3x3 8-bit)
         let img2: Vec<u8> = [9, 8, 7, 6, 5, 4, 3, 2, 1].to_vec();
-        img_encoder.write_image::<colortype::Gray8>(3, 3, &img2[..]).unwrap();
+        img_encoder
+            .write_image::<colortype::Gray8>(3, 3, &img2[..])
+            .unwrap();
     }
 
     // seek to the beginning of the file, so that it can be decoded
     img_file.seek(SeekFrom::Start(0)).unwrap();
 
     {
-        let mut img_decoder = Decoder::new(&mut img_file).unwrap();
+        let mut decoder = Decoder::open(&mut img_file).unwrap();
+        decoder.next_image().unwrap();
 
         // check the dimensions of the image in the first page
-        assert_eq!(img_decoder.dimensions().unwrap(), (2, 2));
-        img_decoder.next_image().unwrap();
+        assert_eq!(decoder.dimensions().unwrap(), (2, 2));
+        decoder.next_image().unwrap();
         // check the dimensions of the image in the second page
-        assert_eq!(img_decoder.dimensions().unwrap(), (3, 3));
+        assert_eq!(decoder.dimensions().unwrap(), (3, 3));
+    }
+}
+
+#[test]
+/// verify rows per strip setting
+fn test_rows_per_strip() {
+    let mut file = Cursor::new(Vec::new());
+    {
+        let mut img_encoder = TiffEncoder::new(&mut file).unwrap();
+
+        let mut image = img_encoder.new_image::<colortype::Gray8>(100, 100).unwrap();
+        assert_eq!(image.next_strip_sample_count(), 100 * 100);
+        image.rows_per_strip(2).unwrap();
+        assert_eq!(image.next_strip_sample_count(), 2 * 100);
+
+        let img2: Vec<u8> = vec![0; 2 * 100];
+        image.write_strip(&img2[..]).unwrap();
+        assert!(image.rows_per_strip(5).is_err());
+        for i in 1..50 {
+            let img2: Vec<u8> = vec![i; 2 * 100];
+            image.write_strip(&img2[..]).unwrap();
+        }
+        assert!(image.write_strip(&img2[..]).is_err());
+        image.finish().unwrap();
+    }
+
+    file.seek(SeekFrom::Start(0)).unwrap();
+    {
+        let mut decoder = Decoder::open(&mut file).unwrap();
+        decoder.next_image().unwrap();
+        assert_eq!(
+            decoder
+                .current_ifd()
+                .get_tag_u64(Tag::RowsPerStrip)
+                .unwrap(),
+            2
+        );
+        assert_eq!(decoder.strip_count().unwrap(), 50);
+
+        for i in 0..50 {
+            let img2 = [i; 2 * 100];
+            match decoder.read_chunk(i as u32).unwrap() {
+                DecodingSampleBuffer::U8(data) => assert_eq!(&img2[..], &data[..]),
+                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::open(&mut data).unwrap();
+
+    {
+        decoder.next_image().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
+            .current_ifd()
+            .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, DecodingSampleBuffer},
+    encoder::{
+        colortype::{self, ColorType},
+        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::open(data).unwrap();
+        decoder.next_image().unwrap();
+
+        // Check the RGB image
+        assert_eq!(
+            match decoder.read_image() {
+                Ok(DecodingSampleBuffer::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(DecodingSampleBuffer::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(1));
+    encode_decode_with_compression(Compression::Deflate(6));
+    encode_decode_with_compression(Compression::Deflate(9));
+}
+
+#[test]
+fn encode_decode_with_packbits() {
+    encode_decode_with_compression(Compression::Packbits);
+}

tests/fuzz_tests.rs

@@ -13,7 +13,8 @@ fn test_directory<F: Fn(File) -> bool>(path: &str, f: F) {
 }
 
 fn decode_tiff(file: File) -> TiffResult<()> {
-    let mut decoder = Decoder::new(file)?;
+    let mut decoder = Decoder::open(file)?;
+    decoder.next_image()?;
     decoder.read_image()?;
     Ok(())
 }