      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126

    use std::error::Error;
    use std::fmt;
    use std::io;
    use std::string;

    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(TiffFormatError),

        /// The Decoder does not support this image format
        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,
        InconsistentSizesEncountered,
        InvalidTag,
        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."),
                InconsistentSizesEncountered => write!(fmt, "Inconsistent sizes encountered."),
                InvalidTag => write!(fmt, "Image contains invalid tag."),
                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 {
                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),
            }
        }
    }

    impl Error for TiffError {
        fn description (&self) -> &str {
            match *self {
                TiffError::FormatError(..) => "Format error",
                TiffError::UnsupportedError(..) => "Unsupported error",
                TiffError::IoError(..) => "IO error",
            }
        }

        fn cause (&self) -> Option<&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<string::FromUtf8Error> for TiffError {
        fn from(_err: string::FromUtf8Error) -> TiffError {
            TiffError::FormatError(TiffFormatError::InvalidTag)
        }
    }

    /// Result of an image decoding/encoding process
    pub type TiffResult<T> = Result<T, TiffError>;

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)