Add checkpoint, storing an IFD offset of a tiff

.github/workflows/rust.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: ["1.48", stable, beta, nightly]
+        rust: ["1.34.2", stable, beta, nightly]
         command: [build, test]
     steps:
     - uses: actions/checkout@v2
@@ -20,7 +20,7 @@ jobs:
     - name: test
       run: >
         cargo test --tests --benches --no-default-features --features "$FEATURES"
-      if: ${{ matrix.rust != '1.48' }}
+      if: ${{ matrix.rust != '1.34.2' }}
       env:
         FEATURES: ${{ matrix.features }}
   rustfmt:

CHANGES.md

@@ -1,97 +1,3 @@
-# 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:

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tiff"
-version = "0.7.2"
+version = "0.6.0"
 authors = [
     "ccgn",
     "bvssvni <bvssvni@gmail.com>",
@@ -15,12 +15,14 @@ license = "MIT"
 description = "TIFF decoding and encoding library in pure Rust"
 repository = "https://github.com/image-rs/image-tiff"
 exclude = ["tests/images/*", "tests/fuzz_images/*"]
-edition = "2018"
 
 [dependencies]
 weezl = "0.1.0"
-jpeg = { package = "jpeg-decoder", version = "0.2.4", default-features = false }
-flate2 = "1.0.20"
+jpeg = { package = "jpeg-decoder", version = "0.1.17", default-features = false }
+
+[dependencies.miniz_oxide]
+version = "0.4.1"
+features = ["no_extern_crate_alloc"]
 
 [dev-dependencies]
 criterion = "0.3.1"

README.md

@@ -1,5 +1,5 @@
 # image-tiff
-[![Build Status](https://github.com/image-rs/image-tiff/workflows/Rust%20CI/badge.svg)](https://github.com/image-rs/image-tiff/actions)
+[![Build Status](https://travis-ci.org/image-rs/image-tiff.svg?branch=master)](https://travis-ci.org/image-rs/image-tiff)
 [![Documentation](https://docs.rs/tiff/badge.svg)](https://docs.rs/tiff)
 [![Further crate info](https://img.shields.io/crates/v/tiff.svg)](https://crates.io/crates/tiff)
 
@@ -16,25 +16,25 @@ TIFF decoding and encoding library in pure Rust
 ### Formats
 This table lists photometric interpretations and sample formats which are supported for encoding and decoding. The entries are `ColorType` variants for which sample bit depths are supported. Only samples where all bit depths are equal are currently supported. For example, `RGB(8)` means that the bit depth [8, 8, 8] is supported and will be interpreted as an 8 bit per channel RGB color type.
 
-| `PhotometricInterpretation` | UINT Format                             | IEEEFP Format             |
-| --------------------------- | --------------------------------------- | ------------------------- |
-| `WhiteIsZero`               | Gray(8\|16\|32\|64)                     | Gray(32\|64)              |
-| `BlackIsZero`               | Gray(8\|16\|32\|64)                     | Gray(32\|64)              |
-| `RGB`                       | RGB(8\|16\|32\|64), RGBA(8\|16\|32\|64) | RGB(32\|64), RGBA(32\|64) |
-| `RGBPalette`                |                                         |                           |
-| `Mask`                      |                                         |                           |
-| `CMYK`                      | CMYK(8\|16\|32\|64)                     | CMYK(32\|64)              |
-| `YCbCr`                     |                                         |                           |
-| `CIELab`                    |                                         |                           |
+| `PhotometricInterpretation` | UINT Format | IEEEFP Format |
+|-|-|-|
+| `WhiteIsZero` | Gray(8\|16\|32\|64) | Gray(32\|64) |
+| `BlackIsZero` | Gray(8\|16\|32\|64) | Gray(32\|64) |
+| `RGB` | RGB(8\|16\|32\|64), RGBA(8\|16\|32\|64) | RGB(32\|64), RGBA(32\|64) |
+| `RGBPalette` | | |
+| `Mask` | | |
+| `CMYK` | CMYK(8\|16\|32\|64) | CMYK(32\|64) |
+| `YCbCr` | | |
+| `CIELab` | | |
 
 ### Compressions
 
-|          | Decoding | Encoding |
-| -------- | -------- | -------- |
-| None     | ✓        | ✓        |
-| LZW      | ✓        | ✓        |
-| Deflate  | ✓        | ✓        |
-| PackBits | ✓        | ✓        |
+| | Decoding | Encoding |
+|-|-|-|
+| None | ✓ | ✓ |
+| LZW | ✓ | |
+| Deflate | ✓ | |
+| PackBits | ✓ | |
 
 
 ## Not yet supported
@@ -44,11 +44,3 @@ Formats and interpretations not listed above or with empty entries are unsupport
 - Baseline tags
   - `ExtraSamples`
 - Extension tags
-
-## 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_image -snone -- -timeout=5`.

benches/lzw.rs

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

fuzz/.gitignore

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

fuzz/Cargo.toml

@@ -1,25 +0,0 @@
-[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_image"
-path = "fuzz_targets/decode_image.rs"
-test = false
-doc = false

fuzz/fuzz_targets/decode_image.rs

@@ -1,31 +0,0 @@
-#![no_main]
-use libfuzzer_sys::fuzz_target;
-
-fuzz_target!(|data: &[u8]| {
-    let mut decoder = if let Ok(d) = tiff::decoder::Decoder::new(std::io::Cursor::new(data)) {
-        d
-    } else {
-        return;
-    };
-
-    let mut limits = tiff::decoder::Limits::default();
-    limits.decoding_buffer_size = 1_000_000;
-    limits.ifd_value_size = 1_000_000;
-    limits.intermediate_buffer_size = 1_000_000;
-
-    decoder = decoder.with_limits(limits);
-    
-    loop {
-        if let Err(_) = decoder.read_image() {
-            break;
-        }
-
-        if !decoder.more_images() {
-            break;
-        }
-
-        if let Err(_) = decoder.next_image() {
-            break;
-        }
-    }
-});

src/bytecast.rs

@@ -23,12 +23,11 @@ macro_rules! integral_slice_as_bytes{($int:ty, $const:ident $(,$mut:ident)*) =>
     })*
 }}
 
-integral_slice_as_bytes!(i8, i8_as_ne_bytes, i8_as_ne_mut_bytes);
+integral_slice_as_bytes!(i8, i8_as_ne_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!(i16, i16_as_ne_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!(i32, i32_as_ne_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!(f64, f64_as_ne_bytes, f64_as_ne_mut_bytes);

src/decoder/ifd.rs

@@ -4,22 +4,20 @@ use std::collections::HashMap;
 use std::convert::{TryFrom, TryInto};
 use std::io::{self, Read, Seek};
 use std::mem;
-use std::str;
 
 use super::stream::{ByteOrder, EndianReader, SmartReader};
-use crate::tags::{Tag, Type};
-use crate::{TiffError, TiffFormatError, TiffResult};
+use tags::{Tag, Type};
+use {TiffError, TiffFormatError, TiffResult, TiffUnsupportedError};
 
 use self::Value::{
-    Ascii, Byte, Double, Float, Ifd, IfdBig, List, Rational, RationalBig, SRational, SRationalBig,
-    Short, Signed, SignedBig, Unsigned, UnsignedBig,
+    Ascii, Byte, Double, Float, List, Rational, RationalBig, SRational, SRationalBig, Signed,
+    SignedBig, Unsigned, UnsignedBig,
 };
 
 #[allow(unused_qualifications)]
 #[derive(Debug, Clone, PartialEq)]
 pub enum Value {
     Byte(u8),
-    Short(u16),
     Signed(i32),
     SignedBig(i64),
     Unsigned(u32),
@@ -32,8 +30,6 @@ pub enum Value {
     SRational(i32, i32),
     SRationalBig(i64, i64),
     Ascii(String),
-    Ifd(u32),
-    IfdBig(u64),
     #[doc(hidden)] // Do not match against this.
     __NonExhaustive,
 }
@@ -46,24 +42,10 @@ impl Value {
         }
     }
 
-    pub fn into_u16(self) -> TiffResult<u16> {
-        match self {
-            Short(val) => Ok(val),
-            Unsigned(val) => Ok(u16::try_from(val)?),
-            UnsignedBig(val) => Ok(u16::try_from(val)?),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
     pub fn into_u32(self) -> TiffResult<u32> {
         match self {
-            Short(val) => Ok(val.into()),
             Unsigned(val) => Ok(val),
             UnsignedBig(val) => Ok(u32::try_from(val)?),
-            Ifd(val) => Ok(val),
-            IfdBig(val) => Ok(u32::try_from(val)?),
             val => Err(TiffError::FormatError(
                 TiffFormatError::UnsignedIntegerExpected(val),
             )),
@@ -82,11 +64,8 @@ impl Value {
 
     pub fn into_u64(self) -> TiffResult<u64> {
         match self {
-            Short(val) => Ok(val.into()),
             Unsigned(val) => Ok(val.into()),
             UnsignedBig(val) => Ok(val),
-            Ifd(val) => Ok(val.into()),
-            IfdBig(val) => Ok(val),
             val => Err(TiffError::FormatError(
                 TiffFormatError::UnsignedIntegerExpected(val),
             )),
@@ -121,15 +100,6 @@ impl Value {
         }
     }
 
-    pub fn into_string(self) -> TiffResult<String> {
-        match self {
-            Ascii(val) => Ok(val),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-
     pub fn into_u32_vec(self) -> TiffResult<Vec<u32>> {
         match self {
             List(vec) => {
@@ -145,8 +115,6 @@ impl Value {
             RationalBig(numerator, denominator) => {
                 Ok(vec![u32::try_from(numerator)?, u32::try_from(denominator)?])
             }
-            Ifd(val) => Ok(vec![val]),
-            IfdBig(val) => Ok(vec![u32::try_from(val)?]),
             Ascii(val) => Ok(val.chars().map(u32::from).collect()),
             val => Err(TiffError::FormatError(
                 TiffFormatError::UnsignedIntegerExpected(val),
@@ -171,22 +139,6 @@ impl Value {
         }
     }
 
-    pub fn into_u16_vec(self) -> TiffResult<Vec<u16>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    new_vec.push(v.into_u16()?)
-                }
-                Ok(new_vec)
-            }
-            Short(val) => Ok(vec![val]),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
     pub fn into_i32_vec(self) -> TiffResult<Vec<i32>> {
         match self {
             List(vec) => {
@@ -263,8 +215,6 @@ impl Value {
             UnsignedBig(val) => Ok(vec![val]),
             Rational(numerator, denominator) => Ok(vec![numerator.into(), denominator.into()]),
             RationalBig(numerator, denominator) => Ok(vec![numerator, denominator]),
-            Ifd(val) => Ok(vec![val.into()]),
-            IfdBig(val) => Ok(vec![val]),
             Ascii(val) => Ok(val.chars().map(u32::from).map(u64::from).collect()),
             val => Err(TiffError::FormatError(
                 TiffFormatError::UnsignedIntegerExpected(val),
@@ -341,278 +291,174 @@ impl Entry {
     pub fn val<R: Read + Seek>(
         &self,
         limits: &super::Limits,
-        bigtiff: bool,
-        reader: &mut SmartReader<R>,
+        decoder: &mut super::Decoder<R>,
     ) -> TiffResult<Value> {
-        // Case 1: there are no values so we can return immediately.
-        if self.count == 0 {
-            return Ok(List(Vec::new()));
-        }
-
-        let bo = reader.byte_order();
-
-        let tag_size = match self.type_ {
-            Type::BYTE | Type::SBYTE | Type::ASCII | Type::UNDEFINED => 1,
-            Type::SHORT | Type::SSHORT => 2,
-            Type::LONG | Type::SLONG | Type::FLOAT | Type::IFD => 4,
-            Type::LONG8
-            | Type::SLONG8
-            | Type::DOUBLE
-            | Type::RATIONAL
-            | Type::SRATIONAL
-            | Type::IFD8 => 8,
-            Type::__NonExhaustive => unreachable!(),
+        let bo = decoder.byte_order();
+        let bigtiff_value = if decoder.bigtiff {
+            match (self.type_, self.count) {
+                (Type::BYTE, 5) => Some(offset_to_bytes(5, self)?),
+                (Type::BYTE, 6) => Some(offset_to_bytes(6, self)?),
+                (Type::BYTE, 7) => Some(offset_to_bytes(7, self)?),
+                (Type::BYTE, 8) => Some(offset_to_bytes(8, self)?),
+                (Type::SBYTE, 5) => Some(offset_to_sbytes(5, self)?),
+                (Type::SBYTE, 6) => Some(offset_to_sbytes(6, self)?),
+                (Type::SBYTE, 7) => Some(offset_to_sbytes(7, self)?),
+                (Type::SBYTE, 8) => Some(offset_to_sbytes(8, self)?),
+                (Type::SHORT, 3) => {
+                    let mut r = self.r(bo);
+                    Some(List(vec![
+                        Unsigned(u32::from(r.read_u16()?)),
+                        Unsigned(u32::from(r.read_u16()?)),
+                        Unsigned(u32::from(r.read_u16()?)),
+                    ]))
+                }
+                (Type::SSHORT, 3) => {
+                    let mut r = self.r(bo);
+                    Some(List(vec![
+                        Signed(i32::from(r.read_i16()?)),
+                        Signed(i32::from(r.read_i16()?)),
+                        Signed(i32::from(r.read_i16()?)),
+                    ]))
+                }
+                (Type::SHORT, 4) => {
+                    let mut r = self.r(bo);
+                    Some(List(vec![
+                        Unsigned(u32::from(r.read_u16()?)),
+                        Unsigned(u32::from(r.read_u16()?)),
+                        Unsigned(u32::from(r.read_u16()?)),
+                        Unsigned(u32::from(r.read_u16()?)),
+                    ]))
+                }
+                (Type::SSHORT, 4) => {
+                    let mut r = self.r(bo);
+                    Some(List(vec![
+                        Signed(i32::from(r.read_i16()?)),
+                        Signed(i32::from(r.read_i16()?)),
+                        Signed(i32::from(r.read_i16()?)),
+                        Signed(i32::from(r.read_i16()?)),
+                    ]))
+                }
+                (Type::LONG, 2) => {
+                    let mut r = self.r(bo);
+                    Some(List(vec![Unsigned(r.read_u32()?), Unsigned(r.read_u32()?)]))
+                }
+                (Type::SLONG, 2) => {
+                    let mut r = self.r(bo);
+                    Some(List(vec![Signed(r.read_i32()?), Signed(r.read_i32()?)]))
+                }
+                (Type::RATIONAL, 1) => {
+                    let mut r = self.r(bo);
+                    let numerator = r.read_u32()?;
+                    let denominator = r.read_u32()?;
+                    Some(Rational(numerator, denominator))
+                }
+                (Type::SRATIONAL, 1) => {
+                    let mut r = self.r(bo);
+                    let numerator = r.read_i32()?;
+                    let denominator = r.read_i32()?;
+                    Some(SRational(numerator, denominator))
+                }
+                _ => None,
+            }
+        } else {
+            None
         };
 
-        let value_bytes = match self.count.checked_mul(tag_size) {
-            Some(n) => n,
-            None => {
-                return Err(TiffError::LimitsExceeded);
-            }
-        };
-
-        // Case 2: there is one value.
-        if self.count == 1 {
-            // 2a: the value is 5-8 bytes and we're in BigTiff mode.
-            if bigtiff && value_bytes > 4 && value_bytes <= 8 {
-                return Ok(match self.type_ {
-                    Type::LONG8 => UnsignedBig(self.r(bo).read_u64()?),
-                    Type::SLONG8 => SignedBig(self.r(bo).read_i64()?),
-                    Type::DOUBLE => Double(self.r(bo).read_f64()?),
-                    Type::RATIONAL => {
-                        let mut r = self.r(bo);
-                        Rational(r.read_u32()?, r.read_u32()?)
+        if let Some(v) = bigtiff_value {
+            Ok(v)
+        } else {
+            match (self.type_, self.count) {
+                // TODO check if this could give wrong results
+                // at a different endianess of file/computer.
+                (Type::BYTE, 1) => Ok(Unsigned(u32::from(self.offset[0]))),
+                (Type::BYTE, 2) => offset_to_bytes(2, self),
+                (Type::BYTE, 3) => offset_to_bytes(3, self),
+                (Type::BYTE, 4) => offset_to_bytes(4, self),
+                (Type::BYTE, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(UnsignedBig(u64::from(decoder.read_byte()?)))
+                }),
+                (Type::SBYTE, 1) => Ok(Signed(i32::from(self.offset[0] as i8))),
+                (Type::SBYTE, 2) => offset_to_sbytes(2, self),
+                (Type::SBYTE, 3) => offset_to_sbytes(3, self),
+                (Type::SBYTE, 4) => offset_to_sbytes(4, self),
+                (Type::SBYTE, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(SignedBig(i64::from(decoder.read_byte()? as i8)))
+                }),
+                (Type::SHORT, 1) => Ok(Unsigned(u32::from(self.r(bo).read_u16()?))),
+                (Type::SSHORT, 1) => Ok(Signed(i32::from(self.r(bo).read_i16()?))),
+                (Type::SHORT, 2) => {
+                    let mut r = self.r(bo);
+                    Ok(List(vec![
+                        Unsigned(u32::from(r.read_u16()?)),
+                        Unsigned(u32::from(r.read_u16()?)),
+                    ]))
+                }
+                (Type::SSHORT, 2) => {
+                    let mut r = self.r(bo);
+                    Ok(List(vec![
+                        Signed(i32::from(r.read_i16()?)),
+                        Signed(i32::from(r.read_i16()?)),
+                    ]))
+                }
+                (Type::SHORT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(UnsignedBig(u64::from(decoder.read_short()?)))
+                }),
+                (Type::SSHORT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(SignedBig(i64::from(decoder.read_sshort()?)))
+                }),
+                (Type::LONG, 1) => Ok(Unsigned(self.r(bo).read_u32()?)),
+                (Type::SLONG, 1) => Ok(Signed(self.r(bo).read_i32()?)),
+                (Type::LONG, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(Unsigned(decoder.read_long()?))
+                }),
+                (Type::SLONG, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(Signed(decoder.read_slong()?))
+                }),
+                (Type::FLOAT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(Float(decoder.read_float()?))
+                }),
+                (Type::DOUBLE, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(Double(decoder.read_double()?))
+                }),
+                (Type::RATIONAL, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(Rational(decoder.read_long()?, decoder.read_long()?))
+                }),
+                (Type::SRATIONAL, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(SRational(decoder.read_slong()?, decoder.read_slong()?))
+                }),
+                (Type::LONG8, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(UnsignedBig(decoder.read_long8()?))
+                }),
+                (Type::ASCII, n) => {
+                    let n = usize::try_from(n)?;
+                    if n > limits.decoding_buffer_size {
+                        return Err(TiffError::LimitsExceeded);
                     }
-                    Type::SRATIONAL => {
-                        let mut r = self.r(bo);
-                        SRational(r.read_i32()?, r.read_i32()?)
-                    }
-                    Type::IFD8 => IfdBig(self.r(bo).read_u64()?),
-                    Type::BYTE
-                    | Type::SBYTE
-                    | Type::ASCII
-                    | Type::UNDEFINED
-                    | Type::SHORT
-                    | Type::SSHORT
-                    | Type::LONG
-                    | Type::SLONG
-                    | Type::FLOAT
-                    | Type::IFD => unreachable!(),
-                    Type::__NonExhaustive => unreachable!(),
-                });
-            }
 
-            // 2b: the value is at most 4 bytes or doesn't fit in the offset field.
-            return Ok(match self.type_ {
-                Type::BYTE => Unsigned(u32::from(self.offset[0])),
-                Type::SBYTE => Signed(i32::from(self.offset[0] as i8)),
-                Type::UNDEFINED => Byte(self.offset[0]),
-                Type::SHORT => Unsigned(u32::from(self.r(bo).read_u16()?)),
-                Type::SSHORT => Signed(i32::from(self.r(bo).read_i16()?)),
-                Type::LONG => Unsigned(self.r(bo).read_u32()?),
-                Type::SLONG => Signed(self.r(bo).read_i32()?),
-                Type::FLOAT => Float(self.r(bo).read_f32()?),
-                Type::ASCII => {
-                    if self.offset[0] == 0 {
-                        Ascii("".to_string())
-                    } else {
-                        return Err(TiffError::FormatError(TiffFormatError::InvalidTag));
-                    }
-                }
-                Type::LONG8 => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    UnsignedBig(reader.read_u64()?)
-                }
-                Type::SLONG8 => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    SignedBig(reader.read_i64()?)
-                }
-                Type::DOUBLE => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    Double(reader.read_f64()?)
-                }
-                Type::RATIONAL => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    Rational(reader.read_u32()?, reader.read_u32()?)
-                }
-                Type::SRATIONAL => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    SRational(reader.read_i32()?, reader.read_i32()?)
-                }
-                Type::IFD => Ifd(self.r(bo).read_u32()?),
-                Type::IFD8 => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    IfdBig(reader.read_u64()?)
-                }
-                Type::__NonExhaustive => unreachable!(),
-            });
-        }
-
-        // Case 3: There is more than one value, but it fits in the offset field.
-        if value_bytes <= 4 || bigtiff && value_bytes <= 8 {
-            match self.type_ {
-                Type::BYTE => return Ok(offset_to_bytes(self.count as usize, self)?),
-                Type::SBYTE => return Ok(offset_to_sbytes(self.count as usize, self)?),
-                Type::ASCII => {
-                    let mut buf = vec![0; self.count as usize];
-                    self.r(bo).read_exact(&mut buf)?;
-                    if buf.is_ascii() && buf.ends_with(&[0]) {
-                        let v = str::from_utf8(&buf)?;
+                    if (n <= 4 && !decoder.bigtiff) || (n <= 8 && decoder.bigtiff) {
+                        let mut buf = vec![0; n];
+                        self.r(bo).read_exact(&mut buf)?;
+                        let v = String::from_utf8(buf)?;
                         let v = v.trim_matches(char::from(0));
-                        return Ok(Ascii(v.into()));
+                        Ok(Ascii(v.into()))
                     } else {
-                        return Err(TiffError::FormatError(TiffFormatError::InvalidTag));
+                        if decoder.bigtiff {
+                            decoder.goto_offset_u64(self.r(bo).read_u64()?)?
+                        } else {
+                            decoder.goto_offset(self.r(bo).read_u32()?)?
+                        }
+                        let string = decoder.read_string(n)?;
+                        Ok(Ascii(string))
                     }
                 }
-                Type::UNDEFINED => {
-                    return Ok(List(
-                        self.offset[0..self.count as usize]
-                            .iter()
-                            .map(|&b| Byte(b))
-                            .collect(),
-                    ));
-                }
-                Type::SHORT => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Short(r.read_u16()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::SSHORT => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Signed(i32::from(r.read_i16()?)));
-                    }
-                    return Ok(List(v));
-                }
-                Type::LONG => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Unsigned(r.read_u32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::SLONG => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Signed(r.read_i32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::FLOAT => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Float(r.read_f32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::IFD => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Ifd(r.read_u32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::LONG8
-                | Type::SLONG8
-                | Type::RATIONAL
-                | Type::SRATIONAL
-                | Type::DOUBLE
-                | Type::IFD8 => {
-                    unreachable!()
-                }
-                Type::__NonExhaustive => unreachable!(),
+                (Type::UNDEFINED, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(Byte(u8::from(decoder.read_byte()?)))
+                }),
+                _ => Err(TiffError::UnsupportedError(
+                    TiffUnsupportedError::UnsupportedDataType,
+                )),
             }
         }
-
-        // Case 4: there is more than one value, and it doesn't fit in the offset field.
-        match self.type_ {
-            // TODO check if this could give wrong results
-            // at a different endianess of file/computer.
-            Type::BYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                let mut buf = [0; 1];
-                reader.read_exact(&mut buf)?;
-                Ok(UnsignedBig(u64::from(buf[0])))
-            }),
-            Type::SBYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(SignedBig(i64::from(reader.read_i8()? as i8)))
-            }),
-            Type::SHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(UnsignedBig(u64::from(reader.read_u16()?)))
-            }),
-            Type::SSHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(SignedBig(i64::from(reader.read_i16()?)))
-            }),
-            Type::LONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Unsigned(reader.read_u32()?))
-            }),
-            Type::SLONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Signed(reader.read_i32()?))
-            }),
-            Type::FLOAT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Float(reader.read_f32()?))
-            }),
-            Type::DOUBLE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Double(reader.read_f64()?))
-            }),
-            Type::RATIONAL => {
-                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    Ok(Rational(reader.read_u32()?, reader.read_u32()?))
-                })
-            }
-            Type::SRATIONAL => {
-                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    Ok(SRational(reader.read_i32()?, reader.read_i32()?))
-                })
-            }
-            Type::LONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(UnsignedBig(reader.read_u64()?))
-            }),
-            Type::SLONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(SignedBig(reader.read_i64()?))
-            }),
-            Type::IFD => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Ifd(reader.read_u32()?))
-            }),
-            Type::IFD8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(IfdBig(reader.read_u64()?))
-            }),
-            Type::UNDEFINED => {
-                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    let mut buf = [0; 1];
-                    reader.read_exact(&mut buf)?;
-                    Ok(Byte(buf[0]))
-                })
-            }
-            Type::ASCII => {
-                let n = usize::try_from(self.count)?;
-                if n > limits.decoding_buffer_size {
-                    return Err(TiffError::LimitsExceeded);
-                }
-
-                if bigtiff {
-                    reader.goto_offset(self.r(bo).read_u64()?)?
-                } else {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?
-                }
-
-                let mut out = vec![0; n];
-                reader.read_exact(&mut out)?;
-                // Strings may be null-terminated, so we trim anything downstream of the null byte
-                if let Some(first) = out.iter().position(|&b| b == 0) {
-                    out.truncate(first);
-                }
-                Ok(Ascii(String::from_utf8(out)?))
-            }
-            Type::__NonExhaustive => unreachable!(),
-        }
     }
 
     #[inline]
