/rust/registry/src/index.crates.io-6f17d22bba15001f/tiff-0.10.0/src/decoder/stream.rs

Source (jump to first uncovered line)
//! All IO functionality needed for TIFF decoding

use std::io::{self, BufRead, BufReader, Read, Seek, Take};

/// Byte order of the TIFF file.
#[derive(Clone, Copy, Debug)]
pub enum ByteOrder {
    /// little endian byte order
    LittleEndian,
    /// big endian byte order
    BigEndian,
}

/// Reader that is aware of the byte order.
#[derive(Debug)]
pub struct EndianReader<R> {
    reader: R,
    pub(crate) byte_order: ByteOrder,
}

impl<R: Read + Seek> EndianReader<R> {
    pub fn new(reader: R, byte_order: ByteOrder) -> Self {
        Self { reader, byte_order }
    }

    pub fn inner(&mut self) -> &mut R {
        &mut self.reader
    }

    pub fn goto_offset(&mut self, offset: u64) -> io::Result<()> {
        self.reader.seek(io::SeekFrom::Start(offset))?;
        Ok(())
    }

    /// Reads an u16
    #[inline(always)]
    pub fn read_u16(&mut self) -> Result<u16, io::Error> {
        let mut n = [0u8; 2];
        self.reader.read_exact(&mut n)?;
        Ok(match self.byte_order {
            ByteOrder::LittleEndian => u16::from_le_bytes(n),
            ByteOrder::BigEndian => u16::from_be_bytes(n),
        })
    }

    /// Reads an i8
    #[inline(always)]
    pub fn read_i8(&mut self) -> Result<i8, io::Error> {
        let mut n = [0u8; 1];
        self.reader.read_exact(&mut n)?;
        Ok(match self.byte_order {
            ByteOrder::LittleEndian => i8::from_le_bytes(n),
            ByteOrder::BigEndian => i8::from_be_bytes(n),
        })
    }

    /// Reads an i16
    #[inline(always)]
    pub fn read_i16(&mut self) -> Result<i16, io::Error> {
        let mut n = [0u8; 2];
        self.reader.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)]
    pub fn read_u32(&mut self) -> Result<u32, io::Error> {
        let mut n = [0u8; 4];
        self.reader.read_exact(&mut n)?;
        Ok(match self.byte_order {
            ByteOrder::LittleEndian => u32::from_le_bytes(n),
            ByteOrder::BigEndian => u32::from_be_bytes(n),
        })
    }

    /// Reads an i32
    #[inline(always)]
    pub fn read_i32(&mut self) -> Result<i32, io::Error> {
        let mut n = [0u8; 4];
        self.reader.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)]
    pub fn read_u64(&mut self) -> Result<u64, io::Error> {
        let mut n = [0u8; 8];
        self.reader.read_exact(&mut n)?;
        Ok(match self.byte_order {
            ByteOrder::LittleEndian => u64::from_le_bytes(n),
            ByteOrder::BigEndian => u64::from_be_bytes(n),
        })
    }

    /// Reads an i64
    #[inline(always)]
    pub fn read_i64(&mut self) -> Result<i64, io::Error> {
        let mut n = [0u8; 8];
        self.reader.read_exact(&mut n)?;
        Ok(match self.byte_order {
            ByteOrder::LittleEndian => i64::from_le_bytes(n),
            ByteOrder::BigEndian => i64::from_be_bytes(n),
        })
    }

    /// Reads an f32
    #[inline(always)]
    pub fn read_f32(&mut self) -> Result<f32, io::Error> {
        let mut n = [0u8; 4];
        self.reader.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),
        }))
    }

    /// Reads an f64
    #[inline(always)]
    pub fn read_f64(&mut self) -> Result<f64, io::Error> {
        let mut n = [0u8; 8];
        self.reader.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),
        }))
    }
}

///
/// # READERS
///

///
/// ## Deflate Reader
///

#[cfg(feature = "deflate")]
pub type DeflateReader<R> = flate2::read::ZlibDecoder<R>;

///
/// ## LZW Reader
///

/// Reader that decompresses LZW streams
#[cfg(feature = "lzw")]
pub struct LZWReader<R: Read> {
    reader: BufReader<Take<R>>,
    decoder: weezl::decode::Decoder,
}

#[cfg(feature = "lzw")]
impl<R: Read> LZWReader<R> {
    /// Wraps a reader
    pub fn new(reader: R, compressed_length: usize) -> LZWReader<R> {
        Self {
            reader: BufReader::with_capacity(
                (32 * 1024).min(compressed_length),
                reader.take(u64::try_from(compressed_length).unwrap()),
            ),
            decoder: weezl::decode::Decoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8),
        }
    }
}

#[cfg(feature = "lzw")]
impl<R: Read> Read for LZWReader<R> {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        loop {
            let result = self.decoder.decode_bytes(self.reader.fill_buf()?, buf);
            self.reader.consume(result.consumed_in);

