diff options
Diffstat (limited to 'vendor/image/src/codecs/gif.rs')
| -rw-r--r-- | vendor/image/src/codecs/gif.rs | 606 |
1 files changed, 0 insertions, 606 deletions
diff --git a/vendor/image/src/codecs/gif.rs b/vendor/image/src/codecs/gif.rs deleted file mode 100644 index dcbd841..0000000 --- a/vendor/image/src/codecs/gif.rs +++ /dev/null @@ -1,606 +0,0 @@ -//! 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()); - } -} |