@@ -620,14 +466,13 @@ impl Entry {
         &self,
         value_count: u64,
         bo: ByteOrder,
-        bigtiff: bool,
         limits: &super::Limits,
-        reader: &mut SmartReader<R>,
+        decoder: &mut super::Decoder<R>,
         decode_fn: F,
     ) -> TiffResult<Value>
     where
         R: Read + Seek,
-        F: Fn(&mut SmartReader<R>) -> TiffResult<Value>,
+        F: Fn(&mut super::Decoder<R>) -> TiffResult<Value>,
     {
         let value_count = usize::try_from(value_count)?;
         if value_count > limits.decoding_buffer_size / mem::size_of::<Value>() {
@@ -635,16 +480,13 @@ impl Entry {
         }
 
         let mut v = Vec::with_capacity(value_count);
-
-        let offset = if bigtiff {
-            self.r(bo).read_u64()?
+        if decoder.bigtiff {
+            decoder.goto_offset_u64(self.r(bo).read_u64()?)?
         } else {
-            self.r(bo).read_u32()?.into()
-        };
-        reader.goto_offset(offset)?;
-
+            decoder.goto_offset(self.r(bo).read_u32()?)?
+        }
         for _ in 0..value_count {
-            v.push(decode_fn(reader)?)
+            v.push(decode_fn(decoder)?)
         }
         Ok(List(v))
     }

src/decoder/image.rs

@@ -1,290 +0,0 @@
-use super::ifd::{Directory, Value};
-use super::tag_reader::TagReader;
-use super::Limits;
-use super::{stream::SmartReader, ChunkType};
-use crate::tags::{CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag};
-use crate::{TiffError, TiffFormatError, TiffResult, TiffUnsupportedError};
-use std::convert::{TryFrom, TryInto};
-use std::io::{Read, Seek};
-
-#[derive(Debug)]
-pub(crate) struct StripDecodeState {
-    pub rows_per_strip: u32,
-}
-
-#[derive(Debug)]
-/// Computed values useful for tile decoding
-pub(crate) struct TileAttributes {
-    pub image_width: usize,
-    pub image_height: usize,
-    pub samples_per_pixel: usize,
-
-    pub tile_width: usize,
-    pub tile_length: usize,
-}
-
-impl TileAttributes {
-    pub fn tiles_across(&self) -> usize {
-        (self.image_width + self.tile_width - 1) / self.tile_width
-    }
-    pub fn tiles_down(&self) -> usize {
-        (self.image_height + self.tile_length - 1) / self.tile_length
-    }
-    fn padding_right(&self) -> usize {
-        self.tile_width - self.image_width % self.tile_width
-    }
-    fn padding_down(&self) -> usize {
-        self.tile_length - self.image_height % self.tile_length
-    }
-    pub fn row_samples(&self) -> usize {
-        self.tile_width * self.samples_per_pixel
-    }
-    pub fn tile_samples(&self) -> usize {
-        self.tile_length * self.tile_width * self.samples_per_pixel
-    }
-    fn tile_strip_samples(&self) -> usize {
-        (self.tile_samples() * self.tiles_across())
-            - (self.padding_right() * self.tile_length * self.samples_per_pixel)
-    }
-
-    /// Returns the tile offset in the result buffer, counted in samples
-    pub fn get_offset(&self, tile: usize) -> usize {
-        let row = tile / self.tiles_across();
-        let column = tile % self.tiles_across();
-
-        (row * self.tile_strip_samples()) + (column * self.row_samples())
-    }
-
-    pub fn get_padding(&self, tile: usize) -> (usize, usize) {
-        let row = tile / self.tiles_across();
-        let column = tile % self.tiles_across();
-
-        let padding_right = if column == self.tiles_across() - 1 {
-            self.padding_right()
-        } else {
-            0
-        };
-
-        let padding_down = if row == self.tiles_down() - 1 {
-            self.padding_down()
-        } else {
-            0
-        };
-
-        (padding_right, padding_down)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Image {
-    pub ifd: Option<Directory>,
-    pub width: u32,
-    pub height: u32,
-    pub bits_per_sample: Vec<u8>,
-    #[allow(unused)]
-    pub samples: u8,
-    pub sample_format: Vec<SampleFormat>,
-    pub photometric_interpretation: PhotometricInterpretation,
-    pub compression_method: CompressionMethod,
-    pub predictor: Predictor,
-    pub jpeg_tables: Option<Vec<u8>>,
-    pub chunk_type: ChunkType,
-    pub strip_decoder: Option<StripDecodeState>,
-    pub tile_attributes: Option<TileAttributes>,
-    pub chunk_offsets: Vec<u64>,
-    pub chunk_bytes: Vec<u64>,
-}
-
-impl Image {
-    pub fn from_reader<R: Read + Seek>(
-        reader: &mut SmartReader<R>,
-        ifd: Directory,
-        limits: &Limits,
-        bigtiff: bool,
-    ) -> TiffResult<Image> {
-        let mut tag_reader = TagReader {
-            reader,
-            limits,
-            ifd: &ifd,
-            bigtiff,
-        };
-
-        let width = tag_reader.require_tag(Tag::ImageWidth)?.into_u32()?;
-        let height = tag_reader.require_tag(Tag::ImageLength)?.into_u32()?;
-
-        let photometric_interpretation = tag_reader
-            .find_tag(Tag::PhotometricInterpretation)?
-            .map(Value::into_u16)
-            .transpose()?
-            .and_then(PhotometricInterpretation::from_u16)
-            .ok_or(TiffUnsupportedError::UnknownInterpretation)?;
-
-        // Try to parse both the compression method and the number, format, and bits of the included samples.
-        // If they are not explicitly specified, those tags are reset to their default values and not carried from previous images.
-        let compression_method = match tag_reader.find_tag(Tag::Compression)? {
-            Some(val) => CompressionMethod::from_u16(val.into_u16()?)
-                .ok_or(TiffUnsupportedError::UnknownCompressionMethod)?,
-            None => CompressionMethod::None,
-        };
-
-        let jpeg_tables = if compression_method == CompressionMethod::ModernJPEG
-            && ifd.contains_key(&Tag::JPEGTables)
-        {
-            let vec = tag_reader
-                .find_tag(Tag::JPEGTables)?
-                .unwrap()
-                .into_u8_vec()?;
-            if vec.len() < 2 {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::InvalidTagValueType(Tag::JPEGTables),
-                ));
-            }
-            Some(vec)
-        } else {
-            None
-        };
-
-        let samples = tag_reader
-            .find_tag(Tag::SamplesPerPixel)?
-            .map(Value::into_u16)
-            .transpose()?
-            .unwrap_or(1)
-            .try_into()?;
-
-        let sample_format = match tag_reader.find_tag_uint_vec(Tag::SampleFormat)? {
-            Some(vals) => {
-                let sample_format: Vec<_> = vals
-                    .into_iter()
-                    .map(SampleFormat::from_u16_exhaustive)
-                    .collect();
-
-                // TODO: for now, only homogenous formats across samples are supported.
-                if !sample_format.windows(2).all(|s| s[0] == s[1]) {
-                    return Err(TiffUnsupportedError::UnsupportedSampleFormat(sample_format).into());
-                }
-
-                sample_format
-            }
-            None => vec![SampleFormat::Uint],
-        };
-
-        let bits_per_sample = match samples {
-            1 | 3 | 4 => tag_reader
-                .find_tag_uint_vec(Tag::BitsPerSample)?
-                .unwrap_or_else(|| vec![1]),
-            _ => return Err(TiffUnsupportedError::UnsupportedSampleDepth(samples).into()),
-        };
-
-        let predictor = tag_reader
-            .find_tag(Tag::Predictor)?
-            .map(Value::into_u16)
-            .transpose()?
-            .map(|p| {
-                Predictor::from_u16(p)
-                    .ok_or(TiffError::FormatError(TiffFormatError::UnknownPredictor(p)))
-            })
-            .transpose()?
-            .unwrap_or(Predictor::None);
-
-        let chunk_type;
-        let chunk_offsets;
-        let chunk_bytes;
-        let strip_decoder;
-        let tile_attributes;
-        match (
-            ifd.contains_key(&Tag::StripByteCounts),
-            ifd.contains_key(&Tag::StripOffsets),
-            ifd.contains_key(&Tag::TileByteCounts),
-            ifd.contains_key(&Tag::TileOffsets),
-        ) {
-            (true, true, false, false) => {
-                chunk_type = ChunkType::Strip;
-
-                chunk_offsets = tag_reader
-                    .find_tag(Tag::StripOffsets)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                chunk_bytes = tag_reader
-                    .find_tag(Tag::StripByteCounts)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                let rows_per_strip = tag_reader
-                    .find_tag(Tag::RowsPerStrip)?
-                    .map(Value::into_u32)
-                    .transpose()?
-                    .unwrap_or(height);
-                strip_decoder = Some(StripDecodeState { rows_per_strip });
-                tile_attributes = None;
-
-                if chunk_offsets.len() != chunk_bytes.len() {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InconsistentSizesEncountered,
-                    ));
-                }
-            }
-            (false, false, true, true) => {
-                chunk_type = ChunkType::Tile;
-
-                let tile_width =
-                    usize::try_from(tag_reader.require_tag(Tag::TileWidth)?.into_u32()?)?;
-                let tile_length =
-                    usize::try_from(tag_reader.require_tag(Tag::TileLength)?.into_u32()?)?;
-
-                if tile_width == 0 {
-                    return Err(TiffFormatError::InvalidTagValueType(Tag::TileWidth).into());
-                } else if tile_length == 0 {
-                    return Err(TiffFormatError::InvalidTagValueType(Tag::TileLength).into());
-                }
-
-                strip_decoder = None;
-                tile_attributes = Some(TileAttributes {
-                    image_width: usize::try_from(width)?,
-                    image_height: usize::try_from(height)?,
-                    samples_per_pixel: bits_per_sample.len(),
-                    tile_width,
-                    tile_length,
-                });
-                chunk_offsets = tag_reader
-                    .find_tag(Tag::TileOffsets)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                chunk_bytes = tag_reader
-                    .find_tag(Tag::TileByteCounts)?
-                    .unwrap()
-                    .into_u64_vec()?;
-
-                let tile = tile_attributes.as_ref().unwrap();
-                if chunk_offsets.len() != chunk_bytes.len()
-                    || chunk_offsets.len() != tile.tiles_down() * tile.tiles_across()
-                {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InconsistentSizesEncountered,
-                    ));
-                }
-            }
-            (_, _, _, _) => {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::StripTileTagConflict,
-                ))
-            }
-        };
-
-        Ok(Image {
-            ifd: Some(ifd),
-            width,
-            height,
-            bits_per_sample,
-            samples,
-            sample_format,
-            photometric_interpretation,
-            compression_method,
-            jpeg_tables,
-            predictor,
-            chunk_type,
-            strip_decoder,
-            tile_attributes,
-            chunk_offsets,
-            chunk_bytes,
-        })
-    }
-}

