diff --git a/src/decoder/ifd.rs b/src/decoder/ifd.rs index 672bb87..82181b0 100644 --- a/src/decoder/ifd.rs +++ b/src/decoder/ifd.rs @@ -242,7 +242,7 @@ impl Entry { (Type::SSHORT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { Ok(Signed(i32::from(decoder.read_sshort()?))) }), - (Type::LONG, 1) => Ok(Unsigned(try!(self.r(bo).read_u32()))), + (Type::LONG, 1) => Ok(Unsigned(self.r(bo).read_u32()?)), (Type::SLONG, 1) => Ok(Signed(self.r(bo).read_i32()?)), (Type::LONG, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { Ok(Unsigned(decoder.read_long()?)) @@ -251,9 +251,9 @@ impl Entry { Ok(Signed(decoder.read_slong()?)) }), (Type::RATIONAL, 1) => { - try!(decoder.goto_offset(try!(self.r(bo).read_u32()))); - let numerator = try!(decoder.read_long()); - let denominator = try!(decoder.read_long()); + decoder.goto_offset(self.r(bo).read_u32()?)?; + let numerator = decoder.read_long()?; + let denominator = decoder.read_long()?; Ok(Rational(numerator, denominator)) } (Type::SRATIONAL, 1) => { @@ -278,8 +278,8 @@ impl Entry { if n as usize > limits.decoding_buffer_size { return Err(TiffError::LimitsExceeded); } - try!(decoder.goto_offset(try!(self.r(bo).read_u32()))); - let string = try!(decoder.read_string(n as usize)); + decoder.goto_offset(self.r(bo).read_u32()?)?; + let string = decoder.read_string(n as usize)?; Ok(Ascii(string)) } _ => Err(TiffError::UnsupportedError( diff --git a/src/decoder/mod.rs b/src/decoder/mod.rs index 7a052d7..dd1ad32 100644 --- a/src/decoder/mod.rs +++ b/src/decoder/mod.rs @@ -284,7 +284,7 @@ impl Decoder { fn read_header(&mut self) -> TiffResult<()> { let mut endianess = Vec::with_capacity(2); - try!(self.reader.by_ref().take(2).read_to_end(&mut endianess)); + self.reader.by_ref().take(2).read_to_end(&mut endianess)?; match &*endianess { b"II" => { self.byte_order = ByteOrder::LittleEndian; @@ -300,12 +300,12 @@ impl Decoder { )) } } - if try!(self.read_short()) != 42 { + if self.read_short()? != 42 { return Err(TiffError::FormatError( TiffFormatError::TiffSignatureInvalid, )); } - self.next_ifd = match try!(self.read_long()) { + self.next_ifd = match self.read_long()? { 0 => None, n => Some(n), }; @@ -314,7 +314,7 @@ impl Decoder { /// Initializes the decoder. pub fn init(mut self) -> TiffResult> { - try!(self.read_header()); + self.read_header()?; self.next_image()?; Ok(self) } @@ -323,13 +323,13 @@ impl Decoder { /// If there is no further image in the TIFF file a format error is returned. /// To determine whether there are more images call `TIFFDecoder::more_images` instead. pub fn next_image(&mut self) -> TiffResult<()> { - self.ifd = Some(try!(self.read_ifd())); - self.width = try!(self.get_tag_u32(ifd::Tag::ImageWidth)); - self.height = try!(self.get_tag_u32(ifd::Tag::ImageLength)); + self.ifd = Some(self.read_ifd()?); + self.width = self.get_tag_u32(ifd::Tag::ImageWidth)?; + self.height = self.get_tag_u32(ifd::Tag::ImageLength)?; self.strip_decoder = None; - self.photometric_interpretation = match FromPrimitive::from_u32(try!( - self.get_tag_u32(ifd::Tag::PhotometricInterpretation) - )) { + self.photometric_interpretation = match FromPrimitive::from_u32( + self.get_tag_u32(ifd::Tag::PhotometricInterpretation)? + ) { Some(val) => val, None => { return Err(TiffError::UnsupportedError( @@ -337,7 +337,7 @@ impl Decoder { )) } }; - if let Some(val) = try!(self.find_tag_u32(ifd::Tag::Compression)) { + if let Some(val) = self.find_tag_u32(ifd::Tag::Compression)? { match FromPrimitive::from_u32(val) { Some(method) => self.compression_method = method, None => { @@ -347,17 +347,17 @@ impl Decoder { } } } - if let Some(val) = try!(self.find_tag_u32(ifd::Tag::SamplesPerPixel)) { + if let Some(val) = self.find_tag_u32(ifd::Tag::SamplesPerPixel)? { self.samples = val as u8 } match self.samples { 1 => { - if let Some(val) = try!(self.find_tag_u32(ifd::Tag::BitsPerSample)) { + if let Some(val) = self.find_tag_u32(ifd::Tag::BitsPerSample)? { self.bits_per_sample = vec![val as u8] } } 3 | 4 => { - if let Some(val) = try!(self.find_tag_u32_vec(ifd::Tag::BitsPerSample)) { + if let Some(val) = self.find_tag_u32_vec(ifd::Tag::BitsPerSample)? { self.bits_per_sample = val.iter().map(|&v| v as u8).collect() } } @@ -426,7 +426,7 @@ impl Decoder { #[inline] pub fn read_offset(&mut self) -> Result<[u8; 4], io::Error> { let mut val = [0; 4]; - try!(self.reader.read_exact(&mut val)); + self.reader.read_exact(&mut val)?; Ok(val) } @@ -446,13 +446,13 @@ impl Decoder { // Count 4 bytes // Value 4 bytes either a pointer the value itself fn read_entry(&mut self) -> TiffResult> { - let tag = ifd::Tag::from_u16(try!(self.read_short())); - let type_: ifd::Type = match FromPrimitive::from_u16(try!(self.read_short())) { + let tag = ifd::Tag::from_u16(self.read_short()?); + let type_: ifd::Type = match FromPrimitive::from_u16(self.read_short()?) { Some(t) => t, None => { // Unknown type. Skip this entry according to spec. - try!(self.read_long()); - try!(self.read_long()); + self.read_long()?; + self.read_long()?; return Ok(None); } }; @@ -460,8 +460,8 @@ impl Decoder { tag, ifd::Entry::new( type_, - try!(self.read_long()), // count - try!(self.read_offset()), // offset + self.read_long()?, // count + self.read_offset()?, // offset ), ))) } @@ -475,16 +475,16 @@ impl Decoder { TiffFormatError::ImageFileDirectoryNotFound, )) } - Some(offset) => try!(self.goto_offset(offset)), + Some(offset) => self.goto_offset(offset)?, } - for _ in 0..try!(self.read_short()) { - let (tag, entry) = match try!(self.read_entry()) { + for _ in 0..self.read_short()? { + let (tag, entry) = match self.read_entry()? { Some(val) => val, None => continue, // Unknown data type in tag, skip }; dir.insert(tag, entry); } - self.next_ifd = match try!(self.read_long()) { + self.next_ifd = match self.read_long()? { 0 => None, n => Some(n), }; @@ -501,7 +501,7 @@ impl Decoder { let limits = self.limits.clone(); - Ok(Some(try!(entry.val(&limits, self)))) + Ok(Some(entry.val(&limits, self)?)) } /// Tries to retrieve a tag and convert it to the desired type. @@ -523,7 +523,7 @@ impl Decoder { /// Tries to retrieve a tag. /// Returns an error if the tag is not present pub fn get_tag(&mut self, tag: ifd::Tag) -> TiffResult { - match try!(self.find_tag(tag)) { + match self.find_tag(tag)? { Some(val) => Ok(val), None => Err(TiffError::FormatError( TiffFormatError::RequiredTagNotFound(tag), @@ -550,8 +550,8 @@ impl Decoder { length: u32, max_uncompressed_length: usize, ) -> TiffResult { - let color_type = try!(self.colortype()); - try!(self.goto_offset(offset)); + let color_type = self.colortype()?; + self.goto_offset(offset)?; let (bytes, mut reader): (usize, Box) = match self.compression_method { CompressionMethod::None => { let order = self.reader.byte_order; @@ -561,20 +561,20 @@ impl Decoder { ) } CompressionMethod::LZW => { - let (bytes, reader) = try!(LZWReader::new( + let (bytes, reader) = LZWReader::new( &mut self.reader, length as usize, max_uncompressed_length - )); + )?; (bytes, Box::new(reader)) } CompressionMethod::PackBits => { let order = self.reader.byte_order; - let (bytes, reader) = try!(PackBitsReader::new( + let (bytes, reader) = PackBitsReader::new( &mut self.reader, order, length as usize - )); + )?; (bytes, Box::new(reader)) } method => { @@ -594,16 +594,16 @@ impl Decoder { (ColorType::RGB(8), DecodingBuffer::U8(ref mut buffer)) | (ColorType::RGBA(8), DecodingBuffer::U8(ref mut buffer)) | (ColorType::CMYK(8), DecodingBuffer::U8(ref mut buffer)) => { - try!(reader.read_exact(&mut buffer[..bytes])); + reader.read_exact(&mut buffer[..bytes])?; bytes } (ColorType::RGBA(16), DecodingBuffer::U16(ref mut buffer)) | (ColorType::RGB(16), DecodingBuffer::U16(ref mut buffer)) => { - try!(reader.read_u16_into(&mut buffer[..bytes / 2])); + reader.read_u16_into(&mut buffer[..bytes / 2])?; bytes / 2 } (ColorType::Gray(16), DecodingBuffer::U16(ref mut buffer)) => { - try!(reader.read_u16_into(&mut buffer[..bytes / 2])); + reader.read_u16_into(&mut buffer[..bytes / 2])?; if self.photometric_interpretation == PhotometricInterpretation::WhiteIsZero { for datum in buffer[..bytes / 2].iter_mut() { *datum = 0xffff - *datum @@ -612,7 +612,7 @@ impl Decoder { bytes / 2 } (ColorType::Gray(n), DecodingBuffer::U8(ref mut buffer)) if n <= 8 => { - try!(reader.read_exact(&mut buffer[..bytes])); + reader.read_exact(&mut buffer[..bytes])?; if self.photometric_interpretation == PhotometricInterpretation::WhiteIsZero { for byte in buffer[..bytes].iter_mut() { *byte = 0xff - *byte diff --git a/src/decoder/stream.rs b/src/decoder/stream.rs index 4eb5e91..46d7d10 100644 --- a/src/decoder/stream.rs +++ b/src/decoder/stream.rs @@ -85,12 +85,12 @@ impl LZWReader { { let order = reader.byte_order; let mut compressed = vec![0; compressed_length as usize]; - try!(reader.read_exact(&mut compressed[..])); + reader.read_exact(&mut compressed[..])?; let mut uncompressed = Vec::with_capacity(max_uncompressed_length); let mut decoder = lzw::DecoderEarlyChange::new(lzw::MsbReader::new(), 8); let mut bytes_read = 0; while bytes_read < compressed_length && uncompressed.len() < max_uncompressed_length { - let (len, bytes) = try!(decoder.decode_bytes(&compressed[bytes_read..])); + let (len, bytes) = decoder.decode_bytes(&compressed[bytes_read..])?; bytes_read += len; uncompressed.extend_from_slice(bytes); } @@ -155,7 +155,7 @@ impl PackBitsReader { fn read_packbits_run(reader: &mut R, buffer: &mut Vec) -> io::Result { let mut header: [u8; 1] = [0]; - let bytes = try!(reader.read(&mut header)); + let bytes = reader.read(&mut header)?; match bytes { 0 => Ok(0), @@ -163,7 +163,7 @@ fn read_packbits_run(reader: &mut R, buffer: &mut Vec) -> io -128 => Ok(1), h if h >= -127 && h <= -1 => { let new_len = buffer.len() + (1 - h as isize) as usize; - try!(reader.read_exact(&mut header)); + reader.read_exact(&mut header)?; buffer.resize(new_len, header[0]); Ok(2) } @@ -171,7 +171,7 @@ fn read_packbits_run(reader: &mut R, buffer: &mut Vec) -> io let num_vals = h as usize + 1; let start = buffer.len(); buffer.resize(start + num_vals, 0); - try!(reader.read_exact(&mut buffer[start..])); + reader.read_exact(&mut buffer[start..])?; Ok(num_vals + 1) } },