use super::decoded::DecodedImage;
use super::error::DecodeError;
use super::interlace::StreamLayout;
use super::parse;
use crate::deflate::InflateError;
use crate::zlib::{self, ZlibError};
const MAX_DEFLATE_RATIO: usize = 1032;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Decoder {
max_image_bytes: usize,
}
impl Decoder {
pub const DEFAULT_MAX_IMAGE_BYTES: usize = 1 << 30;
pub const fn new() -> Self {
Self {
max_image_bytes: Self::DEFAULT_MAX_IMAGE_BYTES,
}
}
#[must_use]
pub const fn max_image_bytes(self, limit: usize) -> Self {
Self {
max_image_bytes: limit,
}
}
pub fn decode(&self, png: &[u8]) -> Result<DecodedImage, DecodeError> {
let parts = parse::read_parts(png)?;
let header = parts.header;
let too_large = || DecodeError::ImageTooLarge {
limit: self.max_image_bytes,
};
let row_bytes = header
.format
.row_bytes(header.width)
.ok_or_else(too_large)?;
let image_bytes = header
.format
.image_bytes(header.width, header.height)
.filter(|&bytes| bytes <= self.max_image_bytes)
.ok_or_else(too_large)?;
let layout = StreamLayout::new(&header).ok_or_else(too_large)?;
let stream = inflate_image_data(&parts.image_data, layout.len())?;
drop(parts.image_data);
let data = layout.reconstruct(&stream, header.format, row_bytes, image_bytes)?;
Ok(DecodedImage::new(
header,
data,
parts.palette,
parts.color_key,
parts.metadata,
))
}
}
impl Default for Decoder {
fn default() -> Self {
Self::new()
}
}
fn inflate_image_data(compressed: &[u8], expected: usize) -> Result<Vec<u8>, DecodeError> {
let capacity = expected.min(compressed.len().saturating_mul(MAX_DEFLATE_RATIO));
let mut stream = Vec::with_capacity(capacity);
match zlib::decompress_into(compressed, &mut stream, expected) {
Ok(_) | Err(ZlibError::Inflate(InflateError::OutputLimitExceeded { .. })) => {}
Err(error) => return Err(error.into()),
}
if stream.len() < expected {
return Err(DecodeError::ImageDataTooShort {
expected,
actual: stream.len(),
});
}
Ok(stream)
}