Add checkpoint, storing an IFD offset of a tiff

Release 0.6.0

.github/workflows/rust.yml

@@ -0,0 +1,40 @@
+name: Rust CI
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust: ["1.34.2", stable, beta, nightly]
+        command: [build, test]
+    steps:
+    - uses: actions/checkout@v2
+    - run: rustup default ${{ matrix.rust }}
+    - name: build
+      run: >
+        cargo build --verbose --no-default-features --features "$FEATURES"
+    - name: test
+      run: >
+        cargo test --tests --benches --no-default-features --features "$FEATURES"
+      if: ${{ matrix.rust != '1.34.2' }}
+      env:
+        FEATURES: ${{ matrix.features }}
+  rustfmt:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        override: true
+        components: rustfmt
+    - name: Run rustfmt check
+      uses: actions-rs/cargo@v1
+      with:
+        command: fmt
+        args: -- --check
+

.travis.yml

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

CHANGES.md

@@ -1,11 +1,19 @@
-# Version 0.6.0-alpha
+# Version 0.6.0
 
+New features:
 * Support for decoding BigTIFF with 64-bit offsets
+* The value types byte, `f32`, `f64` are now recognized
+* Support for Modern JPEG encoded images
+
+Improvements:
 * Better support for adding auxiliary tags before encoding image data
+* Switched to lzw decoder library `weezl` for performance
+* The `ColorType` trait now supports `SAMPLE_ENCODING` hints
+
+Fixes:
 * Fixed decoding of inline ASCII in tags
 * Fixed handling after null terminator in ASCII data
 * Recognize tile and sample format tags
