wim/image-tiff
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Decoder::open, deprecate new

Browse Source
This commit is contained in:
A. Molzer committed 2026-03-06 09:31:23 +01:00
1 parent be9b3a04b9
commit bf79af8de4
16 files changed
+176 -108
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

benches/lzw.rs
+4 -5
View File
@@ -8,13 +8,12 @@ use tiff::decoder::Decoder;
fn read_image(image: &[u8]) { fn read_image(image: &[u8]) {
let image = std::io::Cursor::new(image); let image = std::io::Cursor::new(image);
let decoder = Decoder::new(black_box(image)); let decoder = Decoder::open(black_box(image));
let mut reader = decoder.unwrap();
while { let mut reader = decoder.unwrap();
while reader.more_images() {
reader.read_image().unwrap(); reader.read_image().unwrap();
reader.more_images() }
} {}
} }
fn main() { fn main() {
examples/decode.rs
+1 -1
View File
@@ -8,7 +8,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let file = std::fs::File::open(image)?; let file = std::fs::File::open(image)?;
let io = std::io::BufReader::new(file); let io = std::io::BufReader::new(file);
let mut reader = Decoder::new(io)?; let mut reader = Decoder::open(io)?;
let mut data = DecodingResult::I8(vec![]); let mut data = DecodingResult::I8(vec![]);
examples/tiff-ls.rs
+4 -7
View File
@@ -10,14 +10,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let file = std::fs::File::open(image)?; let file = std::fs::File::open(image)?;
let io = std::io::BufReader::new(file); let io = std::io::BufReader::new(file);
let mut reader = Decoder::new(io)?; let mut reader = Decoder::open(io)?;
loop { while reader.more_images() {
reader.next_directory()?;
ls_dir(&mut reader); ls_dir(&mut reader);
if !reader.more_images() {
break;
}
} }
Ok(()) Ok(())
@@ -29,7 +26,7 @@ fn ls_dir<R: std::io::Read + std::io::Seek>(reader: &mut Decoder<R>) {
} }
println!("Name\tHex\tType\tCount"); println!("Name\tHex\tType\tCount");
let ifd = reader.image_ifd(); let ifd = reader.current_ifd();
for (tag, entry) in ifd.directory().iter() { for (tag, entry) in ifd.directory().iter() {
let name: &'static str = match tag { let name: &'static str = match tag {
src/decoder/mod.rs
+37 -25
View File
@@ -857,6 +857,11 @@ impl TiffHeader {
} }
impl<R: Read + Seek> Decoder<R> { impl<R: Read + Seek> Decoder<R> {
/// Create a decoder and attempt to parse the first image directory.
///
/// To open a file without parsing any directory yet (for instance to retain a [`Decoder`] on
/// errors in the directory), use [`TiffHeader::parse`] and [`TiffHeader::open`] instead..
#[deprecated = "Prefer `Decoder::open`. These methods will become aliases in a future major release."]
pub fn new(mut r: R) -> TiffResult<Decoder<R>> { pub fn new(mut r: R) -> TiffResult<Decoder<R>> {
let header = TiffHeader::parse(&mut r)?; let header = TiffHeader::parse(&mut r)?;
let mut decoder = header.open(r); let mut decoder = header.open(r);
@@ -1483,9 +1488,10 @@ impl<R: Read + Seek> Decoder<R> {
/// let mut result = DecodingResult::U8(vec![]); /// let mut result = DecodingResult::U8(vec![]);
/// ///
/// let mut reader = /* */ /// let mut reader = /* */
/// # Decoder::new(std::io::Cursor::new(include_bytes!(concat!( /// # Decoder::open(std::io::Cursor::new(include_bytes!(concat!(
/// # env!("CARGO_MANIFEST_DIR"), "/tests/images/tiled-gray-i1.tif" /// # env!("CARGO_MANIFEST_DIR"), "/tests/images/tiled-gray-i1.tif"
/// # )))).unwrap(); /// # )))).unwrap();
/// # reader.next_image().unwrap();
/// let layout = reader.read_image_to_buffer(&mut result)?; /// let layout = reader.read_image_to_buffer(&mut result)?;
/// ///
/// if result.as_buffer(0).as_bytes().len() < layout.complete_len { /// if result.as_buffer(0).as_bytes().len() < layout.complete_len {
@@ -1503,10 +1509,10 @@ impl<R: Read + Seek> Decoder<R> {
/// let mut result = DecodingResult::I8(vec![]); /// let mut result = DecodingResult::I8(vec![]);
/// ///
/// let mut reader = /* */ /// let mut reader = /* */
/// # Decoder::new(std::io::Cursor::new(include_bytes!(concat!( /// # Decoder::open(std::io::Cursor::new(include_bytes!(concat!(
/// # env!("CARGO_MANIFEST_DIR"), "/tests/images/tiled-gray-i1.tif" /// # env!("CARGO_MANIFEST_DIR"), "/tests/images/tiled-gray-i1.tif"
/// # )))).unwrap(); /// # )))).unwrap();
/// /// # reader.next_image().unwrap();
/// reader.read_image_to_buffer(&mut result)?; /// reader.read_image_to_buffer(&mut result)?;
/// ///
/// # Ok::<_, tiff::TiffError>(()) /// # Ok::<_, tiff::TiffError>(())
@@ -1589,7 +1595,7 @@ impl<R: Read + Seek> Decoder<R> {
/// This may be used with any directory, valid image or otherwise. When the decoder has not /// This may be used with any directory, valid image or otherwise. When the decoder has not
/// read a directory yet (a state after [`TiffHeader::open`]) the decoder will represent an /// read a directory yet (a state after [`TiffHeader::open`]) the decoder will represent an
/// empty directory with only the next pointer set. /// empty directory with only the next pointer set.
pub fn image_ifd(&mut self) -> IfdDecoder<'_> { pub fn current_ifd(&mut self) -> IfdDecoder<'_> {
IfdDecoder { IfdDecoder {
inner: tag_reader::TagReader { inner: tag_reader::TagReader {
decoder: &mut self.value_reader, decoder: &mut self.value_reader,
@@ -1611,7 +1617,9 @@ impl<R: Read + Seek> Decoder<R> {
/// ///
/// # use std::io::Cursor; /// # use std::io::Cursor;
/// # let mut data = Cursor::new(vec![0]); /// # let mut data = Cursor::new(vec![0]);
/// let mut decoder = Decoder::new(&mut data).unwrap(); /// let mut decoder = Decoder::open(&mut data)?;
///
/// decoder.next_directory()?;
/// let sub_ifds = decoder.get_tag(Tag::SubIfd)?.into_ifd_vec()?; /// let sub_ifds = decoder.get_tag(Tag::SubIfd)?.into_ifd_vec()?;
/// ///
/// for ifd in sub_ifds { /// for ifd in sub_ifds {
@@ -1634,13 +1642,13 @@ impl<R: Read + Seek> Decoder<R> {
/// Tries to retrieve a tag from the current image directory. /// Tries to retrieve a tag from the current image directory.
/// Return `Ok(None)` if the tag is not present. /// Return `Ok(None)` if the tag is not present.
pub fn find_tag(&mut self, tag: Tag) -> TiffResult<Option<ifd::Value>> { pub fn find_tag(&mut self, tag: Tag) -> TiffResult<Option<ifd::Value>> {
self.image_ifd().find_tag(tag) self.current_ifd().find_tag(tag)
} }
/// Tries to retrieve a tag in the current image directory and convert it to the desired /// Tries to retrieve a tag in the current image directory and convert it to the desired
/// unsigned type. /// unsigned type.
pub fn find_tag_unsigned<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<Option<T>> { pub fn find_tag_unsigned<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<Option<T>> {
self.image_ifd().find_tag_unsigned(tag) self.current_ifd().find_tag_unsigned(tag)
} }
/// Tries to retrieve a vector of all a tag's values and convert them to the desired unsigned /// Tries to retrieve a vector of all a tag's values and convert them to the desired unsigned
@@ -1649,19 +1657,19 @@ impl<R: Read + Seek> Decoder<R> {
&mut self, &mut self,
tag: Tag, tag: Tag,
) -> TiffResult<Option<Vec<T>>> { ) -> TiffResult<Option<Vec<T>>> {
self.image_ifd().find_tag_unsigned_vec(tag) self.current_ifd().find_tag_unsigned_vec(tag)
} }
/// Tries to retrieve a tag from the current image directory and convert it to the desired /// Tries to retrieve a tag from the current image directory and convert it to the desired
/// unsigned type. Returns an error if the tag is not present. /// unsigned type. Returns an error if the tag is not present.
pub fn get_tag_unsigned<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<T> { pub fn get_tag_unsigned<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<T> {
self.image_ifd().get_tag_unsigned(tag) self.current_ifd().get_tag_unsigned(tag)
} }
/// Tries to retrieve a tag from the current image directory. /// Tries to retrieve a tag from the current image directory.
/// Returns an error if the tag is not present /// Returns an error if the tag is not present
pub fn get_tag(&mut self, tag: Tag) -> TiffResult<ifd::Value> { pub fn get_tag(&mut self, tag: Tag) -> TiffResult<ifd::Value> {
self.image_ifd().get_tag(tag) self.current_ifd().get_tag(tag)
} }
pub fn get_tag_u32(&mut self, tag: Tag) -> TiffResult<u32> { pub fn get_tag_u32(&mut self, tag: Tag) -> TiffResult<u32> {
@@ -1716,7 +1724,7 @@ impl<R: Read + Seek> Decoder<R> {
} }
pub fn tag_iter(&mut self) -> impl Iterator<Item = TiffResult<(Tag, ifd::Value)>> + '_ { pub fn tag_iter(&mut self) -> impl Iterator<Item = TiffResult<(Tag, ifd::Value)>> + '_ {
self.image_ifd().tag_iter() self.current_ifd().tag_iter()
} }
} }
@@ -1972,9 +1980,11 @@ mod tests {
)) ))
.unwrap(); .unwrap();
let mut decoder = Decoder::new(file).unwrap(); let mut decoder = Decoder::open(file).unwrap();
let file_bo = decoder.byte_order(); let file_bo = decoder.byte_order();
let mut ifd = decoder.image_ifd();
decoder.next_image().unwrap();
let mut ifd = decoder.current_ifd();
{ {
let value = ifd let value = ifd
@@ -2041,25 +2051,26 @@ mod tests {
let (first_ptr, second_ptr, third_ptr); let (first_ptr, second_ptr, third_ptr);
{ {
let mut decoder = Decoder::new(&mut cursor).unwrap(); let mut decoder = Decoder::open(&mut cursor).unwrap();
decoder.next_image().unwrap();
first_ptr = decoder.ifd_pointer(); first_ptr = decoder.ifd_pointer();
let first_ifd = decoder.image_ifd(); let first_ifd = decoder.current_ifd();
assert!(first_ifd.directory().get(Tag::ImageWidth).is_some()); assert!(first_ifd.directory().get(Tag::ImageWidth).is_some());
assert!(decoder.more_images()); assert!(decoder.more_images());
assert!(decoder.next_image().is_err()); assert!(decoder.next_image().is_err());
let broken_ifd = decoder.image_ifd(); let broken_ifd = decoder.current_ifd();
assert!(broken_ifd.directory().get(Tag::ImageWidth).is_some()); assert!(broken_ifd.directory().get(Tag::ImageWidth).is_some());
assert!(decoder.next_directory().is_ok()); assert!(decoder.next_directory().is_ok());
second_ptr = decoder.ifd_pointer(); second_ptr = decoder.ifd_pointer();
let second_ifd = decoder.image_ifd(); let second_ifd = decoder.current_ifd();
assert!(second_ifd.directory().get(Tag::ImageWidth).is_none()); assert!(second_ifd.directory().get(Tag::ImageWidth).is_none());
assert!(decoder.more_images()); assert!(decoder.more_images());
assert!(decoder.next_image().is_ok()); assert!(decoder.next_image().is_ok());
third_ptr = decoder.ifd_pointer(); third_ptr = decoder.ifd_pointer();
let third_ifd = decoder.image_ifd(); let third_ifd = decoder.current_ifd();
assert!(third_ifd.directory().get(Tag::ImageWidth).is_some()); assert!(third_ifd.directory().get(Tag::ImageWidth).is_some());
assert!(!decoder.more_images()); assert!(!decoder.more_images());
@@ -2073,13 +2084,14 @@ mod tests {
cursor.set_position(0); cursor.set_position(0);
{ {
let mut seek_immediately = Decoder::new(&mut cursor).unwrap(); let mut seek_immediately = Decoder::open(&mut cursor).unwrap();
assert!(seek_immediately.seek_to_image(0).is_ok());
assert_eq!(seek_immediately.ifd_pointer(), first_ptr); assert_eq!(seek_immediately.ifd_pointer(), first_ptr);
assert!(seek_immediately.seek_to_image(1).is_err()); assert!(seek_immediately.seek_to_image(1).is_err());
assert!(seek_immediately.seek_to_image(2).is_ok()); assert!(seek_immediately.seek_to_image(2).is_ok());
assert_eq!(seek_immediately.ifd_pointer(), third_ptr); assert_eq!(seek_immediately.ifd_pointer(), third_ptr);
assert!(seek_immediately assert!(seek_immediately
.image_ifd() .current_ifd()
.directory() .directory()
.get(Tag::ImageWidth) .get(Tag::ImageWidth)
.is_some()); .is_some());
@@ -2088,11 +2100,11 @@ mod tests {
cursor.set_position(0); cursor.set_position(0);
{ {
let mut seek_immediately = Decoder::new(&mut cursor).unwrap(); let mut seek_immediately = Decoder::open(&mut cursor).unwrap();
assert!(seek_immediately.seek_to_directory(1).is_ok()); assert!(seek_immediately.seek_to_directory(1).is_ok());
assert_eq!(seek_immediately.ifd_pointer(), second_ptr); assert_eq!(seek_immediately.ifd_pointer(), second_ptr);
assert!(seek_immediately assert!(seek_immediately
.image_ifd() .current_ifd()
.directory() .directory()
.get(Tag::ImageWidth) .get(Tag::ImageWidth)
.is_none()); .is_none());
@@ -2115,19 +2127,19 @@ mod tests {
let header = super::TiffHeader::parse(&mut cursor).unwrap(); let header = super::TiffHeader::parse(&mut cursor).unwrap();
let mut decoder = header.open(cursor); let mut decoder = header.open(cursor);
let indicated_next = decoder.image_ifd().directory().next(); let indicated_next = decoder.current_ifd().directory().next();
assert!(decoder.more_images()); assert!(decoder.more_images());
assert_eq!(decoder.ifd_pointer(), None); assert_eq!(decoder.ifd_pointer(), None);
assert!(decoder.next_directory().is_ok()); assert!(decoder.next_directory().is_ok());
let first_ifd = decoder.image_ifd(); let first_ifd = decoder.current_ifd();
assert!(first_ifd.directory().get(Tag::ImageWidth).is_none()); assert!(first_ifd.directory().get(Tag::ImageWidth).is_none());
assert!(decoder.more_images()); assert!(decoder.more_images());
assert_eq!(decoder.ifd_pointer(), indicated_next); assert_eq!(decoder.ifd_pointer(), indicated_next);
assert!(decoder.next_image().is_ok()); assert!(decoder.next_image().is_ok());
let second_ifd = decoder.image_ifd(); let second_ifd = decoder.current_ifd();
assert!(second_ifd.directory().get(Tag::ImageWidth).is_some()); assert!(second_ifd.directory().get(Tag::ImageWidth).is_some());
assert!(!decoder.more_images()); assert!(!decoder.more_images());
} }
src/encoder/writer.rs
+3 -1
View File
@@ -241,7 +241,9 @@ fn encoder_on_short_writes() {
} }
write.inner.set_position(0); write.inner.set_position(0);
let mut tiff_reader = crate::decoder::Decoder::new(&mut write.inner).unwrap();
let mut tiff_reader = crate::decoder::Decoder::open(&mut write.inner).unwrap();
tiff_reader.next_image().unwrap();
let _layout = tiff_reader.read_image_to_buffer(&mut data).unwrap(); let _layout = tiff_reader.read_image_to_buffer(&mut data).unwrap();
assert!( assert!(
tests/decode_bigtiff_images.rs
+3 -1
View File
@@ -15,7 +15,9 @@ fn test_big_tiff() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image");
assert_eq!( assert_eq!(
decoder.dimensions().expect("Cannot get dimensions"), decoder.dimensions().expect("Cannot get dimensions"),
(64, 64) (64, 64)
tests/decode_fp16_images.rs
+20 -5
View File
@@ -16,7 +16,9 @@ fn test_white_ieee_fp16() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image");
assert_eq!( assert_eq!(
decoder.dimensions().expect("Cannot get dimensions"), decoder.dimensions().expect("Cannot get dimensions"),
(256, 256) (256, 256)
@@ -25,6 +27,7 @@ fn test_white_ieee_fp16() {
decoder.colortype().expect("Cannot get colortype"), decoder.colortype().expect("Cannot get colortype"),
ColorType::Gray(16) ColorType::Gray(16)
); );
if let DecodingResult::F16(img) = decoder.read_image().unwrap() { if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
for p in img { for p in img {
assert!(p == half::f16::from_f32_const(1.0)); assert!(p == half::f16::from_f32_const(1.0));
@@ -43,7 +46,9 @@ fn test_one_black_pixel_ieee_fp16() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image");
assert_eq!( assert_eq!(
decoder.dimensions().expect("Cannot get dimensions"), decoder.dimensions().expect("Cannot get dimensions"),
(256, 256) (256, 256)
@@ -52,6 +57,7 @@ fn test_one_black_pixel_ieee_fp16() {
decoder.colortype().expect("Cannot get colortype"), decoder.colortype().expect("Cannot get colortype"),
ColorType::Gray(16) ColorType::Gray(16)
); );
if let DecodingResult::F16(img) = decoder.read_image().unwrap() { if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
for (i, p) in img.iter().enumerate() { for (i, p) in img.iter().enumerate() {
if i == 0 { if i == 0 {
@@ -74,7 +80,9 @@ fn test_pattern_horizontal_differencing_ieee_fp16() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image");
assert_eq!( assert_eq!(
decoder.dimensions().expect("Cannot get dimensions"), decoder.dimensions().expect("Cannot get dimensions"),
(256, 256) (256, 256)
@@ -83,6 +91,7 @@ fn test_pattern_horizontal_differencing_ieee_fp16() {
decoder.colortype().expect("Cannot get colortype"), decoder.colortype().expect("Cannot get colortype"),
ColorType::Gray(16) ColorType::Gray(16)
); );
if let DecodingResult::F16(img) = decoder.read_image().unwrap() { if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
// 0, 2, 5, 8, 12, 16, 255 are black // 0, 2, 5, 8, 12, 16, 255 are black
let black = [0, 2, 5, 8, 12, 16, 255]; let black = [0, 2, 5, 8, 12, 16, 255];
@@ -107,7 +116,9 @@ fn test_pattern_predictor_ieee_fp16() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image");
assert_eq!( assert_eq!(
decoder.dimensions().expect("Cannot get dimensions"), decoder.dimensions().expect("Cannot get dimensions"),
(256, 256) (256, 256)
@@ -116,6 +127,7 @@ fn test_pattern_predictor_ieee_fp16() {
decoder.colortype().expect("Cannot get colortype"), decoder.colortype().expect("Cannot get colortype"),
ColorType::Gray(16) ColorType::Gray(16)
); );
if let DecodingResult::F16(img) = decoder.read_image().unwrap() { if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
// 0, 2, 5, 8, 12, 16, 255 are black // 0, 2, 5, 8, 12, 16, 255 are black
let black = [0, 2, 5, 8, 12, 16, 255]; let black = [0, 2, 5, 8, 12, 16, 255];
@@ -175,7 +187,9 @@ fn test_predictor_ieee_fp16() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image");
assert_eq!( assert_eq!(
decoder.dimensions().expect("Cannot get dimensions"), decoder.dimensions().expect("Cannot get dimensions"),
(16, 16) (16, 16)
@@ -184,6 +198,7 @@ fn test_predictor_ieee_fp16() {
decoder.colortype().expect("Cannot get colortype"), decoder.colortype().expect("Cannot get colortype"),
ColorType::Gray(16) ColorType::Gray(16)
); );
if let DecodingResult::F16(img) = decoder.read_image().unwrap() { if let DecodingResult::F16(img) = decoder.read_image().unwrap() {
for (exp, found) in std::iter::zip(pnm_values.iter(), img.iter()) { for (exp, found) in std::iter::zip(pnm_values.iter(), img.iter()) {
assert!((exp - found.to_f32()).abs() < 0.0001); assert!((exp - found.to_f32()).abs() < 0.0001);
tests/decode_geotiff_images.rs
+5 -9
View File
@@ -15,8 +15,9 @@ fn test_geo_tiff() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder = decoder.with_limits(tiff::decoder::Limits::unlimited()); decoder = decoder.with_limits(tiff::decoder::Limits::unlimited());
decoder.next_image().expect("Cannot read image");
assert_eq!( assert_eq!(
decoder.dimensions().expect("Cannot get dimensions"), decoder.dimensions().expect("Cannot get dimensions"),
@@ -71,16 +72,11 @@ fn test_webp_tiff() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
loop {
decoder.read_image_to_buffer(&mut buffer).unwrap();
if !decoder.more_images() {
break;
}
while decoder.more_images() {
decoder.next_image().unwrap(); decoder.next_image().unwrap();
decoder.read_image_to_buffer(&mut buffer).unwrap();
} }
} }
} }
tests/decode_images.rs
+42 -20
View File
@@ -14,7 +14,9 @@ macro_rules! test_image_sum {
fn $name(file: &str, expected_type: ColorType, expected_sum: $sum_ty) { fn $name(file: &str, expected_type: ColorType, expected_sum: $sum_ty) {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image IFD");
assert_eq!(decoder.colortype().unwrap(), expected_type); assert_eq!(decoder.colortype().unwrap(), expected_type);
let img_res = decoder.read_image().unwrap(); let img_res = decoder.read_image().unwrap();
@@ -44,7 +46,9 @@ test_image_sum!(test_image_sum_f64, F64, f64);
fn test_image_color_type_unsupported(file: &str, expected_type: ColorType) { fn test_image_color_type_unsupported(file: &str, expected_type: ColorType) {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image IFD");
assert_eq!(decoder.colortype().unwrap(), expected_type); assert_eq!(decoder.colortype().unwrap(), expected_type);
assert!(matches!( assert!(matches!(
decoder.read_image(), decoder.read_image(),
@@ -166,7 +170,8 @@ fn test_string_tags() {
for filename in filenames.iter() { for filename in filenames.iter() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(filename); let path = PathBuf::from(TEST_IMAGE_DIR).join(filename);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image IFD");
let software = decoder.get_tag(tiff::tags::Tag::Software).unwrap(); let software = decoder.get_tag(tiff::tags::Tag::Software).unwrap();
match software { match software {
ifd::Value::Ascii(s) => assert_eq!( ifd::Value::Ascii(s) => assert_eq!(
@@ -190,7 +195,8 @@ fn test_decode_data() {
} }
} }
let file = File::open("./tests/decodedata-rgb-3c-8b.tiff").unwrap(); let file = File::open("./tests/decodedata-rgb-3c-8b.tiff").unwrap();
let mut decoder = Decoder::new(file).unwrap(); let mut decoder = Decoder::open(file).unwrap();
decoder.next_image().expect("Cannot read image IFD");
assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8)); assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
assert_eq!(decoder.dimensions().unwrap(), (100, 100)); assert_eq!(decoder.dimensions().unwrap(), (100, 100));
if let DecodingResult::U8(img_res) = decoder.read_image().unwrap() { if let DecodingResult::U8(img_res) = decoder.read_image().unwrap() {
@@ -236,7 +242,8 @@ fn test_tiled_rect_rgb_u8() {
fn test_inner_access() { fn test_inner_access() {
let path = PathBuf::from(TEST_IMAGE_DIR).join("tiled-rect-rgb-u8.tif"); let path = PathBuf::from(TEST_IMAGE_DIR).join("tiled-rect-rgb-u8.tif");
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image IFD");
assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8)); assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
let c = decoder let c = decoder
@@ -322,7 +329,8 @@ fn test_tiled_incremental() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image IFD");
assert_eq!(decoder.colortype().unwrap(), expected_type); assert_eq!(decoder.colortype().unwrap(), expected_type);
let tiles = decoder.tile_count().unwrap(); let tiles = decoder.tile_count().unwrap();
@@ -352,7 +360,8 @@ fn test_read_planar_bands() {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().expect("Cannot read image IFD");
assert_eq!(decoder.colortype().unwrap(), expected_type); assert_eq!(decoder.colortype().unwrap(), expected_type);
let chunks = decoder.strip_count().unwrap(); let chunks = decoder.strip_count().unwrap();
@@ -396,7 +405,8 @@ fn test_div_zero() {
178, 178, 178, 178, 178, 178,
]; ];
let err = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let err = decoder.next_image().unwrap_err();
match err { match err {
TiffError::FormatError(TiffFormatError::StripTileTagConflict) => {} TiffError::FormatError(TiffFormatError::StripTileTagConflict) => {}
@@ -414,7 +424,8 @@ fn test_too_many_value_bytes() {
0, 89, 89, 89, 89, 89, 89, 89, 89, 96, 1, 20, 89, 89, 89, 89, 18, 0, 89, 89, 89, 89, 89, 89, 89, 89, 96, 1, 20, 89, 89, 89, 89, 18,
]; ];
let error = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let error = decoder.next_image().unwrap_err();
match error { match error {
tiff::TiffError::LimitsExceeded => {} tiff::TiffError::LimitsExceeded => {}
@@ -432,7 +443,8 @@ fn fuzzer_testcase5() {
178, 178, 178, 178, 178, 178,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -445,7 +457,8 @@ fn fuzzer_testcase1() {
178, 178,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -458,7 +471,8 @@ fn fuzzer_testcase6() {
178, 178, 178, 178,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -470,7 +484,8 @@ fn oom() {
0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 178, 48, 178, 178, 178, 178, 162, 178, 0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 178, 48, 178, 178, 178, 178, 162, 178,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -482,7 +497,8 @@ fn fuzzer_testcase4() {
0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 48, 178, 178, 178, 0, 1, 0, 13, 13, 0, 0, 0, 40, 0, 0, 0, 23, 1, 4, 0, 1, 0, 0, 0, 48, 178, 178, 178, 0, 1, 0, 13, 13,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -498,7 +514,8 @@ fn fuzzer_testcase2() {
73, 73,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -514,7 +531,8 @@ fn invalid_jpeg_tag_2() {
0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 36, 73, 73, 0, 42, 36, 36, 36, 36, 0, 0, 8, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 36, 73, 73, 0, 42, 36, 36, 36, 36, 0, 0, 8, 0,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -527,7 +545,8 @@ fn fuzzer_testcase3() {
255, 255, 255, 255,
]; ];
let _ = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let _ = decoder.next_image().unwrap_err();
} }
#[test] #[test]
@@ -545,7 +564,8 @@ fn timeout() {
0, 0, 73, 73, 42, 0, 8, 0, 0, 0, 0, 0, 32, 0, 0, 73, 73, 42, 0, 8, 0, 0, 0, 0, 0, 32,
]; ];
let error = tiff::decoder::Decoder::new(std::io::Cursor::new(&image)).unwrap_err(); let mut decoder = Decoder::open(std::io::Cursor::new(&image)).unwrap();
let error = decoder.next_image().unwrap_err();
match error { match error {
TiffError::FormatError(TiffFormatError::CycleInOffsets) => {} TiffError::FormatError(TiffFormatError::CycleInOffsets) => {}
@@ -583,7 +603,8 @@ fn test_image_bytes(
) { ) {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().unwrap();
let mut buffer = vec![0u8; 0]; let mut buffer = vec![0u8; 0];
for (idx, &(expected_type, expected_crc)) in expected.iter().enumerate() { for (idx, &(expected_type, expected_crc)) in expected.iter().enumerate() {
@@ -726,8 +747,9 @@ fn extra_bits_rgb() {
fn test_decode_huge_g4() { fn test_decode_huge_g4() {
let path = PathBuf::from(TEST_IMAGE_DIR).join("big_g4.tif"); let path = PathBuf::from(TEST_IMAGE_DIR).join("big_g4.tif");
let img_file = File::open(path).expect("failed to open large G4 test image"); let img_file = File::open(path).expect("failed to open large G4 test image");
let mut decoder = tiff::decoder::Decoder::new(img_file).expect("failed to create decoder"); let mut decoder = Decoder::open(img_file).expect("failed to create decoder");
decoder.next_image().expect("failed to read image IFD");
let (width, height) = decoder.dimensions().expect("failed to get dimensions"); let (width, height) = decoder.dimensions().expect("failed to get dimensions");
assert!( assert!(
tests/decode_libtiffpic.rs
+4 -9
View File
@@ -153,17 +153,12 @@ fn decode_libtiffpic(path: &str) -> Result<(), tiff::TiffError> {
let path = path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(path); let path = path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(path);
let img_file = File::open(path)?; let img_file = File::open(path)?;
let mut decoder = Decoder::new(img_file)?; let mut decoder = Decoder::open(img_file)?;
let mut buffer = DecodingResult::U8(vec![]); let mut buffer = DecodingResult::U8(vec![]);
while decoder.more_images() {
loop {
let _layout = decoder.read_image_to_buffer(&mut buffer);
if !decoder.more_images() {
break;
}
decoder.next_image()?; decoder.next_image()?;
let _layout = decoder.read_image_to_buffer(&mut buffer);
} }
Ok(()) Ok(())
tests/decode_planes.rs
+6 -3
View File
@@ -10,8 +10,9 @@ fn read_all_planes() {
let path = PathBuf::from(TEST_IMAGE_DIR).join("planar-rgb-u8.tif"); let path = PathBuf::from(TEST_IMAGE_DIR).join("planar-rgb-u8.tif");
let file = File::open(path).unwrap(); let file = File::open(path).unwrap();
let io = std::io::BufReader::new(file); let io = std::io::BufReader::new(file);
let mut tif = Decoder::open(io).unwrap();
let mut tif = Decoder::new(io).unwrap(); tif.next_image().unwrap();
let layout = tif.image_buffer_layout().unwrap(); let layout = tif.image_buffer_layout().unwrap();
assert_eq!(layout.planes, 3); assert_eq!(layout.planes, 3);
let plane_stride = layout.plane_stride.map_or(0, |x| x.get()); let plane_stride = layout.plane_stride.map_or(0, |x| x.get());
@@ -36,8 +37,9 @@ fn read_first_coding_unit() {
let path = PathBuf::from(TEST_IMAGE_DIR).join("planar-rgb-u8.tif"); let path = PathBuf::from(TEST_IMAGE_DIR).join("planar-rgb-u8.tif");
let file = File::open(path).unwrap(); let file = File::open(path).unwrap();
let io = std::io::BufReader::new(file); let io = std::io::BufReader::new(file);
let mut tif = Decoder::open(io).unwrap();
let mut tif = Decoder::new(io).unwrap(); tif.next_image().unwrap();
let layout = tif.image_coding_unit_layout(TiffCodingUnit(0)).unwrap(); let layout = tif.image_coding_unit_layout(TiffCodingUnit(0)).unwrap();
assert_eq!(layout.planes, 3); assert_eq!(layout.planes, 3);
@@ -85,12 +87,13 @@ fn read_planes_by_limits() {
let mut buffer = DecodingResult::U8(vec![]); let mut buffer = DecodingResult::U8(vec![]);
// Make room for 1 plane. // Make room for 1 plane.
let mut tif = Decoder::new(io).unwrap(); let mut tif = Decoder::open(io).unwrap();
tif = tif.with_limits({ tif = tif.with_limits({
limits.decoding_buffer_size = 374 * 499; limits.decoding_buffer_size = 374 * 499;
limits.clone() limits.clone()
}); });
tif.next_image().unwrap();
tif.read_image_to_buffer(&mut buffer).unwrap(); tif.read_image_to_buffer(&mut buffer).unwrap();
assert_eq!(buffer.as_buffer(0).byte_len(), 374 * 499); assert_eq!(buffer.as_buffer(0).byte_len(), 374 * 499);
tests/encode_images.rs
+33 -16
View File
@@ -33,7 +33,9 @@ fn encode_decode() {
} }
{ {
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8)); assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
assert_eq!(decoder.dimensions().unwrap(), (100, 100)); assert_eq!(decoder.dimensions().unwrap(), (100, 100));
@@ -116,7 +118,9 @@ fn encode_decode_big() {
} }
{ {
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8)); assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(8));
assert_eq!(decoder.dimensions().unwrap(), (100, 100)); assert_eq!(decoder.dimensions().unwrap(), (100, 100));
@@ -207,8 +211,10 @@ fn test_encode_ifd() {
// Rewind the cursor for reading // Rewind the cursor for reading
data.set_position(0); data.set_position(0);
{ {
let mut decoder = Decoder::new(&mut data).unwrap(); let mut decoder = Decoder::open(&mut data).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.assert_tag_u32(65000), 42); assert_eq!(decoder.assert_tag_u32(65000), 42);
assert_eq!(decoder.assert_tag_u32_vec(65000), [42]); assert_eq!(decoder.assert_tag_u32_vec(65000), [42]);
@@ -247,7 +253,9 @@ macro_rules! test_roundtrip {
) { ) {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), expected_type); assert_eq!(decoder.colortype().unwrap(), expected_type);
let mut buffer = tiff::decoder::DecodingResult::U8(vec![]); let mut buffer = tiff::decoder::DecodingResult::U8(vec![]);
@@ -268,7 +276,8 @@ macro_rules! test_roundtrip {
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
{ {
let mut buffer = tiff::decoder::DecodingResult::U8(vec![]); let mut buffer = tiff::decoder::DecodingResult::U8(vec![]);
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
decoder.read_image_to_buffer(&mut buffer).unwrap(); decoder.read_image_to_buffer(&mut buffer).unwrap();
if let DecodingResult::$buffer(img_res) = buffer { if let DecodingResult::$buffer(img_res) = buffer {
assert_eq!(*image_data, img_res); assert_eq!(*image_data, img_res);
@@ -405,7 +414,8 @@ fn test_gray_f32_floating_point_predictor() {
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
{ {
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), ColorType::Gray(32)); assert_eq!(decoder.colortype().unwrap(), ColorType::Gray(32));
let mut buffer = DecodingResult::F32(vec![]); let mut buffer = DecodingResult::F32(vec![]);
@@ -451,7 +461,8 @@ fn test_rgb_f32_floating_point_predictor() {
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
{ {
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(32)); assert_eq!(decoder.colortype().unwrap(), ColorType::RGB(32));
let mut buffer = DecodingResult::F32(vec![]); let mut buffer = DecodingResult::F32(vec![]);
@@ -494,7 +505,8 @@ fn test_gray_f64_floating_point_predictor() {
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
{ {
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), ColorType::Gray(64)); assert_eq!(decoder.colortype().unwrap(), ColorType::Gray(64));
let mut buffer = DecodingResult::F64(vec![]); let mut buffer = DecodingResult::F64(vec![]);
@@ -591,7 +603,8 @@ fn test_multiple_byte() {
data.set_position(0); data.set_position(0);
{ {
let mut decoder = Decoder::new(&mut data).unwrap(); let mut decoder = Decoder::open(&mut data).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.assert_tag_u32_vec(65000), [1]); assert_eq!(decoder.assert_tag_u32_vec(65000), [1]);
assert_eq!(decoder.assert_tag_u32_vec(65001), [1, 2]); assert_eq!(decoder.assert_tag_u32_vec(65001), [1, 2]);
@@ -672,7 +685,8 @@ fn test_signed() {
//Rewind the cursor for reading //Rewind the cursor for reading
data.set_position(0); data.set_position(0);
{ {
let mut decoder = Decoder::new(&mut data).unwrap(); let mut decoder = Decoder::open(&mut data).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.assert_tag_i32(65000), -1); assert_eq!(decoder.assert_tag_i32(65000), -1);
assert_eq!(decoder.assert_tag_i32_vec(65001), [-1]); assert_eq!(decoder.assert_tag_i32_vec(65001), [-1]);
@@ -724,13 +738,14 @@ fn test_multipage_image() {
img_file.seek(SeekFrom::Start(0)).unwrap(); img_file.seek(SeekFrom::Start(0)).unwrap();
{ {
let mut img_decoder = Decoder::new(&mut img_file).unwrap(); let mut decoder = Decoder::open(&mut img_file).unwrap();
decoder.next_image().unwrap();
// check the dimensions of the image in the first page // check the dimensions of the image in the first page
assert_eq!(img_decoder.dimensions().unwrap(), (2, 2)); assert_eq!(decoder.dimensions().unwrap(), (2, 2));
img_decoder.next_image().unwrap(); decoder.next_image().unwrap();
// check the dimensions of the image in the second page // check the dimensions of the image in the second page
assert_eq!(img_decoder.dimensions().unwrap(), (3, 3)); assert_eq!(decoder.dimensions().unwrap(), (3, 3));
} }
} }
@@ -759,7 +774,8 @@ fn test_rows_per_strip() {
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
{ {
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
assert_eq!(decoder.get_tag_u64(Tag::RowsPerStrip).unwrap(), 2); assert_eq!(decoder.get_tag_u64(Tag::RowsPerStrip).unwrap(), 2);
assert_eq!(decoder.strip_count().unwrap(), 50); assert_eq!(decoder.strip_count().unwrap(), 50);
@@ -799,9 +815,10 @@ fn test_auxiliary_directory() {
} }
data.set_position(0); data.set_position(0);
let mut decoder = Decoder::new(&mut data).unwrap(); let mut decoder = Decoder::open(&mut data).unwrap();
{ {
decoder.next_image().unwrap();
assert_eq!(decoder.dimensions().unwrap(), (1, 1)); assert_eq!(decoder.dimensions().unwrap(), (1, 1));
let _ = decoder.read_image().unwrap(); let _ = decoder.read_image().unwrap();
} }
tests/encode_images_with_compression.rs
+2 -1
View File
@@ -110,7 +110,8 @@ fn encode_decode_with_compression(compression: Compression) {
// Decode tiff // Decode tiff
data.set_position(0); data.set_position(0);
{ {
let mut decoder = Decoder::new(data).unwrap(); let mut decoder = Decoder::open(data).unwrap();
decoder.next_image().unwrap();
// Check the RGB image // Check the RGB image
assert_eq!( assert_eq!(
tests/fuzz_tests.rs
+2 -1
View File
@@ -13,7 +13,8 @@ fn test_directory<F: Fn(File) -> bool>(path: &str, f: F) {
} }
fn decode_tiff(file: File) -> TiffResult<()> { fn decode_tiff(file: File) -> TiffResult<()> {
let mut decoder = Decoder::new(file)?; let mut decoder = Decoder::open(file)?;
decoder.next_image()?;
decoder.read_image()?; decoder.read_image()?;
Ok(()) Ok(())
} }
tests/predict.rs
+7 -3
View File
@@ -18,8 +18,9 @@ macro_rules! test_predict {
) { ) {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let file = File::open(path).expect("Cannot find test image!"); let file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(file).expect("Cannot create decoder!"); let mut decoder = Decoder::open(file).expect("Cannot create decoder!");
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), expected_type); assert_eq!(decoder.colortype().unwrap(), expected_type);
let image_data = match decoder.read_image().unwrap() { let image_data = match decoder.read_image().unwrap() {
DecodingResult::$buffer(res) => res, DecodingResult::$buffer(res) => res,
@@ -123,7 +124,9 @@ macro_rules! test_predict_roundtrip {
) { ) {
let path = PathBuf::from(TEST_IMAGE_DIR).join(file); let path = PathBuf::from(TEST_IMAGE_DIR).join(file);
let img_file = File::open(path).expect("Cannot find test image!"); let img_file = File::open(path).expect("Cannot find test image!");
let mut decoder = Decoder::new(img_file).expect("Cannot create decoder"); let mut decoder = Decoder::open(img_file).expect("Cannot create decoder");
decoder.next_image().unwrap();
assert_eq!(decoder.colortype().unwrap(), expected_type); assert_eq!(decoder.colortype().unwrap(), expected_type);
let image_data = match decoder.read_image().unwrap() { let image_data = match decoder.read_image().unwrap() {
@@ -142,7 +145,8 @@ macro_rules! test_predict_roundtrip {
} }
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
{ {
let mut decoder = Decoder::new(&mut file).unwrap(); let mut decoder = Decoder::open(&mut file).unwrap();
decoder.next_image().unwrap();
if let DecodingResult::$buffer(img_res) = if let DecodingResult::$buffer(img_res) =
decoder.read_image().expect("Decoding image failed") decoder.read_image().expect("Decoding image failed")
{ {
tests/subsubifds.rs
+3 -1
View File
@@ -18,8 +18,10 @@ use std::fs::File;
#[test] #[test]
fn decode_seek_chain() { fn decode_seek_chain() {
let file = File::open(TEST_IMAGE_SUBIFD).expect("Cannot open test image"); let file = File::open(TEST_IMAGE_SUBIFD).expect("Cannot open test image");
let mut decoder = Decoder::new(file).expect("Invalid format to create decoder"); let mut decoder = Decoder::open(file).expect("Invalid format to create decoder");
assert!(decoder.ifd_pointer().is_none());
decoder.next_image().unwrap();
// Remember the offsets in the first iteration. // Remember the offsets in the first iteration.
let offset0 = decoder.ifd_pointer().expect("First IFD pointer not found"); let offset0 = decoder.ifd_pointer().expect("First IFD pointer not found");
decoder.next_image().unwrap(); decoder.next_image().unwrap();