src/decoder/stream.rs

@@ -1,5 +1,8 @@
 //! All IO functionality needed for TIFF decoding
 
+use crate::bytecast;
+use crate::error::{TiffError, TiffResult};
+use miniz_oxide::inflate;
 use std::io::{self, Read, Seek};
 
 /// Byte order of the TIFF file.
@@ -27,15 +30,22 @@ pub trait EndianReader: Read {
         })
     }
 
-    /// Reads an i8
     #[inline(always)]
-    fn read_i8(&mut self) -> Result<i8, io::Error> {
-        let mut n = [0u8; 1];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => i8::from_le_bytes(n),
-            ByteOrder::BigEndian => i8::from_be_bytes(n),
-        })
+    fn read_u16_into(&mut self, buffer: &mut [u16]) -> Result<(), io::Error> {
+        self.read_exact(bytecast::u16_as_ne_mut_bytes(buffer))?;
+        match self.byte_order() {
+            ByteOrder::LittleEndian => {
+                for n in buffer {
+                    *n = u16::from_le(*n);
+                }
+            }
+            ByteOrder::BigEndian => {
+                for n in buffer {
+                    *n = u16::from_be(*n);
+                }
+            }
+        }
+        Ok(())
     }
 
     /// Reads an i16
@@ -60,6 +70,24 @@ pub trait EndianReader: Read {
         })
     }
 
+    #[inline(always)]
+    fn read_u32_into(&mut self, buffer: &mut [u32]) -> Result<(), io::Error> {
+        self.read_exact(bytecast::u32_as_ne_mut_bytes(buffer))?;
+        match self.byte_order() {
+            ByteOrder::LittleEndian => {
+                for n in buffer {
+                    *n = u32::from_le(*n);
+                }
+            }
+            ByteOrder::BigEndian => {
+                for n in buffer {
+                    *n = u32::from_be(*n);
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Reads an i32
     #[inline(always)]
     fn read_i32(&mut self) -> Result<i32, io::Error> {
@@ -82,15 +110,22 @@ pub trait EndianReader: Read {
         })
     }
 
-    /// Reads an i64
     #[inline(always)]
-    fn read_i64(&mut self) -> Result<i64, io::Error> {
-        let mut n = [0u8; 8];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => i64::from_le_bytes(n),
-            ByteOrder::BigEndian => i64::from_be_bytes(n),
-        })
+    fn read_u64_into(&mut self, buffer: &mut [u64]) -> Result<(), io::Error> {
+        self.read_exact(bytecast::u64_as_ne_mut_bytes(buffer))?;
+        match self.byte_order() {
+            ByteOrder::LittleEndian => {
+                for n in buffer {
+                    *n = u64::from_le(*n);
+                }
+            }
+            ByteOrder::BigEndian => {
+                for n in buffer {
+                    *n = u64::from_be(*n);
+                }
+            }
+        }
+        Ok(())
     }
 
     /// Reads an f32
@@ -104,6 +139,24 @@ pub trait EndianReader: Read {
         }))
     }
 
+    #[inline(always)]
+    fn read_f32_into(&mut self, buffer: &mut [f32]) -> Result<(), io::Error> {
+        self.read_exact(bytecast::f32_as_ne_mut_bytes(buffer))?;
+        match self.byte_order() {
+            ByteOrder::LittleEndian => {
+                for n in buffer {
+                    *n = f32::from_bits(u32::from_le(n.to_bits()));
+                }
+            }
+            ByteOrder::BigEndian => {
+                for n in buffer {
+                    *n = f32::from_bits(u32::from_be(n.to_bits()));
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Reads an f64
     #[inline(always)]
     fn read_f64(&mut self) -> Result<f64, io::Error> {
@@ -114,6 +167,24 @@ pub trait EndianReader: Read {
             ByteOrder::BigEndian => u64::from_be_bytes(n),
         }))
     }
+
+    #[inline(always)]
+    fn read_f64_into(&mut self, buffer: &mut [f64]) -> Result<(), io::Error> {
+        self.read_exact(bytecast::f64_as_ne_mut_bytes(buffer))?;
+        match self.byte_order() {
+            ByteOrder::LittleEndian => {
+                for n in buffer {
+                    *n = f64::from_bits(u64::from_le(n.to_bits()));
+                }
+            }
+            ByteOrder::BigEndian => {
+                for n in buffer {
+                    *n = f64::from_bits(u64::from_be(n.to_bits()));
+                }
+            }
+        }
+        Ok(())
+    }
 }
 
 ///
@@ -124,7 +195,51 @@ pub trait EndianReader: Read {
 /// ## Deflate Reader
 ///
 
-pub type DeflateReader<'r, R> = flate2::read::ZlibDecoder<&'r mut SmartReader<R>>;
+/// Reader that decompresses DEFLATE streams
+pub struct DeflateReader {
+    buffer: io::Cursor<Vec<u8>>,
+    byte_order: ByteOrder,
+}
+
+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)?;
+
+        // 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
@@ -133,6 +248,7 @@ pub type DeflateReader<'r, R> = flate2::read::ZlibDecoder<&'r mut SmartReader<R>
 /// Reader that decompresses LZW streams
 pub struct LZWReader {
     buffer: io::Cursor<Vec<u8>>,
+    byte_order: ByteOrder,
 }
 
 impl LZWReader {
@@ -145,21 +261,24 @@ impl 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![0; max_uncompressed_length];
+        let mut uncompressed = Vec::with_capacity(max_uncompressed_length);
         let mut decoder = weezl::decode::Decoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8);
-
         let mut bytes_read = 0;
-        let mut bytes_written = 0;
+        while bytes_read < compressed_length && uncompressed.len() < max_uncompressed_length {
+            let bytes_written = uncompressed.len();
+            uncompressed.reserve(1 << 12);
+            let buffer_space = uncompressed.capacity();
+            uncompressed.resize(buffer_space, 0u8);
 
-        while bytes_written < max_uncompressed_length {
             let result = decoder.decode_bytes(
                 &compressed[bytes_read..],
                 &mut uncompressed[bytes_written..],
             );
             bytes_read += result.consumed_in;
-            bytes_written += result.consumed_out;
+            uncompressed.truncate(bytes_written + result.consumed_out);
 
             match result.status {
                 Ok(weezl::LzwStatus::Ok) => {}
@@ -174,11 +293,12 @@ impl LZWReader {
             }
         }
 
-        uncompressed.resize(bytes_written, 0);
+        let bytes = uncompressed.len();
         Ok((
-            uncompressed.len(),
+            bytes,
             LZWReader {
                 buffer: io::Cursor::new(uncompressed),
+                byte_order: order,
             },
         ))
     }
@@ -191,12 +311,20 @@ impl Read for LZWReader {
     }
 }
 
+impl EndianReader for LZWReader {
+    #[inline(always)]
+    fn byte_order(&self) -> ByteOrder {
+        self.byte_order
+    }
+}
+
 ///
 /// ## JPEG Reader (for "new-style" JPEG format (TIFF compression tag 7))
 ///
 
 pub(crate) struct JpegReader {
     buffer: io::Cursor<Vec<u8>>,
+    byte_order: ByteOrder,
 }
 impl JpegReader {
     /// Constructs new JpegReader wrapping a SmartReader.
@@ -219,35 +347,27 @@ impl JpegReader {
     where
         R: Read + Seek,
     {
+        let order = reader.byte_order;
+
         // Read jpeg image data
         let mut segment = vec![0; length as usize];
         reader.read_exact(&mut segment[..])?;
 
         match jpeg_tables {
             Some(tables) => {
-                assert!(
-                    tables.len() >= 2,
-                    "jpeg_tables, if given, must be at least 2 bytes long. Got {:?}",
-                    tables
-                );
-
-                assert!(
-                    length >= 2,
-                    "if jpeg_tables is given, length must be at least 2 bytes long, got {}",
-                    length
-                );
-
                 let mut jpeg_data = tables.clone();
                 let truncated_length = jpeg_data.len() - 2;
                 jpeg_data.truncate(truncated_length);
-                jpeg_data.extend_from_slice(&segment[2..]);
+                jpeg_data.extend_from_slice(&mut segment[2..]);
 
                 Ok(JpegReader {
                     buffer: io::Cursor::new(jpeg_data),
+                    byte_order: order,
                 })
             }
             None => Ok(JpegReader {
                 buffer: io::Cursor::new(segment),
+                byte_order: order,
             }),
         }
     }
@@ -260,6 +380,13 @@ impl Read for JpegReader {
     }
 }
 
+impl EndianReader for JpegReader {
+    #[inline(always)]
+    fn byte_order(&self) -> ByteOrder {
+        self.byte_order
+    }
+}
+
 ///
 /// ## PackBits Reader
 ///
@@ -267,49 +394,61 @@ impl Read for JpegReader {
 /// Reader that unpacks Apple's `PackBits` format
 pub struct PackBitsReader {
     buffer: io::Cursor<Vec<u8>>,
+    byte_order: ByteOrder,
 }
 
 impl PackBitsReader {
     /// 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 header: [u8; 1] = [0];
-        let mut data: [u8; 1] = [0];
-
-        let mut bytes_read = 0;
-        while bytes_read < length {
-            reader.read_exact(&mut header)?;
-            bytes_read += 1;
-
-            let h = header[0] as i8;
-            if h >= -127 && h <= -1 {
-                let new_len = buffer.len() + (1 - h as isize) as usize;
-                reader.read_exact(&mut data)?;
-                buffer.resize(new_len, data[0]);
-                bytes_read += 1;
-            } else if h >= 0 {
-                let num_vals = h as usize + 1;
-                let start = buffer.len();
-                buffer.resize(start + num_vals, 0);
-                reader.read_exact(&mut buffer[start..])?;
-                bytes_read += num_vals
-            } else {
-                // h = -128 is a no-op.
+        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());
             }
+            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> {
+    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)
+            }
+            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)
+            }
+        },
+    }
+}
+
 impl Read for PackBitsReader {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
@@ -317,6 +456,13 @@ impl Read for PackBitsReader {
     }
 }
 