-* Note: these notes will be merged into 0.6.0 when it is released
 
 # Version 0.5.0
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tiff"
-version = "0.6.0-alpha"
+version = "0.6.0"
 authors = [
     "ccgn",
     "bvssvni <bvssvni@gmail.com>",
@@ -17,6 +17,16 @@ repository = "https://github.com/image-rs/image-tiff"
 exclude = ["tests/images/*", "tests/fuzz_images/*"]
 
 [dependencies]
-byteorder = "1.2"
-lzw = "0.10"
-miniz_oxide = "0.3"
+weezl = "0.1.0"
+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"
+
+[[bench]]
+name = "lzw"
+harness = false

README.md

@@ -10,6 +10,7 @@ TIFF decoding and encoding library in pure Rust
 ### Features
 - Baseline spec (other than formats and tags listed below as not supported)
 - Multipage
+- BigTIFF
 - Incremental decoding
 
 ### Formats
@@ -17,12 +18,12 @@ This table lists photometric interpretations and sample formats which are suppor
 
 | `PhotometricInterpretation` | UINT Format | IEEEFP Format |
 |-|-|-|
-| `WhiteIsZero` | Gray(8\|16\|32\|64) | |
-| `BlackIsZero` | Gray(8\|16\|32\|64) | |
-| `RGB` | RGB(8\|16\|32\|64), RGBA(8\|16\|32\|64) | |
+| `WhiteIsZero` | Gray(8\|16\|32\|64) | Gray(32\|64) |
+| `BlackIsZero` | Gray(8\|16\|32\|64) | Gray(32\|64) |
+| `RGB` | RGB(8\|16\|32\|64), RGBA(8\|16\|32\|64) | RGB(32\|64), RGBA(32\|64) |
 | `RGBPalette` | | |
 | `Mask` | | |
-| `CMYK` | CMYK(8\|16\|32\|64) | |
+| `CMYK` | CMYK(8\|16\|32\|64) | CMYK(32\|64) |
 | `YCbCr` | | |
 | `CIELab` | | |
 
@@ -43,4 +44,3 @@ Formats and interpretations not listed above or with empty entries are unsupport
 - Baseline tags
   - `ExtraSamples`
 - Extension tags
-- BigTIFF

benches/lzw.rs

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

src/bytecast.rs

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

@@ -1,7 +1,7 @@
 //! Function for reading TIFF tags
 
 use std::collections::HashMap;
-use std::convert::{TryInto, TryFrom};
+use std::convert::{TryFrom, TryInto};
 use std::io::{self, Read, Seek};
 use std::mem;
 
@@ -9,16 +9,21 @@ use super::stream::{ByteOrder, EndianReader, SmartReader};
 use tags::{Tag, Type};
 use {TiffError, TiffFormatError, TiffResult, TiffUnsupportedError};
 
-use self::Value::{Ascii, List, Rational, Unsigned, Signed, SRational, RationalBig, UnsignedBig, SignedBig, SRationalBig};
-
+use self::Value::{
+    Ascii, Byte, Double, Float, List, Rational, RationalBig, SRational, SRationalBig, Signed,
+    SignedBig, Unsigned, UnsignedBig,
+};
 
 #[allow(unused_qualifications)]
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Value {
+    Byte(u8),
     Signed(i32),
     SignedBig(i64),
     Unsigned(u32),
     UnsignedBig(u64),
+    Float(f32),
+    Double(f64),
     List(Vec<Value>),
     Rational(u32, u32),
     RationalBig(u64, u64),
@@ -30,6 +35,13 @@ pub enum Value {
 }
 
 impl Value {
+    pub fn into_u8(self) -> TiffResult<u8> {
+        match self {
+            Byte(val) => Ok(val),
+            val => Err(TiffError::FormatError(TiffFormatError::ByteExpected(val))),
+        }
+    }
+
     pub fn into_u32(self) -> TiffResult<u32> {
         match self {
             Unsigned(val) => Ok(val),
@@ -70,6 +82,24 @@ impl Value {
         }
     }
 
+    pub fn into_f32(self) -> TiffResult<f32> {
+        match self {
+            Float(val) => Ok(val),
+            val => Err(TiffError::FormatError(
+                TiffFormatError::SignedIntegerExpected(val),
+            )),
+        }
+    }
+
+    pub fn into_f64(self) -> TiffResult<f64> {
+        match self {
+            Double(val) => Ok(val),
+            val => Err(TiffError::FormatError(
+                TiffFormatError::SignedIntegerExpected(val),
+            )),
+        }
+    }
+
     pub fn into_u32_vec(self) -> TiffResult<Vec<u32>> {
         match self {
             List(vec) => {
@@ -82,7 +112,9 @@ impl Value {
             Unsigned(val) => Ok(vec![val]),
             UnsignedBig(val) => Ok(vec![u32::try_from(val)?]),
             Rational(numerator, denominator) => Ok(vec![numerator, denominator]),
-            RationalBig(numerator, denominator) => Ok(vec![u32::try_from(numerator)?, u32::try_from(denominator)?]),
+            RationalBig(numerator, denominator) => {
+                Ok(vec![u32::try_from(numerator)?, u32::try_from(denominator)?])
+            }
             Ascii(val) => Ok(val.chars().map(u32::from).collect()),
             val => Err(TiffError::FormatError(
                 TiffFormatError::UnsignedIntegerExpected(val),
@@ -90,6 +122,23 @@ impl Value {
         }
     }
 
+    pub fn into_u8_vec(self) -> TiffResult<Vec<u8>> {
+        match self {
+            List(vec) => {
+                let mut new_vec = Vec::with_capacity(vec.len());
+                for v in vec {
+                    new_vec.push(v.into_u8()?)
+                }
+                Ok(new_vec)
+            }
+            Byte(val) => Ok(vec![val]),
+
+            val => Err(TiffError::FormatError(
+                TiffFormatError::UnsignedIntegerExpected(val),
+            )),
+        }
+    }
+
     pub fn into_i32_vec(self) -> TiffResult<Vec<i32>> {
         match self {
             List(vec) => {
@@ -112,13 +161,47 @@ impl Value {
             Signed(val) => Ok(vec![val]),
             SignedBig(val) => Ok(vec![i32::try_from(val)?]),
             SRational(numerator, denominator) => Ok(vec![numerator, denominator]),
-            SRationalBig(numerator, denominator) => Ok(vec![i32::try_from(numerator)?, i32::try_from(denominator)?]),
+            SRationalBig(numerator, denominator) => {
+                Ok(vec![i32::try_from(numerator)?, i32::try_from(denominator)?])
+            }
             val => Err(TiffError::FormatError(
                 TiffFormatError::SignedIntegerExpected(val),
             )),
         }
     }
 
+    pub fn into_f32_vec(self) -> TiffResult<Vec<f32>> {
+        match self {
+            List(vec) => {
+                let mut new_vec = Vec::with_capacity(vec.len());
+                for v in vec {
+                    new_vec.push(v.into_f32()?)
+                }
+                Ok(new_vec)
+            }
+            Float(val) => Ok(vec![val]),
+            val => Err(TiffError::FormatError(
+                TiffFormatError::UnsignedIntegerExpected(val),
+            )),
+        }
+    }
+
+    pub fn into_f64_vec(self) -> TiffResult<Vec<f64>> {
+        match self {
+            List(vec) => {
+                let mut new_vec = Vec::with_capacity(vec.len());
+                for v in vec {
+                    new_vec.push(v.into_f64()?)
+                }
+                Ok(new_vec)
+            }
+            Double(val) => Ok(vec![val]),
+            val => Err(TiffError::FormatError(
+                TiffFormatError::UnsignedIntegerExpected(val),
+            )),
+        }
+    }
+
     pub fn into_u64_vec(self) -> TiffResult<Vec<u64>> {
         match self {
             List(vec) => {
@@ -168,7 +251,7 @@ impl Value {
         }
     }
 }
-    
+
 #[derive(Clone)]
 pub struct Entry {
     type_: Type,
@@ -257,17 +340,11 @@ impl Entry {
                 }
                 (Type::LONG, 2) => {
                     let mut r = self.r(bo);
-                    Some(List(vec![
-                        Unsigned(r.read_u32()?),
-                        Unsigned(r.read_u32()?),
-                    ]))
+                    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()?),
-                    ]))
+                    Some(List(vec![Signed(r.read_i32()?), Signed(r.read_i32()?)]))
                 }
                 (Type::RATIONAL, 1) => {
                     let mut r = self.r(bo);
@@ -281,7 +358,7 @@ impl Entry {
                     let denominator = r.read_i32()?;
                     Some(SRational(numerator, denominator))
                 }
-                _ => None
+                _ => None,
             }
         } else {
             None
@@ -337,6 +414,12 @@ impl Entry {
                 (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()?))
                 }),
@@ -351,10 +434,10 @@ impl Entry {
                     if n > limits.decoding_buffer_size {
                         return Err(TiffError::LimitsExceeded);
                     }
-                    
+
                     if (n <= 4 && !decoder.bigtiff) || (n <= 8 && decoder.bigtiff) {
                         let mut buf = vec![0; n];
-                        self.r(bo).read_exact(&mut buf )?;
+                        self.r(bo).read_exact(&mut buf)?;
                         let v = String::from_utf8(buf)?;
                         let v = v.trim_matches(char::from(0));
                         Ok(Ascii(v.into()))
@@ -368,6 +451,9 @@ impl Entry {
                         Ok(Ascii(string))
                     }
                 }
+                (Type::UNDEFINED, n) => self.decode_offset(n, bo, limits, decoder, |decoder| {
+                    Ok(Byte(u8::from(decoder.read_byte()?)))
+                }),
                 _ => Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::UnsupportedDataType,
                 )),
@@ -376,10 +462,17 @@ impl Entry {
     }
 
     #[inline]
-    fn decode_offset<R, F>(&self, value_count: u64, bo: ByteOrder, limits: &super::Limits, decoder: &mut super::Decoder<R>, decode_fn: F) -> TiffResult<Value>
-        where
-            R: Read + Seek,
-            F: Fn(&mut super::Decoder<R>) -> TiffResult<Value>,
+    fn decode_offset<R, F>(
+        &self,
+        value_count: u64,
+        bo: ByteOrder,
+        limits: &super::Limits,
+        decoder: &mut super::Decoder<R>,
+        decode_fn: F,
+    ) -> TiffResult<Value>
+    where
+        R: Read + Seek,
+        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>() {
@@ -406,7 +499,7 @@ fn offset_to_bytes(n: usize, entry: &Entry) -> TiffResult<Value> {
         entry.offset[0..n]
             .iter()
             .map(|&e| Unsigned(u32::from(e)))
-            .collect()
+            .collect(),
     ))
 }
 
@@ -417,7 +510,7 @@ fn offset_to_sbytes(n: usize, entry: &Entry) -> TiffResult<Value> {
         entry.offset[0..n]
             .iter()
             .map(|&e| Signed(i32::from(e as i8)))
-            .collect()
+            .collect(),
     ))
 }
 

src/decoder/mod.rs

@@ -1,14 +1,16 @@
-use std::convert::TryFrom;
-use std::collections::HashMap;
-use std::io::{self, Read, Seek};
 use std::cmp;
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::io::{self, Read, Seek};
 
 use {ColorType, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError};
 
 use self::ifd::Directory;
-use tags::{CompressionMethod, PhotometricInterpretation, Predictor, Tag, Type};
+use tags::{CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag, Type};
 
-use self::stream::{ByteOrder, EndianReader, LZWReader, DeflateReader, PackBitsReader, SmartReader};
+use self::stream::{
+    ByteOrder, DeflateReader, EndianReader, JpegReader, LZWReader, PackBitsReader, SmartReader,
+};
 
 pub mod ifd;
 mod stream;
@@ -24,6 +26,10 @@ pub enum DecodingResult {
     U32(Vec<u32>),
     /// A vector of 64 bit unsigned ints
     U64(Vec<u64>),
+    /// A vector of 32 bit IEEE floats
+    F32(Vec<f32>),
+    /// A vector of 64 bit IEEE floats
+    F64(Vec<f64>),
 }
 
 impl DecodingResult {
@@ -59,12 +65,30 @@ impl DecodingResult {
         }
     }
 
+    fn new_f32(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
+        if size > limits.decoding_buffer_size / std::mem::size_of::<f32>() {
+            Err(TiffError::LimitsExceeded)
+        } else {
+            Ok(DecodingResult::F32(vec![0.0; size]))
+        }
+    }
+
+    fn new_f64(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
+        if size > limits.decoding_buffer_size / std::mem::size_of::<f64>() {
+            Err(TiffError::LimitsExceeded)
+        } else {
+            Ok(DecodingResult::F64(vec![0.0; size]))
+        }
+    }
+
     pub fn as_buffer(&mut self, start: usize) -> DecodingBuffer {
         match *self {
             DecodingResult::U8(ref mut buf) => DecodingBuffer::U8(&mut buf[start..]),
             DecodingResult::U16(ref mut buf) => DecodingBuffer::U16(&mut buf[start..]),
             DecodingResult::U32(ref mut buf) => DecodingBuffer::U32(&mut buf[start..]),
             DecodingResult::U64(ref mut buf) => DecodingBuffer::U64(&mut buf[start..]),
+            DecodingResult::F32(ref mut buf) => DecodingBuffer::F32(&mut buf[start..]),
+            DecodingResult::F64(ref mut buf) => DecodingBuffer::F64(&mut buf[start..]),
         }
     }
 }
@@ -79,6 +103,10 @@ pub enum DecodingBuffer<'a> {
     U32(&'a mut [u32]),
     /// A slice of 64 bit unsigned ints
     U64(&'a mut [u64]),
+    /// A slice of 32 bit IEEE floats
+    F32(&'a mut [f32]),
+    /// A slice of 64 bit IEEE floats
+    F64(&'a mut [f64]),
 }
 
 impl<'a> DecodingBuffer<'a> {
@@ -88,6 +116,8 @@ impl<'a> DecodingBuffer<'a> {
             DecodingBuffer::U16(ref buf) => buf.len(),
             DecodingBuffer::U32(ref buf) => buf.len(),
             DecodingBuffer::U64(ref buf) => buf.len(),
+            DecodingBuffer::F32(ref buf) => buf.len(),
+            DecodingBuffer::F64(ref buf) => buf.len(),
         }
     }
 
@@ -97,6 +127,8 @@ impl<'a> DecodingBuffer<'a> {
             DecodingBuffer::U16(_) => 2,
             DecodingBuffer::U32(_) => 4,
             DecodingBuffer::U64(_) => 8,
+            DecodingBuffer::F32(_) => 4,
+            DecodingBuffer::F64(_) => 8,
         }
     }
 
@@ -109,6 +141,8 @@ impl<'a> DecodingBuffer<'a> {
             DecodingBuffer::U16(ref mut buf) => DecodingBuffer::U16(buf),
             DecodingBuffer::U32(ref mut buf) => DecodingBuffer::U32(buf),
             DecodingBuffer::U64(ref mut buf) => DecodingBuffer::U64(buf),
+            DecodingBuffer::F32(ref mut buf) => DecodingBuffer::F32(buf),
+            DecodingBuffer::F64(ref mut buf) => DecodingBuffer::F64(buf),
         }
     }
 }
@@ -131,6 +165,9 @@ pub struct Limits {
     /// The maximum size of any ifd value in bytes, the default is
     /// 1MiB.
     pub ifd_value_size: usize,
+    /// Maximum size for intermediate buffer which may be used to limit the amount of data read per
+    /// segment even if the entire image is decoded at once.
+    pub intermediate_buffer_size: usize,
     /// The purpose of this is to prevent all the fields of the struct from
     /// being public, as this would make adding new fields a major version
     /// bump.
@@ -141,6 +178,7 @@ impl Default for Limits {
     fn default() -> Limits {
         Limits {
             decoding_buffer_size: 256 * 1024 * 1024,
+            intermediate_buffer_size: 128 * 1024 * 1024,
             ifd_value_size: 1024 * 1024,
             _non_exhaustive: (),
         }
@@ -160,16 +198,23 @@ where
     bigtiff: bool,
     limits: Limits,
     next_ifd: Option<u64>,
+    current_ifd: Option<u64>,
     ifd: Option<Directory>,
     width: u32,
     height: u32,
     bits_per_sample: Vec<u8>,
     samples: u8,
+    sample_format: Vec<SampleFormat>,
     photometric_interpretation: PhotometricInterpretation,
     compression_method: CompressionMethod,
     strip_decoder: Option<StripDecodeState>,
 }
 
+/// Stores state necessary to seek back (or forward) to particular part of the tiff.
+pub struct Checkpoint {
+    offset: u64,
+}
+
 trait Wrapping {
     fn wrapping_add(&self, other: Self) -> Self;
 }
@@ -218,8 +263,14 @@ fn rev_hpredict(image: DecodingBuffer, size: (u32, u32), color_type: ColorType)
     let samples = match color_type {
         ColorType::Gray(8) | ColorType::Gray(16) | ColorType::Gray(32) | ColorType::Gray(64) => 1,
         ColorType::RGB(8) | ColorType::RGB(16) | ColorType::RGB(32) | ColorType::RGB(64) => 3,
-        ColorType::RGBA(8) | ColorType::RGBA(16) | ColorType::RGBA(32) | ColorType::RGBA(64)
-        | ColorType::CMYK(8) | ColorType::CMYK(16) | ColorType::CMYK(32) | ColorType::CMYK(64) => 4,
+        ColorType::RGBA(8)
+        | ColorType::RGBA(16)
+        | ColorType::RGBA(32)
+        | ColorType::RGBA(64)
+        | ColorType::CMYK(8)
+        | ColorType::CMYK(16)
+        | ColorType::CMYK(32)
+        | ColorType::CMYK(64) => 4,
         _ => {
             return Err(TiffError::UnsupportedError(
                 TiffUnsupportedError::HorizontalPredictor(color_type),
@@ -239,6 +290,22 @@ fn rev_hpredict(image: DecodingBuffer, size: (u32, u32), color_type: ColorType)
         DecodingBuffer::U64(buf) => {
             rev_hpredict_nsamp(buf, size, samples)?;
         }
+        DecodingBuffer::F32(_buf) => {
+            // FIXME: check how this is defined.
+            // See issue #89.
+            // rev_hpredict_nsamp(buf, size, samples)?;
+            return Err(TiffError::UnsupportedError(
+                TiffUnsupportedError::HorizontalPredictor(color_type),
+            ));
+        }
+        DecodingBuffer::F64(_buf) => {
+            //FIXME: check how this is defined.
+            // See issue #89.
+            // rev_hpredict_nsamp(buf, size, samples)?;
+            return Err(TiffError::UnsupportedError(
+                TiffUnsupportedError::HorizontalPredictor(color_type),
+            ));
+        }
     }
     Ok(())
 }
@@ -252,11 +319,13 @@ impl<R: Read + Seek> Decoder<R> {
             bigtiff: false,
             limits: Default::default(),
             next_ifd: None,
+            current_ifd: None,
             ifd: None,
             width: 0,
             height: 0,
             bits_per_sample: vec![1],
             samples: 1,
+            sample_format: vec![SampleFormat::Uint],
             photometric_interpretation: PhotometricInterpretation::BlackIsZero,
             compression_method: CompressionMethod::None,
             strip_decoder: None,
@@ -275,28 +344,24 @@ impl<R: Read + Seek> Decoder<R> {
 
     pub fn colortype(&mut self) -> TiffResult<ColorType> {
         match self.photometric_interpretation {
-            PhotometricInterpretation::RGB  => {
-                match self.bits_per_sample[..] {
-                    [r, g, b] if [r, r] == [g, b] => Ok(ColorType::RGB(r)),
-                    [r, g, b, a] if [r, r, r] == [g, b, a] => Ok(ColorType::RGBA(r)),
-                    _ => Err(TiffError::UnsupportedError(
-                        TiffUnsupportedError::InterpretationWithBits(
-                            self.photometric_interpretation,
-                            self.bits_per_sample.clone(),
-                        ),
-                    )),
-                }
+            PhotometricInterpretation::RGB => match self.bits_per_sample[..] {
+                [r, g, b] if [r, r] == [g, b] => Ok(ColorType::RGB(r)),
+                [r, g, b, a] if [r, r, r] == [g, b, a] => Ok(ColorType::RGBA(r)),
+                _ => Err(TiffError::UnsupportedError(
+                    TiffUnsupportedError::InterpretationWithBits(
+                        self.photometric_interpretation,
+                        self.bits_per_sample.clone(),
+                    ),
+                )),
             },
-            PhotometricInterpretation::CMYK => {
-                match self.bits_per_sample[..] {
-                    [c, m, y, k] if [c, c, c] == [m, y, k] => Ok(ColorType::CMYK(c)),
-                    _ => Err(TiffError::UnsupportedError(
-                        TiffUnsupportedError::InterpretationWithBits(
-                            self.photometric_interpretation,
-                            self.bits_per_sample.clone(),
-                        ),
-                    )),
-                }
+            PhotometricInterpretation::CMYK => match self.bits_per_sample[..] {
+                [c, m, y, k] if [c, c, c] == [m, y, k] => Ok(ColorType::CMYK(c)),
+                _ => Err(TiffError::UnsupportedError(
+                    TiffUnsupportedError::InterpretationWithBits(
+                        self.photometric_interpretation,
+                        self.bits_per_sample.clone(),
+                    ),
+                )),
             },
             PhotometricInterpretation::BlackIsZero | PhotometricInterpretation::WhiteIsZero
                 if self.bits_per_sample.len() == 1 =>
@@ -340,18 +405,20 @@ impl<R: Read + Seek> Decoder<R> {
                 if self.read_short()? != 8 {
                     return Err(TiffError::FormatError(
                         TiffFormatError::TiffSignatureNotFound,
-                    ))
+                    ));
                 }
                 // This constant should always be 0
                 if self.read_short()? != 0 {
                     return Err(TiffError::FormatError(
                         TiffFormatError::TiffSignatureNotFound,
-                    ))
+                    ));
                 }
-            },
-            _ => return Err(TiffError::FormatError(
-                TiffFormatError::TiffSignatureInvalid,
-            ))
+            }
+            _ => {
+                return Err(TiffError::FormatError(
+                    TiffFormatError::TiffSignatureInvalid,
+                ))
+            }
         }
         self.next_ifd = match self.read_ifd_offset()? {
             0 => None,
@@ -388,10 +455,26 @@ impl<R: Read + Seek> Decoder<R> {
         if let Some(val) = self.find_tag_unsigned(Tag::SamplesPerPixel)? {
             self.samples = val;
         }
+        if let Some(vals) = self.find_tag_unsigned_vec(Tag::SampleFormat)? {
+            self.sample_format = vals
+                .into_iter()
+                .map(SampleFormat::from_u16_exhaustive)
+                .collect();
+
+            // TODO: for now, only homogenous formats across samples are supported.
+            if !self.sample_format.windows(2).all(|s| s[0] == s[1]) {
+                return Err(TiffUnsupportedError::UnsupportedSampleFormat(
+                    self.sample_format.clone(),
+                )
+                .into());
+            }
+        }
         match self.samples {
-            1 | 3 | 4 => if let Some(val) = self.find_tag_unsigned_vec(Tag::BitsPerSample)? {
-                self.bits_per_sample = val;
-            },
+            1 | 3 | 4 => {
+                if let Some(val) = self.find_tag_unsigned_vec(Tag::BitsPerSample)? {
+                    self.bits_per_sample = val;
+                }
+            }
             _ => return Err(TiffUnsupportedError::UnsupportedSampleDepth(self.samples).into()),
         }
         Ok(())
@@ -448,12 +531,23 @@ impl<R: Read + Seek> Decoder<R> {
         self.reader.read_i32()
     }
 
+    /// Reads a TIFF float value
+    #[inline]
+    pub fn read_float(&mut self) -> Result<f32, io::Error> {
+        self.reader.read_f32()
+    }
+
+    /// Reads a TIFF double value
+    #[inline]
+    pub fn read_double(&mut self) -> Result<f64, io::Error> {
+        self.reader.read_f64()
+    }
+
     #[inline]
     pub fn read_long8(&mut self) -> Result<u64, io::Error> {
         self.reader.read_u64()
     }
 
-
     /// Reads a string
     #[inline]
     pub fn read_string(&mut self, length: usize) -> TiffResult<String> {
@@ -470,7 +564,9 @@ impl<R: Read + Seek> Decoder<R> {
     #[inline]
     pub fn read_offset(&mut self) -> TiffResult<[u8; 4]> {
         if self.bigtiff {
-            return Err(TiffError::FormatError(TiffFormatError::InconsistentSizesEncountered))
+            return Err(TiffError::FormatError(
+                TiffFormatError::InconsistentSizesEncountered,
+            ));
         }
         let mut val = [0; 4];
         self.reader.read_exact(&mut val)?;
@@ -493,9 +589,45 @@ impl<R: Read + Seek> Decoder<R> {
 
     #[inline]
     pub fn goto_offset_u64(&mut self, offset: u64) -> io::Result<()> {
-        self.reader
-            .seek(io::SeekFrom::Start(offset))
-            .map(|_| ())
+        self.reader.seek(io::SeekFrom::Start(offset)).map(|_| ())
+    }
+
+    /// Retrieve a checkpoint that allows seeking before the TIFF header.
+    ///
+    /// This is a special checkpoint where the caller should call `init` after restoring the
+    /// checkpoint and no ifd is being read.
+    pub fn checkpoint_init(&self) -> Checkpoint {
+        Checkpoint { offset: Checkpoint::INITIAL_OFFSET }
+    }
+
+    /// Retrieve a `Checkpoint` that can be used to seek to the current image directory.
+    pub fn checkpoint(&self) -> Checkpoint {
+        match self.current_ifd {
+            None => self.checkpoint_init(),
+            Some(offset) => Checkpoint { offset },
+        }
+    }
+
+    /// Get the next image directory as a checkpoint.
+    ///
+    /// This allows jumping forward to the next image directory later, without needing to pay the
+    /// additional cost of parsing it right away.
+    pub fn checkpoint_next(&self) -> Option<Checkpoint> {
+        match self.next_ifd {
+            None => None,
+            Some(offset) => Some(Checkpoint { offset })
+        }
+    }
+
+    /// Restore the state of a previous checkpoint.
+    pub fn restore(&mut self, checkpoint: &Checkpoint) -> TiffResult<()> {
+        if checkpoint.offset == Checkpoint::INITIAL_OFFSET {
+            self.goto_offset_u64(0)?;
+            Ok(())
+        } else {
+            self.next_ifd = Some(checkpoint.offset);
+            self.next_image()
+        }
     }
 
     /// Reads a IFD entry.
@@ -517,22 +649,11 @@ impl<R: Read + Seek> Decoder<R> {
             }
         };
         let entry = if self.bigtiff {
-            ifd::Entry::new_u64(
-                type_,
-                self.read_long8()?,
-                self.read_offset_u64()?
-            )
+            ifd::Entry::new_u64(type_, self.read_long8()?, self.read_offset_u64()?)
         } else {
-            ifd::Entry::new(
-                type_,
-                self.read_long()?, 
-                self.read_offset()?
-            )
+            ifd::Entry::new(type_, self.read_long()?, self.read_offset()?)
         };
-        Ok(Some((
-            tag,
-            entry,
-        )))
+        Ok(Some((tag, entry)))
     }
 
     /// Reads the next IFD
@@ -544,13 +665,22 @@ impl<R: Read + Seek> Decoder<R> {
                     TiffFormatError::ImageFileDirectoryNotFound,
                 ))
             }
-            Some(offset) => self.goto_offset_u64(offset)?,
+            Some(offset) => {
+                self.goto_offset_u64(offset)?;
+                self.current_ifd = Some(offset);
+            }
         }
-        let num_tags = if self.bigtiff { self.read_long8()? } else { self.read_short()?.into() };
+        let num_tags = if self.bigtiff {
+            self.read_long8()?
+        } else {
+            self.read_short()?.into()
+        };
         for _ in 0..num_tags {
             let (tag, entry) = match self.read_entry()? {
                 Some(val) => val,
-                None => continue, // Unknown data type in tag, skip
+                None => {
+                    continue;
+                } // Unknown data type in tag, skip
             };
             dir.insert(tag, entry);
         }
@@ -577,20 +707,30 @@ impl<R: Read + Seek> Decoder<R> {
     /// Tries to retrieve a tag and convert it to the desired unsigned type.
     pub fn find_tag_unsigned<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<Option<T>> {
         self.find_tag(tag)?
-            .map(|v| v.into_u64()).transpose()?
-            .map(|value| T::try_from(value)
-                .map_err(|_| TiffFormatError::InvalidTagValueType(tag).into()))
+            .map(|v| v.into_u64())
+            .transpose()?
+            .map(|value| {
+                T::try_from(value).map_err(|_| TiffFormatError::InvalidTagValueType(tag).into())
+            })
             .transpose()
     }
 
     /// Tries to retrieve a vector of all a tag's values and convert them to
     /// the desired unsigned type.
-    pub fn find_tag_unsigned_vec<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<Option<Vec<T>>> {
+    pub fn find_tag_unsigned_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())
+            .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()
     }
 
@@ -620,6 +760,16 @@ impl<R: Read + Seek> Decoder<R> {
         self.get_tag(tag)?.into_u64()
     }
 
+    /// Tries to retrieve a tag and convert it to the desired type.
+    pub fn get_tag_f32(&mut self, tag: Tag) -> TiffResult<f32> {
+        self.get_tag(tag)?.into_f32()
+    }
+
+    /// Tries to retrieve a tag and convert it to the desired type.
+    pub fn get_tag_f64(&mut self, tag: Tag) -> TiffResult<f64> {
+        self.get_tag(tag)?.into_f64()
+    }
+
     /// Tries to retrieve a tag and convert it to the desired type.
     pub fn get_tag_u32_vec(&mut self, tag: Tag) -> TiffResult<Vec<u32>> {
         self.get_tag(tag)?.into_u32_vec()
@@ -628,6 +778,21 @@ impl<R: Read + Seek> Decoder<R> {
         self.get_tag(tag)?.into_u64_vec()
     }
 
+    /// Tries to retrieve a tag and convert it to the desired type.
+    pub fn get_tag_f32_vec(&mut self, tag: Tag) -> TiffResult<Vec<f32>> {
+        self.get_tag(tag)?.into_f32_vec()
+    }
+
+    /// Tries to retrieve a tag and convert it to the desired type.
+    pub fn get_tag_f64_vec(&mut self, tag: Tag) -> TiffResult<Vec<f64>> {
+        self.get_tag(tag)?.into_f64_vec()
+    }
+
+    /// Tries to retrieve a tag and convert it to a 8bit vector.
+    pub fn get_tag_u8_vec(&mut self, tag: Tag) -> TiffResult<Vec<u8>> {
+        self.get_tag(tag)?.into_u8_vec()
+    }
+
     /// Decompresses the strip into the supplied buffer.
     /// Returns the number of bytes read.
     fn expand_strip<'a>(
@@ -651,21 +816,19 @@ impl<R: Read + Seek> Decoder<R> {
                 let (bytes, reader) = LZWReader::new(
                     &mut self.reader,
                     usize::try_from(length)?,
-                    max_uncompressed_length * buffer.byte_len()
+                    max_uncompressed_length * buffer.byte_len(),
                 )?;
                 (bytes, Box::new(reader))
             }
             CompressionMethod::PackBits => {
                 let order = self.reader.byte_order;
-                let (bytes, reader) = PackBitsReader::new(
-                    &mut self.reader,
-                    order,
-                    usize::try_from(length)?,
-                )?;
+                let (bytes, reader) =
+                    PackBitsReader::new(&mut self.reader, order, usize::try_from(length)?)?;
                 (bytes, Box::new(reader))
             }
             CompressionMethod::OldDeflate => {
-                let (bytes, reader) = DeflateReader::new(&mut self.reader, max_uncompressed_length)?;
+                let (bytes, reader) =
+                    DeflateReader::new(&mut self.reader, max_uncompressed_length)?;
                 (bytes, Box::new(reader))
             }
             method => {
@@ -700,6 +863,18 @@ impl<R: Read + Seek> Decoder<R> {
                 reader.read_u32_into(&mut buffer[..bytes / 4])?;
                 bytes / 4
             }
+            (ColorType::RGBA(32), DecodingBuffer::F32(ref mut buffer))
+            | (ColorType::RGB(32), DecodingBuffer::F32(ref mut buffer))
+            | (ColorType::CMYK(32), DecodingBuffer::F32(ref mut buffer)) => {
+                reader.read_f32_into(&mut buffer[..bytes / 4])?;
+                bytes / 4
+            }
+            (ColorType::RGBA(64), DecodingBuffer::F64(ref mut buffer))
+            | (ColorType::RGB(64), DecodingBuffer::F64(ref mut buffer))
+            | (ColorType::CMYK(64), DecodingBuffer::F64(ref mut buffer)) => {
+                reader.read_f64_into(&mut buffer[..bytes / 8])?;
+                bytes / 8
+            }
             (ColorType::RGBA(64), DecodingBuffer::U64(ref mut buffer))
             | (ColorType::RGB(64), DecodingBuffer::U64(ref mut buffer))
             | (ColorType::CMYK(64), DecodingBuffer::U64(ref mut buffer)) => {
@@ -742,6 +917,26 @@ impl<R: Read + Seek> Decoder<R> {
                 }
                 bytes
             }
+            (ColorType::Gray(32), DecodingBuffer::F32(ref mut buffer)) => {
+                reader.read_f32_into(&mut buffer[..bytes / 4])?;
+                if self.photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
+                    for datum in buffer[..bytes / 4].iter_mut() {
+                        // FIXME: assumes [0, 1) range for floats
+                        *datum = 1.0 - *datum
+                    }
+                }
+                bytes / 4
+            }
+            (ColorType::Gray(64), DecodingBuffer::F64(ref mut buffer)) => {
+                reader.read_f64_into(&mut buffer[..bytes / 8])?;
+                if self.photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
+                    for datum in buffer[..bytes / 8].iter_mut() {
+                        // FIXME: assumes [0, 1) range for floats
+                        *datum = 1.0 - *datum
+                    }
+                }
+                bytes / 8
+            }
             (type_, _) => {
                 return Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::UnsupportedColorType(type_),
@@ -752,9 +947,7 @@ impl<R: Read + Seek> Decoder<R> {
 
     /// Number of strips in image
     pub fn strip_count(&mut self) -> TiffResult<u32> {
-        let rows_per_strip = self
-            .get_tag_u32(Tag::RowsPerStrip)
-            .unwrap_or(self.height);
+        let rows_per_strip = self.get_tag_u32(Tag::RowsPerStrip).unwrap_or(self.height);
 
         if rows_per_strip == 0 {
             return Ok(0);
@@ -777,6 +970,60 @@ impl<R: Read + Seek> Decoder<R> {
         Ok(())
     }
 
+    pub fn read_jpeg(&mut self) -> TiffResult<DecodingResult> {
+        let offsets = self.get_tag_u32_vec(Tag::StripOffsets)?;
+        let bytes = self.get_tag_u32_vec(Tag::StripByteCounts)?;
+
+        let jpeg_tables: Option<Vec<u8>> = match self.find_tag(Tag::JPEGTables) {
+            Ok(None) => None,
+            Ok(_) => Some(self.get_tag_u8_vec(Tag::JPEGTables)?),
+            Err(e) => return Err(e),
+        };
+
+        if offsets.len() == 0 {
+            return Err(TiffError::FormatError(TiffFormatError::RequiredTagEmpty(
+                Tag::StripOffsets,
+            )));
+        }
+        if offsets.len() != bytes.len() {
+            return Err(TiffError::FormatError(
+                TiffFormatError::InconsistentSizesEncountered,
+            ));
+        }
+
+        let mut res_img = Vec::with_capacity(offsets[0] as usize);
+
+        for (idx, offset) in offsets.iter().enumerate() {
+            if bytes[idx] as usize > self.limits.intermediate_buffer_size {
+                return Err(TiffError::LimitsExceeded);
+            }
+
+            self.goto_offset(*offset)?;
+            let jpeg_reader = JpegReader::new(&mut self.reader, bytes[idx], &jpeg_tables)?;
+            let mut decoder = jpeg::Decoder::new(jpeg_reader);
+
+            match decoder.decode() {
+                Ok(mut val) => res_img.append(&mut val),
+                Err(e) => {
+                    return match e {
+                        jpeg::Error::Io(io_err) => Err(TiffError::IoError(io_err)),
+                        jpeg::Error::Format(fmt_err) => {
+                            Err(TiffError::FormatError(TiffFormatError::Format(fmt_err)))
+                        }
+                        jpeg::Error::Unsupported(_) => Err(TiffError::UnsupportedError(
+                            TiffUnsupportedError::UnknownInterpretation,
+                        )),
+                        jpeg::Error::Internal(_) => Err(TiffError::UnsupportedError(
+                            TiffUnsupportedError::UnknownInterpretation,
+                        )),
+                    }
+                }
+            }
+        }
+
+        Ok(DecodingResult::U8(res_img))
+    }
+
     pub fn read_strip_to_buffer(&mut self, mut buffer: DecodingBuffer) -> TiffResult<()> {
         self.initialize_strip_decoder()?;
 
@@ -800,16 +1047,15 @@ impl<R: Read + Seek> Decoder<R> {
                 TiffFormatError::InconsistentSizesEncountered,
             ))?;
 
-        let rows_per_strip = usize::try_from(self
-            .get_tag_u32(Tag::RowsPerStrip)
-            .unwrap_or(self.height))?;
+        let tag_rows = self.get_tag_u32(Tag::RowsPerStrip).unwrap_or(self.height);
+        let rows_per_strip = usize::try_from(tag_rows)?;
 
-        let strip_height = cmp::min(
-            rows_per_strip,
-            usize::try_from(self.height)? - index * rows_per_strip,
-        );
+        let sized_width = usize::try_from(self.width)?;
+        let sized_height = usize::try_from(self.height)?;
 
-        let buffer_size = usize::try_from(self.width)? * strip_height * self.bits_per_sample.len();
+        let strip_height = cmp::min(rows_per_strip, sized_height - index * rows_per_strip);
+
+        let buffer_size = sized_width * strip_height * self.bits_per_sample.len();
 
         if buffer.len() < buffer_size {
             return Err(TiffError::FormatError(
@@ -854,15 +1100,26 @@ impl<R: Read + Seek> Decoder<R> {
     fn result_buffer(&self, height: usize) -> TiffResult<DecodingResult> {
         let buffer_size = usize::try_from(self.width)? * height * self.bits_per_sample.len();
 
-        match self.bits_per_sample.iter().cloned().max().unwrap_or(8) {
-            n if n <= 8 => DecodingResult::new_u8(buffer_size, &self.limits),
-            n if n <= 16 => DecodingResult::new_u16(buffer_size, &self.limits),
-            n if n <= 32 => DecodingResult::new_u32(buffer_size, &self.limits),
-            n if n <= 64 => DecodingResult::new_u64(buffer_size, &self.limits),
-            n => {
-                Err(TiffError::UnsupportedError(
+        let max_sample_bits = self.bits_per_sample.iter().cloned().max().unwrap_or(8);
+        match self.sample_format.first().unwrap_or(&SampleFormat::Uint) {
+            SampleFormat::Uint => match max_sample_bits {
+                n if n <= 8 => DecodingResult::new_u8(buffer_size, &self.limits),
+                n if n <= 16 => DecodingResult::new_u16(buffer_size, &self.limits),
+                n if n <= 32 => DecodingResult::new_u32(buffer_size, &self.limits),
+                n if n <= 64 => DecodingResult::new_u64(buffer_size, &self.limits),
+                n => Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::UnsupportedBitsPerChannel(n),
-                ))
+                )),
+            },
+            SampleFormat::IEEEFP => match max_sample_bits {
+                32 => DecodingResult::new_f32(buffer_size, &self.limits),
+                64 => DecodingResult::new_f64(buffer_size, &self.limits),
+                n => Err(TiffError::UnsupportedError(
+                    TiffUnsupportedError::UnsupportedBitsPerChannel(n),
+                )),
+            },
+            format => {
+                Err(TiffUnsupportedError::UnsupportedSampleFormat(vec![format.clone()]).into())
             }
         }
     }
@@ -872,9 +1129,8 @@ impl<R: Read + Seek> Decoder<R> {
         self.initialize_strip_decoder()?;
         let index = self.strip_decoder.as_ref().unwrap().strip_index;
 
-        let rows_per_strip = usize::try_from(self
-            .get_tag_u32(Tag::RowsPerStrip)
-            .unwrap_or(self.height))?;
+        let rows_per_strip =
+            usize::try_from(self.get_tag_u32(Tag::RowsPerStrip).unwrap_or(self.height))?;
 
         let strip_height = cmp::min(
             rows_per_strip,
@@ -890,10 +1146,13 @@ impl<R: Read + Seek> Decoder<R> {
 
     /// Decodes the entire image and return it as a Vector
     pub fn read_image(&mut self) -> TiffResult<DecodingResult> {
+        if self.compression_method == CompressionMethod::ModernJPEG {
+            return self.read_jpeg();
+        }
+
         self.initialize_strip_decoder()?;
-        let rows_per_strip = usize::try_from(self
-            .get_tag_u32(Tag::RowsPerStrip)
-            .unwrap_or(self.height))?;
+        let rows_per_strip =
+            usize::try_from(self.get_tag_u32(Tag::RowsPerStrip).unwrap_or(self.height))?;
 
         let samples_per_strip =
             usize::try_from(self.width)? * rows_per_strip * self.bits_per_sample.len();
@@ -903,7 +1162,10 @@ impl<R: Read + Seek> Decoder<R> {
         for i in 0..usize::try_from(self.strip_count()?)? {
             self.read_strip_to_buffer(result.as_buffer(samples_per_strip * i))?;
         }
-
         Ok(result)
     }
 }
+
+impl Checkpoint {
+    const INITIAL_OFFSET: u64 = 0;
+}

src/decoder/stream.rs

@@ -1,8 +1,7 @@
 //! All IO functionality needed for TIFF decoding
 
+use crate::bytecast;
 use crate::error::{TiffError, TiffResult};
-use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
-use lzw;
 use miniz_oxide::inflate;
 use std::io::{self, Read, Seek};
 
@@ -23,85 +22,179 @@ pub trait EndianReader: Read {
     /// Reads an u16
     #[inline(always)]
     fn read_u16(&mut self) -> Result<u16, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u16::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u16::<BigEndian>(self),
-        }
+        let mut n = [0u8; 2];
+        self.read_exact(&mut n)?;
+        Ok(match self.byte_order() {
+            ByteOrder::LittleEndian => u16::from_le_bytes(n),
+            ByteOrder::BigEndian => u16::from_be_bytes(n),
+        })
     }
 
     #[inline(always)]
     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 => {
-                <Self as ReadBytesExt>::read_u16_into::<LittleEndian>(self, buffer)
+                for n in buffer {
+                    *n = u16::from_le(*n);
+                }
             }
             ByteOrder::BigEndian => {
-                <Self as ReadBytesExt>::read_u16_into::<BigEndian>(self, buffer)
+                for n in buffer {
+                    *n = u16::from_be(*n);
+                }
             }
         }
+        Ok(())
     }
 
     /// Reads an i16
     #[inline(always)]
     fn read_i16(&mut self) -> Result<i16, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_i16::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_i16::<BigEndian>(self),
-        }
+        let mut n = [0u8; 2];
+        self.read_exact(&mut n)?;
+        Ok(match self.byte_order() {
+            ByteOrder::LittleEndian => i16::from_le_bytes(n),
+            ByteOrder::BigEndian => i16::from_be_bytes(n),
+        })
     }
 
     /// Reads an u32
     #[inline(always)]
     fn read_u32(&mut self) -> Result<u32, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u32::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u32::<BigEndian>(self),
-        }
+        let mut n = [0u8; 4];
+        self.read_exact(&mut n)?;
+        Ok(match self.byte_order() {
+            ByteOrder::LittleEndian => u32::from_le_bytes(n),
+            ByteOrder::BigEndian => u32::from_be_bytes(n),
+        })
     }
 
     #[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 => {
-                <Self as ReadBytesExt>::read_u32_into::<LittleEndian>(self, buffer)
+                for n in buffer {
+                    *n = u32::from_le(*n);
+                }
             }
             ByteOrder::BigEndian => {
-                <Self as ReadBytesExt>::read_u32_into::<BigEndian>(self, buffer)
-            }
-        }
-    }
-
-    /// Reads an u64
-    #[inline(always)]
-    fn read_u64(&mut self) -> Result<u64, io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u64::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u64::<BigEndian>(self),
-        }
-    }
-
-    #[inline(always)]
-    fn read_u64_into(&mut self, buffer: &mut [u64]) -> Result<(), io::Error> {
-        match self.byte_order() {
-            ByteOrder::LittleEndian => {
-                <Self as ReadBytesExt>::read_u64_into::<LittleEndian>(self, buffer)
-            }
-            ByteOrder::BigEndian => {
-                <Self as ReadBytesExt>::read_u64_into::<BigEndian>(self, buffer)
+                for n in buffer {
+                    *n = u32::from_be(*n);
+                }
             }
         }
+        Ok(())
     }
 
     /// Reads an i32
     #[inline(always)]
     fn read_i32(&mut self) -> Result<i32, io::Error> {
+        let mut n = [0u8; 4];
+        self.read_exact(&mut n)?;
+        Ok(match self.byte_order() {
+            ByteOrder::LittleEndian => i32::from_le_bytes(n),
+            ByteOrder::BigEndian => i32::from_be_bytes(n),
+        })
+    }
+
+    /// Reads an u64
+    #[inline(always)]
+    fn read_u64(&mut self) -> Result<u64, io::Error> {
+        let mut n = [0u8; 8];
+        self.read_exact(&mut n)?;
+        Ok(match self.byte_order() {
+            ByteOrder::LittleEndian => u64::from_le_bytes(n),
+            ByteOrder::BigEndian => u64::from_be_bytes(n),
+        })
+    }
+
+    #[inline(always)]
+    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 => <Self as ReadBytesExt>::read_i32::<LittleEndian>(self),
-            ByteOrder::BigEndian => <Self as ReadBytesExt>::read_i32::<BigEndian>(self),
+            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
+    #[inline(always)]
+    fn read_f32(&mut self) -> Result<f32, io::Error> {
+        let mut n = [0u8; 4];
+        self.read_exact(&mut n)?;
+        Ok(f32::from_bits(match self.byte_order() {
+            ByteOrder::LittleEndian => u32::from_le_bytes(n),
+            ByteOrder::BigEndian => u32::from_be_bytes(n),
+        }))
+    }
+
+    #[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> {
+        let mut n = [0u8; 8];
+        self.read_exact(&mut n)?;
+        Ok(f64::from_bits(match self.byte_order() {
+            ByteOrder::LittleEndian => u64::from_le_bytes(n),
+            ByteOrder::BigEndian => u64::from_be_bytes(n),
+        }))
+    }
+
+    #[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(())
     }
 }
 
+///
+/// # READERS
+///
+
+///
+/// ## Deflate Reader
+///
+
 /// Reader that decompresses DEFLATE streams
 pub struct DeflateReader {
     buffer: io::Cursor<Vec<u8>>,
@@ -148,6 +241,10 @@ impl EndianReader for DeflateReader {
     }
 }
 
+///
+/// ## LZW Reader
+///
+
 /// Reader that decompresses LZW streams
 pub struct LZWReader {
     buffer: io::Cursor<Vec<u8>>,
@@ -168,12 +265,32 @@ impl LZWReader {
         let mut compressed = vec![0; compressed_length as usize];
         reader.read_exact(&mut compressed[..])?;
         let mut uncompressed = Vec::with_capacity(max_uncompressed_length);
-        let mut decoder = lzw::DecoderEarlyChange::new(lzw::MsbReader::new(), 8);
+        let mut decoder = weezl::decode::Decoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8);
         let mut bytes_read = 0;
         while bytes_read < compressed_length && uncompressed.len() < max_uncompressed_length {
-            let (len, bytes) = decoder.decode_bytes(&compressed[bytes_read..])?;
-            bytes_read += len;
-            uncompressed.extend_from_slice(bytes);
+            let bytes_written = uncompressed.len();
+            uncompressed.reserve(1 << 12);
+            let buffer_space = uncompressed.capacity();
+            uncompressed.resize(buffer_space, 0u8);
+
+            let result = decoder.decode_bytes(
+                &compressed[bytes_read..],
+                &mut uncompressed[bytes_written..],
+            );
+            bytes_read += result.consumed_in;
+            uncompressed.truncate(bytes_written + result.consumed_out);
+
+            match result.status {
+                Ok(weezl::LzwStatus::Ok) => {}
+                Ok(weezl::LzwStatus::Done) => break,
+                Ok(weezl::LzwStatus::NoProgress) => {
+                    return Err(io::Error::new(
+                        io::ErrorKind::UnexpectedEof,
+                        "no lzw end code found",
+                    ))
+                }
+                Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidData, err)),
+            }
         }
 
         let bytes = uncompressed.len();
@@ -201,6 +318,79 @@ impl EndianReader for LZWReader {
     }
 }
 
+///
+/// ## 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.
+    /// Because JPEG compression in TIFF allows to save quantization and/or huffman tables in one
+    /// central location, the constructor accepts this data as `jpeg_tables` here containing either
+    /// or both.
+    /// These `jpeg_tables` are simply prepended to the remaining jpeg image data.
+    /// Because these `jpeg_tables` start with a `SOI` (HEX: `0xFFD8`) or __start of image__ marker
+    /// which is also at the beginning of the remaining JPEG image data and would
+    /// confuse the JPEG renderer, one of these has to be taken off. In this case the first two
+    /// bytes of the remaining JPEG data is removed because it follows `jpeg_tables`.
+    /// Similary, `jpeg_tables` ends with a `EOI` (HEX: `0xFFD9`) or __end of image__ marker,
+    /// this has to be removed as well (last two bytes of `jpeg_tables`).
+
+    pub fn new<R>(
+        reader: &mut SmartReader<R>,
+        length: u32,
+        jpeg_tables: &Option<Vec<u8>>,
+    ) -> io::Result<JpegReader>
+    where
+        R: Read + Seek,
+    {
+        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) => {
+                let mut jpeg_data = tables.clone();
+                let truncated_length = jpeg_data.len() - 2;
+                jpeg_data.truncate(truncated_length);
+                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,
+            }),
+        }
+    }
+}
+
+impl Read for JpegReader {
+    // #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.buffer.read(buf)
+    }
+}
+
+impl EndianReader for JpegReader {
+    #[inline(always)]
+    fn byte_order(&self) -> ByteOrder {
+        self.byte_order
+    }
+}
+
+///
+/// ## PackBits Reader
+///
+
 /// Reader that unpacks Apple's `PackBits` format
 pub struct PackBitsReader {
     buffer: io::Cursor<Vec<u8>>,
@@ -273,6 +463,10 @@ impl EndianReader for PackBitsReader {
     }
 }
 
