diff --git a/src/decoder/mod.rs b/src/decoder/mod.rs index 5923590..ecd924f 100644 --- a/src/decoder/mod.rs +++ b/src/decoder/mod.rs @@ -1,6 +1,6 @@ use std::collections::{HashMap, HashSet}; use std::convert::TryFrom; -use std::io::{self, Read, Seek}; +use std::io::{self, Cursor, Read, Seek}; use std::{cmp, ops::Range}; use crate::{ @@ -1030,9 +1030,8 @@ impl Decoder { // Construct necessary reader to perform decompression. self.goto_offset_u64(offset)?; let byte_order = self.reader.byte_order; - let compression_method = self.image().compression_method; - let reader = Self::create_reader(&mut self.reader, compression_method, length)?; + let reader = Self::create_reader(self, length)?; // Read into output buffer. { @@ -1068,9 +1067,9 @@ impl Decoder { } /// Decompresses the tile into the supplied buffer. - fn expand_tile<'a>( + fn expand_tile( &mut self, - mut buffer: DecodingBuffer<'a>, + mut buffer: DecodingBuffer, offset: u64, compressed_length: u64, tile: usize, @@ -1089,11 +1088,9 @@ impl Decoder { self.goto_offset_u64(offset)?; let line_samples = output_width * self.image().bits_per_sample.len(); - let compression_method = self.image().compression_method; let photometric_interpretation = self.image().photometric_interpretation; - let mut reader = - Self::create_reader(&mut self.reader, compression_method, compressed_length)?; + let mut reader = Self::create_reader(self, compressed_length)?; for row in 0..(tile_length - padding_down) { let buf = match &mut buffer { @@ -1132,18 +1129,44 @@ impl Decoder { } fn create_reader<'r>( - reader: &'r mut SmartReader, - compression_method: CompressionMethod, + decoder: &'r mut Self, compressed_length: u64, ) -> TiffResult> { + let compression_method = decoder.image().compression_method; + Ok(match compression_method { - CompressionMethod::None => Box::new(reader), - CompressionMethod::LZW => { - Box::new(LZWReader::new(reader, usize::try_from(compressed_length)?)) + CompressionMethod::None => Box::new(&mut decoder.reader), + CompressionMethod::LZW => Box::new(LZWReader::new( + &mut decoder.reader, + usize::try_from(compressed_length)?, + )), + CompressionMethod::PackBits => { + Box::new(PackBitsReader::new(&mut decoder.reader, compressed_length)) } - CompressionMethod::PackBits => Box::new(PackBitsReader::new(reader, compressed_length)), CompressionMethod::Deflate | CompressionMethod::OldDeflate => { - Box::new(DeflateReader::new(reader)) + Box::new(DeflateReader::new(&mut decoder.reader)) + } + CompressionMethod::ModernJPEG => { + if decoder.image().jpeg_tables.is_some() && compressed_length < 2 { + return Err(TiffError::FormatError( + TiffFormatError::InvalidTagValueType(Tag::JPEGTables), + )); + } + + // TODO: avoid this clone + let jpeg_tables = decoder.image().jpeg_tables.clone(); + let photometric_interpretation = decoder.image().photometric_interpretation; + + let jpeg_reader = JpegReader::new( + &mut decoder.reader, + compressed_length, + &jpeg_tables, + &photometric_interpretation, + )?; + let mut decoder = jpeg::Decoder::new(jpeg_reader); + let data = decoder.decode().unwrap(); + + Box::new(Cursor::new(data)) } method => { return Err(TiffError::UnsupportedError( @@ -1227,9 +1250,14 @@ impl Decoder { } // TODO: avoid this clone let jpeg_tables = self.image().jpeg_tables.clone(); + let photometric_interpretation = self.image().photometric_interpretation; - let jpeg_reader = - JpegReader::new(&mut self.reader, u32::try_from(length)?, &jpeg_tables)?; + let jpeg_reader = JpegReader::new( + &mut self.reader, + length, + &jpeg_tables, + &photometric_interpretation, + )?; let mut decoder = jpeg::Decoder::new(jpeg_reader); match decoder.decode() { @@ -1473,6 +1501,7 @@ impl Decoder { .as_ref() .unwrap() .get_offset(tile); + self.read_tile_to_buffer(&mut result.as_buffer(buffer_offset), tile, width)?; } @@ -1506,7 +1535,6 @@ impl Decoder { /// Decodes the entire image and return it as a Vector pub fn read_image(&mut self) -> TiffResult { let result = match (self.image().chunk_type, self.image().compression_method) { - (_, CompressionMethod::ModernJPEG) => self.read_jpeg()?, (ChunkType::Strip, _) => self.read_stripped_image()?, (ChunkType::Tile, _) => self.read_tiled_image()?, }; diff --git a/src/decoder/stream.rs b/src/decoder/stream.rs index d5af64a..b407f2f 100644 --- a/src/decoder/stream.rs +++ b/src/decoder/stream.rs @@ -3,6 +3,8 @@ use std::convert::TryFrom; use std::io::{self, BufRead, BufReader, Read, Seek, Take}; +use crate::tags::PhotometricInterpretation; + /// Byte order of the TIFF file. #[derive(Clone, Copy, Debug)] pub enum ByteOrder { @@ -189,6 +191,7 @@ impl Read for LZWReader { pub(crate) struct JpegReader { buffer: io::Cursor>, } + impl JpegReader { /// Constructs new JpegReader wrapping a SmartReader. /// Because JPEG compression in TIFF allows to save quantization and/or huffman tables in one @@ -204,14 +207,16 @@ impl JpegReader { pub fn new( reader: &mut SmartReader, - length: u32, + length: u64, jpeg_tables: &Option>, + photometric_interpretation: &PhotometricInterpretation, ) -> io::Result where R: Read + Seek, { // Read jpeg image data let mut segment = vec![0; length as usize]; + reader.read_exact(&mut segment[..])?; match jpeg_tables { @@ -229,6 +234,10 @@ impl JpegReader { ); let mut jpeg_data = tables.clone(); + if photometric_interpretation == &PhotometricInterpretation::RGB { + add_app14segment(&mut jpeg_data, JpegTagApp14Transform::App14TransformUnknown) + } + let truncated_length = jpeg_data.len() - 2; jpeg_data.truncate(truncated_length); jpeg_data.extend_from_slice(&segment[2..]); @@ -244,6 +253,58 @@ impl JpegReader { } } +#[repr(u8)] +enum JpegTagApp14Transform { + // App14TransformYCCK = 2, + // App14TransformYCbCr = 1, + App14TransformUnknown = 0, +} + +fn add_app14segment(jpeg_tables: &mut Vec, transform: JpegTagApp14Transform) { + // Add JPEG Tag APP14 Adobe segment to jpeg_tables. + // This segment stores image encoding information for DCT filters. + // When `transform` value is 0 which is defined as Unknown, jpeg-decoder interpret the + // color-space of image as RGB(3 channels) or CMYK(4). + let mut app14_offset = None; + let mut dht_offset = None; + for (offset, window) in jpeg_tables.windows(2).enumerate() { + if window == [0xff, 0xee] { + app14_offset = Some(offset); + break; + } + if window == [0xff, 0xc4] { + dht_offset = Some(offset); + } + } + match (app14_offset, dht_offset) { + (Some(i), _) => { + jpeg_tables[i + 16] = transform as u8; + } + (None, Some(sos_offset)) => { + let app14segment: [u8; 16] = [ + 0xff, + 0xee, + 0x00, + 0x0e, + 0x41, + 0x64, + 0x6f, + 0x62, + 0x65, + 0x00, + 0x64, + 0x00, + 0x00, + 0x00, + 0x00, + transform as u8, + ]; + jpeg_tables.splice(sos_offset..sos_offset, app14segment.iter().copied()); + } + (None, None) => {} + } +} + impl Read for JpegReader { // #[inline] fn read(&mut self, buf: &mut [u8]) -> io::Result { diff --git a/tests/decode_images.rs b/tests/decode_images.rs index ee6ccd1..6e01fb9 100644 --- a/tests/decode_images.rs +++ b/tests/decode_images.rs @@ -391,6 +391,10 @@ fn oom() { match err { tiff::TiffError::LimitsExceeded => {} + tiff::TiffError::UnsupportedError(tiff::TiffUnsupportedError::InterpretationWithBits( + _, + _, + )) => {} unexpected => panic!("Unexpected error {}", unexpected), } } @@ -452,6 +456,7 @@ fn invalid_jpeg_tag_2() { match err { TiffError::FormatError(TiffFormatError::InvalidTagValueType(tags::Tag::JPEGTables)) => {} + TiffError::LimitsExceeded => {} unexpected => panic!("Unexpected error {}", unexpected), } }