use std::io::{BufRead, Read, Seek}; use crate::buffer::ConvertBuffer; use crate::error::{DecodingError, ImageError, ImageResult}; use crate::metadata::Orientation; use crate::{ AnimationDecoder, ColorType, Delay, Frame, Frames, ImageDecoder, ImageFormat, RgbImage, Rgba, RgbaImage, }; /// WebP Image format decoder. /// /// Supports both lossless and lossy WebP images. pub struct WebPDecoder { inner: image_webp::WebPDecoder, orientation: Option, } impl WebPDecoder { /// Create a new `WebPDecoder` from the Reader `r`. pub fn new(r: R) -> ImageResult { Ok(Self { inner: image_webp::WebPDecoder::new(r).map_err(ImageError::from_webp_decode)?, orientation: None, }) } /// Returns true if the image as described by the bitstream is animated. pub fn has_animation(&self) -> bool { self.inner.is_animated() } /// Sets the background color if the image is an extended and animated webp. pub fn set_background_color(&mut self, color: Rgba) -> ImageResult<()> { self.inner .set_background_color(color.0) .map_err(ImageError::from_webp_decode) } } impl ImageDecoder for WebPDecoder { fn dimensions(&self) -> (u32, u32) { self.inner.dimensions() } fn color_type(&self) -> ColorType { if self.inner.has_alpha() { ColorType::Rgba8 } else { ColorType::Rgb8 } } fn read_image(mut self, buf: &mut [u8]) -> ImageResult<()> { assert_eq!(u64::try_from(buf.len()), Ok(self.total_bytes())); self.inner .read_image(buf) .map_err(ImageError::from_webp_decode) } fn read_image_boxed(self: Box, buf: &mut [u8]) -> ImageResult<()> { (*self).read_image(buf) } fn icc_profile(&mut self) -> ImageResult>> { self.inner .icc_profile() .map_err(ImageError::from_webp_decode) } fn exif_metadata(&mut self) -> ImageResult>> { let exif = self .inner .exif_metadata() .map_err(ImageError::from_webp_decode)?; self.orientation = Some( exif.as_ref() .and_then(|exif| Orientation::from_exif_chunk(exif)) .unwrap_or(Orientation::NoTransforms), ); Ok(exif) } fn xmp_metadata(&mut self) -> ImageResult>> { self.inner .xmp_metadata() .map_err(ImageError::from_webp_decode) } fn orientation(&mut self) -> ImageResult { // `exif_metadata` caches the orientation, so call it if `orientation` hasn't been set yet. if self.orientation.is_none() { let _ = self.exif_metadata()?; } Ok(self.orientation.unwrap()) } } impl<'a, R: 'a + BufRead + Seek> AnimationDecoder<'a> for WebPDecoder { fn into_frames(self) -> Frames<'a> { struct FramesInner { decoder: WebPDecoder, current: u32, } impl Iterator for FramesInner { type Item = ImageResult; fn next(&mut self) -> Option { if self.current == self.decoder.inner.num_frames() { return None; } self.current += 1; let (width, height) = self.decoder.inner.dimensions(); let (img, delay) = if self.decoder.inner.has_alpha() { let mut img = RgbaImage::new(width, height); match self.decoder.inner.read_frame(&mut img) { Ok(delay) => (img, delay), Err(image_webp::DecodingError::NoMoreFrames) => return None, Err(e) => return Some(Err(ImageError::from_webp_decode(e))), } } else { let mut img = RgbImage::new(width, height); match self.decoder.inner.read_frame(&mut img) { Ok(delay) => (img.convert(), delay), Err(image_webp::DecodingError::NoMoreFrames) => return None, Err(e) => return Some(Err(ImageError::from_webp_decode(e))), } }; Some(Ok(Frame::from_parts( img, 0, 0, Delay::from_numer_denom_ms(delay, 1), ))) } } Frames::new(Box::new(FramesInner { decoder: self, current: 0, })) } } impl ImageError { fn from_webp_decode(e: image_webp::DecodingError) -> Self { match e { image_webp::DecodingError::IoError(e) => ImageError::IoError(e), _ => ImageError::Decoding(DecodingError::new(ImageFormat::WebP.into(), e)), } } } #[cfg(test)] mod tests { use super::*; #[test] fn add_with_overflow_size() { let bytes = vec![ 0x52, 0x49, 0x46, 0x46, 0xaf, 0x37, 0x80, 0x47, 0x57, 0x45, 0x42, 0x50, 0x6c, 0x64, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x7e, 0x73, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x40, 0xfb, 0xff, 0xff, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x00, 0x00, 0x00, 0x00, 0x62, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x49, 0x54, 0x55, 0x50, 0x4c, 0x54, 0x59, 0x50, 0x45, 0x33, 0x37, 0x44, 0x4d, 0x46, ]; let data = std::io::Cursor::new(bytes); let _ = WebPDecoder::new(data); } }