+///
+/// ## SmartReader Reader
+///
+
 /// Reader that is aware of the byte order.
 #[derive(Debug)]
 pub struct SmartReader<R>

src/encoder/colortype.rs

@@ -1,4 +1,4 @@
-use tags::PhotometricInterpretation;
+use tags::{PhotometricInterpretation, SampleFormat};
 
 /// Trait for different colortypes that can be encoded.
 pub trait ColorType {
@@ -8,6 +8,8 @@ pub trait ColorType {
     const TIFF_VALUE: PhotometricInterpretation;
     /// The value of the tiff tag `BitsPerSample`
     const BITS_PER_SAMPLE: &'static [u16];
+    /// The value of the tiff tag `SampleFormat`
+    const SAMPLE_FORMAT: &'static [SampleFormat];
 }
 
 pub struct Gray8;
@@ -15,6 +17,7 @@ impl ColorType for Gray8 {
     type Inner = u8;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[8];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
 }
 
 pub struct Gray16;
@@ -22,6 +25,7 @@ impl ColorType for Gray16 {
     type Inner = u16;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[16];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
 }
 
 pub struct Gray32;
@@ -29,6 +33,15 @@ impl ColorType for Gray32 {
     type Inner = u32;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
+}
+
+pub struct Gray32Float;
+impl ColorType for Gray32Float {
+    type Inner = f32;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
+    const BITS_PER_SAMPLE: &'static [u16] = &[32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP];
 }
 
 pub struct Gray64;
@@ -36,6 +49,15 @@ impl ColorType for Gray64 {
     type Inner = u64;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
     const BITS_PER_SAMPLE: &'static [u16] = &[64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint];
+}
+
+pub struct Gray64Float;
+impl ColorType for Gray64Float {
+    type Inner = f64;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::BlackIsZero;
+    const BITS_PER_SAMPLE: &'static [u16] = &[64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP];
 }
 
 pub struct RGB8;
@@ -43,6 +65,7 @@ impl ColorType for RGB8 {
     type Inner = u8;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
 }
 
 pub struct RGB16;
@@ -50,6 +73,7 @@ impl ColorType for RGB16 {
     type Inner = u16;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
 }
 
 pub struct RGB32;
@@ -57,6 +81,15 @@ impl ColorType for RGB32 {
     type Inner = u32;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+}
+
+pub struct RGB32Float;
+impl ColorType for RGB32Float {
+    type Inner = f32;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
+    const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 3];
 }
 
 pub struct RGB64;
