tiff/decoder/
stream.rs

1//! All IO functionality needed for TIFF decoding
2
3use std::convert::TryFrom;
4use std::io::{self, BufRead, BufReader, Read, Seek, Take};
5
6/// Byte order of the TIFF file.
7#[derive(Clone, Copy, Debug)]
8pub enum ByteOrder {
9    /// little endian byte order
10    LittleEndian,
11    /// big endian byte order
12    BigEndian,
13}
14
15/// Reader that is aware of the byte order.
16pub trait EndianReader: Read {
17    /// Byte order that should be adhered to
18    fn byte_order(&self) -> ByteOrder;
19
20    /// Reads an u16
21    #[inline(always)]
22    fn read_u16(&mut self) -> Result<u16, io::Error> {
23        let mut n = [0u8; 2];
24        self.read_exact(&mut n)?;
25        Ok(match self.byte_order() {
26            ByteOrder::LittleEndian => u16::from_le_bytes(n),
27            ByteOrder::BigEndian => u16::from_be_bytes(n),
28        })
29    }
30
31    /// Reads an i8
32    #[inline(always)]
33    fn read_i8(&mut self) -> Result<i8, io::Error> {
34        let mut n = [0u8; 1];
35        self.read_exact(&mut n)?;
36        Ok(match self.byte_order() {
37            ByteOrder::LittleEndian => i8::from_le_bytes(n),
38            ByteOrder::BigEndian => i8::from_be_bytes(n),
39        })
40    }
41
42    /// Reads an i16
43    #[inline(always)]
44    fn read_i16(&mut self) -> Result<i16, io::Error> {
45        let mut n = [0u8; 2];
46        self.read_exact(&mut n)?;
47        Ok(match self.byte_order() {
48            ByteOrder::LittleEndian => i16::from_le_bytes(n),
49            ByteOrder::BigEndian => i16::from_be_bytes(n),
50        })
51    }
52
53    /// Reads an u32
54    #[inline(always)]
55    fn read_u32(&mut self) -> Result<u32, io::Error> {
56        let mut n = [0u8; 4];
57        self.read_exact(&mut n)?;
58        Ok(match self.byte_order() {
59            ByteOrder::LittleEndian => u32::from_le_bytes(n),
60            ByteOrder::BigEndian => u32::from_be_bytes(n),
61        })
62    }
63
64    /// Reads an i32
65    #[inline(always)]
66    fn read_i32(&mut self) -> Result<i32, io::Error> {
67        let mut n = [0u8; 4];
68        self.read_exact(&mut n)?;
69        Ok(match self.byte_order() {
70            ByteOrder::LittleEndian => i32::from_le_bytes(n),
71            ByteOrder::BigEndian => i32::from_be_bytes(n),
72        })
73    }
74
75    /// Reads an u64
76    #[inline(always)]
77    fn read_u64(&mut self) -> Result<u64, io::Error> {
78        let mut n = [0u8; 8];
79        self.read_exact(&mut n)?;
80        Ok(match self.byte_order() {
81            ByteOrder::LittleEndian => u64::from_le_bytes(n),
82            ByteOrder::BigEndian => u64::from_be_bytes(n),
83        })
84    }
85
86    /// Reads an i64
87    #[inline(always)]
88    fn read_i64(&mut self) -> Result<i64, io::Error> {
89        let mut n = [0u8; 8];
90        self.read_exact(&mut n)?;
91        Ok(match self.byte_order() {
92            ByteOrder::LittleEndian => i64::from_le_bytes(n),
93            ByteOrder::BigEndian => i64::from_be_bytes(n),
94        })
95    }
96
97    /// Reads an f32
98    #[inline(always)]
99    fn read_f32(&mut self) -> Result<f32, io::Error> {
100        let mut n = [0u8; 4];
101        self.read_exact(&mut n)?;
102        Ok(f32::from_bits(match self.byte_order() {
103            ByteOrder::LittleEndian => u32::from_le_bytes(n),
104            ByteOrder::BigEndian => u32::from_be_bytes(n),
105        }))
106    }
107
108    /// Reads an f64
109    #[inline(always)]
110    fn read_f64(&mut self) -> Result<f64, io::Error> {
111        let mut n = [0u8; 8];
112        self.read_exact(&mut n)?;
113        Ok(f64::from_bits(match self.byte_order() {
114            ByteOrder::LittleEndian => u64::from_le_bytes(n),
115            ByteOrder::BigEndian => u64::from_be_bytes(n),
116        }))
117    }
118}
119
120///
121/// # READERS
122///
123
124///
125/// ## Deflate Reader
126///
127
128pub type DeflateReader<R> = flate2::read::ZlibDecoder<R>;
129
130///
131/// ## LZW Reader
132///
133
134/// Reader that decompresses LZW streams
135pub struct LZWReader<R: Read> {
136    reader: BufReader<Take<R>>,
137    decoder: weezl::decode::Decoder,
138}
139
140impl<R: Read> LZWReader<R> {
141    /// Wraps a reader
142    pub fn new(reader: R, compressed_length: usize) -> LZWReader<R> {
143        Self {
144            reader: BufReader::with_capacity(
145                (32 * 1024).min(compressed_length),
146                reader.take(u64::try_from(compressed_length).unwrap()),
147            ),
148            decoder: weezl::decode::Decoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8),
149        }
150    }
151}
152
153impl<R: Read> Read for LZWReader<R> {
154    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
155        loop {
156            let result = self.decoder.decode_bytes(self.reader.fill_buf()?, buf);
157            self.reader.consume(result.consumed_in);
158
159            match result.status {
160                Ok(weezl::LzwStatus::Ok) => {
161                    if result.consumed_out == 0 {
162                        continue;
163                    } else {
164                        return Ok(result.consumed_out);
165                    }
166                }
167                Ok(weezl::LzwStatus::NoProgress) => {
168                    assert_eq!(result.consumed_in, 0);
169                    assert_eq!(result.consumed_out, 0);
170                    assert!(self.reader.buffer().is_empty());
171                    return Err(io::Error::new(
172                        io::ErrorKind::UnexpectedEof,
173                        "no lzw end code found",
174                    ));
175                }
176                Ok(weezl::LzwStatus::Done) => {
177                    return Ok(result.consumed_out);
178                }
179                Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidData, err)),
180            }
181        }
182    }
183}
184
185///
186/// ## PackBits Reader
187///
188
189enum PackBitsReaderState {
190    Header,
191    Literal,
192    Repeat { value: u8 },
193}
194
195/// Reader that unpacks Apple's `PackBits` format
196pub struct PackBitsReader<R: Read> {
197    reader: Take<R>,
198    state: PackBitsReaderState,
199    count: usize,
200}
201
202impl<R: Read> PackBitsReader<R> {
203    /// Wraps a reader
204    pub fn new(reader: R, length: u64) -> Self {
205        Self {
206            reader: reader.take(length),
207            state: PackBitsReaderState::Header,
208            count: 0,
209        }
210    }
211}
212
213impl<R: Read> Read for PackBitsReader<R> {
214    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
215        while let PackBitsReaderState::Header = self.state {
216            if self.reader.limit() == 0 {
217                return Ok(0);
218            }
219            let mut header: [u8; 1] = [0];
220            self.reader.read_exact(&mut header)?;
221            let h = header[0] as i8;
222            if (-127..=-1).contains(&h) {
223                let mut data: [u8; 1] = [0];
224                self.reader.read_exact(&mut data)?;
225                self.state = PackBitsReaderState::Repeat { value: data[0] };
226                self.count = (1 - h as isize) as usize;
227            } else if h >= 0 {
228                self.state = PackBitsReaderState::Literal;
229                self.count = h as usize + 1;
230            } else {
231                // h = -128 is a no-op.
232            }
233        }
234
235        let length = buf.len().min(self.count);
236        let actual = match self.state {
237            PackBitsReaderState::Literal => self.reader.read(&mut buf[..length])?,
238            PackBitsReaderState::Repeat { value } => {
239                for b in &mut buf[..length] {
240                    *b = value;
241                }
242
243                length
244            }
245            PackBitsReaderState::Header => unreachable!(),
246        };
247
248        self.count -= actual;
249        if self.count == 0 {
250            self.state = PackBitsReaderState::Header;
251        }
252        Ok(actual)
253    }
254}
255
256///
257/// ## SmartReader Reader
258///
259
260/// Reader that is aware of the byte order.
261#[derive(Debug)]
262pub struct SmartReader<R>
263where
264    R: Read,
265{
266    reader: R,
267    pub byte_order: ByteOrder,
268}
269
270impl<R> SmartReader<R>
271where
272    R: Read,
273{
274    /// Wraps a reader
275    pub fn wrap(reader: R, byte_order: ByteOrder) -> SmartReader<R> {
276        SmartReader { reader, byte_order }
277    }
278    pub fn into_inner(self) -> R {
279        self.reader
280    }
281}
282impl<R: Read + Seek> SmartReader<R> {
283    pub fn goto_offset(&mut self, offset: u64) -> io::Result<()> {
284        self.seek(io::SeekFrom::Start(offset)).map(|_| ())
285    }
286}
287
288impl<R> EndianReader for SmartReader<R>
289where
290    R: Read,
291{
292    #[inline(always)]
293    fn byte_order(&self) -> ByteOrder {
294        self.byte_order
295    }
296}
297
298impl<R: Read> Read for SmartReader<R> {
299    #[inline]
300    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
301        self.reader.read(buf)
302    }
303}
304
305impl<R: Read + Seek> Seek for SmartReader<R> {
306    #[inline]
307    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
308        self.reader.seek(pos)
309    }
310}
311
312#[cfg(test)]
313mod test {
314    use super::*;
315
316    #[test]
317    fn test_packbits() {
318        let encoded = vec![
319            0xFE, 0xAA, 0x02, 0x80, 0x00, 0x2A, 0xFD, 0xAA, 0x03, 0x80, 0x00, 0x2A, 0x22, 0xF7,
320            0xAA,
321        ];
322        let encoded_len = encoded.len();
323
324        let buff = io::Cursor::new(encoded);
325        let mut decoder = PackBitsReader::new(buff, encoded_len as u64);
326
327        let mut decoded = Vec::new();
328        decoder.read_to_end(&mut decoded).unwrap();
329
330        let expected = vec![
331            0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0x22,
332            0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
333        ];
334        assert_eq!(decoded, expected);
335    }
336}
tiff/decoder/stream.rs

tiff/decoder/
stream.rs
