| 1 |
use std::convert::TryInto; |
| 2 |
use std::error; |
| 3 |
use std::fmt; |
| 4 |
use std::io; |
| 5 |
use std::{borrow::Cow, cmp::min}; |
| 6 |
|
| 7 |
use crc32fast::Hasher as Crc32; |
| 8 |
|
| 9 |
use super::zlib::UnfilterBuf; |
| 10 |
use super::zlib::ZlibStream; |
| 11 |
use crate::chunk::is_critical; |
| 12 |
use crate::chunk::{self, ChunkType, IDAT, IEND, IHDR}; |
| 13 |
use crate::common::{ |
| 14 |
AnimationControl, BitDepth, BlendOp, ColorType, ContentLightLevelInfo, DisposeOp, FrameControl, |
| 15 |
Info, MasteringDisplayColorVolume, ParameterError, ParameterErrorKind, PixelDimensions, |
| 16 |
ScaledFloat, SourceChromaticities, Unit, |
| 17 |
}; |
| 18 |
use crate::text_metadata::{ITXtChunk, TEXtChunk, TextDecodingError, ZTXtChunk}; |
| 19 |
use crate::traits::ReadBytesExt; |
| 20 |
use crate::{CodingIndependentCodePoints, Limits}; |
| 21 |
|
| 22 |
pub const CHUNK_BUFFER_SIZE: usize = 128; |
| 23 |
|
| 24 |
/// Determines if checksum checks should be disabled globally. |
| 25 |
/// |
| 26 |
/// This is used only in fuzzing. `afl` automatically adds `--cfg fuzzing` to RUSTFLAGS which can |
| 27 |
/// be used to detect that build. |
| 28 |
#[allow(unexpected_cfgs)] |
| 29 |
const CHECKSUM_DISABLED: bool = cfg!(fuzzing); |
| 30 |
|
| 31 |
/// Kind of `u32` value that is being read via `State::U32`. |
| 32 |
#[derive(Debug)] |
| 33 |
enum U32ValueKind { |
| 34 |
/// First 4 bytes of the PNG signature - see |
| 35 |
/// http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#PNG-file-signature |
| 36 |
Signature1stU32, |
| 37 |
/// Second 4 bytes of the PNG signature - see |
| 38 |
/// http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#PNG-file-signature |
| 39 |
Signature2ndU32, |
| 40 |
/// Chunk length - see |
| 41 |
/// http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#Chunk-layout |
| 42 |
Length, |
| 43 |
/// Chunk type - see |
| 44 |
/// http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#Chunk-layout |
| 45 |
Type { length: u32 }, |
| 46 |
/// Chunk checksum - see |
| 47 |
/// http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#Chunk-layout |
| 48 |
Crc(ChunkType), |
| 49 |
/// Sequence number from an `fdAT` chunk - see |
| 50 |
/// https://wiki.mozilla.org/APNG_Specification#.60fdAT.60:_The_Frame_Data_Chunk |
| 51 |
ApngSequenceNumber, |
| 52 |
} |
| 53 |
|
| 54 |
#[derive(Debug)] |
| 55 |
enum State { |
| 56 |
/// In this state we are reading a u32 value from external input. We start with |
| 57 |
/// `accumulated_count` set to `0`. After reading or accumulating the required 4 bytes we will |
| 58 |
/// call `parse_32` which will then move onto the next state. |
| 59 |
U32 { |
| 60 |
kind: U32ValueKind, |
| 61 |
bytes: [u8; 4], |
| 62 |
accumulated_count: usize, |
| 63 |
}, |
| 64 |
/// In this state we are reading chunk data from external input, and appending it to |
| 65 |
/// `ChunkState::raw_bytes`. Then if all data has been read, we parse the chunk. |
| 66 |
ReadChunkData(ChunkType), |
| 67 |
/// In this state we are reading image data from external input and feeding it directly into |
| 68 |
/// `StreamingDecoder::inflater`. |
| 69 |
ImageData(ChunkType), |
| 70 |
} |
| 71 |
|
| 72 |
impl State { |
| 73 |
fn new_u32(kind: U32ValueKind) -> Self { |
| 74 |
Self::U32 { |
| 75 |
kind, |
| 76 |
bytes: [0; 4], |
| 77 |
accumulated_count: 0, |
| 78 |
} |
| 79 |
} |
| 80 |
} |
| 81 |
|
| 82 |
#[derive(Debug)] |
| 83 |
/// Result of the decoding process |
| 84 |
pub enum Decoded { |
| 85 |
/// Nothing decoded yet |
| 86 |
Nothing, |
| 87 |
|
| 88 |
/// A chunk header (length and type fields) has been read. |
| 89 |
ChunkBegin(u32, ChunkType), |
| 90 |
|
| 91 |
/// Chunk has been read successfully. |
| 92 |
ChunkComplete(ChunkType), |
| 93 |
|
| 94 |
/// An ancillary chunk has been read but it was in the wrong place, had corrupt contents, or had |
| 95 |
/// an invalid CRC. |
| 96 |
BadAncillaryChunk(ChunkType), |
| 97 |
|
| 98 |
/// Skipped an ancillary chunk because it was unrecognized or the decoder was configured to skip |
| 99 |
/// this type of chunk. |
| 100 |
SkippedAncillaryChunk(ChunkType), |
| 101 |
|
| 102 |
/// Decoded raw image data. |
| 103 |
ImageData, |
| 104 |
|
| 105 |
/// The last of a consecutive chunk of IDAT was done. |
| 106 |
/// This is distinct from ChunkComplete which only marks that some IDAT chunk was completed but |
| 107 |
/// not that no additional IDAT chunk follows. |
| 108 |
ImageDataFlushed, |
| 109 |
} |
| 110 |
|
| 111 |
/// Any kind of error during PNG decoding. |
| 112 |
/// |
| 113 |
/// This enumeration provides a very rough analysis on the origin of the failure. That is, each |
| 114 |
/// variant corresponds to one kind of actor causing the error. It should not be understood as a |
| 115 |
/// direct blame but can inform the search for a root cause or if such a search is required. |
| 116 |
#[derive(Debug)] |
| 117 |
pub enum DecodingError { |
| 118 |
/// An error in IO of the underlying reader. |
| 119 |
/// |
| 120 |
/// Note that some IO errors may be recoverable - decoding may be retried after the |
| 121 |
/// error is resolved. For example, decoding from a slow stream of data (e.g. decoding from a |
| 122 |
/// network stream) may occasionally result in [std::io::ErrorKind::UnexpectedEof] kind of |
| 123 |
/// error, but decoding can resume when more data becomes available. |
| 124 |
IoError(io::Error), |
| 125 |
/// The input image was not a valid PNG. |
| 126 |
/// |
| 127 |
/// There isn't a lot that can be done here, except if the program itself was responsible for |
| 128 |
/// creating this image then investigate the generator. This is internally implemented with a |
| 129 |
/// large Enum. If You are interested in accessing some of the more exact information on the |
| 130 |
/// variant then we can discuss in an issue. |
| 131 |
Format(FormatError), |
| 132 |
/// An interface was used incorrectly. |
| 133 |
/// |
| 134 |
/// This is used in cases where it's expected that the programmer might trip up and stability |
| 135 |
/// could be affected. For example when: |
| 136 |
/// |
| 137 |
/// * The decoder is polled for more animation frames despite being done (or not being animated |
| 138 |
/// in the first place). |
| 139 |
/// * The output buffer does not have the required size. |
| 140 |
/// |
| 141 |
/// As a rough guideline for introducing new variants parts of the requirements are dynamically |
| 142 |
/// derived from the (untrusted) input data while the other half is from the caller. In the |
| 143 |
/// above cases the number of frames respectively the size is determined by the file while the |
| 144 |
/// number of calls |
| 145 |
/// |
| 146 |
/// If you're an application you might want to signal that a bug report is appreciated. |
| 147 |
Parameter(ParameterError), |
| 148 |
/// The image would have required exceeding the limits configured with the decoder. |
| 149 |
/// |
| 150 |
/// Note that Your allocations, e.g. when reading into a pre-allocated buffer, is __NOT__ |
| 151 |
/// considered part of the limits. Nevertheless, required intermediate buffers such as for |
| 152 |
/// singular lines is checked against the limit. |
| 153 |
/// |
| 154 |
/// Note that this is a best-effort basis. |
| 155 |
LimitsExceeded, |
| 156 |
} |
| 157 |
|
| 158 |
#[derive(Debug)] |
| 159 |
pub struct FormatError { |
| 160 |
inner: FormatErrorInner, |
| 161 |
} |
| 162 |
|
| 163 |
#[derive(Debug)] |
| 164 |
pub(crate) enum FormatErrorInner { |
| 165 |
/// Bad framing. |
| 166 |
CrcMismatch { |
| 167 |
/// Stored CRC32 value |
| 168 |
crc_val: u32, |
| 169 |
/// Calculated CRC32 sum |
| 170 |
crc_sum: u32, |
| 171 |
/// The chunk type that has the CRC mismatch. |
| 172 |
chunk: ChunkType, |
| 173 |
}, |
| 174 |
/// Not a PNG, the magic signature is missing. |
| 175 |
InvalidSignature, |
| 176 |
// Errors of chunk level ordering, missing etc. |
| 177 |
/// Fctl must occur if an animated chunk occurs. |
| 178 |
MissingFctl, |
| 179 |
/// Image data that was indicated in IHDR or acTL is missing. |
| 180 |
MissingImageData, |
| 181 |
/// 4.3., Must be first. |
| 182 |
ChunkBeforeIhdr { |
| 183 |
kind: ChunkType, |
| 184 |
}, |
| 185 |
/// 4.3., some chunks must be before IDAT. |
| 186 |
AfterIdat { |
| 187 |
kind: ChunkType, |
| 188 |
}, |
| 189 |
// 4.3., Some chunks must be after PLTE. |
| 190 |
BeforePlte { |
| 191 |
kind: ChunkType, |
| 192 |
}, |
| 193 |
/// 4.3., some chunks must be before PLTE. |
| 194 |
AfterPlte { |
| 195 |
kind: ChunkType, |
| 196 |
}, |
| 197 |
/// 4.3., some chunks must be between PLTE and IDAT. |
| 198 |
OutsidePlteIdat { |
| 199 |
kind: ChunkType, |
| 200 |
}, |
| 201 |
/// 4.3., some chunks must be unique. |
| 202 |
DuplicateChunk { |
| 203 |
kind: ChunkType, |
| 204 |
}, |
| 205 |
/// Specifically for fdat there is an embedded sequence number for chunks. |
| 206 |
ApngOrder { |
| 207 |
/// The sequence number in the chunk. |
| 208 |
present: u32, |
| 209 |
/// The one that should have been present. |
| 210 |
expected: u32, |
| 211 |
}, |
| 212 |
// Errors specific to particular chunk data to be validated. |
| 213 |
/// The palette did not even contain a single pixel data. |
| 214 |
ShortPalette { |
| 215 |
expected: usize, |
| 216 |
len: usize, |
| 217 |
}, |
| 218 |
/// sBIT chunk size based on color type. |
| 219 |
InvalidSbitChunkSize { |
| 220 |
color_type: ColorType, |
| 221 |
expected: usize, |
| 222 |
len: usize, |
| 223 |
}, |
| 224 |
InvalidSbit { |
| 225 |
sample_depth: BitDepth, |
| 226 |
sbit: u8, |
| 227 |
}, |
| 228 |
/// A palletized image did not have a palette. |
| 229 |
PaletteRequired, |
| 230 |
/// The color-depth combination is not valid according to Table 11.1. |
| 231 |
InvalidColorBitDepth { |
| 232 |
color_type: ColorType, |
| 233 |
bit_depth: BitDepth, |
| 234 |
}, |
| 235 |
ColorWithBadTrns(ColorType), |
| 236 |
/// The image width or height is zero. |
| 237 |
InvalidDimensions, |
| 238 |
InvalidBitDepth(u8), |
| 239 |
InvalidColorType(u8), |
| 240 |
InvalidDisposeOp(u8), |
| 241 |
InvalidBlendOp(u8), |
| 242 |
InvalidUnit(u8), |
| 243 |
/// The rendering intent of the sRGB chunk is invalid. |
| 244 |
InvalidSrgbRenderingIntent(u8), |
| 245 |
UnknownCompressionMethod(u8), |
| 246 |
UnknownFilterMethod(u8), |
| 247 |
UnknownInterlaceMethod(u8), |
| 248 |
/// The subframe is not in bounds of the image. |
| 249 |
/// TODO: fields with relevant data. |
| 250 |
BadSubFrameBounds {}, |
| 251 |
// Errors specific to the IDAT/fdAT chunks. |
| 252 |
/// The compression of the data stream was faulty. |
| 253 |
CorruptFlateStream { |
| 254 |
err: fdeflate::DecompressionError, |
| 255 |
}, |
| 256 |
/// The image data chunk was too short for the expected pixel count. |
| 257 |
NoMoreImageData, |
| 258 |
/// Bad text encoding |
| 259 |
BadTextEncoding(TextDecodingError), |
| 260 |
/// fdAT shorter than 4 bytes |
| 261 |
FdatShorterThanFourBytes, |
| 262 |
/// "11.2.4 IDAT Image data" section of the PNG spec says: There may be multiple IDAT chunks; |
| 263 |
/// if so, they shall appear consecutively with no other intervening chunks. |
| 264 |
/// `UnexpectedRestartOfDataChunkSequence{kind: IDAT}` indicates that there were "intervening |
| 265 |
/// chunks". |
| 266 |
/// |
| 267 |
/// The APNG spec doesn't directly describe an error similar to `CantInterleaveIdatChunks`, |
| 268 |
/// but we require that a new sequence of consecutive `fdAT` chunks cannot appear unless we've |
| 269 |
/// seen an `fcTL` chunk. |
| 270 |
UnexpectedRestartOfDataChunkSequence { |
| 271 |
kind: ChunkType, |
| 272 |
}, |
| 273 |
/// Failure to parse a chunk, because the chunk didn't contain enough bytes. |
| 274 |
ChunkTooShort { |
| 275 |
kind: ChunkType, |
| 276 |
}, |
| 277 |
UnrecognizedCriticalChunk { |
| 278 |
/// The type of the unrecognized critical chunk. |
| 279 |
type_str: ChunkType, |
| 280 |
}, |
| 281 |
BadGammaValue, |
| 282 |
} |
| 283 |
|
| 284 |
impl error::Error for DecodingError { |
| 285 |
fn cause(&self) -> Option<&(dyn error::Error + 'static)> { |
| 286 |
match self { |
| 287 |
DecodingError::IoError(err) => Some(err), |
| 288 |
_ => None, |
| 289 |
} |
| 290 |
} |
| 291 |
} |
| 292 |
|
| 293 |
impl fmt::Display for DecodingError { |
| 294 |
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { |
| 295 |
use self::DecodingError::*; |
| 296 |
match self { |
| 297 |
IoError(err) => write!(fmt, "{}", err), |
| 298 |
Parameter(desc) => write!(fmt, "{}", &desc), |
| 299 |
Format(desc) => write!(fmt, "{}", desc), |
| 300 |
LimitsExceeded => write!(fmt, "limits are exceeded"), |
| 301 |
} |
| 302 |
} |
| 303 |
} |
| 304 |
|
| 305 |
impl fmt::Display for FormatError { |
| 306 |
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| 307 |
use FormatErrorInner::*; |
| 308 |
match &self.inner { |
| 309 |
CrcMismatch { |
| 310 |
crc_val, |
| 311 |
crc_sum, |
| 312 |
chunk, |
| 313 |
.. |
| 314 |
} => write!( |
| 315 |
fmt, |
| 316 |
"CRC error: expected 0x{:x} have 0x{:x} while decoding {:?} chunk.", |
| 317 |
crc_val, crc_sum, chunk |
| 318 |
), |
| 319 |
MissingFctl => write!(fmt, "fcTL chunk missing before fdAT chunk."), |
| 320 |
MissingImageData => write!(fmt, "IDAT or fdAT chunk is missing."), |
| 321 |
ChunkBeforeIhdr { kind } => write!(fmt, "{:?} chunk appeared before IHDR chunk", kind), |
| 322 |
AfterIdat { kind } => write!(fmt, "Chunk {:?} is invalid after IDAT chunk.", kind), |
| 323 |
BeforePlte { kind } => write!(fmt, "Chunk {:?} is invalid before PLTE chunk.", kind), |
| 324 |
AfterPlte { kind } => write!(fmt, "Chunk {:?} is invalid after PLTE chunk.", kind), |
| 325 |
OutsidePlteIdat { kind } => write!( |
| 326 |
fmt, |
| 327 |
"Chunk {:?} must appear between PLTE and IDAT chunks.", |
| 328 |
kind |
| 329 |
), |
| 330 |
DuplicateChunk { kind } => write!(fmt, "Chunk {:?} must appear at most once.", kind), |
| 331 |
ApngOrder { present, expected } => write!( |
| 332 |
fmt, |
| 333 |
"Sequence is not in order, expected #{} got #{}.", |
| 334 |
expected, present, |
| 335 |
), |
| 336 |
ShortPalette { expected, len } => write!( |
| 337 |
fmt, |
| 338 |
"Not enough palette entries, expect {} got {}.", |
| 339 |
expected, len |
| 340 |
), |
| 341 |
InvalidSbitChunkSize {color_type, expected, len} => write!( |
| 342 |
fmt, |
| 343 |
"The size of the sBIT chunk should be {} byte(s), but {} byte(s) were provided for the {:?} color type.", |
| 344 |
expected, len, color_type |
| 345 |
), |
| 346 |
InvalidSbit {sample_depth, sbit} => write!( |
| 347 |
fmt, |
| 348 |
"Invalid sBIT value {}. It must be greater than zero and less than the sample depth {:?}.", |
| 349 |
sbit, sample_depth |
| 350 |
), |
| 351 |
PaletteRequired => write!(fmt, "Missing palette of indexed image."), |
| 352 |
InvalidDimensions => write!(fmt, "Invalid image dimensions"), |
| 353 |
InvalidColorBitDepth { |
| 354 |
color_type, |
| 355 |
bit_depth, |
| 356 |
} => write!( |
| 357 |
fmt, |
| 358 |
"Invalid color/depth combination in header: {:?}/{:?}", |
| 359 |
color_type, bit_depth, |
| 360 |
), |
| 361 |
ColorWithBadTrns(color_type) => write!( |
| 362 |
fmt, |
| 363 |
"Transparency chunk found for color type {:?}.", |
| 364 |
color_type |
| 365 |
), |
| 366 |
InvalidBitDepth(nr) => write!(fmt, "Invalid bit depth {}.", nr), |
| 367 |
InvalidColorType(nr) => write!(fmt, "Invalid color type {}.", nr), |
| 368 |
InvalidDisposeOp(nr) => write!(fmt, "Invalid dispose op {}.", nr), |
| 369 |
InvalidBlendOp(nr) => write!(fmt, "Invalid blend op {}.", nr), |
| 370 |
InvalidUnit(nr) => write!(fmt, "Invalid physical pixel size unit {}.", nr), |
| 371 |
InvalidSrgbRenderingIntent(nr) => write!(fmt, "Invalid sRGB rendering intent {}.", nr), |
| 372 |
UnknownCompressionMethod(nr) => write!(fmt, "Unknown compression method {}.", nr), |
| 373 |
UnknownFilterMethod(nr) => write!(fmt, "Unknown filter method {}.", nr), |
| 374 |
UnknownInterlaceMethod(nr) => write!(fmt, "Unknown interlace method {}.", nr), |
| 375 |
BadSubFrameBounds {} => write!(fmt, "Sub frame is out-of-bounds."), |
| 376 |
InvalidSignature => write!(fmt, "Invalid PNG signature."), |
| 377 |
NoMoreImageData => write!( |
| 378 |
fmt, |
| 379 |
"IDAT or fDAT chunk does not have enough data for image." |
| 380 |
), |
| 381 |
CorruptFlateStream { err } => { |
| 382 |
write!(fmt, "Corrupt deflate stream. ")?; |
| 383 |
write!(fmt, "{:?}", err) |
| 384 |
} |
| 385 |
// TODO: Wrap more info in the enum variant |
| 386 |
BadTextEncoding(tde) => { |
| 387 |
match tde { |
| 388 |
TextDecodingError::Unrepresentable => { |
| 389 |
write!(fmt, "Unrepresentable data in tEXt chunk.") |
| 390 |
} |
| 391 |
TextDecodingError::InvalidKeywordSize => { |
| 392 |
write!(fmt, "Keyword empty or longer than 79 bytes.") |
| 393 |
} |
| 394 |
TextDecodingError::MissingNullSeparator => { |
| 395 |
write!(fmt, "No null separator in tEXt chunk.") |
| 396 |
} |
| 397 |
TextDecodingError::InflationError => { |
| 398 |
write!(fmt, "Invalid compressed text data.") |
| 399 |
} |
| 400 |
TextDecodingError::OutOfDecompressionSpace => { |
| 401 |
write!(fmt, "Out of decompression space. Try with a larger limit.") |
| 402 |
} |
| 403 |
TextDecodingError::InvalidCompressionMethod => { |
| 404 |
write!(fmt, "Using an unrecognized byte as compression method.") |
| 405 |
} |
| 406 |
TextDecodingError::InvalidCompressionFlag => { |
| 407 |
write!(fmt, "Using a flag that is not 0 or 255 as a compression flag for iTXt chunk.") |
| 408 |
} |
| 409 |
TextDecodingError::MissingCompressionFlag => { |
| 410 |
write!(fmt, "No compression flag in the iTXt chunk.") |
| 411 |
} |
| 412 |
} |
| 413 |
} |
| 414 |
FdatShorterThanFourBytes => write!(fmt, "fdAT chunk shorter than 4 bytes"), |
| 415 |
UnexpectedRestartOfDataChunkSequence { kind } => { |
| 416 |
write!(fmt, "Unexpected restart of {:?} chunk sequence", kind) |
| 417 |
} |
| 418 |
ChunkTooShort { kind } => { |
| 419 |
write!(fmt, "Chunk is too short: {:?}", kind) |
| 420 |
} |
| 421 |
UnrecognizedCriticalChunk { type_str } => { |
| 422 |
write!(fmt, "Unrecognized critical chunk: {:?}", type_str) |
| 423 |
} |
| 424 |
BadGammaValue => write!(fmt, "Bad gamma value."), |
| 425 |
} |
| 426 |
} |
| 427 |
} |
| 428 |
|
| 429 |
impl From<io::Error> for DecodingError { |
| 430 |
fn from(err: io::Error) -> DecodingError { |
| 431 |
DecodingError::IoError(err) |
| 432 |
} |
| 433 |
} |
| 434 |
|
| 435 |
impl From<FormatError> for DecodingError { |
| 436 |
fn from(err: FormatError) -> DecodingError { |
| 437 |
DecodingError::Format(err) |
| 438 |
} |
| 439 |
} |
| 440 |
|
| 441 |
impl From<FormatErrorInner> for FormatError { |
| 442 |
fn from(inner: FormatErrorInner) -> Self { |
| 443 |
FormatError { inner } |
| 444 |
} |
| 445 |
} |
| 446 |
|
| 447 |
impl From<DecodingError> for io::Error { |
| 448 |
fn from(err: DecodingError) -> io::Error { |
| 449 |
match err { |
| 450 |
DecodingError::IoError(err) => err, |
| 451 |
err => io::Error::new(io::ErrorKind::Other, err.to_string()), |
| 452 |
} |
| 453 |
} |
| 454 |
} |
| 455 |
|
| 456 |
impl From<TextDecodingError> for DecodingError { |
| 457 |
fn from(tbe: TextDecodingError) -> Self { |
| 458 |
DecodingError::Format(FormatError { |
| 459 |
inner: FormatErrorInner::BadTextEncoding(tbe), |
| 460 |
}) |
| 461 |
} |
| 462 |
} |
| 463 |
|
| 464 |
/// Decoder configuration options |
| 465 |
#[derive(Clone)] |
| 466 |
pub struct DecodeOptions { |
| 467 |
ignore_adler32: bool, |
| 468 |
ignore_crc: bool, |
| 469 |
ignore_text_chunk: bool, |
| 470 |
ignore_iccp_chunk: bool, |
| 471 |
skip_ancillary_crc_failures: bool, |
| 472 |
} |
| 473 |
|
| 474 |
impl Default for DecodeOptions { |
| 475 |
fn default() -> Self { |
| 476 |
Self { |
| 477 |
ignore_adler32: true, |
| 478 |
ignore_crc: false, |
| 479 |
ignore_text_chunk: false, |
| 480 |
ignore_iccp_chunk: false, |
| 481 |
skip_ancillary_crc_failures: true, |
| 482 |
} |
| 483 |
} |
| 484 |
} |
| 485 |
|
| 486 |
impl DecodeOptions { |
| 487 |
/// When set, the decoder will not compute and verify the Adler-32 checksum. |
| 488 |
/// |
| 489 |
/// Defaults to `true`. |
| 490 |
pub fn set_ignore_adler32(&mut self, ignore_adler32: bool) { |
| 491 |
self.ignore_adler32 = ignore_adler32; |
| 492 |
} |
| 493 |
|
| 494 |
/// When set, the decoder will not compute and verify the CRC code. |
| 495 |
/// |
| 496 |
/// Defaults to `false`. |
| 497 |
pub fn set_ignore_crc(&mut self, ignore_crc: bool) { |
| 498 |
self.ignore_crc = ignore_crc; |
| 499 |
} |
| 500 |
|
| 501 |
/// Flag to ignore computing and verifying the Adler-32 checksum and CRC |
| 502 |
/// code. |
| 503 |
pub fn set_ignore_checksums(&mut self, ignore_checksums: bool) { |
| 504 |
self.ignore_adler32 = ignore_checksums; |
| 505 |
self.ignore_crc = ignore_checksums; |
| 506 |
} |
| 507 |
|
| 508 |
/// Ignore text chunks while decoding. |
| 509 |
/// |
| 510 |
/// Defaults to `false`. |
| 511 |
pub fn set_ignore_text_chunk(&mut self, ignore_text_chunk: bool) { |
| 512 |
self.ignore_text_chunk = ignore_text_chunk; |
| 513 |
} |
| 514 |
|
| 515 |
/// Ignore ICCP chunks while decoding. |
| 516 |
/// |
| 517 |
/// Defaults to `false`. |
| 518 |
pub fn set_ignore_iccp_chunk(&mut self, ignore_iccp_chunk: bool) { |
| 519 |
self.ignore_iccp_chunk = ignore_iccp_chunk; |
| 520 |
} |
| 521 |
|
| 522 |
/// Ignore ancillary chunks if CRC fails |
| 523 |
/// |
| 524 |
/// Defaults to `true` |
| 525 |
pub fn set_skip_ancillary_crc_failures(&mut self, skip_ancillary_crc_failures: bool) { |
| 526 |
self.skip_ancillary_crc_failures = skip_ancillary_crc_failures; |
| 527 |
} |
| 528 |
} |
| 529 |
|
| 530 |
/// PNG StreamingDecoder (low-level interface) |
| 531 |
/// |
| 532 |
/// By default, the decoder does not verify Adler-32 checksum computation. To |
| 533 |
/// enable checksum verification, set it with [`StreamingDecoder::set_ignore_adler32`] |
| 534 |
/// before starting decompression. |
| 535 |
pub struct StreamingDecoder { |
| 536 |
state: Option<State>, |
| 537 |
current_chunk: ChunkState, |
| 538 |
/// The inflater state handling consecutive `IDAT` and `fdAT` chunks. |
| 539 |
inflater: ZlibStream, |
| 540 |
/// The complete image info read from all prior chunks. |
| 541 |
pub(crate) info: Option<Info<'static>>, |
| 542 |
/// The animation chunk sequence number. |
| 543 |
current_seq_no: Option<u32>, |
| 544 |
/// Whether we have already seen a start of an IDAT chunk. (Used to validate chunk ordering - |
| 545 |
/// some chunk types can only appear before or after an IDAT chunk.) |
| 546 |
have_idat: bool, |
| 547 |
/// Whether we are ready for a start of an `IDAT` chunk sequence. Initially `true` and set to |
| 548 |
/// `false` when the first sequence of consecutive `IDAT` chunks ends. |
| 549 |
ready_for_idat_chunks: bool, |
| 550 |
/// Whether we are ready for a start of an `fdAT` chunk sequence. Initially `false`. Set to |
| 551 |
/// `true` after encountering an `fcTL` chunk. Set to `false` when a sequence of consecutive |
| 552 |
/// `fdAT` chunks ends. |
| 553 |
ready_for_fdat_chunks: bool, |
| 554 |
/// Whether we have already seen an iCCP chunk. Used to prevent parsing of duplicate iCCP chunks. |
| 555 |
have_iccp: bool, |
| 556 |
decode_options: DecodeOptions, |
| 557 |
pub(crate) limits: Limits, |
| 558 |
} |
| 559 |
|
| 560 |
struct ChunkState { |
| 561 |
/// The type of the current chunk. |
| 562 |
/// Relevant for `IDAT` and `fdAT` which aggregate consecutive chunks of their own type. |
| 563 |
type_: ChunkType, |
| 564 |
|
| 565 |
/// Partial crc until now. |
| 566 |
crc: Crc32, |
| 567 |
|
| 568 |
/// Remaining bytes to be read. |
| 569 |
remaining: u32, |
| 570 |
|
| 571 |
/// Non-decoded bytes in the chunk. |
| 572 |
raw_bytes: Vec<u8>, |
| 573 |
} |
| 574 |
|
| 575 |
impl StreamingDecoder { |
| 576 |
/// Creates a new StreamingDecoder |
| 577 |
/// |
| 578 |
/// Allocates the internal buffers. |
| 579 |
pub fn new() -> StreamingDecoder { |
| 580 |
StreamingDecoder::new_with_options(DecodeOptions::default()) |
| 581 |
} |
| 582 |
|
| 583 |
pub fn new_with_options(decode_options: DecodeOptions) -> StreamingDecoder { |
| 584 |
let mut inflater = ZlibStream::new(); |
| 585 |
inflater.set_ignore_adler32(decode_options.ignore_adler32); |
| 586 |
|
| 587 |
StreamingDecoder { |
| 588 |
state: Some(State::new_u32(U32ValueKind::Signature1stU32)), |
| 589 |
current_chunk: ChunkState { |
| 590 |
type_: ChunkType([0; 4]), |
| 591 |
crc: Crc32::new(), |
| 592 |
remaining: 0, |
| 593 |
raw_bytes: Vec::with_capacity(CHUNK_BUFFER_SIZE), |
| 594 |
}, |
| 595 |
inflater, |
| 596 |
info: None, |
| 597 |
current_seq_no: None, |
| 598 |
have_idat: false, |
| 599 |
have_iccp: false, |
| 600 |
ready_for_idat_chunks: true, |
| 601 |
ready_for_fdat_chunks: false, |
| 602 |
decode_options, |
| 603 |
limits: Limits { bytes: usize::MAX }, |
| 604 |
} |
| 605 |
} |
| 606 |
|
| 607 |
/// Resets the StreamingDecoder |
| 608 |
pub fn reset(&mut self) { |
| 609 |
self.state = Some(State::new_u32(U32ValueKind::Signature1stU32)); |
| 610 |
self.current_chunk.crc = Crc32::new(); |
| 611 |
self.current_chunk.remaining = 0; |
| 612 |
self.current_chunk.raw_bytes.clear(); |
| 613 |
self.inflater.reset(); |
| 614 |
self.info = None; |
| 615 |
self.current_seq_no = None; |
| 616 |
self.have_idat = false; |
| 617 |
} |
| 618 |
|
| 619 |
/// Provides access to the inner `info` field |
| 620 |
pub fn info(&self) -> Option<&Info<'static>> { |
| 621 |
self.info.as_ref() |
| 622 |
} |
| 623 |
|
| 624 |
pub fn set_ignore_text_chunk(&mut self, ignore_text_chunk: bool) { |
| 625 |
self.decode_options.set_ignore_text_chunk(ignore_text_chunk); |
| 626 |
} |
| 627 |
|
| 628 |
pub fn set_ignore_iccp_chunk(&mut self, ignore_iccp_chunk: bool) { |
| 629 |
self.decode_options.set_ignore_iccp_chunk(ignore_iccp_chunk); |
| 630 |
} |
| 631 |
|
| 632 |
/// Return whether the decoder is set to ignore the Adler-32 checksum. |
| 633 |
pub fn ignore_adler32(&self) -> bool { |
| 634 |
self.inflater.ignore_adler32() |
| 635 |
} |
| 636 |
|
| 637 |
/// Set whether to compute and verify the Adler-32 checksum during |
| 638 |
/// decompression. Return `true` if the flag was successfully set. |
| 639 |
/// |
| 640 |
/// The decoder defaults to `true`. |
| 641 |
/// |
| 642 |
/// This flag cannot be modified after decompression has started until the |
| 643 |
/// [`StreamingDecoder`] is reset. |
| 644 |
pub fn set_ignore_adler32(&mut self, ignore_adler32: bool) -> bool { |
| 645 |
self.inflater.set_ignore_adler32(ignore_adler32) |
| 646 |
} |
| 647 |
|
| 648 |
/// Set whether to compute and verify the Adler-32 checksum during |
| 649 |
/// decompression. |
| 650 |
/// |
| 651 |
/// The decoder defaults to `false`. |
| 652 |
pub fn set_ignore_crc(&mut self, ignore_crc: bool) { |
| 653 |
self.decode_options.set_ignore_crc(ignore_crc) |
| 654 |
} |
| 655 |
|
| 656 |
/// Ignore ancillary chunks if CRC fails |
| 657 |
/// |
| 658 |
/// Defaults to `true` |
| 659 |
pub fn set_skip_ancillary_crc_failures(&mut self, skip_ancillary_crc_failures: bool) { |
| 660 |
self.decode_options |
| 661 |
.set_skip_ancillary_crc_failures(skip_ancillary_crc_failures) |
| 662 |
} |
| 663 |
|
| 664 |
/// Low level StreamingDecoder interface. |
| 665 |
/// |
| 666 |
/// Allows to stream partial data to the encoder. Returns a tuple containing the bytes that have |
| 667 |
/// been consumed from the input buffer and the current decoding result. If the decoded chunk |
| 668 |
/// was an image data chunk, it also appends the read data to `image_data`. |
| 669 |
pub fn update( |
| 670 |
&mut self, |
| 671 |
mut buf: &[u8], |
| 672 |
mut image_data: Option<&mut UnfilterBuf<'_>>, |
| 673 |
) -> Result<(usize, Decoded), DecodingError> { |
| 674 |
if self.state.is_none() { |
| 675 |
return Err(DecodingError::Parameter( |
| 676 |
ParameterErrorKind::PolledAfterFatalError.into(), |
| 677 |
)); |
| 678 |
} |
| 679 |
|
| 680 |
let len = buf.len(); |
| 681 |
while !buf.is_empty() { |
| 682 |
let image_data = image_data.as_deref_mut(); |
| 683 |
|
| 684 |
match self.next_state(buf, image_data) { |
| 685 |
Ok((bytes, Decoded::Nothing)) => buf = &buf[bytes..], |
| 686 |
Ok((bytes, result)) => { |
| 687 |
buf = &buf[bytes..]; |
| 688 |
return Ok((len - buf.len(), result)); |
| 689 |
} |
| 690 |
Err(err) => { |
| 691 |
debug_assert!(self.state.is_none()); |
| 692 |
return Err(err); |
| 693 |
} |
| 694 |
} |
| 695 |
} |
| 696 |
Ok((len - buf.len(), Decoded::Nothing)) |
| 697 |
} |
| 698 |
|
| 699 |
fn next_state( |
| 700 |
&mut self, |
| 701 |
buf: &[u8], |
| 702 |
image_data: Option<&mut UnfilterBuf<'_>>, |
| 703 |
) -> Result<(usize, Decoded), DecodingError> { |
| 704 |
use self::State::*; |
| 705 |
|
| 706 |
// Driver should ensure that state is never None |
| 707 |
let state = self.state.take().unwrap(); |
| 708 |
|
| 709 |
match state { |
| 710 |
U32 { |
| 711 |
kind, |
| 712 |
mut bytes, |
| 713 |
mut accumulated_count, |
| 714 |
} => { |
| 715 |
debug_assert!(accumulated_count <= 4); |
| 716 |
if accumulated_count == 0 && buf.len() >= 4 { |
| 717 |
// Handling these `accumulated_count` and `buf.len()` values in a separate `if` |
| 718 |
// branch is not strictly necessary - the `else` statement below is already |
| 719 |
// capable of handling these values. The main reason for special-casing these |
| 720 |
// values is that they occur fairly frequently and special-casing them results |
| 721 |
// in performance gains. |
| 722 |
const CONSUMED_BYTES: usize = 4; |
| 723 |
self.parse_u32(kind, &buf[0..4], image_data) |
| 724 |
.map(|decoded| (CONSUMED_BYTES, decoded)) |
| 725 |
} else { |
| 726 |
let remaining_count = 4 - accumulated_count; |
| 727 |
let consumed_bytes = { |
| 728 |
let available_count = min(remaining_count, buf.len()); |
| 729 |
bytes[accumulated_count..accumulated_count + available_count] |
| 730 |
.copy_from_slice(&buf[0..available_count]); |
| 731 |
accumulated_count += available_count; |
| 732 |
available_count |
| 733 |
}; |
| 734 |
|
| 735 |
if accumulated_count < 4 { |
| 736 |
self.state = Some(U32 { |
| 737 |
kind, |
| 738 |
bytes, |
| 739 |
accumulated_count, |
| 740 |
}); |
| 741 |
Ok((consumed_bytes, Decoded::Nothing)) |
| 742 |
} else { |
| 743 |
debug_assert_eq!(accumulated_count, 4); |
| 744 |
self.parse_u32(kind, &bytes, image_data) |
| 745 |
.map(|decoded| (consumed_bytes, decoded)) |
| 746 |
} |
| 747 |
} |
| 748 |
} |
| 749 |
ReadChunkData(type_str) => { |
| 750 |
debug_assert!(type_str != IDAT && type_str != chunk::fdAT); |
| 751 |
if self.current_chunk.remaining == 0 { |
| 752 |
self.state = Some(State::new_u32(U32ValueKind::Crc(type_str))); |
| 753 |
Ok((0, Decoded::Nothing)) |
| 754 |
} else { |
| 755 |
let ChunkState { |
| 756 |
crc, |
| 757 |
remaining, |
| 758 |
raw_bytes, |
| 759 |
type_: _, |
| 760 |
} = &mut self.current_chunk; |
| 761 |
|
| 762 |
if raw_bytes.len() == raw_bytes.capacity() { |
| 763 |
if self.limits.bytes == 0 { |
| 764 |
return Err(DecodingError::LimitsExceeded); |
| 765 |
} |
| 766 |
|
| 767 |
// Double the size of the Vec, but not beyond the allocation limit. |
| 768 |
debug_assert!(raw_bytes.capacity() > 0); |
| 769 |
let reserve_size = raw_bytes.capacity().min(self.limits.bytes); |
| 770 |
|
| 771 |
self.limits.reserve_bytes(reserve_size)?; |
| 772 |
raw_bytes.reserve_exact(reserve_size); |
| 773 |
} |
| 774 |
|
| 775 |
let buf_avail = raw_bytes.capacity() - raw_bytes.len(); |
| 776 |
let bytes_avail = min(buf.len(), buf_avail); |
| 777 |
let n = min(*remaining, bytes_avail as u32); |
| 778 |
|
| 779 |
let buf = &buf[..n as usize]; |
| 780 |
if !self.decode_options.ignore_crc { |
| 781 |
crc.update(buf); |
| 782 |
} |
| 783 |
raw_bytes.extend_from_slice(buf); |
| 784 |
|
| 785 |
*remaining -= n; |
| 786 |
if *remaining == 0 { |
| 787 |
debug_assert!(type_str != IDAT && type_str != chunk::fdAT); |
| 788 |
self.state = Some(State::new_u32(U32ValueKind::Crc(type_str))); |
| 789 |
} else { |
| 790 |
self.state = Some(ReadChunkData(type_str)); |
| 791 |
} |
| 792 |
Ok((n as usize, Decoded::Nothing)) |
| 793 |
} |
| 794 |
} |
| 795 |
ImageData(type_str) => { |
| 796 |
debug_assert!(type_str == IDAT || type_str == chunk::fdAT); |
| 797 |
let len = std::cmp::min(buf.len(), self.current_chunk.remaining as usize); |
| 798 |
let buf = &buf[..len]; |
| 799 |
|
| 800 |
let consumed = if let Some(image_data) = image_data { |
| 801 |
self.inflater.decompress(buf, image_data)? |
| 802 |
} else { |
| 803 |
len |
| 804 |
}; |
| 805 |
|
| 806 |
if !self.decode_options.ignore_crc { |
| 807 |
self.current_chunk.crc.update(&buf[..consumed]); |
| 808 |
} |
| 809 |
|
| 810 |
self.current_chunk.remaining -= consumed as u32; |
| 811 |
if self.current_chunk.remaining == 0 { |
| 812 |
self.state = Some(State::new_u32(U32ValueKind::Crc(type_str))); |
| 813 |
} else { |
| 814 |
self.state = Some(ImageData(type_str)); |
| 815 |
} |
| 816 |
Ok((consumed, Decoded::ImageData)) |
| 817 |
} |
| 818 |
} |
| 819 |
} |
| 820 |
|
| 821 |
fn parse_u32( |
| 822 |
&mut self, |
| 823 |
kind: U32ValueKind, |
| 824 |
u32_be_bytes: &[u8], |
| 825 |
image_data: Option<&mut UnfilterBuf<'_>>, |
| 826 |
) -> Result<Decoded, DecodingError> { |
| 827 |
debug_assert_eq!(u32_be_bytes.len(), 4); |
| 828 |
let bytes = u32_be_bytes.try_into().unwrap(); |
| 829 |
let val = u32::from_be_bytes(bytes); |
| 830 |
|
| 831 |
match kind { |
| 832 |
U32ValueKind::Signature1stU32 => { |
| 833 |
if bytes == [137, 80, 78, 71] { |
| 834 |
self.state = Some(State::new_u32(U32ValueKind::Signature2ndU32)); |
| 835 |
Ok(Decoded::Nothing) |
| 836 |
} else { |
| 837 |
Err(DecodingError::Format( |
| 838 |
FormatErrorInner::InvalidSignature.into(), |
| 839 |
)) |
| 840 |
} |
| 841 |
} |
| 842 |
U32ValueKind::Signature2ndU32 => { |
| 843 |
if bytes == [13, 10, 26, 10] { |
| 844 |
self.state = Some(State::new_u32(U32ValueKind::Length)); |
| 845 |
Ok(Decoded::Nothing) |
| 846 |
} else { |
| 847 |
Err(DecodingError::Format( |
| 848 |
FormatErrorInner::InvalidSignature.into(), |
| 849 |
)) |
| 850 |
} |
| 851 |
} |
| 852 |
U32ValueKind::Length => { |
| 853 |
self.state = Some(State::new_u32(U32ValueKind::Type { length: val })); |
| 854 |
Ok(Decoded::Nothing) |
| 855 |
} |
| 856 |
U32ValueKind::Type { length } => { |
| 857 |
let type_str = ChunkType(bytes); |
| 858 |
if self.info.is_none() && type_str != IHDR { |
| 859 |
return Err(DecodingError::Format( |
| 860 |
FormatErrorInner::ChunkBeforeIhdr { kind: type_str }.into(), |
| 861 |
)); |
| 862 |
} |
| 863 |
if type_str != self.current_chunk.type_ |
| 864 |
&& (self.current_chunk.type_ == IDAT || self.current_chunk.type_ == chunk::fdAT) |
| 865 |
{ |
| 866 |
self.current_chunk.type_ = type_str; |
| 867 |
if let Some(image_data) = image_data { |
| 868 |
self.inflater.finish_compressed_chunks(image_data)?; |
| 869 |
} |
| 870 |
|
| 871 |
self.ready_for_idat_chunks = false; |
| 872 |
self.ready_for_fdat_chunks = false; |
| 873 |
self.state = Some(State::U32 { |
| 874 |
kind, |
| 875 |
bytes, |
| 876 |
accumulated_count: 4, |
| 877 |
}); |
| 878 |
return Ok(Decoded::ImageDataFlushed); |
| 879 |
} |
| 880 |
self.state = match type_str { |
| 881 |
chunk::fdAT => { |
| 882 |
if !self.ready_for_fdat_chunks { |
| 883 |
return Err(DecodingError::Format( |
| 884 |
FormatErrorInner::UnexpectedRestartOfDataChunkSequence { |
| 885 |
kind: chunk::fdAT, |
| 886 |
} |
| 887 |
.into(), |
| 888 |
)); |
| 889 |
} |
| 890 |
if length < 4 { |
| 891 |
return Err(DecodingError::Format( |
| 892 |
FormatErrorInner::FdatShorterThanFourBytes.into(), |
| 893 |
)); |
| 894 |
} |
| 895 |
Some(State::new_u32(U32ValueKind::ApngSequenceNumber)) |
| 896 |
} |
| 897 |
IDAT => { |
| 898 |
if !self.ready_for_idat_chunks { |
| 899 |
return Err(DecodingError::Format( |
| 900 |
FormatErrorInner::UnexpectedRestartOfDataChunkSequence { |
| 901 |
kind: IDAT, |
| 902 |
} |
| 903 |
.into(), |
| 904 |
)); |
| 905 |
} |
| 906 |
self.have_idat = true; |
| 907 |
Some(State::ImageData(type_str)) |
| 908 |
} |
| 909 |
_ => Some(State::ReadChunkData(type_str)), |
| 910 |
}; |
| 911 |
self.current_chunk.type_ = type_str; |
| 912 |
if !self.decode_options.ignore_crc { |
| 913 |
self.current_chunk.crc.reset(); |
| 914 |
self.current_chunk.crc.update(&type_str.0); |
| 915 |
} |
| 916 |
self.current_chunk.remaining = length; |
| 917 |
self.current_chunk.raw_bytes.clear(); |
| 918 |
Ok(Decoded::ChunkBegin(length, type_str)) |
| 919 |
} |
| 920 |
U32ValueKind::Crc(type_str) => { |
| 921 |
// If ignore_crc is set, do not calculate CRC. We set |
| 922 |
// sum=val so that it short-circuits to true in the next |
| 923 |
// if-statement block |
| 924 |
let sum = if self.decode_options.ignore_crc { |
| 925 |
val |
| 926 |
} else { |
| 927 |
self.current_chunk.crc.clone().finalize() |
| 928 |
}; |
| 929 |
|
| 930 |
if val == sum || CHECKSUM_DISABLED { |
| 931 |
// A fatal error in chunk parsing leaves the decoder in state 'None' to enforce |
| 932 |
// that parsing can't continue after an error. |
| 933 |
debug_assert!(self.state.is_none()); |
| 934 |
let decoded = self.parse_chunk(type_str)?; |
| 935 |
|
| 936 |
if type_str != IEND { |
| 937 |
self.state = Some(State::new_u32(U32ValueKind::Length)); |
| 938 |
} |
| 939 |
Ok(decoded) |
| 940 |
} else if self.decode_options.skip_ancillary_crc_failures |
| 941 |
&& !chunk::is_critical(type_str) |
| 942 |
{ |
| 943 |
// Ignore ancillary chunk with invalid CRC |
| 944 |
self.state = Some(State::new_u32(U32ValueKind::Length)); |
| 945 |
Ok(Decoded::BadAncillaryChunk(type_str)) |
| 946 |
} else { |
| 947 |
Err(DecodingError::Format( |
| 948 |
FormatErrorInner::CrcMismatch { |
| 949 |
crc_val: val, |
| 950 |
crc_sum: sum, |
| 951 |
chunk: type_str, |
| 952 |
} |
| 953 |
.into(), |
| 954 |
)) |
| 955 |
} |
| 956 |
} |
| 957 |
U32ValueKind::ApngSequenceNumber => { |
| 958 |
debug_assert_eq!(self.current_chunk.type_, chunk::fdAT); |
| 959 |
let next_seq_no = val; |
| 960 |
|
| 961 |
// Should be verified by the FdatShorterThanFourBytes check earlier. |
| 962 |
debug_assert!(self.current_chunk.remaining >= 4); |
| 963 |
self.current_chunk.remaining -= 4; |
| 964 |
|
| 965 |
if let Some(seq_no) = self.current_seq_no { |
| 966 |
if next_seq_no != seq_no + 1 { |
| 967 |
return Err(DecodingError::Format( |
| 968 |
FormatErrorInner::ApngOrder { |
| 969 |
present: next_seq_no, |
| 970 |
expected: seq_no + 1, |
| 971 |
} |
| 972 |
.into(), |
| 973 |
)); |
| 974 |
} |
| 975 |
self.current_seq_no = Some(next_seq_no); |
| 976 |
} else { |
| 977 |
return Err(DecodingError::Format(FormatErrorInner::MissingFctl.into())); |
| 978 |
} |
| 979 |
|
| 980 |
if !self.decode_options.ignore_crc { |
| 981 |
let data = next_seq_no.to_be_bytes(); |
| 982 |
self.current_chunk.crc.update(&data); |
| 983 |
} |
| 984 |
|
| 985 |
self.state = Some(State::ImageData(chunk::fdAT)); |
| 986 |
Ok(Decoded::Nothing) |
| 987 |
} |
| 988 |
} |
| 989 |
} |
| 990 |
|
| 991 |
fn parse_chunk(&mut self, type_str: ChunkType) -> Result<Decoded, DecodingError> { |
| 992 |
let mut parse_result = match type_str { |
| 993 |
// Critical non-data chunks. |
| 994 |
IHDR => self.parse_ihdr(), |
| 995 |
chunk::PLTE => self.parse_plte(), |
| 996 |
chunk::IEND => Ok(()), // TODO: Check chunk size. |
| 997 |
|
| 998 |
// Data chunks handled separately. |
| 999 |
chunk::IDAT => Ok(()), |
| 1000 |
chunk::fdAT => Ok(()), |
| 1001 |
|
| 1002 |
// Recognized bounded-size ancillary chunks. |
| 1003 |
chunk::sBIT => self.parse_sbit(), |
| 1004 |
chunk::tRNS => self.parse_trns(), |
| 1005 |
chunk::pHYs => self.parse_phys(), |
| 1006 |
chunk::gAMA => self.parse_gama(), |
| 1007 |
chunk::acTL => self.parse_actl(), |
| 1008 |
chunk::fcTL => self.parse_fctl(), |
| 1009 |
chunk::cHRM => self.parse_chrm(), |
| 1010 |
chunk::sRGB => self.parse_srgb(), |
| 1011 |
chunk::cICP => self.parse_cicp(), |
| 1012 |
chunk::mDCV => self.parse_mdcv(), |
| 1013 |
chunk::cLLI => self.parse_clli(), |
| 1014 |
chunk::bKGD => self.parse_bkgd(), |
| 1015 |
|
| 1016 |
// Ancillary chunks with unbounded size. |
| 1017 |
chunk::eXIf => self.parse_exif(), // TODO: allow skipping. |
| 1018 |
chunk::iCCP if !self.decode_options.ignore_iccp_chunk => self.parse_iccp(), |
| 1019 |
chunk::tEXt if !self.decode_options.ignore_text_chunk => self.parse_text(), |
| 1020 |
chunk::zTXt if !self.decode_options.ignore_text_chunk => self.parse_ztxt(), |
| 1021 |
chunk::iTXt if !self.decode_options.ignore_text_chunk => self.parse_itxt(), |
| 1022 |
|
| 1023 |
// Unrecognized chunks. |
| 1024 |
_ => { |
| 1025 |
if is_critical(type_str) { |
| 1026 |
return Err(DecodingError::Format( |
| 1027 |
FormatErrorInner::UnrecognizedCriticalChunk { type_str }.into(), |
| 1028 |
)); |
| 1029 |
} else { |
| 1030 |
return Ok(Decoded::SkippedAncillaryChunk(type_str)); |
| 1031 |
} |
| 1032 |
} |
| 1033 |
}; |
| 1034 |
|
| 1035 |
parse_result = parse_result.map_err(|e| { |
| 1036 |
match e { |
| 1037 |
// `parse_chunk` is invoked after gathering **all** bytes of a chunk, so |
| 1038 |
// `UnexpectedEof` from something like `read_be` is permanent and indicates an |
| 1039 |
// invalid PNG that should be represented as a `FormatError`, rather than as a |
| 1040 |
// (potentially recoverable) `IoError` / `UnexpectedEof`. |
| 1041 |
DecodingError::IoError(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => { |
| 1042 |
let fmt_err: FormatError = |
| 1043 |
FormatErrorInner::ChunkTooShort { kind: type_str }.into(); |
| 1044 |
fmt_err.into() |
| 1045 |
} |
| 1046 |
e => e, |
| 1047 |
} |
| 1048 |
}); |
| 1049 |
|
| 1050 |
match parse_result { |
| 1051 |
Ok(()) => Ok(Decoded::ChunkComplete(type_str)), |
| 1052 |
Err(DecodingError::Format(_)) |
| 1053 |
if type_str != chunk::fcTL && !chunk::is_critical(type_str) => |
| 1054 |
{ |
| 1055 |
// Ignore benign errors in most auxiliary chunks. `LimitsExceeded`, `Parameter` and |
| 1056 |
// other error kinds are *not* treated as benign. We don't ignore errors in `fcTL` |
| 1057 |
// chunks because the fallback to the static/non-animated image has to be |
| 1058 |
// implemented *on top* of the `StreamingDecoder` API. |
| 1059 |
// |
| 1060 |
// TODO: Consider supporting a strict mode where even benign errors are reported up. |
| 1061 |
// See https://github.com/image-rs/image-png/pull/569#issuecomment-2642062285 |
| 1062 |
Ok(Decoded::BadAncillaryChunk(type_str)) |
| 1063 |
} |
| 1064 |
Err(e) => Err(e), |
| 1065 |
} |
| 1066 |
} |
| 1067 |
|
| 1068 |
fn parse_fctl(&mut self) -> Result<(), DecodingError> { |
| 1069 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1070 |
let next_seq_no = buf.read_be()?; |
| 1071 |
|
| 1072 |
// Assuming that fcTL is required before *every* fdAT-sequence |
| 1073 |
self.current_seq_no = Some(if let Some(seq_no) = self.current_seq_no { |
| 1074 |
if next_seq_no != seq_no + 1 { |
| 1075 |
return Err(DecodingError::Format( |
| 1076 |
FormatErrorInner::ApngOrder { |
| 1077 |
expected: seq_no + 1, |
| 1078 |
present: next_seq_no, |
| 1079 |
} |
| 1080 |
.into(), |
| 1081 |
)); |
| 1082 |
} |
| 1083 |
next_seq_no |
| 1084 |
} else { |
| 1085 |
if next_seq_no != 0 { |
| 1086 |
return Err(DecodingError::Format( |
| 1087 |
FormatErrorInner::ApngOrder { |
| 1088 |
expected: 0, |
| 1089 |
present: next_seq_no, |
| 1090 |
} |
| 1091 |
.into(), |
| 1092 |
)); |
| 1093 |
} |
| 1094 |
0 |
| 1095 |
}); |
| 1096 |
self.inflater.reset(); |
| 1097 |
self.ready_for_fdat_chunks = true; |
| 1098 |
let fc = FrameControl { |
| 1099 |
sequence_number: next_seq_no, |
| 1100 |
width: buf.read_be()?, |
| 1101 |
height: buf.read_be()?, |
| 1102 |
x_offset: buf.read_be()?, |
| 1103 |
y_offset: buf.read_be()?, |
| 1104 |
delay_num: buf.read_be()?, |
| 1105 |
delay_den: buf.read_be()?, |
| 1106 |
dispose_op: { |
| 1107 |
let dispose_op = buf.read_be()?; |
| 1108 |
match DisposeOp::from_u8(dispose_op) { |
| 1109 |
Some(dispose_op) => dispose_op, |
| 1110 |
None => { |
| 1111 |
return Err(DecodingError::Format( |
| 1112 |
FormatErrorInner::InvalidDisposeOp(dispose_op).into(), |
| 1113 |
)) |
| 1114 |
} |
| 1115 |
} |
| 1116 |
}, |
| 1117 |
blend_op: { |
| 1118 |
let blend_op = buf.read_be()?; |
| 1119 |
match BlendOp::from_u8(blend_op) { |
| 1120 |
Some(blend_op) => blend_op, |
| 1121 |
None => { |
| 1122 |
return Err(DecodingError::Format( |
| 1123 |
FormatErrorInner::InvalidBlendOp(blend_op).into(), |
| 1124 |
)) |
| 1125 |
} |
| 1126 |
} |
| 1127 |
}, |
| 1128 |
}; |
| 1129 |
self.info.as_ref().unwrap().validate(&fc)?; |
| 1130 |
if !self.have_idat { |
| 1131 |
self.info.as_ref().unwrap().validate_default_image(&fc)?; |
| 1132 |
} |
| 1133 |
self.info.as_mut().unwrap().frame_control = Some(fc); |
| 1134 |
Ok(()) |
| 1135 |
} |
| 1136 |
|
| 1137 |
fn parse_actl(&mut self) -> Result<(), DecodingError> { |
| 1138 |
if self.have_idat { |
| 1139 |
Err(DecodingError::Format( |
| 1140 |
FormatErrorInner::AfterIdat { kind: chunk::acTL }.into(), |
| 1141 |
)) |
| 1142 |
} else { |
| 1143 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1144 |
let actl = AnimationControl { |
| 1145 |
num_frames: buf.read_be()?, |
| 1146 |
num_plays: buf.read_be()?, |
| 1147 |
}; |
| 1148 |
// The spec says that "0 is not a valid value" for `num_frames`. |
| 1149 |
// So let's ignore such malformed `acTL` chunks. |
| 1150 |
if actl.num_frames == 0 { |
| 1151 |
return Ok(()); |
| 1152 |
} |
| 1153 |
self.info.as_mut().unwrap().animation_control = Some(actl); |
| 1154 |
Ok(()) |
| 1155 |
} |
| 1156 |
} |
| 1157 |
|
| 1158 |
fn parse_plte(&mut self) -> Result<(), DecodingError> { |
| 1159 |
let info = self.info.as_mut().unwrap(); |
| 1160 |
if info.palette.is_some() { |
| 1161 |
// Only one palette is allowed |
| 1162 |
Err(DecodingError::Format( |
| 1163 |
FormatErrorInner::DuplicateChunk { kind: chunk::PLTE }.into(), |
| 1164 |
)) |
| 1165 |
} else { |
| 1166 |
self.limits |
| 1167 |
.reserve_bytes(self.current_chunk.raw_bytes.len())?; |
| 1168 |
info.palette = Some(Cow::Owned(self.current_chunk.raw_bytes.clone())); |
| 1169 |
Ok(()) |
| 1170 |
} |
| 1171 |
} |
| 1172 |
|
| 1173 |
fn parse_sbit(&mut self) -> Result<(), DecodingError> { |
| 1174 |
let info = self.info.as_mut().unwrap(); |
| 1175 |
if info.palette.is_some() { |
| 1176 |
return Err(DecodingError::Format( |
| 1177 |
FormatErrorInner::AfterPlte { kind: chunk::sBIT }.into(), |
| 1178 |
)); |
| 1179 |
} |
| 1180 |
|
| 1181 |
if self.have_idat { |
| 1182 |
return Err(DecodingError::Format( |
| 1183 |
FormatErrorInner::AfterIdat { kind: chunk::sBIT }.into(), |
| 1184 |
)); |
| 1185 |
} |
| 1186 |
|
| 1187 |
if info.sbit.is_some() { |
| 1188 |
return Err(DecodingError::Format( |
| 1189 |
FormatErrorInner::DuplicateChunk { kind: chunk::sBIT }.into(), |
| 1190 |
)); |
| 1191 |
} |
| 1192 |
|
| 1193 |
let (color_type, bit_depth) = { (info.color_type, info.bit_depth) }; |
| 1194 |
// The sample depth for color type 3 is fixed at eight bits. |
| 1195 |
let sample_depth = if color_type == ColorType::Indexed { |
| 1196 |
BitDepth::Eight |
| 1197 |
} else { |
| 1198 |
bit_depth |
| 1199 |
}; |
| 1200 |
self.limits |
| 1201 |
.reserve_bytes(self.current_chunk.raw_bytes.len())?; |
| 1202 |
let vec = self.current_chunk.raw_bytes.clone(); |
| 1203 |
let len = vec.len(); |
| 1204 |
|
| 1205 |
// expected lenth of the chunk |
| 1206 |
let expected = match color_type { |
| 1207 |
ColorType::Grayscale => 1, |
| 1208 |
ColorType::Rgb | ColorType::Indexed => 3, |
| 1209 |
ColorType::GrayscaleAlpha => 2, |
| 1210 |
ColorType::Rgba => 4, |
| 1211 |
}; |
| 1212 |
|
| 1213 |
// Check if the sbit chunk size is valid. |
| 1214 |
if expected != len { |
| 1215 |
return Err(DecodingError::Format( |
| 1216 |
FormatErrorInner::InvalidSbitChunkSize { |
| 1217 |
color_type, |
| 1218 |
expected, |
| 1219 |
len, |
| 1220 |
} |
| 1221 |
.into(), |
| 1222 |
)); |
| 1223 |
} |
| 1224 |
|
| 1225 |
for sbit in &vec { |
| 1226 |
if *sbit < 1 || *sbit > sample_depth as u8 { |
| 1227 |
return Err(DecodingError::Format( |
| 1228 |
FormatErrorInner::InvalidSbit { |
| 1229 |
sample_depth, |
| 1230 |
sbit: *sbit, |
| 1231 |
} |
| 1232 |
.into(), |
| 1233 |
)); |
| 1234 |
} |
| 1235 |
} |
| 1236 |
info.sbit = Some(Cow::Owned(vec)); |
| 1237 |
Ok(()) |
| 1238 |
} |
| 1239 |
|
| 1240 |
fn parse_trns(&mut self) -> Result<(), DecodingError> { |
| 1241 |
let info = self.info.as_mut().unwrap(); |
| 1242 |
if info.trns.is_some() { |
| 1243 |
return Err(DecodingError::Format( |
| 1244 |
FormatErrorInner::DuplicateChunk { kind: chunk::PLTE }.into(), |
| 1245 |
)); |
| 1246 |
} |
| 1247 |
let (color_type, bit_depth) = { (info.color_type, info.bit_depth as u8) }; |
| 1248 |
self.limits |
| 1249 |
.reserve_bytes(self.current_chunk.raw_bytes.len())?; |
| 1250 |
let mut vec = self.current_chunk.raw_bytes.clone(); |
| 1251 |
let len = vec.len(); |
| 1252 |
match color_type { |
| 1253 |
ColorType::Grayscale => { |
| 1254 |
if len < 2 { |
| 1255 |
return Err(DecodingError::Format( |
| 1256 |
FormatErrorInner::ShortPalette { expected: 2, len }.into(), |
| 1257 |
)); |
| 1258 |
} |
| 1259 |
if bit_depth < 16 { |
| 1260 |
vec[0] = vec[1]; |
| 1261 |
vec.truncate(1); |
| 1262 |
} |
| 1263 |
info.trns = Some(Cow::Owned(vec)); |
| 1264 |
Ok(()) |
| 1265 |
} |
| 1266 |
ColorType::Rgb => { |
| 1267 |
if len < 6 { |
| 1268 |
return Err(DecodingError::Format( |
| 1269 |
FormatErrorInner::ShortPalette { expected: 6, len }.into(), |
| 1270 |
)); |
| 1271 |
} |
| 1272 |
if bit_depth < 16 { |
| 1273 |
vec[0] = vec[1]; |
| 1274 |
vec[1] = vec[3]; |
| 1275 |
vec[2] = vec[5]; |
| 1276 |
vec.truncate(3); |
| 1277 |
} |
| 1278 |
info.trns = Some(Cow::Owned(vec)); |
| 1279 |
Ok(()) |
| 1280 |
} |
| 1281 |
ColorType::Indexed => { |
| 1282 |
// The transparency chunk must be after the palette chunk and |
| 1283 |
// before the data chunk. |
| 1284 |
if info.palette.is_none() { |
| 1285 |
return Err(DecodingError::Format( |
| 1286 |
FormatErrorInner::BeforePlte { kind: chunk::tRNS }.into(), |
| 1287 |
)); |
| 1288 |
} else if self.have_idat { |
| 1289 |
return Err(DecodingError::Format( |
| 1290 |
FormatErrorInner::OutsidePlteIdat { kind: chunk::tRNS }.into(), |
| 1291 |
)); |
| 1292 |
} |
| 1293 |
|
| 1294 |
info.trns = Some(Cow::Owned(vec)); |
| 1295 |
Ok(()) |
| 1296 |
} |
| 1297 |
c => Err(DecodingError::Format( |
| 1298 |
FormatErrorInner::ColorWithBadTrns(c).into(), |
| 1299 |
)), |
| 1300 |
} |
| 1301 |
} |
| 1302 |
|
| 1303 |
fn parse_phys(&mut self) -> Result<(), DecodingError> { |
| 1304 |
let info = self.info.as_mut().unwrap(); |
| 1305 |
if self.have_idat { |
| 1306 |
Err(DecodingError::Format( |
| 1307 |
FormatErrorInner::AfterIdat { kind: chunk::pHYs }.into(), |
| 1308 |
)) |
| 1309 |
} else if info.pixel_dims.is_some() { |
| 1310 |
Err(DecodingError::Format( |
| 1311 |
FormatErrorInner::DuplicateChunk { kind: chunk::pHYs }.into(), |
| 1312 |
)) |
| 1313 |
} else { |
| 1314 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1315 |
let xppu = buf.read_be()?; |
| 1316 |
let yppu = buf.read_be()?; |
| 1317 |
let unit = buf.read_be()?; |
| 1318 |
let unit = match Unit::from_u8(unit) { |
| 1319 |
Some(unit) => unit, |
| 1320 |
None => { |
| 1321 |
return Err(DecodingError::Format( |
| 1322 |
FormatErrorInner::InvalidUnit(unit).into(), |
| 1323 |
)) |
| 1324 |
} |
| 1325 |
}; |
| 1326 |
let pixel_dims = PixelDimensions { xppu, yppu, unit }; |
| 1327 |
info.pixel_dims = Some(pixel_dims); |
| 1328 |
Ok(()) |
| 1329 |
} |
| 1330 |
} |
| 1331 |
|
| 1332 |
fn parse_chrm(&mut self) -> Result<(), DecodingError> { |
| 1333 |
let info = self.info.as_mut().unwrap(); |
| 1334 |
if self.have_idat { |
| 1335 |
Err(DecodingError::Format( |
| 1336 |
FormatErrorInner::AfterIdat { kind: chunk::cHRM }.into(), |
| 1337 |
)) |
| 1338 |
} else if info.chrm_chunk.is_some() { |
| 1339 |
Err(DecodingError::Format( |
| 1340 |
FormatErrorInner::DuplicateChunk { kind: chunk::cHRM }.into(), |
| 1341 |
)) |
| 1342 |
} else { |
| 1343 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1344 |
let white_x: u32 = buf.read_be()?; |
| 1345 |
let white_y: u32 = buf.read_be()?; |
| 1346 |
let red_x: u32 = buf.read_be()?; |
| 1347 |
let red_y: u32 = buf.read_be()?; |
| 1348 |
let green_x: u32 = buf.read_be()?; |
| 1349 |
let green_y: u32 = buf.read_be()?; |
| 1350 |
let blue_x: u32 = buf.read_be()?; |
| 1351 |
let blue_y: u32 = buf.read_be()?; |
| 1352 |
|
| 1353 |
let source_chromaticities = SourceChromaticities { |
| 1354 |
white: ( |
| 1355 |
ScaledFloat::from_scaled(white_x), |
| 1356 |
ScaledFloat::from_scaled(white_y), |
| 1357 |
), |
| 1358 |
red: ( |
| 1359 |
ScaledFloat::from_scaled(red_x), |
| 1360 |
ScaledFloat::from_scaled(red_y), |
| 1361 |
), |
| 1362 |
green: ( |
| 1363 |
ScaledFloat::from_scaled(green_x), |
| 1364 |
ScaledFloat::from_scaled(green_y), |
| 1365 |
), |
| 1366 |
blue: ( |
| 1367 |
ScaledFloat::from_scaled(blue_x), |
| 1368 |
ScaledFloat::from_scaled(blue_y), |
| 1369 |
), |
| 1370 |
}; |
| 1371 |
|
| 1372 |
info.chrm_chunk = Some(source_chromaticities); |
| 1373 |
Ok(()) |
| 1374 |
} |
| 1375 |
} |
| 1376 |
|
| 1377 |
fn parse_gama(&mut self) -> Result<(), DecodingError> { |
| 1378 |
let info = self.info.as_mut().unwrap(); |
| 1379 |
if self.have_idat { |
| 1380 |
Err(DecodingError::Format( |
| 1381 |
FormatErrorInner::AfterIdat { kind: chunk::gAMA }.into(), |
| 1382 |
)) |
| 1383 |
} else if info.gama_chunk.is_some() { |
| 1384 |
Err(DecodingError::Format( |
| 1385 |
FormatErrorInner::DuplicateChunk { kind: chunk::gAMA }.into(), |
| 1386 |
)) |
| 1387 |
} else { |
| 1388 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1389 |
let source_gamma: u32 = buf.read_be()?; |
| 1390 |
if source_gamma == 0 { |
| 1391 |
return Err(DecodingError::Format( |
| 1392 |
FormatErrorInner::BadGammaValue.into(), |
| 1393 |
)); |
| 1394 |
} |
| 1395 |
|
| 1396 |
let source_gamma = ScaledFloat::from_scaled(source_gamma); |
| 1397 |
info.gama_chunk = Some(source_gamma); |
| 1398 |
Ok(()) |
| 1399 |
} |
| 1400 |
} |
| 1401 |
|
| 1402 |
fn parse_srgb(&mut self) -> Result<(), DecodingError> { |
| 1403 |
let info = self.info.as_mut().unwrap(); |
| 1404 |
if self.have_idat { |
| 1405 |
Err(DecodingError::Format( |
| 1406 |
FormatErrorInner::AfterIdat { kind: chunk::sRGB }.into(), |
| 1407 |
)) |
| 1408 |
} else if info.srgb.is_some() { |
| 1409 |
Err(DecodingError::Format( |
| 1410 |
FormatErrorInner::DuplicateChunk { kind: chunk::sRGB }.into(), |
| 1411 |
)) |
| 1412 |
} else { |
| 1413 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1414 |
let raw: u8 = buf.read_be()?; // BE is is nonsense for single bytes, but this way the size is checked. |
| 1415 |
let rendering_intent = crate::SrgbRenderingIntent::from_raw(raw).ok_or_else(|| { |
| 1416 |
FormatError::from(FormatErrorInner::InvalidSrgbRenderingIntent(raw)) |
| 1417 |
})?; |
| 1418 |
|
| 1419 |
// Set srgb and override source gamma and chromaticities. |
| 1420 |
info.srgb = Some(rendering_intent); |
| 1421 |
Ok(()) |
| 1422 |
} |
| 1423 |
} |
| 1424 |
|
| 1425 |
fn parse_cicp(&mut self) -> Result<(), DecodingError> { |
| 1426 |
let info = self.info.as_mut().unwrap(); |
| 1427 |
|
| 1428 |
// The spec requires that the cICP chunk MUST come before the PLTE and IDAT chunks. |
| 1429 |
if info.coding_independent_code_points.is_some() { |
| 1430 |
return Err(DecodingError::Format( |
| 1431 |
FormatErrorInner::DuplicateChunk { kind: chunk::cICP }.into(), |
| 1432 |
)); |
| 1433 |
} else if info.palette.is_some() { |
| 1434 |
return Err(DecodingError::Format( |
| 1435 |
FormatErrorInner::AfterPlte { kind: chunk::cICP }.into(), |
| 1436 |
)); |
| 1437 |
} else if self.have_idat { |
| 1438 |
return Err(DecodingError::Format( |
| 1439 |
FormatErrorInner::AfterIdat { kind: chunk::cICP }.into(), |
| 1440 |
)); |
| 1441 |
} |
| 1442 |
|
| 1443 |
let mut buf = &*self.current_chunk.raw_bytes; |
| 1444 |
let color_primaries: u8 = buf.read_be()?; |
| 1445 |
let transfer_function: u8 = buf.read_be()?; |
| 1446 |
let matrix_coefficients: u8 = buf.read_be()?; |
| 1447 |
let is_video_full_range_image = { |
| 1448 |
let flag: u8 = buf.read_be()?; |
| 1449 |
match flag { |
| 1450 |
0 => false, |
| 1451 |
1 => true, |
| 1452 |
_ => { |
| 1453 |
return Err(DecodingError::IoError( |
| 1454 |
std::io::ErrorKind::InvalidData.into(), |
| 1455 |
)); |
| 1456 |
} |
| 1457 |
} |
| 1458 |
}; |
| 1459 |
|
| 1460 |
// RGB is currently the only supported color model in PNG, and as |
| 1461 |
// such Matrix Coefficients shall be set to 0. |
| 1462 |
if matrix_coefficients != 0 { |
| 1463 |
return Err(DecodingError::IoError( |
| 1464 |
std::io::ErrorKind::InvalidData.into(), |
| 1465 |
)); |
| 1466 |
} |
| 1467 |
|
| 1468 |
if !buf.is_empty() { |
| 1469 |
return Err(DecodingError::IoError( |
| 1470 |
std::io::ErrorKind::InvalidData.into(), |
| 1471 |
)); |
| 1472 |
} |
| 1473 |
|
| 1474 |
info.coding_independent_code_points = Some(CodingIndependentCodePoints { |
| 1475 |
color_primaries, |
| 1476 |
transfer_function, |
| 1477 |
matrix_coefficients, |
| 1478 |
is_video_full_range_image, |
| 1479 |
}); |
| 1480 |
|
| 1481 |
Ok(()) |
| 1482 |
} |
| 1483 |
|
| 1484 |
fn parse_mdcv(&mut self) -> Result<(), DecodingError> { |
| 1485 |
let info = self.info.as_mut().unwrap(); |
| 1486 |
|
| 1487 |
// The spec requires that the mDCV chunk MUST come before the PLTE and IDAT chunks. |
| 1488 |
if info.mastering_display_color_volume.is_some() { |
| 1489 |
return Err(DecodingError::Format( |
| 1490 |
FormatErrorInner::DuplicateChunk { kind: chunk::mDCV }.into(), |
| 1491 |
)); |
| 1492 |
} else if info.palette.is_some() { |
| 1493 |
return Err(DecodingError::Format( |
| 1494 |
FormatErrorInner::AfterPlte { kind: chunk::mDCV }.into(), |
| 1495 |
)); |
| 1496 |
} else if self.have_idat { |
| 1497 |
return Err(DecodingError::Format( |
| 1498 |
FormatErrorInner::AfterIdat { kind: chunk::mDCV }.into(), |
| 1499 |
)); |
| 1500 |
} |
| 1501 |
|
| 1502 |
let mut buf = &*self.current_chunk.raw_bytes; |
| 1503 |
let red_x: u16 = buf.read_be()?; |
| 1504 |
let red_y: u16 = buf.read_be()?; |
| 1505 |
let green_x: u16 = buf.read_be()?; |
| 1506 |
let green_y: u16 = buf.read_be()?; |
| 1507 |
let blue_x: u16 = buf.read_be()?; |
| 1508 |
let blue_y: u16 = buf.read_be()?; |
| 1509 |
let white_x: u16 = buf.read_be()?; |
| 1510 |
let white_y: u16 = buf.read_be()?; |
| 1511 |
fn scale(chunk: u16) -> ScaledFloat { |
| 1512 |
// `ScaledFloat::SCALING` is hardcoded to 100_000, which works |
| 1513 |
// well for the `cHRM` chunk where the spec says that "a value |
| 1514 |
// of 0.3127 would be stored as the integer 31270". In the |
| 1515 |
// `mDCV` chunk the spec says that "0.708, 0.292)" is stored as |
| 1516 |
// "{ 35400, 14600 }", using a scaling factor of 50_000, so we |
| 1517 |
// multiply by 2 before converting. |
| 1518 |
ScaledFloat::from_scaled((chunk as u32) * 2) |
| 1519 |
} |
| 1520 |
let chromaticities = SourceChromaticities { |
| 1521 |
white: (scale(white_x), scale(white_y)), |
| 1522 |
red: (scale(red_x), scale(red_y)), |
| 1523 |
green: (scale(green_x), scale(green_y)), |
| 1524 |
blue: (scale(blue_x), scale(blue_y)), |
| 1525 |
}; |
| 1526 |
let max_luminance: u32 = buf.read_be()?; |
| 1527 |
let min_luminance: u32 = buf.read_be()?; |
| 1528 |
if !buf.is_empty() { |
| 1529 |
return Err(DecodingError::IoError( |
| 1530 |
std::io::ErrorKind::InvalidData.into(), |
| 1531 |
)); |
| 1532 |
} |
| 1533 |
info.mastering_display_color_volume = Some(MasteringDisplayColorVolume { |
| 1534 |
chromaticities, |
| 1535 |
max_luminance, |
| 1536 |
min_luminance, |
| 1537 |
}); |
| 1538 |
|
| 1539 |
Ok(()) |
| 1540 |
} |
| 1541 |
|
| 1542 |
fn parse_clli(&mut self) -> Result<(), DecodingError> { |
| 1543 |
let info = self.info.as_mut().unwrap(); |
| 1544 |
if info.content_light_level.is_some() { |
| 1545 |
return Err(DecodingError::Format( |
| 1546 |
FormatErrorInner::DuplicateChunk { kind: chunk::cLLI }.into(), |
| 1547 |
)); |
| 1548 |
} |
| 1549 |
|
| 1550 |
let mut buf = &*self.current_chunk.raw_bytes; |
| 1551 |
let max_content_light_level: u32 = buf.read_be()?; |
| 1552 |
let max_frame_average_light_level: u32 = buf.read_be()?; |
| 1553 |
if !buf.is_empty() { |
| 1554 |
return Err(DecodingError::IoError( |
| 1555 |
std::io::ErrorKind::InvalidData.into(), |
| 1556 |
)); |
| 1557 |
} |
| 1558 |
info.content_light_level = Some(ContentLightLevelInfo { |
| 1559 |
max_content_light_level, |
| 1560 |
max_frame_average_light_level, |
| 1561 |
}); |
| 1562 |
|
| 1563 |
Ok(()) |
| 1564 |
} |
| 1565 |
|
| 1566 |
fn parse_exif(&mut self) -> Result<(), DecodingError> { |
| 1567 |
let info = self.info.as_mut().unwrap(); |
| 1568 |
if info.exif_metadata.is_some() { |
| 1569 |
return Err(DecodingError::Format( |
| 1570 |
FormatErrorInner::DuplicateChunk { kind: chunk::eXIf }.into(), |
| 1571 |
)); |
| 1572 |
} |
| 1573 |
|
| 1574 |
info.exif_metadata = Some(self.current_chunk.raw_bytes.clone().into()); |
| 1575 |
Ok(()) |
| 1576 |
} |
| 1577 |
|
| 1578 |
fn parse_iccp(&mut self) -> Result<(), DecodingError> { |
| 1579 |
if self.have_idat { |
| 1580 |
Err(DecodingError::Format( |
| 1581 |
FormatErrorInner::AfterIdat { kind: chunk::iCCP }.into(), |
| 1582 |
)) |
| 1583 |
} else if self.have_iccp { |
| 1584 |
Err(DecodingError::Format( |
| 1585 |
FormatErrorInner::DuplicateChunk { kind: chunk::iCCP }.into(), |
| 1586 |
)) |
| 1587 |
} else { |
| 1588 |
self.have_iccp = true; |
| 1589 |
let _ = self.parse_iccp_raw(); |
| 1590 |
Ok(()) |
| 1591 |
} |
| 1592 |
} |
| 1593 |
|
| 1594 |
fn parse_iccp_raw(&mut self) -> Result<(), DecodingError> { |
| 1595 |
let info = self.info.as_mut().unwrap(); |
| 1596 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1597 |
|
| 1598 |
// read profile name |
| 1599 |
for len in 0..=80 { |
| 1600 |
let raw: u8 = buf.read_be()?; |
| 1601 |
if (raw == 0 && len == 0) || (raw != 0 && len == 80) { |
| 1602 |
return Err(DecodingError::from(TextDecodingError::InvalidKeywordSize)); |
| 1603 |
} |
| 1604 |
if raw == 0 { |
| 1605 |
break; |
| 1606 |
} |
| 1607 |
} |
| 1608 |
|
| 1609 |
match buf.read_be()? { |
| 1610 |
// compression method |
| 1611 |
0u8 => (), |
| 1612 |
n => { |
| 1613 |
return Err(DecodingError::Format( |
| 1614 |
FormatErrorInner::UnknownCompressionMethod(n).into(), |
| 1615 |
)) |
| 1616 |
} |
| 1617 |
} |
| 1618 |
|
| 1619 |
match fdeflate::decompress_to_vec_bounded(buf, self.limits.bytes) { |
| 1620 |
Ok(profile) => { |
| 1621 |
self.limits.reserve_bytes(profile.len())?; |
| 1622 |
info.icc_profile = Some(Cow::Owned(profile)); |
| 1623 |
} |
| 1624 |
Err(fdeflate::BoundedDecompressionError::DecompressionError { inner: err }) => { |
| 1625 |
return Err(DecodingError::Format( |
| 1626 |
FormatErrorInner::CorruptFlateStream { err }.into(), |
| 1627 |
)) |
| 1628 |
} |
| 1629 |
Err(fdeflate::BoundedDecompressionError::OutputTooLarge { .. }) => { |
| 1630 |
return Err(DecodingError::LimitsExceeded); |
| 1631 |
} |
| 1632 |
} |
| 1633 |
|
| 1634 |
Ok(()) |
| 1635 |
} |
| 1636 |
|
| 1637 |
fn parse_ihdr(&mut self) -> Result<(), DecodingError> { |
| 1638 |
if self.info.is_some() { |
| 1639 |
return Err(DecodingError::Format( |
| 1640 |
FormatErrorInner::DuplicateChunk { kind: IHDR }.into(), |
| 1641 |
)); |
| 1642 |
} |
| 1643 |
let mut buf = &self.current_chunk.raw_bytes[..]; |
| 1644 |
let width = buf.read_be()?; |
| 1645 |
let height = buf.read_be()?; |
| 1646 |
if width == 0 || height == 0 { |
| 1647 |
return Err(DecodingError::Format( |
| 1648 |
FormatErrorInner::InvalidDimensions.into(), |
| 1649 |
)); |
| 1650 |
} |
| 1651 |
let bit_depth = buf.read_be()?; |
| 1652 |
let bit_depth = match BitDepth::from_u8(bit_depth) { |
| 1653 |
Some(bits) => bits, |
| 1654 |
None => { |
| 1655 |
return Err(DecodingError::Format( |
| 1656 |
FormatErrorInner::InvalidBitDepth(bit_depth).into(), |
| 1657 |
)) |
| 1658 |
} |
| 1659 |
}; |
| 1660 |
let color_type = buf.read_be()?; |
| 1661 |
let color_type = match ColorType::from_u8(color_type) { |
| 1662 |
Some(color_type) => { |
| 1663 |
if color_type.is_combination_invalid(bit_depth) { |
| 1664 |
return Err(DecodingError::Format( |
| 1665 |
FormatErrorInner::InvalidColorBitDepth { |
| 1666 |
color_type, |
| 1667 |
bit_depth, |
| 1668 |
} |
| 1669 |
.into(), |
| 1670 |
)); |
| 1671 |
} else { |
| 1672 |
color_type |
| 1673 |
} |
| 1674 |
} |
| 1675 |
None => { |
| 1676 |
return Err(DecodingError::Format( |
| 1677 |
FormatErrorInner::InvalidColorType(color_type).into(), |
| 1678 |
)) |
| 1679 |
} |
| 1680 |
}; |
| 1681 |
match buf.read_be()? { |
| 1682 |
// compression method |
| 1683 |
0u8 => (), |
| 1684 |
n => { |
| 1685 |
return Err(DecodingError::Format( |
| 1686 |
FormatErrorInner::UnknownCompressionMethod(n).into(), |
| 1687 |
)) |
| 1688 |
} |
| 1689 |
} |
| 1690 |
match buf.read_be()? { |
| 1691 |
// filter method |
| 1692 |
0u8 => (), |
| 1693 |
n => { |
| 1694 |
return Err(DecodingError::Format( |
| 1695 |
FormatErrorInner::UnknownFilterMethod(n).into(), |
| 1696 |
)) |
| 1697 |
} |
| 1698 |
} |
| 1699 |
let interlaced = match buf.read_be()? { |
| 1700 |
0u8 => false, |
| 1701 |
1 => true, |
| 1702 |
n => { |
| 1703 |
return Err(DecodingError::Format( |
| 1704 |
FormatErrorInner::UnknownInterlaceMethod(n).into(), |
| 1705 |
)) |
| 1706 |
} |
| 1707 |
}; |
| 1708 |
|
| 1709 |
self.info = Some(Info { |
| 1710 |
width, |
| 1711 |
height, |
| 1712 |
bit_depth, |
| 1713 |
color_type, |
| 1714 |
interlaced, |
| 1715 |
..Default::default() |
| 1716 |
}); |
| 1717 |
|
| 1718 |
Ok(()) |
| 1719 |
} |
| 1720 |
|
| 1721 |
fn split_keyword(buf: &[u8]) -> Result<(&[u8], &[u8]), DecodingError> { |
| 1722 |
let null_byte_index = buf |
| 1723 |
.iter() |
| 1724 |
.position(|&b| b == 0) |
| 1725 |
.ok_or_else(|| DecodingError::from(TextDecodingError::MissingNullSeparator))?; |
| 1726 |
|
| 1727 |
if null_byte_index == 0 || null_byte_index > 79 { |
| 1728 |
return Err(DecodingError::from(TextDecodingError::InvalidKeywordSize)); |
| 1729 |
} |
| 1730 |
|
| 1731 |
Ok((&buf[..null_byte_index], &buf[null_byte_index + 1..])) |
| 1732 |
} |
| 1733 |
|
| 1734 |
fn parse_text(&mut self) -> Result<(), DecodingError> { |
| 1735 |
let buf = &self.current_chunk.raw_bytes[..]; |
| 1736 |
self.limits.reserve_bytes(buf.len())?; |
| 1737 |
|
| 1738 |
let (keyword_slice, value_slice) = Self::split_keyword(buf)?; |
| 1739 |
|
| 1740 |
self.info |
| 1741 |
.as_mut() |
| 1742 |
.unwrap() |
| 1743 |
.uncompressed_latin1_text |
| 1744 |
.push(TEXtChunk::decode(keyword_slice, value_slice).map_err(DecodingError::from)?); |
| 1745 |
|
| 1746 |
Ok(()) |
| 1747 |
} |
| 1748 |
|
| 1749 |
fn parse_ztxt(&mut self) -> Result<(), DecodingError> { |
| 1750 |
let buf = &self.current_chunk.raw_bytes[..]; |
| 1751 |
self.limits.reserve_bytes(buf.len())?; |
| 1752 |
|
| 1753 |
let (keyword_slice, value_slice) = Self::split_keyword(buf)?; |
| 1754 |
|
| 1755 |
let compression_method = *value_slice |
| 1756 |
.first() |
| 1757 |
.ok_or_else(|| DecodingError::from(TextDecodingError::InvalidCompressionMethod))?; |
| 1758 |
|
| 1759 |
let text_slice = &value_slice[1..]; |
| 1760 |
|
| 1761 |
self.info.as_mut().unwrap().compressed_latin1_text.push( |
| 1762 |
ZTXtChunk::decode(keyword_slice, compression_method, text_slice) |
| 1763 |
.map_err(DecodingError::from)?, |
| 1764 |
); |
| 1765 |
|
| 1766 |
Ok(()) |
| 1767 |
} |
| 1768 |
|
| 1769 |
fn parse_itxt(&mut self) -> Result<(), DecodingError> { |
| 1770 |
let buf = &self.current_chunk.raw_bytes[..]; |
| 1771 |
self.limits.reserve_bytes(buf.len())?; |
| 1772 |
|
| 1773 |
let (keyword_slice, value_slice) = Self::split_keyword(buf)?; |
| 1774 |
|
| 1775 |
let compression_flag = *value_slice |
| 1776 |
.first() |
| 1777 |
.ok_or_else(|| DecodingError::from(TextDecodingError::MissingCompressionFlag))?; |
| 1778 |
|
| 1779 |
let compression_method = *value_slice |
| 1780 |
.get(1) |
| 1781 |
.ok_or_else(|| DecodingError::from(TextDecodingError::InvalidCompressionMethod))?; |
| 1782 |
|
| 1783 |
let second_null_byte_index = value_slice[2..] |
| 1784 |
.iter() |
| 1785 |
.position(|&b| b == 0) |
| 1786 |
.ok_or_else(|| DecodingError::from(TextDecodingError::MissingNullSeparator))? |
| 1787 |
+ 2; |
| 1788 |
|
| 1789 |
let language_tag_slice = &value_slice[2..second_null_byte_index]; |
| 1790 |
|
| 1791 |
let third_null_byte_index = value_slice[second_null_byte_index + 1..] |
| 1792 |
.iter() |
| 1793 |
.position(|&b| b == 0) |
| 1794 |
.ok_or_else(|| DecodingError::from(TextDecodingError::MissingNullSeparator))? |
| 1795 |
+ (second_null_byte_index + 1); |
| 1796 |
|
| 1797 |
let translated_keyword_slice = |
| 1798 |
&value_slice[second_null_byte_index + 1..third_null_byte_index]; |
| 1799 |
|
| 1800 |
let text_slice = &value_slice[third_null_byte_index + 1..]; |
| 1801 |
|
| 1802 |
self.info.as_mut().unwrap().utf8_text.push( |
| 1803 |
ITXtChunk::decode( |
| 1804 |
keyword_slice, |
| 1805 |
compression_flag, |
| 1806 |
compression_method, |
| 1807 |
language_tag_slice, |
| 1808 |
translated_keyword_slice, |
| 1809 |
text_slice, |
| 1810 |
) |
| 1811 |
.map_err(DecodingError::from)?, |
| 1812 |
); |
| 1813 |
|
| 1814 |
Ok(()) |
| 1815 |
} |
| 1816 |
|
| 1817 |
fn parse_bkgd(&mut self) -> Result<(), DecodingError> { |
| 1818 |
let info = self.info.as_mut().unwrap(); |
| 1819 |
if info.bkgd.is_some() { |
| 1820 |
// Only one bKGD chunk is allowed |
| 1821 |
return Err(DecodingError::Format( |
| 1822 |
FormatErrorInner::DuplicateChunk { kind: chunk::bKGD }.into(), |
| 1823 |
)); |
| 1824 |
} else if self.have_idat { |
| 1825 |
return Err(DecodingError::Format( |
| 1826 |
FormatErrorInner::AfterIdat { kind: chunk::bKGD }.into(), |
| 1827 |
)); |
| 1828 |
} |
| 1829 |
|
| 1830 |
let expected = match info.color_type { |
| 1831 |
ColorType::Indexed => { |
| 1832 |
if info.palette.is_none() { |
| 1833 |
return Err(DecodingError::IoError( |
| 1834 |
std::io::ErrorKind::InvalidData.into(), |
| 1835 |
)); |
| 1836 |
}; |
| 1837 |
1 |
| 1838 |
} |
| 1839 |
ColorType::Grayscale | ColorType::GrayscaleAlpha => 2, |
| 1840 |
ColorType::Rgb | ColorType::Rgba => 6, |
| 1841 |
}; |
| 1842 |
let vec = self.current_chunk.raw_bytes.clone(); |
| 1843 |
if vec.len() != expected { |
| 1844 |
return Err(DecodingError::Format( |
| 1845 |
FormatErrorInner::ChunkTooShort { kind: chunk::bKGD }.into(), |
| 1846 |
)); |
| 1847 |
} |
| 1848 |
|
| 1849 |
info.bkgd = Some(Cow::Owned(vec)); |
| 1850 |
Ok(()) |
| 1851 |
} |
| 1852 |
} |
| 1853 |
|
| 1854 |
impl Info<'_> { |
| 1855 |
fn validate_default_image(&self, fc: &FrameControl) -> Result<(), DecodingError> { |
| 1856 |
// https://www.w3.org/TR/png-3/#fcTL-chunk says that: |
| 1857 |
// |
| 1858 |
// > The fcTL chunk corresponding to the default image, if it exists, has these |
| 1859 |
// > restrictions: |
| 1860 |
// > |
| 1861 |
// > * The x_offset and y_offset fields must be 0. |
| 1862 |
// > * The width and height fields must equal |
| 1863 |
// > the corresponding fields from the IHDR chunk. |
| 1864 |
if fc.x_offset != 0 |
| 1865 |
|| fc.y_offset != 0 |
| 1866 |
|| fc.width != self.width |
| 1867 |
|| fc.height != self.height |
| 1868 |
{ |
| 1869 |
return Err(DecodingError::Format( |
| 1870 |
FormatErrorInner::BadSubFrameBounds {}.into(), |
| 1871 |
)); |
| 1872 |
} |
| 1873 |
Ok(()) |
| 1874 |
} |
| 1875 |
|
| 1876 |
fn validate(&self, fc: &FrameControl) -> Result<(), DecodingError> { |
| 1877 |
if fc.width == 0 || fc.height == 0 { |
| 1878 |
return Err(DecodingError::Format( |
| 1879 |
FormatErrorInner::InvalidDimensions.into(), |
| 1880 |
)); |
| 1881 |
} |
| 1882 |
|
| 1883 |
// Validate mathematically: fc.width + fc.x_offset <= self.width |
| 1884 |
let in_x_bounds = Some(fc.width) <= self.width.checked_sub(fc.x_offset); |
| 1885 |
// Validate mathematically: fc.height + fc.y_offset <= self.height |
| 1886 |
let in_y_bounds = Some(fc.height) <= self.height.checked_sub(fc.y_offset); |
| 1887 |
|
| 1888 |
if !in_x_bounds || !in_y_bounds { |
| 1889 |
return Err(DecodingError::Format( |
| 1890 |
// TODO: do we want to display the bad bounds? |
| 1891 |
FormatErrorInner::BadSubFrameBounds {}.into(), |
| 1892 |
)); |
| 1893 |
} |
| 1894 |
|
| 1895 |
Ok(()) |
| 1896 |
} |
| 1897 |
} |
| 1898 |
|
| 1899 |
impl Default for StreamingDecoder { |
| 1900 |
fn default() -> Self { |
| 1901 |
Self::new() |
| 1902 |
} |
| 1903 |
} |
| 1904 |
|
| 1905 |
#[cfg(test)] |
| 1906 |
mod tests { |
| 1907 |
use super::ScaledFloat; |
| 1908 |
use super::SourceChromaticities; |
| 1909 |
use crate::test_utils::*; |
| 1910 |
use crate::{Decoder, DecodingError, Reader, SrgbRenderingIntent, Unit}; |
| 1911 |
use approx::assert_relative_eq; |
| 1912 |
use byteorder::WriteBytesExt; |
| 1913 |
use std::borrow::Cow; |
| 1914 |
use std::cell::RefCell; |
| 1915 |
|
| 1916 |
use std::fs::File; |
| 1917 |
use std::io::BufRead; |
| 1918 |
use std::io::Cursor; |
| 1919 |
use std::io::Seek; |
| 1920 |
use std::io::{BufReader, ErrorKind, Read, Write}; |
| 1921 |
use std::rc::Rc; |
| 1922 |
|
| 1923 |
#[test] |
| 1924 |
fn image_gamma() -> Result<(), ()> { |
| 1925 |
fn trial(path: &str, expected: Option<ScaledFloat>) { |
| 1926 |
let decoder = crate::Decoder::new(BufReader::new(File::open(path).unwrap())); |
| 1927 |
let reader = decoder.read_info().unwrap(); |
| 1928 |
let actual: Option<ScaledFloat> = reader.info().gamma(); |
| 1929 |
assert!(actual == expected); |
| 1930 |
} |
| 1931 |
trial("tests/pngsuite/f00n0g08.png", None); |
| 1932 |
trial("tests/pngsuite/f00n2c08.png", None); |
| 1933 |
trial("tests/pngsuite/f01n0g08.png", None); |
| 1934 |
trial("tests/pngsuite/f01n2c08.png", None); |
| 1935 |
trial("tests/pngsuite/f02n0g08.png", None); |
| 1936 |
trial("tests/pngsuite/f02n2c08.png", None); |
| 1937 |
trial("tests/pngsuite/f03n0g08.png", None); |
| 1938 |
trial("tests/pngsuite/f03n2c08.png", None); |
| 1939 |
trial("tests/pngsuite/f04n0g08.png", None); |
| 1940 |
trial("tests/pngsuite/f04n2c08.png", None); |
| 1941 |
trial("tests/pngsuite/f99n0g04.png", None); |
| 1942 |
trial("tests/pngsuite/tm3n3p02.png", None); |
| 1943 |
trial("tests/pngsuite/g03n0g16.png", Some(ScaledFloat::new(0.35))); |
| 1944 |
trial("tests/pngsuite/g03n2c08.png", Some(ScaledFloat::new(0.35))); |
| 1945 |
trial("tests/pngsuite/g03n3p04.png", Some(ScaledFloat::new(0.35))); |
| 1946 |
trial("tests/pngsuite/g04n0g16.png", Some(ScaledFloat::new(0.45))); |
| 1947 |
trial("tests/pngsuite/g04n2c08.png", Some(ScaledFloat::new(0.45))); |
| 1948 |
trial("tests/pngsuite/g04n3p04.png", Some(ScaledFloat::new(0.45))); |
| 1949 |
trial("tests/pngsuite/g05n0g16.png", Some(ScaledFloat::new(0.55))); |
| 1950 |
trial("tests/pngsuite/g05n2c08.png", Some(ScaledFloat::new(0.55))); |
| 1951 |
trial("tests/pngsuite/g05n3p04.png", Some(ScaledFloat::new(0.55))); |
| 1952 |
trial("tests/pngsuite/g07n0g16.png", Some(ScaledFloat::new(0.7))); |
| 1953 |
trial("tests/pngsuite/g07n2c08.png", Some(ScaledFloat::new(0.7))); |
| 1954 |
trial("tests/pngsuite/g07n3p04.png", Some(ScaledFloat::new(0.7))); |
| 1955 |
trial("tests/pngsuite/g10n0g16.png", Some(ScaledFloat::new(1.0))); |
| 1956 |
trial("tests/pngsuite/g10n2c08.png", Some(ScaledFloat::new(1.0))); |
| 1957 |
trial("tests/pngsuite/g10n3p04.png", Some(ScaledFloat::new(1.0))); |
| 1958 |
trial("tests/pngsuite/g25n0g16.png", Some(ScaledFloat::new(2.5))); |
| 1959 |
trial("tests/pngsuite/g25n2c08.png", Some(ScaledFloat::new(2.5))); |
| 1960 |
trial("tests/pngsuite/g25n3p04.png", Some(ScaledFloat::new(2.5))); |
| 1961 |
Ok(()) |
| 1962 |
} |
| 1963 |
|
| 1964 |
#[test] |
| 1965 |
fn image_source_chromaticities() -> Result<(), ()> { |
| 1966 |
fn trial(path: &str, expected: Option<SourceChromaticities>) { |
| 1967 |
let decoder = crate::Decoder::new(BufReader::new(File::open(path).unwrap())); |
| 1968 |
let reader = decoder.read_info().unwrap(); |
| 1969 |
let actual: Option<SourceChromaticities> = reader.info().chromaticities(); |
| 1970 |
assert!(actual == expected); |
| 1971 |
} |
| 1972 |
trial( |
| 1973 |
"tests/pngsuite/ccwn2c08.png", |
| 1974 |
Some(SourceChromaticities::new( |
| 1975 |
(0.3127, 0.3290), |
| 1976 |
(0.64, 0.33), |
| 1977 |
(0.30, 0.60), |
| 1978 |
(0.15, 0.06), |
| 1979 |
)), |
| 1980 |
); |
| 1981 |
trial( |
| 1982 |
"tests/pngsuite/ccwn3p08.png", |
| 1983 |
Some(SourceChromaticities::new( |
| 1984 |
(0.3127, 0.3290), |
| 1985 |
(0.64, 0.33), |
| 1986 |
(0.30, 0.60), |
| 1987 |
(0.15, 0.06), |
| 1988 |
)), |
| 1989 |
); |
| 1990 |
trial("tests/pngsuite/basi0g01.png", None); |
| 1991 |
trial("tests/pngsuite/basi0g02.png", None); |
| 1992 |
trial("tests/pngsuite/basi0g04.png", None); |
| 1993 |
trial("tests/pngsuite/basi0g08.png", None); |
| 1994 |
trial("tests/pngsuite/basi0g16.png", None); |
| 1995 |
trial("tests/pngsuite/basi2c08.png", None); |
| 1996 |
trial("tests/pngsuite/basi2c16.png", None); |
| 1997 |
trial("tests/pngsuite/basi3p01.png", None); |
| 1998 |
trial("tests/pngsuite/basi3p02.png", None); |
| 1999 |
trial("tests/pngsuite/basi3p04.png", None); |
| 2000 |
trial("tests/pngsuite/basi3p08.png", None); |
| 2001 |
trial("tests/pngsuite/basi4a08.png", None); |
| 2002 |
trial("tests/pngsuite/basi4a16.png", None); |
| 2003 |
trial("tests/pngsuite/basi6a08.png", None); |
| 2004 |
trial("tests/pngsuite/basi6a16.png", None); |
| 2005 |
trial("tests/pngsuite/basn0g01.png", None); |
| 2006 |
trial("tests/pngsuite/basn0g02.png", None); |
| 2007 |
trial("tests/pngsuite/basn0g04.png", None); |
| 2008 |
trial("tests/pngsuite/basn0g08.png", None); |
| 2009 |
trial("tests/pngsuite/basn0g16.png", None); |
| 2010 |
trial("tests/pngsuite/basn2c08.png", None); |
| 2011 |
trial("tests/pngsuite/basn2c16.png", None); |
| 2012 |
trial("tests/pngsuite/basn3p01.png", None); |
| 2013 |
trial("tests/pngsuite/basn3p02.png", None); |
| 2014 |
trial("tests/pngsuite/basn3p04.png", None); |
| 2015 |
trial("tests/pngsuite/basn3p08.png", None); |
| 2016 |
trial("tests/pngsuite/basn4a08.png", None); |
| 2017 |
trial("tests/pngsuite/basn4a16.png", None); |
| 2018 |
trial("tests/pngsuite/basn6a08.png", None); |
| 2019 |
trial("tests/pngsuite/basn6a16.png", None); |
| 2020 |
trial("tests/pngsuite/bgai4a08.png", None); |
| 2021 |
trial("tests/pngsuite/bgai4a16.png", None); |
| 2022 |
trial("tests/pngsuite/bgan6a08.png", None); |
| 2023 |
trial("tests/pngsuite/bgan6a16.png", None); |
| 2024 |
trial("tests/pngsuite/bgbn4a08.png", None); |
| 2025 |
trial("tests/pngsuite/bggn4a16.png", None); |
| 2026 |
trial("tests/pngsuite/bgwn6a08.png", None); |
| 2027 |
trial("tests/pngsuite/bgyn6a16.png", None); |
| 2028 |
trial("tests/pngsuite/cdfn2c08.png", None); |
| 2029 |
trial("tests/pngsuite/cdhn2c08.png", None); |
| 2030 |
trial("tests/pngsuite/cdsn2c08.png", None); |
| 2031 |
trial("tests/pngsuite/cdun2c08.png", None); |
| 2032 |
trial("tests/pngsuite/ch1n3p04.png", None); |
| 2033 |
trial("tests/pngsuite/ch2n3p08.png", None); |
| 2034 |
trial("tests/pngsuite/cm0n0g04.png", None); |
| 2035 |
trial("tests/pngsuite/cm7n0g04.png", None); |
| 2036 |
trial("tests/pngsuite/cm9n0g04.png", None); |
| 2037 |
trial("tests/pngsuite/cs3n2c16.png", None); |
| 2038 |
trial("tests/pngsuite/cs3n3p08.png", None); |
| 2039 |
trial("tests/pngsuite/cs5n2c08.png", None); |
| 2040 |
trial("tests/pngsuite/cs5n3p08.png", None); |
| 2041 |
trial("tests/pngsuite/cs8n2c08.png", None); |
| 2042 |
trial("tests/pngsuite/cs8n3p08.png", None); |
| 2043 |
trial("tests/pngsuite/ct0n0g04.png", None); |
| 2044 |
trial("tests/pngsuite/ct1n0g04.png", None); |
| 2045 |
trial("tests/pngsuite/cten0g04.png", None); |
| 2046 |
trial("tests/pngsuite/ctfn0g04.png", None); |
| 2047 |
trial("tests/pngsuite/ctgn0g04.png", None); |
| 2048 |
trial("tests/pngsuite/cthn0g04.png", None); |
| 2049 |
trial("tests/pngsuite/ctjn0g04.png", None); |
| 2050 |
trial("tests/pngsuite/ctzn0g04.png", None); |
| 2051 |
trial("tests/pngsuite/f00n0g08.png", None); |
| 2052 |
trial("tests/pngsuite/f00n2c08.png", None); |
| 2053 |
trial("tests/pngsuite/f01n0g08.png", None); |
| 2054 |
trial("tests/pngsuite/f01n2c08.png", None); |
| 2055 |
trial("tests/pngsuite/f02n0g08.png", None); |
| 2056 |
trial("tests/pngsuite/f02n2c08.png", None); |
| 2057 |
trial("tests/pngsuite/f03n0g08.png", None); |
| 2058 |
trial("tests/pngsuite/f03n2c08.png", None); |
| 2059 |
trial("tests/pngsuite/f04n0g08.png", None); |
| 2060 |
trial("tests/pngsuite/f04n2c08.png", None); |
| 2061 |
trial("tests/pngsuite/f99n0g04.png", None); |
| 2062 |
trial("tests/pngsuite/g03n0g16.png", None); |
| 2063 |
trial("tests/pngsuite/g03n2c08.png", None); |
| 2064 |
trial("tests/pngsuite/g03n3p04.png", None); |
| 2065 |
trial("tests/pngsuite/g04n0g16.png", None); |
| 2066 |
trial("tests/pngsuite/g04n2c08.png", None); |
| 2067 |
trial("tests/pngsuite/g04n3p04.png", None); |
| 2068 |
trial("tests/pngsuite/g05n0g16.png", None); |
| 2069 |
trial("tests/pngsuite/g05n2c08.png", None); |
| 2070 |
trial("tests/pngsuite/g05n3p04.png", None); |
| 2071 |
trial("tests/pngsuite/g07n0g16.png", None); |
| 2072 |
trial("tests/pngsuite/g07n2c08.png", None); |
| 2073 |
trial("tests/pngsuite/g07n3p04.png", None); |
| 2074 |
trial("tests/pngsuite/g10n0g16.png", None); |
| 2075 |
trial("tests/pngsuite/g10n2c08.png", None); |
| 2076 |
trial("tests/pngsuite/g10n3p04.png", None); |
| 2077 |
trial("tests/pngsuite/g25n0g16.png", None); |
| 2078 |
trial("tests/pngsuite/g25n2c08.png", None); |
| 2079 |
trial("tests/pngsuite/g25n3p04.png", None); |
| 2080 |
trial("tests/pngsuite/oi1n0g16.png", None); |
| 2081 |
trial("tests/pngsuite/oi1n2c16.png", None); |
| 2082 |
trial("tests/pngsuite/oi2n0g16.png", None); |
| 2083 |
trial("tests/pngsuite/oi2n2c16.png", None); |
| 2084 |
trial("tests/pngsuite/oi4n0g16.png", None); |
| 2085 |
trial("tests/pngsuite/oi4n2c16.png", None); |
| 2086 |
trial("tests/pngsuite/oi9n0g16.png", None); |
| 2087 |
trial("tests/pngsuite/oi9n2c16.png", None); |
| 2088 |
trial("tests/pngsuite/PngSuite.png", None); |
| 2089 |
trial("tests/pngsuite/pp0n2c16.png", None); |
| 2090 |
trial("tests/pngsuite/pp0n6a08.png", None); |
| 2091 |
trial("tests/pngsuite/ps1n0g08.png", None); |
| 2092 |
trial("tests/pngsuite/ps1n2c16.png", None); |
| 2093 |
trial("tests/pngsuite/ps2n0g08.png", None); |
| 2094 |
trial("tests/pngsuite/ps2n2c16.png", None); |
| 2095 |
trial("tests/pngsuite/s01i3p01.png", None); |
| 2096 |
trial("tests/pngsuite/s01n3p01.png", None); |
| 2097 |
trial("tests/pngsuite/s02i3p01.png", None); |
| 2098 |
trial("tests/pngsuite/s02n3p01.png", None); |
| 2099 |
trial("tests/pngsuite/s03i3p01.png", None); |
| 2100 |
trial("tests/pngsuite/s03n3p01.png", None); |
| 2101 |
trial("tests/pngsuite/s04i3p01.png", None); |
| 2102 |
trial("tests/pngsuite/s04n3p01.png", None); |
| 2103 |
trial("tests/pngsuite/s05i3p02.png", None); |
| 2104 |
trial("tests/pngsuite/s05n3p02.png", None); |
| 2105 |
trial("tests/pngsuite/s06i3p02.png", None); |
| 2106 |
trial("tests/pngsuite/s06n3p02.png", None); |
| 2107 |
trial("tests/pngsuite/s07i3p02.png", None); |
| 2108 |
trial("tests/pngsuite/s07n3p02.png", None); |
| 2109 |
trial("tests/pngsuite/s08i3p02.png", None); |
| 2110 |
trial("tests/pngsuite/s08n3p02.png", None); |
| 2111 |
trial("tests/pngsuite/s09i3p02.png", None); |
| 2112 |
trial("tests/pngsuite/s09n3p02.png", None); |
| 2113 |
trial("tests/pngsuite/s32i3p04.png", None); |
| 2114 |
trial("tests/pngsuite/s32n3p04.png", None); |
| 2115 |
trial("tests/pngsuite/s33i3p04.png", None); |
| 2116 |
trial("tests/pngsuite/s33n3p04.png", None); |
| 2117 |
trial("tests/pngsuite/s34i3p04.png", None); |
| 2118 |
trial("tests/pngsuite/s34n3p04.png", None); |
| 2119 |
trial("tests/pngsuite/s35i3p04.png", None); |
| 2120 |
trial("tests/pngsuite/s35n3p04.png", None); |
| 2121 |
trial("tests/pngsuite/s36i3p04.png", None); |
| 2122 |
trial("tests/pngsuite/s36n3p04.png", None); |
| 2123 |
trial("tests/pngsuite/s37i3p04.png", None); |
| 2124 |
trial("tests/pngsuite/s37n3p04.png", None); |
| 2125 |
trial("tests/pngsuite/s38i3p04.png", None); |
| 2126 |
trial("tests/pngsuite/s38n3p04.png", None); |
| 2127 |
trial("tests/pngsuite/s39i3p04.png", None); |
| 2128 |
trial("tests/pngsuite/s39n3p04.png", None); |
| 2129 |
trial("tests/pngsuite/s40i3p04.png", None); |
| 2130 |
trial("tests/pngsuite/s40n3p04.png", None); |
| 2131 |
trial("tests/pngsuite/tbbn0g04.png", None); |
| 2132 |
trial("tests/pngsuite/tbbn2c16.png", None); |
| 2133 |
trial("tests/pngsuite/tbbn3p08.png", None); |
| 2134 |
trial("tests/pngsuite/tbgn2c16.png", None); |
| 2135 |
trial("tests/pngsuite/tbgn3p08.png", None); |
| 2136 |
trial("tests/pngsuite/tbrn2c08.png", None); |
| 2137 |
trial("tests/pngsuite/tbwn0g16.png", None); |
| 2138 |
trial("tests/pngsuite/tbwn3p08.png", None); |
| 2139 |
trial("tests/pngsuite/tbyn3p08.png", None); |
| 2140 |
trial("tests/pngsuite/tm3n3p02.png", None); |
| 2141 |
trial("tests/pngsuite/tp0n0g08.png", None); |
| 2142 |
trial("tests/pngsuite/tp0n2c08.png", None); |
| 2143 |
trial("tests/pngsuite/tp0n3p08.png", None); |
| 2144 |
trial("tests/pngsuite/tp1n3p08.png", None); |
| 2145 |
trial("tests/pngsuite/z00n2c08.png", None); |
| 2146 |
trial("tests/pngsuite/z03n2c08.png", None); |
| 2147 |
trial("tests/pngsuite/z06n2c08.png", None); |
| 2148 |
Ok(()) |
| 2149 |
} |
| 2150 |
|
| 2151 |
#[test] |
| 2152 |
fn image_source_sbit() { |
| 2153 |
fn trial(path: &str, expected: Option<Cow<[u8]>>) { |
| 2154 |
let decoder = crate::Decoder::new(BufReader::new(File::open(path).unwrap())); |
| 2155 |
let reader = decoder.read_info().unwrap(); |
| 2156 |
let actual: Option<Cow<[u8]>> = reader.info().sbit.clone(); |
| 2157 |
assert!(actual == expected); |
| 2158 |
} |
| 2159 |
|
| 2160 |
trial("tests/sbit/g.png", Some(Cow::Owned(vec![5u8]))); |
| 2161 |
trial("tests/sbit/ga.png", Some(Cow::Owned(vec![5u8, 3u8]))); |
| 2162 |
trial( |
| 2163 |
"tests/sbit/indexed.png", |
| 2164 |
Some(Cow::Owned(vec![5u8, 6u8, 5u8])), |
| 2165 |
); |
| 2166 |
trial("tests/sbit/rgb.png", Some(Cow::Owned(vec![5u8, 6u8, 5u8]))); |
| 2167 |
trial( |
| 2168 |
"tests/sbit/rgba.png", |
| 2169 |
Some(Cow::Owned(vec![5u8, 6u8, 5u8, 8u8])), |
| 2170 |
); |
| 2171 |
} |
| 2172 |
|
| 2173 |
/// Test handling of a PNG file that contains *two* iCCP chunks. |
| 2174 |
/// This is a regression test for https://github.com/image-rs/image/issues/1825. |
| 2175 |
#[test] |
| 2176 |
fn test_two_iccp_chunks() { |
| 2177 |
// The test file has been taken from |
| 2178 |
// https://github.com/image-rs/image/issues/1825#issuecomment-1321798639, |
| 2179 |
// but the 2nd iCCP chunk has been altered manually (see the 2nd comment below for more |
| 2180 |
// details). |
| 2181 |
let decoder = crate::Decoder::new(BufReader::new( |
| 2182 |
File::open("tests/bugfixes/issue#1825.png").unwrap(), |
| 2183 |
)); |
| 2184 |
let reader = decoder.read_info().unwrap(); |
| 2185 |
let icc_profile = reader.info().icc_profile.clone().unwrap().into_owned(); |
| 2186 |
|
| 2187 |
// Assert that the contents of the *first* iCCP chunk are returned. |
| 2188 |
// |
| 2189 |
// Note that the 2nd chunk in the test file has been manually altered to have a different |
| 2190 |
// content (`b"test iccp contents"`) which would have a different CRC (797351983). |
| 2191 |
assert_eq!(4070462061, crc32fast::hash(&icc_profile)); |
| 2192 |
} |
| 2193 |
|
| 2194 |
#[test] |
| 2195 |
fn test_iccp_roundtrip() { |
| 2196 |
let dummy_icc = b"I'm a profile"; |
| 2197 |
|
| 2198 |
let mut info = crate::Info::with_size(1, 1); |
| 2199 |
info.icc_profile = Some(dummy_icc.into()); |
| 2200 |
let mut encoded_image = Vec::new(); |
| 2201 |
let enc = crate::Encoder::with_info(&mut encoded_image, info).unwrap(); |
| 2202 |
let mut enc = enc.write_header().unwrap(); |
| 2203 |
enc.write_image_data(&[0]).unwrap(); |
| 2204 |
enc.finish().unwrap(); |
| 2205 |
|
| 2206 |
let dec = crate::Decoder::new(Cursor::new(&encoded_image)); |
| 2207 |
let dec = dec.read_info().unwrap(); |
| 2208 |
assert_eq!(dummy_icc, &**dec.info().icc_profile.as_ref().unwrap()); |
| 2209 |
} |
| 2210 |
|
| 2211 |
#[test] |
| 2212 |
fn test_phys_roundtrip() { |
| 2213 |
let mut info = crate::Info::with_size(1, 1); |
| 2214 |
info.pixel_dims = Some(crate::PixelDimensions { |
| 2215 |
xppu: 12, |
| 2216 |
yppu: 34, |
| 2217 |
unit: Unit::Meter, |
| 2218 |
}); |
| 2219 |
let mut encoded_image = Vec::new(); |
| 2220 |
let enc = crate::Encoder::with_info(&mut encoded_image, info).unwrap(); |
| 2221 |
let mut enc = enc.write_header().unwrap(); |
| 2222 |
enc.write_image_data(&[0]).unwrap(); |
| 2223 |
enc.finish().unwrap(); |
| 2224 |
|
| 2225 |
let dec = crate::Decoder::new(Cursor::new(&encoded_image)); |
| 2226 |
let dec = dec.read_info().unwrap(); |
| 2227 |
let phys = dec.info().pixel_dims.as_ref().unwrap(); |
| 2228 |
assert_eq!(phys.xppu, 12); |
| 2229 |
assert_eq!(phys.yppu, 34); |
| 2230 |
assert_eq!(phys.unit, Unit::Meter); |
| 2231 |
} |
| 2232 |
|
| 2233 |
#[test] |
| 2234 |
fn test_srgb_roundtrip() { |
| 2235 |
let mut info = crate::Info::with_size(1, 1); |
| 2236 |
info.srgb = Some(SrgbRenderingIntent::Saturation); |
| 2237 |
let mut encoded_image = Vec::new(); |
| 2238 |
let enc = crate::Encoder::with_info(&mut encoded_image, info).unwrap(); |
| 2239 |
let mut enc = enc.write_header().unwrap(); |
| 2240 |
enc.write_image_data(&[0]).unwrap(); |
| 2241 |
enc.finish().unwrap(); |
| 2242 |
|
| 2243 |
let dec = crate::Decoder::new(Cursor::new(&encoded_image)); |
| 2244 |
let dec = dec.read_info().unwrap(); |
| 2245 |
assert_eq!(dec.info().srgb.unwrap(), SrgbRenderingIntent::Saturation); |
| 2246 |
} |
| 2247 |
|
| 2248 |
#[test] |
| 2249 |
fn test_png_with_broken_iccp() { |
| 2250 |
let decoder = crate::Decoder::new(BufReader::new( |
| 2251 |
File::open("tests/iccp/broken_iccp.png").unwrap(), |
| 2252 |
)); |
| 2253 |
assert!(decoder.read_info().is_ok()); |
| 2254 |
let mut decoder = crate::Decoder::new(BufReader::new( |
| 2255 |
File::open("tests/iccp/broken_iccp.png").unwrap(), |
| 2256 |
)); |
| 2257 |
decoder.set_ignore_iccp_chunk(true); |
| 2258 |
assert!(decoder.read_info().is_ok()); |
| 2259 |
} |
| 2260 |
|
| 2261 |
/// Test handling of `cICP`, `mDCV`, and `cLLI` chunks. |
| 2262 |
#[test] |
| 2263 |
fn test_cicp_mdcv_and_clli_chunks() { |
| 2264 |
let mut decoder = crate::Decoder::new(BufReader::new( |
| 2265 |
File::open("tests/bugfixes/cicp_pq.png").unwrap(), |
| 2266 |
)); |
| 2267 |
decoder.ignore_checksums(true); |
| 2268 |
let reader = decoder.read_info().unwrap(); |
| 2269 |
let info = reader.info(); |
| 2270 |
|
| 2271 |
let cicp = info.coding_independent_code_points.unwrap(); |
| 2272 |
assert_eq!(cicp.color_primaries, 9); |
| 2273 |
assert_eq!(cicp.transfer_function, 16); |
| 2274 |
assert_eq!(cicp.matrix_coefficients, 0); |
| 2275 |
assert!(cicp.is_video_full_range_image); |
| 2276 |
|
| 2277 |
let mdcv = info.mastering_display_color_volume.unwrap(); |
| 2278 |
assert_relative_eq!(mdcv.chromaticities.red.0.into_value(), 0.680); |
| 2279 |
assert_relative_eq!(mdcv.chromaticities.red.1.into_value(), 0.320); |
| 2280 |
assert_relative_eq!(mdcv.chromaticities.green.0.into_value(), 0.265); |
| 2281 |
assert_relative_eq!(mdcv.chromaticities.green.1.into_value(), 0.690); |
| 2282 |
assert_relative_eq!(mdcv.chromaticities.blue.0.into_value(), 0.150); |
| 2283 |
assert_relative_eq!(mdcv.chromaticities.blue.1.into_value(), 0.060); |
| 2284 |
assert_relative_eq!(mdcv.chromaticities.white.0.into_value(), 0.3127); |
| 2285 |
assert_relative_eq!(mdcv.chromaticities.white.1.into_value(), 0.3290); |
| 2286 |
assert_relative_eq!(mdcv.min_luminance as f32 / 10_000.0, 0.01); |
| 2287 |
assert_relative_eq!(mdcv.max_luminance as f32 / 10_000.0, 5000.0); |
| 2288 |
|
| 2289 |
let clli = info.content_light_level.unwrap(); |
| 2290 |
assert_relative_eq!(clli.max_content_light_level as f32 / 10_000.0, 4000.0); |
| 2291 |
assert_relative_eq!(clli.max_frame_average_light_level as f32 / 10_000.0, 2627.0); |
| 2292 |
} |
| 2293 |
|
| 2294 |
/// Test handling of `eXIf` chunk. |
| 2295 |
#[test] |
| 2296 |
fn test_exif_chunk() { |
| 2297 |
let decoder = crate::Decoder::new(BufReader::new( |
| 2298 |
File::open("tests/bugfixes/F-exif-chunk-early.png").unwrap(), |
| 2299 |
)); |
| 2300 |
let reader = decoder.read_info().unwrap(); |
| 2301 |
let info = reader.info(); |
| 2302 |
let exif = info.exif_metadata.as_ref().unwrap().as_ref(); |
| 2303 |
assert_eq!(exif.len(), 90); |
| 2304 |
} |
| 2305 |
|
| 2306 |
/// Tests what happens then [`Reader.finish`] is called twice. |
| 2307 |
#[test] |
| 2308 |
fn test_finishing_twice() { |
| 2309 |
let mut png = Vec::new(); |
| 2310 |
write_noncompressed_png(&mut png, 16, 1024); |
| 2311 |
let decoder = Decoder::new(Cursor::new(&png)); |
| 2312 |
let mut reader = decoder.read_info().unwrap(); |
| 2313 |
|
| 2314 |
// First call to `finish` - expecting success. |
| 2315 |
reader.finish().unwrap(); |
| 2316 |
|
| 2317 |
// Second call to `finish` - expecting an error. |
| 2318 |
let err = reader.finish().unwrap_err(); |
| 2319 |
assert!(matches!(&err, DecodingError::Parameter(_))); |
| 2320 |
assert_eq!("End of image has been reached", format!("{err}")); |
| 2321 |
} |
| 2322 |
|
| 2323 |
/// Writes an acTL chunk. |
| 2324 |
/// See https://wiki.mozilla.org/APNG_Specification#.60acTL.60:_The_Animation_Control_Chunk |
| 2325 |
fn write_actl(w: &mut impl Write, animation: &crate::AnimationControl) { |
| 2326 |
let mut data = Vec::new(); |
| 2327 |
data.write_u32::<byteorder::BigEndian>(animation.num_frames) |
| 2328 |
.unwrap(); |
| 2329 |
data.write_u32::<byteorder::BigEndian>(animation.num_plays) |
| 2330 |
.unwrap(); |
| 2331 |
write_chunk(w, b"acTL", &data); |
| 2332 |
} |
| 2333 |
|
| 2334 |
/// Writes an fcTL chunk. |
| 2335 |
/// See https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk |
| 2336 |
fn write_fctl(w: &mut impl Write, frame: &crate::FrameControl) { |
| 2337 |
let mut data = Vec::new(); |
| 2338 |
data.write_u32::<byteorder::BigEndian>(frame.sequence_number) |
| 2339 |
.unwrap(); |
| 2340 |
data.write_u32::<byteorder::BigEndian>(frame.width).unwrap(); |
| 2341 |
data.write_u32::<byteorder::BigEndian>(frame.height) |
| 2342 |
.unwrap(); |
| 2343 |
data.write_u32::<byteorder::BigEndian>(frame.x_offset) |
| 2344 |
.unwrap(); |
| 2345 |
data.write_u32::<byteorder::BigEndian>(frame.y_offset) |
| 2346 |
.unwrap(); |
| 2347 |
data.write_u16::<byteorder::BigEndian>(frame.delay_num) |
| 2348 |
.unwrap(); |
| 2349 |
data.write_u16::<byteorder::BigEndian>(frame.delay_den) |
| 2350 |
.unwrap(); |
| 2351 |
data.write_u8(frame.dispose_op as u8).unwrap(); |
| 2352 |
data.write_u8(frame.blend_op as u8).unwrap(); |
| 2353 |
write_chunk(w, b"fcTL", &data); |
| 2354 |
} |
| 2355 |
|
| 2356 |
/// Writes an fdAT chunk. |
| 2357 |
/// See https://wiki.mozilla.org/APNG_Specification#.60fdAT.60:_The_Frame_Data_Chunk |
| 2358 |
fn write_fdat(w: &mut impl Write, sequence_number: u32, image_data: &[u8]) { |
| 2359 |
let mut data = Vec::new(); |
| 2360 |
data.write_u32::<byteorder::BigEndian>(sequence_number) |
| 2361 |
.unwrap(); |
| 2362 |
data.write_all(image_data).unwrap(); |
| 2363 |
write_chunk(w, b"fdAT", &data); |
| 2364 |
} |
| 2365 |
|
| 2366 |
/// Writes PNG signature and chunks that can precede an fdAT chunk that is expected |
| 2367 |
/// to have |
| 2368 |
/// - `sequence_number` set to 0 |
| 2369 |
/// - image data with rgba8 pixels in a `width` by `width` image |
| 2370 |
fn write_fdat_prefix(w: &mut impl Write, num_frames: u32, width: u32) { |
| 2371 |
write_png_sig(w); |
| 2372 |
write_rgba8_ihdr_with_width(w, width); |
| 2373 |
write_actl( |
| 2374 |
w, |
| 2375 |
&crate::AnimationControl { |
| 2376 |
num_frames, |
| 2377 |
num_plays: 0, |
| 2378 |
}, |
| 2379 |
); |
| 2380 |
|
| 2381 |
let mut fctl = crate::FrameControl { |
| 2382 |
width, |
| 2383 |
height: width, |
| 2384 |
..Default::default() |
| 2385 |
}; |
| 2386 |
write_fctl(w, &fctl); |
| 2387 |
write_rgba8_idats(w, width, 0x7fffffff); |
| 2388 |
|
| 2389 |
fctl.sequence_number += 1; |
| 2390 |
write_fctl(w, &fctl); |
| 2391 |
} |
| 2392 |
|
| 2393 |
#[test] |
| 2394 |
fn test_fdat_chunk_payload_length_0() { |
| 2395 |
let mut png = Vec::new(); |
| 2396 |
write_fdat_prefix(&mut png, 2, 8); |
| 2397 |
write_chunk(&mut png, b"fdAT", &[]); |
| 2398 |
|
| 2399 |
let decoder = Decoder::new(Cursor::new(&png)); |
| 2400 |
let mut reader = decoder.read_info().unwrap(); |
| 2401 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2402 |
reader.next_frame(&mut buf).unwrap(); |
| 2403 |
|
| 2404 |
// 0-length fdAT should result in an error. |
| 2405 |
let err = reader.next_frame(&mut buf).unwrap_err(); |
| 2406 |
assert!(matches!(&err, DecodingError::Format(_))); |
| 2407 |
assert_eq!("fdAT chunk shorter than 4 bytes", format!("{err}")); |
| 2408 |
|
| 2409 |
// Calling `next_frame` again should return an error. Same error as above would be nice, |
| 2410 |
// but it is probably unnecessary and infeasible (`DecodingError` can't derive `Clone` |
| 2411 |
// because `std::io::Error` doesn't implement `Clone`).. But it definitely shouldn't enter |
| 2412 |
// an infinite loop. |
| 2413 |
let err2 = reader.next_frame(&mut buf).unwrap_err(); |
| 2414 |
assert!(matches!(&err2, DecodingError::Parameter(_))); |
| 2415 |
assert_eq!( |
| 2416 |
"A fatal decoding error has been encounted earlier", |
| 2417 |
format!("{err2}") |
| 2418 |
); |
| 2419 |
} |
| 2420 |
|
| 2421 |
#[test] |
| 2422 |
fn test_fdat_chunk_payload_length_3() { |
| 2423 |
let mut png = Vec::new(); |
| 2424 |
write_fdat_prefix(&mut png, 2, 8); |
| 2425 |
write_chunk(&mut png, b"fdAT", &[1, 0, 0]); |
| 2426 |
|
| 2427 |
let decoder = Decoder::new(Cursor::new(&png)); |
| 2428 |
let mut reader = decoder.read_info().unwrap(); |
| 2429 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2430 |
reader.next_frame(&mut buf).unwrap(); |
| 2431 |
|
| 2432 |
// 3-bytes-long fdAT should result in an error. |
| 2433 |
let err = reader.next_frame(&mut buf).unwrap_err(); |
| 2434 |
assert!(matches!(&err, DecodingError::Format(_))); |
| 2435 |
assert_eq!("fdAT chunk shorter than 4 bytes", format!("{err}")); |
| 2436 |
} |
| 2437 |
|
| 2438 |
#[test] |
| 2439 |
fn test_frame_split_across_two_fdat_chunks() { |
| 2440 |
// Generate test data where the 2nd animation frame is split across 2 fdAT chunks. |
| 2441 |
// |
| 2442 |
// This is similar to the example given in |
| 2443 |
// https://wiki.mozilla.org/APNG_Specification#Chunk_Sequence_Numbers: |
| 2444 |
// |
| 2445 |
// ``` |
| 2446 |
// Sequence number Chunk |
| 2447 |
// (none) `acTL` |
| 2448 |
// 0 `fcTL` first frame |
| 2449 |
// (none) `IDAT` first frame / default image |
| 2450 |
// 1 `fcTL` second frame |
| 2451 |
// 2 first `fdAT` for second frame |
| 2452 |
// 3 second `fdAT` for second frame |
| 2453 |
// ``` |
| 2454 |
let png = { |
| 2455 |
let mut png = Vec::new(); |
| 2456 |
write_fdat_prefix(&mut png, 2, 8); |
| 2457 |
let image_data = generate_rgba8_with_width_and_height(8, 8); |
| 2458 |
write_fdat(&mut png, 2, &image_data[..30]); |
| 2459 |
write_fdat(&mut png, 3, &image_data[30..]); |
| 2460 |
write_iend(&mut png); |
| 2461 |
png |
| 2462 |
}; |
| 2463 |
|
| 2464 |
// Start decoding. |
| 2465 |
let decoder = Decoder::new(Cursor::new(&png)); |
| 2466 |
let mut reader = decoder.read_info().unwrap(); |
| 2467 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2468 |
let Some(animation_control) = reader.info().animation_control else { |
| 2469 |
panic!("No acTL"); |
| 2470 |
}; |
| 2471 |
assert_eq!(animation_control.num_frames, 2); |
| 2472 |
|
| 2473 |
// Process the 1st animation frame. |
| 2474 |
let first_frame: Vec<u8>; |
| 2475 |
{ |
| 2476 |
reader.next_frame(&mut buf).unwrap(); |
| 2477 |
first_frame = buf.clone(); |
| 2478 |
|
| 2479 |
// Note that the doc comment of `Reader::next_frame` says that "[...] |
| 2480 |
// can be checked afterwards by calling `info` **after** a successful call and |
| 2481 |
// inspecting the `frame_control` data.". (Note the **emphasis** on "after".) |
| 2482 |
let Some(frame_control) = reader.info().frame_control else { |
| 2483 |
panic!("No fcTL (1st frame)"); |
| 2484 |
}; |
| 2485 |
// The sequence number is taken from the `fcTL` chunk that comes before the `IDAT` |
| 2486 |
// chunk. |
| 2487 |
assert_eq!(frame_control.sequence_number, 0); |
| 2488 |
} |
| 2489 |
|
| 2490 |
// Process the 2nd animation frame. |
| 2491 |
let second_frame: Vec<u8>; |
| 2492 |
{ |
| 2493 |
reader.next_frame(&mut buf).unwrap(); |
| 2494 |
second_frame = buf.clone(); |
| 2495 |
|
| 2496 |
// Same as above - updated `frame_control` is available *after* the `next_frame` call. |
| 2497 |
let Some(frame_control) = reader.info().frame_control else { |
| 2498 |
panic!("No fcTL (2nd frame)"); |
| 2499 |
}; |
| 2500 |
// The sequence number is taken from the `fcTL` chunk that comes before the two `fdAT` |
| 2501 |
// chunks. Note that sequence numbers inside `fdAT` chunks are not publicly exposed |
| 2502 |
// (but they are still checked when decoding to verify that they are sequential). |
| 2503 |
assert_eq!(frame_control.sequence_number, 1); |
| 2504 |
} |
| 2505 |
|
| 2506 |
assert_eq!(first_frame, second_frame); |
| 2507 |
} |
| 2508 |
|
| 2509 |
#[test] |
| 2510 |
fn test_idat_bigger_than_image_size_from_ihdr() { |
| 2511 |
let png = { |
| 2512 |
let mut png = Vec::new(); |
| 2513 |
write_png_sig(&mut png); |
| 2514 |
write_rgba8_ihdr_with_width(&mut png, 8); |
| 2515 |
|
| 2516 |
// Here we want to test an invalid image where the `IDAT` chunk contains more data |
| 2517 |
// (data for 8x256 image) than declared in the `IHDR` chunk (which only describes an |
| 2518 |
// 8x8 image). |
| 2519 |
write_chunk( |
| 2520 |
&mut png, |
| 2521 |
b"IDAT", |
| 2522 |
&generate_rgba8_with_width_and_height(8, 256), |
| 2523 |
); |
| 2524 |
|
| 2525 |
write_iend(&mut png); |
| 2526 |
png |
| 2527 |
}; |
| 2528 |
let decoder = Decoder::new(Cursor::new(&png)); |
| 2529 |
let mut reader = decoder.read_info().unwrap(); |
| 2530 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2531 |
|
| 2532 |
// TODO: Should this return an error instead? For now let's just have test assertions for |
| 2533 |
// the current behavior. |
| 2534 |
reader.next_frame(&mut buf).unwrap(); |
| 2535 |
assert_eq!(3093270825, crc32fast::hash(&buf)); |
| 2536 |
} |
| 2537 |
|
| 2538 |
#[test] |
| 2539 |
fn test_only_idat_chunk_in_input_stream() { |
| 2540 |
let png = { |
| 2541 |
let mut png = Vec::new(); |
| 2542 |
write_png_sig(&mut png); |
| 2543 |
write_chunk(&mut png, b"IDAT", &[]); |
| 2544 |
png |
| 2545 |
}; |
| 2546 |
let decoder = Decoder::new(Cursor::new(&png)); |
| 2547 |
let Err(err) = decoder.read_info() else { |
| 2548 |
panic!("Expected an error") |
| 2549 |
}; |
| 2550 |
assert!(matches!(&err, DecodingError::Format(_))); |
| 2551 |
assert_eq!( |
| 2552 |
"ChunkType { type: IDAT, \ |
| 2553 |
critical: true, \ |
| 2554 |
private: false, \ |
| 2555 |
reserved: false, \ |
| 2556 |
safecopy: false \ |
| 2557 |
} chunk appeared before IHDR chunk", |
| 2558 |
format!("{err}"), |
| 2559 |
); |
| 2560 |
} |
| 2561 |
|
| 2562 |
/// `StreamingInput` can be used by tests to simulate a streaming input |
| 2563 |
/// (e.g. a slow http response, where all bytes are not immediately available). |
| 2564 |
#[derive(Clone)] |
| 2565 |
struct StreamingInput { |
| 2566 |
full_input: Vec<u8>, |
| 2567 |
state: Rc<RefCell<StreamingInputState>>, |
| 2568 |
} |
| 2569 |
|
| 2570 |
struct StreamingInputState { |
| 2571 |
current_pos: usize, |
| 2572 |
available_len: usize, |
| 2573 |
} |
| 2574 |
|
| 2575 |
impl StreamingInput { |
| 2576 |
fn new(full_input: Vec<u8>) -> Self { |
| 2577 |
Self { |
| 2578 |
full_input, |
| 2579 |
state: Rc::new(RefCell::new(StreamingInputState { |
| 2580 |
current_pos: 0, |
| 2581 |
available_len: 0, |
| 2582 |
})), |
| 2583 |
} |
| 2584 |
} |
| 2585 |
|
| 2586 |
fn with_noncompressed_png(width: u32, idat_size: usize) -> Self { |
| 2587 |
let mut png = Vec::new(); |
| 2588 |
write_noncompressed_png(&mut png, width, idat_size); |
| 2589 |
Self::new(png) |
| 2590 |
} |
| 2591 |
|
| 2592 |
fn expose_next_byte(&self) { |
| 2593 |
let mut state = self.state.borrow_mut(); |
| 2594 |
assert!(state.available_len < self.full_input.len()); |
| 2595 |
state.available_len += 1; |
| 2596 |
} |
| 2597 |
|
| 2598 |
fn stream_input_until_reader_is_available(&self) -> Reader<StreamingInput> { |
| 2599 |
loop { |
| 2600 |
self.state.borrow_mut().current_pos = 0; |
| 2601 |
match Decoder::new(self.clone()).read_info() { |
| 2602 |
Ok(reader) => { |
| 2603 |
break reader; |
| 2604 |
} |
| 2605 |
Err(DecodingError::IoError(e)) if e.kind() == ErrorKind::UnexpectedEof => { |
| 2606 |
self.expose_next_byte(); |
| 2607 |
} |
| 2608 |
_ => panic!("Unexpected error"), |
| 2609 |
} |
| 2610 |
} |
| 2611 |
} |
| 2612 |
|
| 2613 |
fn decode_full_input<F, R>(&self, f: F) -> R |
| 2614 |
where |
| 2615 |
F: FnOnce(Reader<Cursor<&[u8]>>) -> R, |
| 2616 |
{ |
| 2617 |
let decoder = Decoder::new(Cursor::new(&*self.full_input)); |
| 2618 |
f(decoder.read_info().unwrap()) |
| 2619 |
} |
| 2620 |
} |
| 2621 |
|
| 2622 |
impl Read for StreamingInput { |
| 2623 |
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> { |
| 2624 |
let mut state = self.state.borrow_mut(); |
| 2625 |
let mut available_bytes = &self.full_input[state.current_pos..state.available_len]; |
| 2626 |
let number_of_read_bytes = available_bytes.read(buf)?; |
| 2627 |
state.current_pos += number_of_read_bytes; |
| 2628 |
assert!(state.current_pos <= state.available_len); |
| 2629 |
Ok(number_of_read_bytes) |
| 2630 |
} |
| 2631 |
} |
| 2632 |
impl BufRead for StreamingInput { |
| 2633 |
fn fill_buf(&mut self) -> std::io::Result<&[u8]> { |
| 2634 |
let state = self.state.borrow(); |
| 2635 |
Ok(&self.full_input[state.current_pos..state.available_len]) |
| 2636 |
} |
| 2637 |
|
| 2638 |
fn consume(&mut self, amt: usize) { |
| 2639 |
let mut state = self.state.borrow_mut(); |
| 2640 |
state.current_pos += amt; |
| 2641 |
assert!(state.current_pos <= state.available_len); |
| 2642 |
} |
| 2643 |
} |
| 2644 |
impl Seek for StreamingInput { |
| 2645 |
fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> { |
| 2646 |
let mut state = self.state.borrow_mut(); |
| 2647 |
state.current_pos = match pos { |
| 2648 |
std::io::SeekFrom::Start(n) => n as usize, |
| 2649 |
std::io::SeekFrom::End(n) => (self.full_input.len() as i64 + n) as usize, |
| 2650 |
std::io::SeekFrom::Current(n) => (state.current_pos as i64 + n) as usize, |
| 2651 |
} as usize; |
| 2652 |
Ok(state.current_pos as u64) |
| 2653 |
} |
| 2654 |
fn stream_position(&mut self) -> std::io::Result<u64> { |
| 2655 |
Ok(self.state.borrow().current_pos as u64) |
| 2656 |
} |
| 2657 |
} |
| 2658 |
|
| 2659 |
/// Test resuming/retrying `Reader.next_frame` after `UnexpectedEof`. |
| 2660 |
#[test] |
| 2661 |
fn test_streaming_input_and_decoding_via_next_frame() { |
| 2662 |
const WIDTH: u32 = 16; |
| 2663 |
const IDAT_SIZE: usize = 512; |
| 2664 |
let streaming_input = StreamingInput::with_noncompressed_png(WIDTH, IDAT_SIZE); |
| 2665 |
|
| 2666 |
let (whole_output_info, decoded_from_whole_input) = |
| 2667 |
streaming_input.decode_full_input(|mut r| { |
| 2668 |
let mut buf = vec![0; r.output_buffer_size().unwrap()]; |
| 2669 |
let output_info = r.next_frame(&mut buf).unwrap(); |
| 2670 |
(output_info, buf) |
| 2671 |
}); |
| 2672 |
|
| 2673 |
let mut png_reader = streaming_input.stream_input_until_reader_is_available(); |
| 2674 |
let mut decoded_from_streaming_input = vec![0; png_reader.output_buffer_size().unwrap()]; |
| 2675 |
let streaming_output_info = loop { |
| 2676 |
match png_reader.next_frame(decoded_from_streaming_input.as_mut_slice()) { |
| 2677 |
Ok(output_info) => break output_info, |
| 2678 |
Err(DecodingError::IoError(e)) if e.kind() == ErrorKind::UnexpectedEof => { |
| 2679 |
streaming_input.expose_next_byte() |
| 2680 |
} |
| 2681 |
e => panic!("Unexpected error: {:?}", e), |
| 2682 |
} |
| 2683 |
}; |
| 2684 |
assert_eq!(whole_output_info, streaming_output_info); |
| 2685 |
assert_eq!( |
| 2686 |
crc32fast::hash(&decoded_from_whole_input), |
| 2687 |
crc32fast::hash(&decoded_from_streaming_input) |
| 2688 |
); |
| 2689 |
} |
| 2690 |
|
| 2691 |
/// Test resuming/retrying `Reader.next_row` after `UnexpectedEof`. |
| 2692 |
#[test] |
| 2693 |
fn test_streaming_input_and_decoding_via_next_row() { |
| 2694 |
const WIDTH: u32 = 16; |
| 2695 |
const IDAT_SIZE: usize = 512; |
| 2696 |
let streaming_input = StreamingInput::with_noncompressed_png(WIDTH, IDAT_SIZE); |
| 2697 |
|
| 2698 |
let decoded_from_whole_input = streaming_input.decode_full_input(|mut r| { |
| 2699 |
let mut buf = vec![0; r.output_buffer_size().unwrap()]; |
| 2700 |
r.next_frame(&mut buf).unwrap(); |
| 2701 |
buf |
| 2702 |
}); |
| 2703 |
|
| 2704 |
let mut png_reader = streaming_input.stream_input_until_reader_is_available(); |
| 2705 |
let mut decoded_from_streaming_input = Vec::new(); |
| 2706 |
loop { |
| 2707 |
match png_reader.next_row() { |
| 2708 |
Ok(None) => break, |
| 2709 |
Ok(Some(row)) => decoded_from_streaming_input.extend_from_slice(row.data()), |
| 2710 |
Err(DecodingError::IoError(e)) if e.kind() == ErrorKind::UnexpectedEof => { |
| 2711 |
streaming_input.expose_next_byte() |
| 2712 |
} |
| 2713 |
e => panic!("Unexpected error: {:?}", e), |
| 2714 |
} |
| 2715 |
} |
| 2716 |
assert_eq!( |
| 2717 |
crc32fast::hash(&decoded_from_whole_input), |
| 2718 |
crc32fast::hash(&decoded_from_streaming_input) |
| 2719 |
); |
| 2720 |
} |
| 2721 |
|
| 2722 |
/// Test resuming/retrying `Decoder.read_header_info` after `UnexpectedEof`. |
| 2723 |
#[test] |
| 2724 |
fn test_streaming_input_and_reading_header_info() { |
| 2725 |
const WIDTH: u32 = 16; |
| 2726 |
const IDAT_SIZE: usize = 512; |
| 2727 |
let streaming_input = StreamingInput::with_noncompressed_png(WIDTH, IDAT_SIZE); |
| 2728 |
|
| 2729 |
let info_from_whole_input = streaming_input.decode_full_input(|r| r.info().clone()); |
| 2730 |
|
| 2731 |
let mut decoder = Decoder::new(streaming_input.clone()); |
| 2732 |
let info_from_streaming_input = loop { |
| 2733 |
match decoder.read_header_info() { |
| 2734 |
Ok(info) => break info.clone(), |
| 2735 |
Err(DecodingError::IoError(e)) if e.kind() == ErrorKind::UnexpectedEof => { |
| 2736 |
streaming_input.expose_next_byte() |
| 2737 |
} |
| 2738 |
e => panic!("Unexpected error: {:?}", e), |
| 2739 |
} |
| 2740 |
}; |
| 2741 |
|
| 2742 |
assert_eq!(info_from_whole_input.width, info_from_streaming_input.width); |
| 2743 |
assert_eq!( |
| 2744 |
info_from_whole_input.height, |
| 2745 |
info_from_streaming_input.height |
| 2746 |
); |
| 2747 |
assert_eq!( |
| 2748 |
info_from_whole_input.bit_depth, |
| 2749 |
info_from_streaming_input.bit_depth |
| 2750 |
); |
| 2751 |
assert_eq!( |
| 2752 |
info_from_whole_input.color_type, |
| 2753 |
info_from_streaming_input.color_type |
| 2754 |
); |
| 2755 |
assert_eq!( |
| 2756 |
info_from_whole_input.interlaced, |
| 2757 |
info_from_streaming_input.interlaced |
| 2758 |
); |
| 2759 |
} |
| 2760 |
|
| 2761 |
/// Creates a ready-to-test [`Reader`] which decodes a PNG that contains: |
| 2762 |
/// IHDR, IDAT, IEND. |
| 2763 |
fn create_reader_of_ihdr_idat() -> Reader<Cursor<Vec<u8>>> { |
| 2764 |
let mut png = Vec::new(); |
| 2765 |
write_noncompressed_png(&mut png, /* width = */ 16, /* idat_size = */ 1024); |
| 2766 |
Decoder::new(Cursor::new(png)).read_info().unwrap() |
| 2767 |
} |
| 2768 |
|
| 2769 |
/// Creates a ready-to-test [`Reader`] which decodes an animated PNG that contains: |
| 2770 |
/// IHDR, acTL, fcTL, IDAT, fcTL, fdAT, IEND. (i.e. IDAT is part of the animation) |
| 2771 |
fn create_reader_of_ihdr_actl_fctl_idat_fctl_fdat() -> Reader<Cursor<Vec<u8>>> { |
| 2772 |
let width = 16; |
| 2773 |
let mut fctl = crate::FrameControl { |
| 2774 |
width, |
| 2775 |
height: width, |
| 2776 |
..Default::default() |
| 2777 |
}; |
| 2778 |
|
| 2779 |
let mut png = Vec::new(); |
| 2780 |
write_png_sig(&mut png); |
| 2781 |
write_rgba8_ihdr_with_width(&mut png, width); |
| 2782 |
write_actl( |
| 2783 |
&mut png, |
| 2784 |
&crate::AnimationControl { |
| 2785 |
num_frames: 2, |
| 2786 |
num_plays: 0, |
| 2787 |
}, |
| 2788 |
); |
| 2789 |
fctl.sequence_number = 0; |
| 2790 |
write_fctl(&mut png, &fctl); |
| 2791 |
// Using `fctl.height + 1` means that the `IDAT` will have "left-over" data after |
| 2792 |
// processing. This helps to verify that `Reader.read_until_image_data` discards the |
| 2793 |
// left-over data when resetting `UnfilteredRowsBuffer`. |
| 2794 |
let idat_data = generate_rgba8_with_width_and_height(fctl.width, fctl.height + 1); |
| 2795 |
write_chunk(&mut png, b"IDAT", &idat_data); |
| 2796 |
|
| 2797 |
let fdat_width = 10; |
| 2798 |
fctl.sequence_number = 1; |
| 2799 |
// Using different width in `IDAT` and `fDAT` frames helps to catch problems that |
| 2800 |
// may arise when `Reader.read_until_image_data` doesn't properly reset |
| 2801 |
// `UnfilteredRowsBuffer`. |
| 2802 |
fctl.width = fdat_width; |
| 2803 |
write_fctl(&mut png, &fctl); |
| 2804 |
let fdat_data = generate_rgba8_with_width_and_height(fctl.width, fctl.height); |
| 2805 |
write_fdat(&mut png, 2, &fdat_data); |
| 2806 |
write_iend(&mut png); |
| 2807 |
|
| 2808 |
Decoder::new(Cursor::new(png)).read_info().unwrap() |
| 2809 |
} |
| 2810 |
|
| 2811 |
/// Creates a ready-to-test [`Reader`] which decodes an animated PNG that contains: IHDR, acTL, |
| 2812 |
/// IDAT, fcTL, fdAT, fcTL, fdAT, IEND. (i.e. IDAT is *not* part of the animation) |
| 2813 |
fn create_reader_of_ihdr_actl_idat_fctl_fdat_fctl_fdat() -> Reader<Cursor<Vec<u8>>> { |
| 2814 |
let width = 16; |
| 2815 |
let frame_data = generate_rgba8_with_width_and_height(width, width); |
| 2816 |
let mut fctl = crate::FrameControl { |
| 2817 |
width, |
| 2818 |
height: width, |
| 2819 |
..Default::default() |
| 2820 |
}; |
| 2821 |
|
| 2822 |
let mut png = Vec::new(); |
| 2823 |
write_png_sig(&mut png); |
| 2824 |
write_rgba8_ihdr_with_width(&mut png, width); |
| 2825 |
write_actl( |
| 2826 |
&mut png, |
| 2827 |
&crate::AnimationControl { |
| 2828 |
num_frames: 2, |
| 2829 |
num_plays: 0, |
| 2830 |
}, |
| 2831 |
); |
| 2832 |
write_chunk(&mut png, b"IDAT", &frame_data); |
| 2833 |
fctl.sequence_number = 0; |
| 2834 |
write_fctl(&mut png, &fctl); |
| 2835 |
write_fdat(&mut png, 1, &frame_data); |
| 2836 |
fctl.sequence_number = 2; |
| 2837 |
write_fctl(&mut png, &fctl); |
| 2838 |
write_fdat(&mut png, 3, &frame_data); |
| 2839 |
write_iend(&mut png); |
| 2840 |
|
| 2841 |
Decoder::new(Cursor::new(png)).read_info().unwrap() |
| 2842 |
} |
| 2843 |
|
| 2844 |
fn get_fctl_sequence_number(reader: &Reader<impl BufRead + Seek>) -> u32 { |
| 2845 |
reader |
| 2846 |
.info() |
| 2847 |
.frame_control |
| 2848 |
.as_ref() |
| 2849 |
.unwrap() |
| 2850 |
.sequence_number |
| 2851 |
} |
| 2852 |
|
| 2853 |
/// Tests that [`Reader.next_frame`] will report a `PolledAfterEndOfImage` error when called |
| 2854 |
/// after already decoding a single frame in a non-animated PNG. |
| 2855 |
#[test] |
| 2856 |
fn test_next_frame_polling_after_end_non_animated() { |
| 2857 |
let mut reader = create_reader_of_ihdr_idat(); |
| 2858 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2859 |
reader |
| 2860 |
.next_frame(&mut buf) |
| 2861 |
.expect("Expecting no error for IDAT frame"); |
| 2862 |
|
| 2863 |
let err = reader |
| 2864 |
.next_frame(&mut buf) |
| 2865 |
.expect_err("Main test - expecting error"); |
| 2866 |
assert!( |
| 2867 |
matches!(&err, DecodingError::Parameter(_)), |
| 2868 |
"Unexpected kind of error: {:?}", |
| 2869 |
&err, |
| 2870 |
); |
| 2871 |
} |
| 2872 |
|
| 2873 |
/// Tests that [`Reader.next_frame_info`] will report a `PolledAfterEndOfImage` error when |
| 2874 |
/// called when decoding a PNG that only contains a single frame. |
| 2875 |
#[test] |
| 2876 |
fn test_next_frame_info_polling_after_end_non_animated() { |
| 2877 |
let mut reader = create_reader_of_ihdr_idat(); |
| 2878 |
|
| 2879 |
let err = reader |
| 2880 |
.next_frame_info() |
| 2881 |
.expect_err("Main test - expecting error"); |
| 2882 |
assert!( |
| 2883 |
matches!(&err, DecodingError::Parameter(_)), |
| 2884 |
"Unexpected kind of error: {:?}", |
| 2885 |
&err, |
| 2886 |
); |
| 2887 |
} |
| 2888 |
|
| 2889 |
/// Tests that [`Reader.next_frame`] will report a `PolledAfterEndOfImage` error when called |
| 2890 |
/// after already decoding a single frame in an animated PNG where IDAT is part of the |
| 2891 |
/// animation. |
| 2892 |
#[test] |
| 2893 |
fn test_next_frame_polling_after_end_idat_part_of_animation() { |
| 2894 |
let mut reader = create_reader_of_ihdr_actl_fctl_idat_fctl_fdat(); |
| 2895 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2896 |
|
| 2897 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 2898 |
reader |
| 2899 |
.next_frame(&mut buf) |
| 2900 |
.expect("Expecting no error for IDAT frame"); |
| 2901 |
|
| 2902 |
// `next_frame` doesn't advance to the next `fcTL`. |
| 2903 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 2904 |
|
| 2905 |
reader |
| 2906 |
.next_frame(&mut buf) |
| 2907 |
.expect("Expecting no error for fdAT frame"); |
| 2908 |
assert_eq!(get_fctl_sequence_number(&reader), 1); |
| 2909 |
|
| 2910 |
let err = reader |
| 2911 |
.next_frame(&mut buf) |
| 2912 |
.expect_err("Main test - expecting error"); |
| 2913 |
assert!( |
| 2914 |
matches!(&err, DecodingError::Parameter(_)), |
| 2915 |
"Unexpected kind of error: {:?}", |
| 2916 |
&err, |
| 2917 |
); |
| 2918 |
} |
| 2919 |
|
| 2920 |
/// Tests that [`Reader.next_frame`] will report a `PolledAfterEndOfImage` error when called |
| 2921 |
/// after already decoding a single frame in an animated PNG where IDAT is *not* part of the |
| 2922 |
/// animation. |
| 2923 |
#[test] |
| 2924 |
fn test_next_frame_polling_after_end_idat_not_part_of_animation() { |
| 2925 |
let mut reader = create_reader_of_ihdr_actl_idat_fctl_fdat_fctl_fdat(); |
| 2926 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2927 |
|
| 2928 |
assert!(reader.info().frame_control.is_none()); |
| 2929 |
reader |
| 2930 |
.next_frame(&mut buf) |
| 2931 |
.expect("Expecting no error for IDAT frame"); |
| 2932 |
|
| 2933 |
// `next_frame` doesn't advance to the next `fcTL`. |
| 2934 |
assert!(reader.info().frame_control.is_none()); |
| 2935 |
|
| 2936 |
reader |
| 2937 |
.next_frame(&mut buf) |
| 2938 |
.expect("Expecting no error for 1st fdAT frame"); |
| 2939 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 2940 |
|
| 2941 |
reader |
| 2942 |
.next_frame(&mut buf) |
| 2943 |
.expect("Expecting no error for 2nd fdAT frame"); |
| 2944 |
assert_eq!(get_fctl_sequence_number(&reader), 2); |
| 2945 |
|
| 2946 |
let err = reader |
| 2947 |
.next_frame(&mut buf) |
| 2948 |
.expect_err("Main test - expecting error"); |
| 2949 |
assert!( |
| 2950 |
matches!(&err, DecodingError::Parameter(_)), |
| 2951 |
"Unexpected kind of error: {:?}", |
| 2952 |
&err, |
| 2953 |
); |
| 2954 |
} |
| 2955 |
|
| 2956 |
/// Tests that after decoding a whole frame via [`Reader.next_row`] the call to |
| 2957 |
/// [`Reader.next_frame`] will decode the **next** frame. |
| 2958 |
#[test] |
| 2959 |
fn test_row_by_row_then_next_frame() { |
| 2960 |
let mut reader = create_reader_of_ihdr_actl_fctl_idat_fctl_fdat(); |
| 2961 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 2962 |
|
| 2963 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 2964 |
while let Some(_) = reader.next_row().unwrap() {} |
| 2965 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 2966 |
|
| 2967 |
buf.fill(0x0f); |
| 2968 |
reader |
| 2969 |
.next_frame(&mut buf) |
| 2970 |
.expect("Expecting no error from next_frame call"); |
| 2971 |
|
| 2972 |
// Verify if we have read the next `fcTL` chunk + repopulated `buf`: |
| 2973 |
assert_eq!(get_fctl_sequence_number(&reader), 1); |
| 2974 |
assert!(buf.iter().any(|byte| *byte != 0x0f)); |
| 2975 |
} |
| 2976 |
|
| 2977 |
/// Tests that after decoding a whole frame via [`Reader.next_row`] it is possible |
| 2978 |
/// to use [`Reader.next_row`] to decode the next frame (by using the `next_frame_info` API to |
| 2979 |
/// advance to the next frame when `next_row` returns `None`). |
| 2980 |
#[test] |
| 2981 |
fn test_row_by_row_of_two_frames() { |
| 2982 |
let mut reader = create_reader_of_ihdr_actl_fctl_idat_fctl_fdat(); |
| 2983 |
|
| 2984 |
let mut rows_of_frame1 = 0; |
| 2985 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 2986 |
while let Some(_) = reader.next_row().unwrap() { |
| 2987 |
rows_of_frame1 += 1; |
| 2988 |
} |
| 2989 |
assert_eq!(rows_of_frame1, 16); |
| 2990 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 2991 |
|
| 2992 |
let mut rows_of_frame2 = 0; |
| 2993 |
assert_eq!(reader.next_frame_info().unwrap().sequence_number, 1); |
| 2994 |
assert_eq!(get_fctl_sequence_number(&reader), 1); |
| 2995 |
while let Some(_) = reader.next_row().unwrap() { |
| 2996 |
rows_of_frame2 += 1; |
| 2997 |
} |
| 2998 |
assert_eq!(rows_of_frame2, 16); |
| 2999 |
assert_eq!(get_fctl_sequence_number(&reader), 1); |
| 3000 |
|
| 3001 |
let err = reader |
| 3002 |
.next_frame_info() |
| 3003 |
.expect_err("No more frames - expecting error"); |
| 3004 |
assert!( |
| 3005 |
matches!(&err, DecodingError::Parameter(_)), |
| 3006 |
"Unexpected kind of error: {:?}", |
| 3007 |
&err, |
| 3008 |
); |
| 3009 |
} |
| 3010 |
|
| 3011 |
/// This test is similar to `test_next_frame_polling_after_end_idat_part_of_animation`, but it |
| 3012 |
/// uses `next_frame_info` calls to read to the next `fcTL` earlier - before the next call to |
| 3013 |
/// `next_frame` (knowing `fcTL` before calling `next_frame` may be helpful to determine the |
| 3014 |
/// size of the output buffer and/or to prepare the buffer based on the `DisposeOp` of the |
| 3015 |
/// previous frames). |
| 3016 |
#[test] |
| 3017 |
fn test_next_frame_info_after_next_frame() { |
| 3018 |
let mut reader = create_reader_of_ihdr_actl_fctl_idat_fctl_fdat(); |
| 3019 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 3020 |
|
| 3021 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 3022 |
reader |
| 3023 |
.next_frame(&mut buf) |
| 3024 |
.expect("Expecting no error for IDAT frame"); |
| 3025 |
|
| 3026 |
// `next_frame` doesn't advance to the next `fcTL`. |
| 3027 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 3028 |
|
| 3029 |
// But `next_frame_info` can be used to go to the next `fcTL`. |
| 3030 |
assert_eq!(reader.next_frame_info().unwrap().sequence_number, 1); |
| 3031 |
assert_eq!(get_fctl_sequence_number(&reader), 1); |
| 3032 |
|
| 3033 |
reader |
| 3034 |
.next_frame(&mut buf) |
| 3035 |
.expect("Expecting no error for fdAT frame"); |
| 3036 |
assert_eq!(get_fctl_sequence_number(&reader), 1); |
| 3037 |
|
| 3038 |
let err = reader |
| 3039 |
.next_frame_info() |
| 3040 |
.expect_err("Main test - expecting error"); |
| 3041 |
assert!( |
| 3042 |
matches!(&err, DecodingError::Parameter(_)), |
| 3043 |
"Unexpected kind of error: {:?}", |
| 3044 |
&err, |
| 3045 |
); |
| 3046 |
} |
| 3047 |
|
| 3048 |
/// This test is similar to `test_next_frame_polling_after_end_idat_not_part_of_animation`, but |
| 3049 |
/// it uses `next_frame_info` to skip the `IDAT` frame entirely + to move between frames. |
| 3050 |
#[test] |
| 3051 |
fn test_next_frame_info_to_skip_first_frame() { |
| 3052 |
let mut reader = create_reader_of_ihdr_actl_idat_fctl_fdat_fctl_fdat(); |
| 3053 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 3054 |
|
| 3055 |
// First (IDAT) frame doesn't have frame control info, which means |
| 3056 |
// that it is not part of the animation. |
| 3057 |
assert!(reader.info().frame_control.is_none()); |
| 3058 |
|
| 3059 |
// `next_frame_info` can be used to skip the IDAT frame (without first having to separately |
| 3060 |
// discard the image data - e.g. by also calling `next_frame` first). |
| 3061 |
assert_eq!(reader.next_frame_info().unwrap().sequence_number, 0); |
| 3062 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 3063 |
reader |
| 3064 |
.next_frame(&mut buf) |
| 3065 |
.expect("Expecting no error for 1st fdAT frame"); |
| 3066 |
assert_eq!(get_fctl_sequence_number(&reader), 0); |
| 3067 |
|
| 3068 |
// Get the `fcTL` for the 2nd frame. |
| 3069 |
assert_eq!(reader.next_frame_info().unwrap().sequence_number, 2); |
| 3070 |
reader |
| 3071 |
.next_frame(&mut buf) |
| 3072 |
.expect("Expecting no error for 2nd fdAT frame"); |
| 3073 |
assert_eq!(get_fctl_sequence_number(&reader), 2); |
| 3074 |
|
| 3075 |
let err = reader |
| 3076 |
.next_frame_info() |
| 3077 |
.expect_err("Main test - expecting error"); |
| 3078 |
assert!( |
| 3079 |
matches!(&err, DecodingError::Parameter(_)), |
| 3080 |
"Unexpected kind of error: {:?}", |
| 3081 |
&err, |
| 3082 |
); |
| 3083 |
} |
| 3084 |
|
| 3085 |
#[test] |
| 3086 |
fn test_incorrect_trns_chunk_is_ignored() { |
| 3087 |
let png = { |
| 3088 |
let mut png = Vec::new(); |
| 3089 |
write_png_sig(&mut png); |
| 3090 |
write_rgba8_ihdr_with_width(&mut png, 8); |
| 3091 |
write_chunk(&mut png, b"tRNS", &[12, 34, 56]); |
| 3092 |
write_chunk( |
| 3093 |
&mut png, |
| 3094 |
b"IDAT", |
| 3095 |
&generate_rgba8_with_width_and_height(8, 8), |
| 3096 |
); |
| 3097 |
write_iend(&mut png); |
| 3098 |
png |
| 3099 |
}; |
| 3100 |
let decoder = Decoder::new(Cursor::new(&png)); |
| 3101 |
let mut reader = decoder.read_info().unwrap(); |
| 3102 |
let mut buf = vec![0; reader.output_buffer_size().unwrap()]; |
| 3103 |
assert!(reader.info().trns.is_none()); |
| 3104 |
reader.next_frame(&mut buf).unwrap(); |
| 3105 |
assert_eq!(3093270825, crc32fast::hash(&buf)); |
| 3106 |
assert!(reader.info().trns.is_none()); |
| 3107 |
} |
| 3108 |
|
| 3109 |
/// This is a regression test for https://crbug.com/422421347 |
| 3110 |
#[test] |
| 3111 |
fn test_actl_num_frames_zero() { |
| 3112 |
let width = 16; |
| 3113 |
let frame_data = generate_rgba8_with_width_and_height(width, width); |
| 3114 |
|
| 3115 |
let mut png = Vec::new(); |
| 3116 |
write_png_sig(&mut png); |
| 3117 |
write_rgba8_ihdr_with_width(&mut png, width); |
| 3118 |
write_actl( |
| 3119 |
&mut png, |
| 3120 |
&crate::AnimationControl { |
| 3121 |
num_frames: 0, // <= spec violation needed by this test |
| 3122 |
num_plays: 0, |
| 3123 |
}, |
| 3124 |
); |
| 3125 |
// Presence of an `fcTL` chunk will prevent incrementing |
| 3126 |
// `num_frames` when calculating `remaining_frames` in |
| 3127 |
// `Decoder::read_info`. So the test writes an `fcTL` chunk |
| 3128 |
// to end up with `remaining_frames == 0` if `parse_actl` allows |
| 3129 |
// `num_frames == 0`. |
| 3130 |
write_fctl( |
| 3131 |
&mut png, |
| 3132 |
&crate::FrameControl { |
| 3133 |
width, |
| 3134 |
height: width, |
| 3135 |
..Default::default() |
| 3136 |
}, |
| 3137 |
); |
| 3138 |
write_chunk(&mut png, b"IDAT", &frame_data); |
| 3139 |
write_iend(&mut png); |
| 3140 |
|
| 3141 |
let mut reader = Decoder::new(Cursor::new(png)).read_info().unwrap(); |
| 3142 |
|
| 3143 |
// Using `next_interlaced_row` in the test, because it doesn't check |
| 3144 |
// `Reader::remaining_frames` (unlike `next_frame`), because it assumes that either |
| 3145 |
// `read_info` or `next_frame` leave `Reader` in a valid state. |
| 3146 |
// |
| 3147 |
// The test passes if these `next_interlaced_row` calls don't hit any `assert!` failures. |
| 3148 |
while let Some(_row) = reader.next_interlaced_row().unwrap() {} |
| 3149 |
} |
| 3150 |
|
| 3151 |
#[test] |
| 3152 |
fn test_small_fctl() { |
| 3153 |
const FCTL_SIZE: u32 = 30; |
| 3154 |
const IHDR_SIZE: u32 = 50; |
| 3155 |
let mut png = Vec::new(); |
| 3156 |
write_png_sig(&mut png); |
| 3157 |
write_rgba8_ihdr_with_width(&mut png, IHDR_SIZE); |
| 3158 |
write_actl( |
| 3159 |
&mut png, |
| 3160 |
&crate::AnimationControl { |
| 3161 |
num_frames: 1, |
| 3162 |
num_plays: 1, |
| 3163 |
}, |
| 3164 |
); |
| 3165 |
write_fctl( |
| 3166 |
&mut png, |
| 3167 |
&crate::FrameControl { |
| 3168 |
width: FCTL_SIZE, |
| 3169 |
height: FCTL_SIZE, |
| 3170 |
x_offset: 10, |
| 3171 |
y_offset: 10, |
| 3172 |
sequence_number: 0, |
| 3173 |
..Default::default() |
| 3174 |
}, |
| 3175 |
); |
| 3176 |
write_chunk( |
| 3177 |
&mut png, |
| 3178 |
b"IDAT", |
| 3179 |
&generate_rgba8_with_width_and_height(IHDR_SIZE, IHDR_SIZE), |
| 3180 |
); |
| 3181 |
write_iend(&mut png); |
| 3182 |
|
| 3183 |
let reader = Decoder::new(Cursor::new(png)).read_info(); |
| 3184 |
let err = reader.err().unwrap(); |
| 3185 |
assert!(matches!(&err, DecodingError::Format(_))); |
| 3186 |
assert_eq!("Sub frame is out-of-bounds.", format!("{err}")); |
| 3187 |
} |
| 3188 |
|
| 3189 |
#[test] |
| 3190 |
fn test_invalid_text_chunk() { |
| 3191 |
// The spec requires a NUL character (separating keyword from text) within the first 80 |
| 3192 |
// bytes of the chunk. Here there is no NUL character in the first 100 bytes, so this |
| 3193 |
// chunk is invalid and should trigger an error in `parse_text`. |
| 3194 |
let invalid_text_chunk = vec![b'A'; 100]; |
| 3195 |
|
| 3196 |
const SIZE: u32 = 20; |
| 3197 |
let mut png = Vec::new(); |
| 3198 |
write_png_sig(&mut png); |
| 3199 |
write_rgba8_ihdr_with_width(&mut png, SIZE); |
| 3200 |
write_chunk(&mut png, b"tEXt", invalid_text_chunk.as_slice()); |
| 3201 |
write_chunk( |
| 3202 |
&mut png, |
| 3203 |
b"IDAT", |
| 3204 |
&generate_rgba8_with_width_and_height(SIZE, SIZE), |
| 3205 |
); |
| 3206 |
write_iend(&mut png); |
| 3207 |
|
| 3208 |
let reader = Decoder::new(Cursor::new(png)).read_info().unwrap(); |
| 3209 |
let info = reader.info(); |
| 3210 |
assert_eq!(info.width, SIZE); |
| 3211 |
assert_eq!(info.uncompressed_latin1_text.len(), 0); |
| 3212 |
} |
| 3213 |
} |