@@ -64,6 +97,15 @@ impl ColorType for RGB64 {
     type Inner = u64;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 3];
+}
+
+pub struct RGB64Float;
+impl ColorType for RGB64Float {
+    type Inner = f64;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
+    const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 3];
 }
 
 pub struct RGBA8;
@@ -71,6 +113,7 @@ impl ColorType for RGBA8 {
     type Inner = u8;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8, 8];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
 }
 
 pub struct RGBA16;
@@ -78,20 +121,39 @@ impl ColorType for RGBA16 {
     type Inner = u16;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16, 16];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
 }
 
 pub struct RGBA32;
 impl ColorType for RGBA32 {
-    type Inner = u16;
+    type Inner = u32;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+}
+
+pub struct RGBA32Float;
+impl ColorType for RGBA32Float {
+    type Inner = f32;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
+    const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
 }
 
 pub struct RGBA64;
 impl ColorType for RGBA64 {
-    type Inner = u16;
+    type Inner = u64;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+}
+
+pub struct RGBA64Float;
+impl ColorType for RGBA64Float {
+    type Inner = f64;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::RGB;
+    const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
 }
 
 pub struct CMYK8;
@@ -99,6 +161,7 @@ impl ColorType for CMYK8 {
     type Inner = u8;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[8, 8, 8, 8];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
 }
 
 pub struct CMYK16;
