Add old-style DEFLATE support

src/decoder/mod.rs

@@ -7,7 +7,7 @@ use {ColorType, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError};
 
 use self::ifd::Directory;
 
-use self::stream::{ByteOrder, EndianReader, LZWReader, PackBitsReader, SmartReader};
+use self::stream::{ByteOrder, EndianReader, LZWReader, DeflateReader, PackBitsReader, SmartReader};
 
 pub mod ifd;
 mod stream;
@@ -579,6 +579,12 @@ impl<R: Read + Seek> Decoder<R> {
                 )?;
                 (bytes, Box::new(reader))
             }
+            CompressionMethod::OldDeflate => {
+                let (bytes, reader) = DeflateReader::new(
+                    &mut self.reader,
+                    max_uncompressed_length)?;
+                (bytes, Box::new(reader))
+            }
             method => {
                 return Err(TiffError::UnsupportedError(
                     TiffUnsupportedError::UnsupportedCompressionMethod(method),

src/decoder/stream.rs

@@ -3,6 +3,7 @@
 use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
 use lzw;
 use std::io::{self, Read, Seek};
+use libflate::zlib;
 
 /// Byte order of the TIFF file.
 #[derive(Clone, Copy, Debug)]
@@ -67,6 +68,40 @@ pub trait EndianReader: Read {
     }
 }
 
+/// Reader that decompresses DEFLATE streams
+pub struct DeflateReader {
+    buffer: io::Cursor<Vec<u8>>,
+    byte_order: ByteOrder,
+}
+
+impl DeflateReader {
+    pub fn new<R: Read + Seek>(
+        reader: &mut SmartReader<R>,
+        max_uncompressed_length: usize,
+    ) -> io::Result<(usize, Self)> {
+        let byte_order = reader.byte_order;
+        let mut decoder = zlib::Decoder::new(reader)?;
+        let mut uncompressed = Vec::with_capacity(max_uncompressed_length);
+        let bytes_read = decoder.read_to_end(&mut uncompressed)?;
+        Ok((bytes_read, Self {
+            byte_order,
+            buffer: io::Cursor::new(uncompressed),
+        }))
+    }
+}
+
+impl Read for DeflateReader {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.buffer.read(buf)
+    }
+}
+
+impl EndianReader for DeflateReader {
+    fn byte_order(&self) -> ByteOrder {
+        self.byte_order
+    }
+}
+
 /// Reader that decompresses LZW streams
 pub struct LZWReader {
     buffer: io::Cursor<Vec<u8>>,