Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 606 insertions, 0 deletions

diff --git a/vendor/image/src/codecs/gif.rs b/vendor/image/src/codecs/gif.rs
new file mode 100644
index 0000000..dcbd841
--- /dev/null
+++ b/vendor/image/src/codecs/gif.rs
@@ -0,0 +1,606 @@
+//!  Decoding of GIF Images
+//!
+//!  GIF (Graphics Interchange Format) is an image format that supports lossless compression.
+//!
+//!  # Related Links
+//!  * <http://www.w3.org/Graphics/GIF/spec-gif89a.txt> - The GIF Specification
+//!
+//! # Examples
+//! ```rust,no_run
+//! use image::codecs::gif::{GifDecoder, GifEncoder};
+//! use image::{ImageDecoder, AnimationDecoder};
+//! use std::fs::File;
+//! # fn main() -> std::io::Result<()> {
+//! // Decode a gif into frames
+//! let file_in = File::open("foo.gif")?;
+//! let mut decoder = GifDecoder::new(file_in).unwrap();
+//! let frames = decoder.into_frames();
+//! let frames = frames.collect_frames().expect("error decoding gif");
+//!
+//! // Encode frames into a gif and save to a file
+//! let mut file_out = File::open("out.gif")?;
+//! let mut encoder = GifEncoder::new(file_out);
+//! encoder.encode_frames(frames.into_iter());
+//! # Ok(())
+//! # }
+//! ```
+#![allow(clippy::while_let_loop)]
+
+use std::convert::TryFrom;
+use std::convert::TryInto;
+use std::io::{self, Cursor, Read, Write};
+use std::marker::PhantomData;
+use std::mem;
+
+use gif::ColorOutput;
+use gif::{DisposalMethod, Frame};
+use num_rational::Ratio;
+
+use crate::animation;
+use crate::color::{ColorType, Rgba};
+use crate::error::{
+    DecodingError, EncodingError, ImageError, ImageResult, ParameterError, ParameterErrorKind,
+    UnsupportedError, UnsupportedErrorKind,
+};
+use crate::image::{self, AnimationDecoder, ImageDecoder, ImageFormat};
+use crate::io::Limits;
+use crate::traits::Pixel;
+use crate::ImageBuffer;
+
+/// GIF decoder
+pub struct GifDecoder<R: Read> {
+    reader: gif::Decoder<R>,
+    limits: Limits,
+}
+
+impl<R: Read> GifDecoder<R> {
+    /// Creates a new decoder that decodes the input steam `r`
+    pub fn new(r: R) -> ImageResult<GifDecoder<R>> {
+        let mut decoder = gif::DecodeOptions::new();
+        decoder.set_color_output(ColorOutput::RGBA);
+
+        Ok(GifDecoder {
+            reader: decoder.read_info(r).map_err(ImageError::from_decoding)?,
+            limits: Limits::default(),
+        })
+    }
+
+    /// Creates a new decoder that decodes the input steam `r`, using limits `limits`
+    pub fn with_limits(r: R, limits: Limits) -> ImageResult<GifDecoder<R>> {
+        let mut decoder = gif::DecodeOptions::new();
+        decoder.set_color_output(ColorOutput::RGBA);
+
+        Ok(GifDecoder {
+            reader: decoder.read_info(r).map_err(ImageError::from_decoding)?,
+            limits,
+        })
+    }
+}
+
+/// Wrapper struct around a `Cursor<Vec<u8>>`
+pub struct GifReader<R>(Cursor<Vec<u8>>, PhantomData<R>);
+impl<R> Read for GifReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        if self.0.position() == 0 && buf.is_empty() {
+            mem::swap(buf, self.0.get_mut());
+            Ok(buf.len())
+        } else {
+            self.0.read_to_end(buf)
+        }
+    }
+}
+
+impl<'a, R: 'a + Read> ImageDecoder<'a> for GifDecoder<R> {
+    type Reader = GifReader<R>;
+
+    fn dimensions(&self) -> (u32, u32) {
+        (
+            u32::from(self.reader.width()),
+            u32::from(self.reader.height()),
+        )
+    }
+
+    fn color_type(&self) -> ColorType {
+        ColorType::Rgba8
+    }
+
+    fn into_reader(self) -> ImageResult<Self::Reader> {
+        Ok(GifReader(
+            Cursor::new(image::decoder_to_vec(self)?),
+            PhantomData,
+        ))
+    }
+
+    fn read_image(mut self, buf: &mut [u8]) -> ImageResult<()> {
+        assert_eq!(u64::try_from(buf.len()), Ok(self.total_bytes()));
+
+        let frame = match self
+            .reader
+            .next_frame_info()
+            .map_err(ImageError::from_decoding)?
+        {
+            Some(frame) => FrameInfo::new_from_frame(frame),
+            None => {
+                return Err(ImageError::Parameter(ParameterError::from_kind(
+                    ParameterErrorKind::NoMoreData,
+                )))
+            }
+        };
+
+        let (width, height) = self.dimensions();
+
+        if frame.left == 0
+            && frame.width == width
+            && (frame.top as u64 + frame.height as u64 <= height as u64)
+        {
+            // If the frame matches the logical screen, or, as a more general case,
+            // fits into it and touches its left and right borders, then
+            // we can directly write it into the buffer without causing line wraparound.
+            let line_length = usize::try_from(width)
+                .unwrap()
+                .checked_mul(self.color_type().bytes_per_pixel() as usize)
+                .unwrap();
+
+            // isolate the portion of the buffer to read the frame data into.
+            // the chunks above and below it are going to be zeroed.
+            let (blank_top, rest) =
+                buf.split_at_mut(line_length.checked_mul(frame.top as usize).unwrap());
+            let (buf, blank_bottom) =
+                rest.split_at_mut(line_length.checked_mul(frame.height as usize).unwrap());
+
+            debug_assert_eq!(buf.len(), self.reader.buffer_size());
+
+            // this is only necessary in case the buffer is not zeroed
+            for b in blank_top {
+                *b = 0;
+            }
+            // fill the middle section with the frame data
+            self.reader
+                .read_into_buffer(buf)
+                .map_err(ImageError::from_decoding)?;
+            // this is only necessary in case the buffer is not zeroed
+            for b in blank_bottom {
+                *b = 0;
+            }
+        } else {
+            // If the frame does not match the logical screen, read into an extra buffer
+            // and 'insert' the frame from left/top to logical screen width/height.
+            let buffer_size = self.reader.buffer_size();
+
+            self.limits.reserve_usize(buffer_size)?;
+
+            let mut frame_buffer = vec![0; buffer_size];
+
+            self.limits.free_usize(buffer_size);
+
+            self.reader
+                .read_into_buffer(&mut frame_buffer[..])
+                .map_err(ImageError::from_decoding)?;
+
+            let frame_buffer = ImageBuffer::from_raw(frame.width, frame.height, frame_buffer);
+            let image_buffer = ImageBuffer::from_raw(width, height, buf);
+
+            // `buffer_size` uses wrapping arithmetic, thus might not report the
+            // correct storage requirement if the result does not fit in `usize`.
+            // `ImageBuffer::from_raw` detects overflow and reports by returning `None`.
+            if frame_buffer.is_none() || image_buffer.is_none() {
+                return Err(ImageError::Unsupported(
+                    UnsupportedError::from_format_and_kind(
+                        ImageFormat::Gif.into(),
+                        UnsupportedErrorKind::GenericFeature(format!(
+                            "Image dimensions ({}, {}) are too large",
+                            frame.width, frame.height
+                        )),
+                    ),
+                ));
+            }
+
+            let frame_buffer = frame_buffer.unwrap();
+            let mut image_buffer = image_buffer.unwrap();
+
+            for (x, y, pixel) in image_buffer.enumerate_pixels_mut() {
+                let frame_x = x.wrapping_sub(frame.left);
+                let frame_y = y.wrapping_sub(frame.top);
+
+                if frame_x < frame.width && frame_y < frame.height {
+                    *pixel = *frame_buffer.get_pixel(frame_x, frame_y);
+                } else {
+                    // this is only necessary in case the buffer is not zeroed
+                    *pixel = Rgba([0, 0, 0, 0]);
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+struct GifFrameIterator<R: Read> {
+    reader: gif::Decoder<R>,
+
+    width: u32,
+    height: u32,
+
+    non_disposed_frame: ImageBuffer<Rgba<u8>, Vec<u8>>,
+}
+
+impl<R: Read> GifFrameIterator<R> {
+    fn new(decoder: GifDecoder<R>) -> GifFrameIterator<R> {
+        let (width, height) = decoder.dimensions();
+
+        // intentionally ignore the background color for web compatibility
+
+        // create the first non disposed frame
+        let non_disposed_frame = ImageBuffer::from_pixel(width, height, Rgba([0, 0, 0, 0]));
+
+        GifFrameIterator {
+            reader: decoder.reader,
+            width,
+            height,
+            non_disposed_frame,
+        }
+    }
+}
+
+impl<R: Read> Iterator for GifFrameIterator<R> {
+    type Item = ImageResult<animation::Frame>;
+
+    fn next(&mut self) -> Option<ImageResult<animation::Frame>> {
+        // begin looping over each frame
+
+        let frame = match self.reader.next_frame_info() {
+            Ok(frame_info) => {
+                if let Some(frame) = frame_info {
+                    FrameInfo::new_from_frame(frame)
+                } else {
+                    // no more frames
+                    return None;
+                }
+            }
+            Err(err) => return Some(Err(ImageError::from_decoding(err))),
+        };
+
+        let mut vec = vec![0; self.reader.buffer_size()];
+        if let Err(err) = self.reader.read_into_buffer(&mut vec) {
+            return Some(Err(ImageError::from_decoding(err)));
+        }
+
+        // create the image buffer from the raw frame.
+        // `buffer_size` uses wrapping arithmetic, thus might not report the
+        // correct storage requirement if the result does not fit in `usize`.
+        // on the other hand, `ImageBuffer::from_raw` detects overflow and
+        // reports by returning `None`.
+        let mut frame_buffer = match ImageBuffer::from_raw(frame.width, frame.height, vec) {
+            Some(frame_buffer) => frame_buffer,
+            None => {
+                return Some(Err(ImageError::Unsupported(
+                    UnsupportedError::from_format_and_kind(
+                        ImageFormat::Gif.into(),
+                        UnsupportedErrorKind::GenericFeature(format!(
+                            "Image dimensions ({}, {}) are too large",
+                            frame.width, frame.height
+                        )),
+                    ),
+                )))
+            }
+        };
+
+        // blend the current frame with the non-disposed frame, then update
+        // the non-disposed frame according to the disposal method.
+        fn blend_and_dispose_pixel(
+            dispose: DisposalMethod,
+            previous: &mut Rgba<u8>,
+            current: &mut Rgba<u8>,
+        ) {
+            let pixel_alpha = current.channels()[3];
+            if pixel_alpha == 0 {
+                *current = *previous;
+            }
+
+            match dispose {
+                DisposalMethod::Any | DisposalMethod::Keep => {
+                    // do not dispose
+                    // (keep pixels from this frame)
+                    // note: the `Any` disposal method is underspecified in the GIF
+                    // spec, but most viewers treat it identically to `Keep`
+                    *previous = *current;
+                }
+                DisposalMethod::Background => {
+                    // restore to background color
+                    // (background shows through transparent pixels in the next frame)
+                    *previous = Rgba([0, 0, 0, 0]);
+                }
+                DisposalMethod::Previous => {
+                    // restore to previous
+                    // (dispose frames leaving the last none disposal frame)
+                }
+            }
+        }
+
+        // if `frame_buffer`'s frame exactly matches the entire image, then
+        // use it directly, else create a new buffer to hold the composited
+        // image.
+        let image_buffer = if (frame.left, frame.top) == (0, 0)
+            && (self.width, self.height) == frame_buffer.dimensions()
+        {
+            for (x, y, pixel) in frame_buffer.enumerate_pixels_mut() {
+                let previous_pixel = self.non_disposed_frame.get_pixel_mut(x, y);
+                blend_and_dispose_pixel(frame.disposal_method, previous_pixel, pixel);
+            }
+            frame_buffer
+        } else {
+            ImageBuffer::from_fn(self.width, self.height, |x, y| {
+                let frame_x = x.wrapping_sub(frame.left);
+                let frame_y = y.wrapping_sub(frame.top);
+                let previous_pixel = self.non_disposed_frame.get_pixel_mut(x, y);
+
+                if frame_x < frame_buffer.width() && frame_y < frame_buffer.height() {
+                    let mut pixel = *frame_buffer.get_pixel(frame_x, frame_y);
+                    blend_and_dispose_pixel(frame.disposal_method, previous_pixel, &mut pixel);
+                    pixel
+                } else {
+                    // out of bounds, return pixel from previous frame
+                    *previous_pixel
+                }
+            })
+        };
+
+        Some(Ok(animation::Frame::from_parts(
+            image_buffer,
+            0,
+            0,
+            frame.delay,
+        )))
+    }
+}
+
+impl<'a, R: Read + 'a> AnimationDecoder<'a> for GifDecoder<R> {
+    fn into_frames(self) -> animation::Frames<'a> {
+        animation::Frames::new(Box::new(GifFrameIterator::new(self)))
+    }
+}
+
+struct FrameInfo {
+    left: u32,
+    top: u32,
+    width: u32,
+    height: u32,
+    disposal_method: DisposalMethod,
+    delay: animation::Delay,
+}
+
+impl FrameInfo {
+    fn new_from_frame(frame: &Frame) -> FrameInfo {
+        FrameInfo {
+            left: u32::from(frame.left),
+            top: u32::from(frame.top),
+            width: u32::from(frame.width),
+            height: u32::from(frame.height),
+            disposal_method: frame.dispose,
+            // frame.delay is in units of 10ms so frame.delay*10 is in ms
+            delay: animation::Delay::from_ratio(Ratio::new(u32::from(frame.delay) * 10, 1)),
+        }
+    }
+}
+
+/// Number of repetitions for a GIF animation
+#[derive(Clone, Copy, Debug)]
+pub enum Repeat {
+    /// Finite number of repetitions
+    Finite(u16),
+    /// Looping GIF
+    Infinite,
+}
+
+impl Repeat {
+    pub(crate) fn to_gif_enum(&self) -> gif::Repeat {
+        match self {
+            Repeat::Finite(n) => gif::Repeat::Finite(*n),
+            Repeat::Infinite => gif::Repeat::Infinite,
+        }
+    }
+}
+
+/// GIF encoder.
+pub struct GifEncoder<W: Write> {
+    w: Option<W>,
+    gif_encoder: Option<gif::Encoder<W>>,
+    speed: i32,
+    repeat: Option<Repeat>,
+}
+
+impl<W: Write> GifEncoder<W> {
+    /// Creates a new GIF encoder with a speed of 1. This prioritizes quality over performance at any cost.
+    pub fn new(w: W) -> GifEncoder<W> {
+        Self::new_with_speed(w, 1)
+    }
+
+    /// Create a new GIF encoder, and has the speed parameter `speed`. See
+    /// [`Frame::from_rgba_speed`](https://docs.rs/gif/latest/gif/struct.Frame.html#method.from_rgba_speed)
+    /// for more information.
+    pub fn new_with_speed(w: W, speed: i32) -> GifEncoder<W> {
+        assert!(
+            (1..=30).contains(&speed),
+            "speed needs to be in the range [1, 30]"
+        );
+        GifEncoder {
+            w: Some(w),
+            gif_encoder: None,
+            speed,
+            repeat: None,
+        }
+    }
+
+    /// Set the repeat behaviour of the encoded GIF
+    pub fn set_repeat(&mut self, repeat: Repeat) -> ImageResult<()> {
+        if let Some(ref mut encoder) = self.gif_encoder {
+            encoder
+                .set_repeat(repeat.to_gif_enum())
+                .map_err(ImageError::from_encoding)?;
+        }
+        self.repeat = Some(repeat);
+        Ok(())
+    }
+
+    /// Encode a single image.
+    pub fn encode(
+        &mut self,
+        data: &[u8],
+        width: u32,
+        height: u32,
+        color: ColorType,
+    ) -> ImageResult<()> {
+        let (width, height) = self.gif_dimensions(width, height)?;
+        match color {
+            ColorType::Rgb8 => self.encode_gif(Frame::from_rgb(width, height, data)),
+            ColorType::Rgba8 => {
+                self.encode_gif(Frame::from_rgba(width, height, &mut data.to_owned()))
+            }
+            _ => Err(ImageError::Unsupported(
+                UnsupportedError::from_format_and_kind(
+                    ImageFormat::Gif.into(),
+                    UnsupportedErrorKind::Color(color.into()),
+                ),
+            )),
+        }
+    }
+
+    /// Encode one frame of animation.
+    pub fn encode_frame(&mut self, img_frame: animation::Frame) -> ImageResult<()> {
+        let frame = self.convert_frame(img_frame)?;
+        self.encode_gif(frame)
+    }
+
+    /// Encodes Frames.
+    /// Consider using `try_encode_frames` instead to encode an `animation::Frames` like iterator.
+    pub fn encode_frames<F>(&mut self, frames: F) -> ImageResult<()>
+    where
+        F: IntoIterator<Item = animation::Frame>,
+    {
+        for img_frame in frames {
+            self.encode_frame(img_frame)?;
+        }
+        Ok(())
+    }
+
+    /// Try to encode a collection of `ImageResult<animation::Frame>` objects.
+    /// Use this function to encode an `animation::Frames` like iterator.
+    /// Whenever an `Err` item is encountered, that value is returned without further actions.
+    pub fn try_encode_frames<F>(&mut self, frames: F) -> ImageResult<()>
+    where
+        F: IntoIterator<Item = ImageResult<animation::Frame>>,
+    {
+        for img_frame in frames {
+            self.encode_frame(img_frame?)?;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn convert_frame(
+        &mut self,
+        img_frame: animation::Frame,
+    ) -> ImageResult<Frame<'static>> {
+        // get the delay before converting img_frame
+        let frame_delay = img_frame.delay().into_ratio().to_integer();
+        // convert img_frame into RgbaImage
+        let mut rbga_frame = img_frame.into_buffer();
+        let (width, height) = self.gif_dimensions(rbga_frame.width(), rbga_frame.height())?;
+
+        // Create the gif::Frame from the animation::Frame
+        let mut frame = Frame::from_rgba_speed(width, height, &mut rbga_frame, self.speed);
+        // Saturate the conversion to u16::MAX instead of returning an error as that
+        // would require a new special cased variant in ParameterErrorKind which most
+        // likely couldn't be reused for other cases. This isn't a bad trade-off given
+        // that the current algorithm is already lossy.
+        frame.delay = (frame_delay / 10).try_into().unwrap_or(std::u16::MAX);
+
+        Ok(frame)
+    }
+
+    fn gif_dimensions(&self, width: u32, height: u32) -> ImageResult<(u16, u16)> {
+        fn inner_dimensions(width: u32, height: u32) -> Option<(u16, u16)> {
+            let width = u16::try_from(width).ok()?;
+            let height = u16::try_from(height).ok()?;
+            Some((width, height))
+        }
+
+        // TODO: this is not very idiomatic yet. Should return an EncodingError.
+        inner_dimensions(width, height).ok_or_else(|| {
+            ImageError::Parameter(ParameterError::from_kind(
+                ParameterErrorKind::DimensionMismatch,
+            ))
+        })
+    }
+
+    pub(crate) fn encode_gif(&mut self, mut frame: Frame) -> ImageResult<()> {
+        let gif_encoder;
+        if let Some(ref mut encoder) = self.gif_encoder {
+            gif_encoder = encoder;
+        } else {
+            let writer = self.w.take().unwrap();
+            let mut encoder = gif::Encoder::new(writer, frame.width, frame.height, &[])
+                .map_err(ImageError::from_encoding)?;
+            if let Some(ref repeat) = self.repeat {
+                encoder
+                    .set_repeat(repeat.to_gif_enum())
+                    .map_err(ImageError::from_encoding)?;
+            }
+            self.gif_encoder = Some(encoder);
+            gif_encoder = self.gif_encoder.as_mut().unwrap()
+        }
+
+        frame.dispose = gif::DisposalMethod::Background;
+
+        gif_encoder
+            .write_frame(&frame)
+            .map_err(ImageError::from_encoding)
+    }
+}
+
+impl ImageError {
+    fn from_decoding(err: gif::DecodingError) -> ImageError {
+        use gif::DecodingError::*;
+        match err {
+            err @ Format(_) => {
+                ImageError::Decoding(DecodingError::new(ImageFormat::Gif.into(), err))
+            }
+            Io(io_err) => ImageError::IoError(io_err),
+        }
+    }
+
+    fn from_encoding(err: gif::EncodingError) -> ImageError {
+        use gif::EncodingError::*;
+        match err {
+            err @ Format(_) => {
+                ImageError::Encoding(EncodingError::new(ImageFormat::Gif.into(), err))
+            }
+            Io(io_err) => ImageError::IoError(io_err),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn frames_exceeding_logical_screen_size() {
+        // This is a gif with 10x10 logical screen, but a 16x16 frame + 6px offset inside.
+        let data = vec![
+            0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x0A, 0x00, 0x0A, 0x00, 0xF0, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x0E, 0xFF, 0x1F, 0x21, 0xF9, 0x04, 0x09, 0x64, 0x00, 0x00, 0x00, 0x2C,
+            0x06, 0x00, 0x06, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x23, 0x84, 0x8F, 0xA9,
+            0xBB, 0xE1, 0xE8, 0x42, 0x8A, 0x0F, 0x50, 0x79, 0xAE, 0xD1, 0xF9, 0x7A, 0xE8, 0x71,
+            0x5B, 0x48, 0x81, 0x64, 0xD5, 0x91, 0xCA, 0x89, 0x4D, 0x21, 0x63, 0x89, 0x4C, 0x09,
+            0x77, 0xF5, 0x6D, 0x14, 0x00, 0x3B,
+        ];
+
+        let decoder = GifDecoder::new(Cursor::new(data)).unwrap();
+        let mut buf = vec![0u8; decoder.total_bytes() as usize];
+
+        assert!(decoder.read_image(&mut buf).is_ok());
+    }
+}