@@ -106,6 +169,7 @@ impl ColorType for CMYK16 {
     type Inner = u16;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[16, 16, 16, 16];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
 }
 
 pub struct CMYK32;
@@ -113,6 +177,15 @@ impl ColorType for CMYK32 {
     type Inner = u32;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+}
+
+pub struct CMYK32Float;
+impl ColorType for CMYK32Float {
+    type Inner = f32;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
+    const BITS_PER_SAMPLE: &'static [u16] = &[32, 32, 32, 32];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
 }
 
 pub struct CMYK64;
@@ -120,4 +193,13 @@ impl ColorType for CMYK64 {
     type Inner = u64;
     const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
     const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::Uint; 4];
+}
+
+pub struct CMYK64Float;
+impl ColorType for CMYK64Float {
+    type Inner = f64;
+    const TIFF_VALUE: PhotometricInterpretation = PhotometricInterpretation::CMYK;
+    const BITS_PER_SAMPLE: &'static [u16] = &[64, 64, 64, 64];
+    const SAMPLE_FORMAT: &'static [SampleFormat] = &[SampleFormat::IEEEFP; 4];
 }

src/encoder/mod.rs

@@ -1,11 +1,11 @@
-use byteorder::NativeEndian;
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
 use std::io::{Seek, Write};
