From 23751bd8c5729d7af551959ea05d8b799559371b Mon Sep 17 00:00:00 2001 From: Etienne Prothon Date: Thu, 23 Jul 2020 01:33:41 +0200 Subject: [PATCH] feat: Support decoding big tiff --- src/decoder/ifd.rs | 267 ++++++++++++++++++++++++++--------------- src/decoder/mod.rs | 119 ++++++++++++------ tests/encode_images.rs | 40 +++--- 3 files changed, 270 insertions(+), 156 deletions(-) diff --git a/src/decoder/ifd.rs b/src/decoder/ifd.rs index 58965d1..d5b9e0e 100644 --- a/src/decoder/ifd.rs +++ b/src/decoder/ifd.rs @@ -15,18 +15,18 @@ use self::Value::{Ascii, List, Rational, Unsigned, Signed, SRational}; #[allow(unused_qualifications)] #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum Value { - Signed(i32), - Unsigned(u32), + Signed(i64), + Unsigned(u64), List(Vec), - Rational(u32, u32), - SRational(i32, i32), + Rational(u64, u64), + SRational(i64, i64), Ascii(String), #[doc(hidden)] // Do not match against this. __NonExhaustive, } impl Value { - pub fn into_u32(self) -> TiffResult { + pub fn into_u64(self) -> TiffResult { match self { Unsigned(val) => Ok(val), val => Err(TiffError::FormatError( @@ -35,7 +35,7 @@ impl Value { } } - pub fn into_i32(self) -> TiffResult { + pub fn into_i64(self) -> TiffResult { match self { Signed(val) => Ok(val), val => Err(TiffError::FormatError( @@ -44,25 +44,25 @@ impl Value { } } - pub fn into_u32_vec(self) -> TiffResult> { + pub fn into_u64_vec(self) -> TiffResult> { match self { List(vec) => { let mut new_vec = Vec::with_capacity(vec.len()); for v in vec { - new_vec.push(v.into_u32()?) + new_vec.push(v.into_u64()?) } Ok(new_vec) } Unsigned(val) => Ok(vec![val]), Rational(numerator, denominator) => Ok(vec![numerator, denominator]), - Ascii(val) => Ok(val.chars().map(u32::from).collect()), + Ascii(val) => Ok(val.chars().map(u32::from).map(u64::from).collect()), val => Err(TiffError::FormatError( TiffFormatError::UnsignedIntegerExpected(val), )), } } - pub fn into_i32_vec(self) -> TiffResult> { + pub fn into_i64_vec(self) -> TiffResult> { match self { List(vec) => { let mut new_vec = Vec::with_capacity(vec.len()); @@ -72,7 +72,7 @@ impl Value { new_vec.push(numerator); new_vec.push(denominator); } - _ => new_vec.push(v.into_i32()?) + _ => new_vec.push(v.into_i64()?), } } Ok(new_vec) @@ -85,12 +85,12 @@ impl Value { } } } - + #[derive(Clone)] pub struct Entry { type_: Type, - count: u32, - offset: [u8; 4], + count: u64, + offset: [u8; 8], } impl ::std::fmt::Debug for Entry { @@ -103,7 +103,7 @@ impl ::std::fmt::Debug for Entry { } impl Entry { - pub fn new(type_: Type, count: u32, offset: [u8; 4]) -> Entry { + pub fn new(type_: Type, count: u64, offset: [u8; 8]) -> Entry { Entry { type_, count, @@ -122,94 +122,156 @@ impl Entry { decoder: &mut super::Decoder, ) -> TiffResult { let bo = decoder.byte_order(); - match (self.type_, self.count) { - // TODO check if this could give wrong results - // at a different endianess of file/computer. - (Type::BYTE, 1) => Ok(Unsigned(u32::from(self.offset[0]))), - (Type::BYTE, 2) => offset_to_bytes(2, self), - (Type::BYTE, 3) => offset_to_bytes(3, self), - (Type::BYTE, 4) => offset_to_bytes(4, self), - (Type::BYTE, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { - Ok(Unsigned(u32::from(decoder.read_byte()?))) - }), - (Type::SBYTE, 1) => Ok(Signed(i32::from(self.offset[0] as i8))), - (Type::SBYTE, 2) => offset_to_sbytes(2, self), - (Type::SBYTE, 3) => offset_to_sbytes(3, self), - (Type::SBYTE, 4) => offset_to_sbytes(4, self), - (Type::SBYTE, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { - Ok(Signed(i32::from(decoder.read_byte()? as i8))) - }), - (Type::SHORT, 1) => Ok(Unsigned(u32::from(self.r(bo).read_u16()?))), - (Type::SSHORT, 1) => Ok(Signed(i32::from(self.r(bo).read_i16()?))), - (Type::SHORT, 2) => { - let mut r = self.r(bo); - Ok(List(vec![ - Unsigned(u32::from(r.read_u16()?)), - Unsigned(u32::from(r.read_u16()?)), - ])) - } - (Type::SSHORT, 2) => { - let mut r = self.r(bo); - Ok(List(vec![ - Signed(i32::from(r.read_i16()?)), - Signed(i32::from(r.read_i16()?)), - ])) - } - (Type::SHORT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { - Ok(Unsigned(u32::from(decoder.read_short()?))) - }), - (Type::SSHORT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { - Ok(Signed(i32::from(decoder.read_sshort()?))) - }), - (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()?)) - }), - (Type::SLONG, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { - Ok(Signed(decoder.read_slong()?)) - }), - (Type::RATIONAL, 1) => { - 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) => { - decoder.goto_offset(self.r(bo).read_u32()?)?; - let numerator = decoder.read_slong()?; - let denominator = decoder.read_slong()?; - Ok(SRational(numerator, denominator)) - } - (Type::RATIONAL, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { - Ok(Rational( - decoder.read_long()?, - decoder.read_long()?, - )) - }), - (Type::SRATIONAL, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { - Ok(SRational( - decoder.read_slong()?, - decoder.read_slong()?, - )) - }), - (Type::ASCII, n) => { - let n = usize::try_from(n)?; - if n > limits.decoding_buffer_size { - return Err(TiffError::LimitsExceeded); + let bigtiff_value = if decoder.bigtiff && 4 < self.count && self.count <= 8 { + match (self.type_, self.count) { + (Type::BYTE, n) => Some(offset_to_bytes(n as usize, self)?), + (Type::SBYTE, n) => Some(offset_to_sbytes(n as usize, self)?), + (Type::SHORT, 3) => { + let mut r = self.r(bo); + Some(List(vec![ + Unsigned(u64::from(r.read_u16()?)), + Unsigned(u64::from(r.read_u16()?)), + Unsigned(u64::from(r.read_u16()?)), + ])) } - decoder.goto_offset(self.r(bo).read_u32()?)?; - let string = decoder.read_string(n)?; - Ok(Ascii(string)) + (Type::SSHORT, 3) => { + let mut r = self.r(bo); + Some(List(vec![ + Signed(i64::from(r.read_i16()?)), + Signed(i64::from(r.read_i16()?)), + Signed(i64::from(r.read_i16()?)), + ])) + } + (Type::SHORT, 4) => { + let mut r = self.r(bo); + Some(List(vec![ + Unsigned(u64::from(r.read_u16()?)), + Unsigned(u64::from(r.read_u16()?)), + Unsigned(u64::from(r.read_u16()?)), + Unsigned(u64::from(r.read_u16()?)), + ])) + } + (Type::SSHORT, 4) => { + let mut r = self.r(bo); + Some(List(vec![ + Signed(i64::from(r.read_i16()?)), + Signed(i64::from(r.read_i16()?)), + Signed(i64::from(r.read_i16()?)), + Signed(i64::from(r.read_i16()?)), + ])) + } + (Type::LONG, 2) => { + let mut r = self.r(bo); + Some(List(vec![ + Unsigned(r.read_u32()?.into()), + Unsigned(r.read_u32()?.into()), + ])) + } + (Type::SLONG, 2) => { + let mut r = self.r(bo); + Some(List(vec![ + Signed(r.read_i32()?.into()), + Signed(r.read_i32()?.into()), + ])) + } + (Type::RATIONAL, 1) => { + let mut r = self.r(bo); + let numerator = r.read_u32()?.into(); + let denominator = r.read_u32()?.into(); + Some(Rational(numerator, denominator)) + } + (Type::SRATIONAL, 1) => { + let mut r = self.r(bo); + let numerator = r.read_i32()?.into(); + let denominator = r.read_i32()?.into(); + Some(SRational(numerator, denominator)) + } + _ => None + } + } else { + None + }; + + if let Some(v) = bigtiff_value { + Ok(v) + } else { + match (self.type_, self.count) { + // TODO check if this could give wrong results + // at a different endianess of file/computer. + (Type::BYTE, 1) => Ok(Unsigned(u64::from(self.offset[0]))), + (Type::BYTE, 2) => offset_to_bytes(2, self), + (Type::BYTE, 3) => offset_to_bytes(3, self), + (Type::BYTE, 4) => offset_to_bytes(4, self), + (Type::BYTE, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(Unsigned(u64::from(decoder.read_byte()?))) + }), + (Type::SBYTE, 1) => Ok(Signed(i64::from(self.offset[0] as i8))), + (Type::SBYTE, 2) => offset_to_sbytes(2, self), + (Type::SBYTE, 3) => offset_to_sbytes(3, self), + (Type::SBYTE, 4) => offset_to_sbytes(4, self), + (Type::SBYTE, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(Signed(i64::from(decoder.read_byte()? as i8))) + }), + (Type::SHORT, 1) => Ok(Unsigned(u64::from(self.r(bo).read_u16()?))), + (Type::SSHORT, 1) => Ok(Signed(i64::from(self.r(bo).read_i16()?))), + (Type::SHORT, 2) => { + let mut r = self.r(bo); + Ok(List(vec![ + Unsigned(u64::from(r.read_u16()?)), + Unsigned(u64::from(r.read_u16()?)), + ])) + } + (Type::SSHORT, 2) => { + let mut r = self.r(bo); + Ok(List(vec![ + Signed(i64::from(r.read_i16()?)), + Signed(i64::from(r.read_i16()?)), + ])) + } + (Type::SHORT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(Unsigned(u64::from(decoder.read_short()?))) + }), + (Type::SSHORT, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(Signed(i64::from(decoder.read_sshort()?))) + }), + (Type::LONG, 1) => Ok(Unsigned(self.r(bo).read_u32()?.into())), + (Type::SLONG, 1) => Ok(Signed(self.r(bo).read_i32()?.into())), + (Type::LONG, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(Unsigned(decoder.read_long()?.into())) + }), + (Type::SLONG, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(Signed(decoder.read_slong()?.into())) + }), + (Type::RATIONAL, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(Rational(decoder.read_long()?.into(), decoder.read_long()?.into())) + }), + (Type::SRATIONAL, n) => self.decode_offset(n, bo, limits, decoder, |decoder| { + Ok(SRational(decoder.read_slong()?.into(), decoder.read_slong()?.into())) + }), + (Type::ASCII, n) => { + println!("ASCIII COUNT {}", n); + let n = usize::try_from(n)?; + if n > limits.decoding_buffer_size { + return Err(TiffError::LimitsExceeded); + } + let offset = if decoder.bigtiff { + self.r(bo).read_u64()? + } else { + self.r(bo).read_u32()?.into() + }; + decoder.goto_offset(offset)?; + let string = decoder.read_string(n)?; + Ok(Ascii(string)) + } + _ => Err(TiffError::UnsupportedError( + TiffUnsupportedError::UnsupportedDataType, + )), } - _ => Err(TiffError::UnsupportedError( - TiffUnsupportedError::UnsupportedDataType, - )), } } #[inline] - fn decode_offset(&self, value_count: u32, bo: ByteOrder, limits: &super::Limits, decoder: &mut super::Decoder, decode_fn: F) -> TiffResult + fn decode_offset(&self, value_count: u64, bo: ByteOrder, limits: &super::Limits, decoder: &mut super::Decoder, decode_fn: F) -> TiffResult where R: Read + Seek, F: Fn(&mut super::Decoder) -> TiffResult, @@ -220,7 +282,12 @@ impl Entry { } let mut v = Vec::with_capacity(value_count); - decoder.goto_offset(self.r(bo).read_u32()?)?; + let offset = if decoder.bigtiff { + self.r(bo).read_u64()? + } else { + self.r(bo).read_u32()?.into() + }; + decoder.goto_offset(offset)?; for _ in 0..value_count { v.push(decode_fn(decoder)?) } @@ -234,7 +301,7 @@ fn offset_to_bytes(n: usize, entry: &Entry) -> TiffResult { Ok(List( entry.offset[0..n] .iter() - .map(|&e| Unsigned(u32::from(e))) + .map(|&e| Unsigned(u64::from(e))) .collect() )) } @@ -245,7 +312,7 @@ fn offset_to_sbytes(n: usize, entry: &Entry) -> TiffResult { Ok(List( entry.offset[0..n] .iter() - .map(|&e| Signed(i32::from(e as i8))) + .map(|&e| Signed(i64::from(e as i8))) .collect() )) } diff --git a/src/decoder/mod.rs b/src/decoder/mod.rs index a2cd6a0..c34d228 100644 --- a/src/decoder/mod.rs +++ b/src/decoder/mod.rs @@ -1,4 +1,4 @@ -use std::convert::TryFrom; +use std::convert::{TryInto, TryFrom}; use std::collections::HashMap; use std::io::{self, Read, Seek}; use std::cmp; @@ -116,8 +116,8 @@ impl<'a> DecodingBuffer<'a> { #[derive(Debug)] struct StripDecodeState { strip_index: usize, - strip_offsets: Vec, - strip_bytes: Vec, + strip_offsets: Vec, + strip_bytes: Vec, } /// Decoding limits @@ -157,8 +157,9 @@ where { reader: SmartReader, byte_order: ByteOrder, + bigtiff: bool, limits: Limits, - next_ifd: Option, + next_ifd: Option, ifd: Option, width: u32, height: u32, @@ -248,6 +249,7 @@ impl Decoder { Decoder { reader: SmartReader::wrap(r, ByteOrder::LittleEndian), byte_order: ByteOrder::LittleEndian, + bigtiff: false, limits: Default::default(), next_ifd: None, ifd: None, @@ -330,12 +332,28 @@ impl Decoder { )) } } - if self.read_short()? != 42 { - return Err(TiffError::FormatError( + match self.read_short()? { + 42 => self.bigtiff = false, + 43 => { + self.bigtiff = true; + // Read bytesize of offsets (in bigtiff it's alway 8 but provide a way to move to 16 some day) + if self.read_short()? != 8 { + return Err(TiffError::FormatError( + TiffFormatError::TiffSignatureNotFound, + )) + } + // This constant should always be 0 + if self.read_short()? != 0 { + return Err(TiffError::FormatError( + TiffFormatError::TiffSignatureNotFound, + )) + } + }, + _ => return Err(TiffError::FormatError( TiffFormatError::TiffSignatureInvalid, - )); + )) } - self.next_ifd = match self.read_long()? { + self.next_ifd = match self.read_ifd_offset()? { 0 => None, n => Some(n), }; @@ -354,8 +372,8 @@ impl Decoder { /// To determine whether there are more images call `TIFFDecoder::more_images` instead. pub fn next_image(&mut self) -> TiffResult<()> { self.ifd = Some(self.read_ifd()?); - self.width = self.get_tag_u32(Tag::ImageWidth)?; - self.height = self.get_tag_u32(Tag::ImageLength)?; + self.width = u32::try_from(self.get_tag_u64(Tag::ImageWidth)?)?; + self.height = u32::try_from(self.get_tag_u64(Tag::ImageLength)?)?; self.strip_decoder = None; self.photometric_interpretation = self @@ -389,6 +407,15 @@ impl Decoder { self.byte_order } + #[inline] + pub fn read_ifd_offset(&mut self) -> Result { + if self.bigtiff { + self.read_long8() + } else { + self.read_long().map(u64::from) + } + } + /// Reads a TIFF byte value #[inline] pub fn read_byte(&mut self) -> Result { @@ -421,6 +448,12 @@ impl Decoder { self.reader.read_i32() } + #[inline] + pub fn read_long8(&mut self) -> Result { + self.reader.read_u64() + } + + /// Reads a string #[inline] pub fn read_string(&mut self, length: usize) -> TiffResult { @@ -433,17 +466,21 @@ impl Decoder { /// Reads a TIFF IFA offset/value field #[inline] - pub fn read_offset(&mut self) -> Result<[u8; 4], io::Error> { - let mut val = [0; 4]; + pub fn read_offset(&mut self) -> Result<[u8; 8], io::Error> { + let bytes_to_read = if self.bigtiff { 8 } else { 4 }; + let mut val = vec![0; bytes_to_read]; self.reader.read_exact(&mut val)?; - Ok(val) + if ! self.bigtiff { + val.append(&mut vec![0; 4]) + } + Ok(val[..].try_into().unwrap()) } /// Moves the cursor to the specified offset #[inline] - pub fn goto_offset(&mut self, offset: u32) -> io::Result<()> { + pub fn goto_offset(&mut self, offset: u64) -> io::Result<()> { self.reader - .seek(io::SeekFrom::Start(u64::from(offset))) + .seek(io::SeekFrom::Start(offset)) .map(|_| ()) } @@ -465,12 +502,17 @@ impl Decoder { return Ok(None); } }; + let count= if self.bigtiff { + self.read_long8()? + } else { + self.read_long()?.into() + }; Ok(Some(( tag, ifd::Entry::new( type_, - self.read_long()?, // count - self.read_offset()?, // offset + count, + self.read_offset()? ), ))) } @@ -493,7 +535,7 @@ impl Decoder { }; dir.insert(tag, entry); } - self.next_ifd = match self.read_long()? { + self.next_ifd = match self.read_ifd_offset()? { 0 => None, n => Some(n), }; @@ -503,6 +545,7 @@ impl Decoder { /// Tries to retrieve a tag. /// Return `Ok(None)` if the tag is not present. pub fn find_tag(&mut self, tag: Tag) -> TiffResult> { + println!("IFD {:?}", self.ifd.as_ref().unwrap().get(&tag)); let entry = match self.ifd.as_ref().unwrap().get(&tag) { None => return Ok(None), Some(entry) => entry.clone(), @@ -514,9 +557,9 @@ impl Decoder { } /// Tries to retrieve a tag and convert it to the desired unsigned type. - pub fn find_tag_unsigned>(&mut self, tag: Tag) -> TiffResult> { + pub fn find_tag_unsigned>(&mut self, tag: Tag) -> TiffResult> { self.find_tag(tag)? - .map(|v| v.into_u32()).transpose()? + .map(|v| v.into_u64()).transpose()? .map(|value| T::try_from(value) .map_err(|_| TiffFormatError::InvalidTagValueType(tag).into())) .transpose() @@ -524,9 +567,9 @@ impl Decoder { /// Tries to retrieve a vector of all a tag's values and convert them to /// the desired unsigned type. - pub fn find_tag_unsigned_vec>(&mut self, tag: Tag) -> TiffResult>> { + pub fn find_tag_unsigned_vec>(&mut self, tag: Tag) -> TiffResult>> { self.find_tag(tag)? - .map(|v| v.into_u32_vec()).transpose()? + .map(|v| v.into_u64_vec()).transpose()? .map(|v| v.into_iter() .map(|u| T::try_from(u).map_err(|_| TiffFormatError::InvalidTagValueType(tag).into())) .collect()) @@ -535,7 +578,7 @@ impl Decoder { /// Tries to retrieve a tag and convert it to the desired unsigned type. /// Returns an error if the tag is not present. - pub fn get_tag_unsigned>(&mut self, tag: Tag) -> TiffResult { + pub fn get_tag_unsigned>(&mut self, tag: Tag) -> TiffResult { self.find_tag_unsigned(tag)? .ok_or_else(|| TiffFormatError::RequiredTagNotFound(tag).into()) } @@ -552,13 +595,13 @@ impl Decoder { } /// Tries to retrieve a tag and convert it to the desired type. - pub fn get_tag_u32(&mut self, tag: Tag) -> TiffResult { - self.get_tag(tag)?.into_u32() + pub fn get_tag_u64(&mut self, tag: Tag) -> TiffResult { + self.get_tag(tag)?.into_u64() } /// Tries to retrieve a tag and convert it to the desired type. - pub fn get_tag_u32_vec(&mut self, tag: Tag) -> TiffResult> { - self.get_tag(tag)?.into_u32_vec() + pub fn get_tag_u64_vec(&mut self, tag: Tag) -> TiffResult> { + self.get_tag(tag)?.into_u64_vec() } /// Decompresses the strip into the supplied buffer. @@ -566,13 +609,13 @@ impl Decoder { fn expand_strip<'a>( &mut self, buffer: DecodingBuffer<'a>, - offset: u32, - length: u32, + offset: u64, + length: u64, max_uncompressed_length: usize, ) -> TiffResult { let color_type = self.colortype()?; self.goto_offset(offset)?; - let (bytes, mut reader): (usize, Box) = match self.compression_method { + let (bytes, mut reader): (usize, Box) = match self.compression_method { CompressionMethod::None => { let order = self.reader.byte_order; ( @@ -686,7 +729,8 @@ impl Decoder { /// Number of strips in image pub fn strip_count(&mut self) -> TiffResult { let rows_per_strip = self - .get_tag_u32(Tag::RowsPerStrip) + .get_tag_u64(Tag::RowsPerStrip) + .map(u32::try_from)? .unwrap_or(self.height); if rows_per_strip == 0 { @@ -698,8 +742,8 @@ impl Decoder { fn initialize_strip_decoder(&mut self) -> TiffResult<()> { if self.strip_decoder.is_none() { - let strip_offsets = self.get_tag_u32_vec(Tag::StripOffsets)?; - let strip_bytes = self.get_tag_u32_vec(Tag::StripByteCounts)?; + let strip_offsets = self.get_tag_u64_vec(Tag::StripOffsets)?; + let strip_bytes = self.get_tag_u64_vec(Tag::StripByteCounts)?; self.strip_decoder = Some(StripDecodeState { strip_index: 0, @@ -734,7 +778,8 @@ impl Decoder { ))?; let rows_per_strip = usize::try_from(self - .get_tag_u32(Tag::RowsPerStrip) + .get_tag_u64(Tag::RowsPerStrip) + .map(u32::try_from)? .unwrap_or(self.height))?; let strip_height = cmp::min( @@ -806,7 +851,8 @@ impl Decoder { let index = self.strip_decoder.as_ref().unwrap().strip_index; let rows_per_strip = usize::try_from(self - .get_tag_u32(Tag::RowsPerStrip) + .get_tag_u64(Tag::RowsPerStrip) + .map(u32::try_from)? .unwrap_or(self.height))?; let strip_height = cmp::min( @@ -825,7 +871,8 @@ impl Decoder { pub fn read_image(&mut self) -> TiffResult { self.initialize_strip_decoder()?; let rows_per_strip = usize::try_from(self - .get_tag_u32(Tag::RowsPerStrip) + .get_tag_u64(Tag::RowsPerStrip) + .map(u32::try_from)? .unwrap_or(self.height))?; let samples_per_strip = diff --git a/tests/encode_images.rs b/tests/encode_images.rs index 9d1ecfd..c2bd88d 100644 --- a/tests/encode_images.rs +++ b/tests/encode_images.rs @@ -165,11 +165,11 @@ fn test_multiple_byte() { { let mut decoder = Decoder::new(&mut data).unwrap(); - assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_u32_vec().unwrap(), [1]); - assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_u32_vec().unwrap(), [1, 2]); - assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_u32_vec().unwrap(), [1, 2, 3]); - assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_u32_vec().unwrap(), [1, 2, 3, 4]); - assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_u32_vec().unwrap(), [1, 2, 3, 4, 5]); + assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_u64_vec().unwrap(), [1]); + assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_u64_vec().unwrap(), [1, 2]); + assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_u64_vec().unwrap(), [1, 2, 3]); + assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_u64_vec().unwrap(), [1, 2, 3, 4]); + assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_u64_vec().unwrap(), [1, 2, 3, 4, 5]); } } @@ -209,24 +209,24 @@ fn test_signed() { { let mut decoder = Decoder::new(&mut data).unwrap(); - assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_i32().unwrap(), -1, ); - assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_i32_vec().unwrap(), [-1]); - assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_i32_vec().unwrap(), [-1, 2]); - assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3]); - assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3, 4]); - assert_eq!(decoder.get_tag(Tag::Unknown(65005)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3, 4, -5], ); + assert_eq!(decoder.get_tag(Tag::Unknown(65000)).unwrap().into_i64().unwrap(), -1, ); + assert_eq!(decoder.get_tag(Tag::Unknown(65001)).unwrap().into_i64_vec().unwrap(), [-1]); + assert_eq!(decoder.get_tag(Tag::Unknown(65002)).unwrap().into_i64_vec().unwrap(), [-1, 2]); + assert_eq!(decoder.get_tag(Tag::Unknown(65003)).unwrap().into_i64_vec().unwrap(), [-1, 2, -3]); + assert_eq!(decoder.get_tag(Tag::Unknown(65004)).unwrap().into_i64_vec().unwrap(), [-1, 2, -3, 4]); + assert_eq!(decoder.get_tag(Tag::Unknown(65005)).unwrap().into_i64_vec().unwrap(), [-1, 2, -3, 4, -5], ); - assert_eq!(decoder.get_tag(Tag::Unknown(65010)).unwrap().into_i32().unwrap(), -1); - assert_eq!(decoder.get_tag(Tag::Unknown(65011)).unwrap().into_i32_vec().unwrap(), [-1]); - assert_eq!(decoder.get_tag(Tag::Unknown(65012)).unwrap().into_i32_vec().unwrap(), [-1, 2]); - assert_eq!(decoder.get_tag(Tag::Unknown(65013)).unwrap().into_i32_vec().unwrap(), [-1, 2, -3]); + assert_eq!(decoder.get_tag(Tag::Unknown(65010)).unwrap().into_i64().unwrap(), -1); + assert_eq!(decoder.get_tag(Tag::Unknown(65011)).unwrap().into_i64_vec().unwrap(), [-1]); + assert_eq!(decoder.get_tag(Tag::Unknown(65012)).unwrap().into_i64_vec().unwrap(), [-1, 2]); + assert_eq!(decoder.get_tag(Tag::Unknown(65013)).unwrap().into_i64_vec().unwrap(), [-1, 2, -3]); - assert_eq!(decoder.get_tag(Tag::Unknown(65020)).unwrap().into_i32().unwrap(), -1); - assert_eq!(decoder.get_tag(Tag::Unknown(65021)).unwrap().into_i32_vec().unwrap(), [-1]); - assert_eq!(decoder.get_tag(Tag::Unknown(65022)).unwrap().into_i32_vec().unwrap(), [-1, 2]); + assert_eq!(decoder.get_tag(Tag::Unknown(65020)).unwrap().into_i64().unwrap(), -1); + assert_eq!(decoder.get_tag(Tag::Unknown(65021)).unwrap().into_i64_vec().unwrap(), [-1]); + assert_eq!(decoder.get_tag(Tag::Unknown(65022)).unwrap().into_i64_vec().unwrap(), [-1, 2]); - assert_eq!(decoder.get_tag(Tag::Unknown(65030)).unwrap().into_i32_vec().unwrap(), [-1, 100]); - assert_eq!(decoder.get_tag(Tag::Unknown(65031)).unwrap().into_i32_vec().unwrap(), [-1_i32, 100, 2, 100]); + assert_eq!(decoder.get_tag(Tag::Unknown(65030)).unwrap().into_i64_vec().unwrap(), [-1, 100]); + assert_eq!(decoder.get_tag(Tag::Unknown(65031)).unwrap().into_i64_vec().unwrap(), [-1_i64, 100, 2, 100]); } }