diff options
Diffstat (limited to 'vendor/png/src/encoder.rs')
| -rw-r--r-- | vendor/png/src/encoder.rs | 2389 |
1 files changed, 2389 insertions, 0 deletions
diff --git a/vendor/png/src/encoder.rs b/vendor/png/src/encoder.rs new file mode 100644 index 0000000..812bcaa --- /dev/null +++ b/vendor/png/src/encoder.rs @@ -0,0 +1,2389 @@ +use borrow::Cow; +use io::{Read, Write}; +use ops::{Deref, DerefMut}; +use std::{borrow, error, fmt, io, mem, ops, result}; + +use crc32fast::Hasher as Crc32; +use flate2::write::ZlibEncoder; + +use crate::chunk::{self, ChunkType}; +use crate::common::{ + AnimationControl, BitDepth, BlendOp, BytesPerPixel, ColorType, Compression, DisposeOp, + FrameControl, Info, ParameterError, ParameterErrorKind, PixelDimensions, ScaledFloat, +}; +use crate::filter::{filter, AdaptiveFilterType, FilterType}; +use crate::text_metadata::{ + EncodableTextChunk, ITXtChunk, TEXtChunk, TextEncodingError, ZTXtChunk, +}; +use crate::traits::WriteBytesExt; + +pub type Result<T> = result::Result<T, EncodingError>; + +#[derive(Debug)] +pub enum EncodingError { + IoError(io::Error), + Format(FormatError), + Parameter(ParameterError), + LimitsExceeded, +} + +#[derive(Debug)] +pub struct FormatError { + inner: FormatErrorKind, +} + +#[derive(Debug)] +enum FormatErrorKind { + ZeroWidth, + ZeroHeight, + InvalidColorCombination(BitDepth, ColorType), + NoPalette, + // TODO: wait, what? + WrittenTooMuch(usize), + NotAnimated, + OutOfBounds, + EndReached, + ZeroFrames, + MissingFrames, + MissingData(usize), + Unrecoverable, + BadTextEncoding(TextEncodingError), +} + +impl error::Error for EncodingError { + fn cause(&self) -> Option<&(dyn error::Error + 'static)> { + match self { + EncodingError::IoError(err) => Some(err), + _ => None, + } + } +} + +impl fmt::Display for EncodingError { + fn fmt(&self, fmt: &mut fmt::Formatter) -> result::Result<(), fmt::Error> { + use self::EncodingError::*; + match self { + IoError(err) => write!(fmt, "{}", err), + Format(desc) => write!(fmt, "{}", desc), + Parameter(desc) => write!(fmt, "{}", desc), + LimitsExceeded => write!(fmt, "Limits are exceeded."), + } + } +} + +impl fmt::Display for FormatError { + fn fmt(&self, fmt: &mut fmt::Formatter) -> result::Result<(), fmt::Error> { + use FormatErrorKind::*; + match self.inner { + ZeroWidth => write!(fmt, "Zero width not allowed"), + ZeroHeight => write!(fmt, "Zero height not allowed"), + ZeroFrames => write!(fmt, "Zero frames not allowed"), + InvalidColorCombination(depth, color) => write!( + fmt, + "Invalid combination of bit-depth '{:?}' and color-type '{:?}'", + depth, color + ), + NoPalette => write!(fmt, "can't write indexed image without palette"), + WrittenTooMuch(index) => write!(fmt, "wrong data size, got {} bytes too many", index), + NotAnimated => write!(fmt, "not an animation"), + OutOfBounds => write!( + fmt, + "the dimension and position go over the frame boundaries" + ), + EndReached => write!(fmt, "all the frames have been already written"), + MissingFrames => write!(fmt, "there are still frames to be written"), + MissingData(n) => write!(fmt, "there are still {} bytes to be written", n), + Unrecoverable => write!( + fmt, + "a previous error put the writer into an unrecoverable state" + ), + BadTextEncoding(tee) => match tee { + TextEncodingError::Unrepresentable => write!( + fmt, + "The text metadata cannot be encoded into valid ISO 8859-1" + ), + TextEncodingError::InvalidKeywordSize => write!(fmt, "Invalid keyword size"), + TextEncodingError::CompressionError => { + write!(fmt, "Unable to compress text metadata") + } + }, + } + } +} + +impl From<io::Error> for EncodingError { + fn from(err: io::Error) -> EncodingError { + EncodingError::IoError(err) + } +} + +impl From<EncodingError> for io::Error { + fn from(err: EncodingError) -> io::Error { + io::Error::new(io::ErrorKind::Other, err.to_string()) + } +} + +// Private impl. +impl From<FormatErrorKind> for FormatError { + fn from(kind: FormatErrorKind) -> Self { + FormatError { inner: kind } + } +} + +impl From<TextEncodingError> for EncodingError { + fn from(tee: TextEncodingError) -> Self { + EncodingError::Format(FormatError { + inner: FormatErrorKind::BadTextEncoding(tee), + }) + } +} + +/// PNG Encoder. +/// +/// This configures the PNG format options such as animation chunks, palette use, color types, +/// auxiliary chunks etc. +/// +/// FIXME: Configuring APNG might be easier (less individual errors) if we had an _adapter_ which +/// borrows this mutably but guarantees that `info.frame_control` is not `None`. +pub struct Encoder<'a, W: Write> { + w: W, + info: Info<'a>, + options: Options, +} + +/// Decoding options, internal type, forwarded to the Writer. +#[derive(Default)] +struct Options { + filter: FilterType, + adaptive_filter: AdaptiveFilterType, + sep_def_img: bool, + validate_sequence: bool, +} + +impl<'a, W: Write> Encoder<'a, W> { + pub fn new(w: W, width: u32, height: u32) -> Encoder<'static, W> { + Encoder { + w, + info: Info::with_size(width, height), + options: Options::default(), + } + } + + /// Specify that the image is animated. + /// + /// `num_frames` controls how many frames the animation has, while + /// `num_plays` controls how many times the animation should be + /// repeated until it stops, if it's zero then it will repeat + /// infinitely. + /// + /// When this method is returns successfully then the images written will be encoded as fdAT + /// chunks, except for the first image that is still encoded as `IDAT`. You can control if the + /// first frame should be treated as an animation frame with [`Encoder::set_sep_def_img()`]. + /// + /// This method returns an error if `num_frames` is 0. + pub fn set_animated(&mut self, num_frames: u32, num_plays: u32) -> Result<()> { + if num_frames == 0 { + return Err(EncodingError::Format(FormatErrorKind::ZeroFrames.into())); + } + + let actl = AnimationControl { + num_frames, + num_plays, + }; + + let fctl = FrameControl { + sequence_number: 0, + width: self.info.width, + height: self.info.height, + ..Default::default() + }; + + self.info.animation_control = Some(actl); + self.info.frame_control = Some(fctl); + Ok(()) + } + + /// Mark the first animated frame as a 'separate default image'. + /// + /// In APNG each animated frame is preceded by a special control chunk, `fcTL`. It's up to the + /// encoder to decide if the first image, the standard `IDAT` data, should be part of the + /// animation by emitting this chunk or by not doing so. A default image that is _not_ part of + /// the animation is often interpreted as a thumbnail. + /// + /// This method will return an error when animation control was not configured + /// (which is done by calling [`Encoder::set_animated`]). + pub fn set_sep_def_img(&mut self, sep_def_img: bool) -> Result<()> { + if self.info.animation_control.is_some() { + self.options.sep_def_img = sep_def_img; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Sets the raw byte contents of the PLTE chunk. This method accepts + /// both borrowed and owned byte data. + pub fn set_palette<T: Into<Cow<'a, [u8]>>>(&mut self, palette: T) { + self.info.palette = Some(palette.into()); + } + + /// Sets the raw byte contents of the tRNS chunk. This method accepts + /// both borrowed and owned byte data. + pub fn set_trns<T: Into<Cow<'a, [u8]>>>(&mut self, trns: T) { + self.info.trns = Some(trns.into()); + } + + /// Set the display gamma of the source system on which the image was generated or last edited. + pub fn set_source_gamma(&mut self, source_gamma: ScaledFloat) { + self.info.source_gamma = Some(source_gamma); + } + + /// Set the chromaticities for the source system's display channels (red, green, blue) and the whitepoint + /// of the source system on which the image was generated or last edited. + pub fn set_source_chromaticities( + &mut self, + source_chromaticities: super::SourceChromaticities, + ) { + self.info.source_chromaticities = Some(source_chromaticities); + } + + /// Mark the image data as conforming to the SRGB color space with the specified rendering intent. + /// + /// Matching source gamma and chromaticities chunks are added automatically. + /// Any manually specified source gamma or chromaticities will be ignored. + pub fn set_srgb(&mut self, rendering_intent: super::SrgbRenderingIntent) { + self.info.srgb = Some(rendering_intent); + } + + /// Start encoding by writing the header data. + /// + /// The remaining data can be supplied by methods on the returned [`Writer`]. + pub fn write_header(self) -> Result<Writer<W>> { + Writer::new(self.w, PartialInfo::new(&self.info), self.options).init(&self.info) + } + + /// Set the color of the encoded image. + /// + /// These correspond to the color types in the png IHDR data that will be written. The length + /// of the image data that is later supplied must match the color type, otherwise an error will + /// be emitted. + pub fn set_color(&mut self, color: ColorType) { + self.info.color_type = color; + } + + /// Set the indicated depth of the image data. + pub fn set_depth(&mut self, depth: BitDepth) { + self.info.bit_depth = depth; + } + + /// Set compression parameters. + /// + /// Accepts a `Compression` or any type that can transform into a `Compression`. Notably `deflate::Compression` and + /// `deflate::CompressionOptions` which "just work". + pub fn set_compression(&mut self, compression: Compression) { + self.info.compression = compression; + } + + /// Set the used filter type. + /// + /// The default filter is [`FilterType::Sub`] which provides a basic prediction algorithm for + /// sample values based on the previous. For a potentially better compression ratio, at the + /// cost of more complex processing, try out [`FilterType::Paeth`]. + /// + /// [`FilterType::Sub`]: enum.FilterType.html#variant.Sub + /// [`FilterType::Paeth`]: enum.FilterType.html#variant.Paeth + pub fn set_filter(&mut self, filter: FilterType) { + self.options.filter = filter; + } + + /// Set the adaptive filter type. + /// + /// Adaptive filtering attempts to select the best filter for each line + /// based on heuristics which minimize the file size for compression rather + /// than use a single filter for the entire image. The default method is + /// [`AdaptiveFilterType::NonAdaptive`]. + /// + /// [`AdaptiveFilterType::NonAdaptive`]: enum.AdaptiveFilterType.html + pub fn set_adaptive_filter(&mut self, adaptive_filter: AdaptiveFilterType) { + self.options.adaptive_filter = adaptive_filter; + } + + /// Set the fraction of time every frame is going to be displayed, in seconds. + /// + /// *Note that this parameter can be set for each individual frame after + /// [`Encoder::write_header`] is called. (see [`Writer::set_frame_delay`])* + /// + /// If the denominator is 0, it is to be treated as if it were 100 + /// (that is, the numerator then specifies 1/100ths of a second). + /// If the the value of the numerator is 0 the decoder should render the next frame + /// as quickly as possible, though viewers may impose a reasonable lower bound. + /// + /// The default value is 0 for both the numerator and denominator. + /// + /// This method will return an error if the image is not animated. + /// (see [`set_animated`]) + /// + /// [`write_header`]: struct.Encoder.html#method.write_header + /// [`set_animated`]: struct.Encoder.html#method.set_animated + /// [`Writer::set_frame_delay`]: struct.Writer#method.set_frame_delay + pub fn set_frame_delay(&mut self, numerator: u16, denominator: u16) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.delay_den = denominator; + fctl.delay_num = numerator; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the blend operation for every frame. + /// + /// The blend operation specifies whether the frame is to be alpha blended + /// into the current output buffer content, or whether it should completely + /// replace its region in the output buffer. + /// + /// *Note that this parameter can be set for each individual frame after + /// [`write_header`] is called. (see [`Writer::set_blend_op`])* + /// + /// See the [`BlendOp`] documentation for the possible values and their effects. + /// + /// *Note that for the first frame the two blend modes are functionally + /// equivalent due to the clearing of the output buffer at the beginning + /// of each play.* + /// + /// The default value is [`BlendOp::Source`]. + /// + /// This method will return an error if the image is not animated. + /// (see [`set_animated`]) + /// + /// [`BlendOP`]: enum.BlendOp.html + /// [`BlendOP::Source`]: enum.BlendOp.html#variant.Source + /// [`write_header`]: struct.Encoder.html#method.write_header + /// [`set_animated`]: struct.Encoder.html#method.set_animated + /// [`Writer::set_blend_op`]: struct.Writer#method.set_blend_op + pub fn set_blend_op(&mut self, op: BlendOp) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.blend_op = op; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the dispose operation for every frame. + /// + /// The dispose operation specifies how the output buffer should be changed + /// at the end of the delay (before rendering the next frame) + /// + /// *Note that this parameter can be set for each individual frame after + /// [`write_header`] is called (see [`Writer::set_dispose_op`])* + /// + /// See the [`DisposeOp`] documentation for the possible values and their effects. + /// + /// *Note that if the first frame uses [`DisposeOp::Previous`] + /// it will be treated as [`DisposeOp::Background`].* + /// + /// The default value is [`DisposeOp::None`]. + /// + /// This method will return an error if the image is not animated. + /// (see [`set_animated`]) + /// + /// [`DisposeOp`]: ../common/enum.BlendOp.html + /// [`DisposeOp::Previous`]: ../common/enum.BlendOp.html#variant.Previous + /// [`DisposeOp::Background`]: ../common/enum.BlendOp.html#variant.Background + /// [`DisposeOp::None`]: ../common/enum.BlendOp.html#variant.None + /// [`write_header`]: struct.Encoder.html#method.write_header + /// [`set_animated`]: struct.Encoder.html#method.set_animated + /// [`Writer::set_dispose_op`]: struct.Writer#method.set_dispose_op + pub fn set_dispose_op(&mut self, op: DisposeOp) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.dispose_op = op; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + pub fn set_pixel_dims(&mut self, pixel_dims: Option<PixelDimensions>) { + self.info.pixel_dims = pixel_dims + } + /// Convenience function to add tEXt chunks to [`Info`] struct + pub fn add_text_chunk(&mut self, keyword: String, text: String) -> Result<()> { + let text_chunk = TEXtChunk::new(keyword, text); + self.info.uncompressed_latin1_text.push(text_chunk); + Ok(()) + } + + /// Convenience function to add zTXt chunks to [`Info`] struct + pub fn add_ztxt_chunk(&mut self, keyword: String, text: String) -> Result<()> { + let text_chunk = ZTXtChunk::new(keyword, text); + self.info.compressed_latin1_text.push(text_chunk); + Ok(()) + } + + /// Convenience function to add iTXt chunks to [`Info`] struct + /// + /// This function only sets the `keyword` and `text` field of the iTXt chunk. + /// To set the other fields, create a [`ITXtChunk`] directly, and then encode it to the output stream. + pub fn add_itxt_chunk(&mut self, keyword: String, text: String) -> Result<()> { + let text_chunk = ITXtChunk::new(keyword, text); + self.info.utf8_text.push(text_chunk); + Ok(()) + } + + /// Validate the written image sequence. + /// + /// When validation is turned on (it's turned off by default) then attempts to write more than + /// one `IDAT` image or images beyond the number of frames indicated in the animation control + /// chunk will fail and return an error result instead. Attempts to [finish][finish] the image + /// with missing frames will also return an error. + /// + /// [finish]: StreamWriter::finish + /// + /// (It's possible to circumvent these checks by writing raw chunks instead.) + pub fn validate_sequence(&mut self, validate: bool) { + self.options.validate_sequence = validate; + } +} + +/// PNG writer +/// +/// Progresses through the image by writing images, frames, or raw individual chunks. This is +/// constructed through [`Encoder::write_header()`]. +/// +/// FIXME: Writing of animated chunks might be clearer if we had an _adapter_ that you would call +/// to guarantee the next image to be prefaced with a fcTL-chunk, and all other chunks would be +/// guaranteed to be `IDAT`/not affected by APNG's frame control. +pub struct Writer<W: Write> { + /// The underlying writer. + w: W, + /// The local version of the `Info` struct. + info: PartialInfo, + /// Global encoding options. + options: Options, + /// The total number of image frames, counting all consecutive IDAT and fdAT chunks. + images_written: u64, + /// The total number of animation frames, that is equivalent to counting fcTL chunks. + animation_written: u32, + /// A flag to note when the IEND chunk was already added. + /// This is only set on code paths that drop `Self` to control the destructor. + iend_written: bool, +} + +/// Contains the subset of attributes of [Info] needed for [Writer] to function +struct PartialInfo { + width: u32, + height: u32, + bit_depth: BitDepth, + color_type: ColorType, + frame_control: Option<FrameControl>, + animation_control: Option<AnimationControl>, + compression: Compression, + has_palette: bool, +} + +impl PartialInfo { + fn new(info: &Info) -> Self { + PartialInfo { + width: info.width, + height: info.height, + bit_depth: info.bit_depth, + color_type: info.color_type, + frame_control: info.frame_control, + animation_control: info.animation_control, + compression: info.compression, + has_palette: info.palette.is_some(), + } + } + + fn bpp_in_prediction(&self) -> BytesPerPixel { + // Passthrough + self.to_info().bpp_in_prediction() + } + + fn raw_row_length(&self) -> usize { + // Passthrough + self.to_info().raw_row_length() + } + + fn raw_row_length_from_width(&self, width: u32) -> usize { + // Passthrough + self.to_info().raw_row_length_from_width(width) + } + + /// Converts this partial info to an owned Info struct, + /// setting missing values to their defaults + fn to_info(&self) -> Info<'static> { + Info { + width: self.width, + height: self.height, + bit_depth: self.bit_depth, + color_type: self.color_type, + frame_control: self.frame_control, + animation_control: self.animation_control, + compression: self.compression, + ..Default::default() + } + } +} + +const DEFAULT_BUFFER_LENGTH: usize = 4 * 1024; + +pub(crate) fn write_chunk<W: Write>(mut w: W, name: chunk::ChunkType, data: &[u8]) -> Result<()> { + w.write_be(data.len() as u32)?; + w.write_all(&name.0)?; + w.write_all(data)?; + let mut crc = Crc32::new(); + crc.update(&name.0); + crc.update(data); + w.write_be(crc.finalize())?; + Ok(()) +} + +impl<W: Write> Writer<W> { + fn new(w: W, info: PartialInfo, options: Options) -> Writer<W> { + Writer { + w, + info, + options, + images_written: 0, + animation_written: 0, + iend_written: false, + } + } + + fn init(mut self, info: &Info<'_>) -> Result<Self> { + if self.info.width == 0 { + return Err(EncodingError::Format(FormatErrorKind::ZeroWidth.into())); + } + + if self.info.height == 0 { + return Err(EncodingError::Format(FormatErrorKind::ZeroHeight.into())); + } + + if self + .info + .color_type + .is_combination_invalid(self.info.bit_depth) + { + return Err(EncodingError::Format( + FormatErrorKind::InvalidColorCombination(self.info.bit_depth, self.info.color_type) + .into(), + )); + } + + self.w.write_all(&[137, 80, 78, 71, 13, 10, 26, 10])?; // PNG signature + info.encode(&mut self.w)?; + + Ok(self) + } + + /// Write a raw chunk of PNG data. + /// + /// The chunk will have its CRC calculated and correctly. The data is not filtered in any way, + /// but the chunk needs to be short enough to have its length encoded correctly. + pub fn write_chunk(&mut self, name: ChunkType, data: &[u8]) -> Result<()> { + use std::convert::TryFrom; + + if u32::try_from(data.len()).map_or(true, |length| length > i32::MAX as u32) { + let kind = FormatErrorKind::WrittenTooMuch(data.len() - i32::MAX as usize); + return Err(EncodingError::Format(kind.into())); + } + + write_chunk(&mut self.w, name, data) + } + + pub fn write_text_chunk<T: EncodableTextChunk>(&mut self, text_chunk: &T) -> Result<()> { + text_chunk.encode(&mut self.w) + } + + /// Check if we should allow writing another image. + fn validate_new_image(&self) -> Result<()> { + if !self.options.validate_sequence { + return Ok(()); + } + + match self.info.animation_control { + None => { + if self.images_written == 0 { + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::EndReached.into())) + } + } + Some(_) => { + if self.info.frame_control.is_some() { + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::EndReached.into())) + } + } + } + } + + fn validate_sequence_done(&self) -> Result<()> { + if !self.options.validate_sequence { + return Ok(()); + } + + if (self.info.animation_control.is_some() && self.info.frame_control.is_some()) + || self.images_written == 0 + { + Err(EncodingError::Format(FormatErrorKind::MissingFrames.into())) + } else { + Ok(()) + } + } + + const MAX_IDAT_CHUNK_LEN: u32 = std::u32::MAX >> 1; + #[allow(non_upper_case_globals)] + const MAX_fdAT_CHUNK_LEN: u32 = (std::u32::MAX >> 1) - 4; + + /// Writes the next image data. + pub fn write_image_data(&mut self, data: &[u8]) -> Result<()> { + if self.info.color_type == ColorType::Indexed && !self.info.has_palette { + return Err(EncodingError::Format(FormatErrorKind::NoPalette.into())); + } + + self.validate_new_image()?; + + let width: usize; + let height: usize; + if let Some(ref mut fctl) = self.info.frame_control { + width = fctl.width as usize; + height = fctl.height as usize; + } else { + width = self.info.width as usize; + height = self.info.height as usize; + } + + let in_len = self.info.raw_row_length_from_width(width as u32) - 1; + let data_size = in_len * height; + if data_size != data.len() { + return Err(EncodingError::Parameter( + ParameterErrorKind::ImageBufferSize { + expected: data_size, + actual: data.len(), + } + .into(), + )); + } + + let prev = vec![0; in_len]; + let mut prev = prev.as_slice(); + + let bpp = self.info.bpp_in_prediction(); + let filter_method = self.options.filter; + let adaptive_method = self.options.adaptive_filter; + + let zlib_encoded = match self.info.compression { + Compression::Fast => { + let mut compressor = fdeflate::Compressor::new(std::io::Cursor::new(Vec::new()))?; + + let mut current = vec![0; in_len + 1]; + for line in data.chunks(in_len) { + let filter_type = filter( + filter_method, + adaptive_method, + bpp, + prev, + line, + &mut current[1..], + ); + + current[0] = filter_type as u8; + compressor.write_data(¤t)?; + prev = line; + } + + let compressed = compressor.finish()?.into_inner(); + if compressed.len() + > fdeflate::StoredOnlyCompressor::<()>::compressed_size((in_len + 1) * height) + { + // Write uncompressed data since the result from fast compression would take + // more space than that. + // + // We always use FilterType::NoFilter here regardless of the filter method + // requested by the user. Doing filtering again would only add performance + // cost for both encoding and subsequent decoding, without improving the + // compression ratio. + let mut compressor = + fdeflate::StoredOnlyCompressor::new(std::io::Cursor::new(Vec::new()))?; + for line in data.chunks(in_len) { + compressor.write_data(&[0])?; + compressor.write_data(line)?; + } + compressor.finish()?.into_inner() + } else { + compressed + } + } + _ => { + let mut current = vec![0; in_len]; + + let mut zlib = ZlibEncoder::new(Vec::new(), self.info.compression.to_options()); + for line in data.chunks(in_len) { + let filter_type = filter( + filter_method, + adaptive_method, + bpp, + prev, + line, + &mut current, + ); + + zlib.write_all(&[filter_type as u8])?; + zlib.write_all(¤t)?; + prev = line; + } + zlib.finish()? + } + }; + + match self.info.frame_control { + None => { + self.write_zlib_encoded_idat(&zlib_encoded)?; + } + Some(_) if self.should_skip_frame_control_on_default_image() => { + self.write_zlib_encoded_idat(&zlib_encoded)?; + } + Some(ref mut fctl) => { + fctl.encode(&mut self.w)?; + fctl.sequence_number = fctl.sequence_number.wrapping_add(1); + self.animation_written += 1; + + // If the default image is the first frame of an animation, it's still an IDAT. + if self.images_written == 0 { + self.write_zlib_encoded_idat(&zlib_encoded)?; + } else { + let buff_size = zlib_encoded.len().min(Self::MAX_fdAT_CHUNK_LEN as usize); + let mut alldata = vec![0u8; 4 + buff_size]; + for chunk in zlib_encoded.chunks(Self::MAX_fdAT_CHUNK_LEN as usize) { + alldata[..4].copy_from_slice(&fctl.sequence_number.to_be_bytes()); + alldata[4..][..chunk.len()].copy_from_slice(chunk); + write_chunk(&mut self.w, chunk::fdAT, &alldata[..4 + chunk.len()])?; + fctl.sequence_number = fctl.sequence_number.wrapping_add(1); + } + } + } + } + + self.increment_images_written(); + + Ok(()) + } + + fn increment_images_written(&mut self) { + self.images_written = self.images_written.saturating_add(1); + + if let Some(actl) = self.info.animation_control { + if actl.num_frames <= self.animation_written { + // If we've written all animation frames, all following will be normal image chunks. + self.info.frame_control = None; + } + } + } + + fn write_iend(&mut self) -> Result<()> { + self.iend_written = true; + self.write_chunk(chunk::IEND, &[]) + } + + fn should_skip_frame_control_on_default_image(&self) -> bool { + self.options.sep_def_img && self.images_written == 0 + } + + fn write_zlib_encoded_idat(&mut self, zlib_encoded: &[u8]) -> Result<()> { + for chunk in zlib_encoded.chunks(Self::MAX_IDAT_CHUNK_LEN as usize) { + self.write_chunk(chunk::IDAT, chunk)?; + } + Ok(()) + } + + /// Set the used filter type for the following frames. + /// + /// The default filter is [`FilterType::Sub`] which provides a basic prediction algorithm for + /// sample values based on the previous. For a potentially better compression ratio, at the + /// cost of more complex processing, try out [`FilterType::Paeth`]. + /// + /// [`FilterType::Sub`]: enum.FilterType.html#variant.Sub + /// [`FilterType::Paeth`]: enum.FilterType.html#variant.Paeth + pub fn set_filter(&mut self, filter: FilterType) { + self.options.filter = filter; + } + + /// Set the adaptive filter type for the following frames. + /// + /// Adaptive filtering attempts to select the best filter for each line + /// based on heuristics which minimize the file size for compression rather + /// than use a single filter for the entire image. The default method is + /// [`AdaptiveFilterType::NonAdaptive`]. + /// + /// [`AdaptiveFilterType::NonAdaptive`]: enum.AdaptiveFilterType.html + pub fn set_adaptive_filter(&mut self, adaptive_filter: AdaptiveFilterType) { + self.options.adaptive_filter = adaptive_filter; + } + + /// Set the fraction of time the following frames are going to be displayed, + /// in seconds + /// + /// If the denominator is 0, it is to be treated as if it were 100 + /// (that is, the numerator then specifies 1/100ths of a second). + /// If the the value of the numerator is 0 the decoder should render the next frame + /// as quickly as possible, though viewers may impose a reasonable lower bound. + /// + /// This method will return an error if the image is not animated. + pub fn set_frame_delay(&mut self, numerator: u16, denominator: u16) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.delay_den = denominator; + fctl.delay_num = numerator; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the dimension of the following frames. + /// + /// This function will return an error when: + /// - The image is not an animated; + /// + /// - The selected dimension, considering also the current frame position, + /// goes outside the image boundaries; + /// + /// - One or both the width and height are 0; + /// + // ??? TODO ??? + // - The next frame is the default image + pub fn set_frame_dimension(&mut self, width: u32, height: u32) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + if Some(width) > self.info.width.checked_sub(fctl.x_offset) + || Some(height) > self.info.height.checked_sub(fctl.y_offset) + { + return Err(EncodingError::Format(FormatErrorKind::OutOfBounds.into())); + } else if width == 0 { + return Err(EncodingError::Format(FormatErrorKind::ZeroWidth.into())); + } else if height == 0 { + return Err(EncodingError::Format(FormatErrorKind::ZeroHeight.into())); + } + fctl.width = width; + fctl.height = height; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the position of the following frames. + /// + /// An error will be returned if: + /// - The image is not animated; + /// + /// - The selected position, considering also the current frame dimension, + /// goes outside the image boundaries; + /// + // ??? TODO ??? + // - The next frame is the default image + pub fn set_frame_position(&mut self, x: u32, y: u32) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + if Some(x) > self.info.width.checked_sub(fctl.width) + || Some(y) > self.info.height.checked_sub(fctl.height) + { + return Err(EncodingError::Format(FormatErrorKind::OutOfBounds.into())); + } + fctl.x_offset = x; + fctl.y_offset = y; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the frame dimension to occupy all the image, starting from + /// the current position. + /// + /// To reset the frame to the full image size [`reset_frame_position`] + /// should be called first. + /// + /// This method will return an error if the image is not animated. + /// + /// [`reset_frame_position`]: struct.Writer.html#method.reset_frame_position + pub fn reset_frame_dimension(&mut self) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.width = self.info.width - fctl.x_offset; + fctl.height = self.info.height - fctl.y_offset; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the frame position to (0, 0). + /// + /// Equivalent to calling [`set_frame_position(0, 0)`]. + /// + /// This method will return an error if the image is not animated. + /// + /// [`set_frame_position(0, 0)`]: struct.Writer.html#method.set_frame_position + pub fn reset_frame_position(&mut self) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.x_offset = 0; + fctl.y_offset = 0; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the blend operation for the following frames. + /// + /// The blend operation specifies whether the frame is to be alpha blended + /// into the current output buffer content, or whether it should completely + /// replace its region in the output buffer. + /// + /// See the [`BlendOp`] documentation for the possible values and their effects. + /// + /// *Note that for the first frame the two blend modes are functionally + /// equivalent due to the clearing of the output buffer at the beginning + /// of each play.* + /// + /// This method will return an error if the image is not animated. + /// + /// [`BlendOP`]: enum.BlendOp.html + pub fn set_blend_op(&mut self, op: BlendOp) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.blend_op = op; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the dispose operation for the following frames. + /// + /// The dispose operation specifies how the output buffer should be changed + /// at the end of the delay (before rendering the next frame) + /// + /// See the [`DisposeOp`] documentation for the possible values and their effects. + /// + /// *Note that if the first frame uses [`DisposeOp::Previous`] + /// it will be treated as [`DisposeOp::Background`].* + /// + /// This method will return an error if the image is not animated. + /// + /// [`DisposeOp`]: ../common/enum.BlendOp.html + /// [`DisposeOp::Previous`]: ../common/enum.BlendOp.html#variant.Previous + /// [`DisposeOp::Background`]: ../common/enum.BlendOp.html#variant.Background + pub fn set_dispose_op(&mut self, op: DisposeOp) -> Result<()> { + if let Some(ref mut fctl) = self.info.frame_control { + fctl.dispose_op = op; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Create a stream writer. + /// + /// This allows you to create images that do not fit in memory. The default + /// chunk size is 4K, use `stream_writer_with_size` to set another chunk + /// size. + /// + /// This borrows the writer which allows for manually appending additional + /// chunks after the image data has been written. + pub fn stream_writer(&mut self) -> Result<StreamWriter<W>> { + self.stream_writer_with_size(DEFAULT_BUFFER_LENGTH) + } + + /// Create a stream writer with custom buffer size. + /// + /// See [`stream_writer`]. + /// + /// [`stream_writer`]: #fn.stream_writer + pub fn stream_writer_with_size(&mut self, size: usize) -> Result<StreamWriter<W>> { + StreamWriter::new(ChunkOutput::Borrowed(self), size) + } + + /// Turn this into a stream writer for image data. + /// + /// This allows you to create images that do not fit in memory. The default + /// chunk size is 4K, use `stream_writer_with_size` to set another chunk + /// size. + pub fn into_stream_writer(self) -> Result<StreamWriter<'static, W>> { + self.into_stream_writer_with_size(DEFAULT_BUFFER_LENGTH) + } + + /// Turn this into a stream writer with custom buffer size. + /// + /// See [`into_stream_writer`]. + /// + /// [`into_stream_writer`]: #fn.into_stream_writer + pub fn into_stream_writer_with_size(self, size: usize) -> Result<StreamWriter<'static, W>> { + StreamWriter::new(ChunkOutput::Owned(self), size) + } + + /// Consume the stream writer with validation. + /// + /// Unlike a simple drop this ensures that the final chunk was written correctly. When other + /// validation options (chunk sequencing) had been turned on in the configuration then it will + /// also do a check on their correctness _before_ writing the final chunk. + pub fn finish(mut self) -> Result<()> { + self.validate_sequence_done()?; + self.write_iend()?; + self.w.flush()?; + + // Explicitly drop `self` just for clarity. + drop(self); + Ok(()) + } +} + +impl<W: Write> Drop for Writer<W> { + fn drop(&mut self) { + if !self.iend_written { + let _ = self.write_iend(); + } + } +} + +enum ChunkOutput<'a, W: Write> { + Borrowed(&'a mut Writer<W>), + Owned(Writer<W>), +} + +// opted for deref for practical reasons +impl<'a, W: Write> Deref for ChunkOutput<'a, W> { + type Target = Writer<W>; + + fn deref(&self) -> &Self::Target { + match self { + ChunkOutput::Borrowed(writer) => writer, + ChunkOutput::Owned(writer) => writer, + } + } +} + +impl<'a, W: Write> DerefMut for ChunkOutput<'a, W> { + fn deref_mut(&mut self) -> &mut Self::Target { + match self { + ChunkOutput::Borrowed(writer) => writer, + ChunkOutput::Owned(writer) => writer, + } + } +} + +/// This writer is used between the actual writer and the +/// ZlibEncoder and has the job of packaging the compressed +/// data into a PNG chunk, based on the image metadata +/// +/// Currently the way it works is that the specified buffer +/// will hold one chunk at the time and buffer the incoming +/// data until `flush` is called or the maximum chunk size +/// is reached. +/// +/// The maximum chunk is the smallest between the selected buffer size +/// and `u32::MAX >> 1` (`0x7fffffff` or `2147483647` dec) +/// +/// When a chunk has to be flushed the length (that is now known) +/// and the CRC will be written at the correct locations in the chunk. +struct ChunkWriter<'a, W: Write> { + writer: ChunkOutput<'a, W>, + buffer: Vec<u8>, + /// keeps track of where the last byte was written + index: usize, + curr_chunk: ChunkType, +} + +impl<'a, W: Write> ChunkWriter<'a, W> { + fn new(writer: ChunkOutput<'a, W>, buf_len: usize) -> ChunkWriter<'a, W> { + // currently buf_len will determine the size of each chunk + // the len is capped to the maximum size every chunk can hold + // (this wont ever overflow an u32) + // + // TODO (maybe): find a way to hold two chunks at a time if `usize` + // is 64 bits. + const CAP: usize = std::u32::MAX as usize >> 1; + let curr_chunk = if writer.images_written == 0 { + chunk::IDAT + } else { + chunk::fdAT + }; + ChunkWriter { + writer, + buffer: vec![0; CAP.min(buf_len)], + index: 0, + curr_chunk, + } + } + + /// Returns the size of each scanline for the next frame + /// paired with the size of the whole frame + /// + /// This is used by the `StreamWriter` to know when the scanline ends + /// so it can filter compress it and also to know when to start + /// the next one + fn next_frame_info(&self) -> (usize, usize) { + let wrt = self.writer.deref(); + + let width: usize; + let height: usize; + if let Some(fctl) = wrt.info.frame_control { + width = fctl.width as usize; + height = fctl.height as usize; + } else { + width = wrt.info.width as usize; + height = wrt.info.height as usize; + } + + let in_len = wrt.info.raw_row_length_from_width(width as u32) - 1; + let data_size = in_len * height; + + (in_len, data_size) + } + + /// NOTE: this bypasses the internal buffer so the flush method should be called before this + /// in the case there is some data left in the buffer when this is called, it will panic + fn write_header(&mut self) -> Result<()> { + assert_eq!(self.index, 0, "Called when not flushed"); + let wrt = self.writer.deref_mut(); + + self.curr_chunk = if wrt.images_written == 0 { + chunk::IDAT + } else { + chunk::fdAT + }; + + match wrt.info.frame_control { + Some(_) if wrt.should_skip_frame_control_on_default_image() => {} + Some(ref mut fctl) => { + fctl.encode(&mut wrt.w)?; + fctl.sequence_number += 1; + } + _ => {} + } + + Ok(()) + } + + /// Set the `FrameControl` for the following frame + /// + /// It will ignore the `sequence_number` of the parameter + /// as it is updated internally. + fn set_fctl(&mut self, f: FrameControl) { + if let Some(ref mut fctl) = self.writer.info.frame_control { + // Ignore the sequence number + *fctl = FrameControl { + sequence_number: fctl.sequence_number, + ..f + }; + } else { + panic!("This function must be called on an animated PNG") + } + } + + /// Flushes the current chunk + fn flush_inner(&mut self) -> io::Result<()> { + if self.index > 0 { + // flush the chunk and reset everything + write_chunk( + &mut self.writer.w, + self.curr_chunk, + &self.buffer[..self.index], + )?; + + self.index = 0; + } + Ok(()) + } +} + +impl<'a, W: Write> Write for ChunkWriter<'a, W> { + fn write(&mut self, mut data: &[u8]) -> io::Result<usize> { + if data.is_empty() { + return Ok(0); + } + + // index == 0 means a chunk has been flushed out + if self.index == 0 { + let wrt = self.writer.deref_mut(); + + // Prepare the next animated frame, if any. + let no_fctl = wrt.should_skip_frame_control_on_default_image(); + if wrt.info.frame_control.is_some() && !no_fctl { + let fctl = wrt.info.frame_control.as_mut().unwrap(); + self.buffer[0..4].copy_from_slice(&fctl.sequence_number.to_be_bytes()); + fctl.sequence_number += 1; + self.index = 4; + } + } + + // Cap the buffer length to the maximum number of bytes that can't still + // be added to the current chunk + let written = data.len().min(self.buffer.len() - self.index); + data = &data[..written]; + + self.buffer[self.index..][..written].copy_from_slice(data); + self.index += written; + + // if the maximum data for this chunk as been reached it needs to be flushed + if self.index == self.buffer.len() { + self.flush_inner()?; + } + + Ok(written) + } + + fn flush(&mut self) -> io::Result<()> { + self.flush_inner() + } +} + +impl<W: Write> Drop for ChunkWriter<'_, W> { + fn drop(&mut self) { + let _ = self.flush(); + } +} + +// TODO: find a better name +// +/// This enum is used to be allow the `StreamWriter` to keep +/// its inner `ChunkWriter` without wrapping it inside a +/// `ZlibEncoder`. This is used in the case that between the +/// change of state that happens when the last write of a frame +/// is performed an error occurs, which obviously has to be returned. +/// This creates the problem of where to store the writer before +/// exiting the function, and this is where `Wrapper` comes in. +/// +/// Unfortunately the `ZlibWriter` can't be used because on the +/// write following the error, `finish` would be called and that +/// would write some data even if 0 bytes where compressed. +/// +/// If the `finish` function fails then there is nothing much to +/// do as the `ChunkWriter` would get lost so the `Unrecoverable` +/// variant is used to signal that. +enum Wrapper<'a, W: Write> { + Chunk(ChunkWriter<'a, W>), + Zlib(ZlibEncoder<ChunkWriter<'a, W>>), + Unrecoverable, + /// This is used in-between, should never be matched + None, +} + +impl<'a, W: Write> Wrapper<'a, W> { + /// Like `Option::take` this returns the `Wrapper` contained + /// in `self` and replaces it with `Wrapper::None` + fn take(&mut self) -> Wrapper<'a, W> { + let mut swap = Wrapper::None; + mem::swap(self, &mut swap); + swap + } +} + +/// Streaming PNG writer +/// +/// This may silently fail in the destructor, so it is a good idea to call +/// [`finish`](#method.finish) or [`flush`] before dropping. +/// +/// [`flush`]: https://doc.rust-lang.org/stable/std/io/trait.Write.html#tymethod.flush +pub struct StreamWriter<'a, W: Write> { + /// The option here is needed in order to access the inner `ChunkWriter` in-between + /// each frame, which is needed for writing the fcTL chunks between each frame + writer: Wrapper<'a, W>, + prev_buf: Vec<u8>, + curr_buf: Vec<u8>, + /// Amount of data already written + index: usize, + /// length of the current scanline + line_len: usize, + /// size of the frame (width * height * sample_size) + to_write: usize, + + width: u32, + height: u32, + + bpp: BytesPerPixel, + filter: FilterType, + adaptive_filter: AdaptiveFilterType, + fctl: Option<FrameControl>, + compression: Compression, +} + +impl<'a, W: Write> StreamWriter<'a, W> { + fn new(writer: ChunkOutput<'a, W>, buf_len: usize) -> Result<StreamWriter<'a, W>> { + let PartialInfo { + width, + height, + frame_control: fctl, + compression, + .. + } = writer.info; + + let bpp = writer.info.bpp_in_prediction(); + let in_len = writer.info.raw_row_length() - 1; + let filter = writer.options.filter; + let adaptive_filter = writer.options.adaptive_filter; + let prev_buf = vec![0; in_len]; + let curr_buf = vec![0; in_len]; + + let mut chunk_writer = ChunkWriter::new(writer, buf_len); + let (line_len, to_write) = chunk_writer.next_frame_info(); + chunk_writer.write_header()?; + let zlib = ZlibEncoder::new(chunk_writer, compression.to_options()); + + Ok(StreamWriter { + writer: Wrapper::Zlib(zlib), + index: 0, + prev_buf, + curr_buf, + bpp, + filter, + width, + height, + adaptive_filter, + line_len, + to_write, + fctl, + compression, + }) + } + + /// Set the used filter type for the next frame. + /// + /// The default filter is [`FilterType::Sub`] which provides a basic prediction algorithm for + /// sample values based on the previous. For a potentially better compression ratio, at the + /// cost of more complex processing, try out [`FilterType::Paeth`]. + /// + /// [`FilterType::Sub`]: enum.FilterType.html#variant.Sub + /// [`FilterType::Paeth`]: enum.FilterType.html#variant.Paeth + pub fn set_filter(&mut self, filter: FilterType) { + self.filter = filter; + } + + /// Set the adaptive filter type for the next frame. + /// + /// Adaptive filtering attempts to select the best filter for each line + /// based on heuristics which minimize the file size for compression rather + /// than use a single filter for the entire image. The default method is + /// [`AdaptiveFilterType::NonAdaptive`]. + /// + /// [`AdaptiveFilterType::NonAdaptive`]: enum.AdaptiveFilterType.html + pub fn set_adaptive_filter(&mut self, adaptive_filter: AdaptiveFilterType) { + self.adaptive_filter = adaptive_filter; + } + + /// Set the fraction of time the following frames are going to be displayed, + /// in seconds + /// + /// If the denominator is 0, it is to be treated as if it were 100 + /// (that is, the numerator then specifies 1/100ths of a second). + /// If the the value of the numerator is 0 the decoder should render the next frame + /// as quickly as possible, though viewers may impose a reasonable lower bound. + /// + /// This method will return an error if the image is not animated. + pub fn set_frame_delay(&mut self, numerator: u16, denominator: u16) -> Result<()> { + if let Some(ref mut fctl) = self.fctl { + fctl.delay_den = denominator; + fctl.delay_num = numerator; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the dimension of the following frames. + /// + /// This function will return an error when: + /// - The image is not an animated; + /// + /// - The selected dimension, considering also the current frame position, + /// goes outside the image boundaries; + /// + /// - One or both the width and height are 0; + /// + pub fn set_frame_dimension(&mut self, width: u32, height: u32) -> Result<()> { + if let Some(ref mut fctl) = self.fctl { + if Some(width) > self.width.checked_sub(fctl.x_offset) + || Some(height) > self.height.checked_sub(fctl.y_offset) + { + return Err(EncodingError::Format(FormatErrorKind::OutOfBounds.into())); + } else if width == 0 { + return Err(EncodingError::Format(FormatErrorKind::ZeroWidth.into())); + } else if height == 0 { + return Err(EncodingError::Format(FormatErrorKind::ZeroHeight.into())); + } + fctl.width = width; + fctl.height = height; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the position of the following frames. + /// + /// An error will be returned if: + /// - The image is not animated; + /// + /// - The selected position, considering also the current frame dimension, + /// goes outside the image boundaries; + /// + pub fn set_frame_position(&mut self, x: u32, y: u32) -> Result<()> { + if let Some(ref mut fctl) = self.fctl { + if Some(x) > self.width.checked_sub(fctl.width) + || Some(y) > self.height.checked_sub(fctl.height) + { + return Err(EncodingError::Format(FormatErrorKind::OutOfBounds.into())); + } + fctl.x_offset = x; + fctl.y_offset = y; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the frame dimension to occupy all the image, starting from + /// the current position. + /// + /// To reset the frame to the full image size [`reset_frame_position`] + /// should be called first. + /// + /// This method will return an error if the image is not animated. + /// + /// [`reset_frame_position`]: struct.Writer.html#method.reset_frame_position + pub fn reset_frame_dimension(&mut self) -> Result<()> { + if let Some(ref mut fctl) = self.fctl { + fctl.width = self.width - fctl.x_offset; + fctl.height = self.height - fctl.y_offset; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the frame position to (0, 0). + /// + /// Equivalent to calling [`set_frame_position(0, 0)`]. + /// + /// This method will return an error if the image is not animated. + /// + /// [`set_frame_position(0, 0)`]: struct.Writer.html#method.set_frame_position + pub fn reset_frame_position(&mut self) -> Result<()> { + if let Some(ref mut fctl) = self.fctl { + fctl.x_offset = 0; + fctl.y_offset = 0; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the blend operation for the following frames. + /// + /// The blend operation specifies whether the frame is to be alpha blended + /// into the current output buffer content, or whether it should completely + /// replace its region in the output buffer. + /// + /// See the [`BlendOp`] documentation for the possible values and their effects. + /// + /// *Note that for the first frame the two blend modes are functionally + /// equivalent due to the clearing of the output buffer at the beginning + /// of each play.* + /// + /// This method will return an error if the image is not animated. + /// + /// [`BlendOP`]: enum.BlendOp.html + pub fn set_blend_op(&mut self, op: BlendOp) -> Result<()> { + if let Some(ref mut fctl) = self.fctl { + fctl.blend_op = op; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + /// Set the dispose operation for the following frames. + /// + /// The dispose operation specifies how the output buffer should be changed + /// at the end of the delay (before rendering the next frame) + /// + /// See the [`DisposeOp`] documentation for the possible values and their effects. + /// + /// *Note that if the first frame uses [`DisposeOp::Previous`] + /// it will be treated as [`DisposeOp::Background`].* + /// + /// This method will return an error if the image is not animated. + /// + /// [`DisposeOp`]: ../common/enum.BlendOp.html + /// [`DisposeOp::Previous`]: ../common/enum.BlendOp.html#variant.Previous + /// [`DisposeOp::Background`]: ../common/enum.BlendOp.html#variant.Background + pub fn set_dispose_op(&mut self, op: DisposeOp) -> Result<()> { + if let Some(ref mut fctl) = self.fctl { + fctl.dispose_op = op; + Ok(()) + } else { + Err(EncodingError::Format(FormatErrorKind::NotAnimated.into())) + } + } + + pub fn finish(mut self) -> Result<()> { + if self.to_write > 0 { + let err = FormatErrorKind::MissingData(self.to_write).into(); + return Err(EncodingError::Format(err)); + } + + // TODO: call `writer.finish` somehow? + self.flush()?; + + if let Wrapper::Chunk(wrt) = self.writer.take() { + wrt.writer.validate_sequence_done()?; + } + + Ok(()) + } + + /// Flushes the buffered chunk, checks if it was the last frame, + /// writes the next frame header and gets the next frame scanline size + /// and image size. + /// NOTE: This method must only be called when the writer is the variant Chunk(_) + fn new_frame(&mut self) -> Result<()> { + let wrt = match &mut self.writer { + Wrapper::Chunk(wrt) => wrt, + Wrapper::Unrecoverable => { + let err = FormatErrorKind::Unrecoverable.into(); + return Err(EncodingError::Format(err)); + } + Wrapper::Zlib(_) => unreachable!("never called on a half-finished frame"), + Wrapper::None => unreachable!(), + }; + wrt.flush()?; + wrt.writer.validate_new_image()?; + + if let Some(fctl) = self.fctl { + wrt.set_fctl(fctl); + } + let (scansize, size) = wrt.next_frame_info(); + self.line_len = scansize; + self.to_write = size; + + wrt.write_header()?; + wrt.writer.increment_images_written(); + + // now it can be taken because the next statements cannot cause any errors + match self.writer.take() { + Wrapper::Chunk(wrt) => { + let encoder = ZlibEncoder::new(wrt, self.compression.to_options()); + self.writer = Wrapper::Zlib(encoder); + } + _ => unreachable!(), + }; + + Ok(()) + } +} + +impl<'a, W: Write> Write for StreamWriter<'a, W> { + fn write(&mut self, mut data: &[u8]) -> io::Result<usize> { + if let Wrapper::Unrecoverable = self.writer { + let err = FormatErrorKind::Unrecoverable.into(); + return Err(EncodingError::Format(err).into()); + } + + if data.is_empty() { + return Ok(0); + } + + if self.to_write == 0 { + match self.writer.take() { + Wrapper::Zlib(wrt) => match wrt.finish() { + Ok(chunk) => self.writer = Wrapper::Chunk(chunk), + Err(err) => { + self.writer = Wrapper::Unrecoverable; + return Err(err); + } + }, + chunk @ Wrapper::Chunk(_) => self.writer = chunk, + Wrapper::Unrecoverable => unreachable!(), + Wrapper::None => unreachable!(), + }; + + // Transition Wrapper::Chunk to Wrapper::Zlib. + self.new_frame()?; + } + + let written = data.read(&mut self.curr_buf[..self.line_len][self.index..])?; + self.index += written; + self.to_write -= written; + + if self.index == self.line_len { + // TODO: reuse this buffer between rows. + let mut filtered = vec![0; self.curr_buf.len()]; + let filter_type = filter( + self.filter, + self.adaptive_filter, + self.bpp, + &self.prev_buf, + &self.curr_buf, + &mut filtered, + ); + // This can't fail as the other variant is used only to allow the zlib encoder to finish + let wrt = match &mut self.writer { + Wrapper::Zlib(wrt) => wrt, + _ => unreachable!(), + }; + + wrt.write_all(&[filter_type as u8])?; + wrt.write_all(&filtered)?; + mem::swap(&mut self.prev_buf, &mut self.curr_buf); + self.index = 0; + } + + Ok(written) + } + + fn flush(&mut self) -> io::Result<()> { + match &mut self.writer { + Wrapper::Zlib(wrt) => wrt.flush()?, + Wrapper::Chunk(wrt) => wrt.flush()?, + // This handles both the case where we entered an unrecoverable state after zlib + // decoding failure and after a panic while we had taken the chunk/zlib reader. + Wrapper::Unrecoverable | Wrapper::None => { + let err = FormatErrorKind::Unrecoverable.into(); + return Err(EncodingError::Format(err).into()); + } + } + + if self.index > 0 { + let err = FormatErrorKind::WrittenTooMuch(self.index).into(); + return Err(EncodingError::Format(err).into()); + } + + Ok(()) + } +} + +impl<W: Write> Drop for StreamWriter<'_, W> { + fn drop(&mut self) { + let _ = self.flush(); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::Decoder; + + use rand::{thread_rng, Rng}; + use std::fs::File; + use std::io::{Cursor, Write}; + use std::{cmp, io}; + + #[test] + fn roundtrip() { + // More loops = more random testing, but also more test wait time + for _ in 0..10 { + for path in glob::glob("tests/pngsuite/*.png") + .unwrap() + .map(|r| r.unwrap()) + { + if path.file_name().unwrap().to_str().unwrap().starts_with('x') { + // x* files are expected to fail to decode + continue; + } + eprintln!("{}", path.display()); + // Decode image + let decoder = Decoder::new(File::open(path).unwrap()); + let mut reader = decoder.read_info().unwrap(); + let mut buf = vec![0; reader.output_buffer_size()]; + let info = reader.next_frame(&mut buf).unwrap(); + // Encode decoded image + let mut out = Vec::new(); + { + let mut wrapper = RandomChunkWriter { + rng: thread_rng(), + w: &mut out, + }; + + let mut encoder = Encoder::new(&mut wrapper, info.width, info.height); + encoder.set_color(info.color_type); + encoder.set_depth(info.bit_depth); + if let Some(palette) = &reader.info().palette { + encoder.set_palette(palette.clone()); + } + let mut encoder = encoder.write_header().unwrap(); + encoder.write_image_data(&buf).unwrap(); + } + // Decode encoded decoded image + let decoder = Decoder::new(&*out); + let mut reader = decoder.read_info().unwrap(); + let mut buf2 = vec![0; reader.output_buffer_size()]; + reader.next_frame(&mut buf2).unwrap(); + // check if the encoded image is ok: + assert_eq!(buf, buf2); + } + } + } + + #[test] + fn roundtrip_stream() { + // More loops = more random testing, but also more test wait time + for _ in 0..10 { + for path in glob::glob("tests/pngsuite/*.png") + .unwrap() + .map(|r| r.unwrap()) + { + if path.file_name().unwrap().to_str().unwrap().starts_with('x') { + // x* files are expected to fail to decode + continue; + } + // Decode image + let decoder = Decoder::new(File::open(path).unwrap()); + let mut reader = decoder.read_info().unwrap(); + let mut buf = vec![0; reader.output_buffer_size()]; + let info = reader.next_frame(&mut buf).unwrap(); + // Encode decoded image + let mut out = Vec::new(); + { + let mut wrapper = RandomChunkWriter { + rng: thread_rng(), + w: &mut out, + }; + + let mut encoder = Encoder::new(&mut wrapper, info.width, info.height); + encoder.set_color(info.color_type); + encoder.set_depth(info.bit_depth); + if let Some(palette) = &reader.info().palette { + encoder.set_palette(palette.clone()); + } + let mut encoder = encoder.write_header().unwrap(); + let mut stream_writer = encoder.stream_writer().unwrap(); + + let mut outer_wrapper = RandomChunkWriter { + rng: thread_rng(), + w: &mut stream_writer, + }; + + outer_wrapper.write_all(&buf).unwrap(); + } + // Decode encoded decoded image + let decoder = Decoder::new(&*out); + let mut reader = decoder.read_info().unwrap(); + let mut buf2 = vec![0; reader.output_buffer_size()]; + reader.next_frame(&mut buf2).unwrap(); + // check if the encoded image is ok: + assert_eq!(buf, buf2); + } + } + } + + #[test] + fn image_palette() -> Result<()> { + for &bit_depth in &[1u8, 2, 4, 8] { + // Do a reference decoding, choose a fitting palette image from pngsuite + let path = format!("tests/pngsuite/basn3p0{}.png", bit_depth); + let decoder = Decoder::new(File::open(&path).unwrap()); + let mut reader = decoder.read_info().unwrap(); + + let mut decoded_pixels = vec![0; reader.output_buffer_size()]; + let info = reader.info(); + assert_eq!( + info.width as usize * info.height as usize * usize::from(bit_depth), + decoded_pixels.len() * 8 + ); + let info = reader.next_frame(&mut decoded_pixels).unwrap(); + let indexed_data = decoded_pixels; + + let palette = reader.info().palette.as_ref().unwrap(); + let mut out = Vec::new(); + { + let mut encoder = Encoder::new(&mut out, info.width, info.height); + encoder.set_depth(BitDepth::from_u8(bit_depth).unwrap()); + encoder.set_color(ColorType::Indexed); + encoder.set_palette(palette.as_ref()); + + let mut writer = encoder.write_header().unwrap(); + writer.write_image_data(&indexed_data).unwrap(); + } + + // Decode re-encoded image + let decoder = Decoder::new(&*out); + let mut reader = decoder.read_info().unwrap(); + let mut redecoded = vec![0; reader.output_buffer_size()]; + reader.next_frame(&mut redecoded).unwrap(); + // check if the encoded image is ok: + assert_eq!(indexed_data, redecoded); + } + Ok(()) + } + + #[test] + fn expect_error_on_wrong_image_len() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + let mut encoder = Encoder::new(writer, width as u32, height as u32); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Rgb); + let mut png_writer = encoder.write_header()?; + + let correct_image_size = width * height * 3; + let image = vec![0u8; correct_image_size + 1]; + let result = png_writer.write_image_data(image.as_ref()); + assert!(result.is_err()); + + Ok(()) + } + + #[test] + fn expect_error_on_empty_image() -> Result<()> { + let output = vec![0u8; 1024]; + let mut writer = Cursor::new(output); + + let encoder = Encoder::new(&mut writer, 0, 0); + assert!(encoder.write_header().is_err()); + + let encoder = Encoder::new(&mut writer, 100, 0); + assert!(encoder.write_header().is_err()); + + let encoder = Encoder::new(&mut writer, 0, 100); + assert!(encoder.write_header().is_err()); + + Ok(()) + } + + #[test] + fn expect_error_on_invalid_bit_depth_color_type_combination() -> Result<()> { + let output = vec![0u8; 1024]; + let mut writer = Cursor::new(output); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::One); + encoder.set_color(ColorType::Rgb); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::One); + encoder.set_color(ColorType::GrayscaleAlpha); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::One); + encoder.set_color(ColorType::Rgba); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Two); + encoder.set_color(ColorType::Rgb); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Two); + encoder.set_color(ColorType::GrayscaleAlpha); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Two); + encoder.set_color(ColorType::Rgba); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Four); + encoder.set_color(ColorType::Rgb); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Four); + encoder.set_color(ColorType::GrayscaleAlpha); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Four); + encoder.set_color(ColorType::Rgba); + assert!(encoder.write_header().is_err()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Sixteen); + encoder.set_color(ColorType::Indexed); + assert!(encoder.write_header().is_err()); + + Ok(()) + } + + #[test] + fn can_write_header_with_valid_bit_depth_color_type_combination() -> Result<()> { + let output = vec![0u8; 1024]; + let mut writer = Cursor::new(output); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::One); + encoder.set_color(ColorType::Grayscale); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::One); + encoder.set_color(ColorType::Indexed); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Two); + encoder.set_color(ColorType::Grayscale); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Two); + encoder.set_color(ColorType::Indexed); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Four); + encoder.set_color(ColorType::Grayscale); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Four); + encoder.set_color(ColorType::Indexed); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Rgb); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Indexed); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::GrayscaleAlpha); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Rgba); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Sixteen); + encoder.set_color(ColorType::Grayscale); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Sixteen); + encoder.set_color(ColorType::Rgb); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Sixteen); + encoder.set_color(ColorType::GrayscaleAlpha); + assert!(encoder.write_header().is_ok()); + + let mut encoder = Encoder::new(&mut writer, 1, 1); + encoder.set_depth(BitDepth::Sixteen); + encoder.set_color(ColorType::Rgba); + assert!(encoder.write_header().is_ok()); + + Ok(()) + } + + #[test] + fn all_filters_roundtrip() -> io::Result<()> { + let pixel: Vec<_> = (0..48).collect(); + + let roundtrip = |filter: FilterType| -> io::Result<()> { + let mut buffer = vec![]; + let mut encoder = Encoder::new(&mut buffer, 4, 4); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Rgb); + encoder.set_filter(filter); + encoder.write_header()?.write_image_data(&pixel)?; + + let decoder = crate::Decoder::new(Cursor::new(buffer)); + let mut reader = decoder.read_info()?; + let info = reader.info(); + assert_eq!(info.width, 4); + assert_eq!(info.height, 4); + let mut dest = vec![0; pixel.len()]; + reader.next_frame(&mut dest)?; + assert_eq!(dest, pixel, "Deviation with filter type {:?}", filter); + + Ok(()) + }; + + roundtrip(FilterType::NoFilter)?; + roundtrip(FilterType::Sub)?; + roundtrip(FilterType::Up)?; + roundtrip(FilterType::Avg)?; + roundtrip(FilterType::Paeth)?; + + Ok(()) + } + + #[test] + fn some_gamma_roundtrip() -> io::Result<()> { + let pixel: Vec<_> = (0..48).collect(); + + let roundtrip = |gamma: Option<ScaledFloat>| -> io::Result<()> { + let mut buffer = vec![]; + let mut encoder = Encoder::new(&mut buffer, 4, 4); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Rgb); + encoder.set_filter(FilterType::Avg); + if let Some(gamma) = gamma { + encoder.set_source_gamma(gamma); + } + encoder.write_header()?.write_image_data(&pixel)?; + + let decoder = crate::Decoder::new(Cursor::new(buffer)); + let mut reader = decoder.read_info()?; + assert_eq!( + reader.info().source_gamma, + gamma, + "Deviation with gamma {:?}", + gamma + ); + let mut dest = vec![0; pixel.len()]; + let info = reader.next_frame(&mut dest)?; + assert_eq!(info.width, 4); + assert_eq!(info.height, 4); + + Ok(()) + }; + + roundtrip(None)?; + roundtrip(Some(ScaledFloat::new(0.35)))?; + roundtrip(Some(ScaledFloat::new(0.45)))?; + roundtrip(Some(ScaledFloat::new(0.55)))?; + roundtrip(Some(ScaledFloat::new(0.7)))?; + roundtrip(Some(ScaledFloat::new(1.0)))?; + roundtrip(Some(ScaledFloat::new(2.5)))?; + + Ok(()) + } + + #[test] + fn write_image_chunks_beyond_first() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + + // Not an animation but we should still be able to write multiple images + // See issue: <https://github.com/image-rs/image-png/issues/301> + // This is technically all valid png so there is no issue with correctness. + let mut encoder = Encoder::new(writer, width, height); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + let mut png_writer = encoder.write_header()?; + + for _ in 0..3 { + let correct_image_size = (width * height) as usize; + let image = vec![0u8; correct_image_size]; + png_writer.write_image_data(image.as_ref())?; + } + + Ok(()) + } + + #[test] + fn image_validate_sequence_without_animation() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + + let mut encoder = Encoder::new(writer, width, height); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + encoder.validate_sequence(true); + let mut png_writer = encoder.write_header()?; + + let correct_image_size = (width * height) as usize; + let image = vec![0u8; correct_image_size]; + png_writer.write_image_data(image.as_ref())?; + + assert!(png_writer.write_image_data(image.as_ref()).is_err()); + Ok(()) + } + + #[test] + fn image_validate_animation() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + let correct_image_size = (width * height) as usize; + let image = vec![0u8; correct_image_size]; + + let mut encoder = Encoder::new(writer, width, height); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + encoder.set_animated(1, 0)?; + encoder.validate_sequence(true); + let mut png_writer = encoder.write_header()?; + + png_writer.write_image_data(image.as_ref())?; + + Ok(()) + } + + #[test] + fn image_validate_animation2() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + let correct_image_size = (width * height) as usize; + let image = vec![0u8; correct_image_size]; + + let mut encoder = Encoder::new(writer, width, height); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + encoder.set_animated(2, 0)?; + encoder.validate_sequence(true); + let mut png_writer = encoder.write_header()?; + + png_writer.write_image_data(image.as_ref())?; + png_writer.write_image_data(image.as_ref())?; + png_writer.finish()?; + + Ok(()) + } + + #[test] + fn image_validate_animation_sep_def_image() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + let correct_image_size = (width * height) as usize; + let image = vec![0u8; correct_image_size]; + + let mut encoder = Encoder::new(writer, width, height); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + encoder.set_animated(1, 0)?; + encoder.set_sep_def_img(true)?; + encoder.validate_sequence(true); + let mut png_writer = encoder.write_header()?; + + png_writer.write_image_data(image.as_ref())?; + png_writer.write_image_data(image.as_ref())?; + png_writer.finish()?; + + Ok(()) + } + + #[test] + fn image_validate_missing_image() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + + let mut encoder = Encoder::new(writer, width, height); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + encoder.validate_sequence(true); + let png_writer = encoder.write_header()?; + + assert!(png_writer.finish().is_err()); + Ok(()) + } + + #[test] + fn image_validate_missing_animated_frame() -> Result<()> { + let width = 10; + let height = 10; + + let output = vec![0u8; 1024]; + let writer = Cursor::new(output); + let correct_image_size = (width * height) as usize; + let image = vec![0u8; correct_image_size]; + + let mut encoder = Encoder::new(writer, width, height); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + encoder.set_animated(2, 0)?; + encoder.validate_sequence(true); + let mut png_writer = encoder.write_header()?; + + png_writer.write_image_data(image.as_ref())?; + assert!(png_writer.finish().is_err()); + + Ok(()) + } + + #[test] + fn issue_307_stream_validation() -> Result<()> { + let output = vec![0u8; 1024]; + let mut cursor = Cursor::new(output); + + let encoder = Encoder::new(&mut cursor, 1, 1); // Create a 1-pixel image + let mut writer = encoder.write_header()?; + let mut stream = writer.stream_writer()?; + + let written = stream.write(&[1, 2, 3, 4])?; + assert_eq!(written, 1); + stream.finish()?; + drop(writer); + + { + cursor.set_position(0); + let mut decoder = Decoder::new(cursor).read_info().expect("A valid image"); + let mut buffer = [0u8; 1]; + decoder.next_frame(&mut buffer[..]).expect("Valid read"); + assert_eq!(buffer, [1]); + } + + Ok(()) + } + + #[test] + fn stream_filtering() -> Result<()> { + let output = vec![0u8; 1024]; + let mut cursor = Cursor::new(output); + + let mut encoder = Encoder::new(&mut cursor, 8, 8); + encoder.set_color(ColorType::Rgba); + encoder.set_filter(FilterType::Paeth); + let mut writer = encoder.write_header()?; + let mut stream = writer.stream_writer()?; + + for _ in 0..8 { + let written = stream.write(&[1; 32])?; + assert_eq!(written, 32); + } + stream.finish()?; + drop(writer); + + { + cursor.set_position(0); + let mut decoder = Decoder::new(cursor).read_info().expect("A valid image"); + let mut buffer = [0u8; 256]; + decoder.next_frame(&mut buffer[..]).expect("Valid read"); + assert_eq!(buffer, [1; 256]); + } + + Ok(()) + } + + #[test] + #[cfg(all(unix, not(target_pointer_width = "32")))] + fn exper_error_on_huge_chunk() -> Result<()> { + // Okay, so we want a proper 4 GB chunk but not actually spend the memory for reserving it. + // Let's rely on overcommit? Otherwise we got the rather dumb option of mmap-ing /dev/zero. + let empty = vec![0; 1usize << 31]; + let writer = Cursor::new(vec![0u8; 1024]); + + let mut encoder = Encoder::new(writer, 10, 10); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + let mut png_writer = encoder.write_header()?; + + assert!(png_writer.write_chunk(chunk::fdAT, &empty).is_err()); + Ok(()) + } + + #[test] + #[cfg(all(unix, not(target_pointer_width = "32")))] + fn exper_error_on_non_u32_chunk() -> Result<()> { + // Okay, so we want a proper 4 GB chunk but not actually spend the memory for reserving it. + // Let's rely on overcommit? Otherwise we got the rather dumb option of mmap-ing /dev/zero. + let empty = vec![0; 1usize << 32]; + let writer = Cursor::new(vec![0u8; 1024]); + + let mut encoder = Encoder::new(writer, 10, 10); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + let mut png_writer = encoder.write_header()?; + + assert!(png_writer.write_chunk(chunk::fdAT, &empty).is_err()); + Ok(()) + } + + #[test] + fn finish_drops_inner_writer() -> Result<()> { + struct NoWriter<'flag>(&'flag mut bool); + + impl Write for NoWriter<'_> { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + Ok(buf.len()) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + impl Drop for NoWriter<'_> { + fn drop(&mut self) { + *self.0 = true; + } + } + + let mut flag = false; + + { + let mut encoder = Encoder::new(NoWriter(&mut flag), 10, 10); + encoder.set_depth(BitDepth::Eight); + encoder.set_color(ColorType::Grayscale); + + let mut writer = encoder.write_header()?; + writer.write_image_data(&[0; 100])?; + writer.finish()?; + } + + assert!(flag, "PNG finished but writer was not dropped"); + Ok(()) + } + + /// A Writer that only writes a few bytes at a time + struct RandomChunkWriter<R: Rng, W: Write> { + rng: R, + w: W, + } + + impl<R: Rng, W: Write> Write for RandomChunkWriter<R, W> { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + // choose a random length to write + let len = cmp::min(self.rng.gen_range(1..50), buf.len()); + + self.w.write(&buf[0..len]) + } + + fn flush(&mut self) -> io::Result<()> { + self.w.flush() + } + } +} + +/// Mod to encapsulate the converters depending on the `deflate` crate. +/// +/// Since this only contains trait impls, there is no need to make this public, they are simply +/// available when the mod is compiled as well. +impl Compression { + fn to_options(self) -> flate2::Compression { + #[allow(deprecated)] + match self { + Compression::Default => flate2::Compression::default(), + Compression::Fast => flate2::Compression::fast(), + Compression::Best => flate2::Compression::best(), + #[allow(deprecated)] + Compression::Huffman => flate2::Compression::none(), + #[allow(deprecated)] + Compression::Rle => flate2::Compression::none(), + } + } +} |