-use std::mem;
+use std::{cmp, io, mem};
 
-use tags::{self, ResolutionUnit, Tag, Type};
+use bytecast;
 use error::{TiffError, TiffFormatError, TiffResult};
+use tags::{self, ResolutionUnit, Tag, Type};
 
 pub mod colortype;
 mod writer;
@@ -60,9 +60,7 @@ impl TiffValue for [i8] {
     }
 
     fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        // We write using nativeedian so this should be safe
-        let slice =
-            unsafe { ::std::slice::from_raw_parts(self.as_ptr() as *const u8, self.len()) };
+        let slice = bytecast::i8_as_ne_bytes(self);
         writer.write_bytes(slice)?;
         Ok(())
     }
@@ -77,9 +75,7 @@ impl TiffValue for [u16] {
     }
 
     fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        // We write using nativeedian so this sould be safe
-        let slice =
-            unsafe { ::std::slice::from_raw_parts(self.as_ptr() as *const u8, self.len() * 2) };
+        let slice = bytecast::u16_as_ne_bytes(self);
         writer.write_bytes(slice)?;
         Ok(())
     }
@@ -94,9 +90,7 @@ impl TiffValue for [i16] {
     }
 
     fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        // We write using nativeedian so this should be safe
-        let slice =
-            unsafe { ::std::slice::from_raw_parts(self.as_ptr() as *const u8, self.len() * Self::BYTE_LEN as usize) };
+        let slice = bytecast::i16_as_ne_bytes(self);
         writer.write_bytes(slice)?;
         Ok(())
     }
@@ -111,9 +105,7 @@ impl TiffValue for [u32] {
     }
 
     fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        // We write using nativeedian so this sould be safe
-        let slice =
-            unsafe { ::std::slice::from_raw_parts(self.as_ptr() as *const u8, self.len() * 4) };
+        let slice = bytecast::u32_as_ne_bytes(self);
         writer.write_bytes(slice)?;
         Ok(())
     }
@@ -128,9 +120,7 @@ impl TiffValue for [i32] {
     }
 
     fn write<W: Write>(&self, writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        // We write using nativeedian so this should be safe
-        let slice =
-            unsafe { ::std::slice::from_raw_parts(self.as_ptr() as *const u8, self.len() * Self::BYTE_LEN as usize) };
+        let slice = bytecast::i32_as_ne_bytes(self);
         writer.write_bytes(slice)?;
         Ok(())
     }
@@ -144,10 +134,40 @@ impl TiffValue for [u64] {
         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 =
-            unsafe { ::std::slice::from_raw_parts(self.as_ptr() as *const u8, self.len() * 8) };
+        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(())
     }
@@ -283,6 +303,34 @@ impl TiffValue for u64 {
     }
 }
 
+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;
@@ -375,7 +423,7 @@ impl<W: Write + Seek> TiffEncoder<W> {
             writer: TiffWriter::new(writer),
         };
 
-        NativeEndian::write_header(&mut encoder.writer)?;
+        write_tiff_header(&mut encoder.writer)?;
         // blank the IFD offset location
         encoder.writer.write_u32(0)?;
 
@@ -447,8 +495,10 @@ impl<'a, W: 'a + Write + Seek> DirectoryEncoder<'a, W> {
             value.write(&mut writer)?;
         }
 
-        self.ifd
-            .insert(tag.to_u16(), (<T>::FIELD_TYPE.to_u16(), value.count(), bytes));
+        self.ifd.insert(
+            tag.to_u16(),
+            (<T>::FIELD_TYPE.to_u16(), value.count(), bytes),
+        );
 
         Ok(())
     }
@@ -536,7 +586,7 @@ impl<'a, W: Write + Seek> Drop for DirectoryEncoder<'a, W> {
 /// let mut tiff = TiffEncoder::new(&mut file).unwrap();
 /// let mut image = tiff.new_image::<colortype::RGB8>(100, 100).unwrap();
 ///
-/// // You can encode tags here 
+/// // You can encode tags here
 /// image.encoder().write_tag(Tag::Artist, "Image-tiff").unwrap();
 ///
 /// let mut idx = 0;
@@ -582,11 +632,16 @@ impl<'a, W: 'a + Write + Seek, T: ColorType> ImageEncoder<'a, W, T> {
         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();
+        encoder.write_tag(Tag::SampleFormat, &sample_format[..])?;
         encoder.write_tag(Tag::PhotometricInterpretation, <T>::TIFF_VALUE.to_u16())?;
 
         encoder.write_tag(Tag::RowsPerStrip, u32::try_from(rows_per_strip)?)?;
 
-        encoder.write_tag(Tag::SamplesPerPixel, u16::try_from(<T>::BITS_PER_SAMPLE.len())?)?;
+        encoder.write_tag(
+            Tag::SamplesPerPixel,
+            u16::try_from(<T>::BITS_PER_SAMPLE.len())?,
+        )?;
         encoder.write_tag(Tag::XResolution, Rational { n: 1, d: 1 })?;
         encoder.write_tag(Tag::YResolution, Rational { n: 1, d: 1 })?;
         encoder.write_tag(Tag::ResolutionUnit, ResolutionUnit::None.to_u16())?;
@@ -612,11 +667,9 @@ impl<'a, W: 'a + Write + Seek, T: ColorType> ImageEncoder<'a, W, T> {
             return 0;
         }
 
-        let start_row = ::std::cmp::min(u64::from(self.height), self.strip_idx * self.rows_per_strip);
-        let end_row = ::std::cmp::min(
-            u64::from(self.height),
-            (self.strip_idx + 1) * self.rows_per_strip,
-        );
+        let raw_start_row = self.strip_idx * self.rows_per_strip;
+        let start_row = cmp::min(u64::from(self.height), raw_start_row);
+        let end_row = cmp::min(u64::from(self.height), raw_start_row + self.rows_per_strip);
 
         (end_row - start_row) * self.row_samples
     }
@@ -629,9 +682,11 @@ impl<'a, W: 'a + Write + Seek, T: ColorType> ImageEncoder<'a, W, T> {
         // TODO: Compression
         let samples = self.next_strip_sample_count();
         if u64::try_from(value.len())? != samples {
-            return Err(::std::io::Error::new(
-                ::std::io::ErrorKind::InvalidData,
-                "Slice is wrong size for strip").into());
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "Slice is wrong size for strip",
+            )
+            .into());
         }
 
         let offset = self.encoder.write_data(value)?;