            match result.status {
                Ok(weezl::LzwStatus::Ok) => {
                    if result.consumed_out == 0 {
                        continue;
                    } else {
                        return Ok(result.consumed_out);
                    }
                }
                Ok(weezl::LzwStatus::NoProgress) => {
                    assert_eq!(result.consumed_in, 0);
                    assert_eq!(result.consumed_out, 0);
                    assert!(self.reader.buffer().is_empty());
                    return Err(io::Error::new(
                        io::ErrorKind::UnexpectedEof,
                        "no lzw end code found",
                    ));
                }
                Ok(weezl::LzwStatus::Done) => {
                    return Ok(result.consumed_out);
                }
                Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidData, err)),
            }
        }
    }
}

///
/// ## PackBits Reader
///

enum PackBitsReaderState {
    Header,
    Literal,
    Repeat { value: u8 },
}

/// Reader that unpacks Apple's `PackBits` format
pub struct PackBitsReader<R: Read> {
    reader: Take<R>,
    state: PackBitsReaderState,
    count: usize,
}

impl<R: Read> PackBitsReader<R> {
    /// Wraps a reader
    pub fn new(reader: R, length: u64) -> Self {
        Self {
            reader: reader.take(length),
            state: PackBitsReaderState::Header,
            count: 0,
        }
    }
}

impl<R: Read> Read for PackBitsReader<R> {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        while let PackBitsReaderState::Header = self.state {
            if self.reader.limit() == 0 {
                return Ok(0);
            }
            let mut header: [u8; 1] = [0];
            self.reader.read_exact(&mut header)?;
            let h = header[0] as i8;
            if (-127..=-1).contains(&h) {
                let mut data: [u8; 1] = [0];
                self.reader.read_exact(&mut data)?;
                self.state = PackBitsReaderState::Repeat { value: data[0] };
                self.count = (1 - h as isize) as usize;
            } else if h >= 0 {
                self.state = PackBitsReaderState::Literal;
                self.count = h as usize + 1;
            } else {
                // h = -128 is a no-op.
            }
        }

        let length = buf.len().min(self.count);
        let actual = match self.state {
            PackBitsReaderState::Literal => self.reader.read(&mut buf[..length])?,
            PackBitsReaderState::Repeat { value } => {
                for b in &mut buf[..length] {
                    *b = value;
                }

                length
            }
            PackBitsReaderState::Header => unreachable!(),
        };

        self.count -= actual;
        if self.count == 0 {
            self.state = PackBitsReaderState::Header;
        }
        Ok(actual)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_packbits() {
        let encoded = vec![
            0xFE, 0xAA, 0x02, 0x80, 0x00, 0x2A, 0xFD, 0xAA, 0x03, 0x80, 0x00, 0x2A, 0x22, 0xF7,
            0xAA,
        ];
        let encoded_len = encoded.len();

        let buff = io::Cursor::new(encoded);
        let mut decoder = PackBitsReader::new(buff, encoded_len as u64);

        let mut decoded = Vec::new();
        decoder.read_to_end(&mut decoded).unwrap();

        let expected = vec![
            0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0x22,
            0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
        ];
        assert_eq!(decoded, expected);
    }
}

Coverage Report

Created: 2025-07-01 06:50

Line	Count	Source (jump to first uncovered line)
1		//! All IO functionality needed for TIFF decoding
2
3		use std::io::{self, BufRead, BufReader, Read, Seek, Take};
4
5		/// Byte order of the TIFF file.
6		#[derive(Clone, Copy, Debug)]
7		pub enum ByteOrder {
8		/// little endian byte order
9		LittleEndian,
10		/// big endian byte order
11		BigEndian,
12		}
13
14		/// Reader that is aware of the byte order.
15		#[derive(Debug)]
16		pub struct EndianReader<R> {
17		reader: R,
18		pub(crate) byte_order: ByteOrder,
19		}
20
21		impl<R: Read + Seek> EndianReader<R> {
22	0	pub fn new(reader: R, byte_order: ByteOrder) -> Self {
23	0	Self { reader, byte_order }
24	0	} Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<alloc::vec::Vec<u8>>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::new
25
26	0	pub fn inner(&mut self) -> &mut R {
27	0	&mut self.reader
28	0	} Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<_>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::inner
29
30	0	pub fn goto_offset(&mut self, offset: u64) -> io::Result<()> {
31	0	self.reader.seek(io::SeekFrom::Start(offset))?;
32	0	Ok(())
33	0	} Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<_>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset Unexecuted instantiation: <tiff::decoder::stream::EndianReader<std::io::cursor::Cursor<&[u8]>>>::goto_offset
34
35		/// Reads an u16
36		#[inline(always)]
37	0	pub fn read_u16(&mut self) -> Result<u16, io::Error> {
38	0	let mut n = [0u8; 2];
39	0	self.reader.read_exact(&mut n)?;