aboutsummaryrefslogtreecommitdiff
path: root/vendor/tiff/src/decoder/ifd.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/tiff/src/decoder/ifd.rs')
-rw-r--r--vendor/tiff/src/decoder/ifd.rs670
1 files changed, 0 insertions, 670 deletions
diff --git a/vendor/tiff/src/decoder/ifd.rs b/vendor/tiff/src/decoder/ifd.rs
deleted file mode 100644
index b05513d..0000000
--- a/vendor/tiff/src/decoder/ifd.rs
+++ /dev/null
@@ -1,670 +0,0 @@
-//! Function for reading TIFF tags
-
-use std::collections::HashMap;
-use std::convert::{TryFrom, TryInto};
-use std::io::{self, Read, Seek};
-use std::mem;
-use std::str;
-
-use super::stream::{ByteOrder, EndianReader, SmartReader};
-use crate::tags::{Tag, Type};
-use crate::{TiffError, TiffFormatError, TiffResult};
-
-use self::Value::{
- Ascii, Byte, Double, Float, Ifd, IfdBig, List, Rational, RationalBig, SRational, SRationalBig,
- Short, Signed, SignedBig, Unsigned, UnsignedBig,
-};
-
-#[allow(unused_qualifications)]
-#[derive(Debug, Clone, PartialEq)]
-#[non_exhaustive]
-pub enum Value {
- Byte(u8),
- Short(u16),
- Signed(i32),
- SignedBig(i64),
- Unsigned(u32),
- UnsignedBig(u64),
- Float(f32),
- Double(f64),
- List(Vec<Value>),
- Rational(u32, u32),
- RationalBig(u64, u64),
- SRational(i32, i32),
- SRationalBig(i64, i64),
- Ascii(String),
- Ifd(u32),
- IfdBig(u64),
-}
-
-impl Value {
- pub fn into_u8(self) -> TiffResult<u8> {
- match self {
- Byte(val) => Ok(val),
- val => Err(TiffError::FormatError(TiffFormatError::ByteExpected(val))),
- }
- }
-
- pub fn into_u16(self) -> TiffResult<u16> {
- match self {
- Short(val) => Ok(val),
- Unsigned(val) => Ok(u16::try_from(val)?),
- UnsignedBig(val) => Ok(u16::try_from(val)?),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_u32(self) -> TiffResult<u32> {
- match self {
- Short(val) => Ok(val.into()),
- Unsigned(val) => Ok(val),
- UnsignedBig(val) => Ok(u32::try_from(val)?),
- Ifd(val) => Ok(val),
- IfdBig(val) => Ok(u32::try_from(val)?),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_i32(self) -> TiffResult<i32> {
- match self {
- Signed(val) => Ok(val),
- SignedBig(val) => Ok(i32::try_from(val)?),
- val => Err(TiffError::FormatError(
- TiffFormatError::SignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_u64(self) -> TiffResult<u64> {
- match self {
- Short(val) => Ok(val.into()),
- Unsigned(val) => Ok(val.into()),
- UnsignedBig(val) => Ok(val),
- Ifd(val) => Ok(val.into()),
- IfdBig(val) => Ok(val),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_i64(self) -> TiffResult<i64> {
- match self {
- Signed(val) => Ok(val.into()),
- SignedBig(val) => Ok(val),
- val => Err(TiffError::FormatError(
- TiffFormatError::SignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_f32(self) -> TiffResult<f32> {
- match self {
- Float(val) => Ok(val),
- val => Err(TiffError::FormatError(
- TiffFormatError::SignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_f64(self) -> TiffResult<f64> {
- match self {
- Double(val) => Ok(val),
- val => Err(TiffError::FormatError(
- TiffFormatError::SignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_string(self) -> TiffResult<String> {
- match self {
- Ascii(val) => Ok(val),
- val => Err(TiffError::FormatError(
- TiffFormatError::SignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_u32_vec(self) -> TiffResult<Vec<u32>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- new_vec.push(v.into_u32()?)
- }
- Ok(new_vec)
- }
- Unsigned(val) => Ok(vec![val]),
- UnsignedBig(val) => Ok(vec![u32::try_from(val)?]),
- Rational(numerator, denominator) => Ok(vec![numerator, denominator]),
- RationalBig(numerator, denominator) => {
- Ok(vec![u32::try_from(numerator)?, u32::try_from(denominator)?])
- }
- Ifd(val) => Ok(vec![val]),
- IfdBig(val) => Ok(vec![u32::try_from(val)?]),
- Ascii(val) => Ok(val.chars().map(u32::from).collect()),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_u8_vec(self) -> TiffResult<Vec<u8>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- new_vec.push(v.into_u8()?)
- }
- Ok(new_vec)
- }
- Byte(val) => Ok(vec![val]),
-
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_u16_vec(self) -> TiffResult<Vec<u16>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- new_vec.push(v.into_u16()?)
- }
- Ok(new_vec)
- }
- Short(val) => Ok(vec![val]),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_i32_vec(self) -> TiffResult<Vec<i32>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- match v {
- SRational(numerator, denominator) => {
- new_vec.push(numerator);
- new_vec.push(denominator);
- }
- SRationalBig(numerator, denominator) => {
- new_vec.push(i32::try_from(numerator)?);
- new_vec.push(i32::try_from(denominator)?);
- }
- _ => new_vec.push(v.into_i32()?),
- }
- }
- Ok(new_vec)
- }
- Signed(val) => Ok(vec![val]),
- SignedBig(val) => Ok(vec![i32::try_from(val)?]),
- SRational(numerator, denominator) => Ok(vec![numerator, denominator]),
- SRationalBig(numerator, denominator) => {
- Ok(vec![i32::try_from(numerator)?, i32::try_from(denominator)?])
- }
- val => Err(TiffError::FormatError(
- TiffFormatError::SignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_f32_vec(self) -> TiffResult<Vec<f32>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- new_vec.push(v.into_f32()?)
- }
- Ok(new_vec)
- }
- Float(val) => Ok(vec![val]),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_f64_vec(self) -> TiffResult<Vec<f64>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- new_vec.push(v.into_f64()?)
- }
- Ok(new_vec)
- }
- Double(val) => Ok(vec![val]),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_u64_vec(self) -> TiffResult<Vec<u64>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- new_vec.push(v.into_u64()?)
- }
- Ok(new_vec)
- }
- Unsigned(val) => Ok(vec![val.into()]),
- UnsignedBig(val) => Ok(vec![val]),
- Rational(numerator, denominator) => Ok(vec![numerator.into(), denominator.into()]),
- RationalBig(numerator, denominator) => Ok(vec![numerator, denominator]),
- Ifd(val) => Ok(vec![val.into()]),
- IfdBig(val) => Ok(vec![val]),
- Ascii(val) => Ok(val.chars().map(u32::from).map(u64::from).collect()),
- val => Err(TiffError::FormatError(
- TiffFormatError::UnsignedIntegerExpected(val),
- )),
- }
- }
-
- pub fn into_i64_vec(self) -> TiffResult<Vec<i64>> {
- match self {
- List(vec) => {
- let mut new_vec = Vec::with_capacity(vec.len());
- for v in vec {
- match v {
- SRational(numerator, denominator) => {
- new_vec.push(numerator.into());
- new_vec.push(denominator.into());
- }
- SRationalBig(numerator, denominator) => {
- new_vec.push(numerator);
- new_vec.push(denominator);
- }
- _ => new_vec.push(v.into_i64()?),
- }
- }
- Ok(new_vec)
- }
- Signed(val) => Ok(vec![val.into()]),
- SignedBig(val) => Ok(vec![val]),
- SRational(numerator, denominator) => Ok(vec![numerator.into(), denominator.into()]),
- SRationalBig(numerator, denominator) => Ok(vec![numerator, denominator]),
- val => Err(TiffError::FormatError(
- TiffFormatError::SignedIntegerExpected(val),
- )),
- }
- }
-}
-
-#[derive(Clone)]
-pub struct Entry {
- type_: Type,
- count: u64,
- offset: [u8; 8],
-}
-
-impl ::std::fmt::Debug for Entry {
- fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
- fmt.write_str(&format!(
- "Entry {{ type_: {:?}, count: {:?}, offset: {:?} }}",
- self.type_, self.count, &self.offset
- ))
- }
-}
-
-impl Entry {
- pub fn new(type_: Type, count: u32, offset: [u8; 4]) -> Entry {
- let mut offset = offset.to_vec();
- offset.append(&mut vec![0; 4]);
- Entry::new_u64(type_, count.into(), offset[..].try_into().unwrap())
- }
-
- pub fn new_u64(type_: Type, count: u64, offset: [u8; 8]) -> Entry {
- Entry {
- type_,
- count,
- offset,
- }
- }
-
- /// Returns a mem_reader for the offset/value field
- fn r(&self, byte_order: ByteOrder) -> SmartReader<io::Cursor<Vec<u8>>> {
- SmartReader::wrap(io::Cursor::new(self.offset.to_vec()), byte_order)
- }
-
- pub fn val<R: Read + Seek>(
- &self,
- limits: &super::Limits,
- bigtiff: bool,
- reader: &mut SmartReader<R>,
- ) -> TiffResult<Value> {
- // Case 1: there are no values so we can return immediately.
- if self.count == 0 {
- return Ok(List(Vec::new()));
- }
-
- let bo = reader.byte_order();
-
- let tag_size = match self.type_ {
- Type::BYTE | Type::SBYTE | Type::ASCII | Type::UNDEFINED => 1,
- Type::SHORT | Type::SSHORT => 2,
- Type::LONG | Type::SLONG | Type::FLOAT | Type::IFD => 4,
- Type::LONG8
- | Type::SLONG8
- | Type::DOUBLE
- | Type::RATIONAL
- | Type::SRATIONAL
- | Type::IFD8 => 8,
- };
-
- let value_bytes = match self.count.checked_mul(tag_size) {
- Some(n) => n,
- None => {
- return Err(TiffError::LimitsExceeded);
- }
- };
-
- // Case 2: there is one value.
- if self.count == 1 {
- // 2a: the value is 5-8 bytes and we're in BigTiff mode.
- if bigtiff && value_bytes > 4 && value_bytes <= 8 {
- return Ok(match self.type_ {
- Type::LONG8 => UnsignedBig(self.r(bo).read_u64()?),
- Type::SLONG8 => SignedBig(self.r(bo).read_i64()?),
- Type::DOUBLE => Double(self.r(bo).read_f64()?),
- Type::RATIONAL => {
- let mut r = self.r(bo);
- Rational(r.read_u32()?, r.read_u32()?)
- }
- Type::SRATIONAL => {
- let mut r = self.r(bo);
- SRational(r.read_i32()?, r.read_i32()?)
- }
- Type::IFD8 => IfdBig(self.r(bo).read_u64()?),
- Type::BYTE
- | Type::SBYTE
- | Type::ASCII
- | Type::UNDEFINED
- | Type::SHORT
- | Type::SSHORT
- | Type::LONG
- | Type::SLONG
- | Type::FLOAT
- | Type::IFD => unreachable!(),
- });
- }
-
- // 2b: the value is at most 4 bytes or doesn't fit in the offset field.
- return Ok(match self.type_ {
- Type::BYTE => Unsigned(u32::from(self.offset[0])),
- Type::SBYTE => Signed(i32::from(self.offset[0] as i8)),
- Type::UNDEFINED => Byte(self.offset[0]),
- Type::SHORT => Unsigned(u32::from(self.r(bo).read_u16()?)),
- Type::SSHORT => Signed(i32::from(self.r(bo).read_i16()?)),
- Type::LONG => Unsigned(self.r(bo).read_u32()?),
- Type::SLONG => Signed(self.r(bo).read_i32()?),
- Type::FLOAT => Float(self.r(bo).read_f32()?),
- Type::ASCII => {
- if self.offset[0] == 0 {
- Ascii("".to_string())
- } else {
- return Err(TiffError::FormatError(TiffFormatError::InvalidTag));
- }
- }
- Type::LONG8 => {
- reader.goto_offset(self.r(bo).read_u32()?.into())?;
- UnsignedBig(reader.read_u64()?)
- }
- Type::SLONG8 => {
- reader.goto_offset(self.r(bo).read_u32()?.into())?;
- SignedBig(reader.read_i64()?)
- }
- Type::DOUBLE => {
- reader.goto_offset(self.r(bo).read_u32()?.into())?;
- Double(reader.read_f64()?)
- }
- Type::RATIONAL => {
- reader.goto_offset(self.r(bo).read_u32()?.into())?;
- Rational(reader.read_u32()?, reader.read_u32()?)
- }
- Type::SRATIONAL => {
- reader.goto_offset(self.r(bo).read_u32()?.into())?;
- SRational(reader.read_i32()?, reader.read_i32()?)
- }
- Type::IFD => Ifd(self.r(bo).read_u32()?),
- Type::IFD8 => {
- reader.goto_offset(self.r(bo).read_u32()?.into())?;
- IfdBig(reader.read_u64()?)
- }
- });
- }
-
- // Case 3: There is more than one value, but it fits in the offset field.
- if value_bytes <= 4 || bigtiff && value_bytes <= 8 {
- match self.type_ {
- Type::BYTE => return offset_to_bytes(self.count as usize, self),
- Type::SBYTE => return offset_to_sbytes(self.count as usize, self),
- Type::ASCII => {
- let mut buf = vec![0; self.count as usize];
- self.r(bo).read_exact(&mut buf)?;
- if buf.is_ascii() && buf.ends_with(&[0]) {
- let v = str::from_utf8(&buf)?;
- let v = v.trim_matches(char::from(0));
- return Ok(Ascii(v.into()));
- } else {
- return Err(TiffError::FormatError(TiffFormatError::InvalidTag));
- }
- }
- Type::UNDEFINED => {
- return Ok(List(
- self.offset[0..self.count as usize]
- .iter()
- .map(|&b| Byte(b))
- .collect(),
- ));
- }
- Type::SHORT => {
- let mut r = self.r(bo);
- let mut v = Vec::new();
- for _ in 0..self.count {
- v.push(Short(r.read_u16()?));
- }
- return Ok(List(v));
- }
- Type::SSHORT => {
- let mut r = self.r(bo);
- let mut v = Vec::new();
- for _ in 0..self.count {
- v.push(Signed(i32::from(r.read_i16()?)));
- }
- return Ok(List(v));
- }
- Type::LONG => {
- let mut r = self.r(bo);
- let mut v = Vec::new();
- for _ in 0..self.count {
- v.push(Unsigned(r.read_u32()?));
- }
- return Ok(List(v));
- }
- Type::SLONG => {
- let mut r = self.r(bo);
- let mut v = Vec::new();
- for _ in 0..self.count {
- v.push(Signed(r.read_i32()?));
- }
- return Ok(List(v));
- }
- Type::FLOAT => {
- let mut r = self.r(bo);
- let mut v = Vec::new();
- for _ in 0..self.count {
- v.push(Float(r.read_f32()?));
- }
- return Ok(List(v));
- }
- Type::IFD => {
- let mut r = self.r(bo);
- let mut v = Vec::new();
- for _ in 0..self.count {
- v.push(Ifd(r.read_u32()?));
- }
- return Ok(List(v));
- }
- Type::LONG8
- | Type::SLONG8
- | Type::RATIONAL
- | Type::SRATIONAL
- | Type::DOUBLE
- | Type::IFD8 => {
- unreachable!()
- }
- }
- }
-
- // Case 4: there is more than one value, and it doesn't fit in the offset field.
- match self.type_ {
- // TODO check if this could give wrong results
- // at a different endianess of file/computer.
- Type::BYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- let mut buf = [0; 1];
- reader.read_exact(&mut buf)?;
- Ok(UnsignedBig(u64::from(buf[0])))
- }),
- Type::SBYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(SignedBig(i64::from(reader.read_i8()? as i8)))
- }),
- Type::SHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(UnsignedBig(u64::from(reader.read_u16()?)))
- }),
- Type::SSHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(SignedBig(i64::from(reader.read_i16()?)))
- }),
- Type::LONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(Unsigned(reader.read_u32()?))
- }),
- Type::SLONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(Signed(reader.read_i32()?))
- }),
- Type::FLOAT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(Float(reader.read_f32()?))
- }),
- Type::DOUBLE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(Double(reader.read_f64()?))
- }),
- Type::RATIONAL => {
- self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(Rational(reader.read_u32()?, reader.read_u32()?))
- })
- }
- Type::SRATIONAL => {
- self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(SRational(reader.read_i32()?, reader.read_i32()?))
- })
- }
- Type::LONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(UnsignedBig(reader.read_u64()?))
- }),
- Type::SLONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(SignedBig(reader.read_i64()?))
- }),
- Type::IFD => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(Ifd(reader.read_u32()?))
- }),
- Type::IFD8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- Ok(IfdBig(reader.read_u64()?))
- }),
- Type::UNDEFINED => {
- self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
- let mut buf = [0; 1];
- reader.read_exact(&mut buf)?;
- Ok(Byte(buf[0]))
- })
- }
- Type::ASCII => {
- let n = usize::try_from(self.count)?;
- if n > limits.decoding_buffer_size {
- return Err(TiffError::LimitsExceeded);
- }
-
- if bigtiff {
- reader.goto_offset(self.r(bo).read_u64()?)?
- } else {
- reader.goto_offset(self.r(bo).read_u32()?.into())?
- }
-
- let mut out = vec![0; n];
- reader.read_exact(&mut out)?;
- // Strings may be null-terminated, so we trim anything downstream of the null byte
- if let Some(first) = out.iter().position(|&b| b == 0) {
- out.truncate(first);
- }
- Ok(Ascii(String::from_utf8(out)?))
- }
- }
- }
-
- #[inline]
- fn decode_offset<R, F>(
- &self,
- value_count: u64,
- bo: ByteOrder,
- bigtiff: bool,
- limits: &super::Limits,
- reader: &mut SmartReader<R>,
- decode_fn: F,
- ) -> TiffResult<Value>
- where
- R: Read + Seek,
- F: Fn(&mut SmartReader<R>) -> TiffResult<Value>,
- {
- let value_count = usize::try_from(value_count)?;
- if value_count > limits.decoding_buffer_size / mem::size_of::<Value>() {
- return Err(TiffError::LimitsExceeded);
- }
-
- let mut v = Vec::with_capacity(value_count);
-
- let offset = if bigtiff {
- self.r(bo).read_u64()?
- } else {
- self.r(bo).read_u32()?.into()
- };
- reader.goto_offset(offset)?;
-
- for _ in 0..value_count {
- v.push(decode_fn(reader)?)
- }
- Ok(List(v))
- }
-}
-
-/// Extracts a list of BYTE tags stored in an offset
-#[inline]
-fn offset_to_bytes(n: usize, entry: &Entry) -> TiffResult<Value> {
- Ok(List(
- entry.offset[0..n]
- .iter()
- .map(|&e| Unsigned(u32::from(e)))
- .collect(),
- ))
-}
-
-/// Extracts a list of SBYTE tags stored in an offset
-#[inline]
-fn offset_to_sbytes(n: usize, entry: &Entry) -> TiffResult<Value> {
- Ok(List(
- entry.offset[0..n]
- .iter()
- .map(|&e| Signed(i32::from(e as i8)))
- .collect(),
- ))
-}
-
-/// Type representing an Image File Directory
-pub type Directory = HashMap<Tag, Entry>;
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.