@@ -647,14 +702,20 @@ impl<'a, W: 'a + Write + Seek, T: ColorType> ImageEncoder<'a, W, T> {
     where
         [T::Inner]: TiffValue,
     {
-        let num_pix = usize::try_from(self.width)?.checked_mul(usize::try_from(self.height)?)
-            .ok_or_else(|| ::std::io::Error::new(
-                ::std::io::ErrorKind::InvalidInput,
-                "Image width * height exceeds usize"))?;
+        let num_pix = usize::try_from(self.width)?
+            .checked_mul(usize::try_from(self.height)?)
+            .ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "Image width * height exceeds usize",
+                )
+            })?;
         if data.len() < num_pix {
-            return Err(::std::io::Error::new(
-                ::std::io::ErrorKind::InvalidData,
-                "Input data slice is undersized for provided dimensions").into());
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "Input data slice is undersized for provided dimensions",
+            )
+            .into());
         }
         let mut idx = 0;
         while self.next_strip_sample_count() > 0 {
@@ -668,14 +729,20 @@ impl<'a, W: 'a + Write + Seek, T: ColorType> ImageEncoder<'a, W, T> {
 
     /// Set image resolution
     pub fn resolution(&mut self, unit: ResolutionUnit, value: Rational) {
-        self.encoder.write_tag(Tag::ResolutionUnit, unit.to_u16()).unwrap();
-        self.encoder.write_tag(Tag::XResolution, value.clone()).unwrap();
+        self.encoder
+            .write_tag(Tag::ResolutionUnit, unit.to_u16())
+            .unwrap();
+        self.encoder
+            .write_tag(Tag::XResolution, value.clone())
+            .unwrap();
         self.encoder.write_tag(Tag::YResolution, value).unwrap();
     }
 
     /// Set image resolution unit
     pub fn resolution_unit(&mut self, unit: ResolutionUnit) {
-        self.encoder.write_tag(Tag::ResolutionUnit, unit.to_u16()).unwrap();
+        self.encoder
+            .write_tag(Tag::ResolutionUnit, unit.to_u16())
+            .unwrap();
     }
 
     /// Set image x-resolution

src/encoder/writer.rs

@@ -1,29 +1,17 @@
 use error::TiffResult;
-use byteorder::{BigEndian, ByteOrder, LittleEndian, NativeEndian, WriteBytesExt};
 use std::io::{self, Seek, SeekFrom, Write};
 
-pub trait TiffByteOrder: ByteOrder {
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()>;
-}
+pub fn write_tiff_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
+    #[cfg(target_endian = "little")]
+    let boi: u8 = 0x49;
+    #[cfg(not(target_endian = "little"))]
+    let boi: u8 = 0x4d;
 
-impl TiffByteOrder for LittleEndian {
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        writer.writer.write_u16::<LittleEndian>(0x4949)?;
-        writer.writer.write_u16::<LittleEndian>(42)?;
-        writer.offset += 4;
+    writer.writer.write_all(&[boi, boi])?;
+    writer.writer.write_all(&42u16.to_ne_bytes())?;
+    writer.offset += 4;
 
-        Ok(())
-    }
-}
-
-impl TiffByteOrder for BigEndian {
-    fn write_header<W: Write>(writer: &mut TiffWriter<W>) -> TiffResult<()> {
-        writer.writer.write_u16::<BigEndian>(0x4d4d)?;
-        writer.writer.write_u16::<BigEndian>(42)?;
-        writer.offset += 4;
-
-        Ok(())
-    }
+    Ok(())
 }
 
 pub struct TiffWriter<W> {
@@ -47,47 +35,61 @@ impl<W: Write> TiffWriter<W> {
     }
 
     pub fn write_u8(&mut self, n: u8) -> Result<(), io::Error> {
-        self.writer.write_u8(n)?;
+        self.writer.write_all(&n.to_ne_bytes())?;
         self.offset += 1;
         Ok(())
     }
 
     pub fn write_i8(&mut self, n: i8) -> Result<(), io::Error> {
-        self.writer.write_i8(n)?;
+        self.writer.write_all(&n.to_ne_bytes())?;
         self.offset += 1;
         Ok(())
     }
 
     pub fn write_u16(&mut self, n: u16) -> Result<(), io::Error> {
-        self.writer.write_u16::<NativeEndian>(n)?;
+        self.writer.write_all(&n.to_ne_bytes())?;
         self.offset += 2;
 
         Ok(())
     }
 
     pub fn write_i16(&mut self, n: i16) -> Result<(), io::Error> {
-        self.writer.write_i16::<NativeEndian>(n)?;
+        self.writer.write_all(&n.to_ne_bytes())?;
         self.offset += 2;
 
         Ok(())
     }
 
     pub fn write_u32(&mut self, n: u32) -> Result<(), io::Error> {
-        self.writer.write_u32::<NativeEndian>(n)?;
+        self.writer.write_all(&n.to_ne_bytes())?;
         self.offset += 4;
 
         Ok(())
     }
 
     pub fn write_i32(&mut self, n: i32) -> Result<(), io::Error> {
-        self.writer.write_i32::<NativeEndian>(n)?;
+        self.writer.write_all(&n.to_ne_bytes())?;
         self.offset += 4;
 
         Ok(())
     }
 
     pub fn write_u64(&mut self, n: u64) -> Result<(), io::Error> {
-        self.writer.write_u64::<NativeEndian>(n)?;
+        self.writer.write_all(&n.to_ne_bytes())?;
+        self.offset += 8;
+
+        Ok(())
+    }
+
+    pub fn write_f32(&mut self, n: f32) -> Result<(), io::Error> {
+        self.writer.write_all(&u32::to_ne_bytes(n.to_bits()))?;
+        self.offset += 4;
+
+        Ok(())
+    }
+
+    pub fn write_f64(&mut self, n: f64) -> Result<(), io::Error> {
+        self.writer.write_all(&u64::to_ne_bytes(n.to_bits()))?;
         self.offset += 8;
 
         Ok(())

src/error.rs

@@ -3,9 +3,9 @@ use std::fmt;
 use std::io;
 use std::string;
 
-use decoder::ifd::{Value};
-use tags::{CompressionMethod, PhotometricInterpretation, PlanarConfiguration, Tag};
+use decoder::ifd::Value;
 use miniz_oxide::inflate::TINFLStatus;
+use tags::{CompressionMethod, PhotometricInterpretation, PlanarConfiguration, SampleFormat, Tag};
 use ColorType;
 
 /// Tiff error kinds.
@@ -35,7 +35,7 @@ pub enum TiffError {
 ///
 /// The list of variants may grow to incorporate errors of future features. Matching against this
 /// exhaustively is not covered by interface stability guarantees.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum TiffFormatError {
     TiffSignatureNotFound,
     TiffSignatureInvalid,
@@ -45,9 +45,12 @@ pub enum TiffFormatError {
     InvalidTagValueType(Tag),
     RequiredTagNotFound(Tag),
     UnknownPredictor(u16),
+    ByteExpected(Value),
     UnsignedIntegerExpected(Value),
     SignedIntegerExpected(Value),
     InflateError(InflateError),
+    Format(String),
+    RequiredTagEmpty(Tag),
     #[doc(hidden)]
     /// Do not match against this variant. It may get removed.
     __NonExhaustive,
@@ -62,12 +65,14 @@ impl fmt::Display for TiffFormatError {
             ImageFileDirectoryNotFound => write!(fmt, "Image file directory not found."),
             InconsistentSizesEncountered => write!(fmt, "Inconsistent sizes encountered."),
             InvalidTag => write!(fmt, "Image contains invalid tag."),
-            InvalidTagValueType(ref tag) =>
-                write!(fmt, "Tag `{:?}` did not have the expected value type.", tag),
+            InvalidTagValueType(ref tag) => {
+                write!(fmt, "Tag `{:?}` did not have the expected value type.", tag)
+            }
             RequiredTagNotFound(ref tag) => write!(fmt, "Required tag `{:?}` not found.", tag),
             UnknownPredictor(ref predictor) => {
                 write!(fmt, "Unknown predictor “{}” encountered", predictor)
             }
+            ByteExpected(ref val) => write!(fmt, "Expected byte, {:?} found.", val),
             UnsignedIntegerExpected(ref val) => {
                 write!(fmt, "Expected unsigned integer, {:?} found.", val)
             }
@@ -75,6 +80,8 @@ impl fmt::Display for TiffFormatError {
                 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),
             __NonExhaustive => unreachable!(),
         }
     }
@@ -114,6 +121,7 @@ pub enum TiffUnsupportedError {
     UnknownCompressionMethod,
     UnsupportedCompressionMethod(CompressionMethod),
     UnsupportedSampleDepth(u8),
+    UnsupportedSampleFormat(Vec<SampleFormat>),
     UnsupportedColorType(ColorType),
     UnsupportedBitsPerChannel(u8),
     UnsupportedPlanarConfig(Option<PlanarConfiguration>),
@@ -148,6 +156,9 @@ impl fmt::Display for TiffUnsupportedError {
             UnsupportedSampleDepth(samples) => {
                 write!(fmt, "{} samples per pixel is unsupported.", samples)
             }
+            UnsupportedSampleFormat(ref formats) => {
+                write!(fmt, "Sample format {:?} is unsupported.", formats)
+            }
             UnsupportedColorType(color_type) => {
                 write!(fmt, "Color type {:?} is unsupported", color_type)
             }

src/lib.rs

@@ -6,10 +6,11 @@
 //! # Related Links
 //! * <https://www.adobe.io/open/standards/TIFF.html> - The TIFF specification
 
-extern crate byteorder;
-extern crate lzw;
+extern crate jpeg;
 extern crate miniz_oxide;
+extern crate weezl;
 
+mod bytecast;
 pub mod decoder;
 pub mod encoder;
 mod error;

src/tags.rs

@@ -39,16 +39,24 @@ macro_rules! tags {
             }
         }
 
-        tags!($name, $ty);
+        tags!($name, $ty, $($unknown_doc)*);
     };
     // For u16 tags, provide direct inherent primitive conversion methods.
-    ($name:tt, u16) => {
+    ($name:tt, u16, $($unknown_doc:literal)*) => {
         impl $name {
             #[inline(always)]
             pub fn from_u16(val: u16) -> Option<Self> {
                 Self::__from_inner_type(val).ok()
             }
 
+            $(
+            #[inline(always)]
+            pub fn from_u16_exhaustive(val: u16) -> Self {
+                $unknown_doc;
+                Self::__from_inner_type(val).unwrap_or_else(|_| $name::Unknown(val))
+            }
+            )*
+
             #[inline(always)]
             pub fn to_u16(&self) -> u16 {
                 Self::__to_inner_type(self)
@@ -57,7 +65,7 @@ macro_rules! tags {
     };
     // For other tag types, do nothing for now. With concat_idents one could
     // provide inherent conversion methods for all types.
-    ($name:tt, $ty:tt) => {};
+    ($name:tt, $ty:tt, $($unknown_doc:literal)*) => {};
 }
 
 // Note: These tags appear in the order they are mentioned in the TIFF reference
@@ -103,6 +111,8 @@ 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,
@@ -113,12 +123,6 @@ pub enum Tag(u16) unknown("A private or extension tag") {
 }
 }
 
-impl Tag {
-    pub fn from_u16_exhaustive(val: u16) -> Self {
-        Self::from_u16(val).unwrap_or_else(|| Tag::Unknown(val))
-    }
-}
-
 tags! {
 /// The type of an IFD entry (a 2 byte field).
 pub enum Type(u16) {
@@ -128,16 +132,20 @@ pub enum Type(u16) {
     LONG = 4,
     RATIONAL = 5,
     SBYTE = 6,
+    UNDEFINED = 7,
     SSHORT = 8,
     SLONG = 9,
     SRATIONAL = 10,
+    FLOAT = 11,
+    DOUBLE = 12,
     /// BigTIFF 64-bit unsigned integer
     LONG8 = 16,
 }
 }
 
-
 tags! {
+/// See [TIFF compression tags](https://www.awaresystems.be/imaging/tiff/tifftags/compression.html)
+/// for reference.
 pub enum CompressionMethod(u16) {
     None = 1,
     Huffman = 2,
@@ -145,6 +153,8 @@ pub enum CompressionMethod(u16) {
     Fax4 = 4,
     LZW = 5,
     JPEG = 6,
+    // "Extended JPEG" or "new JPEG" style
+    ModernJPEG = 7,
     Deflate = 8,
     OldDeflate = 0x80B2,
     PackBits = 0x8005,
@@ -178,11 +188,20 @@ pub enum Predictor(u16) {
 }
 }
 
-tags!{
+tags! {
 /// Type to represent resolution units
 pub enum ResolutionUnit(u16) {
     None = 1,
     Inch = 2,
     Centimeter = 3,
 }
-}
+}
+
+tags! {
+pub enum SampleFormat(u16) unknown("An unknown extension sample format") {
+    Uint = 1,
+    Int = 2,
+    IEEEFP = 3,
+    Void = 4,
+}
+}

tests/benches/README.md

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

tests/decode_images.rs

@@ -21,7 +21,7 @@ macro_rules! test_image_sum {
                 DecodingResult::$buffer(res) => {
                     let sum: $sum_ty = res.into_iter().map(<$sum_ty>::from).sum();
                     assert_eq!(sum, expected_sum);
-                },
+                }
                 _ => panic!("Wrong bit depth"),
             }
         }
@@ -32,6 +32,8 @@ test_image_sum!(test_image_sum_u8, U8, u64);
 test_image_sum!(test_image_sum_u16, U16, u64);
 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);
+test_image_sum!(test_image_sum_f64, F64, f64);
 
 /// Tests that a decoder can be constructed for an image and the color type
 /// read from the IFD and is of the appropriate type, but the type is
@@ -42,7 +44,9 @@ fn test_image_color_type_unsupported(file: &str, expected_type: ColorType) {
     let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
     assert_eq!(decoder.colortype().unwrap(), expected_type);
     assert!(match decoder.read_image() {
-        Err(tiff::TiffError::UnsupportedError(tiff::TiffUnsupportedError::UnsupportedColorType(_))) => true,
+        Err(tiff::TiffError::UnsupportedError(
+            tiff::TiffUnsupportedError::UnsupportedColorType(_),
+        )) => true,
         _ => false,
     });
 }
@@ -57,6 +61,11 @@ fn test_cmyk_u16() {
     test_image_sum_u16("cmyk-3c-16b.tiff", ColorType::CMYK(16), 2181426827);
 }
 
+#[test]
+fn test_cmyk_f32() {
+    test_image_sum_f32("cmyk-3c-32b-float.tiff", ColorType::CMYK(32), 496.0405);
+}
+
 #[test]
 fn test_gray_u8() {
     test_image_sum_u8("minisblack-1c-8b.tiff", ColorType::Gray(8), 2840893);
@@ -82,6 +91,20 @@ fn test_gray_u64() {
     test_image_sum_u64("gradient-1c-64b.tiff", ColorType::Gray(64), 549892913787);
 }
 
+#[test]
+fn test_gray_f32() {
+    test_image_sum_f32("gradient-1c-32b-float.tiff", ColorType::Gray(32), 128.03194);
+}
+
+#[test]
+fn test_gray_f64() {
+    test_image_sum_f64(
+        "gradient-1c-64b-float.tiff",
+        ColorType::Gray(64),
+        128.0319210877642,
+    );
+}
+
 #[test]
 fn test_rgb_u8() {
     test_image_sum_u8("rgb-3c-8b.tiff", ColorType::RGB(8), 7842108);
@@ -107,6 +130,11 @@ fn test_rgb_u64() {
     test_image_sum_u64("gradient-3c-64b.tiff", ColorType::RGB(64), 2030834111716);
 }
 
+#[test]
+fn test_rgb_f32() {
+    test_image_sum_f32("gradient-3c-32b-float.tiff", ColorType::RGB(32), 472.8405);
+}
+
 #[test]
 fn test_string_tags() {
     // these files have null-terminated strings for their Software tag. One has extra bytes after

tests/encode_images.rs

@@ -1,9 +1,9 @@
 extern crate tiff;
 
-use tiff::decoder::{Decoder, DecodingResult, ifd};
-use tiff::encoder::{colortype, TiffEncoder, SRational};
-use tiff::ColorType;
+use tiff::decoder::{ifd, Decoder, DecodingResult};
+use tiff::encoder::{colortype, SRational, TiffEncoder};
 use tiff::tags::Tag;
+use tiff::ColorType;
 
 use std::fs::File;
 use std::io::{Cursor, Seek, SeekFrom};
@@ -24,18 +24,22 @@ fn encode_decode() {
     {
         let mut tiff = TiffEncoder::new(&mut file).unwrap();
 
-        let mut image = tiff.new_image::<colortype::RGB8>(100, 100)
+        let mut image = tiff.new_image::<colortype::RGB8>(100, 100).unwrap();
+        image
+            .encoder()
+            .write_tag(Tag::Artist, "Image-tiff")
             .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()));
+        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 {
@@ -62,7 +66,10 @@ const TEST_IMAGE_DIR: &str = "./tests/images/";
 
 macro_rules! test_roundtrip {
     ($name:ident, $buffer:ident, $buffer_ty:ty) => {
-        fn $name<C: colortype::ColorType<Inner=$buffer_ty>>(file: &str, expected_type: ColorType) {
+        fn $name<C: colortype::ColorType<Inner = $buffer_ty>>(
+            file: &str,
+            expected_type: ColorType,
+        ) {
             let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
             let img_file = File::open(path).expect("Cannot find test image!");
             let mut decoder = Decoder::new(img_file).expect("Cannot create decoder");
@@ -78,8 +85,7 @@ macro_rules! test_roundtrip {
                 let mut tiff = TiffEncoder::new(&mut file).unwrap();
 
                 let (width, height) = decoder.dimensions().unwrap();
-                tiff.write_image::<C>(width, height, &image_data)
-                    .unwrap();
+                tiff.write_image::<C>(width, height, &image_data).unwrap();
             }
             file.seek(SeekFrom::Start(0)).unwrap();
             {
@@ -98,6 +104,8 @@ test_roundtrip!(test_u8_roundtrip, U8, u8);
 test_roundtrip!(test_u16_roundtrip, U16, u16);
 test_roundtrip!(test_u32_roundtrip, U32, u32);
 test_roundtrip!(test_u64_roundtrip, U64, u64);
+test_roundtrip!(test_f32_roundtrip, F32, f32);
+test_roundtrip!(test_f64_roundtrip, F64, f64);
 
 #[test]
 fn test_gray_u8_roundtrip() {
@@ -149,6 +157,54 @@ fn test_rgb_u64_roundtrip() {
     test_u64_roundtrip::<colortype::RGB64>("gradient-3c-64b.tiff", ColorType::RGB(64));
 }
 
+#[test]
+fn test_gray_f32_roundtrip() {
+    test_f32_roundtrip::<colortype::Gray32Float>("gradient-1c-32b-float.tiff", ColorType::Gray(32));
+}
+
+#[test]
+fn test_rgb_f32_roundtrip() {
+    test_f32_roundtrip::<colortype::RGB32Float>("gradient-3c-32b-float.tiff", ColorType::RGB(32));
+}
+
+#[test]
+fn test_cmyk_f32_roundtrip() {
+    test_f32_roundtrip::<colortype::CMYK32Float>("cmyk-3c-32b-float.tiff", ColorType::CMYK(32));
+}
+
+#[test]
+fn test_gray_f64_roundtrip() {
+    test_f64_roundtrip::<colortype::Gray64Float>("gradient-1c-64b-float.tiff", ColorType::Gray(64));
+}
+
+trait AssertDecode {
+    fn assert_tag_u32(&mut self, tag: u16) -> u32;
+    fn assert_tag_u32_vec(&mut self, tag: u16) -> Vec<u32>;
+    fn assert_tag_i32(&mut self, tag: u16) -> i32;
+    fn assert_tag_i32_vec(&mut self, tag: u16) -> Vec<i32>;
+}
+
+impl<R: std::io::Read + std::io::Seek> AssertDecode for Decoder<R> {
+    fn assert_tag_u32(&mut self, tag: u16) -> u32 {
+        self.get_tag(Tag::Unknown(tag)).unwrap().into_u32().unwrap()
+    }
+    fn assert_tag_u32_vec(&mut self, tag: u16) -> Vec<u32> {
+        self.get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_u32_vec()
+            .unwrap()
+    }
+    fn assert_tag_i32(&mut self, tag: u16) -> i32 {
+        self.get_tag(Tag::Unknown(tag)).unwrap().into_i32().unwrap()
+    }
+    fn assert_tag_i32_vec(&mut self, tag: u16) -> Vec<i32> {
+        self.get_tag(Tag::Unknown(tag))
+            .unwrap()
+            .into_i32_vec()
+            .unwrap()
+    }
+}
+
 #[test]
 fn test_multiple_byte() {
     let mut data = Cursor::new(Vec::new());
@@ -159,21 +215,29 @@ fn test_multiple_byte() {
         let encoder = image_encoder.encoder();
 
         encoder.write_tag(Tag::Unknown(65000), &[1_u8][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65001), &[1_u8, 2][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65002), &[1_u8, 2, 3][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65003), &[1_u8, 2, 3, 4][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65004), &[1_u8, 2, 3, 4, 5][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65001), &[1_u8, 2][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65002), &[1_u8, 2, 3][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65003), &[1_u8, 2, 3, 4][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65004), &[1_u8, 2, 3, 4, 5][..])
+            .unwrap();
     }
 
     data.set_position(0);
     {
         let mut decoder = Decoder::new(&mut data).unwrap();
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_u32_vec().unwrap(), [1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_u32_vec().unwrap(), [1, 2]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_u32_vec().unwrap(), [1, 2, 3]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_u32_vec().unwrap(), [1, 2, 3, 4]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_u32_vec().unwrap(), [1, 2, 3, 4, 5]);
+        assert_eq!(decoder.assert_tag_u32_vec(65000), [1]);
+        assert_eq!(decoder.assert_tag_u32_vec(65001), [1, 2]);
+        assert_eq!(decoder.assert_tag_u32_vec(65002), [1, 2, 3]);
+        assert_eq!(decoder.assert_tag_u32_vec(65003), [1, 2, 3, 4]);
+        assert_eq!(decoder.assert_tag_u32_vec(65004), [1, 2, 3, 4, 5]);
     }
 }
 
@@ -181,6 +245,9 @@ fn test_multiple_byte() {
 /// Test writing signed tags from TIFF 6.0
 fn test_signed() {
     let mut data = Cursor::new(Vec::new());
+    fn make_srational(i: i32) -> SRational {
+        SRational { n: i, d: 100 }
+    }
 
     {
         let mut tiff = TiffEncoder::new(&mut data).unwrap();
@@ -189,23 +256,48 @@ fn test_signed() {
 
         //Use the "reusable" tags section as per the TIFF6 spec
         encoder.write_tag(Tag::Unknown(65000), -1_i8).unwrap();
-        encoder.write_tag(Tag::Unknown(65001), &[-1_i8][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65002), &[-1_i8, 2][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65003), &[-1_i8, 2, -3][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65004), &[-1_i8, 2, -3, 4][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65005), &[-1_i8, 2, -3, 4, -5][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65001), &[-1_i8][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65002), &[-1_i8, 2][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65003), &[-1_i8, 2, -3][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65004), &[-1_i8, 2, -3, 4][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65005), &[-1_i8, 2, -3, 4, -5][..])
+            .unwrap();
 
         encoder.write_tag(Tag::Unknown(65010), -1_i16).unwrap();
         encoder.write_tag(Tag::Unknown(65011), -1_i16).unwrap();
-        encoder.write_tag(Tag::Unknown(65012), &[-1_i16, 2][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65013), &[-1_i16, 2, -3][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65012), &[-1_i16, 2][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65013), &[-1_i16, 2, -3][..])
+            .unwrap();
 
         encoder.write_tag(Tag::Unknown(65020), -1_i32).unwrap();
-        encoder.write_tag(Tag::Unknown(65021), &[-1_i32][..]).unwrap();
-        encoder.write_tag(Tag::Unknown(65022), &[-1_i32, 2][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65021), &[-1_i32][..])
+            .unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65022), &[-1_i32, 2][..])
+            .unwrap();
 
-        encoder.write_tag(Tag::Unknown(65030), SRational { n: -1, d: 100 }).unwrap();
-        encoder.write_tag(Tag::Unknown(65031), &[SRational { n: -1, d: 100 }, SRational { n: 2, d: 100 }][..]).unwrap();
+        encoder
+            .write_tag(Tag::Unknown(65030), make_srational(-1))
+            .unwrap();
+        encoder
+            .write_tag(
+                Tag::Unknown(65031),
+                &[make_srational(-1), make_srational(2)][..],
+            )
+            .unwrap();
     }
 
     //Rewind the cursor for reading
@@ -213,24 +305,24 @@ fn test_signed() {
     {
         let mut decoder = Decoder::new(&mut data).unwrap();
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_i32().unwrap(), -1, );
-        assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_i32_vec().unwrap(), [-1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_i32_vec().unwrap(), [-1, 2]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3, 4]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65005)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3, 4, -5], );
+        assert_eq!(decoder.assert_tag_i32(65000), -1);
+        assert_eq!(decoder.assert_tag_i32_vec(65001), [-1]);
+        assert_eq!(decoder.assert_tag_i32_vec(65002), [-1, 2]);
+        assert_eq!(decoder.assert_tag_i32_vec(65003), [-1, 2, -3]);
+        assert_eq!(decoder.assert_tag_i32_vec(65004), [-1, 2, -3, 4]);
+        assert_eq!(decoder.assert_tag_i32_vec(65005), [-1, 2, -3, 4, -5],);
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65010)).unwrap().into_i32().unwrap(), -1);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65011)).unwrap().into_i32_vec().unwrap(), [-1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65012)).unwrap().into_i32_vec().unwrap(), [-1, 2]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65013)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3]);
+        assert_eq!(decoder.assert_tag_i32(65010), -1);
+        assert_eq!(decoder.assert_tag_i32_vec(65011), [-1]);
+        assert_eq!(decoder.assert_tag_i32_vec(65012), [-1, 2]);
+        assert_eq!(decoder.assert_tag_i32_vec(65013), [-1, 2, -3]);
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65020)).unwrap().into_i32().unwrap(), -1);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65021)).unwrap().into_i32_vec().unwrap(), [-1]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65022)).unwrap().into_i32_vec().unwrap(), [-1, 2]);
+        assert_eq!(decoder.assert_tag_i32(65020), -1);
+        assert_eq!(decoder.assert_tag_i32_vec(65021), [-1]);
+        assert_eq!(decoder.assert_tag_i32_vec(65022), [-1, 2]);
 
