diff options
Diffstat (limited to 'vendor/tiff/src/error.rs')
| -rw-r--r-- | vendor/tiff/src/error.rs | 369 |
1 files changed, 369 insertions, 0 deletions
diff --git a/vendor/tiff/src/error.rs b/vendor/tiff/src/error.rs new file mode 100644 index 0000000..a401c6f --- /dev/null +++ b/vendor/tiff/src/error.rs @@ -0,0 +1,369 @@ +use std::error::Error; +use std::fmt; +use std::fmt::Display; +use std::io; +use std::str; +use std::string; +use std::sync::Arc; + +use jpeg::UnsupportedFeature; + +use crate::decoder::{ifd::Value, ChunkType}; +use crate::tags::{ + CompressionMethod, PhotometricInterpretation, PlanarConfiguration, SampleFormat, Tag, +}; +use crate::ColorType; + +use crate::weezl::LzwError; + +/// Tiff error kinds. +#[derive(Debug)] +pub enum TiffError { + /// The Image is not formatted properly. + FormatError(TiffFormatError), + + /// The Decoder does not support features required by the image. + UnsupportedError(TiffUnsupportedError), + + /// An I/O Error occurred while decoding the image. + IoError(io::Error), + + /// The Limits of the Decoder is exceeded. + LimitsExceeded, + + /// An integer conversion to or from a platform size failed, either due to + /// limits of the platform size or limits of the format. + IntSizeError, + + /// The image does not support the requested operation + UsageError(UsageError), +} + +/// The image is not formatted properly. +/// +/// This indicates that the encoder producing the image might behave incorrectly or that the input +/// file has been corrupted. +/// +/// The list of variants may grow to incorporate errors of future features. Matching against this +/// exhaustively is not covered by interface stability guarantees. +#[derive(Debug, Clone, PartialEq)] +#[non_exhaustive] +pub enum TiffFormatError { + TiffSignatureNotFound, + TiffSignatureInvalid, + ImageFileDirectoryNotFound, + InconsistentSizesEncountered, + UnexpectedCompressedData { + actual_bytes: usize, + required_bytes: usize, + }, + InconsistentStripSamples { + actual_samples: usize, + required_samples: usize, + }, + InvalidDimensions(u32, u32), + InvalidTag, + InvalidTagValueType(Tag), + RequiredTagNotFound(Tag), + UnknownPredictor(u16), + ByteExpected(Value), + UnsignedIntegerExpected(Value), + SignedIntegerExpected(Value), + Format(String), + RequiredTagEmpty(Tag), + StripTileTagConflict, + CycleInOffsets, + JpegDecoder(JpegDecoderError), +} + +impl fmt::Display for TiffFormatError { + fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { + use self::TiffFormatError::*; + match *self { + TiffSignatureNotFound => write!(fmt, "TIFF signature not found."), + TiffSignatureInvalid => write!(fmt, "TIFF signature invalid."), + ImageFileDirectoryNotFound => write!(fmt, "Image file directory not found."), + InconsistentSizesEncountered => write!(fmt, "Inconsistent sizes encountered."), + UnexpectedCompressedData { + actual_bytes, + required_bytes, + } => { + write!( + fmt, + "Decompression returned different amount of bytes than expected: got {}, expected {}.", + actual_bytes, required_bytes + ) + } + InconsistentStripSamples { + actual_samples, + required_samples, + } => { + write!( + fmt, + "Inconsistent elements in strip: got {}, expected {}.", + actual_samples, required_samples + ) + } + InvalidDimensions(width, height) => write!(fmt, "Invalid dimensions: {}x{}.", width, height), + InvalidTag => write!(fmt, "Image contains invalid tag."), + InvalidTagValueType(ref tag) => { + write!(fmt, "Tag `{:?}` did not have the expected value type.", tag) + } + RequiredTagNotFound(ref tag) => write!(fmt, "Required tag `{:?}` not found.", tag), + UnknownPredictor(ref predictor) => { + write!(fmt, "Unknown predictor “{}” encountered", predictor) + } + ByteExpected(ref val) => write!(fmt, "Expected byte, {:?} found.", val), + UnsignedIntegerExpected(ref val) => { + write!(fmt, "Expected unsigned integer, {:?} found.", val) + } + SignedIntegerExpected(ref val) => { + write!(fmt, "Expected signed integer, {:?} found.", val) + } + Format(ref val) => write!(fmt, "Invalid format: {:?}.", val), + RequiredTagEmpty(ref val) => write!(fmt, "Required tag {:?} was empty.", val), + StripTileTagConflict => write!(fmt, "File should contain either (StripByteCounts and StripOffsets) or (TileByteCounts and TileOffsets), other combination was found."), + CycleInOffsets => write!(fmt, "File contained a cycle in the list of IFDs"), + JpegDecoder(ref error) => write!(fmt, "{}", error), + } + } +} + +/// The Decoder does not support features required by the image. +/// +/// This only captures known failures for which the standard either does not require support or an +/// implementation has been planned but not yet completed. Some variants may become unused over +/// time and will then get deprecated before being removed. +/// +/// The list of variants may grow. Matching against this exhaustively is not covered by interface +/// stability guarantees. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +#[non_exhaustive] +pub enum TiffUnsupportedError { + FloatingPointPredictor(ColorType), + HorizontalPredictor(ColorType), + InterpretationWithBits(PhotometricInterpretation, Vec<u8>), + UnknownInterpretation, + UnknownCompressionMethod, + UnsupportedCompressionMethod(CompressionMethod), + UnsupportedSampleDepth(u8), + UnsupportedSampleFormat(Vec<SampleFormat>), + UnsupportedColorType(ColorType), + UnsupportedBitsPerChannel(u8), + UnsupportedPlanarConfig(Option<PlanarConfiguration>), + UnsupportedDataType, + UnsupportedInterpretation(PhotometricInterpretation), + UnsupportedJpegFeature(UnsupportedFeature), +} + +impl fmt::Display for TiffUnsupportedError { + fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { + use self::TiffUnsupportedError::*; + match *self { + FloatingPointPredictor(color_type) => write!( + fmt, + "Floating point predictor for {:?} is unsupported.", + color_type + ), + HorizontalPredictor(color_type) => write!( + fmt, + "Horizontal predictor for {:?} is unsupported.", + color_type + ), + InterpretationWithBits(ref photometric_interpretation, ref bits_per_sample) => write!( + fmt, + "{:?} with {:?} bits per sample is unsupported", + photometric_interpretation, bits_per_sample + ), + UnknownInterpretation => write!( + fmt, + "The image is using an unknown photometric interpretation." + ), + UnknownCompressionMethod => write!(fmt, "Unknown compression method."), + UnsupportedCompressionMethod(method) => { + write!(fmt, "Compression method {:?} is unsupported", method) + } + UnsupportedSampleDepth(samples) => { + write!(fmt, "{} samples per pixel is unsupported.", samples) + } + UnsupportedSampleFormat(ref formats) => { + write!(fmt, "Sample format {:?} is unsupported.", formats) + } + UnsupportedColorType(color_type) => { + write!(fmt, "Color type {:?} is unsupported", color_type) + } + UnsupportedBitsPerChannel(bits) => { + write!(fmt, "{} bits per channel not supported", bits) + } + UnsupportedPlanarConfig(config) => { + write!(fmt, "Unsupported planar configuration “{:?}”.", config) + } + UnsupportedDataType => write!(fmt, "Unsupported data type."), + UnsupportedInterpretation(interpretation) => { + write!( + fmt, + "Unsupported photometric interpretation \"{:?}\".", + interpretation + ) + } + UnsupportedJpegFeature(ref unsupported_feature) => { + write!(fmt, "Unsupported JPEG feature {:?}", unsupported_feature) + } + } + } +} + +/// User attempted to use the Decoder in a way that is incompatible with a specific image. +/// +/// For example: attempting to read a tile from a stripped image. +#[derive(Debug)] +pub enum UsageError { + InvalidChunkType(ChunkType, ChunkType), + InvalidChunkIndex(u32), +} + +impl fmt::Display for UsageError { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + use self::UsageError::*; + match *self { + InvalidChunkType(expected, actual) => { + write!( + fmt, + "Requested operation is only valid for images with chunk encoding of type: {:?}, got {:?}.", + expected, actual + ) + } + InvalidChunkIndex(index) => write!(fmt, "Image chunk index ({}) requested.", index), + } + } +} + +impl fmt::Display for TiffError { + fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { + match *self { + TiffError::FormatError(ref e) => write!(fmt, "Format error: {}", e), + TiffError::UnsupportedError(ref f) => write!( + fmt, + "The Decoder does not support the \ + image format `{}`", + f + ), + TiffError::IoError(ref e) => e.fmt(fmt), + TiffError::LimitsExceeded => write!(fmt, "The Decoder limits are exceeded"), + TiffError::IntSizeError => write!(fmt, "Platform or format size limits exceeded"), + TiffError::UsageError(ref e) => write!(fmt, "Usage error: {}", e), + } + } +} + +impl Error for TiffError { + fn description(&self) -> &str { + match *self { + TiffError::FormatError(..) => "Format error", + TiffError::UnsupportedError(..) => "Unsupported error", + TiffError::IoError(..) => "IO error", + TiffError::LimitsExceeded => "Decoder limits exceeded", + TiffError::IntSizeError => "Platform or format size limits exceeded", + TiffError::UsageError(..) => "Invalid usage", + } + } + + fn cause(&self) -> Option<&dyn Error> { + match *self { + TiffError::IoError(ref e) => Some(e), + _ => None, + } + } +} + +impl From<io::Error> for TiffError { + fn from(err: io::Error) -> TiffError { + TiffError::IoError(err) + } +} + +impl From<str::Utf8Error> for TiffError { + fn from(_err: str::Utf8Error) -> TiffError { + TiffError::FormatError(TiffFormatError::InvalidTag) + } +} + +impl From<string::FromUtf8Error> for TiffError { + fn from(_err: string::FromUtf8Error) -> TiffError { + TiffError::FormatError(TiffFormatError::InvalidTag) + } +} + +impl From<TiffFormatError> for TiffError { + fn from(err: TiffFormatError) -> TiffError { + TiffError::FormatError(err) + } +} + +impl From<TiffUnsupportedError> for TiffError { + fn from(err: TiffUnsupportedError) -> TiffError { + TiffError::UnsupportedError(err) + } +} + +impl From<UsageError> for TiffError { + fn from(err: UsageError) -> TiffError { + TiffError::UsageError(err) + } +} + +impl From<std::num::TryFromIntError> for TiffError { + fn from(_err: std::num::TryFromIntError) -> TiffError { + TiffError::IntSizeError + } +} + +impl From<LzwError> for TiffError { + fn from(err: LzwError) -> TiffError { + match err { + LzwError::InvalidCode => TiffError::FormatError(TiffFormatError::Format(String::from( + "LZW compressed data corrupted", + ))), + } + } +} + +#[derive(Debug, Clone)] +pub struct JpegDecoderError { + inner: Arc<jpeg::Error>, +} + +impl JpegDecoderError { + fn new(error: jpeg::Error) -> Self { + Self { + inner: Arc::new(error), + } + } +} + +impl PartialEq for JpegDecoderError { + fn eq(&self, other: &Self) -> bool { + Arc::ptr_eq(&self.inner, &other.inner) + } +} + +impl Display for JpegDecoderError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.inner.fmt(f) + } +} + +impl From<JpegDecoderError> for TiffError { + fn from(error: JpegDecoderError) -> Self { + TiffError::FormatError(TiffFormatError::JpegDecoder(error)) + } +} + +impl From<jpeg::Error> for TiffError { + fn from(error: jpeg::Error) -> Self { + JpegDecoderError::new(error).into() + } +} + +/// Result of an image decoding/encoding process +pub type TiffResult<T> = Result<T, TiffError>; |