Remove redundant limit on LZWReader output length

src/decoder/mod.rs

@@ -1036,8 +1036,6 @@ impl<R: Read + Seek> Decoder<R> {
             &mut self.reader,
             compression_method,
             length,
-            buffer.len(),
-            buffer.byte_len(),
         )?;
 
         // Read into output buffer.
@@ -1088,7 +1086,6 @@ impl<R: Read + Seek> Decoder<R> {
 
         let tile_attrs = self.image().tile_attributes.as_ref().unwrap();
         let (padding_right, padding_down) = tile_attrs.get_padding(tile);
-        let tile_samples = tile_attrs.tile_samples();
         let tile_length = tile_attrs.tile_length;
         let row_samples = tile_attrs.row_samples();
         let padding_right_samples = padding_right * self.image().bits_per_sample.len();
@@ -1103,8 +1100,6 @@ impl<R: Read + Seek> Decoder<R> {
             &mut self.reader,
             compression_method,
             compressed_length,
-            tile_samples,
-            byte_len,
         )?;
 
         for row in 0..(tile_length - padding_down) {
@@ -1147,16 +1142,12 @@ impl<R: Read + Seek> Decoder<R> {
         reader: &'r mut SmartReader<R>,
         compression_method: CompressionMethod,
         compressed_length: u64,
-        samples: usize,  // Expected chunk length in samples
-        byte_len: usize, // Byte length of the samples in result buffer
     ) -> TiffResult<Box<dyn Read + 'r>> {
         Ok(match compression_method {
             CompressionMethod::None => Box::new(reader),
-            CompressionMethod::LZW => Box::new(LZWReader::new(
+            CompressionMethod::LZW => {
-                reader,
+                Box::new(LZWReader::new(reader, usize::try_from(compressed_length)?))
-                usize::try_from(compressed_length)?,
+            }
-                samples * byte_len,
-            )),
             CompressionMethod::PackBits => {
                 Box::new(PackBitsReader::new(reader, usize::try_from(compressed_length)?)?.1)
             }

src/decoder/stream.rs

@@ -135,7 +135,6 @@ pub type DeflateReader<'r, R> = flate2::read::ZlibDecoder<&'r mut SmartReader<R>
 pub struct LZWReader<R: Read> {
     reader: BufReader<Take<R>>,
     decoder: weezl::decode::Decoder,
-    output_remaining: usize,
 }
 
 impl<R: Read> LZWReader<R> {
@@ -143,7 +142,6 @@ impl<R: Read> LZWReader<R> {
     pub fn new(
         reader: R,
         compressed_length: usize,
-        max_uncompressed_length: usize,
     ) -> LZWReader<R> {
         Self {
             reader: BufReader::with_capacity(
@@ -151,25 +149,17 @@ impl<R: Read> LZWReader<R> {
                 reader.take(u64::try_from(compressed_length).unwrap()),
             ),
             decoder: weezl::decode::Decoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8),
-            output_remaining: max_uncompressed_length,
         }
     }
 }
 
 impl<R: Read> Read for LZWReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        if self.output_remaining == 0 {
-            return Ok(0);
-        }
-
         loop {
-            let max_output_length = self.output_remaining.min(buf.len());
             let result = self
                 .decoder
-                .decode_bytes(self.reader.fill_buf()?, &mut buf[..max_output_length]);
+                .decode_bytes(self.reader.fill_buf()?, buf);
-
             self.reader.consume(result.consumed_in);
-            self.output_remaining -= result.consumed_out;
 
             match result.status {
                 Ok(weezl::LzwStatus::Ok) => {
@@ -189,7 +179,6 @@ impl<R: Read> Read for LZWReader<R> {
                     ));
                 }
                 Ok(weezl::LzwStatus::Done) => {
-                    self.output_remaining = 0;
                     return Ok(result.consumed_out);
                 }
                 Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidData, err)),