-        assert_eq!(decoder.get_tag(Tag::Unknown(65030)).unwrap().into_i32_vec().unwrap(), [-1, 100]);
-        assert_eq!(decoder.get_tag(Tag::Unknown(65031)).unwrap().into_i32_vec().unwrap(), [-1_i32, 100, 2, 100]);
+        assert_eq!(decoder.assert_tag_i32_vec(65030), [-1, 100]);
+        assert_eq!(decoder.assert_tag_i32_vec(65031), [-1_i32, 100, 2, 100]);
     }
 }
 
@@ -245,10 +337,14 @@ fn test_multipage_image() {
 
         // write first grayscale image (2x2 16-bit)
         let img1: Vec<u16> = [1, 2, 3, 4].to_vec();
-        img_encoder.write_image::<colortype::Gray16>(2, 2, &img1[..]).unwrap();
+        img_encoder
+            .write_image::<colortype::Gray16>(2, 2, &img1[..])
+            .unwrap();
         // write second grayscale image (3x3 8-bit)
         let img2: Vec<u8> = [9, 8, 7, 6, 5, 4, 3, 2, 1].to_vec();
-        img_encoder.write_image::<colortype::Gray8>(3, 3, &img2[..]).unwrap();
+        img_encoder
+            .write_image::<colortype::Gray8>(3, 3, &img2[..])
+            .unwrap();
     }
 
     // seek to the beginning of the file, so that it can be decoded
@@ -263,4 +359,4 @@ fn test_multipage_image() {
         // check the dimensions of the image in the second page
         assert_eq!(img_decoder.dimensions().unwrap(), (3, 3));
     }
-}
+}