+impl EndianReader for PackBitsReader {
+    #[inline(always)]
+    fn byte_order(&self) -> ByteOrder {
+        self.byte_order
+    }
+}
+
 ///
 /// ## SmartReader Reader
 ///
@@ -325,7 +471,7 @@ impl Read for PackBitsReader {
 #[derive(Debug)]
 pub struct SmartReader<R>
 where
-    R: Read,
+    R: Read + Seek,
 {
     reader: R,
     pub byte_order: ByteOrder,
@@ -333,25 +479,17 @@ where
 
 impl<R> SmartReader<R>
 where
-    R: Read,
+    R: Read + Seek,
 {
     /// Wraps a reader
     pub fn wrap(reader: R, byte_order: ByteOrder) -> SmartReader<R> {
         SmartReader { reader, byte_order }
     }
-    pub fn into_inner(self) -> R {
-        self.reader
-    }
-}
-impl<R: Read + Seek> SmartReader<R> {
-    pub fn goto_offset(&mut self, offset: u64) -> io::Result<()> {
-        self.seek(io::SeekFrom::Start(offset)).map(|_| ())
-    }
 }
 
 impl<R> EndianReader for SmartReader<R>
 where
-    R: Read,
+    R: Read + Seek,
 {
     #[inline(always)]
     fn byte_order(&self) -> ByteOrder {
@@ -359,7 +497,7 @@ where
     }
 }
 
-impl<R: Read> Read for SmartReader<R> {
+impl<R: Read + Seek> Read for SmartReader<R> {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.reader.read(buf)
@@ -386,7 +524,8 @@ mod test {
         let encoded_len = encoded.len();
 
         let buff = io::Cursor::new(encoded);
-        let (_, mut decoder) = PackBitsReader::new(buff, encoded_len).unwrap();
+        let (_, mut decoder) =
+            PackBitsReader::new(buff, ByteOrder::LittleEndian, encoded_len).unwrap();
 
         let mut decoded = Vec::new();
         decoder.read_to_end(&mut decoded).unwrap();

src/decoder/tag_reader.rs

@@ -1,45 +0,0 @@
-use std::convert::TryFrom;
-use std::io::{Read, Seek};
-
-use crate::tags::Tag;
-use crate::{TiffError, TiffFormatError, TiffResult};
-
-use super::ifd::{Directory, Value};
-use super::stream::SmartReader;
-use super::Limits;
-
-pub(crate) struct TagReader<'a, R: Read + Seek> {
-    pub reader: &'a mut SmartReader<R>,
-    pub ifd: &'a Directory,
-    pub limits: &'a Limits,
-    pub bigtiff: bool,
-}
-impl<'a, R: Read + Seek> TagReader<'a, R> {
-    pub(crate) fn find_tag(&mut self, tag: Tag) -> TiffResult<Option<Value>> {
-        Ok(match self.ifd.get(&tag) {
-            Some(entry) => Some(entry.clone().val(self.limits, self.bigtiff, self.reader)?),
-            None => None,
-        })
-    }
-    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/encoder/colortype.rs

@@ -1,4 +1,4 @@
-use crate::tags::{PhotometricInterpretation, SampleFormat};
+use tags::{PhotometricInterpretation, SampleFormat};
 
 /// Trait for different colortypes that can be encoded.
 pub trait ColorType {
@@ -20,14 +20,6 @@ impl ColorType for Gray8 {
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
 }
 
-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];
-}
-
 pub struct Gray16;
 impl ColorType for Gray16 {
     type Inner = u16;
@@ -36,14 +28,6 @@ impl ColorType for Gray16 {
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
 }
 
-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];
-}
-
 pub struct Gray32;
 impl ColorType for Gray32 {
     type Inner = u32;
@@ -52,14 +36,6 @@ impl ColorType for Gray32 {
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
 }
 
-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];
-}
-
 pub struct Gray32Float;
 impl ColorType for Gray32Float {
     type Inner = f32;
@@ -76,14 +52,6 @@ impl ColorType for Gray64 {
     const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
 }
 
-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];
-}
-
 pub struct Gray64Float;
 impl ColorType for Gray64Float {
     type Inner = f64;

src/encoder/compression/deflate.rs

@@ -1,83 +0,0 @@
-use crate::{encoder::compression::*, tags::CompressionMethod};
-use flate2::{write::ZlibEncoder, Compression as FlateCompression};
-use std::io::Write;
-
-/// The Deflate algorithm used to compress image data in TIFF files.
-#[derive(Debug, Clone, Copy)]
-pub struct Deflate {
-    level: FlateCompression,
-}
-
-/// The level of compression used by the Deflate algorithm.
-/// It allows trading compression ratio for compression speed.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-#[non_exhaustive]
-pub enum DeflateLevel {
-    /// The fastest possible compression mode.
-    Fast = 1,
-    /// The conserative choice between speed and ratio.
-    Balanced = 6,
-    /// The best compression available with Deflate.
-    Best = 9,
-}
-
-impl Default for DeflateLevel {
-    fn default() -> Self {
-        DeflateLevel::Balanced
-    }
-}
-
-impl Deflate {
-    /// Create a new deflate compressor with a specific level of compression.
-    pub fn with_level(level: DeflateLevel) -> Self {
-        Self {
-            level: FlateCompression::new(level as u32),
-        }
-    }
-}
-
-impl Default for Deflate {
-    fn default() -> Self {
-        Self::with_level(DeflateLevel::default())
-    }
-}
-
-impl Compression for Deflate {
-    const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::Deflate;
-
-    fn get_algorithm(&self) -> Compressor {
-        Compressor::Deflate(self.clone())
-    }
-}
-
-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

@@ -1,47 +0,0 @@
-use crate::{encoder::compression::*, tags::CompressionMethod};
-use std::io::Write;
-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::default().write_to(&mut writer, TEST_DATA).unwrap();
-        assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice());
-    }
-}

src/encoder/compression/mod.rs

@@ -1,60 +0,0 @@
-use crate::tags::CompressionMethod;
-use std::io::{self, Write};
-
-mod deflate;
-mod lzw;
-mod packbits;
-mod uncompressed;
-
-pub use self::deflate::{Deflate, DeflateLevel};
-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.
-pub enum Compressor {
-    Uncompressed(Uncompressed),
-    Lzw(Lzw),
-    Deflate(Deflate),
-    Packbits(Packbits),
-}
-
-impl Default for Compressor {
-    /// The default compression strategy does not apply any compression.
-    fn default() -> Self {
-        Compressor::Uncompressed(Uncompressed::default())
-    }
-}
-
-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),
-            Compressor::Lzw(algorithm) => algorithm.write_to(writer, bytes),
-            Compressor::Deflate(algorithm) => algorithm.write_to(writer, bytes),
-            Compressor::Packbits(algorithm) => algorithm.write_to(writer, bytes),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    pub const TEST_DATA: &'static [u8] =
-        b"This is a string for checking various compression algorithms.";
-}

src/encoder/compression/packbits.rs

@@ -1,214 +0,0 @@
-use crate::{encoder::compression::*, tags::CompressionMethod};
-use std::io::{BufWriter, Error, ErrorKind, Write};
-
-/// 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(&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(&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(&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::default()
-            .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: &'static [u8] =
-            b"This strrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrring hangs.";
-        const EXPECTED_COMPRESSED_DATA: &'static [u8] = b"\x06This st\xD1r\x09ing hangs.";
-
-        let mut compressed_data = Vec::<u8>::new();
-        let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
-            .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::default()
-            .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: &'static [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::default()
-            .write_to(&mut writer, &TEST_DATA)
-            .unwrap();
-        assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
-    }
-}

src/encoder/compression/uncompressed.rs

@@ -1,37 +0,0 @@
-use crate::{encoder::compression::*, tags::CompressionMethod};
-use std::io::Write;
-
-/// 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(bytes).map(|byte_count| byte_count 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::default()
-            .write_to(&mut writer, TEST_DATA)
-            .unwrap();
-        assert_eq!(TEST_DATA, compressed_data);
-    }
-}

src/encoder/mod.rs

@@ -1,33 +1,402 @@
-pub use tiff_value::*;
+use std::collections::BTreeMap;
+use std::convert::TryFrom;
+use std::io::{Seek, Write};
+use std::{cmp, io, mem};
 
-use std::{
-    cmp,
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-    io::{self, Seek, Write},
-    marker::PhantomData,
-    mem,
-    num::TryFromIntError,
-};
-
-use crate::{
-    error::TiffResult,
-    tags::{CompressionMethod, ResolutionUnit, Tag},
-};
+use bytecast;
+use error::{TiffError, TiffFormatError, TiffResult};
+use tags::{self, ResolutionUnit, Tag, Type};
 
 pub mod colortype;
-pub mod compression;
-mod tiff_value;
 mod writer;
 
 use self::colortype::*;
-use self::compression::*;
 use self::writer::*;
 
