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

Merge pull request #11 from fschutt/typed_errors

Browse Source 
Use typed errors instead of strings
This commit is contained in:
Sven Nilsen authored and GitHub committed 2018-09-19 15:21:44 +02:00
2 parents daf23f34a0 0089e93b49
commit 80c8c16beb
4 files changed
+93 -60
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/decoder/ifd.rs
+4 -6
View File
@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek};
use std::collections::{HashMap};
use super::stream::{ByteOrder, SmartReader, EndianReader};
use ::{TiffError, TiffResult};
use ::{TiffError, TiffFormatError, TiffUnsupportedError, TiffResult};
use self::Value::{Unsigned, List, Rational};
@@ -86,7 +86,7 @@ pub enum Type {
#[allow(unused_qualifications)]
#[derive(Debug)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Value {
//Signed(i32),
Unsigned(u32),
@@ -98,9 +98,7 @@ impl Value {
pub fn into_u32(self) -> TiffResult<u32> {
match self {
Unsigned(val) => Ok(val),
val => Err(TiffError::FormatError(format!(
"Expected unsigned integer, {:?} found.", val
)))
val => Err(TiffError::FormatError(TiffFormatError::UnsignedIntegerExpected(val))),
}
}
pub fn into_u32_vec(self) -> TiffResult<Vec<u32>> {
@@ -196,7 +194,7 @@ impl Entry {
}
Ok(List(v))
},
_ => Err(TiffError::UnsupportedError("Unsupported data type.".to_string()))
_ => Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedDataType))
}
}
}
src/decoder/mod.rs
+24 -51
View File
@@ -3,7 +3,7 @@ use std::mem;
use num_traits::{FromPrimitive, Num};
use std::collections::HashMap;
use ::{ColorType, TiffError, TiffResult};
use ::{ColorType, TiffError, TiffFormatError, TiffUnsupportedError, TiffResult};
use self::ifd::Directory;
@@ -35,8 +35,8 @@ enum DecodingBuffer<'a> {
U16(&'a mut [u16])
}
#[derive(Clone, Copy, Debug, PartialEq, FromPrimitive)]
enum PhotometricInterpretation {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
pub enum PhotometricInterpretation {
WhiteIsZero = 0,
BlackIsZero = 1,
RGB = 2,
@@ -47,8 +47,8 @@ enum PhotometricInterpretation {
CIELab = 8,
}
#[derive(Clone, Copy, Debug, FromPrimitive)]
enum CompressionMethod {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
pub enum CompressionMethod {
None = 1,
Huffman = 2,
Fax3 = 3,
@@ -58,13 +58,13 @@ enum CompressionMethod {
PackBits = 0x8005
}
#[derive(Clone, Copy, Debug, FromPrimitive)]
enum PlanarConfiguration {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
pub enum PlanarConfiguration {
Chunky = 1,
Planar = 2
}
#[derive(Clone, Copy, Debug, FromPrimitive)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, FromPrimitive)]
enum Predictor {
None = 1,
Horizontal = 2
@@ -125,9 +125,7 @@ fn rev_hpredict(image: DecodingResult, size: (u32, u32), color_type: ColorType)
ColorType::Gray(8) | ColorType::Gray(16) => 1,
ColorType::RGB(8) | ColorType::RGB(16) => 3,
ColorType::RGBA(8) | ColorType::RGBA(16) | ColorType::CMYK(8) => 4,
_ => return Err(TiffError::UnsupportedError(format!(
"Horizontal predictor for {:?} is unsupported.", color_type
)))
_ => return Err(TiffError::UnsupportedError(TiffUnsupportedError::HorizontalPredictor(color_type)))
};
Ok(match image {
DecodingResult::U8(buf) => {
@@ -171,9 +169,8 @@ impl<R: Read + Seek> Decoder<R> {
PhotometricInterpretation::BlackIsZero | PhotometricInterpretation::WhiteIsZero
if self.bits_per_sample.len() == 1 => Ok(ColorType::Gray(self.bits_per_sample[0])),
_ => Err(TiffError::UnsupportedError(format!(
"{:?} with {:?} bits per sample is unsupported", self.photometric_interpretation, self.bits_per_sample
))) // TODO: this is bad we should not fail at this point}
// TODO: this is bad we should not fail at this point
_ => Err(TiffError::UnsupportedError(TiffUnsupportedError::InterpretationWithBits(self.photometric_interpretation, self.bits_per_sample.clone())))
}
}
@@ -187,12 +184,10 @@ impl<R: Read + Seek> Decoder<R> {
b"MM" => {
self.byte_order = ByteOrder::BigEndian;
self.reader.byte_order = ByteOrder::BigEndian; },
_ => return Err(TiffError::FormatError(
"TIFF signature not found.".to_string()
))
_ => return Err(TiffError::FormatError(TiffFormatError::TiffSignatureNotFound))
}
if try!(self.read_short()) != 42 {
return Err(TiffError::FormatError("TIFF signature invalid.".to_string()))
return Err(TiffError::FormatError(TiffFormatError::TiffSignatureInvalid))
}
self.next_ifd = match try!(self.read_long()) {
0 => None,
@@ -218,18 +213,14 @@ impl<R: Read + Seek> Decoder<R> {
try!(self.get_tag_u32(ifd::Tag::PhotometricInterpretation))
) {
Some(val) => val,
None => return Err(TiffError::UnsupportedError(
"The image is using an unknown photometric interpretation.".to_string()
))
None => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnknownInterpretation))
};
if let Some(val) = try!(self.find_tag_u32(ifd::Tag::Compression)) {
match FromPrimitive::from_u32(val) {
Some(method) => {
self.compression_method = method
},
None => return Err(TiffError::UnsupportedError(
"Unknown compression method.".to_string()
))
None => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnknownCompressionMethod))
}
}
if let Some(val) = try!(self.find_tag_u32(ifd::Tag::SamplesPerPixel)) {
@@ -247,9 +238,7 @@ impl<R: Read + Seek> Decoder<R> {
}
}
_ => return Err(TiffError::UnsupportedError(
format!("{} samples per pixel is supported.", self.samples)
))
_ => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedSampleDepth(self.samples)))
}
Ok(self)
}
@@ -323,9 +312,7 @@ impl<R: Read + Seek> Decoder<R> {
fn read_ifd(&mut self) -> TiffResult<Directory> {
let mut dir: Directory = HashMap::new();
match self.next_ifd {
None => return Err(TiffError::FormatError(
"Image file directory not found.".to_string())
),
None => return Err(TiffError::FormatError(TiffFormatError::ImageFileDirectoryNotFound)),
Some(offset) => try!(self.goto_offset(offset))
}
for _ in 0..try!(self.read_short()) {
@@ -379,9 +366,7 @@ impl<R: Read + Seek> Decoder<R> {
pub fn get_tag(&mut self, tag: ifd::Tag) -> TiffResult<ifd::Value> {
match try!(self.find_tag(tag)) {
Some(val) => Ok(val),
None => Err(TiffError::FormatError(format!(
"Required tag `{:?}` not found.", tag
)))
None => Err(TiffError::FormatError(TiffFormatError::RequiredTagNotFound(tag))),
}
}
@@ -414,13 +399,11 @@ impl<R: Read + Seek> Decoder<R> {
let (bytes, reader) = try!(PackBitsReader::new(&mut self.reader, order, length as usize));
(bytes, Box::new(reader))
},
method => return Err(TiffError::UnsupportedError(format!(
"Compression method {:?} is unsupported", method
)))
method => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedCompressionMethod(method)))
};
Ok(match (color_type, buffer) {
(ColorType:: RGB(8), DecodingBuffer::U8(ref mut buffer)) |
(ColorType::RGBA(8), DecodingBuffer::U8(ref mut buffer)) |
(ColorType::RGBA(8), DecodingBuffer::U8(ref mut buffer)) |
(ColorType::CMYK(8), DecodingBuffer::U8(ref mut buffer)) => {
try!(reader.read(&mut buffer[..bytes]))
}
@@ -449,9 +432,7 @@ impl<R: Read + Seek> Decoder<R> {
}
bytes
}
(type_, _) => return Err(TiffError::UnsupportedError(format!(
"Color type {:?} is unsupported", type_
)))
(type_, _) => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedColorType(type_))),
})
}
@@ -469,18 +450,12 @@ impl<R: Read + Seek> Decoder<R> {
let mut result = match self.bits_per_sample.iter().cloned().max().unwrap_or(8) {
n if n <= 8 => DecodingResult::U8(Vec::with_capacity(buffer_size)),
n if n <= 16 => DecodingResult::U16(Vec::with_capacity(buffer_size)),
n => return Err(
TiffError::UnsupportedError(
format!("{} bits per channel not supported", n)
)
)
n => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedBitsPerChannel(n))),
};
if let Ok(config) = self.get_tag_u32(ifd::Tag::PlanarConfiguration) {
match FromPrimitive::from_u32(config) {
Some(PlanarConfiguration::Chunky) => {},
config => return Err(TiffError::UnsupportedError(
format!("Unsupported planar configuration “{:?}”.", config)
))
config => return Err(TiffError::UnsupportedError(TiffUnsupportedError::UnsupportedPlanarConfig(config)))
}
}
// Safe since the uninitialized values are never read.
@@ -533,9 +508,7 @@ impl<R: Read + Seek> Decoder<R> {
try!(self.colortype())
))
},
None => return Err(TiffError::FormatError(
format!("Unknown predictor “{}” encountered", predictor)
))
None => return Err(TiffError::FormatError(TiffFormatError::UnknownPredictor(predictor))),
}
}
Ok(result)
src/error.rs
+64 -2
View File
@@ -2,19 +2,81 @@ use std::error::Error;
use std::fmt;
use std::io;
use decoder::ifd::{Tag, Value};
use decoder::{PhotometricInterpretation, CompressionMethod, PlanarConfiguration};
use ColorType;
/// Tiff error kinds.
#[derive(Debug)]
pub enum TiffError {
/// The Image is not formatted properly
FormatError(String),
FormatError(TiffFormatError),
/// The Decoder does not support this image format
UnsupportedError(String),
UnsupportedError(TiffUnsupportedError),
/// An I/O Error occurred while decoding the image
IoError(io::Error),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TiffFormatError {
TiffSignatureNotFound,
TiffSignatureInvalid,
ImageFileDirectoryNotFound,
RequiredTagNotFound(Tag),
UnknownPredictor(u32),
UnsignedIntegerExpected(Value),
}
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."),
RequiredTagNotFound(ref tag) => write!(fmt, "Required tag `{:?}` not found.", tag),
UnknownPredictor(ref predictor) => write!(fmt, "Unknown predictor “{}” encountered", predictor),
UnsignedIntegerExpected(ref val) => write!(fmt, "Expected unsigned integer, {:?} found.", val),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TiffUnsupportedError {
HorizontalPredictor(ColorType),
InterpretationWithBits(PhotometricInterpretation, Vec<u8>),
UnknownInterpretation,
UnknownCompressionMethod,
UnsupportedCompressionMethod(CompressionMethod),
UnsupportedSampleDepth(u8),
UnsupportedColorType(ColorType),
UnsupportedBitsPerChannel(u8),
UnsupportedPlanarConfig(Option<PlanarConfiguration>),
UnsupportedDataType,
}
impl fmt::Display for TiffUnsupportedError {
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
use self::TiffUnsupportedError::*;
match *self {
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 supported.", samples),
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."),
}
}
}
impl fmt::Display for TiffError {
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match *self {
src/lib.rs
+1 -1
View File
@@ -14,7 +14,7 @@ extern crate num_traits;
pub mod decoder;
mod error;
pub use self::error::{TiffError, TiffResult};
pub use self::error::{TiffError, TiffFormatError, TiffUnsupportedError, TiffResult};
/// An enumeration over supported color types and their bit depths
#[derive(Copy, PartialEq, Eq, Debug, Clone, Hash)]