| 1 |
use byteorder_lite::{LittleEndian, ReadBytesExt}; |
| 2 |
use quick_error::quick_error; |
| 3 |
|
| 4 |
use std::collections::HashMap; |
| 5 |
use std::io::{self, BufRead, Cursor, Read, Seek}; |
| 6 |
use std::num::NonZeroU16; |
| 7 |
use std::ops::Range; |
| 8 |
|
| 9 |
use crate::extended::{self, get_alpha_predictor, read_alpha_chunk, WebPExtendedInfo}; |
| 10 |
|
| 11 |
use super::lossless::LosslessDecoder; |
| 12 |
use super::vp8::Vp8Decoder; |
| 13 |
|
| 14 |
quick_error! { |
| 15 |
/// Errors that can occur when attempting to decode a WebP image |
| 16 |
#[derive(Debug)] |
| 17 |
#[non_exhaustive] |
| 18 |
pub enum DecodingError { |
| 19 |
/// An IO error occurred while reading the file |
| 20 |
IoError(err: io::Error) { |
| 21 |
from() |
| 22 |
display("IO Error: {}", err) |
| 23 |
source(err) |
| 24 |
} |
| 25 |
|
| 26 |
/// RIFF's "RIFF" signature not found or invalid |
| 27 |
RiffSignatureInvalid(err: [u8; 4]) { |
| 28 |
display("Invalid RIFF signature: {err:x?}") |
| 29 |
} |
| 30 |
|
| 31 |
/// WebP's "WEBP" signature not found or invalid |
| 32 |
WebpSignatureInvalid(err: [u8; 4]) { |
| 33 |
display("Invalid WebP signature: {err:x?}") |
| 34 |
} |
| 35 |
|
| 36 |
/// An expected chunk was missing |
| 37 |
ChunkMissing { |
| 38 |
display("An expected chunk was missing") |
| 39 |
} |
| 40 |
|
| 41 |
/// Chunk Header was incorrect or invalid in its usage |
| 42 |
ChunkHeaderInvalid(err: [u8; 4]) { |
| 43 |
display("Invalid Chunk header: {err:x?}") |
| 44 |
} |
| 45 |
|
| 46 |
#[allow(deprecated)] |
| 47 |
#[deprecated] |
| 48 |
/// Some bits were invalid |
| 49 |
ReservedBitSet { |
| 50 |
display("Reserved bits set") |
| 51 |
} |
| 52 |
|
| 53 |
/// The ALPH chunk preprocessing info flag was invalid |
| 54 |
InvalidAlphaPreprocessing { |
| 55 |
display("Alpha chunk preprocessing flag invalid") |
| 56 |
} |
| 57 |
|
| 58 |
/// Invalid compression method |
| 59 |
InvalidCompressionMethod { |
| 60 |
display("Invalid compression method") |
| 61 |
} |
| 62 |
|
| 63 |
/// Alpha chunk doesn't match the frame's size |
| 64 |
AlphaChunkSizeMismatch { |
| 65 |
display("Alpha chunk size mismatch") |
| 66 |
} |
| 67 |
|
| 68 |
/// Image is too large, either for the platform's pointer size or generally |
| 69 |
ImageTooLarge { |
| 70 |
display("Image too large") |
| 71 |
} |
| 72 |
|
| 73 |
/// Frame would go out of the canvas |
| 74 |
FrameOutsideImage { |
| 75 |
display("Frame outside image") |
| 76 |
} |
| 77 |
|
| 78 |
/// Signature of 0x2f not found |
| 79 |
LosslessSignatureInvalid(err: u8) { |
| 80 |
display("Invalid lossless signature: {err:x?}") |
| 81 |
} |
| 82 |
|
| 83 |
/// Version Number was not zero |
| 84 |
VersionNumberInvalid(err: u8) { |
| 85 |
display("Invalid lossless version number: {err}") |
| 86 |
} |
| 87 |
|
| 88 |
/// Invalid color cache bits |
| 89 |
InvalidColorCacheBits(err: u8) { |
| 90 |
display("Invalid color cache bits: {err}") |
| 91 |
} |
| 92 |
|
| 93 |
/// An invalid Huffman code was encountered |
| 94 |
HuffmanError { |
| 95 |
display("Invalid Huffman code") |
| 96 |
} |
| 97 |
|
| 98 |
/// The bitstream was somehow corrupt |
| 99 |
BitStreamError { |
| 100 |
display("Corrupt bitstream") |
| 101 |
} |
| 102 |
|
| 103 |
/// The transforms specified were invalid |
| 104 |
TransformError { |
| 105 |
display("Invalid transform") |
| 106 |
} |
| 107 |
|
| 108 |
/// VP8's `[0x9D, 0x01, 0x2A]` magic not found or invalid |
| 109 |
Vp8MagicInvalid(err: [u8; 3]) { |
| 110 |
display("Invalid VP8 magic: {err:x?}") |
| 111 |
} |
| 112 |
|
| 113 |
/// VP8 Decoder initialisation wasn't provided with enough data |
| 114 |
NotEnoughInitData { |
| 115 |
display("Not enough VP8 init data") |
| 116 |
} |
| 117 |
|
| 118 |
/// At time of writing, only the YUV colour-space encoded as `0` is specified |
| 119 |
ColorSpaceInvalid(err: u8) { |
| 120 |
display("Invalid VP8 color space: {err}") |
| 121 |
} |
| 122 |
|
| 123 |
/// LUMA prediction mode was not recognised |
| 124 |
LumaPredictionModeInvalid(err: i8) { |
| 125 |
display("Invalid VP8 luma prediction mode: {err}") |
| 126 |
} |
| 127 |
|
| 128 |
/// Intra-prediction mode was not recognised |
| 129 |
IntraPredictionModeInvalid(err: i8) { |
| 130 |
display("Invalid VP8 intra prediction mode: {err}") |
| 131 |
} |
| 132 |
|
| 133 |
/// Chroma prediction mode was not recognised |
| 134 |
ChromaPredictionModeInvalid(err: i8) { |
| 135 |
display("Invalid VP8 chroma prediction mode: {err}") |
| 136 |
} |
| 137 |
|
| 138 |
/// Inconsistent image sizes |
| 139 |
InconsistentImageSizes { |
| 140 |
display("Inconsistent image sizes") |
| 141 |
} |
| 142 |
|
| 143 |
/// The file may be valid, but this crate doesn't support decoding it. |
| 144 |
UnsupportedFeature(err: String) { |
| 145 |
display("Unsupported feature: {err}") |
| 146 |
} |
| 147 |
|
| 148 |
/// Invalid function call or parameter |
| 149 |
InvalidParameter(err: String) { |
| 150 |
display("Invalid parameter: {err}") |
| 151 |
} |
| 152 |
|
| 153 |
/// Memory limit exceeded |
| 154 |
MemoryLimitExceeded { |
| 155 |
display("Memory limit exceeded") |
| 156 |
} |
| 157 |
|
| 158 |
/// Invalid chunk size |
| 159 |
InvalidChunkSize { |
| 160 |
display("Invalid chunk size") |
| 161 |
} |
| 162 |
|
| 163 |
/// No more frames in image |
| 164 |
NoMoreFrames { |
| 165 |
display("No more frames") |
| 166 |
} |
| 167 |
} |
| 168 |
} |
| 169 |
|
| 170 |
/// All possible RIFF chunks in a WebP image file |
| 171 |
#[allow(clippy::upper_case_acronyms)] |
| 172 |
#[derive(Debug, Clone, Copy, PartialEq, Hash, Eq)] |
| 173 |
pub(crate) enum WebPRiffChunk { |
| 174 |
RIFF, |
| 175 |
WEBP, |
| 176 |
VP8, |
| 177 |
VP8L, |
| 178 |
VP8X, |
| 179 |
ANIM, |
| 180 |
ANMF, |
| 181 |
ALPH, |
| 182 |
ICCP, |
| 183 |
EXIF, |
| 184 |
XMP, |
| 185 |
Unknown([u8; 4]), |
| 186 |
} |
| 187 |
|
| 188 |
impl WebPRiffChunk { |
| 189 |
pub(crate) const fn from_fourcc(chunk_fourcc: [u8; 4]) -> Self { |
| 190 |
match &chunk_fourcc { |
| 191 |
b"RIFF" => Self::RIFF, |
| 192 |
b"WEBP" => Self::WEBP, |
| 193 |
b"VP8 " => Self::VP8, |
| 194 |
b"VP8L" => Self::VP8L, |
| 195 |
b"VP8X" => Self::VP8X, |
| 196 |
b"ANIM" => Self::ANIM, |
| 197 |
b"ANMF" => Self::ANMF, |
| 198 |
b"ALPH" => Self::ALPH, |
| 199 |
b"ICCP" => Self::ICCP, |
| 200 |
b"EXIF" => Self::EXIF, |
| 201 |
b"XMP " => Self::XMP, |
| 202 |
_ => Self::Unknown(chunk_fourcc), |
| 203 |
} |
| 204 |
} |
| 205 |
|
| 206 |
pub(crate) const fn to_fourcc(self) -> [u8; 4] { |
| 207 |
match self { |
| 208 |
Self::RIFF => *b"RIFF", |
| 209 |
Self::WEBP => *b"WEBP", |
| 210 |
Self::VP8 => *b"VP8 ", |
| 211 |
Self::VP8L => *b"VP8L", |
| 212 |
Self::VP8X => *b"VP8X", |
| 213 |
Self::ANIM => *b"ANIM", |
| 214 |
Self::ANMF => *b"ANMF", |
| 215 |
Self::ALPH => *b"ALPH", |
| 216 |
Self::ICCP => *b"ICCP", |
| 217 |
Self::EXIF => *b"EXIF", |
| 218 |
Self::XMP => *b"XMP ", |
| 219 |
Self::Unknown(fourcc) => fourcc, |
| 220 |
} |
| 221 |
} |
| 222 |
|
| 223 |
pub(crate) const fn is_unknown(self) -> bool { |
| 224 |
matches!(self, Self::Unknown(_)) |
| 225 |
} |
| 226 |
} |
| 227 |
|
| 228 |
// enum WebPImage { |
| 229 |
// Lossy(VP8Frame), |
| 230 |
// Lossless(LosslessFrame), |
| 231 |
// Extended(ExtendedImage), |
| 232 |
// } |
| 233 |
|
| 234 |
enum ImageKind { |
| 235 |
Lossy, |
| 236 |
Lossless, |
| 237 |
Extended(WebPExtendedInfo), |
| 238 |
} |
| 239 |
|
| 240 |
struct AnimationState { |
| 241 |
next_frame: u32, |
| 242 |
next_frame_start: u64, |
| 243 |
dispose_next_frame: bool, |
| 244 |
previous_frame_width: u32, |
| 245 |
previous_frame_height: u32, |
| 246 |
previous_frame_x_offset: u32, |
| 247 |
previous_frame_y_offset: u32, |
| 248 |
canvas: Option<Vec<u8>>, |
| 249 |
} |
| 250 |
impl Default for AnimationState { |
| 251 |
fn default() -> Self { |
| 252 |
Self { |
| 253 |
next_frame: 0, |
| 254 |
next_frame_start: 0, |
| 255 |
dispose_next_frame: true, |
| 256 |
previous_frame_width: 0, |
| 257 |
previous_frame_height: 0, |
| 258 |
previous_frame_x_offset: 0, |
| 259 |
previous_frame_y_offset: 0, |
| 260 |
canvas: None, |
| 261 |
} |
| 262 |
} |
| 263 |
} |
| 264 |
|
| 265 |
/// Number of times that an animation loops. |
| 266 |
#[derive(Copy, Clone, Debug, Eq, PartialEq)] |
| 267 |
pub enum LoopCount { |
| 268 |
/// The animation loops forever. |
| 269 |
Forever, |
| 270 |
/// Each frame of the animation is displayed the specified number of times. |
| 271 |
Times(NonZeroU16), |
| 272 |
} |
| 273 |
|
| 274 |
/// WebP decoder configuration options |
| 275 |
#[derive(Clone)] |
| 276 |
#[non_exhaustive] |
| 277 |
pub struct WebPDecodeOptions { |
| 278 |
/// The upsampling method used in conversion from lossy yuv to rgb |
| 279 |
/// |
| 280 |
/// Defaults to `Bilinear`. |
| 281 |
pub lossy_upsampling: UpsamplingMethod, |
| 282 |
} |
| 283 |
|
| 284 |
impl Default for WebPDecodeOptions { |
| 285 |
fn default() -> Self { |
| 286 |
Self { |
| 287 |
lossy_upsampling: UpsamplingMethod::Bilinear, |
| 288 |
} |
| 289 |
} |
| 290 |
} |
| 291 |
|
| 292 |
/// Methods for upsampling the chroma values in lossy decoding |
| 293 |
/// |
| 294 |
/// The chroma red and blue planes are encoded in VP8 as half the size of the luma plane |
| 295 |
/// Therefore we need to upsample these values up to fit each pixel in the image. |
| 296 |
#[derive(Clone, Copy, Default)] |
| 297 |
pub enum UpsamplingMethod { |
| 298 |
/// Fancy upsampling |
| 299 |
/// |
| 300 |
/// Does bilinear interpolation using the 4 values nearest to the pixel, weighting based on the distance |
| 301 |
/// from the pixel. |
| 302 |
#[default] |
| 303 |
Bilinear, |
| 304 |
/// Simple upsampling, just uses the closest u/v value to the pixel when upsampling |
| 305 |
/// |
| 306 |
/// Matches the -nofancy option in dwebp. |
| 307 |
/// Should be faster but may lead to slightly jagged edges. |
| 308 |
Simple, |
| 309 |
} |
| 310 |
|
| 311 |
/// WebP image format decoder. |
| 312 |
pub struct WebPDecoder<R> { |
| 313 |
r: R, |
| 314 |
memory_limit: usize, |
| 315 |
|
| 316 |
width: u32, |
| 317 |
height: u32, |
| 318 |
|
| 319 |
kind: ImageKind, |
| 320 |
animation: AnimationState, |
| 321 |
|
| 322 |
is_lossy: bool, |
| 323 |
has_alpha: bool, |
| 324 |
num_frames: u32, |
| 325 |
loop_count: LoopCount, |
| 326 |
loop_duration: u64, |
| 327 |
|
| 328 |
chunks: HashMap<WebPRiffChunk, Range<u64>>, |
| 329 |
|
| 330 |
webp_decode_options: WebPDecodeOptions, |
| 331 |
} |
| 332 |
|
| 333 |
impl<R: BufRead + Seek> WebPDecoder<R> { |
| 334 |
/// Create a new `WebPDecoder` from the reader `r`. The decoder performs many small reads, so the |
| 335 |
/// reader should be buffered. |
| 336 |
pub fn new(r: R) -> Result<Self, DecodingError> { |
| 337 |
Self::new_with_options(r, WebPDecodeOptions::default()) |
| 338 |
} |
| 339 |
|
| 340 |
/// Create a new `WebPDecoder` from the reader `r` with the options `WebPDecodeOptions`. The decoder |
| 341 |
/// performs many small reads, so the reader should be buffered. |
| 342 |
pub fn new_with_options( |
| 343 |
r: R, |
| 344 |
webp_decode_options: WebPDecodeOptions, |
| 345 |
) -> Result<Self, DecodingError> { |
| 346 |
let mut decoder = Self { |
| 347 |
r, |
| 348 |
width: 0, |
| 349 |
height: 0, |
| 350 |
num_frames: 0, |
| 351 |
kind: ImageKind::Lossy, |
| 352 |
chunks: HashMap::new(), |
| 353 |
animation: Default::default(), |
| 354 |
memory_limit: usize::MAX, |
| 355 |
is_lossy: false, |
| 356 |
has_alpha: false, |
| 357 |
loop_count: LoopCount::Times(NonZeroU16::new(1).unwrap()), |
| 358 |
loop_duration: 0, |
| 359 |
webp_decode_options, |
| 360 |
}; |
| 361 |
decoder.read_data()?; |
| 362 |
Ok(decoder) |
| 363 |
} |
| 364 |
|
| 365 |
fn read_data(&mut self) -> Result<(), DecodingError> { |
| 366 |
let (WebPRiffChunk::RIFF, riff_size, _) = read_chunk_header(&mut self.r)? else { |
| 367 |
return Err(DecodingError::ChunkHeaderInvalid(*b"RIFF")); |
| 368 |
}; |
| 369 |
|
| 370 |
match &read_fourcc(&mut self.r)? { |
| 371 |
WebPRiffChunk::WEBP => {} |
| 372 |
fourcc => return Err(DecodingError::WebpSignatureInvalid(fourcc.to_fourcc())), |
| 373 |
} |
| 374 |
|
| 375 |
let (chunk, chunk_size, chunk_size_rounded) = read_chunk_header(&mut self.r)?; |
| 376 |
let start = self.r.stream_position()?; |
| 377 |
|
| 378 |
match chunk { |
| 379 |
WebPRiffChunk::VP8 => { |
| 380 |
let tag = self.r.read_u24::<LittleEndian>()?; |
| 381 |
|
| 382 |
let keyframe = tag & 1 == 0; |
| 383 |
if !keyframe { |
| 384 |
return Err(DecodingError::UnsupportedFeature( |
| 385 |
"Non-keyframe frames".to_owned(), |
| 386 |
)); |
| 387 |
} |
| 388 |
|
| 389 |
let mut tag = [0u8; 3]; |
| 390 |
self.r.read_exact(&mut tag)?; |
| 391 |
if tag != [0x9d, 0x01, 0x2a] { |
| 392 |
return Err(DecodingError::Vp8MagicInvalid(tag)); |
| 393 |
} |
| 394 |
|
| 395 |
let w = self.r.read_u16::<LittleEndian>()?; |
| 396 |
let h = self.r.read_u16::<LittleEndian>()?; |
| 397 |
|
| 398 |
self.width = u32::from(w & 0x3FFF); |
| 399 |
self.height = u32::from(h & 0x3FFF); |
| 400 |
if self.width == 0 || self.height == 0 { |
| 401 |
return Err(DecodingError::InconsistentImageSizes); |
| 402 |
} |
| 403 |
|
| 404 |
self.chunks |
| 405 |
.insert(WebPRiffChunk::VP8, start..start + chunk_size); |
| 406 |
self.kind = ImageKind::Lossy; |
| 407 |
self.is_lossy = true; |
| 408 |
} |
| 409 |
WebPRiffChunk::VP8L => { |
| 410 |
let signature = self.r.read_u8()?; |
| 411 |
if signature != 0x2f { |
| 412 |
return Err(DecodingError::LosslessSignatureInvalid(signature)); |
| 413 |
} |
| 414 |
|
| 415 |
let header = self.r.read_u32::<LittleEndian>()?; |
| 416 |
let version = header >> 29; |
| 417 |
if version != 0 { |
| 418 |
return Err(DecodingError::VersionNumberInvalid(version as u8)); |
| 419 |
} |
| 420 |
|
| 421 |
self.width = (1 + header) & 0x3FFF; |
| 422 |
self.height = (1 + (header >> 14)) & 0x3FFF; |
| 423 |
self.chunks |
| 424 |
.insert(WebPRiffChunk::VP8L, start..start + chunk_size); |
| 425 |
self.kind = ImageKind::Lossless; |
| 426 |
self.has_alpha = (header >> 28) & 1 != 0; |
| 427 |
} |
| 428 |
WebPRiffChunk::VP8X => { |
| 429 |
let mut info = extended::read_extended_header(&mut self.r)?; |
| 430 |
self.width = info.canvas_width; |
| 431 |
self.height = info.canvas_height; |
| 432 |
|
| 433 |
let mut position = start + chunk_size_rounded; |
| 434 |
let max_position = position + riff_size.saturating_sub(12); |
| 435 |
self.r.seek(io::SeekFrom::Start(position))?; |
| 436 |
|
| 437 |
while position < max_position { |
| 438 |
match read_chunk_header(&mut self.r) { |
| 439 |
Ok((chunk, chunk_size, chunk_size_rounded)) => { |
| 440 |
let range = position + 8..position + 8 + chunk_size; |
| 441 |
position += 8 + chunk_size_rounded; |
| 442 |
|
| 443 |
if !chunk.is_unknown() { |
| 444 |
self.chunks.entry(chunk).or_insert(range); |
| 445 |
} |
| 446 |
|
| 447 |
if chunk == WebPRiffChunk::ANMF { |
| 448 |
self.num_frames += 1; |
| 449 |
if chunk_size < 24 { |
| 450 |
return Err(DecodingError::InvalidChunkSize); |
| 451 |
} |
| 452 |
|
| 453 |
self.r.seek_relative(12)?; |
| 454 |
let duration = self.r.read_u32::<LittleEndian>()? & 0xffffff; |
| 455 |
self.loop_duration = |
| 456 |
self.loop_duration.wrapping_add(u64::from(duration)); |
| 457 |
|
| 458 |
// If the image is animated, the image data chunk will be inside the |
| 459 |
// ANMF chunks, so we must inspect them to determine whether the |
| 460 |
// image contains any lossy image data. VP8 chunks store lossy data |
| 461 |
// and the spec says that lossless images SHOULD NOT contain ALPH |
| 462 |
// chunks, so we treat both as indicators of lossy images. |
| 463 |
if !self.is_lossy { |
| 464 |
let (subchunk, ..) = read_chunk_header(&mut self.r)?; |
| 465 |
if let WebPRiffChunk::VP8 | WebPRiffChunk::ALPH = subchunk { |
| 466 |
self.is_lossy = true; |
| 467 |
} |
| 468 |
self.r.seek_relative(chunk_size_rounded as i64 - 24)?; |
| 469 |
} else { |
| 470 |
self.r.seek_relative(chunk_size_rounded as i64 - 16)?; |
| 471 |
} |
| 472 |
|
| 473 |
continue; |
| 474 |
} |
| 475 |
|
| 476 |
self.r.seek_relative(chunk_size_rounded as i64)?; |
| 477 |
} |
| 478 |
Err(DecodingError::IoError(e)) |
| 479 |
if e.kind() == io::ErrorKind::UnexpectedEof => |
| 480 |
{ |
| 481 |
break; |
| 482 |
} |
| 483 |
Err(e) => return Err(e), |
| 484 |
} |
| 485 |
} |
| 486 |
self.is_lossy = self.is_lossy || self.chunks.contains_key(&WebPRiffChunk::VP8); |
| 487 |
|
| 488 |
// NOTE: We allow malformed images that have `info.icc_profile` set without a ICCP chunk, |
| 489 |
// because this is relatively common. |
| 490 |
if info.animation |
| 491 |
&& (!self.chunks.contains_key(&WebPRiffChunk::ANIM) |
| 492 |
|| !self.chunks.contains_key(&WebPRiffChunk::ANMF)) |
| 493 |
|| info.exif_metadata && !self.chunks.contains_key(&WebPRiffChunk::EXIF) |
| 494 |
|| info.xmp_metadata && !self.chunks.contains_key(&WebPRiffChunk::XMP) |
| 495 |
|| !info.animation |
| 496 |
&& self.chunks.contains_key(&WebPRiffChunk::VP8) |
| 497 |
== self.chunks.contains_key(&WebPRiffChunk::VP8L) |
| 498 |
{ |
| 499 |
return Err(DecodingError::ChunkMissing); |
| 500 |
} |
| 501 |
|
| 502 |
// Decode ANIM chunk. |
| 503 |
if info.animation { |
| 504 |
match self.read_chunk(WebPRiffChunk::ANIM, 6) { |
| 505 |
Ok(Some(chunk)) => { |
| 506 |
let mut cursor = Cursor::new(chunk); |
| 507 |
cursor.read_exact(&mut info.background_color_hint)?; |
| 508 |
self.loop_count = match cursor.read_u16::<LittleEndian>()? { |
| 509 |
0 => LoopCount::Forever, |
| 510 |
n => LoopCount::Times(NonZeroU16::new(n).unwrap()), |
| 511 |
}; |
| 512 |
self.animation.next_frame_start = |
| 513 |
self.chunks.get(&WebPRiffChunk::ANMF).unwrap().start - 8; |
| 514 |
} |
| 515 |
Ok(None) => return Err(DecodingError::ChunkMissing), |
| 516 |
Err(DecodingError::MemoryLimitExceeded) => { |
| 517 |
return Err(DecodingError::InvalidChunkSize) |
| 518 |
} |
| 519 |
Err(e) => return Err(e), |
| 520 |
} |
| 521 |
} |
| 522 |
|
| 523 |
// If the image is animated, the image data chunk will be inside the ANMF chunks. We |
| 524 |
// store the ALPH, VP8, and VP8L chunks (as applicable) of the first frame in the |
| 525 |
// hashmap so that we can read them later. |
| 526 |
if let Some(range) = self.chunks.get(&WebPRiffChunk::ANMF).cloned() { |
| 527 |
let mut position = range.start + 16; |
| 528 |
self.r.seek(io::SeekFrom::Start(position))?; |
| 529 |
for _ in 0..2 { |
| 530 |
let (subchunk, subchunk_size, subchunk_size_rounded) = |
| 531 |
read_chunk_header(&mut self.r)?; |
| 532 |
let subrange = position + 8..position + 8 + subchunk_size; |
| 533 |
self.chunks.entry(subchunk).or_insert(subrange.clone()); |
| 534 |
|
| 535 |
position += 8 + subchunk_size_rounded; |
| 536 |
if position + 8 > range.end { |
| 537 |
break; |
| 538 |
} |
| 539 |
} |
| 540 |
} |
| 541 |
|
| 542 |
self.has_alpha = info.alpha; |
| 543 |
self.kind = ImageKind::Extended(info); |
| 544 |
} |
| 545 |
_ => return Err(DecodingError::ChunkHeaderInvalid(chunk.to_fourcc())), |
| 546 |
}; |
| 547 |
|
| 548 |
Ok(()) |
| 549 |
} |
| 550 |
|
| 551 |
/// Sets the maximum amount of memory that the decoder is allowed to allocate at once. |
| 552 |
/// |
| 553 |
/// TODO: Some allocations currently ignore this limit. |
| 554 |
pub fn set_memory_limit(&mut self, limit: usize) { |
| 555 |
self.memory_limit = limit; |
| 556 |
} |
| 557 |
|
| 558 |
/// Get the background color specified in the image file if the image is extended and animated webp. |
| 559 |
pub fn background_color_hint(&self) -> Option<[u8; 4]> { |
| 560 |
if let ImageKind::Extended(info) = &self.kind { |
| 561 |
Some(info.background_color_hint) |
| 562 |
} else { |
| 563 |
None |
| 564 |
} |
| 565 |
} |
| 566 |
|
| 567 |
/// Sets the background color if the image is an extended and animated webp. |
| 568 |
pub fn set_background_color(&mut self, color: [u8; 4]) -> Result<(), DecodingError> { |
| 569 |
if let ImageKind::Extended(info) = &mut self.kind { |
| 570 |
info.background_color = Some(color); |
| 571 |
Ok(()) |
| 572 |
} else { |
| 573 |
Err(DecodingError::InvalidParameter( |
| 574 |
"Background color can only be set on animated webp".to_owned(), |
| 575 |
)) |
| 576 |
} |
| 577 |
} |
| 578 |
|
| 579 |
/// Returns the (width, height) of the image in pixels. |
| 580 |
pub fn dimensions(&self) -> (u32, u32) { |
| 581 |
(self.width, self.height) |
| 582 |
} |
| 583 |
|
| 584 |
/// Returns whether the image has an alpha channel. If so, the pixel format is Rgba8 and |
| 585 |
/// otherwise Rgb8. |
| 586 |
pub fn has_alpha(&self) -> bool { |
| 587 |
self.has_alpha |
| 588 |
} |
| 589 |
|
| 590 |
/// Returns true if the image is animated. |
| 591 |
pub fn is_animated(&self) -> bool { |
| 592 |
match &self.kind { |
| 593 |
ImageKind::Lossy | ImageKind::Lossless => false, |
| 594 |
ImageKind::Extended(extended) => extended.animation, |
| 595 |
} |
| 596 |
} |
| 597 |
|
| 598 |
/// Returns whether the image is lossy. For animated images, this is true if any frame is lossy. |
| 599 |
pub fn is_lossy(&mut self) -> bool { |
| 600 |
self.is_lossy |
| 601 |
} |
| 602 |
|
| 603 |
/// Returns the number of frames of a single loop of the animation, or zero if the image is not |
| 604 |
/// animated. |
| 605 |
pub fn num_frames(&self) -> u32 { |
| 606 |
self.num_frames |
| 607 |
} |
| 608 |
|
| 609 |
/// Returns the number of times the animation should loop. |
| 610 |
pub fn loop_count(&self) -> LoopCount { |
| 611 |
self.loop_count |
| 612 |
} |
| 613 |
|
| 614 |
/// Returns the total duration of one loop through the animation in milliseconds, or zero if the |
| 615 |
/// image is not animated. |
| 616 |
/// |
| 617 |
/// This is the sum of the durations of all individual frames of the image. |
| 618 |
pub fn loop_duration(&self) -> u64 { |
| 619 |
self.loop_duration |
| 620 |
} |
| 621 |
|
| 622 |
fn read_chunk( |
| 623 |
&mut self, |
| 624 |
chunk: WebPRiffChunk, |
| 625 |
max_size: usize, |
| 626 |
) -> Result<Option<Vec<u8>>, DecodingError> { |
| 627 |
match self.chunks.get(&chunk) { |
| 628 |
Some(range) => { |
| 629 |
if range.end - range.start > max_size as u64 { |
| 630 |
return Err(DecodingError::MemoryLimitExceeded); |
| 631 |
} |
| 632 |
|
| 633 |
self.r.seek(io::SeekFrom::Start(range.start))?; |
| 634 |
let mut data = vec![0; (range.end - range.start) as usize]; |
| 635 |
self.r.read_exact(&mut data)?; |
| 636 |
Ok(Some(data)) |
| 637 |
} |
| 638 |
None => Ok(None), |
| 639 |
} |
| 640 |
} |
| 641 |
|
| 642 |
/// Returns the raw bytes of the ICC profile, or None if there is no ICC profile. |
| 643 |
pub fn icc_profile(&mut self) -> Result<Option<Vec<u8>>, DecodingError> { |
| 644 |
self.read_chunk(WebPRiffChunk::ICCP, self.memory_limit) |
| 645 |
} |
| 646 |
|
| 647 |
/// Returns the raw bytes of the EXIF metadata, or None if there is no EXIF metadata. |
| 648 |
pub fn exif_metadata(&mut self) -> Result<Option<Vec<u8>>, DecodingError> { |
| 649 |
self.read_chunk(WebPRiffChunk::EXIF, self.memory_limit) |
| 650 |
} |
| 651 |
|
| 652 |
/// Returns the raw bytes of the XMP metadata, or None if there is no XMP metadata. |
| 653 |
pub fn xmp_metadata(&mut self) -> Result<Option<Vec<u8>>, DecodingError> { |
| 654 |
self.read_chunk(WebPRiffChunk::XMP, self.memory_limit) |
| 655 |
} |
| 656 |
|
| 657 |
/// Returns the number of bytes required to store the image or a single frame, or None if that |
| 658 |
/// would take more than `usize::MAX` bytes. |
| 659 |
pub fn output_buffer_size(&self) -> Option<usize> { |
| 660 |
let bytes_per_pixel = if self.has_alpha() { 4 } else { 3 }; |
| 661 |
(self.width as usize) |
| 662 |
.checked_mul(self.height as usize)? |
| 663 |
.checked_mul(bytes_per_pixel) |
| 664 |
} |
| 665 |
|
| 666 |
/// Returns the raw bytes of the image. For animated images, this is the first frame. |
| 667 |
/// |
| 668 |
/// Fails with `ImageTooLarge` if `buf` has length different than `output_buffer_size()` |
| 669 |
pub fn read_image(&mut self, buf: &mut [u8]) -> Result<(), DecodingError> { |
| 670 |
if Some(buf.len()) != self.output_buffer_size() { |
| 671 |
return Err(DecodingError::ImageTooLarge); |
| 672 |
} |
| 673 |
|
| 674 |
if self.is_animated() { |
| 675 |
let saved = std::mem::take(&mut self.animation); |
| 676 |
self.animation.next_frame_start = |
| 677 |
self.chunks.get(&WebPRiffChunk::ANMF).unwrap().start - 8; |
| 678 |
let result = self.read_frame(buf); |
| 679 |
self.animation = saved; |
| 680 |
result?; |
| 681 |
} else if let Some(range) = self.chunks.get(&WebPRiffChunk::VP8L) { |
| 682 |
let mut decoder = LosslessDecoder::new(range_reader(&mut self.r, range.clone())?); |
| 683 |
|
| 684 |
if self.has_alpha { |
| 685 |
decoder.decode_frame(self.width, self.height, false, buf)?; |
| 686 |
} else { |
| 687 |
let mut data = vec![0; self.width as usize * self.height as usize * 4]; |
| 688 |
decoder.decode_frame(self.width, self.height, false, &mut data)?; |
| 689 |
for (rgba_val, chunk) in data.chunks_exact(4).zip(buf.chunks_exact_mut(3)) { |
| 690 |
chunk.copy_from_slice(&rgba_val[..3]); |
| 691 |
} |
| 692 |
} |
| 693 |
} else { |
| 694 |
let range = self |
| 695 |
.chunks |
| 696 |
.get(&WebPRiffChunk::VP8) |
| 697 |
.ok_or(DecodingError::ChunkMissing)?; |
| 698 |
let reader = range_reader(&mut self.r, range.start..range.end)?; |
| 699 |
let frame = Vp8Decoder::decode_frame(reader)?; |
| 700 |
if u32::from(frame.width) != self.width || u32::from(frame.height) != self.height { |
| 701 |
return Err(DecodingError::InconsistentImageSizes); |
| 702 |
} |
| 703 |
|
| 704 |
if self.has_alpha() { |
| 705 |
frame.fill_rgba(buf, self.webp_decode_options.lossy_upsampling); |
| 706 |
|
| 707 |
let range = self |
| 708 |
.chunks |
| 709 |
.get(&WebPRiffChunk::ALPH) |
| 710 |
.ok_or(DecodingError::ChunkMissing)? |
| 711 |
.clone(); |
| 712 |
let alpha_chunk = read_alpha_chunk( |
| 713 |
&mut range_reader(&mut self.r, range)?, |
| 714 |
self.width as u16, |
| 715 |
self.height as u16, |
| 716 |
)?; |
| 717 |
|
| 718 |
for y in 0..frame.height { |
| 719 |
for x in 0..frame.width { |
| 720 |
let predictor: u8 = get_alpha_predictor( |
| 721 |
x.into(), |
| 722 |
y.into(), |
| 723 |
frame.width.into(), |
| 724 |
alpha_chunk.filtering_method, |
| 725 |
buf, |
| 726 |
); |
| 727 |
|
| 728 |
let alpha_index = |
| 729 |
usize::from(y) * usize::from(frame.width) + usize::from(x); |
| 730 |
let buffer_index = alpha_index * 4 + 3; |
| 731 |
|
| 732 |
buf[buffer_index] = predictor.wrapping_add(alpha_chunk.data[alpha_index]); |
| 733 |
} |
| 734 |
} |
| 735 |
} else { |
| 736 |
frame.fill_rgb(buf, self.webp_decode_options.lossy_upsampling); |
| 737 |
} |
| 738 |
} |
| 739 |
|
| 740 |
Ok(()) |
| 741 |
} |
| 742 |
|
| 743 |
/// Reads the next frame of the animation. |
| 744 |
/// |
| 745 |
/// The frame contents are written into `buf` and the method returns the duration of the frame |
| 746 |
/// in milliseconds. If there are no more frames, the method returns |
| 747 |
/// `DecodingError::NoMoreFrames` and `buf` is left unchanged. |
| 748 |
/// |
| 749 |
/// # Panics |
| 750 |
/// |
| 751 |
/// Panics if the image is not animated. |
| 752 |
pub fn read_frame(&mut self, buf: &mut [u8]) -> Result<u32, DecodingError> { |
| 753 |
assert!(self.is_animated()); |
| 754 |
assert_eq!(Some(buf.len()), self.output_buffer_size()); |
| 755 |
|
| 756 |
if self.animation.next_frame == self.num_frames { |
| 757 |
return Err(DecodingError::NoMoreFrames); |
| 758 |
} |
| 759 |
|
| 760 |
let ImageKind::Extended(info) = &self.kind else { |
| 761 |
unreachable!() |
| 762 |
}; |
| 763 |
|
| 764 |
self.r |
| 765 |
.seek(io::SeekFrom::Start(self.animation.next_frame_start))?; |
| 766 |
|
| 767 |
let anmf_size = match read_chunk_header(&mut self.r)? { |
| 768 |
(WebPRiffChunk::ANMF, size, _) if size >= 32 => size, |
| 769 |
_ => return Err(DecodingError::ChunkHeaderInvalid(*b"ANMF")), |
| 770 |
}; |
| 771 |
|
| 772 |
// Read ANMF chunk |
| 773 |
let frame_x = extended::read_3_bytes(&mut self.r)? * 2; |
| 774 |
let frame_y = extended::read_3_bytes(&mut self.r)? * 2; |
| 775 |
let frame_width = extended::read_3_bytes(&mut self.r)? + 1; |
| 776 |
let frame_height = extended::read_3_bytes(&mut self.r)? + 1; |
| 777 |
if frame_width > 16384 || frame_height > 16384 { |
| 778 |
return Err(DecodingError::ImageTooLarge); |
| 779 |
} |
| 780 |
if frame_x + frame_width > self.width || frame_y + frame_height > self.height { |
| 781 |
return Err(DecodingError::FrameOutsideImage); |
| 782 |
} |
| 783 |
let duration = extended::read_3_bytes(&mut self.r)?; |
| 784 |
let frame_info = self.r.read_u8()?; |
| 785 |
let use_alpha_blending = frame_info & 0b00000010 == 0; |
| 786 |
let dispose = frame_info & 0b00000001 != 0; |
| 787 |
|
| 788 |
let clear_color = if self.animation.dispose_next_frame { |
| 789 |
info.background_color |
| 790 |
} else { |
| 791 |
None |
| 792 |
}; |
| 793 |
|
| 794 |
// Read normal bitstream now |
| 795 |
let (chunk, chunk_size, chunk_size_rounded) = read_chunk_header(&mut self.r)?; |
| 796 |
if chunk_size_rounded + 24 > anmf_size { |
| 797 |
return Err(DecodingError::ChunkHeaderInvalid(chunk.to_fourcc())); |
| 798 |
} |
| 799 |
|
| 800 |
let (frame, frame_has_alpha): (Vec<u8>, bool) = match chunk { |
| 801 |
WebPRiffChunk::VP8 => { |
| 802 |
let reader = (&mut self.r).take(chunk_size); |
| 803 |
let raw_frame = Vp8Decoder::decode_frame(reader)?; |
| 804 |
if u32::from(raw_frame.width) != frame_width |
| 805 |
|| u32::from(raw_frame.height) != frame_height |
| 806 |
{ |
| 807 |
return Err(DecodingError::InconsistentImageSizes); |
| 808 |
} |
| 809 |
let mut rgb_frame = vec![0; frame_width as usize * frame_height as usize * 3]; |
| 810 |
raw_frame.fill_rgb(&mut rgb_frame, self.webp_decode_options.lossy_upsampling); |
| 811 |
(rgb_frame, false) |
| 812 |
} |
| 813 |
WebPRiffChunk::VP8L => { |
| 814 |
let reader = (&mut self.r).take(chunk_size); |
| 815 |
let mut lossless_decoder = LosslessDecoder::new(reader); |
| 816 |
let mut rgba_frame = vec![0; frame_width as usize * frame_height as usize * 4]; |
| 817 |
lossless_decoder.decode_frame(frame_width, frame_height, false, &mut rgba_frame)?; |
| 818 |
(rgba_frame, true) |
| 819 |
} |
| 820 |
WebPRiffChunk::ALPH => { |
| 821 |
if chunk_size_rounded + 32 > anmf_size { |
| 822 |
return Err(DecodingError::ChunkHeaderInvalid(chunk.to_fourcc())); |
| 823 |
} |
| 824 |
|
| 825 |
// read alpha |
| 826 |
let next_chunk_start = self.r.stream_position()? + chunk_size_rounded; |
| 827 |
let mut reader = (&mut self.r).take(chunk_size); |
| 828 |
let alpha_chunk = |
| 829 |
read_alpha_chunk(&mut reader, frame_width as u16, frame_height as u16)?; |
| 830 |
|
| 831 |
// read opaque |
| 832 |
self.r.seek(io::SeekFrom::Start(next_chunk_start))?; |
| 833 |
let (next_chunk, next_chunk_size, _) = read_chunk_header(&mut self.r)?; |
| 834 |
if chunk_size + next_chunk_size + 32 > anmf_size { |
| 835 |
return Err(DecodingError::ChunkHeaderInvalid(next_chunk.to_fourcc())); |
| 836 |
} |
| 837 |
|
| 838 |
let frame = Vp8Decoder::decode_frame((&mut self.r).take(next_chunk_size))?; |
| 839 |
|
| 840 |
let mut rgba_frame = vec![0; frame_width as usize * frame_height as usize * 4]; |
| 841 |
frame.fill_rgba(&mut rgba_frame, self.webp_decode_options.lossy_upsampling); |
| 842 |
|
| 843 |
for y in 0..frame.height { |
| 844 |
for x in 0..frame.width { |
| 845 |
let predictor: u8 = get_alpha_predictor( |
| 846 |
x.into(), |
| 847 |
y.into(), |
| 848 |
frame.width.into(), |
| 849 |
alpha_chunk.filtering_method, |
| 850 |
&rgba_frame, |
| 851 |
); |
| 852 |
|
| 853 |
let alpha_index = |
| 854 |
usize::from(y) * usize::from(frame.width) + usize::from(x); |
| 855 |
let buffer_index = alpha_index * 4 + 3; |
| 856 |
|
| 857 |
rgba_frame[buffer_index] = |
| 858 |
predictor.wrapping_add(alpha_chunk.data[alpha_index]); |
| 859 |
} |
| 860 |
} |
| 861 |
|
| 862 |
(rgba_frame, true) |
| 863 |
} |
| 864 |
_ => return Err(DecodingError::ChunkHeaderInvalid(chunk.to_fourcc())), |
| 865 |
}; |
| 866 |
|
| 867 |
// fill starting canvas with clear color |
| 868 |
if self.animation.canvas.is_none() { |
| 869 |
self.animation.canvas = { |
| 870 |
let mut canvas = vec![0; (self.width * self.height * 4) as usize]; |
| 871 |
if let Some(color) = info.background_color.as_ref() { |
| 872 |
canvas |
| 873 |
.chunks_exact_mut(4) |
| 874 |
.for_each(|c| c.copy_from_slice(color)) |
| 875 |
} |
| 876 |
Some(canvas) |
| 877 |
} |
| 878 |
} |
| 879 |
extended::composite_frame( |
| 880 |
self.animation.canvas.as_mut().unwrap(), |
| 881 |
self.width, |
| 882 |
self.height, |
| 883 |
clear_color, |
| 884 |
&frame, |
| 885 |
frame_x, |
| 886 |
frame_y, |
| 887 |
frame_width, |
| 888 |
frame_height, |
| 889 |
frame_has_alpha, |
| 890 |
use_alpha_blending, |
| 891 |
self.animation.previous_frame_width, |
| 892 |
self.animation.previous_frame_height, |
| 893 |
self.animation.previous_frame_x_offset, |
| 894 |
self.animation.previous_frame_y_offset, |
| 895 |
); |
| 896 |
|
| 897 |
self.animation.previous_frame_width = frame_width; |
| 898 |
self.animation.previous_frame_height = frame_height; |
| 899 |
self.animation.previous_frame_x_offset = frame_x; |
| 900 |
self.animation.previous_frame_y_offset = frame_y; |
| 901 |
|
| 902 |
self.animation.dispose_next_frame = dispose; |
| 903 |
self.animation.next_frame_start += anmf_size + 8; |
| 904 |
self.animation.next_frame += 1; |
| 905 |
|
| 906 |
if self.has_alpha() { |
| 907 |
buf.copy_from_slice(self.animation.canvas.as_ref().unwrap()); |
| 908 |
} else { |
| 909 |
for (b, c) in buf |
| 910 |
.chunks_exact_mut(3) |
| 911 |
.zip(self.animation.canvas.as_ref().unwrap().chunks_exact(4)) |
| 912 |
{ |
| 913 |
b.copy_from_slice(&c[..3]); |
| 914 |
} |
| 915 |
} |
| 916 |
|
| 917 |
Ok(duration) |
| 918 |
} |
| 919 |
|
| 920 |
/// Resets the animation to the first frame. |
| 921 |
/// |
| 922 |
/// # Panics |
| 923 |
/// |
| 924 |
/// Panics if the image is not animated. |
| 925 |
pub fn reset_animation(&mut self) { |
| 926 |
assert!(self.is_animated()); |
| 927 |
|
| 928 |
self.animation.next_frame = 0; |
| 929 |
self.animation.next_frame_start = self.chunks.get(&WebPRiffChunk::ANMF).unwrap().start - 8; |
| 930 |
self.animation.dispose_next_frame = true; |
| 931 |
} |
| 932 |
|
| 933 |
/// Sets the upsampling method that is used in lossy decoding |
| 934 |
pub fn set_lossy_upsampling(&mut self, upsampling_method: UpsamplingMethod) { |
| 935 |
self.webp_decode_options.lossy_upsampling = upsampling_method; |
| 936 |
} |
| 937 |
} |
| 938 |
|
| 939 |
pub(crate) fn range_reader<R: BufRead + Seek>( |
| 940 |
mut r: R, |
| 941 |
range: Range<u64>, |
| 942 |
) -> Result<impl BufRead, DecodingError> { |
| 943 |
r.seek(io::SeekFrom::Start(range.start))?; |
| 944 |
Ok(r.take(range.end - range.start)) |
| 945 |
} |
| 946 |
|
| 947 |
pub(crate) fn read_fourcc<R: BufRead>(mut r: R) -> Result<WebPRiffChunk, DecodingError> { |
| 948 |
let mut chunk_fourcc = [0; 4]; |
| 949 |
r.read_exact(&mut chunk_fourcc)?; |
| 950 |
Ok(WebPRiffChunk::from_fourcc(chunk_fourcc)) |
| 951 |
} |
| 952 |
|
| 953 |
pub(crate) fn read_chunk_header<R: BufRead>( |
| 954 |
mut r: R, |
| 955 |
) -> Result<(WebPRiffChunk, u64, u64), DecodingError> { |
| 956 |
let chunk = read_fourcc(&mut r)?; |
| 957 |
let chunk_size = r.read_u32::<LittleEndian>()?; |
| 958 |
let chunk_size_rounded = chunk_size.saturating_add(chunk_size & 1); |
| 959 |
Ok((chunk, chunk_size.into(), chunk_size_rounded.into())) |
| 960 |
} |
| 961 |
|
| 962 |
#[cfg(test)] |
| 963 |
mod tests { |
| 964 |
use super::*; |
| 965 |
const RGB_BPP: usize = 3; |
| 966 |
|
| 967 |
#[test] |
| 968 |
fn add_with_overflow_size() { |
| 969 |
let bytes = vec![ |
| 970 |
0x52, 0x49, 0x46, 0x46, 0xaf, 0x37, 0x80, 0x47, 0x57, 0x45, 0x42, 0x50, 0x6c, 0x64, |
| 971 |
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x7e, 0x73, 0x00, 0x06, 0x00, 0x00, 0x00, |
| 972 |
0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, |
| 973 |
0x40, 0xfb, 0xff, 0xff, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, |
| 974 |
0x00, 0x00, 0x00, 0x00, 0x62, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, |
| 975 |
0x49, 0x54, 0x55, 0x50, 0x4c, 0x54, 0x59, 0x50, 0x45, 0x33, 0x37, 0x44, 0x4d, 0x46, |
| 976 |
]; |
| 977 |
|
| 978 |
let data = std::io::Cursor::new(bytes); |
| 979 |
|
| 980 |
let _ = WebPDecoder::new(data); |
| 981 |
} |
| 982 |
|
| 983 |
#[test] |
| 984 |
fn decode_2x2_single_color_image() { |
| 985 |
// Image data created from imagemagick and output of xxd: |
| 986 |
// $ convert -size 2x2 xc:#f00 red.webp |
| 987 |
// $ xxd -g 1 red.webp | head |
| 988 |
|
| 989 |
const NUM_PIXELS: usize = 2 * 2 * RGB_BPP; |
| 990 |
// 2x2 red pixel image |
| 991 |
let bytes = [ |
| 992 |
0x52, 0x49, 0x46, 0x46, 0x3c, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50, 0x56, 0x50, |
| 993 |
0x38, 0x20, 0x30, 0x00, 0x00, 0x00, 0xd0, 0x01, 0x00, 0x9d, 0x01, 0x2a, 0x02, 0x00, |
| 994 |
0x02, 0x00, 0x02, 0x00, 0x34, 0x25, 0xa0, 0x02, 0x74, 0xba, 0x01, 0xf8, 0x00, 0x03, |
| 995 |
0xb0, 0x00, 0xfe, 0xf0, 0xc4, 0x0b, 0xff, 0x20, 0xb9, 0x61, 0x75, 0xc8, 0xd7, 0xff, |
| 996 |
0x20, 0x3f, 0xe4, 0x07, 0xfc, 0x80, 0xff, 0xf8, 0xf2, 0x00, 0x00, 0x00, |
| 997 |
]; |
| 998 |
|
| 999 |
let mut data = [0; NUM_PIXELS]; |
| 1000 |
let mut decoder = WebPDecoder::new(std::io::Cursor::new(bytes)).unwrap(); |
| 1001 |
decoder.read_image(&mut data).unwrap(); |
| 1002 |
|
| 1003 |
// All pixels are the same value |
| 1004 |
let first_pixel = &data[..RGB_BPP]; |
| 1005 |
assert!(data.chunks_exact(3).all(|ch| ch.iter().eq(first_pixel))); |
| 1006 |
} |
| 1007 |
|
| 1008 |
#[test] |
| 1009 |
fn decode_3x3_single_color_image() { |
| 1010 |
// Test that any odd pixel "tail" is decoded properly |
| 1011 |
|
| 1012 |
const NUM_PIXELS: usize = 3 * 3 * RGB_BPP; |
| 1013 |
// 3x3 red pixel image |
| 1014 |
let bytes = [ |
| 1015 |
0x52, 0x49, 0x46, 0x46, 0x3c, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50, 0x56, 0x50, |
| 1016 |
0x38, 0x20, 0x30, 0x00, 0x00, 0x00, 0xd0, 0x01, 0x00, 0x9d, 0x01, 0x2a, 0x03, 0x00, |
| 1017 |
0x03, 0x00, 0x02, 0x00, 0x34, 0x25, 0xa0, 0x02, 0x74, 0xba, 0x01, 0xf8, 0x00, 0x03, |
| 1018 |
0xb0, 0x00, 0xfe, 0xf0, 0xc4, 0x0b, 0xff, 0x20, 0xb9, 0x61, 0x75, 0xc8, 0xd7, 0xff, |
| 1019 |
0x20, 0x3f, 0xe4, 0x07, 0xfc, 0x80, 0xff, 0xf8, 0xf2, 0x00, 0x00, 0x00, |
| 1020 |
]; |
| 1021 |
|
| 1022 |
let mut data = [0; NUM_PIXELS]; |
| 1023 |
let mut decoder = WebPDecoder::new(std::io::Cursor::new(bytes)).unwrap(); |
| 1024 |
decoder.read_image(&mut data).unwrap(); |
| 1025 |
|
| 1026 |
// All pixels are the same value |
| 1027 |
let first_pixel = &data[..RGB_BPP]; |
| 1028 |
assert!(data.chunks_exact(3).all(|ch| ch.iter().eq(first_pixel))); |
| 1029 |
} |
| 1030 |
} |