1 //! All IO functionality needed for TIFF decoding
2
3 use std::io::{self, Read, Seek};
4 use byteorder::{ReadBytesExt, BigEndian, LittleEndian};
5 use lzw;
6
7 /// Byte order of the TIFF file.
8 #[derive(Clone, Copy, Debug)]
9 pub enum ByteOrder {
10 /// little endian byte order
11 LittleEndian,
12 /// big endian byte order
13 BigEndian
14 }
15
16
17 /// Reader that is aware of the byte order.
18 pub trait EndianReader: Read {
19 /// Byte order that should be adhered to
byte_order(&self) -> ByteOrder20 fn byte_order(&self) -> ByteOrder;
21
22 /// Reads an u16
23 #[inline(always)]
read_u16(&mut self) -> Result<u16, io::Error>24 fn read_u16(&mut self) -> Result<u16, io::Error> {
25 match self.byte_order() {
26 ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u16::<LittleEndian>(self),
27 ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u16::<BigEndian>(self)
28 }
29 }
30
31 #[inline(always)]
read_u16_into(&mut self, buffer: &mut [u16]) -> Result<(), io::Error>32 fn read_u16_into(&mut self, buffer: &mut [u16]) -> Result<(), io::Error> {
33 match self.byte_order() {
34 ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u16_into::<LittleEndian>(self, buffer),
35 ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u16_into::<BigEndian>(self, buffer)
36 }
37 }
38
39 /// Reads an u32
40 #[inline(always)]
read_u32(&mut self) -> Result<u32, io::Error>41 fn read_u32(&mut self) -> Result<u32, io::Error> {
42 match self.byte_order() {
43 ByteOrder::LittleEndian => <Self as ReadBytesExt>::read_u32::<LittleEndian>(self),
44 ByteOrder::BigEndian => <Self as ReadBytesExt>::read_u32::<BigEndian>(self)
45 }
46 }
47 }
48
49 /// Reader that decompresses LZW streams
50 pub struct LZWReader {
51 buffer: io::Cursor<Vec<u8>>,
52 byte_order: ByteOrder
53 }
54
55 impl LZWReader {
56 /// Wraps a reader
new<R>(reader: &mut SmartReader<R>, compressed_length: usize, max_uncompressed_length: usize) -> io::Result<(usize, LZWReader)> where R: Read + Seek57 pub fn new<R>(reader: &mut SmartReader<R>, compressed_length: usize, max_uncompressed_length: usize) -> io::Result<(usize, LZWReader)> where R: Read + Seek {
58 let order = reader.byte_order;
59 let mut compressed = vec![0; compressed_length as usize];
60 try!(reader.read_exact(&mut compressed[..]));
61 let mut uncompressed = Vec::with_capacity(max_uncompressed_length);
62 let mut decoder = lzw::DecoderEarlyChange::new(lzw::MsbReader::new(), 8);
63 let mut bytes_read = 0;
64 while bytes_read < compressed_length && uncompressed.len() < max_uncompressed_length {
65 let (len, bytes) = try!(decoder.decode_bytes(&compressed[bytes_read..]));
66 bytes_read += len;
67 uncompressed.extend_from_slice(bytes);
68 }
69
70 let bytes = uncompressed.len();
71 Ok((bytes, LZWReader {
72 buffer: io::Cursor::new(uncompressed),
73 byte_order: order
74 }))
75 }
76 }
77
78 impl Read for LZWReader {
79 #[inline]
read(&mut self, buf: &mut [u8]) -> io::Result<usize>80 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
81 self.buffer.read(buf)
82 }
83 }
84
85 impl EndianReader for LZWReader {
86 #[inline(always)]
byte_order(&self) -> ByteOrder87 fn byte_order(&self) -> ByteOrder {
88 self.byte_order
89 }
90 }
91
92 /// Reader that unpacks Apple's `PackBits` format
93 pub struct PackBitsReader {
94 buffer: io::Cursor<Vec<u8>>,
95 byte_order: ByteOrder
96 }
97
98 impl PackBitsReader {
99 /// Wraps a reader
new<R: Read + Seek>(mut reader: R, byte_order: ByteOrder, length: usize) -> io::Result<(usize, PackBitsReader)>100 pub fn new<R: Read + Seek>(mut reader: R, byte_order: ByteOrder, length: usize) -> io::Result<(usize, PackBitsReader)> {
101 let mut buffer = Vec::new();
102 let mut read: usize = 0;
103 while read < length {
104 read += try!(read_packbits_run(&mut reader, &mut buffer));
105 }
106 Ok((buffer.len(), PackBitsReader {
107 buffer: io::Cursor::new(buffer),
108 byte_order
109 }))
110 }
111 }
112
read_packbits_run<R: Read + Seek>(reader: &mut R, buffer: &mut Vec<u8>) -> io::Result<usize>113 fn read_packbits_run<R: Read + Seek>(reader: &mut R, buffer: &mut Vec<u8>) -> io::Result<usize> {
114 let mut header: [u8; 1] = [0];
115
116 let bytes = try!(reader.read(&mut header));
117
118 match bytes {
119 0 => Ok(0),
120 _ => match header[0] as i8 {
121 -128 => Ok(1),
122 h if h >= -127 && h <= -1 => {
123 let new_len = buffer.len() + (1 - h as isize) as usize;
124 try!(reader.read_exact(&mut header));
125 buffer.resize(new_len, header[0]);
126 Ok(2)
127 },
128 h => {
129 let num_vals = h as usize + 1;
130 let start = buffer.len();
131 buffer.resize(start + num_vals, 0);
132 try!(reader.read_exact(&mut buffer[start..]));
133 Ok(num_vals + 1)
134 }
135 }
136 }
137 }
138
139 impl Read for PackBitsReader {
140 #[inline]
read(&mut self, buf: &mut [u8]) -> io::Result<usize>141 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
142 self.buffer.read(buf)
143 }
144 }
145
146 impl EndianReader for PackBitsReader {
147 #[inline(always)]
byte_order(&self) -> ByteOrder148 fn byte_order(&self) -> ByteOrder {
149 self.byte_order
150 }
151 }
152
153 /// Reader that is aware of the byte order.
154 #[derive(Debug)]
155 pub struct SmartReader<R> where R: Read + Seek {
156 reader: R,
157 pub byte_order: ByteOrder
158 }
159
160 impl<R> SmartReader<R> where R: Read + Seek {
161 /// Wraps a reader
wrap(reader: R, byte_order: ByteOrder) -> SmartReader<R>162 pub fn wrap(reader: R, byte_order: ByteOrder) -> SmartReader<R> {
163 SmartReader { reader, byte_order }
164 }
165 }
166
167 impl<R> EndianReader for SmartReader<R> where R: Read + Seek {
168 #[inline(always)]
byte_order(&self) -> ByteOrder169 fn byte_order(&self) -> ByteOrder {
170 self.byte_order
171 }
172 }
173
174 impl<R: Read + Seek> Read for SmartReader<R> {
175 #[inline]
read(&mut self, buf: &mut [u8]) -> io::Result<usize>176 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
177 self.reader.read(buf)
178 }
179 }
180
181 impl<R: Read + Seek> Seek for SmartReader<R> {
182 #[inline]
seek(&mut self, pos: io::SeekFrom) -> io::Result<u64>183 fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
184 self.reader.seek(pos)
185 }
186 }
187
188 #[cfg(test)]
189 mod test {
190 use super::*;
191
192 #[test]
test_packbits()193 fn test_packbits() {
194 let encoded = vec![0xFE, 0xAA, 0x02, 0x80, 0x00, 0x2A, 0xFD, 0xAA,
195 0x03, 0x80, 0x00, 0x2A, 0x22, 0xF7, 0xAA];
196 let encoded_len = encoded.len();
197
198 let buff = io::Cursor::new(encoded);
199 let (_, mut decoder) = PackBitsReader::new(buff, ByteOrder::LittleEndian, encoded_len).unwrap();
200
201 let mut decoded = Vec::new();
202 decoder.read_to_end(&mut decoded).unwrap();
203
204 let expected = vec![0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0xAA, 0xAA,
205 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0x22, 0xAA, 0xAA,
206 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA];
207 assert_eq!(decoded, expected);
208 }
209 }
210