Vendor things
This commit is contained in:
parent
5deceec006
commit
977e3c17e5
19434 changed files with 10682014 additions and 0 deletions
384
third-party/vendor/png/src/adam7.rs
vendored
Normal file
384
third-party/vendor/png/src/adam7.rs
vendored
Normal file
|
|
@ -0,0 +1,384 @@
|
|||
//! Utility functions
|
||||
use std::iter::StepBy;
|
||||
use std::ops::Range;
|
||||
|
||||
/// This iterator iterates over the different passes of an image Adam7 encoded
|
||||
/// PNG image
|
||||
/// The pattern is:
|
||||
/// 16462646
|
||||
/// 77777777
|
||||
/// 56565656
|
||||
/// 77777777
|
||||
/// 36463646
|
||||
/// 77777777
|
||||
/// 56565656
|
||||
/// 77777777
|
||||
///
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct Adam7Iterator {
|
||||
line: u32,
|
||||
lines: u32,
|
||||
line_width: u32,
|
||||
current_pass: u8,
|
||||
width: u32,
|
||||
height: u32,
|
||||
}
|
||||
|
||||
impl Adam7Iterator {
|
||||
pub fn new(width: u32, height: u32) -> Adam7Iterator {
|
||||
let mut this = Adam7Iterator {
|
||||
line: 0,
|
||||
lines: 0,
|
||||
line_width: 0,
|
||||
current_pass: 1,
|
||||
width,
|
||||
height,
|
||||
};
|
||||
this.init_pass();
|
||||
this
|
||||
}
|
||||
|
||||
/// Calculates the bounds of the current pass
|
||||
fn init_pass(&mut self) {
|
||||
let w = f64::from(self.width);
|
||||
let h = f64::from(self.height);
|
||||
let (line_width, lines) = match self.current_pass {
|
||||
1 => (w / 8.0, h / 8.0),
|
||||
2 => ((w - 4.0) / 8.0, h / 8.0),
|
||||
3 => (w / 4.0, (h - 4.0) / 8.0),
|
||||
4 => ((w - 2.0) / 4.0, h / 4.0),
|
||||
5 => (w / 2.0, (h - 2.0) / 4.0),
|
||||
6 => ((w - 1.0) / 2.0, h / 2.0),
|
||||
7 => (w, (h - 1.0) / 2.0),
|
||||
_ => unreachable!(),
|
||||
};
|
||||
self.line_width = line_width.ceil() as u32;
|
||||
self.lines = lines.ceil() as u32;
|
||||
self.line = 0;
|
||||
}
|
||||
|
||||
/// The current pass#.
|
||||
pub fn current_pass(&self) -> u8 {
|
||||
self.current_pass
|
||||
}
|
||||
}
|
||||
|
||||
/// Iterates over the (passes, lines, widths)
|
||||
impl Iterator for Adam7Iterator {
|
||||
type Item = (u8, u32, u32);
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.line < self.lines && self.line_width > 0 {
|
||||
let this_line = self.line;
|
||||
self.line += 1;
|
||||
Some((self.current_pass, this_line, self.line_width))
|
||||
} else if self.current_pass < 7 {
|
||||
self.current_pass += 1;
|
||||
self.init_pass();
|
||||
self.next()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn subbyte_pixels(scanline: &[u8], bits_pp: usize) -> impl Iterator<Item = u8> + '_ {
|
||||
(0..scanline.len() * 8)
|
||||
.step_by(bits_pp)
|
||||
.map(move |bit_idx| {
|
||||
let byte_idx = bit_idx / 8;
|
||||
|
||||
// sub-byte samples start in the high-order bits
|
||||
let rem = 8 - bit_idx % 8 - bits_pp;
|
||||
|
||||
match bits_pp {
|
||||
// evenly divides bytes
|
||||
1 => (scanline[byte_idx] >> rem) & 1,
|
||||
2 => (scanline[byte_idx] >> rem) & 3,
|
||||
4 => (scanline[byte_idx] >> rem) & 15,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Given pass, image width, and line number, produce an iterator of bit positions of pixels to copy
|
||||
/// from the input scanline to the image buffer.
|
||||
fn expand_adam7_bits(
|
||||
pass: u8,
|
||||
width: usize,
|
||||
line_no: usize,
|
||||
bits_pp: usize,
|
||||
) -> StepBy<Range<usize>> {
|
||||
let (line_mul, line_off, samp_mul, samp_off) = match pass {
|
||||
1 => (8, 0, 8, 0),
|
||||
2 => (8, 0, 8, 4),
|
||||
3 => (8, 4, 4, 0),
|
||||
4 => (4, 0, 4, 2),
|
||||
5 => (4, 2, 2, 0),
|
||||
6 => (2, 0, 2, 1),
|
||||
7 => (2, 1, 1, 0),
|
||||
_ => panic!("Adam7 pass out of range: {}", pass),
|
||||
};
|
||||
|
||||
// the equivalent line number in progressive scan
|
||||
let prog_line = line_mul * line_no + line_off;
|
||||
// line width is rounded up to the next byte
|
||||
let line_width = (width * bits_pp + 7) & !7;
|
||||
let line_start = prog_line * line_width;
|
||||
let start = line_start + (samp_off * bits_pp);
|
||||
let stop = line_start + (width * bits_pp);
|
||||
|
||||
(start..stop).step_by(bits_pp * samp_mul)
|
||||
}
|
||||
|
||||
/// Expands an Adam 7 pass
|
||||
pub fn expand_pass(
|
||||
img: &mut [u8],
|
||||
width: u32,
|
||||
scanline: &[u8],
|
||||
pass: u8,
|
||||
line_no: u32,
|
||||
bits_pp: u8,
|
||||
) {
|
||||
let width = width as usize;
|
||||
let line_no = line_no as usize;
|
||||
let bits_pp = bits_pp as usize;
|
||||
|
||||
// pass is out of range but don't blow up
|
||||
if pass == 0 || pass > 7 {
|
||||
return;
|
||||
}
|
||||
|
||||
let bit_indices = expand_adam7_bits(pass, width, line_no, bits_pp);
|
||||
|
||||
if bits_pp < 8 {
|
||||
for (pos, px) in bit_indices.zip(subbyte_pixels(scanline, bits_pp)) {
|
||||
let rem = 8 - pos % 8 - bits_pp;
|
||||
img[pos / 8] |= px << rem as u8;
|
||||
}
|
||||
} else {
|
||||
let bytes_pp = bits_pp / 8;
|
||||
|
||||
for (bitpos, px) in bit_indices.zip(scanline.chunks(bytes_pp)) {
|
||||
for (offset, val) in px.iter().enumerate() {
|
||||
img[bitpos / 8 + offset] = *val;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_adam7() {
|
||||
/*
|
||||
1646
|
||||
7777
|
||||
5656
|
||||
7777
|
||||
*/
|
||||
let it = Adam7Iterator::new(4, 4);
|
||||
let passes: Vec<_> = it.collect();
|
||||
assert_eq!(
|
||||
&*passes,
|
||||
&[
|
||||
(1, 0, 1),
|
||||
(4, 0, 1),
|
||||
(5, 0, 2),
|
||||
(6, 0, 2),
|
||||
(6, 1, 2),
|
||||
(7, 0, 4),
|
||||
(7, 1, 4)
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_subbyte_pixels() {
|
||||
let scanline = &[0b10101010, 0b10101010];
|
||||
|
||||
let pixels = subbyte_pixels(scanline, 1).collect::<Vec<_>>();
|
||||
assert_eq!(pixels.len(), 16);
|
||||
assert_eq!(pixels, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_adam7_bits() {
|
||||
let width = 32;
|
||||
let bits_pp = 1;
|
||||
|
||||
let expected = |offset: usize, step: usize, count: usize| {
|
||||
(0..count)
|
||||
.map(move |i| step * i + offset)
|
||||
.collect::<Vec<_>>()
|
||||
};
|
||||
|
||||
for line_no in 0..8 {
|
||||
let start = 8 * line_no * width;
|
||||
|
||||
assert_eq!(
|
||||
expand_adam7_bits(1, width, line_no, bits_pp).collect::<Vec<_>>(),
|
||||
expected(start, 8, 4)
|
||||
);
|
||||
|
||||
let start = start + 4;
|
||||
|
||||
assert_eq!(
|
||||
expand_adam7_bits(2, width, line_no, bits_pp).collect::<Vec<_>>(),
|
||||
expected(start, 8, 4)
|
||||
);
|
||||
|
||||
let start = (8 * line_no + 4) * width;
|
||||
|
||||
assert_eq!(
|
||||
expand_adam7_bits(3, width, line_no, bits_pp).collect::<Vec<_>>(),
|
||||
expected(start, 4, 8)
|
||||
);
|
||||
}
|
||||
|
||||
for line_no in 0..16 {
|
||||
let start = 4 * line_no * width + 2;
|
||||
|
||||
assert_eq!(
|
||||
expand_adam7_bits(4, width, line_no, bits_pp).collect::<Vec<_>>(),
|
||||
expected(start, 4, 8)
|
||||
);
|
||||
|
||||
let start = (4 * line_no + 2) * width;
|
||||
|
||||
assert_eq!(
|
||||
expand_adam7_bits(5, width, line_no, bits_pp).collect::<Vec<_>>(),
|
||||
expected(start, 2, 16)
|
||||
)
|
||||
}
|
||||
|
||||
for line_no in 0..32 {
|
||||
let start = 2 * line_no * width + 1;
|
||||
|
||||
assert_eq!(
|
||||
expand_adam7_bits(6, width, line_no, bits_pp).collect::<Vec<_>>(),
|
||||
expected(start, 2, 16),
|
||||
"line_no: {}",
|
||||
line_no
|
||||
);
|
||||
|
||||
let start = (2 * line_no + 1) * width;
|
||||
|
||||
assert_eq!(
|
||||
expand_adam7_bits(7, width, line_no, bits_pp).collect::<Vec<_>>(),
|
||||
expected(start, 1, 32)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_pass_subbyte() {
|
||||
let mut img = [0u8; 8];
|
||||
let width = 8;
|
||||
let bits_pp = 1;
|
||||
|
||||
expand_pass(&mut img, width, &[0b10000000], 1, 0, bits_pp);
|
||||
assert_eq!(img, [0b10000000u8, 0, 0, 0, 0, 0, 0, 0]);
|
||||
|
||||
expand_pass(&mut img, width, &[0b10000000], 2, 0, bits_pp);
|
||||
assert_eq!(img, [0b10001000u8, 0, 0, 0, 0, 0, 0, 0]);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11000000], 3, 0, bits_pp);
|
||||
assert_eq!(img, [0b10001000u8, 0, 0, 0, 0b10001000, 0, 0, 0]);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11000000], 4, 0, bits_pp);
|
||||
assert_eq!(img, [0b10101010u8, 0, 0, 0, 0b10001000, 0, 0, 0]);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11000000], 4, 1, bits_pp);
|
||||
assert_eq!(img, [0b10101010u8, 0, 0, 0, 0b10101010, 0, 0, 0]);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11110000], 5, 0, bits_pp);
|
||||
assert_eq!(img, [0b10101010u8, 0, 0b10101010, 0, 0b10101010, 0, 0, 0]);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11110000], 5, 1, bits_pp);
|
||||
assert_eq!(
|
||||
img,
|
||||
[0b10101010u8, 0, 0b10101010, 0, 0b10101010, 0, 0b10101010, 0]
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11110000], 6, 0, bits_pp);
|
||||
assert_eq!(
|
||||
img,
|
||||
[0b11111111u8, 0, 0b10101010, 0, 0b10101010, 0, 0b10101010, 0]
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11110000], 6, 1, bits_pp);
|
||||
assert_eq!(
|
||||
img,
|
||||
[0b11111111u8, 0, 0b11111111, 0, 0b10101010, 0, 0b10101010, 0]
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11110000], 6, 2, bits_pp);
|
||||
assert_eq!(
|
||||
img,
|
||||
[0b11111111u8, 0, 0b11111111, 0, 0b11111111, 0, 0b10101010, 0]
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11110000], 6, 3, bits_pp);
|
||||
assert_eq!(
|
||||
[0b11111111u8, 0, 0b11111111, 0, 0b11111111, 0, 0b11111111, 0],
|
||||
img
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11111111], 7, 0, bits_pp);
|
||||
assert_eq!(
|
||||
[
|
||||
0b11111111u8,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0,
|
||||
0b11111111,
|
||||
0,
|
||||
0b11111111,
|
||||
0
|
||||
],
|
||||
img
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11111111], 7, 1, bits_pp);
|
||||
assert_eq!(
|
||||
[
|
||||
0b11111111u8,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0,
|
||||
0b11111111,
|
||||
0
|
||||
],
|
||||
img
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11111111], 7, 2, bits_pp);
|
||||
assert_eq!(
|
||||
[
|
||||
0b11111111u8,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0
|
||||
],
|
||||
img
|
||||
);
|
||||
|
||||
expand_pass(&mut img, width, &[0b11111111], 7, 3, bits_pp);
|
||||
assert_eq!(
|
||||
[
|
||||
0b11111111u8,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111,
|
||||
0b11111111
|
||||
],
|
||||
img
|
||||
);
|
||||
}
|
||||
29
third-party/vendor/png/src/benchable_apis.rs
vendored
Normal file
29
third-party/vendor/png/src/benchable_apis.rs
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
//! Development-time-only helper module for exporting private APIs so that they can be benchmarked.
|
||||
//! This module is gated behind the "benchmarks" feature.
|
||||
|
||||
use crate::common::BytesPerPixel;
|
||||
use crate::filter::FilterType;
|
||||
use crate::{BitDepth, ColorType, Info};
|
||||
|
||||
/// Re-exporting `unfilter` to make it easier to benchmark, despite some items being only
|
||||
/// `pub(crate)`: `fn unfilter`, `enum BytesPerPixel`.
|
||||
pub fn unfilter(filter: FilterType, tbpp: u8, previous: &[u8], current: &mut [u8]) {
|
||||
let tbpp = BytesPerPixel::from_usize(tbpp as usize);
|
||||
crate::filter::unfilter(filter, tbpp, previous, current)
|
||||
}
|
||||
|
||||
pub use crate::decoder::transform::{create_transform_fn, TransformFn};
|
||||
|
||||
pub fn create_info_from_plte_trns_bitdepth<'a>(
|
||||
plte: &'a [u8],
|
||||
trns: Option<&'a [u8]>,
|
||||
bit_depth: u8,
|
||||
) -> Info<'a> {
|
||||
Info {
|
||||
color_type: ColorType::Indexed,
|
||||
bit_depth: BitDepth::from_u8(bit_depth).unwrap(),
|
||||
palette: Some(plte.into()),
|
||||
trns: trns.map(Into::into),
|
||||
..Info::default()
|
||||
}
|
||||
}
|
||||
98
third-party/vendor/png/src/chunk.rs
vendored
Normal file
98
third-party/vendor/png/src/chunk.rs
vendored
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
//! Chunk types and functions
|
||||
#![allow(dead_code)]
|
||||
#![allow(non_upper_case_globals)]
|
||||
use core::fmt;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct ChunkType(pub [u8; 4]);
|
||||
|
||||
// -- Critical chunks --
|
||||
|
||||
/// Image header
|
||||
pub const IHDR: ChunkType = ChunkType(*b"IHDR");
|
||||
/// Palette
|
||||
pub const PLTE: ChunkType = ChunkType(*b"PLTE");
|
||||
/// Image data
|
||||
pub const IDAT: ChunkType = ChunkType(*b"IDAT");
|
||||
/// Image trailer
|
||||
pub const IEND: ChunkType = ChunkType(*b"IEND");
|
||||
|
||||
// -- Ancillary chunks --
|
||||
|
||||
/// Transparency
|
||||
pub const tRNS: ChunkType = ChunkType(*b"tRNS");
|
||||
/// Background colour
|
||||
pub const bKGD: ChunkType = ChunkType(*b"bKGD");
|
||||
/// Image last-modification time
|
||||
pub const tIME: ChunkType = ChunkType(*b"tIME");
|
||||
/// Physical pixel dimensions
|
||||
pub const pHYs: ChunkType = ChunkType(*b"pHYs");
|
||||
/// Source system's pixel chromaticities
|
||||
pub const cHRM: ChunkType = ChunkType(*b"cHRM");
|
||||
/// Source system's gamma value
|
||||
pub const gAMA: ChunkType = ChunkType(*b"gAMA");
|
||||
/// sRGB color space chunk
|
||||
pub const sRGB: ChunkType = ChunkType(*b"sRGB");
|
||||
/// ICC profile chunk
|
||||
pub const iCCP: ChunkType = ChunkType(*b"iCCP");
|
||||
/// Latin-1 uncompressed textual data
|
||||
pub const tEXt: ChunkType = ChunkType(*b"tEXt");
|
||||
/// Latin-1 compressed textual data
|
||||
pub const zTXt: ChunkType = ChunkType(*b"zTXt");
|
||||
/// UTF-8 textual data
|
||||
pub const iTXt: ChunkType = ChunkType(*b"iTXt");
|
||||
|
||||
// -- Extension chunks --
|
||||
|
||||
/// Animation control
|
||||
pub const acTL: ChunkType = ChunkType(*b"acTL");
|
||||
/// Frame control
|
||||
pub const fcTL: ChunkType = ChunkType(*b"fcTL");
|
||||
/// Frame data
|
||||
pub const fdAT: ChunkType = ChunkType(*b"fdAT");
|
||||
|
||||
// -- Chunk type determination --
|
||||
|
||||
/// Returns true if the chunk is critical.
|
||||
pub fn is_critical(ChunkType(type_): ChunkType) -> bool {
|
||||
type_[0] & 32 == 0
|
||||
}
|
||||
|
||||
/// Returns true if the chunk is private.
|
||||
pub fn is_private(ChunkType(type_): ChunkType) -> bool {
|
||||
type_[1] & 32 != 0
|
||||
}
|
||||
|
||||
/// Checks whether the reserved bit of the chunk name is set.
|
||||
/// If it is set the chunk name is invalid.
|
||||
pub fn reserved_set(ChunkType(type_): ChunkType) -> bool {
|
||||
type_[2] & 32 != 0
|
||||
}
|
||||
|
||||
/// Returns true if the chunk is safe to copy if unknown.
|
||||
pub fn safe_to_copy(ChunkType(type_): ChunkType) -> bool {
|
||||
type_[3] & 32 != 0
|
||||
}
|
||||
|
||||
impl fmt::Debug for ChunkType {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
struct DebugType([u8; 4]);
|
||||
|
||||
impl fmt::Debug for DebugType {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
for &c in &self.0[..] {
|
||||
write!(f, "{}", char::from(c).escape_debug())?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
f.debug_struct("ChunkType")
|
||||
.field("type", &DebugType(self.0))
|
||||
.field("critical", &is_critical(*self))
|
||||
.field("private", &is_private(*self))
|
||||
.field("reserved", &reserved_set(*self))
|
||||
.field("safecopy", &safe_to_copy(*self))
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
812
third-party/vendor/png/src/common.rs
vendored
Normal file
812
third-party/vendor/png/src/common.rs
vendored
Normal file
|
|
@ -0,0 +1,812 @@
|
|||
//! Common types shared between the encoder and decoder
|
||||
use crate::text_metadata::{EncodableTextChunk, ITXtChunk, TEXtChunk, ZTXtChunk};
|
||||
use crate::{chunk, encoder};
|
||||
use io::Write;
|
||||
use std::{borrow::Cow, convert::TryFrom, fmt, io};
|
||||
|
||||
/// Describes how a pixel is encoded.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(u8)]
|
||||
pub enum ColorType {
|
||||
/// 1 grayscale sample.
|
||||
Grayscale = 0,
|
||||
/// 1 red sample, 1 green sample, 1 blue sample.
|
||||
Rgb = 2,
|
||||
/// 1 sample for the palette index.
|
||||
Indexed = 3,
|
||||
/// 1 grayscale sample, then 1 alpha sample.
|
||||
GrayscaleAlpha = 4,
|
||||
/// 1 red sample, 1 green sample, 1 blue sample, and finally, 1 alpha sample.
|
||||
Rgba = 6,
|
||||
}
|
||||
|
||||
impl ColorType {
|
||||
/// Returns the number of samples used per pixel encoded in this way.
|
||||
pub fn samples(self) -> usize {
|
||||
self.samples_u8().into()
|
||||
}
|
||||
|
||||
pub(crate) fn samples_u8(self) -> u8 {
|
||||
use self::ColorType::*;
|
||||
match self {
|
||||
Grayscale | Indexed => 1,
|
||||
Rgb => 3,
|
||||
GrayscaleAlpha => 2,
|
||||
Rgba => 4,
|
||||
}
|
||||
}
|
||||
|
||||
/// u8 -> Self. Temporary solution until Rust provides a canonical one.
|
||||
pub fn from_u8(n: u8) -> Option<ColorType> {
|
||||
match n {
|
||||
0 => Some(ColorType::Grayscale),
|
||||
2 => Some(ColorType::Rgb),
|
||||
3 => Some(ColorType::Indexed),
|
||||
4 => Some(ColorType::GrayscaleAlpha),
|
||||
6 => Some(ColorType::Rgba),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn checked_raw_row_length(self, depth: BitDepth, width: u32) -> Option<usize> {
|
||||
// No overflow can occur in 64 bits, we multiply 32-bit with 5 more bits.
|
||||
let bits = u64::from(width) * u64::from(self.samples_u8()) * u64::from(depth.into_u8());
|
||||
TryFrom::try_from(1 + (bits + 7) / 8).ok()
|
||||
}
|
||||
|
||||
pub(crate) fn raw_row_length_from_width(self, depth: BitDepth, width: u32) -> usize {
|
||||
let samples = width as usize * self.samples();
|
||||
1 + match depth {
|
||||
BitDepth::Sixteen => samples * 2,
|
||||
BitDepth::Eight => samples,
|
||||
subbyte => {
|
||||
let samples_per_byte = 8 / subbyte as usize;
|
||||
let whole = samples / samples_per_byte;
|
||||
let fract = usize::from(samples % samples_per_byte > 0);
|
||||
whole + fract
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_combination_invalid(self, bit_depth: BitDepth) -> bool {
|
||||
// Section 11.2.2 of the PNG standard disallows several combinations
|
||||
// of bit depth and color type
|
||||
((bit_depth == BitDepth::One || bit_depth == BitDepth::Two || bit_depth == BitDepth::Four)
|
||||
&& (self == ColorType::Rgb
|
||||
|| self == ColorType::GrayscaleAlpha
|
||||
|| self == ColorType::Rgba))
|
||||
|| (bit_depth == BitDepth::Sixteen && self == ColorType::Indexed)
|
||||
}
|
||||
}
|
||||
|
||||
/// Bit depth of the PNG file.
|
||||
/// Specifies the number of bits per sample.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(u8)]
|
||||
pub enum BitDepth {
|
||||
One = 1,
|
||||
Two = 2,
|
||||
Four = 4,
|
||||
Eight = 8,
|
||||
Sixteen = 16,
|
||||
}
|
||||
|
||||
/// Internal count of bytes per pixel.
|
||||
/// This is used for filtering which never uses sub-byte units. This essentially reduces the number
|
||||
/// of possible byte chunk lengths to a very small set of values appropriate to be defined as an
|
||||
/// enum.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
#[repr(u8)]
|
||||
pub(crate) enum BytesPerPixel {
|
||||
One = 1,
|
||||
Two = 2,
|
||||
Three = 3,
|
||||
Four = 4,
|
||||
Six = 6,
|
||||
Eight = 8,
|
||||
}
|
||||
|
||||
impl BitDepth {
|
||||
/// u8 -> Self. Temporary solution until Rust provides a canonical one.
|
||||
pub fn from_u8(n: u8) -> Option<BitDepth> {
|
||||
match n {
|
||||
1 => Some(BitDepth::One),
|
||||
2 => Some(BitDepth::Two),
|
||||
4 => Some(BitDepth::Four),
|
||||
8 => Some(BitDepth::Eight),
|
||||
16 => Some(BitDepth::Sixteen),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn into_u8(self) -> u8 {
|
||||
self as u8
|
||||
}
|
||||
}
|
||||
|
||||
/// Pixel dimensions information
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct PixelDimensions {
|
||||
/// Pixels per unit, X axis
|
||||
pub xppu: u32,
|
||||
/// Pixels per unit, Y axis
|
||||
pub yppu: u32,
|
||||
/// Either *Meter* or *Unspecified*
|
||||
pub unit: Unit,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(u8)]
|
||||
/// Physical unit of the pixel dimensions
|
||||
pub enum Unit {
|
||||
Unspecified = 0,
|
||||
Meter = 1,
|
||||
}
|
||||
|
||||
impl Unit {
|
||||
/// u8 -> Self. Temporary solution until Rust provides a canonical one.
|
||||
pub fn from_u8(n: u8) -> Option<Unit> {
|
||||
match n {
|
||||
0 => Some(Unit::Unspecified),
|
||||
1 => Some(Unit::Meter),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// How to reset buffer of an animated png (APNG) at the end of a frame.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(u8)]
|
||||
pub enum DisposeOp {
|
||||
/// Leave the buffer unchanged.
|
||||
None = 0,
|
||||
/// Clear buffer with the background color.
|
||||
Background = 1,
|
||||
/// Reset the buffer to the state before the current frame.
|
||||
Previous = 2,
|
||||
}
|
||||
|
||||
impl DisposeOp {
|
||||
/// u8 -> Self. Using enum_primitive or transmute is probably the right thing but this will do for now.
|
||||
pub fn from_u8(n: u8) -> Option<DisposeOp> {
|
||||
match n {
|
||||
0 => Some(DisposeOp::None),
|
||||
1 => Some(DisposeOp::Background),
|
||||
2 => Some(DisposeOp::Previous),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for DisposeOp {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
let name = match *self {
|
||||
DisposeOp::None => "DISPOSE_OP_NONE",
|
||||
DisposeOp::Background => "DISPOSE_OP_BACKGROUND",
|
||||
DisposeOp::Previous => "DISPOSE_OP_PREVIOUS",
|
||||
};
|
||||
write!(f, "{}", name)
|
||||
}
|
||||
}
|
||||
|
||||
/// How pixels are written into the buffer.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(u8)]
|
||||
pub enum BlendOp {
|
||||
/// Pixels overwrite the value at their position.
|
||||
Source = 0,
|
||||
/// The new pixels are blended into the current state based on alpha.
|
||||
Over = 1,
|
||||
}
|
||||
|
||||
impl BlendOp {
|
||||
/// u8 -> Self. Using enum_primitive or transmute is probably the right thing but this will do for now.
|
||||
pub fn from_u8(n: u8) -> Option<BlendOp> {
|
||||
match n {
|
||||
0 => Some(BlendOp::Source),
|
||||
1 => Some(BlendOp::Over),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for BlendOp {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
let name = match *self {
|
||||
BlendOp::Source => "BLEND_OP_SOURCE",
|
||||
BlendOp::Over => "BLEND_OP_OVER",
|
||||
};
|
||||
write!(f, "{}", name)
|
||||
}
|
||||
}
|
||||
|
||||
/// Frame control information
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct FrameControl {
|
||||
/// Sequence number of the animation chunk, starting from 0
|
||||
pub sequence_number: u32,
|
||||
/// Width of the following frame
|
||||
pub width: u32,
|
||||
/// Height of the following frame
|
||||
pub height: u32,
|
||||
/// X position at which to render the following frame
|
||||
pub x_offset: u32,
|
||||
/// Y position at which to render the following frame
|
||||
pub y_offset: u32,
|
||||
/// Frame delay fraction numerator
|
||||
pub delay_num: u16,
|
||||
/// Frame delay fraction denominator
|
||||
pub delay_den: u16,
|
||||
/// Type of frame area disposal to be done after rendering this frame
|
||||
pub dispose_op: DisposeOp,
|
||||
/// Type of frame area rendering for this frame
|
||||
pub blend_op: BlendOp,
|
||||
}
|
||||
|
||||
impl Default for FrameControl {
|
||||
fn default() -> FrameControl {
|
||||
FrameControl {
|
||||
sequence_number: 0,
|
||||
width: 0,
|
||||
height: 0,
|
||||
x_offset: 0,
|
||||
y_offset: 0,
|
||||
delay_num: 1,
|
||||
delay_den: 30,
|
||||
dispose_op: DisposeOp::None,
|
||||
blend_op: BlendOp::Source,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FrameControl {
|
||||
pub fn set_seq_num(&mut self, s: u32) {
|
||||
self.sequence_number = s;
|
||||
}
|
||||
|
||||
pub fn inc_seq_num(&mut self, i: u32) {
|
||||
self.sequence_number += i;
|
||||
}
|
||||
|
||||
pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
|
||||
let mut data = [0u8; 26];
|
||||
data[..4].copy_from_slice(&self.sequence_number.to_be_bytes());
|
||||
data[4..8].copy_from_slice(&self.width.to_be_bytes());
|
||||
data[8..12].copy_from_slice(&self.height.to_be_bytes());
|
||||
data[12..16].copy_from_slice(&self.x_offset.to_be_bytes());
|
||||
data[16..20].copy_from_slice(&self.y_offset.to_be_bytes());
|
||||
data[20..22].copy_from_slice(&self.delay_num.to_be_bytes());
|
||||
data[22..24].copy_from_slice(&self.delay_den.to_be_bytes());
|
||||
data[24] = self.dispose_op as u8;
|
||||
data[25] = self.blend_op as u8;
|
||||
|
||||
encoder::write_chunk(w, chunk::fcTL, &data)
|
||||
}
|
||||
}
|
||||
|
||||
/// Animation control information
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct AnimationControl {
|
||||
/// Number of frames
|
||||
pub num_frames: u32,
|
||||
/// Number of times to loop this APNG. 0 indicates infinite looping.
|
||||
pub num_plays: u32,
|
||||
}
|
||||
|
||||
impl AnimationControl {
|
||||
pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
|
||||
let mut data = [0; 8];
|
||||
data[..4].copy_from_slice(&self.num_frames.to_be_bytes());
|
||||
data[4..].copy_from_slice(&self.num_plays.to_be_bytes());
|
||||
encoder::write_chunk(w, chunk::acTL, &data)
|
||||
}
|
||||
}
|
||||
|
||||
/// The type and strength of applied compression.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum Compression {
|
||||
/// Default level
|
||||
Default,
|
||||
/// Fast minimal compression
|
||||
Fast,
|
||||
/// Higher compression level
|
||||
///
|
||||
/// Best in this context isn't actually the highest possible level
|
||||
/// the encoder can do, but is meant to emulate the `Best` setting in the `Flate2`
|
||||
/// library.
|
||||
Best,
|
||||
#[deprecated(
|
||||
since = "0.17.6",
|
||||
note = "use one of the other compression levels instead, such as 'fast'"
|
||||
)]
|
||||
Huffman,
|
||||
#[deprecated(
|
||||
since = "0.17.6",
|
||||
note = "use one of the other compression levels instead, such as 'fast'"
|
||||
)]
|
||||
Rle,
|
||||
}
|
||||
|
||||
impl Default for Compression {
|
||||
fn default() -> Self {
|
||||
Self::Default
|
||||
}
|
||||
}
|
||||
|
||||
/// An unsigned integer scaled version of a floating point value,
|
||||
/// equivalent to an integer quotient with fixed denominator (100_000)).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct ScaledFloat(u32);
|
||||
|
||||
impl ScaledFloat {
|
||||
const SCALING: f32 = 100_000.0;
|
||||
|
||||
/// Gets whether the value is within the clamped range of this type.
|
||||
pub fn in_range(value: f32) -> bool {
|
||||
value >= 0.0 && (value * Self::SCALING).floor() <= std::u32::MAX as f32
|
||||
}
|
||||
|
||||
/// Gets whether the value can be exactly converted in round-trip.
|
||||
#[allow(clippy::float_cmp)] // Stupid tool, the exact float compare is _the entire point_.
|
||||
pub fn exact(value: f32) -> bool {
|
||||
let there = Self::forward(value);
|
||||
let back = Self::reverse(there);
|
||||
value == back
|
||||
}
|
||||
|
||||
fn forward(value: f32) -> u32 {
|
||||
(value.max(0.0) * Self::SCALING).floor() as u32
|
||||
}
|
||||
|
||||
fn reverse(encoded: u32) -> f32 {
|
||||
encoded as f32 / Self::SCALING
|
||||
}
|
||||
|
||||
/// Slightly inaccurate scaling and quantization.
|
||||
/// Clamps the value into the representable range if it is negative or too large.
|
||||
pub fn new(value: f32) -> Self {
|
||||
Self(Self::forward(value))
|
||||
}
|
||||
|
||||
/// Fully accurate construction from a value scaled as per specification.
|
||||
pub fn from_scaled(val: u32) -> Self {
|
||||
Self(val)
|
||||
}
|
||||
|
||||
/// Get the accurate encoded value.
|
||||
pub fn into_scaled(self) -> u32 {
|
||||
self.0
|
||||
}
|
||||
|
||||
/// Get the unscaled value as a floating point.
|
||||
pub fn into_value(self) -> f32 {
|
||||
Self::reverse(self.0)
|
||||
}
|
||||
|
||||
pub(crate) fn encode_gama<W: Write>(self, w: &mut W) -> encoder::Result<()> {
|
||||
encoder::write_chunk(w, chunk::gAMA, &self.into_scaled().to_be_bytes())
|
||||
}
|
||||
}
|
||||
|
||||
/// Chromaticities of the color space primaries
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct SourceChromaticities {
|
||||
pub white: (ScaledFloat, ScaledFloat),
|
||||
pub red: (ScaledFloat, ScaledFloat),
|
||||
pub green: (ScaledFloat, ScaledFloat),
|
||||
pub blue: (ScaledFloat, ScaledFloat),
|
||||
}
|
||||
|
||||
impl SourceChromaticities {
|
||||
pub fn new(white: (f32, f32), red: (f32, f32), green: (f32, f32), blue: (f32, f32)) -> Self {
|
||||
SourceChromaticities {
|
||||
white: (ScaledFloat::new(white.0), ScaledFloat::new(white.1)),
|
||||
red: (ScaledFloat::new(red.0), ScaledFloat::new(red.1)),
|
||||
green: (ScaledFloat::new(green.0), ScaledFloat::new(green.1)),
|
||||
blue: (ScaledFloat::new(blue.0), ScaledFloat::new(blue.1)),
|
||||
}
|
||||
}
|
||||
|
||||
#[rustfmt::skip]
|
||||
pub fn to_be_bytes(self) -> [u8; 32] {
|
||||
let white_x = self.white.0.into_scaled().to_be_bytes();
|
||||
let white_y = self.white.1.into_scaled().to_be_bytes();
|
||||
let red_x = self.red.0.into_scaled().to_be_bytes();
|
||||
let red_y = self.red.1.into_scaled().to_be_bytes();
|
||||
let green_x = self.green.0.into_scaled().to_be_bytes();
|
||||
let green_y = self.green.1.into_scaled().to_be_bytes();
|
||||
let blue_x = self.blue.0.into_scaled().to_be_bytes();
|
||||
let blue_y = self.blue.1.into_scaled().to_be_bytes();
|
||||
[
|
||||
white_x[0], white_x[1], white_x[2], white_x[3],
|
||||
white_y[0], white_y[1], white_y[2], white_y[3],
|
||||
red_x[0], red_x[1], red_x[2], red_x[3],
|
||||
red_y[0], red_y[1], red_y[2], red_y[3],
|
||||
green_x[0], green_x[1], green_x[2], green_x[3],
|
||||
green_y[0], green_y[1], green_y[2], green_y[3],
|
||||
blue_x[0], blue_x[1], blue_x[2], blue_x[3],
|
||||
blue_y[0], blue_y[1], blue_y[2], blue_y[3],
|
||||
]
|
||||
}
|
||||
|
||||
pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
|
||||
encoder::write_chunk(w, chunk::cHRM, &self.to_be_bytes())
|
||||
}
|
||||
}
|
||||
|
||||
/// The rendering intent for an sRGB image.
|
||||
///
|
||||
/// Presence of this data also indicates that the image conforms to the sRGB color space.
|
||||
#[repr(u8)]
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum SrgbRenderingIntent {
|
||||
/// For images preferring good adaptation to the output device gamut at the expense of colorimetric accuracy, such as photographs.
|
||||
Perceptual = 0,
|
||||
/// For images requiring colour appearance matching (relative to the output device white point), such as logos.
|
||||
RelativeColorimetric = 1,
|
||||
/// For images preferring preservation of saturation at the expense of hue and lightness, such as charts and graphs.
|
||||
Saturation = 2,
|
||||
/// For images requiring preservation of absolute colorimetry, such as previews of images destined for a different output device (proofs).
|
||||
AbsoluteColorimetric = 3,
|
||||
}
|
||||
|
||||
impl SrgbRenderingIntent {
|
||||
pub(crate) fn into_raw(self) -> u8 {
|
||||
self as u8
|
||||
}
|
||||
|
||||
pub(crate) fn from_raw(raw: u8) -> Option<Self> {
|
||||
match raw {
|
||||
0 => Some(SrgbRenderingIntent::Perceptual),
|
||||
1 => Some(SrgbRenderingIntent::RelativeColorimetric),
|
||||
2 => Some(SrgbRenderingIntent::Saturation),
|
||||
3 => Some(SrgbRenderingIntent::AbsoluteColorimetric),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
|
||||
encoder::write_chunk(w, chunk::sRGB, &[self.into_raw()])
|
||||
}
|
||||
}
|
||||
|
||||
/// PNG info struct
|
||||
#[derive(Clone, Debug)]
|
||||
#[non_exhaustive]
|
||||
pub struct Info<'a> {
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
pub bit_depth: BitDepth,
|
||||
/// How colors are stored in the image.
|
||||
pub color_type: ColorType,
|
||||
pub interlaced: bool,
|
||||
/// The image's `tRNS` chunk, if present; contains the alpha channel of the image's palette, 1 byte per entry.
|
||||
pub trns: Option<Cow<'a, [u8]>>,
|
||||
pub pixel_dims: Option<PixelDimensions>,
|
||||
/// The image's `PLTE` chunk, if present; contains the RGB channels (in that order) of the image's palettes, 3 bytes per entry (1 per channel).
|
||||
pub palette: Option<Cow<'a, [u8]>>,
|
||||
/// The contents of the image's gAMA chunk, if present.
|
||||
/// Prefer `source_gamma` to also get the derived replacement gamma from sRGB chunks.
|
||||
pub gama_chunk: Option<ScaledFloat>,
|
||||
/// The contents of the image's `cHRM` chunk, if present.
|
||||
/// Prefer `source_chromaticities` to also get the derived replacements from sRGB chunks.
|
||||
pub chrm_chunk: Option<SourceChromaticities>,
|
||||
|
||||
pub frame_control: Option<FrameControl>,
|
||||
pub animation_control: Option<AnimationControl>,
|
||||
pub compression: Compression,
|
||||
/// Gamma of the source system.
|
||||
/// Set by both `gAMA` as well as to a replacement by `sRGB` chunk.
|
||||
pub source_gamma: Option<ScaledFloat>,
|
||||
/// Chromaticities of the source system.
|
||||
/// Set by both `cHRM` as well as to a replacement by `sRGB` chunk.
|
||||
pub source_chromaticities: Option<SourceChromaticities>,
|
||||
/// The rendering intent of an SRGB image.
|
||||
///
|
||||
/// Presence of this value also indicates that the image conforms to the SRGB color space.
|
||||
pub srgb: Option<SrgbRenderingIntent>,
|
||||
/// The ICC profile for the image.
|
||||
pub icc_profile: Option<Cow<'a, [u8]>>,
|
||||
/// tEXt field
|
||||
pub uncompressed_latin1_text: Vec<TEXtChunk>,
|
||||
/// zTXt field
|
||||
pub compressed_latin1_text: Vec<ZTXtChunk>,
|
||||
/// iTXt field
|
||||
pub utf8_text: Vec<ITXtChunk>,
|
||||
}
|
||||
|
||||
impl Default for Info<'_> {
|
||||
fn default() -> Info<'static> {
|
||||
Info {
|
||||
width: 0,
|
||||
height: 0,
|
||||
bit_depth: BitDepth::Eight,
|
||||
color_type: ColorType::Grayscale,
|
||||
interlaced: false,
|
||||
palette: None,
|
||||
trns: None,
|
||||
gama_chunk: None,
|
||||
chrm_chunk: None,
|
||||
pixel_dims: None,
|
||||
frame_control: None,
|
||||
animation_control: None,
|
||||
// Default to `deflate::Compression::Fast` and `filter::FilterType::Sub`
|
||||
// to maintain backward compatible output.
|
||||
compression: Compression::Fast,
|
||||
source_gamma: None,
|
||||
source_chromaticities: None,
|
||||
srgb: None,
|
||||
icc_profile: None,
|
||||
uncompressed_latin1_text: Vec::new(),
|
||||
compressed_latin1_text: Vec::new(),
|
||||
utf8_text: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Info<'_> {
|
||||
/// A utility constructor for a default info with width and height.
|
||||
pub fn with_size(width: u32, height: u32) -> Self {
|
||||
Info {
|
||||
width,
|
||||
height,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Size of the image, width then height.
|
||||
pub fn size(&self) -> (u32, u32) {
|
||||
(self.width, self.height)
|
||||
}
|
||||
|
||||
/// Returns true if the image is an APNG image.
|
||||
pub fn is_animated(&self) -> bool {
|
||||
self.frame_control.is_some() && self.animation_control.is_some()
|
||||
}
|
||||
|
||||
/// Returns the frame control information of the image.
|
||||
pub fn animation_control(&self) -> Option<&AnimationControl> {
|
||||
self.animation_control.as_ref()
|
||||
}
|
||||
|
||||
/// Returns the frame control information of the current frame
|
||||
pub fn frame_control(&self) -> Option<&FrameControl> {
|
||||
self.frame_control.as_ref()
|
||||
}
|
||||
|
||||
/// Returns the number of bits per pixel.
|
||||
pub fn bits_per_pixel(&self) -> usize {
|
||||
self.color_type.samples() * self.bit_depth as usize
|
||||
}
|
||||
|
||||
/// Returns the number of bytes per pixel.
|
||||
pub fn bytes_per_pixel(&self) -> usize {
|
||||
// If adjusting this for expansion or other transformation passes, remember to keep the old
|
||||
// implementation for bpp_in_prediction, which is internal to the png specification.
|
||||
self.color_type.samples() * ((self.bit_depth as usize + 7) >> 3)
|
||||
}
|
||||
|
||||
/// Return the number of bytes for this pixel used in prediction.
|
||||
///
|
||||
/// Some filters use prediction, over the raw bytes of a scanline. Where a previous pixel is
|
||||
/// require for such forms the specification instead references previous bytes. That is, for
|
||||
/// a gray pixel of bit depth 2, the pixel used in prediction is actually 4 pixels prior. This
|
||||
/// has the consequence that the number of possible values is rather small. To make this fact
|
||||
/// more obvious in the type system and the optimizer we use an explicit enum here.
|
||||
pub(crate) fn bpp_in_prediction(&self) -> BytesPerPixel {
|
||||
BytesPerPixel::from_usize(self.bytes_per_pixel())
|
||||
}
|
||||
|
||||
/// Returns the number of bytes needed for one deinterlaced image.
|
||||
pub fn raw_bytes(&self) -> usize {
|
||||
self.height as usize * self.raw_row_length()
|
||||
}
|
||||
|
||||
/// Returns the number of bytes needed for one deinterlaced row.
|
||||
pub fn raw_row_length(&self) -> usize {
|
||||
self.raw_row_length_from_width(self.width)
|
||||
}
|
||||
|
||||
pub(crate) fn checked_raw_row_length(&self) -> Option<usize> {
|
||||
self.color_type
|
||||
.checked_raw_row_length(self.bit_depth, self.width)
|
||||
}
|
||||
|
||||
/// Returns the number of bytes needed for one deinterlaced row of width `width`.
|
||||
pub fn raw_row_length_from_width(&self, width: u32) -> usize {
|
||||
self.color_type
|
||||
.raw_row_length_from_width(self.bit_depth, width)
|
||||
}
|
||||
|
||||
/// Encode this header to the writer.
|
||||
///
|
||||
/// Note that this does _not_ include the PNG signature, it starts with the IHDR chunk and then
|
||||
/// includes other chunks that were added to the header.
|
||||
pub fn encode<W: Write>(&self, mut w: W) -> encoder::Result<()> {
|
||||
// Encode the IHDR chunk
|
||||
let mut data = [0; 13];
|
||||
data[..4].copy_from_slice(&self.width.to_be_bytes());
|
||||
data[4..8].copy_from_slice(&self.height.to_be_bytes());
|
||||
data[8] = self.bit_depth as u8;
|
||||
data[9] = self.color_type as u8;
|
||||
data[12] = self.interlaced as u8;
|
||||
encoder::write_chunk(&mut w, chunk::IHDR, &data)?;
|
||||
// Encode the pHYs chunk
|
||||
if let Some(pd) = self.pixel_dims {
|
||||
let mut phys_data = [0; 9];
|
||||
phys_data[0..4].copy_from_slice(&pd.xppu.to_be_bytes());
|
||||
phys_data[4..8].copy_from_slice(&pd.yppu.to_be_bytes());
|
||||
match pd.unit {
|
||||
Unit::Meter => phys_data[8] = 1,
|
||||
Unit::Unspecified => phys_data[8] = 0,
|
||||
}
|
||||
encoder::write_chunk(&mut w, chunk::pHYs, &phys_data)?;
|
||||
}
|
||||
|
||||
if let Some(p) = &self.palette {
|
||||
encoder::write_chunk(&mut w, chunk::PLTE, p)?;
|
||||
};
|
||||
|
||||
if let Some(t) = &self.trns {
|
||||
encoder::write_chunk(&mut w, chunk::tRNS, t)?;
|
||||
}
|
||||
|
||||
// If specified, the sRGB information overrides the source gamma and chromaticities.
|
||||
if let Some(srgb) = &self.srgb {
|
||||
let gamma = crate::srgb::substitute_gamma();
|
||||
let chromaticities = crate::srgb::substitute_chromaticities();
|
||||
srgb.encode(&mut w)?;
|
||||
gamma.encode_gama(&mut w)?;
|
||||
chromaticities.encode(&mut w)?;
|
||||
} else {
|
||||
if let Some(gma) = self.source_gamma {
|
||||
gma.encode_gama(&mut w)?
|
||||
}
|
||||
if let Some(chrms) = self.source_chromaticities {
|
||||
chrms.encode(&mut w)?;
|
||||
}
|
||||
}
|
||||
if let Some(actl) = self.animation_control {
|
||||
actl.encode(&mut w)?;
|
||||
}
|
||||
|
||||
for text_chunk in &self.uncompressed_latin1_text {
|
||||
text_chunk.encode(&mut w)?;
|
||||
}
|
||||
|
||||
for text_chunk in &self.compressed_latin1_text {
|
||||
text_chunk.encode(&mut w)?;
|
||||
}
|
||||
|
||||
for text_chunk in &self.utf8_text {
|
||||
text_chunk.encode(&mut w)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl BytesPerPixel {
|
||||
pub(crate) fn from_usize(bpp: usize) -> Self {
|
||||
match bpp {
|
||||
1 => BytesPerPixel::One,
|
||||
2 => BytesPerPixel::Two,
|
||||
3 => BytesPerPixel::Three,
|
||||
4 => BytesPerPixel::Four,
|
||||
6 => BytesPerPixel::Six, // Only rgb×16bit
|
||||
8 => BytesPerPixel::Eight, // Only rgba×16bit
|
||||
_ => unreachable!("Not a possible byte rounded pixel width"),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn into_usize(self) -> usize {
|
||||
self as usize
|
||||
}
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
/// Output transformations
|
||||
///
|
||||
/// Many flags from libpng are not yet supported. A PR discussing/adding them would be nice.
|
||||
///
|
||||
#[doc = "
|
||||
```c
|
||||
/// Discard the alpha channel
|
||||
const STRIP_ALPHA = 0x0002; // read only
|
||||
/// Expand 1; 2 and 4-bit samples to bytes
|
||||
const PACKING = 0x0004; // read and write
|
||||
/// Change order of packed pixels to LSB first
|
||||
const PACKSWAP = 0x0008; // read and write
|
||||
/// Invert monochrome images
|
||||
const INVERT_MONO = 0x0020; // read and write
|
||||
/// Normalize pixels to the sBIT depth
|
||||
const SHIFT = 0x0040; // read and write
|
||||
/// Flip RGB to BGR; RGBA to BGRA
|
||||
const BGR = 0x0080; // read and write
|
||||
/// Flip RGBA to ARGB or GA to AG
|
||||
const SWAP_ALPHA = 0x0100; // read and write
|
||||
/// Byte-swap 16-bit samples
|
||||
const SWAP_ENDIAN = 0x0200; // read and write
|
||||
/// Change alpha from opacity to transparency
|
||||
const INVERT_ALPHA = 0x0400; // read and write
|
||||
const STRIP_FILLER = 0x0800; // write only
|
||||
const STRIP_FILLER_BEFORE = 0x0800; // write only
|
||||
const STRIP_FILLER_AFTER = 0x1000; // write only
|
||||
const GRAY_TO_RGB = 0x2000; // read only
|
||||
const EXPAND_16 = 0x4000; // read only
|
||||
/// Similar to STRIP_16 but in libpng considering gamma?
|
||||
/// Not entirely sure the documentation says it is more
|
||||
/// accurate but doesn't say precisely how.
|
||||
const SCALE_16 = 0x8000; // read only
|
||||
```
|
||||
"]
|
||||
pub struct Transformations: u32 {
|
||||
/// No transformation
|
||||
const IDENTITY = 0x00000; // read and write */
|
||||
/// Strip 16-bit samples to 8 bits
|
||||
const STRIP_16 = 0x00001; // read only */
|
||||
/// Expand paletted images to RGB; expand grayscale images of
|
||||
/// less than 8-bit depth to 8-bit depth; and expand tRNS chunks
|
||||
/// to alpha channels.
|
||||
const EXPAND = 0x00010; // read only */
|
||||
/// Expand paletted images to include an alpha channel. Implies `EXPAND`.
|
||||
const ALPHA = 0x10000; // read only */
|
||||
}
|
||||
}
|
||||
|
||||
impl Transformations {
|
||||
/// Transform every input to 8bit grayscale or color.
|
||||
///
|
||||
/// This sets `EXPAND` and `STRIP_16` which is similar to the default transformation used by
|
||||
/// this library prior to `0.17`.
|
||||
pub fn normalize_to_color8() -> Transformations {
|
||||
Transformations::EXPAND | Transformations::STRIP_16
|
||||
}
|
||||
}
|
||||
|
||||
/// Instantiate the default transformations, the identity transform.
|
||||
impl Default for Transformations {
|
||||
fn default() -> Transformations {
|
||||
Transformations::IDENTITY
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct ParameterError {
|
||||
inner: ParameterErrorKind,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum ParameterErrorKind {
|
||||
/// A provided buffer must be have the exact size to hold the image data. Where the buffer can
|
||||
/// be allocated by the caller, they must ensure that it has a minimum size as hinted previously.
|
||||
/// Even though the size is calculated from image data, this does counts as a parameter error
|
||||
/// because they must react to a value produced by this library, which can have been subjected
|
||||
/// to limits.
|
||||
ImageBufferSize { expected: usize, actual: usize },
|
||||
/// A bit like return `None` from an iterator.
|
||||
/// We use it to differentiate between failing to seek to the next image in a sequence and the
|
||||
/// absence of a next image. This is an error of the caller because they should have checked
|
||||
/// the number of images by inspecting the header data returned when opening the image. This
|
||||
/// library will perform the checks necessary to ensure that data was accurate or error with a
|
||||
/// format error otherwise.
|
||||
PolledAfterEndOfImage,
|
||||
}
|
||||
|
||||
impl From<ParameterErrorKind> for ParameterError {
|
||||
fn from(inner: ParameterErrorKind) -> Self {
|
||||
ParameterError { inner }
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for ParameterError {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
use ParameterErrorKind::*;
|
||||
match self.inner {
|
||||
ImageBufferSize { expected, actual } => {
|
||||
write!(fmt, "wrong data size, expected {} got {}", expected, actual)
|
||||
}
|
||||
PolledAfterEndOfImage => write!(fmt, "End of image has been reached"),
|
||||
}
|
||||
}
|
||||
}
|
||||
811
third-party/vendor/png/src/decoder/mod.rs
vendored
Normal file
811
third-party/vendor/png/src/decoder/mod.rs
vendored
Normal file
|
|
@ -0,0 +1,811 @@
|
|||
mod stream;
|
||||
pub(crate) mod transform;
|
||||
mod zlib;
|
||||
|
||||
pub use self::stream::{DecodeOptions, Decoded, DecodingError, StreamingDecoder};
|
||||
use self::stream::{FormatErrorInner, CHUNCK_BUFFER_SIZE};
|
||||
use self::transform::{create_transform_fn, TransformFn};
|
||||
|
||||
use std::io::{BufRead, BufReader, Read};
|
||||
use std::mem;
|
||||
use std::ops::Range;
|
||||
|
||||
use crate::adam7;
|
||||
use crate::chunk;
|
||||
use crate::common::{
|
||||
BitDepth, BytesPerPixel, ColorType, Info, ParameterErrorKind, Transformations,
|
||||
};
|
||||
use crate::filter::{unfilter, FilterType};
|
||||
|
||||
/*
|
||||
pub enum InterlaceHandling {
|
||||
/// Outputs the raw rows
|
||||
RawRows,
|
||||
/// Fill missing the pixels from the existing ones
|
||||
Rectangle,
|
||||
/// Only fill the needed pixels
|
||||
Sparkle
|
||||
}
|
||||
*/
|
||||
|
||||
/// Output info.
|
||||
///
|
||||
/// This describes one particular frame of the image that was written into the output buffer.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct OutputInfo {
|
||||
/// The pixel width of this frame.
|
||||
pub width: u32,
|
||||
/// The pixel height of this frame.
|
||||
pub height: u32,
|
||||
/// The chosen output color type.
|
||||
pub color_type: ColorType,
|
||||
/// The chosen output bit depth.
|
||||
pub bit_depth: BitDepth,
|
||||
/// The byte count of each scan line in the image.
|
||||
pub line_size: usize,
|
||||
}
|
||||
|
||||
impl OutputInfo {
|
||||
/// Returns the size needed to hold a decoded frame
|
||||
/// If the output buffer was larger then bytes after this count should be ignored. They may
|
||||
/// still have been changed.
|
||||
pub fn buffer_size(&self) -> usize {
|
||||
self.line_size * self.height as usize
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
/// Limits on the resources the `Decoder` is allowed too use
|
||||
pub struct Limits {
|
||||
/// maximum number of bytes the decoder is allowed to allocate, default is 64Mib
|
||||
pub bytes: usize,
|
||||
}
|
||||
|
||||
impl Limits {
|
||||
pub(crate) fn reserve_bytes(&mut self, bytes: usize) -> Result<(), DecodingError> {
|
||||
if self.bytes >= bytes {
|
||||
self.bytes -= bytes;
|
||||
Ok(())
|
||||
} else {
|
||||
Err(DecodingError::LimitsExceeded)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Limits {
|
||||
fn default() -> Limits {
|
||||
Limits {
|
||||
bytes: 1024 * 1024 * 64,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// PNG Decoder
|
||||
pub struct Decoder<R: Read> {
|
||||
read_decoder: ReadDecoder<R>,
|
||||
/// Output transformations
|
||||
transform: Transformations,
|
||||
}
|
||||
|
||||
/// A row of data with interlace information attached.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct InterlacedRow<'data> {
|
||||
data: &'data [u8],
|
||||
interlace: InterlaceInfo,
|
||||
}
|
||||
|
||||
impl<'data> InterlacedRow<'data> {
|
||||
pub fn data(&self) -> &'data [u8] {
|
||||
self.data
|
||||
}
|
||||
|
||||
pub fn interlace(&self) -> InterlaceInfo {
|
||||
self.interlace
|
||||
}
|
||||
}
|
||||
|
||||
/// PNG (2003) specifies two interlace modes, but reserves future extensions.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum InterlaceInfo {
|
||||
/// the null method means no interlacing
|
||||
Null,
|
||||
/// Adam7 derives its name from doing 7 passes over the image, only decoding a subset of all pixels in each pass.
|
||||
/// The following table shows pictorially what parts of each 8x8 area of the image is found in each pass:
|
||||
///
|
||||
/// 1 6 4 6 2 6 4 6
|
||||
/// 7 7 7 7 7 7 7 7
|
||||
/// 5 6 5 6 5 6 5 6
|
||||
/// 7 7 7 7 7 7 7 7
|
||||
/// 3 6 4 6 3 6 4 6
|
||||
/// 7 7 7 7 7 7 7 7
|
||||
/// 5 6 5 6 5 6 5 6
|
||||
/// 7 7 7 7 7 7 7 7
|
||||
Adam7 { pass: u8, line: u32, width: u32 },
|
||||
}
|
||||
|
||||
/// A row of data without interlace information.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Row<'data> {
|
||||
data: &'data [u8],
|
||||
}
|
||||
|
||||
impl<'data> Row<'data> {
|
||||
pub fn data(&self) -> &'data [u8] {
|
||||
self.data
|
||||
}
|
||||
}
|
||||
|
||||
impl<R: Read> Decoder<R> {
|
||||
/// Create a new decoder configuration with default limits.
|
||||
pub fn new(r: R) -> Decoder<R> {
|
||||
Decoder::new_with_limits(r, Limits::default())
|
||||
}
|
||||
|
||||
/// Create a new decoder configuration with custom limits.
|
||||
pub fn new_with_limits(r: R, limits: Limits) -> Decoder<R> {
|
||||
let mut decoder = StreamingDecoder::new();
|
||||
decoder.limits = limits;
|
||||
|
||||
Decoder {
|
||||
read_decoder: ReadDecoder {
|
||||
reader: BufReader::with_capacity(CHUNCK_BUFFER_SIZE, r),
|
||||
decoder,
|
||||
at_eof: false,
|
||||
},
|
||||
transform: Transformations::IDENTITY,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new decoder configuration with custom `DecodeOptions`.
|
||||
pub fn new_with_options(r: R, decode_options: DecodeOptions) -> Decoder<R> {
|
||||
let mut decoder = StreamingDecoder::new_with_options(decode_options);
|
||||
decoder.limits = Limits::default();
|
||||
|
||||
Decoder {
|
||||
read_decoder: ReadDecoder {
|
||||
reader: BufReader::with_capacity(CHUNCK_BUFFER_SIZE, r),
|
||||
decoder,
|
||||
at_eof: false,
|
||||
},
|
||||
transform: Transformations::IDENTITY,
|
||||
}
|
||||
}
|
||||
|
||||
/// Limit resource usage.
|
||||
///
|
||||
/// Note that your allocations, e.g. when reading into a pre-allocated buffer, are __NOT__
|
||||
/// considered part of the limits. Nevertheless, required intermediate buffers such as for
|
||||
/// singular lines is checked against the limit.
|
||||
///
|
||||
/// Note that this is a best-effort basis.
|
||||
///
|
||||
/// ```
|
||||
/// use std::fs::File;
|
||||
/// use png::{Decoder, Limits};
|
||||
/// // This image is 32×32, 1bit per pixel. The reader buffers one row which requires 4 bytes.
|
||||
/// let mut limits = Limits::default();
|
||||
/// limits.bytes = 3;
|
||||
/// let mut decoder = Decoder::new_with_limits(File::open("tests/pngsuite/basi0g01.png").unwrap(), limits);
|
||||
/// assert!(decoder.read_info().is_err());
|
||||
///
|
||||
/// // This image is 32x32 pixels, so the decoder will allocate less than 10Kib
|
||||
/// let mut limits = Limits::default();
|
||||
/// limits.bytes = 10*1024;
|
||||
/// let mut decoder = Decoder::new_with_limits(File::open("tests/pngsuite/basi0g01.png").unwrap(), limits);
|
||||
/// assert!(decoder.read_info().is_ok());
|
||||
/// ```
|
||||
pub fn set_limits(&mut self, limits: Limits) {
|
||||
self.read_decoder.decoder.limits = limits;
|
||||
}
|
||||
|
||||
/// Read the PNG header and return the information contained within.
|
||||
///
|
||||
/// Most image metadata will not be read until `read_info` is called, so those fields will be
|
||||
/// None or empty.
|
||||
pub fn read_header_info(&mut self) -> Result<&Info<'static>, DecodingError> {
|
||||
let mut buf = Vec::new();
|
||||
while self.read_decoder.info().is_none() {
|
||||
buf.clear();
|
||||
if self.read_decoder.decode_next(&mut buf)?.is_none() {
|
||||
return Err(DecodingError::Format(
|
||||
FormatErrorInner::UnexpectedEof.into(),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(self.read_decoder.info().unwrap())
|
||||
}
|
||||
|
||||
/// Reads all meta data until the first IDAT chunk
|
||||
pub fn read_info(mut self) -> Result<Reader<R>, DecodingError> {
|
||||
self.read_header_info()?;
|
||||
|
||||
let mut reader = Reader {
|
||||
decoder: self.read_decoder,
|
||||
bpp: BytesPerPixel::One,
|
||||
subframe: SubframeInfo::not_yet_init(),
|
||||
fctl_read: 0,
|
||||
next_frame: SubframeIdx::Initial,
|
||||
data_stream: Vec::new(),
|
||||
prev_start: 0,
|
||||
current_start: 0,
|
||||
transform: self.transform,
|
||||
transform_fn: None,
|
||||
scratch_buffer: Vec::new(),
|
||||
};
|
||||
|
||||
// Check if the decoding buffer of a single raw line has a valid size.
|
||||
if reader.info().checked_raw_row_length().is_none() {
|
||||
return Err(DecodingError::LimitsExceeded);
|
||||
}
|
||||
|
||||
// Check if the output buffer has a valid size.
|
||||
let (width, height) = reader.info().size();
|
||||
let (color, depth) = reader.output_color_type();
|
||||
let rowlen = color
|
||||
.checked_raw_row_length(depth, width)
|
||||
.ok_or(DecodingError::LimitsExceeded)?
|
||||
- 1;
|
||||
let height: usize =
|
||||
std::convert::TryFrom::try_from(height).map_err(|_| DecodingError::LimitsExceeded)?;
|
||||
if rowlen.checked_mul(height).is_none() {
|
||||
return Err(DecodingError::LimitsExceeded);
|
||||
}
|
||||
|
||||
reader.read_until_image_data()?;
|
||||
Ok(reader)
|
||||
}
|
||||
|
||||
/// Set the allowed and performed transformations.
|
||||
///
|
||||
/// A transformation is a pre-processing on the raw image data modifying content or encoding.
|
||||
/// Many options have an impact on memory or CPU usage during decoding.
|
||||
pub fn set_transformations(&mut self, transform: Transformations) {
|
||||
self.transform = transform;
|
||||
}
|
||||
|
||||
/// Set the decoder to ignore all text chunks while parsing.
|
||||
///
|
||||
/// eg.
|
||||
/// ```
|
||||
/// use std::fs::File;
|
||||
/// use png::Decoder;
|
||||
/// let mut decoder = Decoder::new(File::open("tests/pngsuite/basi0g01.png").unwrap());
|
||||
/// decoder.set_ignore_text_chunk(true);
|
||||
/// assert!(decoder.read_info().is_ok());
|
||||
/// ```
|
||||
pub fn set_ignore_text_chunk(&mut self, ignore_text_chunk: bool) {
|
||||
self.read_decoder
|
||||
.decoder
|
||||
.set_ignore_text_chunk(ignore_text_chunk);
|
||||
}
|
||||
|
||||
/// Set the decoder to ignore and not verify the Adler-32 checksum
|
||||
/// and CRC code.
|
||||
pub fn ignore_checksums(&mut self, ignore_checksums: bool) {
|
||||
self.read_decoder
|
||||
.decoder
|
||||
.set_ignore_adler32(ignore_checksums);
|
||||
self.read_decoder.decoder.set_ignore_crc(ignore_checksums);
|
||||
}
|
||||
}
|
||||
|
||||
struct ReadDecoder<R: Read> {
|
||||
reader: BufReader<R>,
|
||||
decoder: StreamingDecoder,
|
||||
at_eof: bool,
|
||||
}
|
||||
|
||||
impl<R: Read> ReadDecoder<R> {
|
||||
/// Returns the next decoded chunk. If the chunk is an ImageData chunk, its contents are written
|
||||
/// into image_data.
|
||||
fn decode_next(&mut self, image_data: &mut Vec<u8>) -> Result<Option<Decoded>, DecodingError> {
|
||||
while !self.at_eof {
|
||||
let (consumed, result) = {
|
||||
let buf = self.reader.fill_buf()?;
|
||||
if buf.is_empty() {
|
||||
return Err(DecodingError::Format(
|
||||
FormatErrorInner::UnexpectedEof.into(),
|
||||
));
|
||||
}
|
||||
self.decoder.update(buf, image_data)?
|
||||
};
|
||||
self.reader.consume(consumed);
|
||||
match result {
|
||||
Decoded::Nothing => (),
|
||||
Decoded::ImageEnd => self.at_eof = true,
|
||||
result => return Ok(Some(result)),
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
fn finish_decoding(&mut self) -> Result<(), DecodingError> {
|
||||
while !self.at_eof {
|
||||
let buf = self.reader.fill_buf()?;
|
||||
if buf.is_empty() {
|
||||
return Err(DecodingError::Format(
|
||||
FormatErrorInner::UnexpectedEof.into(),
|
||||
));
|
||||
}
|
||||
let (consumed, event) = self.decoder.update(buf, &mut vec![])?;
|
||||
self.reader.consume(consumed);
|
||||
match event {
|
||||
Decoded::Nothing => (),
|
||||
Decoded::ImageEnd => self.at_eof = true,
|
||||
// ignore more data
|
||||
Decoded::ChunkComplete(_, _) | Decoded::ChunkBegin(_, _) | Decoded::ImageData => {}
|
||||
Decoded::ImageDataFlushed => return Ok(()),
|
||||
Decoded::PartialChunk(_) => {}
|
||||
new => unreachable!("{:?}", new),
|
||||
}
|
||||
}
|
||||
|
||||
Err(DecodingError::Format(
|
||||
FormatErrorInner::UnexpectedEof.into(),
|
||||
))
|
||||
}
|
||||
|
||||
fn info(&self) -> Option<&Info<'static>> {
|
||||
self.decoder.info.as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
/// PNG reader (mostly high-level interface)
|
||||
///
|
||||
/// Provides a high level that iterates over lines or whole images.
|
||||
pub struct Reader<R: Read> {
|
||||
decoder: ReadDecoder<R>,
|
||||
bpp: BytesPerPixel,
|
||||
subframe: SubframeInfo,
|
||||
/// Number of frame control chunks read.
|
||||
/// By the APNG specification the total number must equal the count specified in the animation
|
||||
/// control chunk. The IDAT image _may_ have such a chunk applying to it.
|
||||
fctl_read: u32,
|
||||
next_frame: SubframeIdx,
|
||||
/// Vec containing the uncompressed image data currently being processed.
|
||||
data_stream: Vec<u8>,
|
||||
/// Index in `data_stream` where the previous row starts.
|
||||
prev_start: usize,
|
||||
/// Index in `data_stream` where the current row starts.
|
||||
current_start: usize,
|
||||
/// Output transformations
|
||||
transform: Transformations,
|
||||
/// Function that can transform decompressed, unfiltered rows into final output.
|
||||
/// See the `transform.rs` module for more details.
|
||||
transform_fn: Option<TransformFn>,
|
||||
/// This buffer is only used so that `next_row` and `next_interlaced_row` can return reference
|
||||
/// to a byte slice. In a future version of this library, this buffer will be removed and
|
||||
/// `next_row` and `next_interlaced_row` will write directly into a user provided output buffer.
|
||||
scratch_buffer: Vec<u8>,
|
||||
}
|
||||
|
||||
/// The subframe specific information.
|
||||
///
|
||||
/// In APNG the frames are constructed by combining previous frame and a new subframe (through a
|
||||
/// combination of `dispose_op` and `overlay_op`). These sub frames specify individual dimension
|
||||
/// information and reuse the global interlace options. This struct encapsulates the state of where
|
||||
/// in a particular IDAT-frame or subframe we are.
|
||||
struct SubframeInfo {
|
||||
width: u32,
|
||||
height: u32,
|
||||
rowlen: usize,
|
||||
interlace: InterlaceIter,
|
||||
consumed_and_flushed: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
enum InterlaceIter {
|
||||
None(Range<u32>),
|
||||
Adam7(adam7::Adam7Iterator),
|
||||
}
|
||||
|
||||
/// Denote a frame as given by sequence numbers.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
||||
enum SubframeIdx {
|
||||
/// The initial frame in an IDAT chunk without fcTL chunk applying to it.
|
||||
/// Note that this variant precedes `Some` as IDAT frames precede fdAT frames and all fdAT
|
||||
/// frames must have a fcTL applying to it.
|
||||
Initial,
|
||||
/// An IDAT frame with fcTL or an fdAT frame.
|
||||
Some(u32),
|
||||
/// The past-the-end index.
|
||||
End,
|
||||
}
|
||||
|
||||
impl<R: Read> Reader<R> {
|
||||
/// Reads all meta data until the next frame data starts.
|
||||
/// Requires IHDR before the IDAT and fcTL before fdAT.
|
||||
fn read_until_image_data(&mut self) -> Result<(), DecodingError> {
|
||||
loop {
|
||||
// This is somewhat ugly. The API requires us to pass a buffer to decode_next but we
|
||||
// know that we will stop before reading any image data from the stream. Thus pass an
|
||||
// empty buffer and assert that remains empty.
|
||||
let mut buf = Vec::new();
|
||||
let state = self.decoder.decode_next(&mut buf)?;
|
||||
assert!(buf.is_empty());
|
||||
|
||||
match state {
|
||||
Some(Decoded::ChunkBegin(_, chunk::IDAT))
|
||||
| Some(Decoded::ChunkBegin(_, chunk::fdAT)) => break,
|
||||
Some(Decoded::FrameControl(_)) => {
|
||||
self.subframe = SubframeInfo::new(self.info());
|
||||
// The next frame is the one to which this chunk applies.
|
||||
self.next_frame = SubframeIdx::Some(self.fctl_read);
|
||||
// TODO: what about overflow here? That would imply there are more fctl chunks
|
||||
// than can be specified in the animation control but also that we have read
|
||||
// several gigabytes of data.
|
||||
self.fctl_read += 1;
|
||||
}
|
||||
None => {
|
||||
return Err(DecodingError::Format(
|
||||
FormatErrorInner::MissingImageData.into(),
|
||||
))
|
||||
}
|
||||
// Ignore all other chunk events. Any other chunk may be between IDAT chunks, fdAT
|
||||
// chunks and their control chunks.
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
let info = self
|
||||
.decoder
|
||||
.info()
|
||||
.ok_or(DecodingError::Format(FormatErrorInner::MissingIhdr.into()))?;
|
||||
self.bpp = info.bpp_in_prediction();
|
||||
self.subframe = SubframeInfo::new(info);
|
||||
|
||||
// Allocate output buffer.
|
||||
let buflen = self.output_line_size(self.subframe.width);
|
||||
self.decoder.decoder.limits.reserve_bytes(buflen)?;
|
||||
|
||||
self.prev_start = self.current_start;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Get information on the image.
|
||||
///
|
||||
/// The structure will change as new frames of an animated image are decoded.
|
||||
pub fn info(&self) -> &Info<'static> {
|
||||
self.decoder.info().unwrap()
|
||||
}
|
||||
|
||||
/// Decodes the next frame into `buf`.
|
||||
///
|
||||
/// Note that this decodes raw subframes that need to be mixed according to blend-op and
|
||||
/// dispose-op by the caller.
|
||||
///
|
||||
/// The caller must always provide a buffer large enough to hold a complete frame (the APNG
|
||||
/// specification restricts subframes to the dimensions given in the image header). The region
|
||||
/// that has been written be checked afterwards by calling `info` after a successful call and
|
||||
/// inspecting the `frame_control` data. This requirement may be lifted in a later version of
|
||||
/// `png`.
|
||||
///
|
||||
/// Output lines will be written in row-major, packed matrix with width and height of the read
|
||||
/// frame (or subframe), all samples are in big endian byte order where this matters.
|
||||
pub fn next_frame(&mut self, buf: &mut [u8]) -> Result<OutputInfo, DecodingError> {
|
||||
let subframe_idx = match self.decoder.info().unwrap().frame_control() {
|
||||
None => SubframeIdx::Initial,
|
||||
Some(_) => SubframeIdx::Some(self.fctl_read - 1),
|
||||
};
|
||||
|
||||
if self.next_frame == SubframeIdx::End {
|
||||
return Err(DecodingError::Parameter(
|
||||
ParameterErrorKind::PolledAfterEndOfImage.into(),
|
||||
));
|
||||
} else if self.next_frame != subframe_idx {
|
||||
// Advance until we've read the info / fcTL for this frame.
|
||||
self.read_until_image_data()?;
|
||||
}
|
||||
|
||||
if buf.len() < self.output_buffer_size() {
|
||||
return Err(DecodingError::Parameter(
|
||||
ParameterErrorKind::ImageBufferSize {
|
||||
expected: buf.len(),
|
||||
actual: self.output_buffer_size(),
|
||||
}
|
||||
.into(),
|
||||
));
|
||||
}
|
||||
|
||||
let (color_type, bit_depth) = self.output_color_type();
|
||||
let output_info = OutputInfo {
|
||||
width: self.subframe.width,
|
||||
height: self.subframe.height,
|
||||
color_type,
|
||||
bit_depth,
|
||||
line_size: self.output_line_size(self.subframe.width),
|
||||
};
|
||||
|
||||
self.data_stream.clear();
|
||||
self.current_start = 0;
|
||||
self.prev_start = 0;
|
||||
let width = self.info().width;
|
||||
if self.info().interlaced {
|
||||
while let Some(InterlacedRow {
|
||||
data: row,
|
||||
interlace,
|
||||
..
|
||||
}) = self.next_interlaced_row()?
|
||||
{
|
||||
let (line, pass) = match interlace {
|
||||
InterlaceInfo::Adam7 { line, pass, .. } => (line, pass),
|
||||
InterlaceInfo::Null => unreachable!("expected interlace information"),
|
||||
};
|
||||
let samples = color_type.samples() as u8;
|
||||
adam7::expand_pass(buf, width, row, pass, line, samples * (bit_depth as u8));
|
||||
}
|
||||
} else {
|
||||
for row in buf
|
||||
.chunks_exact_mut(output_info.line_size)
|
||||
.take(self.subframe.height as usize)
|
||||
{
|
||||
self.next_interlaced_row_impl(self.subframe.rowlen, row)?;
|
||||
}
|
||||
}
|
||||
|
||||
// Advance over the rest of data for this (sub-)frame.
|
||||
if !self.subframe.consumed_and_flushed {
|
||||
self.decoder.finish_decoding()?;
|
||||
}
|
||||
|
||||
// Advance our state to expect the next frame.
|
||||
let past_end_subframe = self
|
||||
.info()
|
||||
.animation_control()
|
||||
.map(|ac| ac.num_frames)
|
||||
.unwrap_or(0);
|
||||
self.next_frame = match self.next_frame {
|
||||
SubframeIdx::End => unreachable!("Next frame called when already at image end"),
|
||||
// Reached the end of non-animated image.
|
||||
SubframeIdx::Initial if past_end_subframe == 0 => SubframeIdx::End,
|
||||
// An animated image, expecting first subframe.
|
||||
SubframeIdx::Initial => SubframeIdx::Some(0),
|
||||
// This was the last subframe, slightly fuzzy condition in case of programmer error.
|
||||
SubframeIdx::Some(idx) if past_end_subframe <= idx + 1 => SubframeIdx::End,
|
||||
// Expecting next subframe.
|
||||
SubframeIdx::Some(idx) => SubframeIdx::Some(idx + 1),
|
||||
};
|
||||
|
||||
Ok(output_info)
|
||||
}
|
||||
|
||||
/// Returns the next processed row of the image
|
||||
pub fn next_row(&mut self) -> Result<Option<Row>, DecodingError> {
|
||||
self.next_interlaced_row()
|
||||
.map(|v| v.map(|v| Row { data: v.data }))
|
||||
}
|
||||
|
||||
/// Returns the next processed row of the image
|
||||
pub fn next_interlaced_row(&mut self) -> Result<Option<InterlacedRow>, DecodingError> {
|
||||
let (rowlen, interlace) = match self.next_pass() {
|
||||
Some((rowlen, interlace)) => (rowlen, interlace),
|
||||
None => return Ok(None),
|
||||
};
|
||||
|
||||
let width = if let InterlaceInfo::Adam7 { width, .. } = interlace {
|
||||
width
|
||||
} else {
|
||||
self.subframe.width
|
||||
};
|
||||
let output_line_size = self.output_line_size(width);
|
||||
|
||||
// TODO: change the interface of `next_interlaced_row` to take an output buffer instead of
|
||||
// making us return a reference to a buffer that we own.
|
||||
let mut output_buffer = mem::take(&mut self.scratch_buffer);
|
||||
output_buffer.resize(output_line_size, 0u8);
|
||||
let ret = self.next_interlaced_row_impl(rowlen, &mut output_buffer);
|
||||
self.scratch_buffer = output_buffer;
|
||||
ret?;
|
||||
|
||||
Ok(Some(InterlacedRow {
|
||||
data: &self.scratch_buffer[..output_line_size],
|
||||
interlace,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Read the rest of the image and chunks and finish up, including text chunks or others
|
||||
/// This will discard the rest of the image if the image is not read already with [`Reader::next_frame`], [`Reader::next_row`] or [`Reader::next_interlaced_row`]
|
||||
pub fn finish(&mut self) -> Result<(), DecodingError> {
|
||||
self.next_frame = SubframeIdx::End;
|
||||
self.data_stream.clear();
|
||||
self.current_start = 0;
|
||||
self.prev_start = 0;
|
||||
loop {
|
||||
let mut buf = Vec::new();
|
||||
let state = self.decoder.decode_next(&mut buf)?;
|
||||
|
||||
if state.is_none() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Fetch the next interlaced row and filter it according to our own transformations.
|
||||
fn next_interlaced_row_impl(
|
||||
&mut self,
|
||||
rowlen: usize,
|
||||
output_buffer: &mut [u8],
|
||||
) -> Result<(), DecodingError> {
|
||||
self.next_raw_interlaced_row(rowlen)?;
|
||||
assert_eq!(self.current_start - self.prev_start, rowlen - 1);
|
||||
let row = &self.data_stream[self.prev_start..self.current_start];
|
||||
|
||||
// Apply transformations and write resulting data to buffer.
|
||||
let transform_fn = {
|
||||
if self.transform_fn.is_none() {
|
||||
self.transform_fn = Some(create_transform_fn(self.info(), self.transform)?);
|
||||
}
|
||||
self.transform_fn.as_deref().unwrap()
|
||||
};
|
||||
transform_fn(row, output_buffer, self.info());
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Returns the color type and the number of bits per sample
|
||||
/// of the data returned by `Reader::next_row` and Reader::frames`.
|
||||
pub fn output_color_type(&self) -> (ColorType, BitDepth) {
|
||||
use crate::common::ColorType::*;
|
||||
let t = self.transform;
|
||||
let info = self.info();
|
||||
if t == Transformations::IDENTITY {
|
||||
(info.color_type, info.bit_depth)
|
||||
} else {
|
||||
let bits = match info.bit_depth as u8 {
|
||||
16 if t.intersects(Transformations::STRIP_16) => 8,
|
||||
n if n < 8
|
||||
&& (t.contains(Transformations::EXPAND)
|
||||
|| t.contains(Transformations::ALPHA)) =>
|
||||
{
|
||||
8
|
||||
}
|
||||
n => n,
|
||||
};
|
||||
let color_type =
|
||||
if t.contains(Transformations::EXPAND) || t.contains(Transformations::ALPHA) {
|
||||
let has_trns = info.trns.is_some() || t.contains(Transformations::ALPHA);
|
||||
match info.color_type {
|
||||
Grayscale if has_trns => GrayscaleAlpha,
|
||||
Rgb if has_trns => Rgba,
|
||||
Indexed if has_trns => Rgba,
|
||||
Indexed => Rgb,
|
||||
ct => ct,
|
||||
}
|
||||
} else {
|
||||
info.color_type
|
||||
};
|
||||
(color_type, BitDepth::from_u8(bits).unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the number of bytes required to hold a deinterlaced image frame
|
||||
/// that is decoded using the given input transformations.
|
||||
pub fn output_buffer_size(&self) -> usize {
|
||||
let (width, height) = self.info().size();
|
||||
let size = self.output_line_size(width);
|
||||
size * height as usize
|
||||
}
|
||||
|
||||
/// Returns the number of bytes required to hold a deinterlaced row.
|
||||
pub fn output_line_size(&self, width: u32) -> usize {
|
||||
let (color, depth) = self.output_color_type();
|
||||
color.raw_row_length_from_width(depth, width) - 1
|
||||
}
|
||||
|
||||
fn next_pass(&mut self) -> Option<(usize, InterlaceInfo)> {
|
||||
match self.subframe.interlace {
|
||||
InterlaceIter::Adam7(ref mut adam7) => {
|
||||
let last_pass = adam7.current_pass();
|
||||
let (pass, line, width) = adam7.next()?;
|
||||
let rowlen = self.info().raw_row_length_from_width(width);
|
||||
if last_pass != pass {
|
||||
self.prev_start = self.current_start;
|
||||
}
|
||||
Some((rowlen, InterlaceInfo::Adam7 { pass, line, width }))
|
||||
}
|
||||
InterlaceIter::None(ref mut height) => {
|
||||
let _ = height.next()?;
|
||||
Some((self.subframe.rowlen, InterlaceInfo::Null))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Write the next raw interlaced row into `self.prev`.
|
||||
///
|
||||
/// The scanline is filtered against the previous scanline according to the specification.
|
||||
fn next_raw_interlaced_row(&mut self, rowlen: usize) -> Result<(), DecodingError> {
|
||||
// Read image data until we have at least one full row (but possibly more than one).
|
||||
while self.data_stream.len() - self.current_start < rowlen {
|
||||
if self.subframe.consumed_and_flushed {
|
||||
return Err(DecodingError::Format(
|
||||
FormatErrorInner::NoMoreImageData.into(),
|
||||
));
|
||||
}
|
||||
|
||||
// Clear the current buffer before appending more data.
|
||||
if self.prev_start > 0 {
|
||||
self.data_stream.copy_within(self.prev_start.., 0);
|
||||
self.data_stream
|
||||
.truncate(self.data_stream.len() - self.prev_start);
|
||||
self.current_start -= self.prev_start;
|
||||
self.prev_start = 0;
|
||||
}
|
||||
|
||||
match self.decoder.decode_next(&mut self.data_stream)? {
|
||||
Some(Decoded::ImageData) => {}
|
||||
Some(Decoded::ImageDataFlushed) => {
|
||||
self.subframe.consumed_and_flushed = true;
|
||||
}
|
||||
None => {
|
||||
return Err(DecodingError::Format(
|
||||
if self.data_stream.is_empty() {
|
||||
FormatErrorInner::NoMoreImageData
|
||||
} else {
|
||||
FormatErrorInner::UnexpectedEndOfChunk
|
||||
}
|
||||
.into(),
|
||||
));
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
// Get a reference to the current row and point scan_start to the next one.
|
||||
let (prev, row) = self.data_stream.split_at_mut(self.current_start);
|
||||
|
||||
// Unfilter the row.
|
||||
let filter = FilterType::from_u8(row[0]).ok_or(DecodingError::Format(
|
||||
FormatErrorInner::UnknownFilterMethod(row[0]).into(),
|
||||
))?;
|
||||
unfilter(
|
||||
filter,
|
||||
self.bpp,
|
||||
&prev[self.prev_start..],
|
||||
&mut row[1..rowlen],
|
||||
);
|
||||
|
||||
self.prev_start = self.current_start + 1;
|
||||
self.current_start += rowlen;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl SubframeInfo {
|
||||
fn not_yet_init() -> Self {
|
||||
SubframeInfo {
|
||||
width: 0,
|
||||
height: 0,
|
||||
rowlen: 0,
|
||||
interlace: InterlaceIter::None(0..0),
|
||||
consumed_and_flushed: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn new(info: &Info) -> Self {
|
||||
// The apng fctnl overrides width and height.
|
||||
// All other data is set by the main info struct.
|
||||
let (width, height) = if let Some(fc) = info.frame_control {
|
||||
(fc.width, fc.height)
|
||||
} else {
|
||||
(info.width, info.height)
|
||||
};
|
||||
|
||||
let interlace = if info.interlaced {
|
||||
InterlaceIter::Adam7(adam7::Adam7Iterator::new(width, height))
|
||||
} else {
|
||||
InterlaceIter::None(0..height)
|
||||
};
|
||||
|
||||
SubframeInfo {
|
||||
width,
|
||||
height,
|
||||
rowlen: info.raw_row_length_from_width(width),
|
||||
interlace,
|
||||
consumed_and_flushed: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
1948
third-party/vendor/png/src/decoder/stream.rs
vendored
Normal file
1948
third-party/vendor/png/src/decoder/stream.rs
vendored
Normal file
File diff suppressed because it is too large
Load diff
203
third-party/vendor/png/src/decoder/transform.rs
vendored
Normal file
203
third-party/vendor/png/src/decoder/transform.rs
vendored
Normal file
|
|
@ -0,0 +1,203 @@
|
|||
//! Transforming a decompressed, unfiltered row into the final output.
|
||||
|
||||
mod palette;
|
||||
|
||||
use crate::{BitDepth, ColorType, DecodingError, Info, Transformations};
|
||||
|
||||
use super::stream::FormatErrorInner;
|
||||
|
||||
/// Type of a function that can transform a decompressed, unfiltered row (the
|
||||
/// 1st argument) into the final pixels (the 2nd argument), optionally using
|
||||
/// image metadata (e.g. PLTE data can be accessed using the 3rd argument).
|
||||
///
|
||||
/// TODO: If some precomputed state is needed (e.g. to make `expand_paletted...`
|
||||
/// faster) then consider changing this into `Box<dyn Fn(...)>`.
|
||||
pub type TransformFn = Box<dyn Fn(&[u8], &mut [u8], &Info) + Send + Sync>;
|
||||
|
||||
/// Returns a transformation function that should be applied to image rows based
|
||||
/// on 1) decoded image metadata (`info`) and 2) the transformations requested
|
||||
/// by the crate client (`transform`).
|
||||
pub fn create_transform_fn(
|
||||
info: &Info,
|
||||
transform: Transformations,
|
||||
) -> Result<TransformFn, DecodingError> {
|
||||
let color_type = info.color_type;
|
||||
let bit_depth = info.bit_depth as u8;
|
||||
let trns = info.trns.is_some() || transform.contains(Transformations::ALPHA);
|
||||
let expand =
|
||||
transform.contains(Transformations::EXPAND) || transform.contains(Transformations::ALPHA);
|
||||
let strip16 = bit_depth == 16 && transform.contains(Transformations::STRIP_16);
|
||||
match color_type {
|
||||
ColorType::Indexed if expand => {
|
||||
if info.palette.is_none() {
|
||||
return Err(DecodingError::Format(
|
||||
FormatErrorInner::PaletteRequired.into(),
|
||||
));
|
||||
} else if let BitDepth::Sixteen = info.bit_depth {
|
||||
// This should have been caught earlier but let's check again. Can't hurt.
|
||||
return Err(DecodingError::Format(
|
||||
FormatErrorInner::InvalidColorBitDepth {
|
||||
color_type: ColorType::Indexed,
|
||||
bit_depth: BitDepth::Sixteen,
|
||||
}
|
||||
.into(),
|
||||
));
|
||||
} else {
|
||||
Ok(if trns {
|
||||
palette::create_expansion_into_rgba8(info)
|
||||
} else {
|
||||
palette::create_expansion_into_rgb8(info)
|
||||
})
|
||||
}
|
||||
}
|
||||
ColorType::Grayscale | ColorType::GrayscaleAlpha if bit_depth < 8 && expand => {
|
||||
Ok(Box::new(if trns {
|
||||
expand_gray_u8_with_trns
|
||||
} else {
|
||||
expand_gray_u8
|
||||
}))
|
||||
}
|
||||
ColorType::Grayscale | ColorType::Rgb if expand && trns => {
|
||||
Ok(Box::new(if bit_depth == 8 {
|
||||
expand_trns_line
|
||||
} else if strip16 {
|
||||
expand_trns_and_strip_line16
|
||||
} else {
|
||||
assert_eq!(bit_depth, 16);
|
||||
expand_trns_line16
|
||||
}))
|
||||
}
|
||||
ColorType::Grayscale | ColorType::GrayscaleAlpha | ColorType::Rgb | ColorType::Rgba
|
||||
if strip16 =>
|
||||
{
|
||||
Ok(Box::new(transform_row_strip16))
|
||||
}
|
||||
_ => Ok(Box::new(copy_row)),
|
||||
}
|
||||
}
|
||||
|
||||
fn copy_row(row: &[u8], output_buffer: &mut [u8], _: &Info) {
|
||||
output_buffer.copy_from_slice(row);
|
||||
}
|
||||
|
||||
fn transform_row_strip16(row: &[u8], output_buffer: &mut [u8], _: &Info) {
|
||||
for i in 0..row.len() / 2 {
|
||||
output_buffer[i] = row[2 * i];
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn unpack_bits<F>(input: &[u8], output: &mut [u8], channels: usize, bit_depth: u8, func: F)
|
||||
where
|
||||
F: Fn(u8, &mut [u8]),
|
||||
{
|
||||
// Only [1, 2, 4, 8] are valid bit depths
|
||||
assert!(matches!(bit_depth, 1 | 2 | 4 | 8));
|
||||
// Check that `input` is capable of producing a buffer as long as `output`:
|
||||
// number of shift lookups per bit depth * channels * input length
|
||||
assert!((8 / bit_depth as usize * channels).saturating_mul(input.len()) >= output.len());
|
||||
|
||||
let mut buf_chunks = output.chunks_exact_mut(channels);
|
||||
let mut iter = input.iter();
|
||||
|
||||
// `shift` iterates through the corresponding bit depth sequence:
|
||||
// 1 => &[7, 6, 5, 4, 3, 2, 1, 0],
|
||||
// 2 => &[6, 4, 2, 0],
|
||||
// 4 => &[4, 0],
|
||||
// 8 => &[0],
|
||||
//
|
||||
// `(0..8).step_by(bit_depth.into()).rev()` doesn't always optimize well so
|
||||
// shifts are calculated instead. (2023-08, Rust 1.71)
|
||||
|
||||
if bit_depth == 8 {
|
||||
for (&curr, chunk) in iter.zip(&mut buf_chunks) {
|
||||
func(curr, chunk);
|
||||
}
|
||||
} else {
|
||||
let mask = ((1u16 << bit_depth) - 1) as u8;
|
||||
|
||||
// These variables are initialized in the loop
|
||||
let mut shift = -1;
|
||||
let mut curr = 0;
|
||||
|
||||
for chunk in buf_chunks {
|
||||
if shift < 0 {
|
||||
shift = 8 - bit_depth as i32;
|
||||
curr = *iter.next().expect("input for unpack bits is not empty");
|
||||
}
|
||||
|
||||
let pixel = (curr >> shift) & mask;
|
||||
func(pixel, chunk);
|
||||
|
||||
shift -= bit_depth as i32;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_trns_line(input: &[u8], output: &mut [u8], info: &Info) {
|
||||
let channels = info.color_type.samples();
|
||||
let trns = info.trns.as_deref();
|
||||
for (input, output) in input
|
||||
.chunks_exact(channels)
|
||||
.zip(output.chunks_exact_mut(channels + 1))
|
||||
{
|
||||
output[..channels].copy_from_slice(input);
|
||||
output[channels] = if Some(input) == trns { 0 } else { 0xFF };
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_trns_line16(input: &[u8], output: &mut [u8], info: &Info) {
|
||||
let channels = info.color_type.samples();
|
||||
let trns = info.trns.as_deref();
|
||||
for (input, output) in input
|
||||
.chunks_exact(channels * 2)
|
||||
.zip(output.chunks_exact_mut(channels * 2 + 2))
|
||||
{
|
||||
output[..channels * 2].copy_from_slice(input);
|
||||
if Some(input) == trns {
|
||||
output[channels * 2] = 0;
|
||||
output[channels * 2 + 1] = 0
|
||||
} else {
|
||||
output[channels * 2] = 0xFF;
|
||||
output[channels * 2 + 1] = 0xFF
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_trns_and_strip_line16(input: &[u8], output: &mut [u8], info: &Info) {
|
||||
let channels = info.color_type.samples();
|
||||
let trns = info.trns.as_deref();
|
||||
for (input, output) in input
|
||||
.chunks_exact(channels * 2)
|
||||
.zip(output.chunks_exact_mut(channels + 1))
|
||||
{
|
||||
for i in 0..channels {
|
||||
output[i] = input[i * 2];
|
||||
}
|
||||
output[channels] = if Some(input) == trns { 0 } else { 0xFF };
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_gray_u8(row: &[u8], buffer: &mut [u8], info: &Info) {
|
||||
let scaling_factor = (255) / ((1u16 << info.bit_depth as u8) - 1) as u8;
|
||||
unpack_bits(row, buffer, 1, info.bit_depth as u8, |val, chunk| {
|
||||
chunk[0] = val * scaling_factor
|
||||
});
|
||||
}
|
||||
|
||||
fn expand_gray_u8_with_trns(row: &[u8], buffer: &mut [u8], info: &Info) {
|
||||
let scaling_factor = (255) / ((1u16 << info.bit_depth as u8) - 1) as u8;
|
||||
let trns = info.trns.as_deref();
|
||||
unpack_bits(row, buffer, 2, info.bit_depth as u8, |pixel, chunk| {
|
||||
chunk[1] = if let Some(trns) = trns {
|
||||
if pixel == trns[0] {
|
||||
0
|
||||
} else {
|
||||
0xFF
|
||||
}
|
||||
} else {
|
||||
0xFF
|
||||
};
|
||||
chunk[0] = pixel * scaling_factor
|
||||
});
|
||||
}
|
||||
361
third-party/vendor/png/src/decoder/transform/palette.rs
vendored
Normal file
361
third-party/vendor/png/src/decoder/transform/palette.rs
vendored
Normal file
|
|
@ -0,0 +1,361 @@
|
|||
//! Helpers for taking a slice of indeces (indices into `PLTE` and/or `trNS`
|
||||
//! entries) and transforming this into RGB or RGBA output.
|
||||
//!
|
||||
//! # Memoization
|
||||
//!
|
||||
//! To achieve higher throughput, `create_rgba_palette` combines entries from
|
||||
//! `PLTE` and `trNS` chunks into a single lookup table. This is based on the
|
||||
//! ideas explored in https://crbug.com/706134.
|
||||
//!
|
||||
//! Memoization is a trade-off:
|
||||
//! * On one hand, memoization requires spending X ns before starting to call
|
||||
//! `expand_paletted_...` functions.
|
||||
//! * On the other hand, memoization improves the throughput of the
|
||||
//! `expand_paletted_...` functions - they take Y ns less to process each byte
|
||||
//!
|
||||
//! Based on X and Y, we can try to calculate the breakeven point. It seems
|
||||
//! that memoization is a net benefit for images bigger than around 13x13 pixels.
|
||||
|
||||
use super::{unpack_bits, TransformFn};
|
||||
use crate::{BitDepth, Info};
|
||||
|
||||
pub fn create_expansion_into_rgb8(info: &Info) -> TransformFn {
|
||||
let rgba_palette = create_rgba_palette(info);
|
||||
|
||||
if info.bit_depth == BitDepth::Eight {
|
||||
Box::new(move |input, output, _info| expand_8bit_into_rgb8(input, output, &rgba_palette))
|
||||
} else {
|
||||
Box::new(move |input, output, info| expand_into_rgb8(input, output, info, &rgba_palette))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_expansion_into_rgba8(info: &Info) -> TransformFn {
|
||||
let rgba_palette = create_rgba_palette(info);
|
||||
Box::new(move |input, output, info| {
|
||||
expand_paletted_into_rgba8(input, output, info, &rgba_palette)
|
||||
})
|
||||
}
|
||||
|
||||
fn create_rgba_palette(info: &Info) -> [[u8; 4]; 256] {
|
||||
let palette = info.palette.as_deref().expect("Caller should verify");
|
||||
let trns = info.trns.as_deref().unwrap_or(&[]);
|
||||
|
||||
// > The tRNS chunk shall not contain more alpha values than there are palette
|
||||
// entries, but a tRNS chunk may contain fewer values than there are palette
|
||||
// entries. In this case, the alpha value for all remaining palette entries is
|
||||
// assumed to be 255.
|
||||
//
|
||||
// It seems, accepted reading is to fully *ignore* an invalid tRNS as if it were
|
||||
// completely empty / all pixels are non-transparent.
|
||||
let trns = if trns.len() <= palette.len() / 3 {
|
||||
trns
|
||||
} else {
|
||||
&[]
|
||||
};
|
||||
|
||||
// Default to black, opaque entries.
|
||||
let mut rgba_palette = [[0, 0, 0, 0xFF]; 256];
|
||||
|
||||
// Copy `palette` (RGB) entries into `rgba_palette`. This may clobber alpha
|
||||
// values in `rgba_palette` - we need to fix this later.
|
||||
{
|
||||
let mut palette_iter = palette;
|
||||
let mut rgba_iter = &mut rgba_palette[..];
|
||||
while palette_iter.len() >= 4 {
|
||||
// Copying 4 bytes at a time is more efficient than copying 3.
|
||||
// OTOH, this clobbers the alpha value in `rgba_iter[0][3]` - we
|
||||
// need to fix this later.
|
||||
rgba_iter[0].copy_from_slice(&palette_iter[0..4]);
|
||||
|
||||
palette_iter = &palette_iter[3..];
|
||||
rgba_iter = &mut rgba_iter[1..];
|
||||
}
|
||||
if palette_iter.len() > 0 {
|
||||
rgba_iter[0][0..3].copy_from_slice(&palette_iter[0..3]);
|
||||
}
|
||||
}
|
||||
|
||||
// Copy `trns` (alpha) entries into `rgba_palette`. `trns.len()` may be
|
||||
// smaller than `palette.len()` and therefore this is not sufficient to fix
|
||||
// all the clobbered alpha values.
|
||||
for (alpha, rgba) in trns.iter().copied().zip(rgba_palette.iter_mut()) {
|
||||
rgba[3] = alpha;
|
||||
}
|
||||
|
||||
// Unclobber the remaining alpha values.
|
||||
for rgba in rgba_palette[trns.len()..(palette.len() / 3)].iter_mut() {
|
||||
rgba[3] = 0xFF;
|
||||
}
|
||||
|
||||
rgba_palette
|
||||
}
|
||||
|
||||
fn expand_8bit_into_rgb8(mut input: &[u8], mut output: &mut [u8], rgba_palette: &[[u8; 4]; 256]) {
|
||||
while output.len() >= 4 {
|
||||
// Copying 4 bytes at a time is more efficient than 3.
|
||||
let rgba = &rgba_palette[input[0] as usize];
|
||||
output[0..4].copy_from_slice(rgba);
|
||||
|
||||
input = &input[1..];
|
||||
output = &mut output[3..];
|
||||
}
|
||||
if output.len() > 0 {
|
||||
let rgba = &rgba_palette[input[0] as usize];
|
||||
output[0..3].copy_from_slice(&rgba[0..3]);
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_into_rgb8(row: &[u8], buffer: &mut [u8], info: &Info, rgba_palette: &[[u8; 4]; 256]) {
|
||||
unpack_bits(row, buffer, 3, info.bit_depth as u8, |i, chunk| {
|
||||
let rgba = &rgba_palette[i as usize];
|
||||
chunk[0] = rgba[0];
|
||||
chunk[1] = rgba[1];
|
||||
chunk[2] = rgba[2];
|
||||
})
|
||||
}
|
||||
|
||||
fn expand_paletted_into_rgba8(
|
||||
row: &[u8],
|
||||
buffer: &mut [u8],
|
||||
info: &Info,
|
||||
rgba_palette: &[[u8; 4]; 256],
|
||||
) {
|
||||
unpack_bits(row, buffer, 4, info.bit_depth as u8, |i, chunk| {
|
||||
chunk.copy_from_slice(&rgba_palette[i as usize]);
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use crate::{BitDepth, ColorType, Info, Transformations};
|
||||
|
||||
/// Old, non-memoized version of the code is used as a test oracle.
|
||||
fn oracle_expand_paletted_into_rgb8(row: &[u8], buffer: &mut [u8], info: &Info) {
|
||||
let palette = info.palette.as_deref().expect("Caller should verify");
|
||||
let black = [0, 0, 0];
|
||||
|
||||
super::unpack_bits(row, buffer, 3, info.bit_depth as u8, |i, chunk| {
|
||||
let rgb = palette
|
||||
.get(3 * i as usize..3 * i as usize + 3)
|
||||
.unwrap_or(&black);
|
||||
chunk[0] = rgb[0];
|
||||
chunk[1] = rgb[1];
|
||||
chunk[2] = rgb[2];
|
||||
})
|
||||
}
|
||||
|
||||
/// Old, non-memoized version of the code is used as a test oracle.
|
||||
fn oracle_expand_paletted_into_rgba8(row: &[u8], buffer: &mut [u8], info: &Info) {
|
||||
let palette = info.palette.as_deref().expect("Caller should verify");
|
||||
let trns = info.trns.as_deref().unwrap_or(&[]);
|
||||
let black = [0, 0, 0];
|
||||
|
||||
// > The tRNS chunk shall not contain more alpha values than there are palette
|
||||
// entries, but a tRNS chunk may contain fewer values than there are palette
|
||||
// entries. In this case, the alpha value for all remaining palette entries is
|
||||
// assumed to be 255.
|
||||
//
|
||||
// It seems, accepted reading is to fully *ignore* an invalid tRNS as if it were
|
||||
// completely empty / all pixels are non-transparent.
|
||||
let trns = if trns.len() <= palette.len() / 3 {
|
||||
trns
|
||||
} else {
|
||||
&[]
|
||||
};
|
||||
|
||||
super::unpack_bits(row, buffer, 4, info.bit_depth as u8, |i, chunk| {
|
||||
let (rgb, a) = (
|
||||
palette
|
||||
.get(3 * i as usize..3 * i as usize + 3)
|
||||
.unwrap_or(&black),
|
||||
*trns.get(i as usize).unwrap_or(&0xFF),
|
||||
);
|
||||
chunk[0] = rgb[0];
|
||||
chunk[1] = rgb[1];
|
||||
chunk[2] = rgb[2];
|
||||
chunk[3] = a;
|
||||
});
|
||||
}
|
||||
|
||||
fn create_info<'a>(src_bit_depth: u8, palette: &'a [u8], trns: Option<&'a [u8]>) -> Info<'a> {
|
||||
Info {
|
||||
color_type: ColorType::Indexed,
|
||||
bit_depth: BitDepth::from_u8(src_bit_depth).unwrap(),
|
||||
palette: Some(palette.into()),
|
||||
trns: trns.map(Into::into),
|
||||
..Info::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_paletted(
|
||||
src: &[u8],
|
||||
src_bit_depth: u8,
|
||||
palette: &[u8],
|
||||
trns: Option<&[u8]>,
|
||||
) -> Vec<u8> {
|
||||
let info = create_info(src_bit_depth, palette, trns);
|
||||
let output_bytes_per_input_sample = match trns {
|
||||
None => 3,
|
||||
Some(_) => 4,
|
||||
};
|
||||
let samples_count_per_byte = (8 / src_bit_depth) as usize;
|
||||
let samples_count = src.len() * samples_count_per_byte;
|
||||
|
||||
let mut dst = vec![0; samples_count * output_bytes_per_input_sample];
|
||||
let transform_fn =
|
||||
super::super::create_transform_fn(&info, Transformations::EXPAND).unwrap();
|
||||
transform_fn(src, dst.as_mut_slice(), &info);
|
||||
|
||||
{
|
||||
// Compare the memoization-based calculations with the old, non-memoized code.
|
||||
let mut simple_dst = vec![0; samples_count * output_bytes_per_input_sample];
|
||||
if trns.is_none() {
|
||||
oracle_expand_paletted_into_rgb8(src, &mut simple_dst, &info)
|
||||
} else {
|
||||
oracle_expand_paletted_into_rgba8(src, &mut simple_dst, &info)
|
||||
}
|
||||
assert_eq!(&dst, &simple_dst);
|
||||
}
|
||||
|
||||
dst
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_paletted_rgba_8bit() {
|
||||
let actual = expand_paletted(
|
||||
&[0, 1, 2, 3], // src
|
||||
8, // src_bit_depth
|
||||
&[
|
||||
// palette
|
||||
0, 1, 2, // entry #0
|
||||
4, 5, 6, // entry #1
|
||||
8, 9, 10, // entry #2
|
||||
12, 13, 14, // entry #3
|
||||
],
|
||||
Some(&[3, 7, 11, 15]), // trns
|
||||
);
|
||||
assert_eq!(actual, (0..16).collect::<Vec<u8>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_paletted_rgb_8bit() {
|
||||
let actual = expand_paletted(
|
||||
&[0, 1, 2, 3], // src
|
||||
8, // src_bit_depth
|
||||
&[
|
||||
// palette
|
||||
0, 1, 2, // entry #0
|
||||
3, 4, 5, // entry #1
|
||||
6, 7, 8, // entry #2
|
||||
9, 10, 11, // entry #3
|
||||
],
|
||||
None, // trns
|
||||
);
|
||||
assert_eq!(actual, (0..12).collect::<Vec<u8>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_paletted_rgba_4bit() {
|
||||
let actual = expand_paletted(
|
||||
&[0x01, 0x23], // src
|
||||
4, // src_bit_depth
|
||||
&[
|
||||
// palette
|
||||
0, 1, 2, // entry #0
|
||||
4, 5, 6, // entry #1
|
||||
8, 9, 10, // entry #2
|
||||
12, 13, 14, // entry #3
|
||||
],
|
||||
Some(&[3, 7, 11, 15]), // trns
|
||||
);
|
||||
assert_eq!(actual, (0..16).collect::<Vec<u8>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_paletted_rgb_4bit() {
|
||||
let actual = expand_paletted(
|
||||
&[0x01, 0x23], // src
|
||||
4, // src_bit_depth
|
||||
&[
|
||||
// palette
|
||||
0, 1, 2, // entry #0
|
||||
3, 4, 5, // entry #1
|
||||
6, 7, 8, // entry #2
|
||||
9, 10, 11, // entry #3
|
||||
],
|
||||
None, // trns
|
||||
);
|
||||
assert_eq!(actual, (0..12).collect::<Vec<u8>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_paletted_rgba_8bit_more_trns_entries_than_palette_entries() {
|
||||
let actual = expand_paletted(
|
||||
&[0, 1, 2, 3], // src
|
||||
8, // src_bit_depth
|
||||
&[
|
||||
// palette
|
||||
0, 1, 2, // entry #0
|
||||
4, 5, 6, // entry #1
|
||||
8, 9, 10, // entry #2
|
||||
12, 13, 14, // entry #3
|
||||
],
|
||||
Some(&[123; 5]), // trns
|
||||
);
|
||||
|
||||
// Invalid (too-long) `trns` means that we'll use 0xFF / opaque alpha everywhere.
|
||||
assert_eq!(
|
||||
actual,
|
||||
vec![0, 1, 2, 0xFF, 4, 5, 6, 0xFF, 8, 9, 10, 0xFF, 12, 13, 14, 0xFF],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expand_paletted_rgba_8bit_less_trns_entries_than_palette_entries() {
|
||||
let actual = expand_paletted(
|
||||
&[0, 1, 2, 3], // src
|
||||
8, // src_bit_depth
|
||||
&[
|
||||
// palette
|
||||
0, 1, 2, // entry #0
|
||||
4, 5, 6, // entry #1
|
||||
8, 9, 10, // entry #2
|
||||
12, 13, 14, // entry #3
|
||||
],
|
||||
Some(&[3, 7]), // trns
|
||||
);
|
||||
|
||||
// Too-short `trns` is treated differently from too-long - only missing entries are
|
||||
// replaced with 0XFF / opaque.
|
||||
assert_eq!(
|
||||
actual,
|
||||
vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0xFF, 12, 13, 14, 0xFF],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_create_rgba_palette() {
|
||||
fn create_expected_rgba_palette(plte: &[u8], trns: &[u8]) -> [[u8; 4]; 256] {
|
||||
let mut rgba = [[1, 2, 3, 4]; 256];
|
||||
for (i, rgba) in rgba.iter_mut().enumerate() {
|
||||
rgba[0] = plte.get(i * 3 + 0).map(|&r| r).unwrap_or(0);
|
||||
rgba[1] = plte.get(i * 3 + 1).map(|&g| g).unwrap_or(0);
|
||||
rgba[2] = plte.get(i * 3 + 2).map(|&b| b).unwrap_or(0);
|
||||
rgba[3] = trns.get(i * 1 + 0).map(|&a| a).unwrap_or(0xFF);
|
||||
}
|
||||
rgba
|
||||
}
|
||||
|
||||
for plte_len in 1..=32 {
|
||||
for trns_len in 0..=plte_len {
|
||||
let plte: Vec<u8> = (0..plte_len * 3).collect();
|
||||
let trns: Vec<u8> = (0..trns_len).map(|alpha| alpha + 200).collect();
|
||||
|
||||
let info = create_info(8, &plte, Some(&trns));
|
||||
let expected = create_expected_rgba_palette(&plte, &trns);
|
||||
let actual = super::create_rgba_palette(&info);
|
||||
assert_eq!(actual, expected);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
230
third-party/vendor/png/src/decoder/zlib.rs
vendored
Normal file
230
third-party/vendor/png/src/decoder/zlib.rs
vendored
Normal file
|
|
@ -0,0 +1,230 @@
|
|||
use super::{stream::FormatErrorInner, DecodingError, CHUNCK_BUFFER_SIZE};
|
||||
|
||||
use fdeflate::Decompressor;
|
||||
|
||||
/// Ergonomics wrapper around `miniz_oxide::inflate::stream` for zlib compressed data.
|
||||
pub(super) struct ZlibStream {
|
||||
/// Current decoding state.
|
||||
state: Box<fdeflate::Decompressor>,
|
||||
/// If there has been a call to decompress already.
|
||||
started: bool,
|
||||
/// Remaining buffered decoded bytes.
|
||||
/// The decoder sometimes wants inspect some already finished bytes for further decoding. So we
|
||||
/// keep a total of 32KB of decoded data available as long as more data may be appended.
|
||||
out_buffer: Vec<u8>,
|
||||
/// The first index of `out_buffer` where new data can be written.
|
||||
out_pos: usize,
|
||||
/// The first index of `out_buffer` that hasn't yet been passed to our client
|
||||
/// (i.e. not yet appended to the `image_data` parameter of `fn decompress` or `fn
|
||||
/// finish_compressed_chunks`).
|
||||
read_pos: usize,
|
||||
/// Limit on how many bytes can be decompressed in total. This field is mostly used for
|
||||
/// performance optimizations (e.g. to avoid allocating and zeroing out large buffers when only
|
||||
/// a small image is being decoded).
|
||||
max_total_output: usize,
|
||||
/// Ignore and do not calculate the Adler-32 checksum. Defaults to `true`.
|
||||
///
|
||||
/// This flag overrides `TINFL_FLAG_COMPUTE_ADLER32`.
|
||||
///
|
||||
/// This flag should not be modified after decompression has started.
|
||||
ignore_adler32: bool,
|
||||
}
|
||||
|
||||
impl ZlibStream {
|
||||
pub(crate) fn new() -> Self {
|
||||
ZlibStream {
|
||||
state: Box::new(Decompressor::new()),
|
||||
started: false,
|
||||
out_buffer: Vec::new(),
|
||||
out_pos: 0,
|
||||
read_pos: 0,
|
||||
max_total_output: usize::MAX,
|
||||
ignore_adler32: true,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn reset(&mut self) {
|
||||
self.started = false;
|
||||
self.out_buffer.clear();
|
||||
self.out_pos = 0;
|
||||
self.read_pos = 0;
|
||||
self.max_total_output = usize::MAX;
|
||||
*self.state = Decompressor::new();
|
||||
}
|
||||
|
||||
pub(crate) fn set_max_total_output(&mut self, n: usize) {
|
||||
self.max_total_output = n;
|
||||
}
|
||||
|
||||
/// Set the `ignore_adler32` flag and return `true` if the flag was
|
||||
/// successfully set.
|
||||
///
|
||||
/// The default is `true`.
|
||||
///
|
||||
/// This flag cannot be modified after decompression has started until the
|
||||
/// [ZlibStream] is reset.
|
||||
pub(crate) fn set_ignore_adler32(&mut self, flag: bool) -> bool {
|
||||
if !self.started {
|
||||
self.ignore_adler32 = flag;
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// Return the `ignore_adler32` flag.
|
||||
pub(crate) fn ignore_adler32(&self) -> bool {
|
||||
self.ignore_adler32
|
||||
}
|
||||
|
||||
/// Fill the decoded buffer as far as possible from `data`.
|
||||
/// On success returns the number of consumed input bytes.
|
||||
pub(crate) fn decompress(
|
||||
&mut self,
|
||||
data: &[u8],
|
||||
image_data: &mut Vec<u8>,
|
||||
) -> Result<usize, DecodingError> {
|
||||
// There may be more data past the adler32 checksum at the end of the deflate stream. We
|
||||
// match libpng's default behavior and ignore any trailing data. In the future we may want
|
||||
// to add a flag to control this behavior.
|
||||
if self.state.is_done() {
|
||||
return Ok(data.len());
|
||||
}
|
||||
|
||||
self.prepare_vec_for_appending();
|
||||
|
||||
if !self.started && self.ignore_adler32 {
|
||||
self.state.ignore_adler32();
|
||||
}
|
||||
|
||||
let (in_consumed, out_consumed) = self
|
||||
.state
|
||||
.read(data, self.out_buffer.as_mut_slice(), self.out_pos, false)
|
||||
.map_err(|err| {
|
||||
DecodingError::Format(FormatErrorInner::CorruptFlateStream { err }.into())
|
||||
})?;
|
||||
|
||||
self.started = true;
|
||||
self.out_pos += out_consumed;
|
||||
self.transfer_finished_data(image_data);
|
||||
self.compact_out_buffer_if_needed();
|
||||
|
||||
Ok(in_consumed)
|
||||
}
|
||||
|
||||
/// Called after all consecutive IDAT chunks were handled.
|
||||
///
|
||||
/// The compressed stream can be split on arbitrary byte boundaries. This enables some cleanup
|
||||
/// within the decompressor and flushing additional data which may have been kept back in case
|
||||
/// more data were passed to it.
|
||||
pub(crate) fn finish_compressed_chunks(
|
||||
&mut self,
|
||||
image_data: &mut Vec<u8>,
|
||||
) -> Result<(), DecodingError> {
|
||||
if !self.started {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
while !self.state.is_done() {
|
||||
self.prepare_vec_for_appending();
|
||||
let (_in_consumed, out_consumed) = self
|
||||
.state
|
||||
.read(&[], self.out_buffer.as_mut_slice(), self.out_pos, true)
|
||||
.map_err(|err| {
|
||||
DecodingError::Format(FormatErrorInner::CorruptFlateStream { err }.into())
|
||||
})?;
|
||||
|
||||
self.out_pos += out_consumed;
|
||||
|
||||
if !self.state.is_done() {
|
||||
let transferred = self.transfer_finished_data(image_data);
|
||||
assert!(
|
||||
transferred > 0 || out_consumed > 0,
|
||||
"No more forward progress made in stream decoding."
|
||||
);
|
||||
self.compact_out_buffer_if_needed();
|
||||
}
|
||||
}
|
||||
|
||||
self.transfer_finished_data(image_data);
|
||||
self.out_buffer.clear();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Resize the vector to allow allocation of more data.
|
||||
fn prepare_vec_for_appending(&mut self) {
|
||||
// The `debug_assert` below explains why we can use `>=` instead of `>` in the condition
|
||||
// that compares `self.out_post >= self.max_total_output` in the next `if` statement.
|
||||
debug_assert!(!self.state.is_done());
|
||||
if self.out_pos >= self.max_total_output {
|
||||
// This can happen when the `max_total_output` was miscalculated (e.g.
|
||||
// because the `IHDR` chunk was malformed and didn't match the `IDAT` chunk). In
|
||||
// this case, let's reset `self.max_total_output` before further calculations.
|
||||
self.max_total_output = usize::MAX;
|
||||
}
|
||||
|
||||
let current_len = self.out_buffer.len();
|
||||
let desired_len = self
|
||||
.out_pos
|
||||
.saturating_add(CHUNCK_BUFFER_SIZE)
|
||||
.min(self.max_total_output);
|
||||
if current_len >= desired_len {
|
||||
return;
|
||||
}
|
||||
|
||||
let buffered_len = self.decoding_size(self.out_buffer.len());
|
||||
debug_assert!(self.out_buffer.len() <= buffered_len);
|
||||
self.out_buffer.resize(buffered_len, 0u8);
|
||||
}
|
||||
|
||||
fn decoding_size(&self, len: usize) -> usize {
|
||||
// Allocate one more chunk size than currently or double the length while ensuring that the
|
||||
// allocation is valid and that any cursor within it will be valid.
|
||||
len
|
||||
// This keeps the buffer size a power-of-two, required by miniz_oxide.
|
||||
.saturating_add(CHUNCK_BUFFER_SIZE.max(len))
|
||||
// Ensure all buffer indices are valid cursor positions.
|
||||
// Note: both cut off and zero extension give correct results.
|
||||
.min(u64::max_value() as usize)
|
||||
// Ensure the allocation request is valid.
|
||||
// TODO: maximum allocation limits?
|
||||
.min(isize::max_value() as usize)
|
||||
// Don't unnecessarily allocate more than `max_total_output`.
|
||||
.min(self.max_total_output)
|
||||
}
|
||||
|
||||
fn transfer_finished_data(&mut self, image_data: &mut Vec<u8>) -> usize {
|
||||
let transferred = &self.out_buffer[self.read_pos..self.out_pos];
|
||||
image_data.extend_from_slice(transferred);
|
||||
self.read_pos = self.out_pos;
|
||||
transferred.len()
|
||||
}
|
||||
|
||||
fn compact_out_buffer_if_needed(&mut self) {
|
||||
// [PNG spec](https://www.w3.org/TR/2003/REC-PNG-20031110/#10Compression) says that
|
||||
// "deflate/inflate compression with a sliding window (which is an upper bound on the
|
||||
// distances appearing in the deflate stream) of at most 32768 bytes".
|
||||
//
|
||||
// `fdeflate` requires that we keep this many most recently decompressed bytes in the
|
||||
// `out_buffer` - this allows referring back to them when handling "length and distance
|
||||
// codes" in the deflate stream).
|
||||
const LOOKBACK_SIZE: usize = 32768;
|
||||
|
||||
// Compact `self.out_buffer` when "needed". Doing this conditionally helps to put an upper
|
||||
// bound on the amortized cost of copying the data within `self.out_buffer`.
|
||||
//
|
||||
// TODO: The factor of 4 is an ad-hoc heuristic. Consider measuring and using a different
|
||||
// factor. (Early experiments seem to indicate that factor of 4 is faster than a factor of
|
||||
// 2 and 4 * `LOOKBACK_SIZE` seems like an acceptable memory trade-off. Higher factors
|
||||
// result in higher memory usage, but the compaction cost is lower - factor of 4 means
|
||||
// that 1 byte gets copied during compaction for 3 decompressed bytes.)
|
||||
if self.out_pos > LOOKBACK_SIZE * 4 {
|
||||
// Only preserve the `lookback_buffer` and "throw away" the earlier prefix.
|
||||
let lookback_buffer = self.out_pos.saturating_sub(LOOKBACK_SIZE)..self.out_pos;
|
||||
let preserved_len = lookback_buffer.len();
|
||||
self.out_buffer.copy_within(lookback_buffer, 0);
|
||||
self.read_pos = preserved_len;
|
||||
self.out_pos = preserved_len;
|
||||
}
|
||||
}
|
||||
}
|
||||
2413
third-party/vendor/png/src/encoder.rs
vendored
Normal file
2413
third-party/vendor/png/src/encoder.rs
vendored
Normal file
File diff suppressed because it is too large
Load diff
1073
third-party/vendor/png/src/filter.rs
vendored
Normal file
1073
third-party/vendor/png/src/filter.rs
vendored
Normal file
File diff suppressed because it is too large
Load diff
88
third-party/vendor/png/src/lib.rs
vendored
Normal file
88
third-party/vendor/png/src/lib.rs
vendored
Normal file
|
|
@ -0,0 +1,88 @@
|
|||
//! # PNG encoder and decoder
|
||||
//!
|
||||
//! This crate contains a PNG encoder and decoder. It supports reading of single lines or whole frames.
|
||||
//!
|
||||
//! ## The decoder
|
||||
//!
|
||||
//! The most important types for decoding purposes are [`Decoder`](struct.Decoder.html) and
|
||||
//! [`Reader`](struct.Reader.html). They both wrap a `std::io::Read`.
|
||||
//! `Decoder` serves as a builder for `Reader`. Calling `Decoder::read_info` reads from the `Read` until the
|
||||
//! image data is reached.
|
||||
//!
|
||||
//! ### Using the decoder
|
||||
//! ```
|
||||
//! use std::fs::File;
|
||||
//! // The decoder is a build for reader and can be used to set various decoding options
|
||||
//! // via `Transformations`. The default output transformation is `Transformations::IDENTITY`.
|
||||
//! let decoder = png::Decoder::new(File::open("tests/pngsuite/basi0g01.png").unwrap());
|
||||
//! let mut reader = decoder.read_info().unwrap();
|
||||
//! // Allocate the output buffer.
|
||||
//! let mut buf = vec![0; reader.output_buffer_size()];
|
||||
//! // Read the next frame. An APNG might contain multiple frames.
|
||||
//! let info = reader.next_frame(&mut buf).unwrap();
|
||||
//! // Grab the bytes of the image.
|
||||
//! let bytes = &buf[..info.buffer_size()];
|
||||
//! // Inspect more details of the last read frame.
|
||||
//! let in_animation = reader.info().frame_control.is_some();
|
||||
//! ```
|
||||
//!
|
||||
//! ## Encoder
|
||||
//! ### Using the encoder
|
||||
//!
|
||||
//! ```no_run
|
||||
//! // For reading and opening files
|
||||
//! use std::path::Path;
|
||||
//! use std::fs::File;
|
||||
//! use std::io::BufWriter;
|
||||
//!
|
||||
//! let path = Path::new(r"/path/to/image.png");
|
||||
//! let file = File::create(path).unwrap();
|
||||
//! let ref mut w = BufWriter::new(file);
|
||||
//!
|
||||
//! let mut encoder = png::Encoder::new(w, 2, 1); // Width is 2 pixels and height is 1.
|
||||
//! encoder.set_color(png::ColorType::Rgba);
|
||||
//! encoder.set_depth(png::BitDepth::Eight);
|
||||
//! encoder.set_source_gamma(png::ScaledFloat::from_scaled(45455)); // 1.0 / 2.2, scaled by 100000
|
||||
//! encoder.set_source_gamma(png::ScaledFloat::new(1.0 / 2.2)); // 1.0 / 2.2, unscaled, but rounded
|
||||
//! let source_chromaticities = png::SourceChromaticities::new( // Using unscaled instantiation here
|
||||
//! (0.31270, 0.32900),
|
||||
//! (0.64000, 0.33000),
|
||||
//! (0.30000, 0.60000),
|
||||
//! (0.15000, 0.06000)
|
||||
//! );
|
||||
//! encoder.set_source_chromaticities(source_chromaticities);
|
||||
//! let mut writer = encoder.write_header().unwrap();
|
||||
//!
|
||||
//! let data = [255, 0, 0, 255, 0, 0, 0, 255]; // An array containing a RGBA sequence. First pixel is red and second pixel is black.
|
||||
//! writer.write_image_data(&data).unwrap(); // Save
|
||||
//! ```
|
||||
//!
|
||||
|
||||
#![cfg_attr(feature = "unstable", feature(portable_simd))]
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
#[macro_use]
|
||||
extern crate bitflags;
|
||||
|
||||
mod adam7;
|
||||
pub mod chunk;
|
||||
mod common;
|
||||
mod decoder;
|
||||
mod encoder;
|
||||
mod filter;
|
||||
mod srgb;
|
||||
pub mod text_metadata;
|
||||
mod traits;
|
||||
|
||||
pub use crate::common::*;
|
||||
pub use crate::decoder::{
|
||||
DecodeOptions, Decoded, Decoder, DecodingError, Limits, OutputInfo, Reader, StreamingDecoder,
|
||||
};
|
||||
pub use crate::encoder::{Encoder, EncodingError, StreamWriter, Writer};
|
||||
pub use crate::filter::{AdaptiveFilterType, FilterType};
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) mod test_utils;
|
||||
|
||||
#[cfg(feature = "benchmarks")]
|
||||
pub mod benchable_apis;
|
||||
30
third-party/vendor/png/src/srgb.rs
vendored
Normal file
30
third-party/vendor/png/src/srgb.rs
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
use crate::{ScaledFloat, SourceChromaticities};
|
||||
|
||||
/// Get the gamma that should be substituted for images conforming to the sRGB color space.
|
||||
pub fn substitute_gamma() -> ScaledFloat {
|
||||
// Value taken from https://www.w3.org/TR/2003/REC-PNG-20031110/#11sRGB
|
||||
ScaledFloat::from_scaled(45455)
|
||||
}
|
||||
|
||||
/// Get the chromaticities that should be substituted for images conforming to the sRGB color space.
|
||||
pub fn substitute_chromaticities() -> SourceChromaticities {
|
||||
// Values taken from https://www.w3.org/TR/2003/REC-PNG-20031110/#11sRGB
|
||||
SourceChromaticities {
|
||||
white: (
|
||||
ScaledFloat::from_scaled(31270),
|
||||
ScaledFloat::from_scaled(32900),
|
||||
),
|
||||
red: (
|
||||
ScaledFloat::from_scaled(64000),
|
||||
ScaledFloat::from_scaled(33000),
|
||||
),
|
||||
green: (
|
||||
ScaledFloat::from_scaled(30000),
|
||||
ScaledFloat::from_scaled(60000),
|
||||
),
|
||||
blue: (
|
||||
ScaledFloat::from_scaled(15000),
|
||||
ScaledFloat::from_scaled(6000),
|
||||
),
|
||||
}
|
||||
}
|
||||
118
third-party/vendor/png/src/test_utils.rs
vendored
Normal file
118
third-party/vendor/png/src/test_utils.rs
vendored
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
//! A set of test utilities.
|
||||
//!
|
||||
//! There is some overlap between this module and `src/encoder.rs` module, but:
|
||||
//!
|
||||
//! * This module (unlike `src/encoder.rs`) performs no validation of the data being written - this
|
||||
//! allows building testcases that use arbitrary, potentially invalid PNGs as input.
|
||||
//! * This module can be reused from `benches/decoder.rs` (a separate crate).
|
||||
|
||||
use byteorder::WriteBytesExt;
|
||||
use std::io::Write;
|
||||
|
||||
/// Generates a store-only, non-compressed image:
|
||||
///
|
||||
/// * `00` compression mode (i.e.`BTYPE` = `00` = no compression) is used
|
||||
/// * No filter is applied to the image rows
|
||||
///
|
||||
/// Currently the image always has the following properties:
|
||||
///
|
||||
/// * Single `IDAT` chunk
|
||||
/// * Zlib chunks of maximum possible size
|
||||
/// * 8-bit RGBA
|
||||
///
|
||||
/// These images are somewhat artificial, but may be useful for benchmarking performance of parts
|
||||
/// outside of `fdeflate` crate and/or the `unfilter` function (e.g. these images were originally
|
||||
/// used to evaluate changes to minimize copying of image pixels between various buffers - see
|
||||
/// [this
|
||||
/// discussion](https://github.com/image-rs/image-png/discussions/416#discussioncomment-7436871)
|
||||
/// for more details).
|
||||
#[allow(dead_code)] // Used from `benches/decoder.rs`
|
||||
pub fn write_noncompressed_png(w: &mut impl Write, size: u32, idat_bytes: usize) {
|
||||
write_png_sig(w);
|
||||
write_rgba8_ihdr_with_width(w, size);
|
||||
write_rgba8_idats(w, size, idat_bytes);
|
||||
write_iend(w);
|
||||
}
|
||||
|
||||
/// Writes PNG signature.
|
||||
/// See http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#PNG-file-signature
|
||||
pub fn write_png_sig(w: &mut impl Write) {
|
||||
const SIG: [u8; 8] = [137, 80, 78, 71, 13, 10, 26, 10];
|
||||
w.write_all(&SIG).unwrap();
|
||||
}
|
||||
|
||||
/// Writes an arbitrary PNG chunk.
|
||||
pub fn write_chunk(w: &mut impl Write, chunk_type: &[u8], data: &[u8]) {
|
||||
assert_eq!(chunk_type.len(), 4);
|
||||
let crc = {
|
||||
let input = chunk_type
|
||||
.iter()
|
||||
.copied()
|
||||
.chain(data.iter().copied())
|
||||
.collect::<Vec<_>>();
|
||||
crc32fast::hash(input.as_slice())
|
||||
};
|
||||
w.write_u32::<byteorder::BigEndian>(data.len() as u32)
|
||||
.unwrap();
|
||||
w.write_all(chunk_type).unwrap();
|
||||
w.write_all(data).unwrap();
|
||||
w.write_u32::<byteorder::BigEndian>(crc).unwrap();
|
||||
}
|
||||
|
||||
/// Writes an IHDR chunk that indicates a non-interlaced RGBA8 that uses the same height and
|
||||
/// `width`. See http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IHDR
|
||||
pub fn write_rgba8_ihdr_with_width(w: &mut impl Write, width: u32) {
|
||||
let mut data = Vec::new();
|
||||
data.write_u32::<byteorder::BigEndian>(width).unwrap();
|
||||
data.write_u32::<byteorder::BigEndian>(width).unwrap(); // height
|
||||
data.write_u8(8).unwrap(); // bit depth = always 8-bits per channel
|
||||
data.write_u8(6).unwrap(); // color type = color + alpha
|
||||
data.write_u8(0).unwrap(); // compression method (0 is the only allowed value)
|
||||
data.write_u8(0).unwrap(); // filter method (0 is the only allowed value)
|
||||
data.write_u8(0).unwrap(); // interlace method = no interlacing
|
||||
write_chunk(w, b"IHDR", &data);
|
||||
}
|
||||
|
||||
/// Generates RGBA8 `width` x `height` image and wraps it in a store-only zlib container.
|
||||
pub fn generate_rgba8_with_width_and_height(width: u32, height: u32) -> Vec<u8> {
|
||||
// Generate arbitrary test pixels.
|
||||
let image_pixels = {
|
||||
let mut row = Vec::new();
|
||||
row.write_u8(0).unwrap(); // filter = no filter
|
||||
|
||||
let row_pixels = (0..width).flat_map(|i| {
|
||||
let color: u8 = (i * 255 / width) as u8;
|
||||
let alpha: u8 = 0xff;
|
||||
[color, 255 - color, color / 2, alpha]
|
||||
});
|
||||
row.extend(row_pixels);
|
||||
|
||||
std::iter::repeat(row)
|
||||
.take(height as usize)
|
||||
.flatten()
|
||||
.collect::<Vec<_>>()
|
||||
};
|
||||
|
||||
let mut zlib_data = Vec::new();
|
||||
let mut store_only_compressor =
|
||||
fdeflate::StoredOnlyCompressor::new(std::io::Cursor::new(&mut zlib_data)).unwrap();
|
||||
store_only_compressor.write_data(&image_pixels).unwrap();
|
||||
store_only_compressor.finish().unwrap();
|
||||
|
||||
zlib_data
|
||||
}
|
||||
|
||||
/// Writes an IDAT chunk.
|
||||
pub fn write_rgba8_idats(w: &mut impl Write, size: u32, idat_bytes: usize) {
|
||||
let data = generate_rgba8_with_width_and_height(size, size);
|
||||
|
||||
for chunk in data.chunks(idat_bytes) {
|
||||
write_chunk(w, b"IDAT", chunk);
|
||||
}
|
||||
}
|
||||
|
||||
/// Writes an IEND chunk.
|
||||
/// See http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IEND
|
||||
pub fn write_iend(w: &mut impl Write) {
|
||||
write_chunk(w, b"IEND", &[]);
|
||||
}
|
||||
586
third-party/vendor/png/src/text_metadata.rs
vendored
Normal file
586
third-party/vendor/png/src/text_metadata.rs
vendored
Normal file
|
|
@ -0,0 +1,586 @@
|
|||
//! # Text chunks (tEXt/zTXt/iTXt) structs and functions
|
||||
//!
|
||||
//! The [PNG spec](https://www.w3.org/TR/2003/REC-PNG-20031110/#11textinfo) optionally allows for
|
||||
//! embedded text chunks in the file. They may appear either before or after the image data
|
||||
//! chunks. There are three kinds of text chunks.
|
||||
//! - `tEXt`: This has a `keyword` and `text` field, and is ISO 8859-1 encoded.
|
||||
//! - `zTXt`: This is semantically the same as `tEXt`, i.e. it has the same fields and
|
||||
//! encoding, but the `text` field is compressed before being written into the PNG file.
|
||||
//! - `iTXt`: This chunk allows for its `text` field to be any valid UTF-8, and supports
|
||||
//! compression of the text field as well.
|
||||
//!
|
||||
//! The `ISO 8859-1` encoding technically doesn't allow any control characters
|
||||
//! to be used, but in practice these values are encountered anyway. This can
|
||||
//! either be the extended `ISO-8859-1` encoding with control characters or the
|
||||
//! `Windows-1252` encoding. This crate assumes the `ISO-8859-1` encoding is
|
||||
//! used.
|
||||
//!
|
||||
//! ## Reading text chunks
|
||||
//!
|
||||
//! As a PNG is decoded, any text chunk encountered is appended the
|
||||
//! [`Info`](`crate::common::Info`) struct, in the `uncompressed_latin1_text`,
|
||||
//! `compressed_latin1_text`, and the `utf8_text` fields depending on whether the encountered
|
||||
//! chunk is `tEXt`, `zTXt`, or `iTXt`.
|
||||
//!
|
||||
//! ```
|
||||
//! use std::fs::File;
|
||||
//! use std::iter::FromIterator;
|
||||
//! use std::path::PathBuf;
|
||||
//!
|
||||
//! // Opening a png file that has a zTXt chunk
|
||||
//! let decoder = png::Decoder::new(
|
||||
//! File::open(PathBuf::from_iter([
|
||||
//! "tests",
|
||||
//! "text_chunk_examples",
|
||||
//! "ztxt_example.png",
|
||||
//! ]))
|
||||
//! .unwrap(),
|
||||
//! );
|
||||
//! let mut reader = decoder.read_info().unwrap();
|
||||
//! // If the text chunk is before the image data frames, `reader.info()` already contains the text.
|
||||
//! for text_chunk in &reader.info().compressed_latin1_text {
|
||||
//! println!("{:?}", text_chunk.keyword); // Prints the keyword
|
||||
//! println!("{:#?}", text_chunk); // Prints out the text chunk.
|
||||
//! // To get the uncompressed text, use the `get_text` method.
|
||||
//! println!("{}", text_chunk.get_text().unwrap());
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! ## Writing text chunks
|
||||
//!
|
||||
//! There are two ways to write text chunks: the first is to add the appropriate text structs directly to the encoder header before the header is written to file.
|
||||
//! To add a text chunk at any point in the stream, use the `write_text_chunk` method.
|
||||
//!
|
||||
//! ```
|
||||
//! # use png::text_metadata::{ITXtChunk, ZTXtChunk};
|
||||
//! # use std::env;
|
||||
//! # use std::fs::File;
|
||||
//! # use std::io::BufWriter;
|
||||
//! # use std::iter::FromIterator;
|
||||
//! # use std::path::PathBuf;
|
||||
//! # let file = File::create(PathBuf::from_iter(["target", "text_chunk.png"])).unwrap();
|
||||
//! # let ref mut w = BufWriter::new(file);
|
||||
//! let mut encoder = png::Encoder::new(w, 2, 1); // Width is 2 pixels and height is 1.
|
||||
//! encoder.set_color(png::ColorType::Rgba);
|
||||
//! encoder.set_depth(png::BitDepth::Eight);
|
||||
//! // Adding text chunks to the header
|
||||
//! encoder
|
||||
//! .add_text_chunk(
|
||||
//! "Testing tEXt".to_string(),
|
||||
//! "This is a tEXt chunk that will appear before the IDAT chunks.".to_string(),
|
||||
//! )
|
||||
//! .unwrap();
|
||||
//! encoder
|
||||
//! .add_ztxt_chunk(
|
||||
//! "Testing zTXt".to_string(),
|
||||
//! "This is a zTXt chunk that is compressed in the png file.".to_string(),
|
||||
//! )
|
||||
//! .unwrap();
|
||||
//! encoder
|
||||
//! .add_itxt_chunk(
|
||||
//! "Testing iTXt".to_string(),
|
||||
//! "iTXt chunks support all of UTF8. Example: हिंदी.".to_string(),
|
||||
//! )
|
||||
//! .unwrap();
|
||||
//!
|
||||
//! let mut writer = encoder.write_header().unwrap();
|
||||
//!
|
||||
//! let data = [255, 0, 0, 255, 0, 0, 0, 255]; // An array containing a RGBA sequence. First pixel is red and second pixel is black.
|
||||
//! writer.write_image_data(&data).unwrap(); // Save
|
||||
//!
|
||||
//! // We can add a tEXt/zTXt/iTXt at any point before the encoder is dropped from scope. These chunks will be at the end of the png file.
|
||||
//! let tail_ztxt_chunk = ZTXtChunk::new("Comment".to_string(), "A zTXt chunk after the image data.".to_string());
|
||||
//! writer.write_text_chunk(&tail_ztxt_chunk).unwrap();
|
||||
//!
|
||||
//! // The fields of the text chunk are public, so they can be mutated before being written to the file.
|
||||
//! let mut tail_itxt_chunk = ITXtChunk::new("Author".to_string(), "सायंतन खान".to_string());
|
||||
//! tail_itxt_chunk.compressed = true;
|
||||
//! tail_itxt_chunk.language_tag = "hi".to_string();
|
||||
//! tail_itxt_chunk.translated_keyword = "लेखक".to_string();
|
||||
//! writer.write_text_chunk(&tail_itxt_chunk).unwrap();
|
||||
//! ```
|
||||
|
||||
#![warn(missing_docs)]
|
||||
|
||||
use crate::{chunk, encoder, DecodingError, EncodingError};
|
||||
use fdeflate::BoundedDecompressionError;
|
||||
use flate2::write::ZlibEncoder;
|
||||
use flate2::Compression;
|
||||
use std::{convert::TryFrom, io::Write};
|
||||
|
||||
/// Default decompression limit for compressed text chunks.
|
||||
pub const DECOMPRESSION_LIMIT: usize = 2097152; // 2 MiB
|
||||
|
||||
/// Text encoding errors that is wrapped by the standard EncodingError type
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub(crate) enum TextEncodingError {
|
||||
/// Unrepresentable characters in string
|
||||
Unrepresentable,
|
||||
/// Keyword longer than 79 bytes or empty
|
||||
InvalidKeywordSize,
|
||||
/// Error encountered while compressing text
|
||||
CompressionError,
|
||||
}
|
||||
|
||||
/// Text decoding error that is wrapped by the standard DecodingError type
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub(crate) enum TextDecodingError {
|
||||
/// Unrepresentable characters in string
|
||||
Unrepresentable,
|
||||
/// Keyword longer than 79 bytes or empty
|
||||
InvalidKeywordSize,
|
||||
/// Missing null separator
|
||||
MissingNullSeparator,
|
||||
/// Compressed text cannot be uncompressed
|
||||
InflationError,
|
||||
/// Needs more space to decompress
|
||||
OutOfDecompressionSpace,
|
||||
/// Using an unspecified value for the compression method
|
||||
InvalidCompressionMethod,
|
||||
/// Using a byte that is not 0 or 255 as compression flag in iTXt chunk
|
||||
InvalidCompressionFlag,
|
||||
/// Missing the compression flag
|
||||
MissingCompressionFlag,
|
||||
}
|
||||
|
||||
/// A generalized text chunk trait
|
||||
pub trait EncodableTextChunk {
|
||||
/// Encode text chunk as Vec<u8> to a `Write`
|
||||
fn encode<W: Write>(&self, w: &mut W) -> Result<(), EncodingError>;
|
||||
}
|
||||
|
||||
/// Struct representing a tEXt chunk
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct TEXtChunk {
|
||||
/// Keyword field of the tEXt chunk. Needs to be between 1-79 bytes when encoded as Latin-1.
|
||||
pub keyword: String,
|
||||
/// Text field of tEXt chunk. Can be at most 2GB.
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
fn decode_iso_8859_1(text: &[u8]) -> String {
|
||||
text.iter().map(|&b| b as char).collect()
|
||||
}
|
||||
|
||||
fn encode_iso_8859_1(text: &str) -> Result<Vec<u8>, TextEncodingError> {
|
||||
encode_iso_8859_1_iter(text).collect()
|
||||
}
|
||||
|
||||
fn encode_iso_8859_1_into(buf: &mut Vec<u8>, text: &str) -> Result<(), TextEncodingError> {
|
||||
for b in encode_iso_8859_1_iter(text) {
|
||||
buf.push(b?);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn encode_iso_8859_1_iter(text: &str) -> impl Iterator<Item = Result<u8, TextEncodingError>> + '_ {
|
||||
text.chars()
|
||||
.map(|c| u8::try_from(c as u32).map_err(|_| TextEncodingError::Unrepresentable))
|
||||
}
|
||||
|
||||
fn decode_ascii(text: &[u8]) -> Result<&str, TextDecodingError> {
|
||||
if text.is_ascii() {
|
||||
// `from_utf8` cannot panic because we're already checked that `text` is ASCII-7.
|
||||
// And this is the only safe way to get ASCII-7 string from `&[u8]`.
|
||||
Ok(std::str::from_utf8(text).expect("unreachable"))
|
||||
} else {
|
||||
Err(TextDecodingError::Unrepresentable)
|
||||
}
|
||||
}
|
||||
|
||||
impl TEXtChunk {
|
||||
/// Constructs a new TEXtChunk.
|
||||
/// Not sure whether it should take &str or String.
|
||||
pub fn new(keyword: impl Into<String>, text: impl Into<String>) -> Self {
|
||||
Self {
|
||||
keyword: keyword.into(),
|
||||
text: text.into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Decodes a slice of bytes to a String using Latin-1 decoding.
|
||||
/// The decoder runs in strict mode, and any decoding errors are passed along to the caller.
|
||||
pub(crate) fn decode(
|
||||
keyword_slice: &[u8],
|
||||
text_slice: &[u8],
|
||||
) -> Result<Self, TextDecodingError> {
|
||||
if keyword_slice.is_empty() || keyword_slice.len() > 79 {
|
||||
return Err(TextDecodingError::InvalidKeywordSize);
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
keyword: decode_iso_8859_1(keyword_slice),
|
||||
text: decode_iso_8859_1(text_slice),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl EncodableTextChunk for TEXtChunk {
|
||||
/// Encodes TEXtChunk to a Writer. The keyword and text are separated by a byte of zeroes.
|
||||
fn encode<W: Write>(&self, w: &mut W) -> Result<(), EncodingError> {
|
||||
let mut data = encode_iso_8859_1(&self.keyword)?;
|
||||
|
||||
if data.is_empty() || data.len() > 79 {
|
||||
return Err(TextEncodingError::InvalidKeywordSize.into());
|
||||
}
|
||||
|
||||
data.push(0);
|
||||
|
||||
encode_iso_8859_1_into(&mut data, &self.text)?;
|
||||
|
||||
encoder::write_chunk(w, chunk::tEXt, &data)
|
||||
}
|
||||
}
|
||||
|
||||
/// Struct representing a zTXt chunk
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct ZTXtChunk {
|
||||
/// Keyword field of the tEXt chunk. Needs to be between 1-79 bytes when encoded as Latin-1.
|
||||
pub keyword: String,
|
||||
/// Text field of zTXt chunk. It is compressed by default, but can be uncompressed if necessary.
|
||||
text: OptCompressed,
|
||||
}
|
||||
|
||||
/// Private enum encoding the compressed and uncompressed states of zTXt/iTXt text field.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
enum OptCompressed {
|
||||
/// Compressed version of text field. Can be at most 2GB.
|
||||
Compressed(Vec<u8>),
|
||||
/// Uncompressed text field.
|
||||
Uncompressed(String),
|
||||
}
|
||||
|
||||
impl ZTXtChunk {
|
||||
/// Creates a new ZTXt chunk.
|
||||
pub fn new(keyword: impl Into<String>, text: impl Into<String>) -> Self {
|
||||
Self {
|
||||
keyword: keyword.into(),
|
||||
text: OptCompressed::Uncompressed(text.into()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn decode(
|
||||
keyword_slice: &[u8],
|
||||
compression_method: u8,
|
||||
text_slice: &[u8],
|
||||
) -> Result<Self, TextDecodingError> {
|
||||
if keyword_slice.is_empty() || keyword_slice.len() > 79 {
|
||||
return Err(TextDecodingError::InvalidKeywordSize);
|
||||
}
|
||||
|
||||
if compression_method != 0 {
|
||||
return Err(TextDecodingError::InvalidCompressionMethod);
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
keyword: decode_iso_8859_1(keyword_slice),
|
||||
text: OptCompressed::Compressed(text_slice.to_vec()),
|
||||
})
|
||||
}
|
||||
|
||||
/// Decompresses the inner text, mutating its own state. Can only handle decompressed text up to `DECOMPRESSION_LIMIT` bytes.
|
||||
pub fn decompress_text(&mut self) -> Result<(), DecodingError> {
|
||||
self.decompress_text_with_limit(DECOMPRESSION_LIMIT)
|
||||
}
|
||||
|
||||
/// Decompresses the inner text, mutating its own state. Can only handle decompressed text up to `limit` bytes.
|
||||
pub fn decompress_text_with_limit(&mut self, limit: usize) -> Result<(), DecodingError> {
|
||||
match &self.text {
|
||||
OptCompressed::Compressed(v) => {
|
||||
let uncompressed_raw = match fdeflate::decompress_to_vec_bounded(&v[..], limit) {
|
||||
Ok(s) => s,
|
||||
Err(BoundedDecompressionError::OutputTooLarge { .. }) => {
|
||||
return Err(DecodingError::from(
|
||||
TextDecodingError::OutOfDecompressionSpace,
|
||||
));
|
||||
}
|
||||
Err(_) => {
|
||||
return Err(DecodingError::from(TextDecodingError::InflationError));
|
||||
}
|
||||
};
|
||||
self.text = OptCompressed::Uncompressed(decode_iso_8859_1(&uncompressed_raw));
|
||||
}
|
||||
OptCompressed::Uncompressed(_) => {}
|
||||
};
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Decompresses the inner text, and returns it as a `String`.
|
||||
/// If decompression uses more the 2MiB, first call decompress with limit, and then this method.
|
||||
pub fn get_text(&self) -> Result<String, DecodingError> {
|
||||
match &self.text {
|
||||
OptCompressed::Compressed(v) => {
|
||||
let uncompressed_raw = fdeflate::decompress_to_vec(v)
|
||||
.map_err(|_| DecodingError::from(TextDecodingError::InflationError))?;
|
||||
Ok(decode_iso_8859_1(&uncompressed_raw))
|
||||
}
|
||||
OptCompressed::Uncompressed(s) => Ok(s.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Compresses the inner text, mutating its own state.
|
||||
pub fn compress_text(&mut self) -> Result<(), EncodingError> {
|
||||
match &self.text {
|
||||
OptCompressed::Uncompressed(s) => {
|
||||
let uncompressed_raw = encode_iso_8859_1(s)?;
|
||||
let mut encoder = ZlibEncoder::new(Vec::new(), Compression::fast());
|
||||
encoder
|
||||
.write_all(&uncompressed_raw)
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?;
|
||||
self.text = OptCompressed::Compressed(
|
||||
encoder
|
||||
.finish()
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?,
|
||||
);
|
||||
}
|
||||
OptCompressed::Compressed(_) => {}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl EncodableTextChunk for ZTXtChunk {
|
||||
fn encode<W: Write>(&self, w: &mut W) -> Result<(), EncodingError> {
|
||||
let mut data = encode_iso_8859_1(&self.keyword)?;
|
||||
|
||||
if data.is_empty() || data.len() > 79 {
|
||||
return Err(TextEncodingError::InvalidKeywordSize.into());
|
||||
}
|
||||
|
||||
// Null separator
|
||||
data.push(0);
|
||||
|
||||
// Compression method: the only valid value is 0, as of 2021.
|
||||
data.push(0);
|
||||
|
||||
match &self.text {
|
||||
OptCompressed::Compressed(v) => {
|
||||
data.extend_from_slice(&v[..]);
|
||||
}
|
||||
OptCompressed::Uncompressed(s) => {
|
||||
// This code may have a bug. Check for correctness.
|
||||
let uncompressed_raw = encode_iso_8859_1(s)?;
|
||||
let mut encoder = ZlibEncoder::new(data, Compression::fast());
|
||||
encoder
|
||||
.write_all(&uncompressed_raw)
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?;
|
||||
data = encoder
|
||||
.finish()
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?;
|
||||
}
|
||||
};
|
||||
|
||||
encoder::write_chunk(w, chunk::zTXt, &data)
|
||||
}
|
||||
}
|
||||
|
||||
/// Struct encoding an iTXt chunk
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct ITXtChunk {
|
||||
/// The keyword field. This needs to be between 1-79 bytes when encoded as Latin-1.
|
||||
pub keyword: String,
|
||||
/// Indicates whether the text will be (or was) compressed in the PNG.
|
||||
pub compressed: bool,
|
||||
/// A hyphen separated list of languages that the keyword is translated to. This is ASCII-7 encoded.
|
||||
pub language_tag: String,
|
||||
/// Translated keyword. This is UTF-8 encoded.
|
||||
pub translated_keyword: String,
|
||||
/// Text field of iTXt chunk. It is compressed by default, but can be uncompressed if necessary.
|
||||
text: OptCompressed,
|
||||
}
|
||||
|
||||
impl ITXtChunk {
|
||||
/// Constructs a new iTXt chunk. Leaves all but keyword and text to default values.
|
||||
pub fn new(keyword: impl Into<String>, text: impl Into<String>) -> Self {
|
||||
Self {
|
||||
keyword: keyword.into(),
|
||||
compressed: false,
|
||||
language_tag: "".to_string(),
|
||||
translated_keyword: "".to_string(),
|
||||
text: OptCompressed::Uncompressed(text.into()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn decode(
|
||||
keyword_slice: &[u8],
|
||||
compression_flag: u8,
|
||||
compression_method: u8,
|
||||
language_tag_slice: &[u8],
|
||||
translated_keyword_slice: &[u8],
|
||||
text_slice: &[u8],
|
||||
) -> Result<Self, TextDecodingError> {
|
||||
if keyword_slice.is_empty() || keyword_slice.len() > 79 {
|
||||
return Err(TextDecodingError::InvalidKeywordSize);
|
||||
}
|
||||
let keyword = decode_iso_8859_1(keyword_slice);
|
||||
|
||||
let compressed = match compression_flag {
|
||||
0 => false,
|
||||
1 => true,
|
||||
_ => return Err(TextDecodingError::InvalidCompressionFlag),
|
||||
};
|
||||
|
||||
if compressed && compression_method != 0 {
|
||||
return Err(TextDecodingError::InvalidCompressionMethod);
|
||||
}
|
||||
|
||||
let language_tag = decode_ascii(language_tag_slice)?.to_owned();
|
||||
|
||||
let translated_keyword = std::str::from_utf8(translated_keyword_slice)
|
||||
.map_err(|_| TextDecodingError::Unrepresentable)?
|
||||
.to_string();
|
||||
let text = if compressed {
|
||||
OptCompressed::Compressed(text_slice.to_vec())
|
||||
} else {
|
||||
OptCompressed::Uncompressed(
|
||||
String::from_utf8(text_slice.to_vec())
|
||||
.map_err(|_| TextDecodingError::Unrepresentable)?,
|
||||
)
|
||||
};
|
||||
|
||||
Ok(Self {
|
||||
keyword,
|
||||
compressed,
|
||||
language_tag,
|
||||
translated_keyword,
|
||||
text,
|
||||
})
|
||||
}
|
||||
|
||||
/// Decompresses the inner text, mutating its own state. Can only handle decompressed text up to `DECOMPRESSION_LIMIT` bytes.
|
||||
pub fn decompress_text(&mut self) -> Result<(), DecodingError> {
|
||||
self.decompress_text_with_limit(DECOMPRESSION_LIMIT)
|
||||
}
|
||||
|
||||
/// Decompresses the inner text, mutating its own state. Can only handle decompressed text up to `limit` bytes.
|
||||
pub fn decompress_text_with_limit(&mut self, limit: usize) -> Result<(), DecodingError> {
|
||||
match &self.text {
|
||||
OptCompressed::Compressed(v) => {
|
||||
let uncompressed_raw = match fdeflate::decompress_to_vec_bounded(v, limit) {
|
||||
Ok(s) => s,
|
||||
Err(BoundedDecompressionError::OutputTooLarge { .. }) => {
|
||||
return Err(DecodingError::from(
|
||||
TextDecodingError::OutOfDecompressionSpace,
|
||||
));
|
||||
}
|
||||
Err(_) => {
|
||||
return Err(DecodingError::from(TextDecodingError::InflationError));
|
||||
}
|
||||
};
|
||||
self.text = OptCompressed::Uncompressed(
|
||||
String::from_utf8(uncompressed_raw)
|
||||
.map_err(|_| TextDecodingError::Unrepresentable)?,
|
||||
);
|
||||
}
|
||||
OptCompressed::Uncompressed(_) => {}
|
||||
};
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Decompresses the inner text, and returns it as a `String`.
|
||||
/// If decompression takes more than 2 MiB, try `decompress_text_with_limit` followed by this method.
|
||||
pub fn get_text(&self) -> Result<String, DecodingError> {
|
||||
match &self.text {
|
||||
OptCompressed::Compressed(v) => {
|
||||
let uncompressed_raw = fdeflate::decompress_to_vec(v)
|
||||
.map_err(|_| DecodingError::from(TextDecodingError::InflationError))?;
|
||||
String::from_utf8(uncompressed_raw)
|
||||
.map_err(|_| TextDecodingError::Unrepresentable.into())
|
||||
}
|
||||
OptCompressed::Uncompressed(s) => Ok(s.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Compresses the inner text, mutating its own state.
|
||||
pub fn compress_text(&mut self) -> Result<(), EncodingError> {
|
||||
match &self.text {
|
||||
OptCompressed::Uncompressed(s) => {
|
||||
let uncompressed_raw = s.as_bytes();
|
||||
let mut encoder = ZlibEncoder::new(Vec::new(), Compression::fast());
|
||||
encoder
|
||||
.write_all(uncompressed_raw)
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?;
|
||||
self.text = OptCompressed::Compressed(
|
||||
encoder
|
||||
.finish()
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?,
|
||||
);
|
||||
}
|
||||
OptCompressed::Compressed(_) => {}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl EncodableTextChunk for ITXtChunk {
|
||||
fn encode<W: Write>(&self, w: &mut W) -> Result<(), EncodingError> {
|
||||
// Keyword
|
||||
let mut data = encode_iso_8859_1(&self.keyword)?;
|
||||
|
||||
if data.is_empty() || data.len() > 79 {
|
||||
return Err(TextEncodingError::InvalidKeywordSize.into());
|
||||
}
|
||||
|
||||
// Null separator
|
||||
data.push(0);
|
||||
|
||||
// Compression flag
|
||||
if self.compressed {
|
||||
data.push(1);
|
||||
} else {
|
||||
data.push(0);
|
||||
}
|
||||
|
||||
// Compression method
|
||||
data.push(0);
|
||||
|
||||
// Language tag
|
||||
if !self.language_tag.is_ascii() {
|
||||
return Err(EncodingError::from(TextEncodingError::Unrepresentable));
|
||||
}
|
||||
data.extend(self.language_tag.as_bytes());
|
||||
|
||||
// Null separator
|
||||
data.push(0);
|
||||
|
||||
// Translated keyword
|
||||
data.extend_from_slice(self.translated_keyword.as_bytes());
|
||||
|
||||
// Null separator
|
||||
data.push(0);
|
||||
|
||||
// Text
|
||||
if self.compressed {
|
||||
match &self.text {
|
||||
OptCompressed::Compressed(v) => {
|
||||
data.extend_from_slice(&v[..]);
|
||||
}
|
||||
OptCompressed::Uncompressed(s) => {
|
||||
let uncompressed_raw = s.as_bytes();
|
||||
let mut encoder = ZlibEncoder::new(data, Compression::fast());
|
||||
encoder
|
||||
.write_all(uncompressed_raw)
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?;
|
||||
data = encoder
|
||||
.finish()
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
match &self.text {
|
||||
OptCompressed::Compressed(v) => {
|
||||
let uncompressed_raw = fdeflate::decompress_to_vec(v)
|
||||
.map_err(|_| EncodingError::from(TextEncodingError::CompressionError))?;
|
||||
data.extend_from_slice(&uncompressed_raw[..]);
|
||||
}
|
||||
OptCompressed::Uncompressed(s) => {
|
||||
data.extend_from_slice(s.as_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
encoder::write_chunk(w, chunk::iTXt, &data)
|
||||
}
|
||||
}
|
||||
43
third-party/vendor/png/src/traits.rs
vendored
Normal file
43
third-party/vendor/png/src/traits.rs
vendored
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
use std::io;
|
||||
|
||||
macro_rules! read_bytes_ext {
|
||||
($output_type:ty) => {
|
||||
impl<W: io::Read + ?Sized> ReadBytesExt<$output_type> for W {
|
||||
#[inline]
|
||||
fn read_be(&mut self) -> io::Result<$output_type> {
|
||||
let mut bytes = [0u8; std::mem::size_of::<$output_type>()];
|
||||
self.read_exact(&mut bytes)?;
|
||||
Ok(<$output_type>::from_be_bytes(bytes))
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! write_bytes_ext {
|
||||
($input_type:ty) => {
|
||||
impl<W: io::Write + ?Sized> WriteBytesExt<$input_type> for W {
|
||||
#[inline]
|
||||
fn write_be(&mut self, n: $input_type) -> io::Result<()> {
|
||||
self.write_all(&n.to_be_bytes())
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Read extension to read big endian data
|
||||
pub trait ReadBytesExt<T>: io::Read {
|
||||
/// Read `T` from a bytes stream. Most significant byte first.
|
||||
fn read_be(&mut self) -> io::Result<T>;
|
||||
}
|
||||
|
||||
/// Write extension to write big endian data
|
||||
pub trait WriteBytesExt<T>: io::Write {
|
||||
/// Writes `T` to a bytes stream. Most significant byte first.
|
||||
fn write_be(&mut self, _: T) -> io::Result<()>;
|
||||
}
|
||||
|
||||
read_bytes_ext!(u8);
|
||||
read_bytes_ext!(u16);
|
||||
read_bytes_ext!(u32);
|
||||
|
||||
write_bytes_ext!(u32);
|
||||
Loading…
Add table
Add a link
Reference in a new issue