Deleted vendor folder

1 files changed, 0 insertions, 601 deletions

diff --git a/vendor/tiff/src/decoder/image.rs b/vendor/tiff/src/decoder/image.rs
deleted file mode 100644
index c037e31..0000000
--- a/vendor/tiff/src/decoder/image.rs
+++ /dev/null
@@ -1,601 +0,0 @@
-use super::ifd::{Directory, Value};
-use super::stream::{ByteOrder, DeflateReader, JpegReader, LZWReader, PackBitsReader};
-use super::tag_reader::TagReader;
-use super::{fp_predict_f32, fp_predict_f64, DecodingBuffer, Limits};
-use super::{stream::SmartReader, ChunkType};
-use crate::tags::{CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag};
-use crate::{ColorType, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError};
-use std::convert::{TryFrom, TryInto};
-use std::io::{self, Cursor, Read, Seek};
-use std::sync::Arc;
-
-#[derive(Debug)]
-pub(crate) struct StripDecodeState {
-    pub rows_per_strip: u32,
-}
-
-#[derive(Debug)]
-/// Computed values useful for tile decoding
-pub(crate) struct TileAttributes {
-    pub image_width: usize,
-    pub image_height: usize,
-
-    pub tile_width: usize,
-    pub tile_length: usize,
-}
-
-impl TileAttributes {
-    pub fn tiles_across(&self) -> usize {
-        (self.image_width + self.tile_width - 1) / self.tile_width
-    }
-    pub fn tiles_down(&self) -> usize {
-        (self.image_height + self.tile_length - 1) / self.tile_length
-    }
-    fn padding_right(&self) -> usize {
-        (self.tile_width - self.image_width % self.tile_width) % self.tile_width
-    }
-    fn padding_down(&self) -> usize {
-        (self.tile_length - self.image_height % self.tile_length) % self.tile_length
-    }
-    pub fn get_padding(&self, tile: usize) -> (usize, usize) {
-        let row = tile / self.tiles_across();
-        let column = tile % self.tiles_across();
-
-        let padding_right = if column == self.tiles_across() - 1 {
-            self.padding_right()
-        } else {
-            0
-        };
-
-        let padding_down = if row == self.tiles_down() - 1 {
-            self.padding_down()
-        } else {
-            0
-        };
-
-        (padding_right, padding_down)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Image {
-    pub ifd: Option<Directory>,
-    pub width: u32,
-    pub height: u32,
-    pub bits_per_sample: Vec<u8>,
-    #[allow(unused)]
-    pub samples: u8,
-    pub sample_format: Vec<SampleFormat>,
-    pub photometric_interpretation: PhotometricInterpretation,
-    pub compression_method: CompressionMethod,
-    pub predictor: Predictor,
-    pub jpeg_tables: Option<Arc<Vec<u8>>>,
-    pub chunk_type: ChunkType,
-    pub strip_decoder: Option<StripDecodeState>,
-    pub tile_attributes: Option<TileAttributes>,
-    pub chunk_offsets: Vec<u64>,
-    pub chunk_bytes: Vec<u64>,
-}
-
-impl Image {
-    pub fn from_reader<R: Read + Seek>(
-        reader: &mut SmartReader<R>,
-        ifd: Directory,
-        limits: &Limits,
-        bigtiff: bool,
-    ) -> TiffResult<Image> {
-        let mut tag_reader = TagReader {
-            reader,
-            limits,
-            ifd: &ifd,
-            bigtiff,
-        };
-
-        let width = tag_reader.require_tag(Tag::ImageWidth)?.into_u32()?;
-        let height = tag_reader.require_tag(Tag::ImageLength)?.into_u32()?;
-        if width == 0 || height == 0 {
-            return Err(TiffError::FormatError(TiffFormatError::InvalidDimensions(
-                width, height,
-            )));
-        }
-
-        let photometric_interpretation = tag_reader
-            .find_tag(Tag::PhotometricInterpretation)?
-            .map(Value::into_u16)
-            .transpose()?
-            .and_then(PhotometricInterpretation::from_u16)
-            .ok_or(TiffUnsupportedError::UnknownInterpretation)?;
-
-        // Try to parse both the compression method and the number, format, and bits of the included samples.
-        // If they are not explicitly specified, those tags are reset to their default values and not carried from previous images.
-        let compression_method = match tag_reader.find_tag(Tag::Compression)? {
-            Some(val) => CompressionMethod::from_u16(val.into_u16()?)
-                .ok_or(TiffUnsupportedError::UnknownCompressionMethod)?,
-            None => CompressionMethod::None,
-        };
-
-        let jpeg_tables = if compression_method == CompressionMethod::ModernJPEG
-            && ifd.contains_key(&Tag::JPEGTables)
-        {
-            let vec = tag_reader
-                .find_tag(Tag::JPEGTables)?
-                .unwrap()
-                .into_u8_vec()?;
-            if vec.len() < 2 {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::InvalidTagValueType(Tag::JPEGTables),
-                ));
-            }
-
-            Some(Arc::new(vec))
-        } else {
-            None
-        };
-
-        let samples = tag_reader
-            .find_tag(Tag::SamplesPerPixel)?
-            .map(Value::into_u16)
-            .transpose()?
-            .unwrap_or(1)
-            .try_into()?;
-
-        let sample_format = match tag_reader.find_tag_uint_vec(Tag::SampleFormat)? {
-            Some(vals) => {
-                let sample_format: Vec<_> = vals
-                    .into_iter()
-                    .map(SampleFormat::from_u16_exhaustive)
-                    .collect();
-
-                // TODO: for now, only homogenous formats across samples are supported.
-                if !sample_format.windows(2).all(|s| s[0] == s[1]) {
-                    return Err(TiffUnsupportedError::UnsupportedSampleFormat(sample_format).into());
-                }
-
-                sample_format
-            }
-            None => vec![SampleFormat::Uint],
-        };
-
-        let bits_per_sample = match samples {
-            1 | 3 | 4 => tag_reader
-                .find_tag_uint_vec(Tag::BitsPerSample)?
-                .unwrap_or_else(|| vec![1]),
-            _ => return Err(TiffUnsupportedError::UnsupportedSampleDepth(samples).into()),
-        };
-
-        let predictor = tag_reader
-            .find_tag(Tag::Predictor)?
-            .map(Value::into_u16)
-            .transpose()?
-            .map(|p| {
-                Predictor::from_u16(p)
-                    .ok_or(TiffError::FormatError(TiffFormatError::UnknownPredictor(p)))
-            })
-            .transpose()?
-            .unwrap_or(Predictor::None);
-
-        let chunk_type;
-        let chunk_offsets;
-        let chunk_bytes;
-        let strip_decoder;
-        let tile_attributes;
-        match (
-            ifd.contains_key(&Tag::StripByteCounts),
-            ifd.contains_key(&Tag::StripOffsets),
-            ifd.contains_key(&Tag::TileByteCounts),
-            ifd.contains_key(&Tag::TileOffsets),
-        ) {
-            (true, true, false, false) => {
-                chunk_type = ChunkType::Strip;
-
-                chunk_offsets = tag_reader
-                    .find_tag(Tag::StripOffsets)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                chunk_bytes = tag_reader
-                    .find_tag(Tag::StripByteCounts)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                let rows_per_strip = tag_reader
-                    .find_tag(Tag::RowsPerStrip)?
-                    .map(Value::into_u32)
-                    .transpose()?
-                    .unwrap_or(height);
-                strip_decoder = Some(StripDecodeState { rows_per_strip });
-                tile_attributes = None;
-
-                if chunk_offsets.len() != chunk_bytes.len()
-                    || rows_per_strip == 0
-                    || u32::try_from(chunk_offsets.len())?
-                        != height.saturating_sub(1) / rows_per_strip + 1
-                {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InconsistentSizesEncountered,
-                    ));
-                }
-            }
-            (false, false, true, true) => {
-                chunk_type = ChunkType::Tile;
-
-                let tile_width =
-                    usize::try_from(tag_reader.require_tag(Tag::TileWidth)?.into_u32()?)?;
-                let tile_length =
-                    usize::try_from(tag_reader.require_tag(Tag::TileLength)?.into_u32()?)?;
-
-                if tile_width == 0 {
-                    return Err(TiffFormatError::InvalidTagValueType(Tag::TileWidth).into());
-                } else if tile_length == 0 {
-                    return Err(TiffFormatError::InvalidTagValueType(Tag::TileLength).into());
-                }
-
-                strip_decoder = None;
-                tile_attributes = Some(TileAttributes {
-                    image_width: usize::try_from(width)?,
-                    image_height: usize::try_from(height)?,
-                    tile_width,
-                    tile_length,
-                });
-                chunk_offsets = tag_reader
-                    .find_tag(Tag::TileOffsets)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                chunk_bytes = tag_reader
-                    .find_tag(Tag::TileByteCounts)?
-                    .unwrap()
-                    .into_u64_vec()?;
-
-                let tile = tile_attributes.as_ref().unwrap();
-                if chunk_offsets.len() != chunk_bytes.len()
-                    || chunk_offsets.len() != tile.tiles_down() * tile.tiles_across()
-                {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InconsistentSizesEncountered,
-                    ));
-                }
-            }
-            (_, _, _, _) => {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::StripTileTagConflict,
-                ))
-            }
-        };
-
-        Ok(Image {
-            ifd: Some(ifd),
-            width,
-            height,
-            bits_per_sample,
-            samples,
-            sample_format,
-            photometric_interpretation,
-            compression_method,
-            jpeg_tables,
-            predictor,
-            chunk_type,
-            strip_decoder,
-            tile_attributes,
-            chunk_offsets,
-            chunk_bytes,
-        })
-    }
-
-    pub(crate) fn colortype(&self) -> TiffResult<ColorType> {
-        match self.photometric_interpretation {
-            PhotometricInterpretation::RGB => match self.bits_per_sample[..] {
-                [r, g, b] if [r, r] == [g, b] => Ok(ColorType::RGB(r)),
-                [r, g, b, a] if [r, r, r] == [g, b, a] => Ok(ColorType::RGBA(r)),
-                // FIXME: We should _ignore_ other components. In particular:
-                // > Beware of extra components. Some TIFF files may have more components per pixel
-                // than you think. A Baseline TIFF reader must skip over them gracefully,using the
-                // values of the SamplesPerPixel and BitsPerSample fields.
-                // > -- TIFF 6.0 Specification, Section 7, Additional Baseline requirements.
-                _ => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::InterpretationWithBits(
-                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
-                    ),
-                )),
-            },
-            PhotometricInterpretation::CMYK => match self.bits_per_sample[..] {
-                [c, m, y, k] if [c, c, c] == [m, y, k] => Ok(ColorType::CMYK(c)),
-                _ => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::InterpretationWithBits(
-                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
-                    ),
-                )),
-            },
-            PhotometricInterpretation::YCbCr => match self.bits_per_sample[..] {
-                [y, cb, cr] if [y, y] == [cb, cr] => Ok(ColorType::YCbCr(y)),
-                _ => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::InterpretationWithBits(
-                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
-                    ),
-                )),
-            },
-            PhotometricInterpretation::BlackIsZero | PhotometricInterpretation::WhiteIsZero
-                if self.bits_per_sample.len() == 1 =>
-            {
-                Ok(ColorType::Gray(self.bits_per_sample[0]))
-            }
-
-            // TODO: this is bad we should not fail at this point
-            _ => Err(TiffError::UnsupportedError(
-                TiffUnsupportedError::InterpretationWithBits(
-                    self.photometric_interpretation,
-                    self.bits_per_sample.clone(),
-                ),
-            )),
-        }
-    }
-
-    fn create_reader<'r, R: 'r + Read>(
-        reader: R,
-        photometric_interpretation: PhotometricInterpretation,
-        compression_method: CompressionMethod,
-        compressed_length: u64,
-        jpeg_tables: Option<Arc<Vec<u8>>>,
-    ) -> TiffResult<Box<dyn Read + 'r>> {
-        Ok(match compression_method {
-            CompressionMethod::None => Box::new(reader),
-            CompressionMethod::LZW => {
-                Box::new(LZWReader::new(reader, usize::try_from(compressed_length)?))
-            }
-            CompressionMethod::PackBits => Box::new(PackBitsReader::new(reader, compressed_length)),
-            CompressionMethod::Deflate | CompressionMethod::OldDeflate => {
-                Box::new(DeflateReader::new(reader))
-            }
-            CompressionMethod::ModernJPEG => {
-                if jpeg_tables.is_some() && compressed_length < 2 {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InvalidTagValueType(Tag::JPEGTables),
-                    ));
-                }
-
-                let jpeg_reader = JpegReader::new(reader, compressed_length, jpeg_tables)?;
-                let mut decoder = jpeg::Decoder::new(jpeg_reader);
-
-                match photometric_interpretation {
-                    PhotometricInterpretation::RGB => {
-                        decoder.set_color_transform(jpeg::ColorTransform::RGB)
-                    }
-                    PhotometricInterpretation::WhiteIsZero => {
-                        decoder.set_color_transform(jpeg::ColorTransform::None)
-                    }
-                    PhotometricInterpretation::BlackIsZero => {
-                        decoder.set_color_transform(jpeg::ColorTransform::None)
-                    }
-                    PhotometricInterpretation::TransparencyMask => {
-                        decoder.set_color_transform(jpeg::ColorTransform::None)
-                    }
-                    PhotometricInterpretation::CMYK => {
-                        decoder.set_color_transform(jpeg::ColorTransform::CMYK)
-                    }
-                    PhotometricInterpretation::YCbCr => {
-                        decoder.set_color_transform(jpeg::ColorTransform::YCbCr)
-                    }
-                    photometric_interpretation => {
-                        return Err(TiffError::UnsupportedError(
-                            TiffUnsupportedError::UnsupportedInterpretation(
-                                photometric_interpretation,
-                            ),
-                        ));
-                    }
-                }
-
-                let data = decoder.decode()?;
-
-                Box::new(Cursor::new(data))
-            }
-            method => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::UnsupportedCompressionMethod(method),
-                ))
-            }
-        })
-    }
-
-    pub(crate) fn chunk_file_range(&self, chunk: u32) -> TiffResult<(u64, u64)> {
-        let file_offset = self
-            .chunk_offsets
-            .get(chunk as usize)
-            .ok_or(TiffError::FormatError(
-                TiffFormatError::InconsistentSizesEncountered,
-            ))?;
-
-        let compressed_bytes =
-            self.chunk_bytes
-                .get(chunk as usize)
-                .ok_or(TiffError::FormatError(
-                    TiffFormatError::InconsistentSizesEncountered,
-                ))?;
-
-        Ok((*file_offset, *compressed_bytes))
-    }
-
-    pub(crate) fn chunk_dimensions(&self) -> TiffResult<(u32, u32)> {
-        match self.chunk_type {
-            ChunkType::Strip => {
-                let strip_attrs = self.strip_decoder.as_ref().unwrap();
-                Ok((self.width, strip_attrs.rows_per_strip))
-            }
-            ChunkType::Tile => {
-                let tile_attrs = self.tile_attributes.as_ref().unwrap();
-                Ok((
-                    u32::try_from(tile_attrs.tile_width)?,
-                    u32::try_from(tile_attrs.tile_length)?,
-                ))
-            }
-        }
-    }
-
-    pub(crate) fn chunk_data_dimensions(&self, chunk_index: u32) -> TiffResult<(u32, u32)> {
-        let dims = self.chunk_dimensions()?;
-
-        match self.chunk_type {
-            ChunkType::Strip => {
-                let strip_height_without_padding = chunk_index
-                    .checked_mul(dims.1)
-                    .and_then(|x| self.height.checked_sub(x))
-                    .ok_or(TiffError::UsageError(UsageError::InvalidChunkIndex(
-                        chunk_index,
-                    )))?;
-
-                // Ignore potential vertical padding on the bottommost strip
-                let strip_height = dims.1.min(strip_height_without_padding);
-
-                Ok((dims.0, strip_height))
-            }
-            ChunkType::Tile => {
-                let tile_attrs = self.tile_attributes.as_ref().unwrap();
-                let (padding_right, padding_down) = tile_attrs.get_padding(chunk_index as usize);
-
-                let tile_width = tile_attrs.tile_width - padding_right;
-                let tile_length = tile_attrs.tile_length - padding_down;
-
-                Ok((u32::try_from(tile_width)?, u32::try_from(tile_length)?))
-            }
-        }
-    }
-
-    pub(crate) fn expand_chunk(
-        &self,
-        reader: impl Read,
-        mut buffer: DecodingBuffer,
-        output_width: usize,
-        byte_order: ByteOrder,
-        chunk_index: u32,
-    ) -> TiffResult<()> {
-        // Validate that the provided buffer is of the expected type.
-        let color_type = self.colortype()?;
-        match (color_type, &buffer) {
-            (ColorType::RGB(n), _)
-            | (ColorType::RGBA(n), _)
-            | (ColorType::CMYK(n), _)
-            | (ColorType::YCbCr(n), _)
-            | (ColorType::Gray(n), _)
-                if usize::from(n) == buffer.byte_len() * 8 => {}
-            (ColorType::Gray(n), DecodingBuffer::U8(_)) if n < 8 => match self.predictor {
-                Predictor::None => {}
-                Predictor::Horizontal => {
-                    return Err(TiffError::UnsupportedError(
-                        TiffUnsupportedError::HorizontalPredictor(color_type),
-                    ))
-                }
-                Predictor::FloatingPoint => {
-                    return Err(TiffError::UnsupportedError(
-                        TiffUnsupportedError::FloatingPointPredictor(color_type),
-                    ));
-                }
-            },
-            (type_, _) => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::UnsupportedColorType(type_),
-                ))
-            }
-        }
-
-        // Validate that the predictor is supported for the sample type.
-        match (self.predictor, &buffer) {
-            (Predictor::Horizontal, DecodingBuffer::F32(_))
-            | (Predictor::Horizontal, DecodingBuffer::F64(_)) => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::HorizontalPredictor(color_type),
-                ));
-            }
-            (Predictor::FloatingPoint, DecodingBuffer::F32(_))
-            | (Predictor::FloatingPoint, DecodingBuffer::F64(_)) => {}
-            (Predictor::FloatingPoint, _) => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::FloatingPointPredictor(color_type),
-                ));
-            }
-            _ => {}
-        }
-
-        let compressed_bytes =
-            self.chunk_bytes
-                .get(chunk_index as usize)
-                .ok_or(TiffError::FormatError(
-                    TiffFormatError::InconsistentSizesEncountered,
-                ))?;
-
-        let byte_len = buffer.byte_len();
-        let compression_method = self.compression_method;
-        let photometric_interpretation = self.photometric_interpretation;
-        let predictor = self.predictor;
-        let samples = self.bits_per_sample.len();
-
-        let chunk_dims = self.chunk_dimensions()?;
-        let data_dims = self.chunk_data_dimensions(chunk_index)?;
-
-        let padding_right = chunk_dims.0 - data_dims.0;
-
-        let jpeg_tables = self.jpeg_tables.clone();
-        let mut reader = Self::create_reader(
-            reader,
-            photometric_interpretation,
-            compression_method,
-            *compressed_bytes,
-            jpeg_tables,
-        )?;
-
-        if output_width == data_dims.0 as usize && padding_right == 0 {
-            let total_samples = data_dims.0 as usize * data_dims.1 as usize * samples;
-            let tile = &mut buffer.as_bytes_mut()[..total_samples * byte_len];
-            reader.read_exact(tile)?;
-
-            for row in 0..data_dims.1 as usize {
-                let row_start = row as usize * output_width as usize * samples;
-                let row_end = (row + 1) * output_width as usize * samples;
-                let row = buffer.subrange(row_start..row_end);
-                super::fix_endianness_and_predict(row, samples, byte_order, predictor);
-            }
-            if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                super::invert_colors(&mut buffer.subrange(0..total_samples), color_type);
-            }
-        } else if padding_right > 0 && self.predictor == Predictor::FloatingPoint {
-            // The floating point predictor shuffles the padding bytes into the encoded output, so
-            // this case is handled specially when needed.
-            let mut encoded = vec![0u8; chunk_dims.0 as usize * samples * byte_len];
-
-            for row in 0..data_dims.1 as usize {
-                let row_start = row * output_width as usize * samples;
-                let row_end = row_start + data_dims.0 as usize * samples;
-
-                reader.read_exact(&mut encoded)?;
-                match buffer.subrange(row_start..row_end) {
-                    DecodingBuffer::F32(buf) => fp_predict_f32(&mut encoded, buf, samples),
-                    DecodingBuffer::F64(buf) => fp_predict_f64(&mut encoded, buf, samples),
-                    _ => unreachable!(),
-                }
-                if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                    super::invert_colors(&mut buffer.subrange(row_start..row_end), color_type);
-                }
-            }
-        } else {
-            for row in 0..data_dims.1 as usize {
-                let row_start = row * output_width as usize * samples;
-                let row_end = row_start + data_dims.0 as usize * samples;
-
-                let row = &mut buffer.as_bytes_mut()[(row_start * byte_len)..(row_end * byte_len)];
-                reader.read_exact(row)?;
-
-                // Skip horizontal padding
-                if padding_right > 0 {
-                    let len = u64::try_from(padding_right as usize * samples * byte_len)?;
-                    io::copy(&mut reader.by_ref().take(len), &mut io::sink())?;
-                }
-
-                let mut row = buffer.subrange(row_start..row_end);
-                super::fix_endianness_and_predict(row.copy(), samples, byte_order, predictor);
-                if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                    super::invert_colors(&mut row, color_type);
-                }
-            }
-        }
-
-        Ok(())
-    }
-}