-/// Encoder for Tiff and BigTiff files.
+/// Type to represent tiff values of type `RATIONAL`
+#[derive(Clone)]
+pub struct Rational {
+    pub n: u32,
+    pub d: u32,
+}
+
+/// Type to represent tiff values of type `SRATIONAL`
+pub struct SRational {
+    pub n: i32,
+    pub d: i32,
+}
+
+/// Trait for types that can be encoded in a tiff file
+pub trait TiffValue {
+    const BYTE_LEN: u32;
+    const FIELD_TYPE: Type;
+    fn count(&self) -> u32;
+    fn bytes(&self) -> u32 {
+        self.count() * Self::BYTE_LEN
+    }
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()>;
+}
+
+impl TiffValue for [u8] {
+    const BYTE_LEN: u32 = 1;
+    const FIELD_TYPE: Type = Type::BYTE;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_bytes(self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [i8] {
+    const BYTE_LEN: u32 = 1;
+    const FIELD_TYPE: Type = Type::SBYTE;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        let slice = bytecast::i8_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [u16] {
+    const BYTE_LEN: u32 = 2;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        let slice = bytecast::u16_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [i16] {
+    const BYTE_LEN: u32 = 2;
+    const FIELD_TYPE: Type = Type::SSHORT;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        let slice = bytecast::i16_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [u32] {
+    const BYTE_LEN: u32 = 4;
+    const FIELD_TYPE: Type = Type::LONG;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        let slice = bytecast::u32_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [i32] {
+    const BYTE_LEN: u32 = 4;
+    const FIELD_TYPE: Type = Type::SLONG;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        let slice = bytecast::i32_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [u64] {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::LONG8;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        let slice = bytecast::u64_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [f32] {
+    const BYTE_LEN: u32 = 4;
+    const FIELD_TYPE: Type = Type::FLOAT;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        // We write using nativeedian so this sould be safe
+        let slice = bytecast::f32_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [f64] {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::DOUBLE;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        // We write using nativeedian so this sould be safe
+        let slice = bytecast::f64_as_ne_bytes(self);
+        writer.write_bytes(slice)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for [Rational] {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::RATIONAL;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        for x in self {
+            x.write(writer)?;
+        }
+        Ok(())
+    }
+}
+
+impl TiffValue for [SRational] {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::SRATIONAL;
+
+    fn count(&self) -> u32 {
+        self.len() as u32
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        for x in self {
+            x.write(writer)?;
+        }
+        Ok(())
+    }
+}
+
+impl TiffValue for u8 {
+    const BYTE_LEN: u32 = 1;
+    const FIELD_TYPE: Type = Type::BYTE;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u8(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for i8 {
+    const BYTE_LEN: u32 = 1;
+    const FIELD_TYPE: Type = Type::SBYTE;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i8(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for u16 {
+    const BYTE_LEN: u32 = 2;
+    const FIELD_TYPE: Type = Type::SHORT;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u16(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for i16 {
+    const BYTE_LEN: u32 = 2;
+    const FIELD_TYPE: Type = Type::SSHORT;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i16(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for u32 {
+    const BYTE_LEN: u32 = 4;
+    const FIELD_TYPE: Type = Type::LONG;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u32(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for i32 {
+    const BYTE_LEN: u32 = 4;
+    const FIELD_TYPE: Type = Type::SLONG;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i32(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for u64 {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::LONG8;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u64(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for f32 {
+    const BYTE_LEN: u32 = 4;
+    const FIELD_TYPE: Type = Type::FLOAT;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_f32(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for f64 {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::DOUBLE;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_f64(*self)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for Rational {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::RATIONAL;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_u32(self.n)?;
+        writer.write_u32(self.d)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for SRational {
+    const BYTE_LEN: u32 = 8;
+    const FIELD_TYPE: Type = Type::SRATIONAL;
+
+    fn count(&self) -> u32 {
+        1
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        writer.write_i32(self.n)?;
+        writer.write_i32(self.d)?;
+        Ok(())
+    }
+}
+
+impl TiffValue for str {
+    const BYTE_LEN: u32 = 1;
+    const FIELD_TYPE: Type = Type::ASCII;
+
+    fn count(&self) -> u32 {
+        self.len() as u32 + 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))
+        }
+    }
+}
+
+impl<'a, T: TiffValue + ?Sized> TiffValue for &'a T {
+    const BYTE_LEN: u32 = T::BYTE_LEN;
+    const FIELD_TYPE: Type = T::FIELD_TYPE;
+
+    fn count(&self) -> u32 {
+        (*self).count()
+    }
+
+    fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
+        (*self).write(writer)
+    }
+}
+
+/// Tiff encoder.
 ///
 /// With this type you can get a `DirectoryEncoder` or a `ImageEncoder`
-/// to encode Tiff/BigTiff ifd directories with images.
+/// to encode tiff ifd directories with images.
 ///
 /// See `DirectoryEncoder` and `ImageEncoder`.
 ///
@@ -39,83 +408,43 @@ use self::writer::*;
 /// # let image_data = vec![0; 100*100*3];
 /// use tiff::encoder::*;
 ///
-/// // create a standard Tiff file
 /// let mut tiff = TiffEncoder::new(&mut file).unwrap();
+///
 /// tiff.write_image::<colortype::RGB8>(100, 100, &image_data).unwrap();
-///
-/// // create a BigTiff file
-/// let mut bigtiff = TiffEncoder::new_big(&mut file).unwrap();
-/// bigtiff.write_image::<colortype::RGB8>(100, 100, &image_data).unwrap();
-///
 /// # }
 /// ```
-pub struct TiffEncoder<W, K: TiffKind = TiffKindStandard> {
+pub struct TiffEncoder<W> {
     writer: TiffWriter<W>,
-    kind: PhantomData<K>,
 }
 
-/// Constructor functions to create standard Tiff files.
 impl<W: Write + Seek> TiffEncoder<W> {
-    /// Creates a new encoder for standard Tiff files.
-    ///
-    /// To create BigTiff files, use [`new_big`][TiffEncoder::new_big] or
-    /// [`new_generic`][TiffEncoder::new_generic].
-    pub fn new(writer: W) -> TiffResult<TiffEncoder<W, TiffKindStandard>> {
-        TiffEncoder::new_generic(writer)
-    }
-}
-
-/// Constructor functions to create BigTiff files.
-impl<W: Write + Seek> TiffEncoder<W, TiffKindBig> {
-    /// Creates a new encoder for BigTiff files.
-    ///
-    /// To create standard Tiff files, use [`new`][TiffEncoder::new] or
-    /// [`new_generic`][TiffEncoder::new_generic].
-    pub fn new_big(writer: W) -> TiffResult<Self> {
-        TiffEncoder::new_generic(writer)
-    }
-}
-
-/// Generic functions that are available for both Tiff and BigTiff encoders.
-impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {
-    /// Creates a new Tiff or BigTiff encoder, inferred from the return type.
-    pub fn new_generic(writer: W) -> TiffResult<Self> {
+    pub fn new(writer: W) -> TiffResult<TiffEncoder<W>> {
         let mut encoder = TiffEncoder {
             writer: TiffWriter::new(writer),
-            kind: PhantomData,
         };
 
-        K::write_header(&mut encoder.writer)?;
+        write_tiff_header(&mut encoder.writer)?;
+        // blank the IFD offset location
+        encoder.writer.write_u32(0)?;
 
         Ok(encoder)
     }
 
-    /// Create a [`DirectoryEncoder`] to encode an ifd directory.
-    pub fn new_directory(&mut self) -> TiffResult<DirectoryEncoder<W, K>> {
+    /// Create a `DirectoryEncoder` to encode an ifd directory.
+    pub fn new_directory(&mut self) -> TiffResult<DirectoryEncoder<W>> {
         DirectoryEncoder::new(&mut self.writer)
     }
 
-    /// Create an [`ImageEncoder`] to encode an image one slice at a time.
+    /// Create an 'ImageEncoder' to encode an image one slice at a time.
     pub fn new_image<C: ColorType>(
         &mut self,
         width: u32,
         height: u32,
-    ) -> TiffResult<ImageEncoder<W, C, K, Uncompressed>> {
+    ) -> TiffResult<ImageEncoder<W, C>> {
         let encoder = DirectoryEncoder::new(&mut self.writer)?;
         ImageEncoder::new(encoder, width, height)
     }
 
-    /// Create an [`ImageEncoder`] to encode an image one slice at a time.
-    pub fn new_image_with_compression<C: ColorType, D: Compression>(
-        &mut self,
-        width: u32,
-        height: u32,
-        compression: D,
-    ) -> TiffResult<ImageEncoder<W, C, K, D>> {
-        let encoder = DirectoryEncoder::new(&mut self.writer)?;
-        ImageEncoder::with_compression(encoder, width, height, compression)
-    }
-
     /// Convenience function to write an entire image from memory.
     pub fn write_image<C: ColorType>(
         &mut self,
@@ -127,24 +456,7 @@ impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {
         [C::Inner]: TiffValue,
     {
         let encoder = DirectoryEncoder::new(&mut self.writer)?;
-        let image: ImageEncoder<W, C, K> = ImageEncoder::new(encoder, width, height)?;
-        image.write_data(data)
-    }
-
-    /// Convenience function to write an entire image from memory with a given compression.
-    pub fn write_image_with_compression<C: ColorType, D: Compression>(
-        &mut self,
-        width: u32,
-        height: u32,
-        compression: D,
-        data: &[C::Inner],
-    ) -> TiffResult<()>
-    where
-        [C::Inner]: TiffValue,
-    {
-        let encoder = DirectoryEncoder::new(&mut self.writer)?;
-        let image: ImageEncoder<W, C, K, D> =
-            ImageEncoder::with_compression(encoder, width, height, compression)?;
+        let image: ImageEncoder<W, C> = ImageEncoder::new(encoder, width, height)?;
         image.write_data(data)
     }
 }
@@ -153,19 +465,19 @@ impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {
 ///
 /// You should call `finish` on this when you are finished with it.
 /// Encoding can silently fail while this is dropping.
-pub struct DirectoryEncoder<'a, W: 'a + Write + Seek, K: TiffKind> {
+pub struct DirectoryEncoder<'a, W: 'a + Write + Seek> {
     writer: &'a mut TiffWriter<W>,
     dropped: bool,
     // We use BTreeMap to make sure tags are written in correct order
     ifd_pointer_pos: u64,
-    ifd: BTreeMap<u16, DirectoryEntry<K::OffsetType>>,
+    ifd: BTreeMap<u16, (u16, u32, Vec<u8>)>,
 }
 
-impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
-    fn new(writer: &'a mut TiffWriter<W>) -> TiffResult<Self> {
+impl<'a, W: 'a + Write + Seek> DirectoryEncoder<'a, W> {
+    fn new(writer: &'a mut TiffWriter<W>) -> TiffResult<DirectoryEncoder<'a, W>> {
         // the previous word is the IFD offset position
-        let ifd_pointer_pos = writer.offset() - mem::size_of::<K::OffsetType>() as u64;
-        writer.pad_word_boundary()?; // TODO: Do we need to adjust this for BigTiff?
+        let ifd_pointer_pos = writer.offset() - mem::size_of::<u32>() as u64;
+        writer.pad_word_boundary()?;
         Ok(DirectoryEncoder {
             writer,
             dropped: false,
@@ -176,7 +488,8 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
 
     /// Write a single ifd tag.
     pub fn write_tag<T: TiffValue>(&mut self, tag: Tag, value: T) -> TiffResult<()> {
-        let mut bytes = Vec::with_capacity(value.bytes());
+        let len = <T>::BYTE_LEN * value.count();
+        let mut bytes = Vec::with_capacity(usize::try_from(len)?);
         {
             let mut writer = TiffWriter::new(&mut bytes);
             value.write(&mut writer)?;
@@ -184,11 +497,7 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
 
         self.ifd.insert(
             tag.to_u16(),
-            DirectoryEntry {
-                data_type: <T>::FIELD_TYPE.to_u16(),
-                count: value.count().try_into()?,
-                data: bytes,
-            },
+            (<T>::FIELD_TYPE.to_u16(), value.count(), bytes),
         );
 
         Ok(())
@@ -196,21 +505,15 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
 
     fn write_directory(&mut self) -> TiffResult<u64> {
         // Start by writing out all values
-        for &mut DirectoryEntry {
-            data: ref mut bytes,
-            ..
-        } in self.ifd.values_mut()
-        {
-            let data_bytes = mem::size_of::<K::OffsetType>();
-
-            if bytes.len() > data_bytes {
+        for &mut (_, _, ref mut bytes) in self.ifd.values_mut() {
+            if bytes.len() > 4 {
                 let offset = self.writer.offset();
                 self.writer.write_bytes(bytes)?;
-                *bytes = vec![0; data_bytes];
+                *bytes = vec![0, 0, 0, 0];
                 let mut writer = TiffWriter::new(bytes as &mut [u8]);
-                K::write_offset(&mut writer, offset)?;
+                writer.write_u32(u32::try_from(offset)?)?;
             } else {
-                while bytes.len() < data_bytes {
+                while bytes.len() < 4 {
                     bytes.push(0);
                 }
             }
@@ -218,19 +521,11 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
 
         let offset = self.writer.offset();
 
-        K::write_entry_count(&mut self.writer, self.ifd.len())?;
-        for (
-            tag,
-            &DirectoryEntry {
-                data_type: ref field_type,
-                ref count,
-                data: ref offset,
-            },
-        ) in self.ifd.iter()
-        {
+        self.writer.write_u16(u16::try_from(self.ifd.len())?)?;
+        for (tag, &(ref field_type, ref count, ref offset)) in self.ifd.iter() {
             self.writer.write_u16(*tag)?;
             self.writer.write_u16(*field_type)?;
-            (*count).write(&mut self.writer)?;
+            self.writer.write_u32(*count)?;
             self.writer.write_bytes(offset)?;
         }
 
@@ -246,19 +541,14 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
         Ok(offset)
     }
 
-    /// Provides the number of bytes written by the underlying TiffWriter during the last call.
-    fn last_written(&self) -> u64 {
-        self.writer.last_written()
-    }
-
     fn finish_internal(&mut self) -> TiffResult<()> {
         let ifd_pointer = self.write_directory()?;
         let curr_pos = self.writer.offset();
 
         self.writer.goto_offset(self.ifd_pointer_pos)?;
-        K::write_offset(&mut self.writer, ifd_pointer)?;
+        self.writer.write_u32(u32::try_from(ifd_pointer)?)?;
         self.writer.goto_offset(curr_pos)?;
-        K::write_offset(&mut self.writer, 0)?;
+        self.writer.write_u32(0)?;
 
         self.dropped = true;
 
@@ -271,7 +561,7 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
     }
 }
 
-impl<'a, W: Write + Seek, K: TiffKind> Drop for DirectoryEncoder<'a, W, K> {
+impl<'a, W: Write + Seek> Drop for DirectoryEncoder<'a, W> {
     fn drop(&mut self) {
         if !self.dropped {
             let _ = self.finish_internal();
@@ -299,9 +589,6 @@ impl<'a, W: Write + Seek, K: TiffKind> Drop for DirectoryEncoder<'a, W, K> {
 /// // You can encode tags here
 /// image.encoder().write_tag(Tag::Artist, "Image-tiff").unwrap();
 ///
-/// // Strip size can be configured before writing data
-/// image.rows_per_strip(2).unwrap();
-///
 /// let mut idx = 0;
 /// while image.next_strip_sample_count() > 0 {
 ///     let sample_count = image.next_strip_sample_count() as usize;
@@ -312,60 +599,37 @@ impl<'a, W: Write + Seek, K: TiffKind> Drop for DirectoryEncoder<'a, W, K> {
 /// # }
 /// ```
 /// You can also call write_data function wich will encode by strip and finish
-pub struct ImageEncoder<
-    'a,
-    W: 'a + Write + Seek,
-    C: ColorType,
-    K: TiffKind,
-    D: Compression = Uncompressed,
-> {
-    encoder: DirectoryEncoder<'a, W, K>,
+pub struct ImageEncoder<'a, W: 'a + Write + Seek, C: ColorType> {
+    encoder: DirectoryEncoder<'a, W>,
     strip_idx: u64,
     strip_count: u64,
     row_samples: u64,
     width: u32,
     height: u32,
     rows_per_strip: u64,
-    strip_offsets: Vec<K::OffsetType>,
-    strip_byte_count: Vec<K::OffsetType>,
+    strip_offsets: Vec<u32>,
+    strip_byte_count: Vec<u32>,
     dropped: bool,
-    compression: D,
     _phantom: ::std::marker::PhantomData<C>,
 }
 
-impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
-    ImageEncoder<'a, W, T, K, D>
-{
-    fn new(encoder: DirectoryEncoder<'a, W, K>, width: u32, height: u32) -> TiffResult<Self>
-    where
-        D: Default,
-    {
-        Self::with_compression(encoder, width, height, D::default())
-    }
-
-    fn with_compression(
-        mut encoder: DirectoryEncoder<'a, W, K>,
+impl<'a, W: 'a + Write + Seek, T: ColorType> ImageEncoder<'a, W, T> {
+    fn new(
+        mut encoder: DirectoryEncoder<'a, W>,
         width: u32,
         height: u32,
-        compression: D,
-    ) -> TiffResult<Self> {
+    ) -> TiffResult<ImageEncoder<'a, W, T>> {
         let row_samples = u64::from(width) * u64::try_from(<T>::BITS_PER_SAMPLE.len())?;
         let row_bytes = row_samples * u64::from(<T::Inner>::BYTE_LEN);
 
-        // Limit the strip size to prevent potential memory and security issues.
-        // Also keep the multiple strip handling 'oiled'
-        let rows_per_strip = {
-            match D::COMPRESSION_METHOD {
-                CompressionMethod::PackBits => 1, // Each row must be packed separately. Do not compress across row boundaries
-                _ => (1_000_000 + row_bytes - 1) / row_bytes,
-            }
-        };
+        // As per tiff spec each strip should be about 8k long
+        let rows_per_strip = (8000 + row_bytes - 1) / row_bytes;
 
         let strip_count = (u64::from(height) + rows_per_strip - 1) / rows_per_strip;
 
         encoder.write_tag(Tag::ImageWidth, width)?;
         encoder.write_tag(Tag::ImageLength, height)?;
-        encoder.write_tag(Tag::Compression, D::COMPRESSION_METHOD.to_u16())?;
+        encoder.write_tag(Tag::Compression, tags::CompressionMethod::None.to_u16())?;
 
         encoder.write_tag(Tag::BitsPerSample, <T>::BITS_PER_SAMPLE)?;
         let sample_format: Vec<_> = <T>::SAMPLE_FORMAT.iter().map(|s| s.to_u16()).collect();
@@ -393,7 +657,6 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
             strip_offsets: Vec::new(),
             strip_byte_count: Vec::new(),
             dropped: false,
-            compression: compression,
             _phantom: ::std::marker::PhantomData,
         })
     }
@@ -416,6 +679,7 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
     where
         [T::Inner]: TiffValue,
     {
+        // TODO: Compression
         let samples = self.next_strip_sample_count();
         if u64::try_from(value.len())? != samples {
             return Err(io::Error::new(
@@ -425,12 +689,9 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
             .into());
         }
 
-        // Write the (possible compressed) data to the encoder.
         let offset = self.encoder.write_data(value)?;
-        let byte_count = self.encoder.last_written() as usize;
-
-        self.strip_offsets.push(K::convert_offset(offset)?);
-        self.strip_byte_count.push(byte_count.try_into()?);
+        self.strip_offsets.push(u32::try_from(offset)?);
+        self.strip_byte_count.push(value.bytes());
 
         self.strip_idx += 1;
         Ok(())
@@ -456,19 +717,12 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
             )
             .into());
         }
-
-        self.encoder
-            .writer
-            .set_compression(self.compression.get_algorithm());
-
         let mut idx = 0;
         while self.next_strip_sample_count() > 0 {
             let sample_count = usize::try_from(self.next_strip_sample_count())?;
             self.write_strip(&data[idx..idx + sample_count])?;
             idx += sample_count;
         }
-
-        self.encoder.writer.reset_compression();
         self.finish()?;
         Ok(())
     }
@@ -501,42 +755,18 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
         self.encoder.write_tag(Tag::YResolution, value).unwrap();
     }
 
-    /// Set image number of lines per strip
-    ///
-    /// This function needs to be called before any calls to `write_data` or
-    /// `write_strip` and will return an error otherwise.
-    pub fn rows_per_strip(&mut self, value: u32) -> TiffResult<()> {
-        if self.strip_idx != 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Cannot change strip size after data was written",
-            )
-            .into());
-        }
-        // Write tag as 32 bits
-        self.encoder.write_tag(Tag::RowsPerStrip, value)?;
-
-        let value: u64 = value as u64;
-        self.strip_count = (self.height as u64 + value - 1) / value;
-        self.rows_per_strip = value;
-
-        Ok(())
-    }
-
     fn finish_internal(&mut self) -> TiffResult<()> {
         self.encoder
-            .write_tag(Tag::StripOffsets, K::convert_slice(&self.strip_offsets))?;
-        self.encoder.write_tag(
-            Tag::StripByteCounts,
-            K::convert_slice(&self.strip_byte_count),
-        )?;
+            .write_tag(Tag::StripOffsets, &*self.strip_offsets)?;
+        self.encoder
+            .write_tag(Tag::StripByteCounts, &*self.strip_byte_count)?;
         self.dropped = true;
 
         self.encoder.finish_internal()
     }
 
     /// Get a reference of the underlying `DirectoryEncoder`
-    pub fn encoder(&mut self) -> &mut DirectoryEncoder<'a, W, K> {
+    pub fn encoder(&mut self) -> &mut DirectoryEncoder<'a, W> {
         &mut self.encoder
     }
 
@@ -546,129 +776,10 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
     }
 }
 
-impl<'a, W: Write + Seek, C: ColorType, K: TiffKind, D: Compression> Drop
-    for ImageEncoder<'a, W, C, K, D>
-{
+impl<'a, W: Write + Seek, C: ColorType> Drop for ImageEncoder<'a, W, C> {
     fn drop(&mut self) {
         if !self.dropped {
             let _ = self.finish_internal();
         }
     }
 }
-
-struct DirectoryEntry<S> {
-    data_type: u16,
-    count: S,
-    data: Vec<u8>,
-}
-
-/// Trait to abstract over Tiff/BigTiff differences.
-///
-/// Implemented for [`TiffKindStandard`] and [`TiffKindBig`].
-pub trait TiffKind {
-    /// The type of offset fields, `u32` for normal Tiff, `u64` for BigTiff.
-    type OffsetType: TryFrom<usize, Error = TryFromIntError> + Into<u64> + TiffValue;
-
-    /// Needed for the `convert_slice` method.
-    type OffsetArrayType: ?Sized + TiffValue;
-
-    /// Write the (Big)Tiff header.
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()>;
-
-    /// Convert a file offset to `Self::OffsetType`.
-    ///
-    /// This returns an error for normal Tiff if the offset is larger than `u32::MAX`.
-    fn convert_offset(offset: u64) -> TiffResult<Self::OffsetType>;
-
-    /// Write an offset value to the given writer.
-    ///
-    /// Like `convert_offset`, this errors if `offset > u32::MAX` for normal Tiff.
-    fn write_offset<W: Write>(writer: &mut TiffWriter<W>, offset: u64) -> TiffResult<()>;
-
-    /// Write the IFD entry count field with the given `count` value.
-    ///
-    /// The entry count field is an `u16` for normal Tiff and `u64` for BigTiff. Errors
-    /// if the given `usize` is larger than the representable values.
-    fn write_entry_count<W: Write>(writer: &mut TiffWriter<W>, count: usize) -> TiffResult<()>;
-
-    /// Internal helper method for satisfying Rust's type checker.
-    ///
-    /// The `TiffValue` trait is implemented for both primitive values (e.g. `u8`, `u32`) and
-    /// slices of primitive values (e.g. `[u8]`, `[u32]`). However, this is not represented in
-    /// the type system, so there is no guarantee that that for all `T: TiffValue` there is also
-    /// an implementation of `TiffValue` for `[T]`. This method works around that problem by
-    /// providing a conversion from `[T]` to some value that implements `TiffValue`, thereby
-    /// making all slices of `OffsetType` usable with `write_tag` and similar methods.
-    ///
-    /// Implementations of this trait should always set `OffsetArrayType` to `[OffsetType]`.
-    fn convert_slice(slice: &[Self::OffsetType]) -> &Self::OffsetArrayType;
-}
-
-/// Create a standard Tiff file.
-pub struct TiffKindStandard;
-
-impl TiffKind for TiffKindStandard {
-    type OffsetType = u32;
-    type OffsetArrayType = [u32];
-
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        write_tiff_header(writer)?;
-        // blank the IFD offset location
-        writer.write_u32(0)?;
-
-        Ok(())
-    }
-
-    fn convert_offset(offset: u64) -> TiffResult<Self::OffsetType> {
-        Ok(Self::OffsetType::try_from(offset)?)
-    }
-
-    fn write_offset<W: Write>(writer: &mut TiffWriter<W>, offset: u64) -> TiffResult<()> {
-        writer.write_u32(u32::try_from(offset)?)?;
-        Ok(())
-    }
-
-    fn write_entry_count<W: Write>(writer: &mut TiffWriter<W>, count: usize) -> TiffResult<()> {
-        writer.write_u16(u16::try_from(count)?)?;
-
-        Ok(())
-    }
-
-    fn convert_slice(slice: &[Self::OffsetType]) -> &Self::OffsetArrayType {
-        slice
-    }
-}
-
-/// Create a BigTiff file.
-pub struct TiffKindBig;
-
-impl TiffKind for TiffKindBig {
-    type OffsetType = u64;
-    type OffsetArrayType = [u64];
-
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        write_bigtiff_header(writer)?;
-        // blank the IFD offset location
-        writer.write_u64(0)?;
-
-        Ok(())
-    }
-
-    fn convert_offset(offset: u64) -> TiffResult<Self::OffsetType> {
-        Ok(offset)
-    }
-
-    fn write_offset<W: Write>(writer: &mut TiffWriter<W>, offset: u64) -> TiffResult<()> {
-        writer.write_u64(offset)?;
-        Ok(())
-    }
-
-    fn write_entry_count<W: Write>(writer: &mut TiffWriter<W>, count: usize) -> TiffResult<()> {
-        writer.write_u64(u64::try_from(count)?)?;
-        Ok(())
-    }
-
-    fn convert_slice(slice: &[Self::OffsetType]) -> &Self::OffsetArrayType {
-        slice
-    }
-}

src/encoder/tiff_value.rs

@@ -1,523 +0,0 @@
-use std::{borrow::Cow, io::Write, slice::from_ref};
-
-use crate::{bytecast, tags::Type, TiffError, TiffFormatError, TiffResult};
-
-use super::writer::TiffWriter;
-
-/// Trait for types that can be encoded in a tiff file
-pub trait TiffValue {
-    const BYTE_LEN: u8;
-    const FIELD_TYPE: Type;
-    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![]
-            }
-        })
-    }
-}
-
-impl<'a, T: TiffValue + ?Sized> TiffValue for &'a 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)
-    }
-}
-
-macro_rules! impl_tiff_value_for_contiguous_sequence {
-    ($inner_type:ty; $bytes:expr; $field_type:expr) => {
-        impl $crate::encoder::TiffValue for [$inner_type] {
-            const BYTE_LEN: u8 = $bytes;
-            const FIELD_TYPE: Type = $field_type;
-
-            fn count(&self) -> usize {
-                self.len()
-            }
-
-            fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-                for x in self {
-                    x.write(writer)?;
-                }
-                Ok(())
-            }
-
-            fn data(&self) -> Cow<[u8]> {
-                let mut buf: Vec<u8> = Vec::with_capacity(Self::BYTE_LEN as usize * self.len());
-                for x in self {
-                    buf.extend_from_slice(&x.data());
-                }
-                Cow::Owned(buf)
-            }
-        }
-    };
-}
-
-impl_tiff_value_for_contiguous_sequence!(Ifd; 4; Type::IFD);
-impl_tiff_value_for_contiguous_sequence!(Ifd8; 8; Type::IFD8);
-impl_tiff_value_for_contiguous_sequence!(Rational; 8; Type::RATIONAL);
-impl_tiff_value_for_contiguous_sequence!(SRational; 8; Type::SRATIONAL);
-
-/// Type to represent tiff values of type `IFD`
-#[derive(Clone)]
-pub struct Ifd(pub u32);
-
-/// Type to represent tiff values of type `IFD8`
-#[derive(Clone)]
-pub struct Ifd8(pub u64);
-
-/// Type to represent tiff values of type `RATIONAL`
-#[derive(Clone)]
-pub struct Rational {
-    pub n: u32,
-    pub d: u32,
-}
-
-/// Type to represent tiff values of type `SRATIONAL`
-#[derive(Clone)]
-pub struct SRational {
-    pub n: i32,
-    pub d: i32,
-}

src/encoder/writer.rs

@@ -1,5 +1,4 @@
-use crate::encoder::compression::*;
-use crate::error::TiffResult;
+use error::TiffResult;
 use std::io::{self, Seek, SeekFrom, Write};
 
 pub fn write_tiff_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
@@ -15,154 +14,83 @@ pub fn write_tiff_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()>
     Ok(())
 }
 
-/// 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,
-            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();
+        Self { writer, offset: 0 }
     }
 
     pub fn offset(&self) -> u64 {
         self.offset
     }
 
-    pub fn last_written(&self) -> u64 {
-        self.byte_count
-    }
-
     pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), io::Error> {
-        self.byte_count = self.compressor.write_to(&mut self.writer, bytes)?;
-        self.offset += self.byte_count;
+        self.writer.write_all(bytes)?;
+        self.offset += bytes.len() as u64;
         Ok(())
     }
 
     pub fn write_u8(&mut self, n: u8) -> Result<(), io::Error> {
-        self.byte_count = self
-            .compressor
-            .write_to(&mut self.writer, &n.to_ne_bytes())?;
-        self.offset += self.byte_count;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 1;
         Ok(())
     }
 
     pub fn write_i8(&mut self, n: i8) -> Result<(), io::Error> {
-        self.byte_count = self
-            .compressor
-            .write_to(&mut self.writer, &n.to_ne_bytes())?;
-        self.offset += self.byte_count;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 1;
         Ok(())
     }
 
     pub fn write_u16(&mut self, n: u16) -> Result<(), io::Error> {
-        self.byte_count = self
-            .compressor
-            .write_to(&mut self.writer, &n.to_ne_bytes())?;
-        self.offset += self.byte_count;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 2;
 
         Ok(())
     }
 
     pub fn write_i16(&mut self, n: i16) -> Result<(), io::Error> {
-        self.byte_count = self
-            .compressor
-            .write_to(&mut self.writer, &n.to_ne_bytes())?;
-        self.offset += self.byte_count;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 2;
 
         Ok(())
     }
 
     pub fn write_u32(&mut self, n: u32) -> Result<(), io::Error> {
-        self.byte_count = self
-            .compressor
-            .write_to(&mut self.writer, &n.to_ne_bytes())?;
-        self.offset += self.byte_count;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 4;
 
         Ok(())
     }
 
     pub fn write_i32(&mut self, n: i32) -> Result<(), io::Error> {
-        self.byte_count = self
-            .compressor
-            .write_to(&mut self.writer, &n.to_ne_bytes())?;
-        self.offset += self.byte_count;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 4;
 
         Ok(())
     }
 
     pub fn write_u64(&mut self, n: u64) -> 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_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;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 8;
 
         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;
+        self.writer.write_all(&u32::to_ne_bytes(n.to_bits()))?;
+        self.offset += 4;
 
         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;
+        self.writer.write_all(&u64::to_ne_bytes(n.to_bits()))?;
+        self.offset += 8;
 
         Ok(())
     }

src/error.rs

@@ -1,16 +1,12 @@
 use std::error::Error;
 use std::fmt;
 use std::io;
-use std::str;
 use std::string;
 
-use crate::decoder::{ifd::Value, ChunkType};
-use crate::tags::{
-    CompressionMethod, PhotometricInterpretation, PlanarConfiguration, SampleFormat, Tag,
-};
-use crate::ColorType;
-
-use crate::weezl::LzwError;
+use decoder::ifd::Value;
+use miniz_oxide::inflate::TINFLStatus;
+use tags::{CompressionMethod, PhotometricInterpretation, PlanarConfiguration, SampleFormat, Tag};
+use ColorType;
 
 /// Tiff error kinds.
 #[derive(Debug)]
@@ -30,9 +26,6 @@ pub enum TiffError {
     /// An integer conversion to or from a platform size failed, either due to
     /// limits of the platform size or limits of the format.
     IntSizeError,
-
-    /// The image does not support the requested operation
-    UsageError(UsageError),
 }
 
 /// The image is not formatted properly.
@@ -48,14 +41,6 @@ pub enum TiffFormatError {
     TiffSignatureInvalid,
     ImageFileDirectoryNotFound,
     InconsistentSizesEncountered,
-    UnexpectedCompressedData {
-        actual_bytes: usize,
-        required_bytes: usize,
-    },
-    InconsistentStripSamples {
-        actual_samples: usize,
-        required_samples: usize,
-    },
     InvalidTag,
     InvalidTagValueType(Tag),
     RequiredTagNotFound(Tag),
@@ -63,10 +48,9 @@ pub enum TiffFormatError {
     ByteExpected(Value),
     UnsignedIntegerExpected(Value),
     SignedIntegerExpected(Value),
+    InflateError(InflateError),
     Format(String),
     RequiredTagEmpty(Tag),
-    StripTileTagConflict,
-    CycleInOffsets,
     #[doc(hidden)]
     /// Do not match against this variant. It may get removed.
     __NonExhaustive,
@@ -80,26 +64,6 @@ impl fmt::Display for TiffFormatError {
             TiffSignatureInvalid => write!(fmt, "TIFF signature invalid."),
             ImageFileDirectoryNotFound => write!(fmt, "Image file directory not found."),
             InconsistentSizesEncountered => write!(fmt, "Inconsistent sizes encountered."),
-            UnexpectedCompressedData {
-                actual_bytes,
-                required_bytes,
-            } => {
-                write!(
-                    fmt,
-                    "Decompression returned different amount of bytes than expected: got {}, expected {}.",
-                    actual_bytes, required_bytes
-                )
-            }
-            InconsistentStripSamples {
-                actual_samples,
-                required_samples,
-            } => {
-                write!(
-                    fmt,
-                    "Inconsistent elements in strip: got {}, expected {}.",
-                    actual_samples, required_samples
-                )
-            }
             InvalidTag => write!(fmt, "Image contains invalid tag."),
             InvalidTagValueType(ref tag) => {
                 write!(fmt, "Tag `{:?}` did not have the expected value type.", tag)
@@ -115,15 +79,32 @@ impl fmt::Display for TiffFormatError {
             SignedIntegerExpected(ref val) => {
                 write!(fmt, "Expected signed integer, {:?} found.", val)
             }
+            InflateError(_) => write!(fmt, "Failed to decode inflate data."),
             Format(ref val) => write!(fmt, "Invalid format: {:?}.", val),
             RequiredTagEmpty(ref val) => write!(fmt, "Required tag {:?} was empty.", val),
-            StripTileTagConflict => write!(fmt, "File should contain either (StripByteCounts and StripOffsets) or (TileByteCounts and TileOffsets), other combination was found."),
-            CycleInOffsets => write!(fmt, "File contained a cycle in the list of IFDs"),
             __NonExhaustive => unreachable!(),
         }
     }
 }
 
+/// 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 }
+    }
+}
+
+impl TiffError {
+    pub(crate) fn from_inflate_status(status: TINFLStatus) -> Self {
+        TiffError::FormatError(TiffFormatError::InflateError(InflateError::new(status)))
+    }
+}
+
 /// 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
@@ -193,29 +174,6 @@ impl fmt::Display for TiffUnsupportedError {
     }
 }
 
-/// User attempted to use the Decoder in a way that is incompatible with a specific image.
-///
-/// For example: attempting to read a tile from a stripped image.
-#[derive(Debug)]
-pub enum UsageError {
-    InvalidChunkType(ChunkType, ChunkType),
-}
-
-impl fmt::Display for UsageError {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use self::UsageError::*;
-        match *self {
-            InvalidChunkType(expected, actual) => {
-                write!(
-                    fmt,
-                    "Requested operation is only valid for images with chunk encoding of type: {:?}, got {:?}.",
-                    expected, actual
-                )
-            }
-        }
-    }
-}
-
 impl fmt::Display for TiffError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match *self {
@@ -229,7 +187,6 @@ impl fmt::Display for TiffError {
             TiffError::IoError(ref e) => e.fmt(fmt),
             TiffError::LimitsExceeded => write!(fmt, "The Decoder limits are exceeded"),
             TiffError::IntSizeError => write!(fmt, "Platform or format size limits exceeded"),
-            TiffError::UsageError(ref e) => write!(fmt, "Usage error: {}", e),
         }
     }
 }
@@ -242,7 +199,6 @@ impl Error for TiffError {
             TiffError::IoError(..) => "IO error",
             TiffError::LimitsExceeded => "Decoder limits exceeded",
             TiffError::IntSizeError => "Platform or format size limits exceeded",
-            TiffError::UsageError(..) => "Invalid usage",
         }
     }
 
@@ -260,12 +216,6 @@ impl From<io::Error> for TiffError {
     }
 }
 
-impl From<str::Utf8Error> for TiffError {
-    fn from(_err: str::Utf8Error) -> TiffError {
-        TiffError::FormatError(TiffFormatError::InvalidTag)
-    }
-}
-
 impl From<string::FromUtf8Error> for TiffError {
     fn from(_err: string::FromUtf8Error) -> TiffError {
         TiffError::FormatError(TiffFormatError::InvalidTag)
@@ -290,15 +240,5 @@ impl From<std::num::TryFromIntError> for TiffError {
     }
 }
 
-impl From<LzwError> for TiffError {
-    fn from(err: LzwError) -> TiffError {
-        match err {
-            LzwError::InvalidCode => TiffError::FormatError(TiffFormatError::Format(String::from(
-                "LZW compressed data corrupted",
-            ))),
-        }
-    }
-}
-
 /// Result of an image decoding/encoding process
 pub type TiffResult<T> = Result<T, TiffError>;

src/lib.rs

@@ -7,6 +7,7 @@
 //! * <https://www.adobe.io/open/standards/TIFF.html> - The TIFF specification
 
 extern crate jpeg;
+extern crate miniz_oxide;
 extern crate weezl;
 
 mod bytecast;
@@ -15,7 +16,7 @@ pub mod encoder;
 mod error;
 pub mod tags;
 
-pub use self::error::{TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError};
+pub use self::error::{InflateError, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError};
 
 /// An enumeration over supported color types and their bit depths
 #[derive(Copy, PartialEq, Eq, Debug, Clone, Hash)]

src/tags.rs

@@ -111,64 +111,35 @@ pub enum Tag(u16) unknown("A private or extension tag") {
     Threshholding = 263, // TODO add support
     XResolution = 282,
     YResolution = 283,
+    // JPEG
+    JPEGTables = 347,
     // Advanced tags
     Predictor = 317,
     TileWidth = 322,
     TileLength = 323,
     TileOffsets = 324,
     TileByteCounts = 325,
-    // Data Sample Format
     SampleFormat = 339,
-    SMinSampleValue = 340, // TODO add support
-    SMaxSampleValue = 341, // TODO add support
-    // JPEG
-    JPEGTables = 347,
-    // GeoTIFF
-    ModelPixelScaleTag = 33550, // (SoftDesk)
-    ModelTransformationTag = 34264, // (JPL Carto Group)
-    ModelTiepointTag = 33922, // (Intergraph)
-    GeoKeyDirectoryTag = 34735, // (SPOT)
-    GeoDoubleParamsTag = 34736, // (SPOT)
-    GeoAsciiParamsTag = 34737, // (SPOT)
-    GdalNodata = 42113, // Contains areas with missing data
 }
 }
 
 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,
 }
 }
 

tests/decode_images.rs

@@ -29,9 +29,7 @@ macro_rules! test_image_sum {
 }
 
 test_image_sum!(test_image_sum_u8, U8, u64);
-test_image_sum!(test_image_sum_i8, I8, i64);
 test_image_sum!(test_image_sum_u16, U16, u64);
-test_image_sum!(test_image_sum_i16, I16, i64);
 test_image_sum!(test_image_sum_u32, U32, u64);
 test_image_sum!(test_image_sum_u64, U64, u64);
 test_image_sum!(test_image_sum_f32, F32, f32);
@@ -137,26 +135,6 @@ fn test_rgb_f32() {
     test_image_sum_f32("gradient-3c-32b-float.tiff", ColorType::RGB(32), 472.8405);
 }
 
-#[test]
-fn test_int8() {
-    test_image_sum_i8("int8.tif", ColorType::Gray(8), 3111)
-}
-
-#[test]
-fn test_int8_rgb() {
-    test_image_sum_i8("int8_rgb.tif", ColorType::RGB(8), -10344)
-}
-
-#[test]
-fn test_int16() {
-    test_image_sum_i16("int16.tif", ColorType::Gray(16), 354396);
-}
-
-#[test]
-fn test_int16_rgb() {
-    test_image_sum_i16("int16_rgb.tif", ColorType::RGB(16), 1063188);
-}
-
 #[test]
 fn test_string_tags() {
     // these files have null-terminated strings for their Software tag. One has extra bytes after
@@ -215,284 +193,3 @@ fn issue_69() {
 //let img_res = decoder.read_image();
 //assert!(img_res.is_ok());
 //}
-
-#[test]
-fn test_tiled_rgb_u8() {
-    test_image_sum_u8("tiled-rgb-u8.tif", ColorType::RGB(8), 39528948);
-}
-
-#[test]
-fn test_tiled_rect_rgb_u8() {
-    test_image_sum_u8("tiled-rect-rgb-u8.tif", ColorType::RGB(8), 62081032);
-}
-
-/* #[test]
-fn test_tiled_jpeg_rgb_u8() {
-    test_image_sum_u8("tiled-jpeg-rgb-u8.tif", ColorType::RGB(8), 93031606);
-} */
-
-#[test]
-fn test_tiled_oversize_gray_i8() {
-    test_image_sum_i8("tiled-oversize-gray-i8.tif", ColorType::Gray(8), 1214996);
-}
-
-#[test]
-fn test_tiled_cmyk_i8() {
-    test_image_sum_i8("tiled-cmyk-i8.tif", ColorType::CMYK(8), 1759101);
-}
-
-#[test]
-fn test_tiled_incremental() {
-    let file = "tiled-rgb-u8.tif";
-    let expected_type = ColorType::RGB(8);
-    let sums = [
-        188760, 195639, 108148, 81986, 665088, 366140, 705317, 423366, 172033, 324455, 244102,
-        81853, 181258, 247971, 129486, 55600, 565625, 422102, 730888, 379271, 232142, 292549,
-        244045, 86866, 188141, 115036, 150785, 84389, 353170, 459325, 719619, 329594, 278663,
-        220474, 243048, 113563, 189152, 109684, 179391, 122188, 279651, 622093, 724682, 302459,
-        268428, 204499, 224255, 124674, 170668, 121868, 192768, 183367, 378029, 585651, 657712,
-        296790, 241444, 197083, 198429, 134869, 182318, 86034, 203655, 182338, 297255, 601284,
-        633813, 242531, 228578, 206441, 193552, 125412, 181527, 165439, 202531, 159538, 268388,
-        565790, 611382, 272967, 236497, 215154, 158881, 90806, 106114, 182342, 191824, 186138,
-        215174, 393193, 701228, 198866, 227944, 193830, 166330, 49008, 55719, 122820, 197316,
-        161969, 203152, 170986, 624427, 188605, 186187, 111064, 115192, 39538, 48626, 163929,
-        144682, 135796, 194141, 154198, 584125, 180255, 153524, 121433, 132641, 35743, 47798,
-        152343, 162874, 167664, 160175, 133038, 659882, 138339, 166470, 124173, 118929, 51317,
-        45267, 155776, 161331, 161006, 130052, 137618, 337291, 106481, 161999, 127343, 87724,
-        59540, 63907, 155677, 140668, 141523, 108061, 168657, 186482, 98599, 147614, 139963, 90444,
-        56602, 92547, 125644, 134212, 126569, 144153, 179800, 174516, 133969, 129399, 117681,
-        83305, 55075, 110737, 115108, 128572, 128911, 130922, 179986, 143288, 145884, 155856,
-        96683, 94057, 56238, 79649, 71651, 70182, 75010, 77009, 98855, 78979, 74341, 83482, 53403,
-        59842, 30305,
-    ];
-
-    let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
-    let img_file = File::open(path).expect("Cannot find test image!");
-    let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
-    assert_eq!(decoder.colortype().unwrap(), expected_type);
-
-    let tiles = decoder.tile_count().unwrap();
-    assert_eq!(tiles as usize, sums.len());
-
-    for tile in 0..tiles {
-        match decoder.read_tile().unwrap() {
-            DecodingResult::U8(res) => {
-                let sum: u64 = res.into_iter().map(<u64>::from).sum();
-                assert_eq!(sum, sums[tile as usize]);
-            }
-            _ => panic!("Wrong bit depth"),
-        }
-    }
-}
-
-#[test]
-fn test_div_zero() {
-    use tiff::{TiffError, TiffFormatError};
-
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 40, 1, 0, 0,
-        0, 158, 0, 0, 251, 3, 1, 3, 0, 1, 0, 0, 0, 1, 0, 0, 39, 6, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-        17, 1, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 3, 0, 1, 0, 0, 0, 158, 0, 0, 251, 67, 1, 3, 0,
-        1, 0, 0, 0, 40, 0, 0, 0, 66, 1, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 178, 178, 178, 178,
-        178, 178, 178,
-    ];
-
-    let err = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
-
-    match err {
-        TiffError::FormatError(TiffFormatError::StripTileTagConflict) => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
-}
-
-#[test]
-fn test_too_many_value_bytes() {
-    let image = [
-        73, 73, 43, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 8, 0, 0, 0,
-        23, 0, 12, 0, 0, 65, 4, 0, 1, 6, 0, 0, 1, 16, 0, 1, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0,
-        0, 0, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0, 59, 73, 84, 186, 202, 83, 240, 66, 1, 53, 22, 56, 47,
-        0, 0, 0, 0, 0, 0, 1, 222, 4, 0, 58, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 4, 0, 0, 100, 0,
-        0, 89, 89, 89, 89, 89, 89, 89, 89, 96, 1, 20, 89, 89, 89, 89, 18,
-    ];
-
-    let error = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
-
-    match error {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
-}
-
-#[test]
-fn test_bad_strip_count() {
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 100, 0, 0, 0, 1, 1, 4, 0, 1, 0, 0,
-        0, 158, 0, 0, 251, 3, 1, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-        17, 1, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 3, 0, 0, 0, 0, 0, 246, 16, 0, 0, 22, 1, 4, 0, 1,
-        0, 0, 0, 40, 0, 251, 255, 23, 1, 4, 0, 1, 0, 0, 0, 48, 178, 178, 178, 178, 178, 178, 178,
-        178, 178, 178,
-    ];
-
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::IntSizeError => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
-}
-
-#[test]
-fn fuzzer_testcase1() {
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 99, 255, 255, 254, 1, 1, 4, 0, 1,
-        0, 0, 0, 158, 0, 0, 251, 3, 1, 3, 255, 254, 255, 255, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0,
-        0, 0, 0, 0, 0, 17, 1, 4, 0, 9, 0, 0, 0, 0, 0, 0, 0, 2, 1, 3, 0, 2, 0, 0, 0, 63, 0, 0, 0,
-        22, 1, 4, 0, 1, 0, 0, 0, 44, 0, 0, 0, 23, 1, 4, 0, 0, 0, 0, 0, 0, 0, 2, 1, 3, 1, 0, 178,
-        178,
-    ];
-
-    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
-}
-
-#[test]
-fn test_stripped_image_overflow() {
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 100, 0, 0, 148, 1, 1, 4, 0, 1, 0,
-        0, 0, 158, 0, 0, 251, 3, 1, 3, 255, 254, 255, 255, 0, 1, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0,
-        0, 0, 0, 0, 17, 1, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 3, 0, 2, 0, 0, 0, 63, 0, 0, 0, 22,
-        1, 4, 0, 1, 0, 0, 0, 44, 0, 248, 255, 23, 1, 4, 0, 1, 0, 0, 0, 178, 178, 178, 0, 1, 178,
-        178, 178,
-    ];
-
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
-}
-
-#[test]
-fn oom() {
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 40, 1, 0, 0,
-        0, 158, 0, 0, 251, 3, 1, 3, 0, 1, 0, 0, 0, 7, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0, 2, 0, 0, 0,
-        17, 1, 4, 0, 1, 0, 0, 0, 3, 77, 0, 0, 1, 1, 3, 0, 1, 0, 0, 0, 3, 128, 0, 0, 22, 1, 4, 0, 1,
-        0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 178, 48, 178, 178, 178, 178, 162, 178,
-    ];
-
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
-}
-
-#[test]
-fn oom_2() {
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 40, 1, 0, 0,
-        0, 158, 0, 0, 251, 3, 1, 3, 0, 1, 0, 0, 0, 5, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-        17, 1, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 3, 0, 1, 0, 0, 0, 3, 128, 0, 0, 22, 1, 4, 0, 1,
-        0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 48, 178, 178, 178, 0, 1, 0, 13, 13,
-    ];
-
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        tiff::TiffError::LimitsExceeded => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
-}
-
-#[test]
-fn fuzzer_testcase2() {
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 15, 0, 0, 254, 44, 1, 0, 0, 0, 0, 0, 32, 0, 0, 0, 1, 4, 0, 1, 0,
-        0, 0, 0, 1, 0, 0, 91, 1, 1, 0, 0, 0, 0, 0, 242, 4, 0, 0, 0, 22, 0, 56, 77, 0, 77, 1, 0, 0,
-        73, 42, 0, 1, 4, 0, 1, 0, 0, 0, 4, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 158, 0, 0, 251, 3, 1,
-        3, 0, 1, 0, 0, 0, 7, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0, 2, 0, 0, 0, 17, 1, 4, 0, 1, 0, 0, 0,
-        0, 0, 0, 0, 1, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 4, 61, 1, 18, 0, 1, 0, 0, 0, 202, 0, 0, 0, 17,
-        1, 100, 0, 129, 0, 0, 0, 0, 0, 0, 0, 232, 254, 252, 255, 254, 255, 255, 255, 1, 29, 0, 0,
-        22, 1, 3, 0, 1, 0, 0, 0, 16, 0, 0, 0, 23, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 123, 73, 254, 0,
-        73,
-    ];
-
-    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
-}
-
-#[test]
-fn invalid_jpeg_tag_2() {
-    use tiff::tags;
-    use tiff::{TiffError, TiffFormatError};
-
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 16, 0, 254, 0, 4, 0, 1, 0, 0, 0, 0, 0, 0, 242, 0, 1, 4, 0, 1, 0,
-        0, 0, 0, 129, 16, 0, 1, 1, 4, 0, 1, 0, 0, 0, 214, 0, 0, 248, 253, 1, 3, 0, 1, 0, 0, 0, 64,
-        0, 0, 0, 3, 1, 3, 0, 1, 0, 0, 0, 7, 0, 0, 0, 6, 1, 3, 0, 1, 0, 0, 0, 1, 0, 0, 64, 14, 1, 0,
-        2, 0, 0, 148, 0, 206, 0, 0, 0, 17, 1, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-        1, 0, 0, 0, 22, 1, 4, 0, 17, 0, 0, 201, 1, 0, 0, 0, 23, 1, 2, 0, 20, 0, 0, 0, 194, 0, 0, 0,
-        91, 1, 7, 0, 5, 0, 0, 0, 64, 0, 0, 0, 237, 254, 65, 255, 255, 255, 255, 255, 1, 0, 0, 0,
-        22, 1, 4, 0, 1, 0, 0, 0, 42, 0, 0, 0, 23, 1, 255, 255, 255, 255, 255, 36, 36, 0, 0, 0, 0,
-        0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 36, 73, 73, 0, 42, 36, 36, 36, 36, 0, 0, 8, 0,
-    ];
-
-    let mut decoder = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap();
-
-    let err = decoder.read_image().unwrap_err();
-
-    match err {
-        TiffError::FormatError(TiffFormatError::InvalidTagValueType(tags::Tag::JPEGTables)) => {}
-        unexpected => panic!("Unexpected error {}", unexpected),
-    }
-}
-
-#[test]
-fn fuzzer_testcase3() {
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 2, 0, 0, 0, 61, 1, 9, 0, 46, 22,
-        128, 0, 0, 0, 0, 1, 6, 1, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 17, 1, 4, 0, 27, 0, 0, 0, 0, 0, 0,
-        0, 1, 1, 3, 0, 1, 0, 0, 0, 17, 1, 0, 231, 22, 1, 1, 0, 1, 0, 0, 0, 130, 0, 0, 0, 23, 1, 4,
-        0, 14, 0, 0, 0, 0, 0, 0, 0, 133, 133, 133, 77, 77, 77, 0, 0, 22, 128, 0, 255, 255, 255,
-        255, 255,
-    ];
-
-    let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
-}
-
-#[test]
-fn timeout() {
-    use tiff::{TiffError, TiffFormatError};
-
-    let image = [
-        73, 73, 42, 0, 8, 0, 0, 0, 16, 0, 254, 0, 4, 0, 1, 68, 0, 0, 0, 2, 0, 32, 254, 252, 0, 109,
-        0, 129, 0, 0, 0, 32, 0, 58, 0, 1, 4, 0, 1, 0, 6, 0, 0, 0, 8, 0, 0, 1, 73, 73, 42, 0, 8, 0,
-        0, 0, 8, 0, 0, 1, 4, 0, 1, 0, 0, 0, 21, 0, 0, 0, 61, 1, 255, 128, 9, 0, 0, 8, 0, 1, 113, 2,
-        3, 1, 3, 0, 1, 0, 0, 0, 5, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 112, 0, 0, 36, 0, 0,
-        0, 112, 56, 200, 0, 5, 0, 0, 64, 0, 0, 1, 0, 4, 0, 0, 0, 2, 0, 6, 1, 3, 0, 1, 0, 0, 0, 0,
-        0, 0, 4, 17, 1, 1, 0, 93, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 3, 6, 0, 231, 22, 1,
-        1, 0, 1, 0, 0, 0, 2, 64, 118, 36, 23, 1, 1, 0, 43, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 8,
-        0, 0, 73, 73, 42, 0, 8, 0, 0, 0, 0, 0, 32,
-    ];
-
-    let error = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err();
-
-    match error {
-        TiffError::FormatError(TiffFormatError::CycleInOffsets) => {}
-        e => panic!("Unexpected error {:?}", e),
-    }
-}
-
-#[test]
-fn test_no_rows_per_strip() {
-    test_image_sum_u8("no_rows_per_strip.tiff", ColorType::RGB(8), 99448840);
-}

tests/encode_images.rs

@@ -1,7 +1,7 @@
 extern crate tiff;
 
 use tiff::decoder::{ifd, Decoder, DecodingResult};
-use tiff::encoder::{colortype, Ifd, Ifd8, SRational, TiffEncoder};
+use tiff::encoder::{colortype, SRational, TiffEncoder};
 use tiff::tags::Tag;
 use tiff::ColorType;
 
@@ -48,92 +48,6 @@ 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::new(&mut file).unwrap();
-        assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
-        assert_eq!(decoder.dimensions().unwrap(), (100, 100));
-        assert_eq!(
-            decoder.get_tag(Tag::Artist).unwrap(),
-            ifd::Value::Ascii("Image-tiff".into())
-        );
-        if let DecodingResult::U8(img_res) = decoder.read_image().unwrap() {
-            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();
-        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::new(&mut data).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.
@@ -268,10 +182,6 @@ trait AssertDecode {
     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> {
@@ -293,24 +203,6 @@ impl<R: std::io::Read + std::io::Seek> AssertDecode for Decoder<R> {
             .into_i32_vec()
             .unwrap()
     }
-    fn assert_tag_u64(&mut self, tag: u16) -> u64 {
-        self.get_tag(Tag::Unknown(tag)).unwrap().into_u64().unwrap()
-    }
-    fn assert_tag_u64_vec(&mut self, tag: u16) -> Vec<u64> {
-        self.get_tag(Tag::Unknown(tag))
-            .unwrap()
-            .into_u64_vec()
-            .unwrap()
-    }
-    fn assert_tag_i64(&mut self, tag: u16) -> i64 {
-        self.get_tag(Tag::Unknown(tag)).unwrap().into_i64().unwrap()
-    }
-    fn assert_tag_i64_vec(&mut self, tag: u16) -> Vec<i64> {
-        self.get_tag(Tag::Unknown(tag))
-            .unwrap()
-            .into_i64_vec()
-            .unwrap()
-    }
 }
 
 #[test]
@@ -397,20 +289,12 @@ fn test_signed() {
             .write_tag(Tag::Unknown(65022), &[-1_i32, 2][..])
             .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))
+            .write_tag(Tag::Unknown(65030), make_srational(-1))
             .unwrap();
         encoder
             .write_tag(
-                Tag::Unknown(65041),
+                Tag::Unknown(65031),
                 &[make_srational(-1), make_srational(2)][..],
             )
             .unwrap();
@@ -437,12 +321,8 @@ fn test_signed() {
         assert_eq!(decoder.assert_tag_i32_vec(65021), [-1]);
         assert_eq!(decoder.assert_tag_i32_vec(65022), [-1, 2]);
 
-        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]);
+        assert_eq!(decoder.assert_tag_i32_vec(65030), [-1, 100]);
+        assert_eq!(decoder.assert_tag_i32_vec(65031), [-1_i32, 100, 2, 100]);
     }
 }
 
@@ -480,42 +360,3 @@ fn test_multipage_image() {
         assert_eq!(img_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::new(&mut file).unwrap();
-        assert_eq!(decoder.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_strip().unwrap() {
-                DecodingResult::U8(data) => assert_eq!(&img2[..], &data[..]),
-                other => panic!("Incorrect strip type {:?}", other),
-            }
-        }
-    }
-}

tests/encode_images_with_compression.rs

@@ -1,157 +0,0 @@
-extern crate tiff;
-
-use std::io::{Cursor, Seek, Write};
-use tiff::{
-    decoder::{Decoder, DecodingResult},
-    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<C: Compression, W: Write + Seek>(
-        &self,
-        encoder: &mut TiffEncoder<W>,
-        compression: C,
-    ) where
-        [<Self::Color as ColorType>::Inner]: TiffValue,
-    {
-        let image = encoder
-            .new_image_with_compression::<Self::Color, C>(Self::WIDTH, Self::HEIGHT, compression)
-            .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<C: Compression + Clone>(compression: C) {
-    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();
-        image_rgb.compress(&mut encoder, compression.clone());
-        image_grayscale.compress(&mut encoder, compression);
-    }
-
-    // Decode tiff
-    data.set_position(0);
-    {
-        let mut decoder = Decoder::new(data).unwrap();
-
-        // Check the RGB image
-        assert_eq!(
-            match decoder.read_image() {
-                Ok(DecodingResult::U16(image_data)) => image_data,
-                unexpected => panic!("Descoding RGB failed: {:?}", unexpected),
-            },
-            image_rgb.reference_data()
-        );
-
-        // Check the grayscale image
-        decoder.next_image().unwrap();
-        assert_eq!(
-            match decoder.read_image() {
-                Ok(DecodingResult::U8(image_data)) => image_data,
-                unexpected => panic!("Decoding grayscale failed: {:?}", unexpected),
-            },
-            image_grayscale.reference_data()
-        );
-    }
-}
-
-#[test]
-fn encode_decode_without_compression() {
-    encode_decode_with_compression(Uncompressed::default());
-}
-
-#[test]
-fn encode_decode_with_lzw() {
-    encode_decode_with_compression(Lzw::default());
-}
-
-#[test]
-fn encode_decode_with_deflate() {
-    encode_decode_with_compression(Deflate::with_level(DeflateLevel::Fast));
-    encode_decode_with_compression(Deflate::with_level(DeflateLevel::Balanced));
-    encode_decode_with_compression(Deflate::with_level(DeflateLevel::Best));
-}
-
-#[test]
-fn encode_decode_with_packbits() {
-    encode_decode_with_compression(Packbits::default());
-}