aboutsummaryrefslogtreecommitdiff
path: root/vendor/gif/src/reader
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/gif/src/reader')
-rw-r--r--vendor/gif/src/reader/decoder.rs724
-rw-r--r--vendor/gif/src/reader/mod.rs522
2 files changed, 0 insertions, 1246 deletions
diff --git a/vendor/gif/src/reader/decoder.rs b/vendor/gif/src/reader/decoder.rs
deleted file mode 100644
index f0f8eea..0000000
--- a/vendor/gif/src/reader/decoder.rs
+++ /dev/null
@@ -1,724 +0,0 @@
-use std::cmp;
-use std::error;
-use std::fmt;
-use std::io;
-use std::mem;
-use std::default::Default;
-
-use crate::common::{AnyExtension, Block, DisposalMethod, Extension, Frame};
-use crate::reader::DecodeOptions;
-
-use weezl::{BitOrder, decode::Decoder as LzwDecoder, LzwStatus};
-
-/// GIF palettes are RGB
-pub const PLTE_CHANNELS: usize = 3;
-
-/// An error returned in the case of the image not being formatted properly.
-#[derive(Debug)]
-pub struct DecodingFormatError {
- underlying: Box<dyn error::Error + Send + Sync + 'static>
-}
-
-impl fmt::Display for DecodingFormatError {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- fmt::Display::fmt(&*self.underlying, fmt)
- }
-}
-
-impl error::Error for DecodingFormatError {
- fn source(&self) -> Option<&(dyn error::Error + 'static)> {
- Some(&*self.underlying as _)
- }
-}
-
-impl DecodingFormatError {
- fn new(
- err: impl Into<Box<dyn error::Error + Send + Sync>>,
- ) -> Self {
- DecodingFormatError {
- underlying: err.into(),
- }
- }
-}
-
-#[derive(Debug)]
-/// Decoding error.
-pub enum DecodingError {
- /// Returned if the image is found to be malformed.
- Format(DecodingFormatError),
- /// Wraps `std::io::Error`.
- Io(io::Error),
-}
-
-impl DecodingError {
- #[inline]
- pub(crate) fn format(
- err: impl Into<Box<dyn error::Error + Send + Sync>>,
- ) -> Self {
- DecodingError::Format(DecodingFormatError::new(err))
- }
-}
-
-impl fmt::Display for DecodingError {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- match *self {
- DecodingError::Format(ref d) => d.fmt(fmt),
- DecodingError::Io(ref err) => err.fmt(fmt),
- }
- }
-}
-
-impl error::Error for DecodingError {
- fn source(&self) -> Option<&(dyn error::Error + 'static)> {
- match *self {
- DecodingError::Format(ref err) => Some(err),
- DecodingError::Io(ref err) => Some(err),
- }
- }
-}
-
-impl From<io::Error> for DecodingError {
- fn from(err: io::Error) -> Self {
- DecodingError::Io(err)
- }
-}
-
-impl From<DecodingFormatError> for DecodingError {
- fn from(err: DecodingFormatError) -> Self {
- DecodingError::Format(err)
- }
-}
-
-/// Configures how extensions should be handled
-#[derive(PartialEq, Debug)]
-pub enum Extensions {
- /// Saves all extention data
- Save,
- /// Skips the data of unknown extensions
- /// and extracts the data from known ones
- Skip
-}
-
-/// Indicates whether a certain object has been decoded
-#[derive(Debug)]
-pub enum Decoded<'a> {
- /// Decoded nothing.
- Nothing,
- /// Global palette.
- GlobalPalette(Vec<u8>),
- /// Index of the background color in the global palette.
- BackgroundColor(u8),
- /// Decoded the image trailer.
- Trailer,
- /// The start of a block.
- BlockStart(Block),
- /// Decoded a sub-block. More sub-block are available.
- ///
- /// Indicates the label of the extension which might be unknown. A label of `0` is used when
- /// the sub block does not belong to an extension.
- SubBlockFinished(AnyExtension, &'a [u8]),
- /// Decoded the last (or only) sub-block of a block.
- ///
- /// Indicates the label of the extension which might be unknown. A label of `0` is used when
- /// the sub block does not belong to an extension.
- BlockFinished(AnyExtension, &'a [u8]),
- /// Decoded all information of the next frame.
- ///
- /// The returned frame does **not** contain any owned image data.
- Frame(&'a Frame<'static>),
- /// Decoded some data of the current frame.
- Data(&'a [u8]),
- /// No more data available the current frame.
- DataEnd,
-
-}
-
-/// Internal state of the GIF decoder
-#[derive(Debug)]
-enum State {
- Magic(usize, [u8; 6]),
- U16Byte1(U16Value, u8),
- U16(U16Value),
- Byte(ByteValue),
- GlobalPalette(usize),
- BlockStart(Option<Block>),
- /// Block end, with remaining expected data. NonZero for invalid EOF.
- BlockEnd(u8),
- ExtensionBlock(AnyExtension),
- SkipBlock(usize),
- LocalPalette(usize),
- LzwInit(u8),
- DecodeSubBlock(usize),
- FrameDecoded,
- Trailer
-}
-use self::State::*;
-
-/// U16 values that may occur in a GIF image
-#[derive(Debug)]
-enum U16Value {
- /// Logical screen descriptor width
- ScreenWidth,
- /// Logical screen descriptor height
- ScreenHeight,
- /// Delay time
- Delay,
- /// Left frame offset
- ImageLeft,
- /// Top frame offset
- ImageTop,
- /// Frame width
- ImageWidth,
- /// Frame height
- ImageHeight,
-}
-
-/// Single byte screen descriptor values
-#[derive(Debug)]
-enum ByteValue {
- GlobalFlags,
- Background { table_size: usize },
- AspectRatio { table_size: usize },
- ControlFlags,
- ImageFlags,
- TransparentIdx,
- CodeSize,
-}
-
-/// GIF decoder which supports streaming
-pub struct StreamingDecoder {
- state: Option<State>,
- lzw_reader: Option<LzwDecoder>,
- decode_buffer: Vec<u8>,
- skip_extensions: bool,
- check_frame_consistency: bool,
- check_for_end_code: bool,
- allow_unknown_blocks: bool,
- version: Version,
- width: u16,
- height: u16,
- global_color_table: Vec<u8>,
- background_color: [u8; 4],
- /// ext buffer
- ext: ExtensionData,
- /// Frame data
- current: Option<Frame<'static>>,
-}
-
-/// One version number of the GIF standard.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[non_exhaustive]
-pub enum Version {
- /// Version 87a, from May 1987.
- V87a,
- /// Version 89a, from July 1989.
- V89a,
-}
-
-struct ExtensionData {
- id: AnyExtension,
- data: Vec<u8>,
- is_block_end: bool,
-}
-
-impl StreamingDecoder {
- /// Creates a new streaming decoder
- pub fn new() -> StreamingDecoder {
- let options = DecodeOptions::new();
- Self::with_options(&options)
- }
-
- pub(crate) fn with_options(options: &DecodeOptions) -> Self {
- StreamingDecoder {
- state: Some(Magic(0, [0; 6])),
- lzw_reader: None,
- decode_buffer: vec![],
- skip_extensions: true,
- check_frame_consistency: options.check_frame_consistency,
- check_for_end_code: options.check_for_end_code,
- allow_unknown_blocks: options.allow_unknown_blocks,
- version: Version::V87a,
- width: 0,
- height: 0,
- global_color_table: Vec::new(),
- background_color: [0, 0, 0, 0xFF],
- ext: ExtensionData {
- id: AnyExtension(0),
- data: Vec::with_capacity(256), // 0xFF + 1 byte length
- is_block_end: true,
- },
- current: None
- }
- }
-
- /// Updates the internal state of the decoder.
- ///
- /// Returns the number of bytes consumed from the input buffer
- /// and the last decoding result.
- pub fn update<'a>(&'a mut self, mut buf: &[u8])
- -> Result<(usize, Decoded<'a>), DecodingError> {
- // NOTE: Do not change the function signature without double-checking the
- // unsafe block!
- let len = buf.len();
- while buf.len() > 0 && self.state.is_some() {
- match self.next_state(buf) {
- Ok((bytes, Decoded::Nothing)) => {
- buf = &buf[bytes..]
- }
- Ok((bytes, Decoded::Trailer)) => {
- buf = &buf[bytes..];
- break
- }
- Ok((bytes, result)) => {
- buf = &buf[bytes..];
- return Ok(
- (len-buf.len(),
- // This transmute just casts the lifetime away. Since Rust only
- // has SESE regions, this early return cannot be worked out and
- // such that the borrow region of self includes the whole block.
- // The explixit lifetimes in the function signature ensure that
- // this is safe.
- // ### NOTE
- // To check that everything is sound, return the result without
- // the match (e.g. `return Ok(self.next_state(buf)?)`). If
- // it compiles the returned lifetime is correct.
- unsafe {
- mem::transmute::<Decoded, Decoded>(result)
- }
- ))
- }
- Err(err) => return Err(err)
- }
- }
- Ok((len-buf.len(), Decoded::Nothing))
-
- }
-
- /// Returns the data of the last extension that has been decoded.
- pub fn last_ext(&self) -> (AnyExtension, &[u8], bool) {
- (self.ext.id, &self.ext.data, self.ext.is_block_end)
- }
-
- #[inline(always)]
- /// Current frame info as a mutable ref.
- pub fn current_frame_mut<'a>(&'a mut self) -> &'a mut Frame<'static> {
- self.current.as_mut().unwrap()
- }
-
- #[inline(always)]
- /// Current frame info as a ref.
- pub fn current_frame<'a>(&'a self) -> &'a Frame<'static> {
- self.current.as_ref().unwrap()
- }
-
- /// Width of the image
- pub fn width(&self) -> u16 {
- self.width
- }
-
- /// Height of the image
- pub fn height(&self) -> u16 {
- self.height
- }
-
- /// The version number of the GIF standard used in this image.
- ///
- /// We suppose a minimum of `V87a` compatibility. This value will be reported until we have
- /// read the version information in the magic header bytes.
- pub fn version(&self) -> Version {
- self.version
- }
-
- /// Configure whether extensions are saved or skipped.
- #[deprecated = "Does not work as intended. In fact, doesn't do anything. This may disappear soon."]
- pub fn set_extensions(&mut self, extensions: Extensions) {
- self.skip_extensions = match extensions {
- Extensions::Skip => true,
- Extensions::Save => false,
- }
- }
-
- fn next_state<'a>(&'a mut self, buf: &[u8]) -> Result<(usize, Decoded<'a>), DecodingError> {
- macro_rules! goto (
- ($n:expr, $state:expr) => ({
- self.state = Some($state);
- Ok(($n, Decoded::Nothing))
- });
- ($state:expr) => ({
- self.state = Some($state);
- Ok((1, Decoded::Nothing))
- });
- ($n:expr, $state:expr, emit $res:expr) => ({
- self.state = Some($state);
- Ok(($n, $res))
- });
- ($state:expr, emit $res:expr) => ({
- self.state = Some($state);
- Ok((1, $res))
- })
- );
-
- let b = buf[0];
-
- // Driver should ensure that state is never None
- let state = self.state.take().unwrap();
- //println!("{:?}", state);
-
- match state {
- Magic(i, mut version) => if i < 6 {
- version[i] = b;
- goto!(Magic(i+1, version))
- } else if &version[..3] == b"GIF" {
- self.version = match &version[3..] {
- b"87a" => Version::V87a,
- b"89a" => Version::V89a,
- _ => return Err(DecodingError::format("unsupported GIF version"))
- };
- goto!(U16Byte1(U16Value::ScreenWidth, b))
- } else {
- Err(DecodingError::format("malformed GIF header"))
- },
- U16(next) => goto!(U16Byte1(next, b)),
- U16Byte1(next, value) => {
- use self::U16Value::*;
- let value = ((b as u16) << 8) | value as u16;
- match (next, value) {
- (ScreenWidth, width) => {
- self.width = width;
- goto!(U16(U16Value::ScreenHeight))
- },
- (ScreenHeight, height) => {
- self.height = height;
- goto!(Byte(ByteValue::GlobalFlags))
- },
- (Delay, delay) => {
- self.ext.data.push(value as u8);
- self.ext.data.push(b);
- self.current_frame_mut().delay = delay;
- goto!(Byte(ByteValue::TransparentIdx))
- },
- (ImageLeft, left) => {
- self.current_frame_mut().left = left;
- goto!(U16(U16Value::ImageTop))
- },
- (ImageTop, top) => {
- self.current_frame_mut().top = top;
- goto!(U16(U16Value::ImageWidth))
- },
- (ImageWidth, width) => {
- self.current_frame_mut().width = width;
- goto!(U16(U16Value::ImageHeight))
- },
- (ImageHeight, height) => {
- self.current_frame_mut().height = height;
- goto!(Byte(ByteValue::ImageFlags))
- }
- }
- }
- Byte(value) => {
- use self::ByteValue::*;
- match value {
- GlobalFlags => {
- let global_table = b & 0x80 != 0;
- let entries = if global_table {
- let entries = PLTE_CHANNELS*(1 << ((b & 0b111) + 1) as usize);
- self.global_color_table.reserve_exact(entries);
- entries
- } else {
- 0usize
- };
- goto!(Byte(Background { table_size: entries }))
- },
- Background { table_size } => {
- goto!(
- Byte(AspectRatio { table_size: table_size }),
- emit Decoded::BackgroundColor(b)
- )
- },
- AspectRatio { table_size } => {
- goto!(GlobalPalette(table_size))
- },
- ControlFlags => {
- self.ext.data.push(b);
- let control_flags = b;
- if control_flags & 1 != 0 {
- // Set to Some(...), gets overwritten later
- self.current_frame_mut().transparent = Some(0)
- }
- self.current_frame_mut().needs_user_input =
- control_flags & 0b10 != 0;
- self.current_frame_mut().dispose = match DisposalMethod::from_u8(
- (control_flags & 0b11100) >> 2
- ) {
- Some(method) => method,
- None => DisposalMethod::Any
- };
- goto!(U16(U16Value::Delay))
- }
- TransparentIdx => {
- self.ext.data.push(b);
- if let Some(ref mut idx) = self.current_frame_mut().transparent {
- *idx = b
- }
- goto!(SkipBlock(0))
- //goto!(AwaitBlockEnd)
- }
- ImageFlags => {
- let local_table = (b & 0b1000_0000) != 0;
- let interlaced = (b & 0b0100_0000) != 0;
- let table_size = b & 0b0000_0111;
-
- self.current_frame_mut().interlaced = interlaced;
-
- if self.check_frame_consistency {
- // Consistency checks.
- let (width, height) = (self.width, self.height);
- let frame = self.current_frame_mut();
- if width.checked_sub(frame.width) < Some(frame.left)
- || height.checked_sub(frame.height) < Some(frame.top)
- {
- return Err(DecodingError::format("frame descriptor is out-of-bounds"))
- }
- }
-
- if local_table {
- let entries = PLTE_CHANNELS * (1 << (table_size + 1));
-
- self.current_frame_mut().palette =
- Some(Vec::with_capacity(entries));
- goto!(LocalPalette(entries))
- } else {
- goto!(Byte(CodeSize))
- }
- },
- CodeSize => goto!(LzwInit(b))
- }
- }
- GlobalPalette(left) => {
- let n = cmp::min(left, buf.len());
- if left > 0 {
- self.global_color_table.extend_from_slice(&buf[..n]);
- goto!(n, GlobalPalette(left - n))
- } else {
- let idx = self.background_color[0];
- match self.global_color_table.chunks(PLTE_CHANNELS).nth(idx as usize) {
- Some(chunk) => self.background_color[..PLTE_CHANNELS]
- .copy_from_slice(&chunk[..PLTE_CHANNELS]),
- None => self.background_color[0] = 0
- }
- goto!(BlockStart(Block::from_u8(b)), emit Decoded::GlobalPalette(
- mem::replace(&mut self.global_color_table, Vec::new())
- ))
- }
- }
- BlockStart(type_) => {
- match type_ {
- Some(Block::Image) => {
- self.add_frame();
- goto!(U16Byte1(U16Value::ImageLeft, b), emit Decoded::BlockStart(Block::Image))
- }
- Some(Block::Extension) => {
- goto!(ExtensionBlock(AnyExtension(b)), emit Decoded::BlockStart(Block::Extension))
- }
- Some(Block::Trailer) => {
- goto!(0, State::Trailer, emit Decoded::BlockStart(Block::Trailer))
- }
- None => {
- if self.allow_unknown_blocks {
- goto!(SkipBlock(b as usize))
- } else {
- Err(DecodingError::format("unknown block type encountered"))
- }
- }
- }
- }
- BlockEnd(terminator) => {
- if terminator == 0 {
- if b == Block::Trailer as u8 {
- goto!(0, BlockStart(Some(Block::Trailer)))
- } else {
- goto!(BlockStart(Block::from_u8(b)))
- }
- } else {
- return Err(DecodingError::format(
- "expected block terminator not found"
- ))
- }
- }
- ExtensionBlock(id) => {
- use Extension::*;
- self.ext.id = id;
- self.ext.data.clear();
- self.ext.data.push(b);
- if let Some(ext) = Extension::from_u8(id.0) {
- match ext {
- Control => {
- goto!(self.read_control_extension(b)?)
- }
- Text | Comment | Application => {
- goto!(SkipBlock(b as usize))
- }
- }
- } else {
- return Err(DecodingError::format(
- "unknown extention block encountered"
- ))
- }
- }
- SkipBlock(left) => {
- let n = cmp::min(left, buf.len());
- if left > 0 {
- self.ext.data.extend_from_slice(&buf[..n]);
- goto!(n, SkipBlock(left - n))
- } else {
- if b == 0 {
- self.ext.is_block_end = true;
- goto!(BlockEnd(b), emit Decoded::BlockFinished(self.ext.id, &self.ext.data))
- } else {
- self.ext.is_block_end = false;
- goto!(SkipBlock(b as usize), emit Decoded::SubBlockFinished(self.ext.id, &self.ext.data))
- }
- }
- }
- LocalPalette(left) => {
- let n = cmp::min(left, buf.len());
- if left > 0 {
-
- self.current_frame_mut().palette
- .as_mut().unwrap().extend(buf[..n].iter().cloned());
- goto!(n, LocalPalette(left - n))
- } else {
- goto!(LzwInit(b))
- }
- }
- LzwInit(code_size) => {
- // LZW spec: max 12 bits per code
- if code_size > 11 {
- return Err(DecodingError::format(
- "invalid minimal code size"
- ))
- }
- self.lzw_reader = Some(LzwDecoder::new(BitOrder::Lsb, code_size));
- goto!(DecodeSubBlock(b as usize), emit Decoded::Frame(self.current_frame_mut()))
- }
- DecodeSubBlock(left) => {
- if left > 0 {
- let n = cmp::min(left, buf.len());
- let max_bytes = self.current_frame().required_bytes();
- let decoder = self.lzw_reader.as_mut().unwrap();
- if decoder.has_ended() {
- debug_assert!(n > 0, "Made forward progress after LZW end");
- return goto!(n, DecodeSubBlock(0), emit Decoded::Data(&[]));
- }
-
- let mut dummy_target;
- let decode_target;
-
- if self.decode_buffer.is_empty() {
- let size = (1 << 14).min(max_bytes);
- self.decode_buffer = vec![0; size];
- }
-
- if max_bytes == 0 {
- dummy_target = [0; 16];
- decode_target = &mut dummy_target[..];
- } else {
- decode_target = self.decode_buffer.as_mut_slice();
- }
-
- debug_assert!(!decode_target.is_empty(), "LZW decoding can make forward progress.");
- let decoded = decoder.decode_bytes(&buf[..n], decode_target);
-
- if let Err(err) = decoded.status {
- return Err(io::Error::new(io::ErrorKind::InvalidData, &*format!("{:?}", err)).into());
- }
-
- let bytes = &self.decode_buffer[..decoded.consumed_out.min(max_bytes)];
- let consumed = decoded.consumed_in;
- goto!(consumed, DecodeSubBlock(left - consumed), emit Decoded::Data(bytes))
- } else if b != 0 { // decode next sub-block
- goto!(DecodeSubBlock(b as usize))
- } else {
- let max_bytes = self.current_frame().required_bytes();
- // The end of the lzw stream is only reached if left == 0 and an additional call
- // to `decode_bytes` results in an empty slice.
- let decoder = self.lzw_reader.as_mut().unwrap();
- // Some mutable bytes to decode into. We need this for forward progress in
- // `lzw`. However, in some cases we do not actually need any bytes, when
- // `max_bytes` is `0`.
- let mut dummy_target;
- let decode_target;
-
- if self.decode_buffer.is_empty() {
- let size = (1 << 14).min(max_bytes);
- self.decode_buffer = vec![0; size];
- }
-
- if max_bytes == 0 {
- dummy_target = [0; 16];
- decode_target = &mut dummy_target[..];
- } else {
- decode_target = self.decode_buffer.as_mut_slice();
- }
-
- debug_assert!(!decode_target.is_empty(), "LZW decoding can make forward progress.");
- let decoded = decoder.decode_bytes(&[], decode_target);
-
- match decoded.status {
- Ok(LzwStatus::Done) | Ok(LzwStatus::Ok) => {},
- Ok(LzwStatus::NoProgress) => {
- if self.check_for_end_code {
- return Err(io::Error::new(io::ErrorKind::InvalidData, "No end code in lzw stream").into());
- } else {
- self.current = None;
- return goto!(0, FrameDecoded, emit Decoded::DataEnd);
- }
- },
- Err(err) => {
- return Err(io::Error::new(io::ErrorKind::InvalidData, &*format!("{:?}", err)).into());
- }
- }
- let bytes = &self.decode_buffer[..decoded.consumed_out.min(max_bytes)];
-
- if bytes.len() > 0 {
- goto!(0, DecodeSubBlock(0), emit Decoded::Data(bytes))
- } else {
- // end of image data reached
- self.current = None;
- goto!(0, FrameDecoded, emit Decoded::DataEnd)
- }
- }
- }
- FrameDecoded => {
- goto!(BlockEnd(b))
- }
- Trailer => {
- self.state = None;
- Ok((1, Decoded::Trailer))
- //panic!("EOF {:?}", self)
- }
- }
- }
-
- fn read_control_extension(&mut self, b: u8) -> Result<State, DecodingError> {
- self.add_frame();
- self.ext.data.push(b);
- if b != 4 {
- return Err(DecodingError::format(
- "control extension has wrong length"
- ))
- }
- Ok(Byte(ByteValue::ControlFlags))
- }
-
- fn add_frame(&mut self) {
- if self.current.is_none() {
- self.current = Some(Frame::default())
- }
- }
-}
-
-#[test]
-fn error_cast() {
- let _ : Box<dyn error::Error> = DecodingError::Format(DecodingFormatError::new("testing")).into();
-}
diff --git a/vendor/gif/src/reader/mod.rs b/vendor/gif/src/reader/mod.rs
deleted file mode 100644
index a453e79..0000000
--- a/vendor/gif/src/reader/mod.rs
+++ /dev/null
@@ -1,522 +0,0 @@
-use std::borrow::Cow;
-use std::io;
-use std::cmp;
-use std::mem;
-use std::iter;
-use std::io::prelude::*;
-
-use crate::common::{Block, Frame};
-
-mod decoder;
-pub use self::decoder::{
- PLTE_CHANNELS, StreamingDecoder, Decoded, DecodingError, DecodingFormatError, Extensions,
- Version
-};
-
-const N_CHANNELS: usize = 4;
-
-/// Output mode for the image data
-#[derive(Clone, Copy, Debug, PartialEq)]
-#[repr(u8)]
-pub enum ColorOutput {
- /// The decoder expands the image data to 32bit RGBA.
- /// This affects:
- ///
- /// - The buffer buffer of the `Frame` returned by `Decoder::read_next_frame`.
- /// - `Decoder::fill_buffer`, `Decoder::buffer_size` and `Decoder::line_length`.
- RGBA = 0,
- /// The decoder returns the raw indexed data.
- Indexed = 1,
-}
-
-#[derive(Clone, Debug)]
-/// Memory limit in bytes. `MemoryLimit(0)` means
-/// that there is no memory limit set.
-pub struct MemoryLimit(pub u32);
-
-impl MemoryLimit {
- /// Enforce no memory limit.
- ///
- /// If you intend to process images from unknown origins this is a potentially dangerous
- /// constant to use, as your program could be vulnerable to decompression bombs. That is,
- /// malicious images crafted specifically to require an enormous amount of memory to process
- /// while having a disproportionately small file size.
- ///
- /// The risks for modern machines are a bit smaller as the dimensions of each frame can not
- /// exceed `u32::MAX` (~4Gb) but this is still a significant amount of memory.
- pub const NONE: MemoryLimit = MemoryLimit(0);
-
- fn buffer_size(&self, color: ColorOutput, width: u16, height: u16) -> Option<usize> {
- let pixels = u32::from(width) * u32::from(height);
-
- let bytes_per_pixel = match color {
- ColorOutput::Indexed => 1,
- ColorOutput::RGBA => 4,
- };
-
- if self.0 > 0 && pixels > self.0 / bytes_per_pixel {
- None
- } else {
- Some(pixels as usize * bytes_per_pixel as usize)
- }
- }
-}
-
-/// Options for opening a GIF decoder.
-#[derive(Clone, Debug)]
-pub struct DecodeOptions {
- memory_limit: MemoryLimit,
- color_output: ColorOutput,
- check_frame_consistency: bool,
- check_for_end_code: bool,
- allow_unknown_blocks: bool,
-}
-
-impl DecodeOptions {
- /// Creates a new decoder builder
- pub fn new() -> DecodeOptions {
- DecodeOptions {
- memory_limit: MemoryLimit(50_000_000), // 50 MB
- color_output: ColorOutput::Indexed,
- check_frame_consistency: false,
- check_for_end_code: false,
- allow_unknown_blocks: false,
- }
- }
-
- /// Configure how color data is decoded.
- pub fn set_color_output(&mut self, color: ColorOutput) {
- self.color_output = color;
- }
-
- /// Configure a memory limit for decoding.
- pub fn set_memory_limit(&mut self, limit: MemoryLimit) {
- self.memory_limit = limit;
- }
-
- /// Configure if frames must be within the screen descriptor.
- ///
- /// The default is `false`.
- ///
- /// When turned on, all frame descriptors being read must fit within the screen descriptor or
- /// otherwise an error is returned and the stream left in an unspecified state.
- ///
- /// When turned off, frames may be arbitrarily larger or offset in relation to the screen. Many
- /// other decoder libraries handle this in highly divergent ways. This moves all checks to the
- /// caller, for example to emulate a specific style.
- pub fn check_frame_consistency(&mut self, check: bool) {
- self.check_frame_consistency = check;
- }
-
- /// Configure if LZW encoded blocks must end with a marker end code.
- ///
- /// The default is `false`.
- ///
- /// When turned on, all image data blocks—which are LZW encoded—must contain a special bit
- /// sequence signalling the end of the data. LZW processing terminates when this code is
- /// encountered. The specification states that it must be the last code output by the encoder
- /// for an image.
- ///
- /// When turned off then image data blocks can simply end. Note that this might silently ignore
- /// some bits of the last or second to last byte.
- pub fn check_lzw_end_code(&mut self, check: bool) {
- self.check_for_end_code = check;
- }
-
- /// Configure if unknown blocks are allowed to be decoded.
- ///
- /// The default is `false`.
- ///
- /// When turned on, the decoder will allow unknown blocks to be in the
- /// `BlockStart` position.
- ///
- /// When turned off, decoded block starts must mark an `Image`, `Extension`,
- /// or `Trailer` block. Otherwise, the decoded image will return an error.
- /// If an unknown block error is returned from decoding, enabling this
- /// setting may allow for a further state of decoding on the next attempt.
- pub fn allow_unknown_blocks(&mut self, check: bool) {
- self.allow_unknown_blocks = check;
- }
-
- /// Reads the logical screen descriptor including the global color palette
- ///
- /// Returns a `Decoder`. All decoder configuration has to be done beforehand.
- pub fn read_info<R: Read>(self, r: R) -> Result<Decoder<R>, DecodingError> {
- Decoder::with_no_init(r, StreamingDecoder::with_options(&self), self).init()
- }
-}
-
-struct ReadDecoder<R: Read> {
- reader: io::BufReader<R>,
- decoder: StreamingDecoder,
- at_eof: bool
-}
-
-impl<R: Read> ReadDecoder<R> {
- fn decode_next(&mut self) -> Result<Option<Decoded>, DecodingError> {
- while !self.at_eof {
- let (consumed, result) = {
- let buf = self.reader.fill_buf()?;
- if buf.len() == 0 {
- return Err(DecodingError::format(
- "unexpected EOF"
- ))
- }
- self.decoder.update(buf)?
- };
- self.reader.consume(consumed);
- match result {
- Decoded::Nothing => (),
- Decoded::BlockStart(Block::Trailer) => {
- self.at_eof = true
- },
- result => return Ok(unsafe{
- // FIXME: #6393
- Some(mem::transmute::<Decoded, Decoded>(result))
- }),
- }
- }
- Ok(None)
- }
-}
-
-#[allow(dead_code)]
-/// GIF decoder
-pub struct Decoder<R: Read> {
- decoder: ReadDecoder<R>,
- color_output: ColorOutput,
- memory_limit: MemoryLimit,
- bg_color: Option<u8>,
- global_palette: Option<Vec<u8>>,
- current_frame: Frame<'static>,
- buffer: Vec<u8>,
-}
-
-impl<R> Decoder<R> where R: Read {
- /// Create a new decoder with default options.
- pub fn new(reader: R) -> Result<Self, DecodingError> {
- DecodeOptions::new().read_info(reader)
- }
-
- /// Return a builder that allows configuring limits etc.
- pub fn build() -> DecodeOptions {
- DecodeOptions::new()
- }
-
- fn with_no_init(reader: R, decoder: StreamingDecoder, options: DecodeOptions) -> Decoder<R> {
- Decoder {
- decoder: ReadDecoder {
- reader: io::BufReader::new(reader),
- decoder,
- at_eof: false
- },
- bg_color: None,
- global_palette: None,
- buffer: Vec::with_capacity(32),
- color_output: options.color_output,
- memory_limit: options.memory_limit,
- current_frame: Frame::default(),
- }
- }
-
- fn init(mut self) -> Result<Self, DecodingError> {
- loop {
- match self.decoder.decode_next()? {
- Some(Decoded::BackgroundColor(bg_color)) => {
- self.bg_color = Some(bg_color)
- }
- Some(Decoded::GlobalPalette(palette)) => {
- self.global_palette = if palette.len() > 0 {
- Some(palette)
- } else {
- None
- };
- break
- },
- Some(_) => {
- // Unreachable since this loop exists after the global
- // palette has been read.
- unreachable!()
- },
- None => return Err(DecodingError::format(
- "file does not contain any image data"
- ))
- }
- }
- // If the background color is invalid, ignore it
- if let Some(ref palette) = self.global_palette {
- if self.bg_color.unwrap_or(0) as usize >= (palette.len() / PLTE_CHANNELS) {
- self.bg_color = None;
- }
- }
- Ok(self)
- }
-
- /// Returns the next frame info
- pub fn next_frame_info(&mut self) -> Result<Option<&Frame<'static>>, DecodingError> {
- if !self.buffer.is_empty() {
- // FIXME: Warn about discarding data?
- self.buffer.clear();
- }
-
- loop {
- match self.decoder.decode_next()? {
- Some(Decoded::Frame(frame)) => {
- self.current_frame = frame.clone();
- if frame.palette.is_none() && self.global_palette.is_none() {
- return Err(DecodingError::format(
- "no color table available for current frame"
- ))
- }
- break
- },
- Some(_) => (),
- None => return Ok(None)
-
- }
- }
- Ok(Some(&self.current_frame))
- }
-
- /// Reads the next frame from the image.
- ///
- /// Do not call `Self::next_frame_info` beforehand.
- /// Deinterlaces the result.
- pub fn read_next_frame(&mut self) -> Result<Option<&Frame<'static>>, DecodingError> {
- if let Some(frame) = self.next_frame_info()? {
- let (width, height) = (frame.width, frame.height);
- let pixel_bytes = self.memory_limit
- .buffer_size(self.color_output, width, height)
- .ok_or_else(|| {
- DecodingError::format("image is too large to decode")
- })?;
-
- debug_assert_eq!(
- pixel_bytes, self.buffer_size(),
- "Checked computation diverges from required buffer size"
- );
-
- let mut vec = vec![0; pixel_bytes];
- self.read_into_buffer(&mut vec)?;
- self.current_frame.buffer = Cow::Owned(vec);
- self.current_frame.interlaced = false;
- Ok(Some(&self.current_frame))
- } else {
- Ok(None)
- }
- }
-
- /// Reads the data of the current frame into a pre-allocated buffer.
- ///
- /// `Self::next_frame_info` needs to be called beforehand.
- /// The length of `buf` must be at least `Self::buffer_size`.
- /// Deinterlaces the result.
- pub fn read_into_buffer(&mut self, buf: &mut [u8]) -> Result<(), DecodingError> {
- if self.current_frame.interlaced {
- let width = self.line_length();
- let height = self.current_frame.height as usize;
- for row in (InterlaceIterator { len: height, next: 0, pass: 0 }) {
- if !self.fill_buffer(&mut buf[row*width..][..width])? {
- return Err(DecodingError::format("image truncated"))
- }
- }
- } else {
- let buf = &mut buf[..self.buffer_size()];
- if !self.fill_buffer(buf)? {
- return Err(DecodingError::format("image truncated"))
- }
- };
- Ok(())
- }
-
- /// Reads data of the current frame into a pre-allocated buffer until the buffer has been
- /// filled completely.
- ///
- /// `Self::next_frame_info` needs to be called beforehand. Returns `true` if the supplied
- /// buffer could be filled completely. Should not be called after `false` had been returned.
- pub fn fill_buffer(&mut self, mut buf: &mut [u8]) -> Result<bool, DecodingError> {
- use self::ColorOutput::*;
- const PLTE_CHANNELS: usize = 3;
- macro_rules! handle_data(
- ($data:expr) => {
- match self.color_output {
- RGBA => {
- let transparent = self.current_frame.transparent;
- let palette: &[u8] = match self.current_frame.palette {
- Some(ref table) => &*table,
- None => &*self.global_palette.as_ref().unwrap(),
- };
- let len = cmp::min(buf.len()/N_CHANNELS, $data.len());
- for (rgba, &idx) in buf[..len*N_CHANNELS].chunks_mut(N_CHANNELS).zip($data.iter()) {
- let plte_offset = PLTE_CHANNELS * idx as usize;
- if palette.len() >= plte_offset + PLTE_CHANNELS {
- let colors = &palette[plte_offset..];
- rgba[0] = colors[0];
- rgba[1] = colors[1];
- rgba[2] = colors[2];
- rgba[3] = if let Some(t) = transparent {
- if t == idx { 0x00 } else { 0xFF }
- } else {
- 0xFF
- }
- }
- }
- (len, N_CHANNELS)
- },
- Indexed => {
- let len = cmp::min(buf.len(), $data.len());
- buf[..len].copy_from_slice(&$data[..len]);
- (len, 1)
- }
- }
- }
- );
- let buf_len = self.buffer.len();
- if buf_len > 0 {
- let (len, channels) = handle_data!(&self.buffer);
- let _ = self.buffer.drain(..len);
- buf = &mut buf[len*channels..];
- if buf.len() == 0 {
- return Ok(true)
- }
- }
- loop {
- match self.decoder.decode_next()? {
- Some(Decoded::Data(data)) => {
- let (len, channels) = handle_data!(data);
- buf = &mut buf[len*channels..]; // shorten buf
- if buf.len() > 0 {
- continue
- } else if len < data.len() {
- self.buffer.extend_from_slice(&data[len..]);
- }
- return Ok(true)
- },
- Some(_) => return Ok(false), // make sure that no important result is missed
- None => return Ok(false)
-
- }
- }
- }
-
- /// Output buffer size
- pub fn buffer_size(&self) -> usize {
- self.line_length() * self.current_frame.height as usize
- }
-
- /// Line length of the current frame
- pub fn line_length(&self) -> usize {
- use self::ColorOutput::*;
- match self.color_output {
- RGBA => self.current_frame.width as usize * N_CHANNELS,
- Indexed => self.current_frame.width as usize
- }
- }
-
- /// Returns the color palette relevant for the current (next) frame
- pub fn palette(&self) -> Result<&[u8], DecodingError> {
- // TODO prevent planic
- Ok(match self.current_frame.palette {
- Some(ref table) => &*table,
- None => &*self.global_palette.as_ref().ok_or(DecodingError::format(
- "no color table available for current frame"
- ))?,
- })
- }
-
- /// The global color palette
- pub fn global_palette(&self) -> Option<&[u8]> {
- self.global_palette.as_ref().map(|v| &**v)
- }
-
- /// Width of the image
- pub fn width(&self) -> u16 {
- self.decoder.decoder.width()
- }
-
- /// Height of the image
- pub fn height(&self) -> u16 {
- self.decoder.decoder.height()
- }
-
- /// Index of the background color in the global palette
- pub fn bg_color(&self) -> Option<usize> {
- self.bg_color.map(|v| v as usize)
- }
-}
-
-struct InterlaceIterator {
- len: usize,
- next: usize,
- pass: usize
-}
-
-impl iter::Iterator for InterlaceIterator {
- type Item = usize;
-
- fn next(&mut self) -> Option<Self::Item> {
- if self.len == 0 || self.pass > 3 {
- return None
- }
- let mut next = self.next + [8, 8, 4, 2][self.pass];
- while next >= self.len {
- next = [4, 2, 1, 0][self.pass];
- self.pass += 1;
- }
- mem::swap(&mut next, &mut self.next);
- Some(next)
- }
-}
-
-#[cfg(test)]
-mod test {
- use std::fs::File;
-
- use super::{Decoder, InterlaceIterator};
-
- #[test]
- fn test_simple_indexed() {
- let mut decoder = Decoder::new(File::open("tests/samples/sample_1.gif").unwrap()).unwrap();
- let frame = decoder.read_next_frame().unwrap().unwrap();
- assert_eq!(&*frame.buffer, &[
- 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
- 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
- 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
- 1, 1, 1, 0, 0, 0, 0, 2, 2, 2,
- 1, 1, 1, 0, 0, 0, 0, 2, 2, 2,
- 2, 2, 2, 0, 0, 0, 0, 1, 1, 1,
- 2, 2, 2, 0, 0, 0, 0, 1, 1, 1,
- 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
- 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
- 2, 2, 2, 2, 2, 1, 1, 1, 1, 1
- ][..])
- }
-
- #[test]
- fn test_interlace_iterator() {
- for &(len, expect) in &[
- (0, &[][..]),
- (1, &[0][..]),
- (2, &[0, 1][..]),
- (3, &[0, 2, 1][..]),
- (4, &[0, 2, 1, 3][..]),
- (5, &[0, 4, 2, 1, 3][..]),
- (6, &[0, 4, 2, 1, 3, 5][..]),
- (7, &[0, 4, 2, 6, 1, 3, 5][..]),
- (8, &[0, 4, 2, 6, 1, 3, 5, 7][..]),
- (9, &[0, 8, 4, 2, 6, 1, 3, 5, 7][..]),
- (10, &[0, 8, 4, 2, 6, 1, 3, 5, 7, 9][..]),
- (11, &[0, 8, 4, 2, 6, 10, 1, 3, 5, 7, 9][..]),
- (12, &[0, 8, 4, 2, 6, 10, 1, 3, 5, 7, 9, 11][..]),
- (13, &[0, 8, 4, 12, 2, 6, 10, 1, 3, 5, 7, 9, 11][..]),
- (14, &[0, 8, 4, 12, 2, 6, 10, 1, 3, 5, 7, 9, 11, 13][..]),
- (15, &[0, 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13][..]),
- (16, &[0, 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15][..]),
- (17, &[0, 8, 16, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15][..]),
- ] {
- let iter = InterlaceIterator { len: len, next: 0, pass: 0 };
- let lines = iter.collect::<Vec<_>>();
- assert_eq!(lines, expect);
- }
- }
-}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.