Compare commits

...
Author SHA1 Message Date
Nigel Tao 7f70dda95c release: wuffs gen -version=0.4.0-alpha.12 2026-10-20 14:35:26 +11:00
Nigel Tao 0d8b52336e spec/suitar: fix normalization link 2026-10-20 14:33:59 +11:00
Nigel Tao 0baab7fe72 release: spin in v0.3.6
This copies wuffs-v0.3.c from the v0.3 branch to the main branch. The
main branch is currently working on an unstable v0.4.
2026-10-20 14:32:33 +11:00
Nigel Tao c99f5af9fe base: fix parse_number_f64, 801 digits before '.'
Fixes #183
2026-10-20 14:09:09 +11:00
Nigel Tao fb8926614b A+C: add sabith saheb 2026-10-20 13:30:30 +11:00
Nigel Tao 2fa1d20d76 Merge pull request #182 from Medios-lgtm/parse-number-slice-bounds
base: don't read past the end of the slice in parse_number_{u64,f64}
2026-10-20 13:28:38 +11:00
sabith saheb 9d41525a2f base: don't read past the end of the slice in parse_number_{u64,f64} 2026-10-19 12:59:04 +05:30
Nigel Tao 2a6876f8bb release: wuffs gen -version=0.4.0-alpha.11 2026-10-18 18:17:12 +11:00
Nigel Tao c677bef7fd std/png: parse cICP chunk
Updates #180
2026-10-18 18:13:59 +11:00
Nigel Tao ab24b06450 doc: add lz4, etc to enumerated-media-types.txt 2026-10-18 14:47:55 +11:00
Nigel Tao 1f513d8023 cgen: tweak arm_neon_utility.make_u16x4_multiple
The -O3 codegen is the same (https://godbolt.org/z/5ecWrEq77) but this
avoids compound literals, not part of C++11, and can trigger "compound
literals are a C99-specific feature [-Werror,-Wc99-extensions]".

Fixes #181
2026-10-06 22:30:32 +11:00
Nigel Tao 89b7cc7a36 base: add WUFFS_BASE__MIME_TYPE__ETC 2026-10-05 16:55:53 +11:00
Nigel Tao b2e6da3024 lib/suitar: allow implicitly-sized entries 2026-09-29 22:31:20 +10:00
Nigel Tao 72045c951e doc: add rar, zip to enumerated-media-types.txt 2026-09-21 09:43:35 +10:00
Nigel Tao f31d952b62 snippet: avoid some -Wunused-function warnings 2026-09-16 20:49:39 +10:00
Nigel Tao fbb65550ac snippet/uncompng: fix encode_apng return value 2026-09-16 20:39:10 +10:00
Nigel Tao 5f95a0d49a example: inspect SECCOMP_MODE_STRICT return value 2026-09-16 20:32:27 +10:00
Nigel Tao e0f1efc4a6 example/gifplayer: add NIE support 2026-09-15 22:30:23 +10:00
Nigel Tao 56250f1f27 example/gifplayer: refactor 2026-09-15 22:28:50 +10:00
Nigel Tao b1adeeccb1 lib/suitar: allow Write to a sparse entry 2026-09-15 15:31:04 +10:00
Nigel Tao b77e1a67de lib/suitar: make some Reader.Next errors sticky
Updates PR #179
2026-09-15 14:02:10 +10:00
Nigel Tao c944c491c4 lib/suitar: tweak some style nits
Updates PR #179
2026-09-15 14:00:21 +10:00
Nigel Tao 4abc399eaa A+C: add rootkiller6788 2026-09-15 10:44:18 +10:00
Nigel Tao 901b740c00 spec/suitar: elaborate on duplicate file names 2026-09-15 10:42:51 +10:00
Nigel Tao 3d46062176 cgen: note that base.io_buffer__struct is linear 2026-09-15 10:42:51 +10:00
Nigel Tao 1ca418ef16 snippet/uncompng: support APNG (Animated PNG) 2026-09-15 10:42:51 +10:00
Nigel Tao 742e8b78d9 lib/suitar: reject names ending in "/." or "/.." 2026-09-15 10:42:51 +10:00
39 changed files with 5467 additions and 1714 deletions

No files matched your search

+2
View File
@@ -22,5 +22,7 @@ Muhammad Aldo Firmansyah <TheCrott@users.noreply.github.com>
Přemysl Eric Janouch <p@janouch.name>
Richard Hughes <rhughes@redhat.com>
Samuel Bronson <naesten@gmail.com>
rootkiller6788 <17553215+rootkiller6788@user.noreply.gitee.com>
sabith saheb <admin@medios.digiscrypt.com>
sarastro-nl <nlsarastro@gmail.com>
zhuzeitou <zhuzeitou@gmail.com>
+2
View File
@@ -48,5 +48,7 @@ Peter Kasting <pkasting@chromium.org>
Přemysl Eric Janouch <p@janouch.name>
Richard Hughes <rhughes@redhat.com>
Samuel Bronson <naesten@gmail.com>
rootkiller6788 <17553215+rootkiller6788@user.noreply.gitee.com>
sabith saheb <admin@medios.digiscrypt.com>
sarastro-nl <nlsarastro@gmail.com>
zhuzeitou <zhuzeitou@gmail.com>
+6
View File
@@ -70,6 +70,12 @@ code (instead of writing C/C++ code that _uses_ Wuffs' standard library).
a tab).
## 2026-10-20 version 0.3.6
- Fix some `parse_number_f64` and `parse_number_u64` bugs.
- Fix "go test" example names for newer Go toolchains.
## 2026-07-11 version 0.3.5
- No significant changes to `wuffs-v0.3.c` per se.
+12 -1
View File
@@ -47,7 +47,10 @@
# directory of the github.com/google/wuffs repository. That same directory also
# holds a base38-and-fourcc.md file that elaborates on base38 encoding.
0x09CC62_556F2000 2757997502603264 appl/brot/.. application/brotli
0x09CC62_607F1000 2757997688197120 appl/defl/.. application/deflate
0x09CC62_6933B000 2757997834252288 appl/epub/.. application/epub+zip
0x09CC62_784EA000 2757998087675904 appl/gzip/.. application/gzip
0x09CC62_880DB9BE 2757998351858110 appl/java/ar application/java-archive
0x09CC62_880DBC67 2757998351858791 appl/java/so application/java-serialized-object
0x09CC62_880DBCD7 2757998351858903 appl/java/vm application/java-vm
@@ -114,6 +117,7 @@
0x09CC62_DADFCC6C 2757999741357164 appl/vopo/st application/vnd.openxmlformats-officedocument.spreadsheetml.template
0x09CC62_DADFCCF4 2757999741357300 appl/vopo/wd application/vnd.openxmlformats-officedocument.wordprocessingml.document
0x09CC62_DADFCD04 2757999741357316 appl/vopo/wt application/vnd.openxmlformats-officedocument.wordprocessingml.template
0x09CC62_DB557000 2757999749066752 appl/vrar/.. application/vnd.rar
0x09CC62_DF1E4800 2757999812560896 appl/wasm/.. application/wasm
0x09CC62_E5514000 2757999916564480 appl/x7z./.. application/x-7z-compressed
0x09CC62_E5BCB800 2757999923607552 appl/xabi/.. application/x-abiword
@@ -128,14 +132,18 @@
0x09CC62_E70E1800 2757999945717760 appl/xhtm/.. application/xhtml+xml
0x09CC62_E73A1800 2757999948601344 appl/xiso/.. application/x-iso9660-image
0x09CC62_E7AC4000 2757999956082688 appl/xlat/.. application/x-latex
0x09CC62_E7C92800 2757999957977088 appl/xlz4/.. application/x-lz4
0x09CC62_E7C9B800 2757999958013952 appl/xlzm/.. application/x-lzma
0x09CC62_E7C9BB7D 2757999958014845 appl/xlzm/mi application/x-micro-lzma
0x09CC62_E7E58000 2757999959834624 appl/xml./.. application/xml
0x09CC62_E7E5F000 2757999959863296 appl/xmld/.. application/xml-dtd
0x09CC62_E7EDD1BC 2757999960379836 appl/xms./ap application/x-ms-application
0x09CC62_E7EDD460 2757999960380512 appl/xms./sh application/x-ms-shortcut
0x09CC62_E7EE4000 2757999960408064 appl/xmsd/.. application/x-msdownload
0x09CC62_E8BAF000 2757999973822464 appl/xrar/.. application/x-rar-compressed
0x09CC62_E8EF8000 2757999977267200 appl/xsh./.. application/x-sh
0x09CC62_E8F04800 2757999977318400 appl/xsho/.. application/x-shockwave-flash
0x09CC62_E8F6FA7C 2757999977757308 appl/xsna/fr application/x-snappy-framed
0x09CC62_E8F6FC33 2757999977757747 appl/xsna/ra application/x-snappy-raw
0x09CC62_E8FAE000 2757999978012672 appl/xsql/.. application/x-sql
0x09CC62_E9153000 2757999979737088 appl/xtar/.. application/x-tar
0x09CC62_E91A2000 2757999980060672 appl/xtex/.. application/x-tex
@@ -143,6 +151,9 @@
0x09CC62_E91A22EA 2757999980061418 appl/xtex/in application/x-texinfo
0x09CC62_E9E68000 2757999993454592 appl/xxz./.. application/x-xz
0x09CC62_F49B4000 2758000173072384 appl/zip./.. application/zip
0x09CC62_F49B420A 2758000173072906 appl/zip./cr application/zip-crypto
0x09CC62_F51AB000 2758000181424128 appl/zlib/.. application/zlib
0x09CC62_F663B000 2758000202985472 appl/zstd/.. application/zstd
0x09CC62_FAA35800 2758000274266112 appl/~exa/.. application/pua.example
0x09CC62_FE887DA3 2758000339615139 appl/~~~~/~~ application/*
+101 -30
View File
@@ -15,7 +15,7 @@ or [NIE](./nie-spec.md) is to image files: an uncompressed, "designed for Unix
pipes" format that is trivial to read or write in a few hundred lines of code,
ideally in a memory-safe programming language. It's a format for what the
Chromium web browser's "Rule of 2" security advice calls
[https://chromium.googlesource.com/chromium/src/+/master/docs/security/rule-of-2.md#normalization](Normalization).
[Normalization](https://chromium.googlesource.com/chromium/src/+/master/docs/security/rule-of-2.md#normalization).
## Subset of TAR
@@ -31,7 +31,15 @@ wrapping TAR, but is out of scope of this document.
Like TAR, SUITAR files are a sequence of independent entries (files or
directories). Independent means that, like JSON map keys, duplicate names are
valid, although some decoders may choose to reject them.
valid, although some SUITAR decoders (or some destination File Systems or
Operating Systems, if unpacking from a source SUITAR archive to a particular
destination FS / OS) may choose to reject them.
For example, answering "are these two file names duplicates (and does the
destination FS / OS accept or reject duplicates)?" may depend on the
_destination_ FS / OS's case-sensitivity and Unicode normalization
configuration (and whether case folding and normalization elides DICPs, Unicode
Default-Ignorable Code Points), not the _source_ SUITAR archive per se.
A file's entry does not need to be preceded by explicit entries for that file's
parent directories.
@@ -43,9 +51,9 @@ Compared to plain TAR (and refer to [the GNU TAR
manual](https://ftp.gnu.org/old-gnu/Manuals/tar-1.12/html_node/tar_123.html)),
SUITAR has further restrictions:
- Entries are either regular files (`REGTYPE`), sparse files (`GNUTYPE_SPARSE`)
or directories (`DIRTYPE`). There is no support for hard links, symlinks,
device files or other non-standard files.
- Entries are either regular files (`REGTYPE` or `AREGTYPE`), sparse files
(`GNUTYPE_SPARSE`) or directories (`DIRTYPE`). There is no support for hard
links, symlinks, device files or other non-standard files.
- Sparse files must be completely sparse. Their content must be one contiguous
span of NUL (zero) bytes that covers the entire file.
- File and directory names must obey the "File Name Validity" rules, below.
@@ -65,16 +73,6 @@ There is no support for various TAR variants, such as "the PAX extensions to
TAR" or "the USTAR extensions to TAR", other than what's implied by the subset
of the GNU extensions that SUITAR explicitly uses.
Encoders have no meaningful choices, bar one exception. There is only one valid
SUITAR encoding (unlike full TAR's backwards-compatible choice between base-8
or base-256 encoding of various sufficiently small numbers) for any given file
or directory entry (its combination of type, name, size, mode, modTime and
contents).
The one exception is that, if a file's contents are all NUL bytes (including
zero-sized files), an encoder can choose between a `REGTYPE` regular file (with
explicit NULs) or a `GNUTYPE_SPARSE` sparse file (with implicit NULs).
### File Name Validity
@@ -86,13 +84,21 @@ These rules apply to both file names and directory names.
- Names must not contain the `'\x7F'` ASCII DEL byte.
- Names must be no longer than 4095 bytes, excluding a trailing NUL.
- Names must not be `""`, `"."` or `".."`.
- Names must not start or end with `"/"`, `"./"` or `"../"`.
- Names must not start with `"/"`, `"./"` or `"../"`.
- Names must not end with `"/"`, `"/."` or `"/.."`.
- Names must not contain `"//"`, `"/./"` or `"/../"` as substrings.
For example, when converting from ZIP (with Japanese file names) to SUITAR, it
is the SUITAR producer's responsibility, not the SUITAR consumer's, to detect
and transform Shift-JIS encoded names to equivalent and valid UTF-8.
Names like `"abc/.\u200B./xyz"`, containing a DICP (U+200B ZERO WIDTH SPACE),
are valid SUITAR file names per se. However, when unpacking from a source
SUITAR archive to a particular destination FS / OS, SUITAR decoders may wish to
impose further restrictions on file names, to avoid path traversal attacks
specific to that FS / OS. For example, eliding DICPs before applying the File
Name Validity rules would prohibit the `"/.\u200B./"` substring.
## File Structure
@@ -102,12 +108,70 @@ number of 512-byte blocks:
- 1 `GNUTYPE_LONGNAME` header block.
- 1 or more payload blocks containing the file or directory name.
- 1 `REGTYPE`, `GNUTYPE_SPARSE` or `DIRTYPE` header block.
- 1 `REGTYPE`, `AREGTYPE`, `GNUTYPE_SPARSE` or `DIRTYPE` header block.
- If `REGTYPE`, 0 or more payload blocks containing the file contents.
- If not `REGTYPE`, no further blocks.
- If `AREGTYPE`, see "Implicitly-Sized Files" below.
- If neither `REGTYPE` or `AREGTYPE`, no further blocks.
### Header Blocks
## Implicitly-Sized Files
For TAR itself, each entry's contents is preceded by the entry's header that
states the entire contents' size in bytes. SUITAR keeps that formal structure
but also uses additional convention to represent entries whose size is only
known at the end, not the start, of the entry.
For example, when decompressing `foobar.dat.gz` from a GZIP stream to SUITAR
(an archive with one entry: `foobar.dat`), the uncompressed `foobar.dat` size
is not known until the end of the GZIP-formatted input stream is reached.
For historical reasons, TAR itself has two typeflag codes for regular files
(`REGTYPE` and `AREGTYPE`) and both codes are largely equivalent. SUITAR, by
convention, treats them differently: `REGTYPE` is for the common case, where
the contents' size is known up-front, and `AREGTYPE` means the contents that
follow are partial and to be continued.
An implicitly-sized file is partitioned into 2 or more chunks. The final chunk
is `REGTYPE` and all other chunks are `AREGTYPE`. Each chunk's size is explicit
(and zero is a valid size) but the number of chunks isn't known until the final
`REGTYPE` chunk is delivered. The entry's structure is:
- 1 `GNUTYPE_LONGNAME` header block.
- 1 or more payload blocks containing the file or directory name.
- 1 or more non-final chunks, each being:
- 1 `AREGTYPE` header block, stating the chunk contents' size.
- 0 or more payload blocks containing the chunk contents.
- 1 final chunk, being:
- 1 `REGTYPE` header block, stating the chunk contents' size.
- 0 or more payload blocks containing the chunk contents.
"0 non-final chunks" is actually valid in some sense, equivalent to an
explicitly-sized `REGTYPE` entry (of exactly one chunk).
The file name still comes from the `GNUTYPE_LONGNAME` payload. There is only
one `GNUTYPE_LONGNAME` header block, not one per chunk.
Other metadata (mode and modTime, but not file size) comes from the initial
chunk's header block. For non-initial chunks, the mode must be `"644"` and the
modTime must be zero.
### Implicitly-Sized Fallback Behavior
Other TAR-reading tools and libraries, which do not understand SUITAR's
"implicitly-sized files" convention, will fall back to treating all non-initial
chunks as separate regular files. These will all have the same file name
(`"\x13sUItAR"`, due to the SUITAR magic signature), which does not satisfy the
File Name Validity rules, but this fallback name will not be presented by
decoders that understand the convention.
SUITAR encoders are discouraged from using this implicitly-sized files
convention unless the surrounding context ensures that the decoders also speak
SUITAR, not just TAR per se. This can be more likely if writing SUITAR over a
Unix pipe (with a known program on the other end), compared to writing to disk.
## Header Blocks
Like all blocks, each header block is 512 bytes long. Each header block also
starts with a 12-byte magic signature (that is not valid UTF-8), identifying
@@ -149,6 +213,7 @@ These `?` bytes are the 3-byte mode (`"644"` or `"755"`), physical size or
modTime as an 8-byte big-endian `uint64`, 6-byte checksum (see below) or 1-byte
type, which must be one of:
- `'\x00'` for `AREGTYPE`.
- `'0'` for `REGTYPE`.
- `'5'` for `DIRTYPE`, in which case mode must be `"755"` and physical size
must be all zeroes.
@@ -174,17 +239,20 @@ template (and `?` again indicates an 8-byte big-endian `uint64`):
### Header Checksum
A 512-byte header block's checksum value is simply the sum of each byte (after
converting from `uint8` to `uint32`, to avoid overflow) in the block, at
offsets in the two half-open ranges `0 .. 148` and `156 .. 512`, which excludes
the 8 bytes for the 6-byte checksum itself plus another two hard-coded bytes
`"\x00\x20"`.
A 512-byte header block's checksum value is simply 256 plus the sum of each
byte (after converting from `uint8` to `uint32`, to avoid overflow) in the
block, at offsets in the two half-open ranges `0 .. 148` and `156 .. 512`,
which excludes the 8 bytes for the 6-byte checksum itself plus another two
hard-coded bytes `"\x00\x20"`.
That "256 plus" is equivalent to summing over the entire `0 .. 512` range if
valuing the 8 checksum bytes in the range `148 .. 156` as being `'\x20'`.
That checksum value is written as a 6-byte ASCII octal number in the header.
For example, `4853` (decimal) would be encoded as `"011365"` (octal).
### Payload Blocks
## Payload Blocks
Each entry has one or more payload blocks, between its two header blocks,
containing the file or directory name. The name length (including a trailing
@@ -194,10 +262,13 @@ must range within `1 .. 4095`. Rounding up that including-a-trailing-NUL length
to a multiple of 512 gives the number of 512-byte payload blocks that contain
the name. All padding bytes in the name's final payload block must be NUL.
For `REGTYPE` entries, the second header block's physical size value gives the
reconstructed file's size and rounding that up to a multiple of 512 gives the
number of 512-byte payload blocks that contain the file contents. Again, all
padding bytes in the contents' final payload block must be NUL.
For `REGTYPE` or `AREGTYPE` entries, the name payload is followed by one or
more chunks. Concatenating the chunks' contents reconstructs the file. Only the
final chunk is `REGTYPE` and all others are `AREGTYPE`. Each chunk has one
header block and zero or more payload blocks. The header block's physical size
value gives the chunk's size and rounding that up to a multiple of 512 gives
the number of 512-byte payload blocks that contain the chunk contents. Again,
all padding bytes in the contents' final payload block must be NUL.
For other entries (`DIRTYPE` or `GNUTYPE_SPARSE`), there are no further payload
blocks after the second header block.
@@ -206,7 +277,7 @@ For `GNUTYPE_SPARSE` entries, the second header block's logical size value
gives the reconstructed file's size and its contents are all NUL bytes.
# Reference Implementation
## Reference Implementation
The [google/wuffs](https://github.com/google/wuffs) repository, which holds
this specification document, also holds a
+16 -2
View File
@@ -255,6 +255,17 @@ struct {
bool output_nia_or_crc32_digest; // Implicitly set.
bool output_nie;
bool output_uncompressed_png;
// There is no "bool output_uncompressed_apng" option. At the file format
// level, writing an Animated PNG requires knowing the total number of frames
// very early in the output (to write in the acTL chunk). In contrast,
// convert-to-nia can convert from image formats (such as GIF) that do not
// have an explicit "number of frames" record, only an implicit one (like
// NIA), calculated by parsing every frame. But convert-to-nia also does not
// assume that its input or output is rewindable. It is designed to operate
// under a SECCOMP_MODE_STRICT sandbox in O(1) memory, where it only reads
// its input or write its output forward, as non-seekable streams.
} g_flags = {0};
const char* //
@@ -1087,8 +1098,11 @@ main(int argc, char** argv) {
// ----
#if defined(WUFFS_EXAMPLE_USE_SECCOMP)
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
g_sandboxed = true;
g_sandboxed = prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT) >= 0;
if (!g_sandboxed) {
const char* msg = "SECCOMP_MODE_STRICT sandbox failed.\n";
ignore_return_value(write(STDERR_FD, msg, strlen(msg)));
}
#endif
int exit_code = compute_exit_code(main1(argc, argv));
+174 -140
View File
@@ -11,8 +11,8 @@
// ----------------
/*
gifplayer prints an ASCII representation of the GIF image read from stdin. To
play Eadweard Muybridge's iconic galloping horse animation, run:
gifplayer prints an ASCII representation of the GIF or NIE image read from
stdin. To play Eadweard Muybridge's iconic galloping horse animation, run:
$CC gifplayer.c && ./a.out < ../../test/data/muybridge.gif; rm -f a.out
@@ -87,6 +87,7 @@ micros_since_start(struct timespec* now) {
#define WUFFS_CONFIG__MODULES
#define WUFFS_CONFIG__MODULE__BASE
#define WUFFS_CONFIG__MODULE__GIF
#define WUFFS_CONFIG__MODULE__NIE
// Defining the WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST (and the
// associated ETC__ALLOW_FOO) macros are optional, but can lead to smaller
@@ -116,6 +117,14 @@ micros_since_start(struct timespec* now) {
} \
} while (false)
#define TRY_STATUS(expr) \
do { \
wuffs_base__status z = expr; \
if (!wuffs_base__status__is_ok(&z)) { \
return wuffs_base__status__message(&z); \
} \
} while (false)
// Limit the input GIF image to (64 MiB - 1 byte) compressed and 4096 × 4096
// pixels uncompressed. This is a limitation of this example program (which
// uses the Wuffs standard library), not a limitation of Wuffs per se.
@@ -293,7 +302,7 @@ print_color_art(wuffs_base__pixel_buffer* pb) {
// ----
const char* //
try_allocate(wuffs_gif__decoder* dec) {
try_allocate(wuffs_base__range_ii_u64 workbuf_len) {
uint32_t width = wuffs_base__pixel_config__width(&g_ic.pixcfg);
uint32_t height = wuffs_base__pixel_config__height(&g_ic.pixcfg);
uint64_t num_pixels = ((uint64_t)width) * ((uint64_t)height);
@@ -312,13 +321,10 @@ try_allocate(wuffs_gif__decoder* dec) {
return "could not allocate prev-dst buffer";
}
wuffs_base__range_ii_u64 r = wuffs_gif__decoder__workbuf_len(dec);
if (wuffs_base__range_ii_u64__is_empty(&r)) {
if (wuffs_base__range_ii_u64__is_empty(&workbuf_len)) {
return "indeterminate work buffer length";
}
uint64_t workbuf_len_max_incl = r.max_incl;
if (workbuf_len_max_incl > 0) {
g_workbuf = wuffs_base__malloc_slice_u8(malloc, workbuf_len_max_incl);
} else if (workbuf_len.max_incl > 0) {
g_workbuf = wuffs_base__malloc_slice_u8(malloc, workbuf_len.max_incl);
if (!g_workbuf.ptr) {
return "could not allocate work buffer";
}
@@ -340,8 +346,8 @@ try_allocate(wuffs_gif__decoder* dec) {
}
const char* //
allocate(wuffs_gif__decoder* dec) {
const char* status_msg = try_allocate(dec);
allocate(wuffs_base__range_ii_u64 workbuf_len) {
const char* status_msg = try_allocate(workbuf_len);
if (status_msg) {
free(g_printbuf.ptr);
g_printbuf = wuffs_base__empty_slice_u8();
@@ -356,18 +362,160 @@ allocate(wuffs_gif__decoder* dec) {
return status_msg;
}
const char* //
set_up_before_first_play(wuffs_base__image_decoder* dec,
wuffs_base__io_buffer* src) {
wuffs_base__status dic_status =
wuffs_base__image_decoder__decode_image_config(dec, &g_ic, src);
if (!wuffs_base__status__is_ok(&dic_status)) {
return wuffs_base__status__message(&dic_status);
} else if (!wuffs_base__image_config__is_valid(&g_ic)) {
return "invalid image configuration";
}
uint32_t width = wuffs_base__pixel_config__width(&g_ic.pixcfg);
uint32_t height = wuffs_base__pixel_config__height(&g_ic.pixcfg);
if ((width > MAX_DIMENSION) || (height > MAX_DIMENSION)) {
return "image dimensions are too large";
}
// Override the source's indexed pixel format to be non-indexed.
wuffs_base__pixel_config__set(
&g_ic.pixcfg, WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL,
WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, width, height);
TRY(allocate(wuffs_base__image_decoder__workbuf_len(dec)));
wuffs_base__status sfs0_status = wuffs_base__pixel_buffer__set_from_slice(
&g_pb, &g_ic.pixcfg,
wuffs_base__make_slice_u8(g_curr_dst_buffer, g_dst_len));
if (!wuffs_base__status__is_ok(&sfs0_status)) {
return wuffs_base__status__message(&sfs0_status);
}
return NULL;
}
const char* //
play_one_frame(wuffs_base__image_decoder* dec, wuffs_base__io_buffer* src) {
wuffs_base__frame_config fc = {0};
wuffs_base__status dfc_status =
wuffs_base__image_decoder__decode_frame_config(dec, &fc, src);
if (!wuffs_base__status__is_ok(&dfc_status)) {
if (dfc_status.repr == wuffs_base__note__end_of_data) {
return wuffs_base__note__end_of_data;
}
return wuffs_base__status__message(&dfc_status);
}
if (wuffs_base__frame_config__index(&fc) == 0) {
wuffs_base__color_u32_argb_premul background_color =
wuffs_base__frame_config__background_color(&fc);
size_t n = g_dst_len / sizeof(wuffs_base__color_u32_argb_premul);
uint8_t* p = g_curr_dst_buffer;
for (size_t i = 0; i < n; i++) {
wuffs_base__poke_u32le__no_bounds_check(p, background_color);
p += sizeof(wuffs_base__color_u32_argb_premul);
}
}
switch (wuffs_base__frame_config__disposal(&fc)) {
case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS: {
memcpy(g_prev_dst_buffer, g_curr_dst_buffer, g_dst_len);
break;
}
}
wuffs_base__status decode_frame_status =
wuffs_base__image_decoder__decode_frame(
dec, &g_pb, src,
wuffs_base__frame_config__overwrite_instead_of_blend(&fc)
? WUFFS_BASE__PIXEL_BLEND__SRC
: WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
g_workbuf, NULL);
if (decode_frame_status.repr == wuffs_base__note__end_of_data) {
return wuffs_base__note__end_of_data;
}
size_t n = g_flags.color ? print_color_art(&g_pb) : print_ascii_art(&g_pb);
switch (wuffs_base__frame_config__disposal(&fc)) {
case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND: {
restore_background(&g_pb, wuffs_base__frame_config__bounds(&fc),
wuffs_base__frame_config__background_color(&fc));
break;
}
case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS: {
uint8_t* swap = g_curr_dst_buffer;
g_curr_dst_buffer = g_prev_dst_buffer;
g_prev_dst_buffer = swap;
wuffs_base__status sfs1_status = wuffs_base__pixel_buffer__set_from_slice(
&g_pb, &g_ic.pixcfg,
wuffs_base__make_slice_u8(g_curr_dst_buffer, g_dst_len));
if (!wuffs_base__status__is_ok(&sfs1_status)) {
return wuffs_base__status__message(&sfs1_status);
}
break;
}
}
#if defined(WUFFS_EXAMPLE_USE_TIMERS)
if (g_started) {
struct timespec now;
if (clock_gettime(CLOCK_MONOTONIC, &now)) {
return strerror(errno);
}
int64_t elapsed_micros = micros_since_start(&now);
if (g_cumulative_delay_micros > elapsed_micros) {
usleep(g_cumulative_delay_micros - elapsed_micros);
}
} else {
if (clock_gettime(CLOCK_MONOTONIC, &g_start_time)) {
return strerror(errno);
}
g_started = true;
}
#endif
fwrite(g_printbuf.ptr, sizeof(uint8_t), n, stdout);
fflush(stdout);
g_cumulative_delay_micros +=
(1000 * wuffs_base__frame_config__duration(&fc)) /
WUFFS_BASE__FLICKS_PER_MILLISECOND;
// TODO: should a zero duration mean to show this frame forever?
return wuffs_base__status__message(&decode_frame_status);
}
const char* //
play() {
wuffs_gif__decoder dec;
wuffs_base__status i_status =
wuffs_gif__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION, 0);
if (!wuffs_base__status__is_ok(&i_status)) {
return wuffs_base__status__message(&i_status);
static union {
wuffs_gif__decoder gif;
wuffs_nie__decoder nie;
} decoders;
wuffs_base__image_decoder* dec = NULL;
if (g_src_len <= 0) {
return "main: input is too short";
} else if (g_src_buffer_array[0] == 'G') {
TRY_STATUS(wuffs_gif__decoder__initialize(
&decoders.gif, sizeof decoders.gif, WUFFS_VERSION, 0));
dec =
wuffs_gif__decoder__upcast_as__wuffs_base__image_decoder(&decoders.gif);
} else if (g_src_buffer_array[0] == 'n') {
TRY_STATUS(wuffs_nie__decoder__initialize(
&decoders.nie, sizeof decoders.nie, WUFFS_VERSION, 0));
dec =
wuffs_nie__decoder__upcast_as__wuffs_base__image_decoder(&decoders.nie);
} else {
return "main: input is not GIF or NIE";
}
if (g_flags.quirk_honor_background_color) {
wuffs_gif__decoder__set_quirk(&dec, WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR,
1);
wuffs_base__image_decoder__set_quirk(
dec, WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR, 1);
}
wuffs_base__io_buffer src;
@@ -379,137 +527,23 @@ play() {
src.meta.closed = true;
if (g_first_play) {
wuffs_base__status dic_status =
wuffs_gif__decoder__decode_image_config(&dec, &g_ic, &src);
if (!wuffs_base__status__is_ok(&dic_status)) {
return wuffs_base__status__message(&dic_status);
}
if (!wuffs_base__image_config__is_valid(&g_ic)) {
return "invalid image configuration";
}
uint32_t width = wuffs_base__pixel_config__width(&g_ic.pixcfg);
uint32_t height = wuffs_base__pixel_config__height(&g_ic.pixcfg);
if ((width > MAX_DIMENSION) || (height > MAX_DIMENSION)) {
return "image dimensions are too large";
}
// Override the source's indexed pixel format to be non-indexed.
wuffs_base__pixel_config__set(
&g_ic.pixcfg, WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL,
WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, width, height);
const char* msg = allocate(&dec);
if (msg) {
return msg;
}
wuffs_base__status sfs0_status = wuffs_base__pixel_buffer__set_from_slice(
&g_pb, &g_ic.pixcfg,
wuffs_base__make_slice_u8(g_curr_dst_buffer, g_dst_len));
if (!wuffs_base__status__is_ok(&sfs0_status)) {
return wuffs_base__status__message(&sfs0_status);
}
TRY(set_up_before_first_play(dec, &src));
}
while (1) {
wuffs_base__frame_config fc = {0};
wuffs_base__status dfc_status =
wuffs_gif__decoder__decode_frame_config(&dec, &fc, &src);
if (!wuffs_base__status__is_ok(&dfc_status)) {
if (dfc_status.repr == wuffs_base__note__end_of_data) {
break;
}
return wuffs_base__status__message(&dfc_status);
}
if (wuffs_base__frame_config__index(&fc) == 0) {
wuffs_base__color_u32_argb_premul background_color =
wuffs_base__frame_config__background_color(&fc);
size_t n = g_dst_len / sizeof(wuffs_base__color_u32_argb_premul);
uint8_t* p = g_curr_dst_buffer;
for (size_t i = 0; i < n; i++) {
wuffs_base__poke_u32le__no_bounds_check(p, background_color);
p += sizeof(wuffs_base__color_u32_argb_premul);
}
}
switch (wuffs_base__frame_config__disposal(&fc)) {
case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS: {
memcpy(g_prev_dst_buffer, g_curr_dst_buffer, g_dst_len);
break;
}
}
wuffs_base__status decode_frame_status = wuffs_gif__decoder__decode_frame(
&dec, &g_pb, &src,
wuffs_base__frame_config__overwrite_instead_of_blend(&fc)
? WUFFS_BASE__PIXEL_BLEND__SRC
: WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
g_workbuf, NULL);
if (decode_frame_status.repr == wuffs_base__note__end_of_data) {
const char* msg = play_one_frame(dec, &src);
if (msg == wuffs_base__note__end_of_data) {
break;
}
size_t n = g_flags.color ? print_color_art(&g_pb) : print_ascii_art(&g_pb);
switch (wuffs_base__frame_config__disposal(&fc)) {
case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND: {
restore_background(&g_pb, wuffs_base__frame_config__bounds(&fc),
wuffs_base__frame_config__background_color(&fc));
break;
}
case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS: {
uint8_t* swap = g_curr_dst_buffer;
g_curr_dst_buffer = g_prev_dst_buffer;
g_prev_dst_buffer = swap;
wuffs_base__status sfs1_status =
wuffs_base__pixel_buffer__set_from_slice(
&g_pb, &g_ic.pixcfg,
wuffs_base__make_slice_u8(g_curr_dst_buffer, g_dst_len));
if (!wuffs_base__status__is_ok(&sfs1_status)) {
return wuffs_base__status__message(&sfs1_status);
}
break;
}
}
#if defined(WUFFS_EXAMPLE_USE_TIMERS)
if (g_started) {
struct timespec now;
if (clock_gettime(CLOCK_MONOTONIC, &now)) {
return strerror(errno);
}
int64_t elapsed_micros = micros_since_start(&now);
if (g_cumulative_delay_micros > elapsed_micros) {
usleep(g_cumulative_delay_micros - elapsed_micros);
}
} else {
if (clock_gettime(CLOCK_MONOTONIC, &g_start_time)) {
return strerror(errno);
}
g_started = true;
}
#endif
fwrite(g_printbuf.ptr, sizeof(uint8_t), n, stdout);
fflush(stdout);
g_cumulative_delay_micros +=
(1000 * wuffs_base__frame_config__duration(&fc)) /
WUFFS_BASE__FLICKS_PER_MILLISECOND;
// TODO: should a zero duration mean to show this frame forever?
if (!wuffs_base__status__is_ok(&decode_frame_status)) {
return wuffs_base__status__message(&decode_frame_status);
} else if (msg) {
return msg;
}
}
if (g_first_play) {
g_first_play = false;
g_still_image = wuffs_gif__decoder__num_decoded_frame_configs(&dec) <= 1;
g_num_loops_remaining = wuffs_gif__decoder__num_animation_loops(&dec);
g_still_image =
wuffs_base__image_decoder__num_decoded_frame_configs(dec) <= 1;
g_num_loops_remaining = wuffs_base__image_decoder__num_animation_loops(dec);
}
return NULL;
+6 -2
View File
@@ -1471,8 +1471,12 @@ main(int argc, char** argv) {
}
#if defined(WUFFS_EXAMPLE_USE_SECCOMP)
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
g_sandboxed = true;
g_sandboxed = prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT) >= 0;
if (!g_sandboxed) {
const int stderr_fd = 2;
const char* msg = "SECCOMP_MODE_STRICT sandbox failed.\n";
ignore_return_value(write(stderr_fd, msg, strlen(msg)));
}
#endif
const char* z = main1(argc, argv);
+6 -2
View File
@@ -397,8 +397,12 @@ print_crc32_digest(bool bad) {
int //
main(int argc, char** argv) {
#if defined(WUFFS_EXAMPLE_USE_SECCOMP)
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
g_sandboxed = true;
g_sandboxed = prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT) >= 0;
if (!g_sandboxed) {
const int stderr_fd = 2;
const char* msg = "SECCOMP_MODE_STRICT sandbox failed.\n";
ignore_return_value(write(stderr_fd, msg, strlen(msg)));
}
#endif
int exit_code = compute_exit_code(main1(argc, argv));
+6 -2
View File
@@ -260,8 +260,12 @@ compute_exit_code(const char* status_msg) {
int //
main(int argc, char** argv) {
#if defined(WUFFS_EXAMPLE_USE_SECCOMP)
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
g_sandboxed = true;
g_sandboxed = prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT) >= 0;
if (!g_sandboxed) {
const int stderr_fd = 2;
const char* msg = "SECCOMP_MODE_STRICT sandbox failed.\n";
ignore_return_value(write(stderr_fd, msg, strlen(msg)));
}
#endif
int exit_code = compute_exit_code(main1(argc, argv));
+3
View File
@@ -414,6 +414,9 @@ redirect:
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_CICP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CICP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
interested_in_metadata_after_the_frame = true;
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
+11 -9
View File
@@ -236,27 +236,29 @@ struct DecodeImageArgFlags {
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
// Primary Chromaticities and White Point.
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
// Coding-Independent Code Points for video signal type identification.
static constexpr uint64_t REPORT_METADATA_CICP = 0x0004;
// Exchangeable Image File Format.
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0008;
// Gamma Correction.
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0010;
// International Color Consortium Profile.
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0020;
// Key-Value Pair.
//
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
// HandleMetadata callback, the raw argument contains UTF-8 strings.
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
static constexpr uint64_t REPORT_METADATA_KVP = 0x0040;
// Modification Time.
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0080;
// Offset (2-Dimensional).
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0100;
// Physical Dimensions.
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0200;
// Standard Red Green Blue (Rendering Intent).
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0400;
// Extensible Metadata Platform.
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
static constexpr uint64_t REPORT_METADATA_XMP = 0x0800;
uint64_t repr;
};
+18 -21
View File
@@ -268,14 +268,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
uint8_t* q = s.ptr + s.len;
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
// Parse sign.
do {
@@ -288,14 +286,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
break;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
} while (0);
// Parse digits, up to (and including) a '.', 'E' or 'e'. Examples for each
@@ -347,9 +343,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
if (nd < WUFFS_PRIVATE_IMPL__HPD__DIGITS_PRECISION) {
h->digits[nd++] = (uint8_t)(*p - '0');
dp = (int32_t)nd;
} else if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
} else {
dp++;
if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
}
}
} else if (*p ==
((options &
@@ -408,14 +407,12 @@ after_sep:
after_exp:
do {
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
int32_t exp_sign = +1;
if (*p == '+') {
+45
View File
@@ -682,6 +682,13 @@ typedef struct wuffs_base__transform__output__struct {
// --------
// Various MIME types in 4/4/2 base-38 encoding, per
// doc/note/enumerated-media-types.txt
// ¡ INSERT MimeTypes.
// --------
// Quirks.
// ¡ INSERT Quirks.
@@ -1394,6 +1401,44 @@ wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {
#endif
}
// --------
static inline uint64_t //
wuffs_base__pack_u8x8le_as_u64(uint8_t a0,
uint8_t a1,
uint8_t a2,
uint8_t a3,
uint8_t a4,
uint8_t a5,
uint8_t a6,
uint8_t a7) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 8) | //
(((uint64_t)a2) << 16) | //
(((uint64_t)a3) << 24) | //
(((uint64_t)a4) << 32) | //
(((uint64_t)a5) << 40) | //
(((uint64_t)a6) << 48) | //
(((uint64_t)a7) << 56);
}
static inline uint64_t //
wuffs_base__pack_u16x4le_as_u64(uint16_t a0,
uint16_t a1,
uint16_t a2,
uint16_t a3) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 16) | //
(((uint64_t)a2) << 32) | //
(((uint64_t)a3) << 48);
}
static inline uint64_t //
wuffs_base__pack_u32x2le_as_u64(uint32_t a0, uint32_t a1) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 32);
}
// ---------------- Slices and Tables
// WUFFS_BASE__SLICE is a 1-dimensional buffer.
+2
View File
@@ -215,6 +215,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto hexadecimal;
}
goto fail_bad_argument;
} else if ((*p == 'd') || (*p == 'D')) {
p++;
@@ -225,6 +226,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto decimal;
}
goto fail_bad_argument;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {
+1 -1
View File
@@ -22,7 +22,7 @@ typedef struct wuffs_base__io_buffer_meta__struct {
} wuffs_base__io_buffer_meta;
// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus
// additional metadata.
// additional metadata. It is a linear buffer, not a circular buffer.
//
// A value with all fields zero is a valid, empty buffer.
typedef struct wuffs_base__io_buffer__struct {
+55
View File
@@ -1122,6 +1122,7 @@ typedef struct wuffs_base__more_information__struct {
inline uint32_t metadata__fourcc() const;
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
inline int32_t metadata_parsed__chrm(uint32_t component) const;
inline uint8_t metadata_parsed__cicp(uint32_t component) const;
inline uint32_t metadata_parsed__gama() const;
inline uint32_t metadata_parsed__srgb() const;
#endif // __cplusplus
@@ -1264,6 +1265,55 @@ wuffs_base__more_information__metadata_parsed__chrm(
return ((int32_t)(u << 8)) >> 8;
}
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__COLOR_PRIMARIES 0
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__TRANSFER_FUNCTION 1
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__MATRIX_COEFFICIENTS \
2
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__VIDEO_FULL_RANGE_FLAG \
3
// wuffs_base__more_information__metadata_parsed__cicp returns
// Coding-Independent Code Points values.
//
// - Component 0 is the Color Primaries.
// - Component 1 is the Transfer Function.
// - Component 2 is the Matrix Coefficients.
// - Component 3 is the Video Full Range Flag.
//
// The (CP, TF) pair is the most interesting of these four. Some examples:
//
// - (CP: 1, TF: 1) is "bt.709".
// - (CP: 1, TF: 8) is "linear-light-srgb".
// - (CP: 1, TF: 13) is "srgb".
// - (CP: 5, TF: 6) is "bt.601-pal".
// - (CP: 6, TF: 6) is "bt.601-ntsc".
// - (CP: 9, TF: 14) is "bt.2020-10-bit".
// - (CP: 9, TF: 15) is "bt.2020-12-bit".
// - (CP: 9, TF: 16) is "bt.2100-pq".
// - (CP: 9, TF: 18) is "bt.2100-hlg".
// - (CP: 11, TF: 17) is "dci-p3".
// - (CP: 12, TF: 13) is "display-p3".
// - (CP: 12, TF: 16) is "p3-d65-pq".
//
// For PNG, the MC value is always zero, as PNG uses the RGB color model. For
// H.273, valid values include 0, 1, 5, 6 and 9. See the AOMediaCodec page.
//
// For PNG, the VFRF value is 0 (for narrow range) or 1 (for full range).
//
// See:
//
// - https://github.com/AOMediaCodec/libavif/wiki/CICP
// - https://svgees.us/blog/cICP.html
// - https://www.itu.int/rec/T-REC-H.273-202407-I
// - https://www.w3.org/TR/png-3/#cICP-chunk
static inline uint8_t //
wuffs_base__more_information__metadata_parsed__cicp(
const wuffs_base__more_information* m,
uint32_t component) {
int shift = 8 * (component & 3);
return ((uint8_t)(m->x >> shift));
}
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
@@ -1328,6 +1378,11 @@ wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
}
inline uint8_t //
wuffs_base__more_information::metadata_parsed__cicp(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__cicp(this, component);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__gama() const {
return wuffs_base__more_information__metadata_parsed__gama(this);
+1 -1
View File
@@ -331,7 +331,7 @@ typedef struct wuffs_base__token_buffer_meta__struct {
} wuffs_base__token_buffer_meta;
// wuffs_base__token_buffer is a 1-dimensional buffer (a pointer and length)
// plus additional metadata.
// plus additional metadata. It is a linear buffer, not a circular buffer.
//
// A value with all fields zero is a valid, empty buffer.
typedef struct wuffs_base__token_buffer__struct {
+24 -11
View File
@@ -514,26 +514,37 @@ func (g *gen) writeBuiltinCPUArchARMCRC32(b *buffer, recv *a.Expr, method t.ID,
func (g *gen) writeBuiltinCPUArchARMNeon(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, sideEffectsOnly bool, depth uint32) error {
methodStr := method.Str(g.tm)
if strings.HasPrefix(methodStr, "make_") {
before, after, ptr := "", ")", false
before, middle, after, ptr := "", "", ")", false
if strings.HasSuffix(methodStr, "_multiple") {
after = "})"
switch methodStr {
case "make_u8x8_multiple":
before = "((uint8x8_t){"
before = "vreinterpret_u8_u64(vcreate_u64(wuffs_base__pack_u8x8le_as_u64("
after = ")))"
case "make_u16x4_multiple":
before = "((uint16x4_t){"
before = "vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64("
after = ")))"
case "make_u32x2_multiple":
before = "((uint32x2_t){"
before = "vreinterpret_u32_u64(vcreate_u64(wuffs_base__pack_u32x2le_as_u64("
after = ")))"
case "make_u64x1_multiple":
before = "((uint64x1_t){"
before = "vcreate_u64("
after = ")"
case "make_u8x16_multiple":
before = "((uint8x16_t){"
before = "vcombine_u8(vreinterpret_u8_u64(vcreate_u64(wuffs_base__pack_u8x8le_as_u64("
middle = "))), vreinterpret_u8_u64(vcreate_u64(wuffs_base__pack_u8x8le_as_u64("
after = "))))"
case "make_u16x8_multiple":
before = "((uint16x8_t){"
before = "vcombine_u16(vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64("
middle = "))), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64("
after = "))))"
case "make_u32x4_multiple":
before = "((uint32x4_t){"
before = "vcombine_u32(vreinterpret_u32_u64(vcreate_u64(wuffs_base__pack_u32x2le_as_u64("
middle = "))), vreinterpret_u32_u64(vcreate_u64(wuffs_base__pack_u32x2le_as_u64("
after = "))))"
case "make_u64x2_multiple":
before = "((uint64x2_t){"
before = "vcombine_u64(vcreate_u64("
middle = "), vcreate_u64("
after = "))"
}
} else {
switch methodStr {
@@ -563,7 +574,9 @@ func (g *gen) writeBuiltinCPUArchARMNeon(b *buffer, recv *a.Expr, method t.ID, a
}
b.writes(before)
for i, o := range args {
if i > 0 {
if (i == (len(args) / 2)) && (middle != "") {
b.writes(middle)
} else if i > 0 {
b.writes(", ")
}
if ptr {
+26
View File
@@ -316,6 +316,32 @@ func insertBaseAllPublicH(buf *buffer) error {
}
return nil
},
"// ¡ INSERT MimeTypes.\n": func(b *buffer) error {
for i, z := range builtin.MimeTypes {
if i != 0 {
b.writeb('\n')
}
strBuf := make([]byte, len(z.Name))
for i := range strBuf {
c := z.Name[i]
if ('a' <= c) && (c <= 'z') {
strBuf[i] = c &^ 0x20
} else if (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) {
strBuf[i] = c
} else {
strBuf[i] = '_'
}
}
b.printf("// base38(%q) = 0x%X_%08X\n#define WUFFS_BASE__MIME_TYPE__%s %d\n",
z.Base38String,
z.Base38Number>>32,
z.Base38Number&0xFFFFFFFF,
string(strBuf),
z.Base38Number,
)
}
return nil
},
"// ¡ INSERT Quirks.\n": func(b *buffer) error {
first := true
for _, z := range builtin.Consts {
+10
View File
@@ -32,6 +32,7 @@ var FourCCs = [...][2]string{
{"BZ2 ", "Bzip2"},
{"CBOR", "Concise Binary Object Representation"},
{"CHRM", "Primary Chromaticities and White Point"},
{"CICP", "Coding-Independent Code Points for video signal type identification"},
{"CSS ", "Cascading Style Sheets"},
{"EPS ", "Encapsulated PostScript"},
{"ETC2", "Ericsson Texture Compression 2 (iPACKMAN)"},
@@ -94,6 +95,15 @@ var FourCCs = [...][2]string{
{"ZSTD", "Zstandard"},
}
var MimeTypes = [...]struct {
Base38Number uint64
Base38String string
Name string
}{
{0x09CC62_607F1000, "appl/defl/..", "application/deflate"},
{0x09CC62_A9E37800, "appl/octe/..", "application/octet-stream"},
}
var Consts = [...]struct {
Type t.ID
Value string
+205 -40
View File
@@ -38,6 +38,8 @@ var (
errClosed = errors.New("suitar: closed")
errHeaderSize = errors.New("suitar: inconsistent Header.Size and Write length")
errHeaderTypeflag = errors.New("suitar: inconsistent Header.Typeflag for Write")
errImplicitSize = errors.New("suitar: implicit size is too large")
errWriteANonNul = errors.New("suitar: Write a non-NUL byte to a sparse entry")
)
// lenMagic makes headerBlockTemplate[:lenMagic] SUITAR's magic signature.
@@ -95,6 +97,7 @@ const (
TypeGNUSparse = 'S' // Sparse file (its contents are all NUL bytes).
typeGNULongName = 'L'
typeRegA = '\x00'
)
// Valid values for Header.Mode. The zero value is invalid.
@@ -103,6 +106,15 @@ const (
Mode755 = int64(0o755) // "rwxr-xr-x" mode bits, also known as permission bits.
)
// SizeIsImplicit can be passed in the Writer.WriteHeader's argument's
// Header.Size field to mean that the contents' size-in-bytes is not yet known,
// but is implied by the total length of the []byte passed to Writer.Write, up
// until the next call to Writer.WriteHeader or Writer.Close.
//
// When reading, the actual size is returned by Reader.NumBytesRead. Call this
// after Reader.Read has returned io.EOF and before the next Reader.Next call.
const SizeIsImplicit = int64(-1)
// IsValidHeaderName returns whether name is a valid Header.Name field value.
func IsValidHeaderName(name string) bool {
return (len(name) < 4096) &&
@@ -113,6 +125,8 @@ func IsValidHeaderName(name string) bool {
(name[len(name)-1] != '/') &&
!strings.HasPrefix(name, "./") &&
!strings.HasPrefix(name, "../") &&
!strings.HasSuffix(name, "/.") &&
!strings.HasSuffix(name, "/..") &&
!strings.Contains(name, "//") &&
!strings.Contains(name, "/./") &&
!strings.Contains(name, "/../") &&
@@ -208,9 +222,9 @@ func (b *block) isValidHeader(which int) bool {
}
// Check the mode bits.
if (b[0x0068] == '6') && (b[0x0069] == '4') && (b[0x006A] == '4') {
if (b[0x068] == '6') && (b[0x069] == '4') && (b[0x06A] == '4') {
// No-op.
} else if (b[0x0068] == '7') && (b[0x0069] == '5') && (b[0x006A] == '5') && (which == 1) {
} else if (b[0x068] == '7') && (b[0x069] == '5') && (b[0x06A] == '5') && (which == 1) {
// No-op.
} else {
return false
@@ -245,7 +259,8 @@ type Header struct {
// - Typeflag must be one of three values (TypeReg, TypeDir, TypeGNUSparse).
// In particular, it cannot be zero.
// - Name must satisfy IsValidHeaderName.
// - Size must be non-negative. It must be 0 if Typeflag is TypeDir.
// - Size must be non-negative or, if Typeflag is TypeReg, it can also be -1,
// the value of SizeIsImplicit. It must be 0 if Typeflag is TypeDir.
// - Mode must be one of two values (Mode644, Mode755). It must be Mode755 if
// Typeflag is TypeDir.
// - ModTime.Unix() must be a non-negative int64. In particular, ModTime must
@@ -272,9 +287,14 @@ func (h *Header) Valid() bool {
}
}
size := h.Size
if (size == -1) && (h.Typeflag == TypeReg) {
size = 0
}
const maxExcl = 1 << 53
m := h.ModTime.Unix()
return (0 <= h.Size) && (h.Size < maxExcl) &&
return (0 <= size) && (size < maxExcl) &&
(0 <= m) && (m < maxExcl) &&
IsValidHeaderName(h.Name)
}
@@ -289,7 +309,7 @@ type Writer struct {
err error
w io.Writer
header Header
remaining int64
remaining int64 // If negative, ^remaining is the accumulated implicit size.
bIndex int32
block block
nameBuf [4096]byte
@@ -298,9 +318,29 @@ type Writer struct {
func (w *Writer) flush() error {
if w.err != nil {
return w.err
} else if w.remaining != 0 {
} else if w.remaining < 0 {
initBlock(&w.block, TypeReg, int64(w.bIndex), Mode644, 0)
if _, err := w.w.Write(w.block[:]); err != nil {
w.err = err
return w.err
}
if w.bIndex != 0 {
end := (w.bIndex + 511) &^ 511
clear(w.nameBuf[w.bIndex:end])
if _, err := w.w.Write(w.nameBuf[:end]); err != nil {
w.err = err
return w.err
}
w.bIndex = 0
}
return nil
} else if (w.remaining != 0) && (w.header.Typeflag != TypeGNUSparse) {
w.err = errHeaderSize
return w.err
} else if w.bIndex != 0 {
clear(w.block[w.bIndex:])
if _, err := w.w.Write(w.block[:]); err != nil {
@@ -354,10 +394,6 @@ func (w *Writer) WriteHeader(h *Header) error {
}
w.remaining = w.header.Size
if w.header.Typeflag == TypeGNUSparse {
w.remaining = 0
}
return nil
}
@@ -379,6 +415,9 @@ func initBlock(b *block, typeflag byte, size int64, mode int64, modTime int64) {
physicalSize := size
if typeflag == TypeGNUSparse {
physicalSize = 0
} else if size < 0 {
physicalSize = 0
typeflag = typeRegA
}
setI64(b, 0x07C, physicalSize)
@@ -410,16 +449,92 @@ func setI64(b *block, offset int, value int64) {
func (w *Writer) Write(b []byte) (int, error) {
if w.err != nil {
return 0, w.err
} else if (w.header.Typeflag != TypeReg) && (w.header.Typeflag != TypeGNUSparse) {
}
tooMuch := (int64(len(b)) > w.remaining) && (w.remaining >= 0)
if tooMuch {
b = b[:w.remaining]
}
ret := 0
if w.remaining < 0 {
ret, w.err = w.writeImplicitlySized(b)
} else if w.header.Typeflag == TypeReg {
ret, w.err = w.writeReg(b)
} else if w.header.Typeflag == TypeGNUSparse {
ret, w.err = w.writeSparse(b)
} else {
w.err = errHeaderTypeflag
return 0, w.err
} else if len(b) == 0 {
}
w.remaining -= int64(ret)
if tooMuch && (w.err == nil) {
w.err = errHeaderSize
}
return ret, w.err
}
func (w *Writer) writeImplicitlySized(b []byte) (int, error) {
if len(b) == 0 {
return 0, nil
}
tooMuch := int64(len(b)) > w.remaining
if tooMuch {
b = b[:w.remaining]
const maxExcl = 1 << 53
if n := int64(len(b)); (n >= maxExcl) || ((n + ^w.remaining) >= maxExcl) {
return 0, errImplicitSize
}
if (w.bIndex > 0) || (len(b) < (len(w.nameBuf) - int(w.bIndex))) {
n := copy(w.nameBuf[w.bIndex:], b)
w.bIndex += int32(n)
b = b[n:]
if len(b) == 0 {
return n, nil
}
}
ret := 0
split := len(b) &^ 511
prefix, suffix := b[:split], b[split:]
if size := int64(w.bIndex) + int64(len(prefix)); size > 0 {
initBlock(&w.block, typeRegA, size, Mode644, 0)
if _, err := w.w.Write(w.block[:]); err != nil {
return ret, err
}
}
if w.bIndex > 0 {
n, err := w.w.Write(w.nameBuf[:w.bIndex])
ret += n
if err != nil {
return ret, err
}
w.bIndex = 0
}
if len(prefix) > 0 {
n, err := w.w.Write(prefix)
ret += n
if err != nil {
return ret, err
}
}
if len(suffix) > 0 {
w.bIndex = int32(copy(w.nameBuf[:], suffix))
ret += len(suffix)
}
return ret, nil
}
func (w *Writer) writeReg(b []byte) (int, error) {
if len(b) == 0 {
return 0, nil
}
ret := 0
@@ -430,17 +545,14 @@ func (w *Writer) Write(b []byte) (int, error) {
if len(prefix) > 0 {
n, err := w.w.Write(prefix)
w.remaining -= int64(n)
ret += n
if err != nil {
w.err = err
break
return ret, err
}
}
if len(suffix) > 0 {
w.bIndex = int32(copy(w.block[:], suffix))
w.remaining -= int64(w.bIndex)
ret += int(w.bIndex)
}
@@ -450,24 +562,27 @@ func (w *Writer) Write(b []byte) (int, error) {
n := copy(w.block[w.bIndex:], b)
w.bIndex += int32(n)
w.remaining -= int64(n)
ret += n
b = b[n:]
if int(w.bIndex) < len(w.block) {
continue
} else if _, err := w.w.Write(w.block[:]); err != nil {
w.err = err
break
return ret, err
}
w.bIndex = 0
}
if tooMuch && (w.err == nil) {
w.err = errHeaderSize
}
return ret, nil
}
return ret, w.err
func (w *Writer) writeSparse(b []byte) (int, error) {
for _, c := range b {
if c != 0 {
return 0, errWriteANonNul
}
}
return 0, nil
}
// Close satisfies io.Closer. It closes the entire archive, not just one entry.
@@ -491,18 +606,21 @@ func NewReader(r io.Reader) *Reader {
// Reader provides sequential reading of a SUITAR archive.
type Reader struct {
err error
r io.Reader
remaining int64
numPadding int32
sparse bool
block block
nameBuf [4096]byte
err error
r io.Reader
remaining int64
numBytesRead int64
numPadding int32
sparse bool
sizeIsImplicit bool
block block
nameBuf [4096]byte
}
// Next advances to the next entry in the SUITAR archive, preparing to read the
// file's contents (as r is also an io.Reader).
func (r *Reader) Next() (Header, error) {
r.numBytesRead = 0
if r.err != nil {
return Header{}, r.err
} else if r.remaining > 0 {
@@ -515,7 +633,7 @@ func (r *Reader) Next() (Header, error) {
if _, err := readFullNoEOF(r.r, r.block[:]); err != nil {
r.err = err
return Header{}, r.err
} else if r.block[0x09C] == 0 {
} else if r.block[0] == 0 {
// SUITAR ends with 2 blocks (1024 bytes) of zeroes.
if !isAllZeroes(r.block[:]) {
r.err = errBadHeader
@@ -550,16 +668,23 @@ func (r *Reader) Next() (Header, error) {
}
if _, err := readFullNoEOF(r.r, r.block[:0x200]); err != nil {
r.err = err
return Header{}, err
}
typeflag, size, mode, modTime, err := parseBlock1(&r.block)
if err != nil {
r.err = err
return Header{}, err
}
r.remaining = size
r.numPadding = int32(roundUp512(uint64(size)) - uint64(size))
r.sparse = typeflag == TypeGNUSparse
r.sizeIsImplicit = typeflag == typeRegA
if r.sizeIsImplicit {
typeflag = TypeReg
size = SizeIsImplicit
}
return Header{
Typeflag: typeflag,
@@ -592,7 +717,7 @@ func parseBlock1(b *block) (byte, int64, int64, int64, error) {
}
typeflag := b[0x09C]
if (typeflag != TypeReg) && (typeflag != TypeDir) && (typeflag != TypeGNUSparse) {
if (typeflag != TypeReg) && (typeflag != TypeDir) && (typeflag != TypeGNUSparse) && (typeflag != typeRegA) {
return 0, 0, 0, 0, errBadHeader
}
@@ -630,15 +755,45 @@ func parseBlock1(b *block) (byte, int64, int64, int64, error) {
// Read satisfies io.Reader.
func (r *Reader) Read(b []byte) (int, error) {
n, err := r.read(b)
r.numBytesRead += int64(n)
return n, err
}
func (r *Reader) read(b []byte) (int, error) {
if r.err != nil {
return 0, r.err
} else if r.remaining == 0 {
return 0, io.EOF
} else if len(b) == 0 {
return 0, nil
}
for r.remaining == 0 {
if !r.sizeIsImplicit {
return 0, io.EOF
}
if _, err := readFullNoEOF(r.r, r.block[:0x200]); err != nil {
r.err = err
return 0, err
}
typeflag, size, mode, modTime, err := parseBlock1(&r.block)
if err != nil {
r.err = err
return 0, err
} else if ((typeflag != TypeReg) && (typeflag != typeRegA)) || (mode != Mode644) || (modTime != 0) {
r.err = errBadHeader
return 0, err
} else if (r.numBytesRead + size) >= (1 << 53) {
r.err = errImplicitSize
return 0, err
}
r.remaining = size
r.numPadding = int32(roundUp512(uint64(size)) - uint64(size))
r.sizeIsImplicit = typeflag == typeRegA
}
b = b[:int(min(r.remaining, int64(len(b))))]
if len(b) == 0 {
return 0, nil
}
if r.sparse {
n := len(b)
clear(b)
@@ -669,7 +824,11 @@ func (r *Reader) Read(b []byte) (int, error) {
r.numPadding = 0
}
if (err == nil) || (err == io.EOF) {
return n, io.EOF
if r.sizeIsImplicit {
return n, nil
} else {
return n, io.EOF
}
}
} else if err == io.EOF {
@@ -679,3 +838,9 @@ func (r *Reader) Read(b []byte) (int, error) {
r.err = err
return n, r.err
}
// NumBytesRead returns the number of bytes read by all previous Reader.Read
// calls. The counter resets to zero on each Reader.Next call.
func (r *Reader) NumBytesRead() int64 {
return r.numBytesRead
}
+233 -65
View File
@@ -17,7 +17,9 @@ import (
"fmt"
"hash/crc32"
"io"
"math/rand"
"os"
"reflect"
"testing"
"time"
)
@@ -31,8 +33,12 @@ func (c *crcWriter) Write(b []byte) (int, error) {
return len(b), nil
}
func testWriter(tt *testing.T, sparse bool) {
f, err := os.Open("../../test/data/archive.tar")
func testWriter(tt *testing.T, sparse bool, implicit bool) {
srcFilename := "../../test/data/archive.tar"
if implicit {
srcFilename = "../../test/data/various-peacocks.dense.suitar"
}
f, err := os.Open(srcFilename)
if err != nil {
tt.Fatalf("os.Open: %v", err)
}
@@ -50,10 +56,15 @@ func testWriter(tt *testing.T, sparse bool) {
tt.Fatalf("Next: %v", err)
}
size := tHeader.Size
if implicit {
size = SizeIsImplicit
}
sHeader := &Header{
Typeflag: tHeader.Typeflag,
Name: tHeader.Name,
Size: tHeader.Size,
Size: size,
Mode: tHeader.Mode,
ModTime: tHeader.ModTime,
}
@@ -78,11 +89,11 @@ func testWriter(tt *testing.T, sparse bool) {
}
got := buf.Bytes()
wantFilename := "../../test/data/archive"
wantFilename := "../../test/data/archive.dense.suitar"
if sparse {
wantFilename += ".sparse.suitar"
} else {
wantFilename += ".dense.suitar"
wantFilename = "../../test/data/archive.sparse.suitar"
} else if implicit {
wantFilename = "../../test/data/various-peacocks.implicit.suitar"
}
want, err := os.ReadFile(wantFilename)
if err != nil {
@@ -180,16 +191,17 @@ func testReader(tt *testing.T, sparse bool, ignore bool) {
}
}
func TestWriterDense(tt *testing.T) { testWriter(tt, false) }
func TestWriterSparse(tt *testing.T) { testWriter(tt, true) }
func TestWriterDense(tt *testing.T) { testWriter(tt, false, false) }
func TestWriterSparse(tt *testing.T) { testWriter(tt, true, false) }
func TestWriterImplicit(tt *testing.T) { testWriter(tt, false, true) }
func TestReaderDenseCheck(tt *testing.T) { testReader(tt, false, false) }
func TestReaderDenseIgnore(tt *testing.T) { testReader(tt, false, true) }
func TestReaderSparseCheck(tt *testing.T) { testReader(tt, true, false) }
func TestReaderSparseIgnore(tt *testing.T) { testReader(tt, true, true) }
// cappedWriter returns an error once the total number of bytes written would
// exceed limit, so that a Writer which runs away fails this test instead of
// hanging it.
// exceed limit, so that a buggy Writer (which would otherwise loop forever)
// instead fails the surrounding test.
type cappedWriter struct {
buf bytes.Buffer
limit int
@@ -204,10 +216,10 @@ func (w *cappedWriter) Write(b []byte) (int, error) {
var errCappedWriter = errors.New("suitar_test: capped writer")
// writeOneFile returns a SUITAR archive holding a single file whose contents
// are size bytes long, written in chunks of chunk bytes (or all at once if
// chunk is non-positive).
func writeOneFile(tt *testing.T, size int, chunk int) []byte {
// writeOneFileChunked returns a SUITAR archive holding a single file whose
// contents are size bytes long, written in chunks of chunk bytes (or all at
// once if chunk is non-positive).
func writeOneFileChunked(tt *testing.T, size int, chunk int) []byte {
tt.Helper()
cw := &cappedWriter{limit: 0x10000}
@@ -217,25 +229,25 @@ func writeOneFile(tt *testing.T, size int, chunk int) []byte {
Name: "file.bin",
Size: int64(size),
Mode: Mode644,
ModTime: time.Unix(0x5E3A5C50, 0),
ModTime: time.Unix(12345678, 0),
})
if err != nil {
tt.Fatalf("size=%d chunk=%d: WriteHeader: %v", size, chunk, err)
}
pix := make([]byte, size)
for i := range pix {
pix[i] = byte(i)
contents := make([]byte, size)
for i := range contents {
contents[i] = byte(i)
}
if chunk <= 0 {
if _, err := w.Write(pix); err != nil {
if _, err := w.Write(contents); err != nil {
tt.Fatalf("size=%d chunk=%d: Write: %v", size, chunk, err)
}
} else {
for i := 0; i < size; i += chunk {
j := min(i+chunk, size)
if _, err := w.Write(pix[i:j]); err != nil {
if _, err := w.Write(contents[i:j]); err != nil {
tt.Fatalf("size=%d chunk=%d: Write[%d:%d]: %v", size, chunk, i, j, err)
}
}
@@ -248,15 +260,13 @@ func writeOneFile(tt *testing.T, size int, chunk int) []byte {
}
// TestWriterChunked checks that how the file contents are split up over Write
// calls doesn't matter, as long as the total is Header.Size bytes long. A
// chunk size that isn't a multiple of 512 used to loop forever, writing
// 512-byte blocks non-stop, and also to duplicate one 512-byte block.
// calls doesn't matter, as long as the total is Header.Size bytes long.
func TestWriterChunked(tt *testing.T) {
for _, size := range []int{0, 1, 300, 511, 512, 513, 700, 1000, 1024, 5000} {
want := writeOneFile(tt, size, 0)
want := writeOneFileChunked(tt, size, 0)
for _, chunk := range []int{1, 100, 300, 511, 512, 700, 1024} {
if got := writeOneFile(tt, size, chunk); !bytes.Equal(got, want) {
if got := writeOneFileChunked(tt, size, chunk); !bytes.Equal(got, want) {
tt.Fatalf("size=%d chunk=%d: chunk size changed the archive bytes", size, chunk)
}
}
@@ -287,62 +297,220 @@ func TestWriterChunked(tt *testing.T) {
}
}
// TestWriterDir checks that a directory entry, which has no contents, can be
// written and read back.
func TestWriterDir(tt *testing.T) {
// TestWriteNonRegular checks that entries (including TypeDir entries which
// have no contents and TypeGNUSparse entries which have all-NUL contents) can
// be written and read back.
func TestWriteNonRegular(tt *testing.T) {
headers := []Header{{
Typeflag: TypeDir,
Name: "a/b",
Mode: Mode755,
ModTime: time.Unix(12345601, 0),
}, {
Typeflag: TypeReg,
Name: "a/b/c.txt",
Size: 5,
Mode: Mode644,
ModTime: time.Unix(12345602, 0),
}, {
Typeflag: TypeGNUSparse,
Name: "sparse0.bin",
Size: 3,
Mode: Mode644,
ModTime: time.Unix(123000, 0),
}, {
Typeflag: TypeGNUSparse,
Name: "sparse1.bin",
Size: 3,
Mode: Mode644,
ModTime: time.Unix(123001, 0),
}, {
Typeflag: TypeGNUSparse,
Name: "sparse3.bin",
Size: 3,
Mode: Mode644,
ModTime: time.Unix(123002, 0),
}}
contents := map[string]string{
"a/b/c.txt": "hello",
"sparse0.bin": "\x00\x00\x00",
"sparse1.bin": "\x00\x00\x00",
"sparse3.bin": "\x00\x00\x00",
}
buf := bytes.Buffer{}
w := NewWriter(&buf)
for _, h := range []*Header{
{
Typeflag: TypeDir,
Name: "a/b",
Mode: Mode755,
ModTime: time.Unix(0x5E3A5C50, 0),
},
{
Typeflag: TypeReg,
Name: "a/b/c.txt",
Size: 5,
Mode: Mode644,
ModTime: time.Unix(0x5E3A5C50, 0),
},
} {
if err := w.WriteHeader(h); err != nil {
for _, h := range headers {
if err := w.WriteHeader(&h); err != nil {
tt.Fatalf("WriteHeader(%q): %v", h.Name, err)
}
if h.Typeflag == TypeReg {
if _, err := w.Write([]byte("hello")); err != nil {
tt.Fatalf("Write: %v", err)
}
content, ok := contents[h.Name]
if !ok {
continue
} else if h.Name == "sparse0.bin" {
// It's OK, for TypeGNUSparse, to Write no bytes.
continue
} else if h.Name == "sparse1.bin" {
// It's OK, for TypeGNUSparse, to Write some but not all of the
// Size bytes, provided that what you're writing are NUL bytes.
content = content[:1]
} else if h.Name == "sparse3.bin" {
// No-op, going on to Write all 3 explicit NUL bytes.
}
if _, err := w.Write([]byte(content)); err != nil {
tt.Fatalf("Write(%q): %v", h.Name, err)
}
}
if err := w.Close(); err != nil {
tt.Fatalf("Close: %v", err)
}
r := NewReader(bytes.NewReader(buf.Bytes()))
for _, want := range []struct {
typeflag byte
name string
contents string
}{
{TypeDir, "a/b", ""},
{TypeReg, "a/b/c.txt", "hello"},
} {
h, err := r.Next()
r := NewReader(&buf)
for _, hWant := range headers {
hGot, err := r.Next()
if err != nil {
tt.Fatalf("Next: %v", err)
} else if (h.Typeflag != want.typeflag) || (h.Name != want.name) {
tt.Fatalf("got T:'%c' N:%s, want T:'%c' N:%s",
h.Typeflag, h.Name, want.typeflag, want.name)
} else if !reflect.DeepEqual(hGot, hWant) {
tt.Fatalf("got vs want\n%#v\n%#v", hGot, hWant)
}
if got, err := io.ReadAll(r); err != nil {
if readAll, err := io.ReadAll(r); err != nil {
tt.Fatalf("ReadAll: %v", err)
} else if string(got) != want.contents {
tt.Fatalf("N:%s: got %q, want %q", want.name, got, want.contents)
} else if rGot, rWant := string(readAll), contents[hGot.Name]; rGot != rWant {
tt.Fatalf("N:%s: got %q, want %q", hGot.Name, rGot, rWant)
}
}
if _, err := r.Next(); err != io.EOF {
tt.Fatalf("Next after the last entry: %v", err)
}
}
func TestWriteANonNUL(tt *testing.T) {
buf := bytes.Buffer{}
w := NewWriter(&buf)
if err := w.WriteHeader(&Header{
Typeflag: TypeGNUSparse,
Name: "example.dat",
Size: 5,
Mode: Mode644,
ModTime: time.Unix(0, 0),
}); err != nil {
tt.Fatalf("WriteHeader: %v", err)
}
if _, err := w.Write([]byte("Lorem")); err != errWriteANonNul {
tt.Fatalf("Write: got %v, want %v", err, errWriteANonNul)
}
}
func testWriteTooMuch(tt *testing.T, typeflag byte) {
for i := 8; i <= 12; i++ {
buf := bytes.Buffer{}
w := NewWriter(&buf)
if err := w.WriteHeader(&Header{
Typeflag: typeflag,
Name: "example.dat",
Size: 10,
Mode: Mode644,
ModTime: time.Unix(0, 0),
}); err != nil {
tt.Fatalf("WriteHeader: %v", err)
}
errWant := error(nil)
if i > 10 {
errWant = errHeaderSize
}
if _, errGot := w.Write(make([]byte, i)); errGot != errWant {
tt.Fatalf("i=%d: Write: got %v, want %v", i, errGot, errWant)
}
}
}
func TestWriteTooMuchRegular(tt *testing.T) { testWriteTooMuch(tt, TypeReg) }
func TestWriteTooMuchSparse(tt *testing.T) { testWriteTooMuch(tt, TypeGNUSparse) }
func TestSizeIsImplicit(tt *testing.T) {
pi, err := os.ReadFile("../../test/data/pi.txt")
if err != nil {
tt.Fatalf("ReadFile: %v", err)
}
writeSizes := []int{
1, 2, 3, 4,
10, 20, 50, 100,
250, 251, 252, 253,
254, 255, 256, 257,
401, 402, 403, 404,
510, 511, 512, 513,
1024, 1234, 4094, 4095,
4096, 4097, 4098, -1,
}
totalSizes := []int(nil)
buf := bytes.Buffer{}
sWriter := NewWriter(&buf)
rng := rand.New(rand.NewSource(0))
for i := range 100 {
if err := sWriter.WriteHeader(&Header{
Typeflag: TypeReg,
Name: fmt.Sprintf("%03d.dat", i),
Size: SizeIsImplicit,
Mode: Mode644,
ModTime: time.Unix(0, 0),
}); err != nil {
tt.Fatalf("WriteHeader: %v", err)
}
totalSize := 0
for range 20 {
writeSize := min(writeSizes[rng.Intn(len(writeSizes))], len(pi)-totalSize)
if writeSize <= 0 {
break
}
if _, err := sWriter.Write(pi[totalSize : totalSize+writeSize]); err != nil {
tt.Fatalf("Write: %v", err)
}
totalSize += writeSize
}
totalSizes = append(totalSizes, totalSize)
}
if err := sWriter.Close(); err != nil {
tt.Fatalf("Close: %v", err)
}
sReader := NewReader(&buf)
for i, totalSize := range totalSizes {
sHeader, err := sReader.Next()
if err == io.EOF {
break
} else if err != nil {
tt.Fatalf("Next: %v", err)
} else if sHeader.Size != SizeIsImplicit {
tt.Fatalf("sHeader.Size: got %d, want %d", sHeader.Size, SizeIsImplicit)
} else if want := fmt.Sprintf("%03d.dat", i); sHeader.Name != want {
tt.Fatalf("sHeader.Name: got %q, want %q", sHeader.Name, want)
}
got, err := io.ReadAll(sReader)
if err != nil {
tt.Fatalf("ReadAll: %v", err)
} else if len(got) != totalSize {
tt.Fatalf("bytes read: got %d, want %d", len(got), totalSize)
} else if !bytes.Equal(got, pi[:totalSize]) {
tt.Fatalf("bytes read: contents differ")
} else if n := sReader.NumBytesRead(); n != int64(totalSize) {
tt.Fatalf("NumBytesRead: got %d, want %d", n, totalSize)
}
}
}
+1 -2
View File
@@ -764,13 +764,12 @@ func (e *AnimationEncoder) EncodeFrame(
fType |= frameTypeBitLastFrame
}
ej := e.encodeFrameHeader(w, delayNumerator, delayDenominator)
ej := e.encodeFrameHeader(delayNumerator, delayDenominator)
return e.enc.encodeFramePayload(
w, fType, &e.seqNum, e.depth, e.colorType, int(e.width), int(e.height), pix, stride, ej)
}
func (e *AnimationEncoder) encodeFrameHeader(
w io.Writer,
delayNumerator uint16,
delayDenominator uint16) int {
+272 -46
View File
@@ -782,6 +782,9 @@ typedef struct wuffs_base__transform__output__struct {
// Primary Chromaticities and White Point.
#define WUFFS_BASE__FOURCC__CHRM 0x4348524D
// Coding-Independent Code Points for video signal type identification.
#define WUFFS_BASE__FOURCC__CICP 0x43494350
// Cascading Style Sheets.
#define WUFFS_BASE__FOURCC__CSS 0x43535320
@@ -964,6 +967,17 @@ typedef struct wuffs_base__transform__output__struct {
// --------
// Various MIME types in 4/4/2 base-38 encoding, per
// doc/note/enumerated-media-types.txt
// base38("appl/defl/..") = 0x9CC62_607F1000
#define WUFFS_BASE__MIME_TYPE__APPLICATION_DEFLATE 2757997688197120
// base38("appl/octe/..") = 0x9CC62_A9E37800
#define WUFFS_BASE__MIME_TYPE__APPLICATION_OCTET_STREAM 2757998919514112
// --------
// Quirks.
#define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1
@@ -1680,6 +1694,44 @@ wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {
#endif
}
// --------
static inline uint64_t //
wuffs_base__pack_u8x8le_as_u64(uint8_t a0,
uint8_t a1,
uint8_t a2,
uint8_t a3,
uint8_t a4,
uint8_t a5,
uint8_t a6,
uint8_t a7) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 8) | //
(((uint64_t)a2) << 16) | //
(((uint64_t)a3) << 24) | //
(((uint64_t)a4) << 32) | //
(((uint64_t)a5) << 40) | //
(((uint64_t)a6) << 48) | //
(((uint64_t)a7) << 56);
}
static inline uint64_t //
wuffs_base__pack_u16x4le_as_u64(uint16_t a0,
uint16_t a1,
uint16_t a2,
uint16_t a3) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 16) | //
(((uint64_t)a2) << 32) | //
(((uint64_t)a3) << 48);
}
static inline uint64_t //
wuffs_base__pack_u32x2le_as_u64(uint32_t a0, uint32_t a1) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 32);
}
// ---------------- Slices and Tables
// WUFFS_BASE__SLICE is a 1-dimensional buffer.
@@ -3175,6 +3227,7 @@ typedef struct wuffs_base__more_information__struct {
inline uint32_t metadata__fourcc() const;
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
inline int32_t metadata_parsed__chrm(uint32_t component) const;
inline uint8_t metadata_parsed__cicp(uint32_t component) const;
inline uint32_t metadata_parsed__gama() const;
inline uint32_t metadata_parsed__srgb() const;
#endif // __cplusplus
@@ -3317,6 +3370,55 @@ wuffs_base__more_information__metadata_parsed__chrm(
return ((int32_t)(u << 8)) >> 8;
}
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__COLOR_PRIMARIES 0
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__TRANSFER_FUNCTION 1
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__MATRIX_COEFFICIENTS \
2
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__VIDEO_FULL_RANGE_FLAG \
3
// wuffs_base__more_information__metadata_parsed__cicp returns
// Coding-Independent Code Points values.
//
// - Component 0 is the Color Primaries.
// - Component 1 is the Transfer Function.
// - Component 2 is the Matrix Coefficients.
// - Component 3 is the Video Full Range Flag.
//
// The (CP, TF) pair is the most interesting of these four. Some examples:
//
// - (CP: 1, TF: 1) is "bt.709".
// - (CP: 1, TF: 8) is "linear-light-srgb".
// - (CP: 1, TF: 13) is "srgb".
// - (CP: 5, TF: 6) is "bt.601-pal".
// - (CP: 6, TF: 6) is "bt.601-ntsc".
// - (CP: 9, TF: 14) is "bt.2020-10-bit".
// - (CP: 9, TF: 15) is "bt.2020-12-bit".
// - (CP: 9, TF: 16) is "bt.2100-pq".
// - (CP: 9, TF: 18) is "bt.2100-hlg".
// - (CP: 11, TF: 17) is "dci-p3".
// - (CP: 12, TF: 13) is "display-p3".
// - (CP: 12, TF: 16) is "p3-d65-pq".
//
// For PNG, the MC value is always zero, as PNG uses the RGB color model. For
// H.273, valid values include 0, 1, 5, 6 and 9. See the AOMediaCodec page.
//
// For PNG, the VFRF value is 0 (for narrow range) or 1 (for full range).
//
// See:
//
// - https://github.com/AOMediaCodec/libavif/wiki/CICP
// - https://svgees.us/blog/cICP.html
// - https://www.itu.int/rec/T-REC-H.273-202407-I
// - https://www.w3.org/TR/png-3/#cICP-chunk
static inline uint8_t //
wuffs_base__more_information__metadata_parsed__cicp(
const wuffs_base__more_information* m,
uint32_t component) {
int shift = 8 * (component & 3);
return ((uint8_t)(m->x >> shift));
}
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
@@ -3381,6 +3483,11 @@ wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
}
inline uint8_t //
wuffs_base__more_information::metadata_parsed__cicp(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__cicp(this, component);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__gama() const {
return wuffs_base__more_information__metadata_parsed__gama(this);
@@ -3407,7 +3514,7 @@ typedef struct wuffs_base__io_buffer_meta__struct {
} wuffs_base__io_buffer_meta;
// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus
// additional metadata.
// additional metadata. It is a linear buffer, not a circular buffer.
//
// A value with all fields zero is a valid, empty buffer.
typedef struct wuffs_base__io_buffer__struct {
@@ -4027,7 +4134,7 @@ typedef struct wuffs_base__token_buffer_meta__struct {
} wuffs_base__token_buffer_meta;
// wuffs_base__token_buffer is a 1-dimensional buffer (a pointer and length)
// plus additional metadata.
// plus additional metadata. It is a linear buffer, not a circular buffer.
//
// A value with all fields zero is a valid, empty buffer.
typedef struct wuffs_base__token_buffer__struct {
@@ -13906,6 +14013,7 @@ struct wuffs_png__decoder__struct {
uint64_t f_pass_workbuf_length;
uint8_t f_call_sequence;
bool f_report_metadata_chrm;
bool f_report_metadata_cicp;
bool f_report_metadata_exif;
bool f_report_metadata_gama;
bool f_report_metadata_iccp;
@@ -13918,6 +14026,7 @@ struct wuffs_png__decoder__struct {
uint8_t f_interlace_pass;
bool f_seen_actl;
bool f_seen_chrm;
bool f_seen_cicp;
bool f_seen_fctl;
bool f_seen_exif;
bool f_seen_gama;
@@ -13983,6 +14092,7 @@ struct wuffs_png__decoder__struct {
uint32_t p_decode_other_chunk;
uint32_t p_decode_actl;
uint32_t p_decode_chrm;
uint32_t p_decode_cicp;
uint32_t p_decode_fctl;
uint32_t p_decode_gama;
uint32_t p_decode_iccp;
@@ -14025,6 +14135,9 @@ struct wuffs_png__decoder__struct {
struct {
uint64_t scratch;
} s_decode_chrm;
struct {
uint64_t scratch;
} s_decode_cicp;
struct {
uint32_t v_x0;
uint32_t v_x1;
@@ -18018,27 +18131,29 @@ struct DecodeImageArgFlags {
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
// Primary Chromaticities and White Point.
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
// Coding-Independent Code Points for video signal type identification.
static constexpr uint64_t REPORT_METADATA_CICP = 0x0004;
// Exchangeable Image File Format.
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0008;
// Gamma Correction.
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0010;
// International Color Consortium Profile.
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0020;
// Key-Value Pair.
//
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
// HandleMetadata callback, the raw argument contains UTF-8 strings.
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
static constexpr uint64_t REPORT_METADATA_KVP = 0x0040;
// Modification Time.
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0080;
// Offset (2-Dimensional).
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0100;
// Physical Dimensions.
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0200;
// Standard Red Green Blue (Rendering Intent).
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0400;
// Extensible Metadata Platform.
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
static constexpr uint64_t REPORT_METADATA_XMP = 0x0800;
uint64_t repr;
};
@@ -21553,14 +21668,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
uint8_t* q = s.ptr + s.len;
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
// Parse sign.
do {
@@ -21573,14 +21686,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
break;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
} while (0);
// Parse digits, up to (and including) a '.', 'E' or 'e'. Examples for each
@@ -21632,9 +21743,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
if (nd < WUFFS_PRIVATE_IMPL__HPD__DIGITS_PRECISION) {
h->digits[nd++] = (uint8_t)(*p - '0');
dp = (int32_t)nd;
} else if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
} else {
dp++;
if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
}
}
} else if (*p ==
((options &
@@ -21693,14 +21807,12 @@ after_sep:
after_exp:
do {
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
int32_t exp_sign = +1;
if (*p == '+') {
@@ -23470,6 +23582,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto hexadecimal;
}
goto fail_bad_argument;
} else if ((*p == 'd') || (*p == 'D')) {
p++;
@@ -23480,6 +23593,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto decimal;
}
goto fail_bad_argument;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {
@@ -35949,14 +36063,14 @@ wuffs_adler32__hasher__up_arm_neon(
v_p.len = 0;
}
v_v2 = vshlq_n_u32(v_v2, 5u);
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col0), ((uint16x4_t){32u, 31u, 30u, 29u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col0), ((uint16x4_t){28u, 27u, 26u, 25u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col1), ((uint16x4_t){24u, 23u, 22u, 21u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col1), ((uint16x4_t){20u, 19u, 18u, 17u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col2), ((uint16x4_t){16u, 15u, 14u, 13u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col2), ((uint16x4_t){12u, 11u, 10u, 9u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col3), ((uint16x4_t){8u, 7u, 6u, 5u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col3), ((uint16x4_t){4u, 3u, 2u, 1u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col0), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(32u, 31u, 30u, 29u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col0), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(28u, 27u, 26u, 25u))));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col1), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(24u, 23u, 22u, 21u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col1), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(20u, 19u, 18u, 17u))));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col2), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(16u, 15u, 14u, 13u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col2), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(12u, 11u, 10u, 9u))));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col3), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(8u, 7u, 6u, 5u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col3), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(4u, 3u, 2u, 1u))));
v_sum1 = vpadd_u32(vget_low_u32(v_v1), vget_high_u32(v_v1));
v_sum2 = vpadd_u32(vget_low_u32(v_v2), vget_high_u32(v_v2));
v_sum12 = vpadd_u32(v_sum1, v_sum2);
@@ -70311,6 +70425,12 @@ wuffs_png__decoder__decode_chrm(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_png__decoder__decode_cicp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_png__decoder__decode_exif(
@@ -72856,6 +72976,25 @@ wuffs_png__decoder__decode_other_chunk(
}
self->private_impl.f_seen_chrm = true;
}
} else if (self->private_impl.f_chunk_type == 1346586979u) {
if (self->private_impl.f_report_metadata_cicp) {
if (self->private_impl.f_seen_cicp) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_png__decoder__decode_cicp(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_cicp = true;
}
} else if (self->private_impl.f_chunk_type == 1280598886u) {
if (self->private_impl.f_seen_fctl) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
@@ -72864,7 +73003,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_png__decoder__decode_fctl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72882,7 +73021,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_png__decoder__decode_gama(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72901,7 +73040,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_png__decoder__decode_iccp(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72920,7 +73059,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
status = wuffs_png__decoder__decode_srgb(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72939,7 +73078,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
status = wuffs_png__decoder__decode_trns(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72953,7 +73092,7 @@ wuffs_png__decoder__decode_other_chunk(
}
if (self->private_impl.f_metadata_fourcc == 0u) {
self->private_data.s_decode_other_chunk.scratch = self->private_impl.f_chunk_length;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
if (self->private_data.s_decode_other_chunk.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_other_chunk.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
@@ -73394,6 +73533,88 @@ wuffs_png__decoder__decode_chrm(
return status;
}
// -------- func png.decoder.decode_cicp
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_png__decoder__decode_cicp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_cicp;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 4u) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0u;
self->private_impl.f_metadata_flavor = 5u;
self->private_impl.f_metadata_fourcc = 1128874832u;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = ((uint64_t)(wuffs_base__peek_u32le__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_cicp.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_cicp.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint64_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
self->private_impl.f_metadata_x = t_0;
}
self->private_impl.f_metadata_y = 0u;
self->private_impl.f_metadata_z = 0u;
goto ok;
ok:
self->private_impl.p_decode_cicp = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_cicp = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_exif
WUFFS_BASE__GENERATED_C_CODE
@@ -75565,6 +75786,8 @@ wuffs_png__decoder__set_report_metadata(
if (a_fourcc == 1128813133u) {
self->private_impl.f_report_metadata_chrm = a_report;
} else if (a_fourcc == 1128874832u) {
self->private_impl.f_report_metadata_cicp = a_report;
} else if (a_fourcc == 1163413830u) {
self->private_impl.f_report_metadata_exif = a_report;
} else if (a_fourcc == 1195461953u) {
@@ -97050,6 +97273,9 @@ redirect:
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_CICP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CICP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
interested_in_metadata_after_the_frame = true;
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
+26 -27
View File
@@ -85,15 +85,15 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// 40445d992b97be816cd09b0460c55e6a160389f6 committed on 2026-07-11.
#define WUFFS_VERSION 0x000030005
// 55279938422060f30cd487173b98a651da075e3a committed on 2026-10-20.
#define WUFFS_VERSION 0x000030006
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 3
#define WUFFS_VERSION_PATCH 5
#define WUFFS_VERSION_PATCH 6
#define WUFFS_VERSION_PRE_RELEASE_LABEL ""
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3404
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20260711
#define WUFFS_VERSION_STRING "0.3.5+3404.20260711"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3407
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20261020
#define WUFFS_VERSION_STRING "0.3.6+3407.20261020"
// ---------------- Configuration
@@ -13794,14 +13794,12 @@ wuffs_base__private_implementation__high_prec_dec__parse(
uint8_t* q = s.ptr + s.len;
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
// Parse sign.
do {
@@ -13814,14 +13812,12 @@ wuffs_base__private_implementation__high_prec_dec__parse(
break;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
} while (0);
// Parse digits, up to (and including) a '.', 'E' or 'e'. Examples for each
@@ -13873,9 +13869,12 @@ wuffs_base__private_implementation__high_prec_dec__parse(
if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
h->digits[nd++] = (uint8_t)(*p - '0');
dp = (int32_t)nd;
} else if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
} else {
dp++;
if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
}
}
} else if (*p ==
((options &
@@ -13935,14 +13934,12 @@ after_sep:
after_exp:
do {
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
int32_t exp_sign = +1;
if (*p == '+') {
@@ -15751,6 +15748,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto hexadecimal;
}
goto fail_bad_argument;
} else if ((*p == 'd') || (*p == 'D')) {
p++;
@@ -15761,6 +15759,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto decimal;
}
goto fail_bad_argument;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {
+3088 -1208
View File
@@ -71,15 +71,15 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// f3de3336423f041ee251c3cf7f50a19b7eebb939 committed on 2026-06-23.
// 0d8b52336e4c5a27d885f62bc8c4be996a024d70 committed on 2026-10-20.
#define WUFFS_VERSION 0x000040000
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 4
#define WUFFS_VERSION_PATCH 0
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.10"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3966
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20260623
#define WUFFS_VERSION_STRING "0.4.0-alpha.10+3966.20260623"
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.12"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 4048
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20261020
#define WUFFS_VERSION_STRING "0.4.0-alpha.12+4048.20261020"
// ---------------- Private Implementation Macros Re-definition Check
@@ -783,6 +783,9 @@ typedef struct wuffs_base__transform__output__struct {
// Primary Chromaticities and White Point.
#define WUFFS_BASE__FOURCC__CHRM 0x4348524D
// Coding-Independent Code Points for video signal type identification.
#define WUFFS_BASE__FOURCC__CICP 0x43494350
// Cascading Style Sheets.
#define WUFFS_BASE__FOURCC__CSS 0x43535320
@@ -965,6 +968,17 @@ typedef struct wuffs_base__transform__output__struct {
// --------
// Various MIME types in 4/4/2 base-38 encoding, per
// doc/note/enumerated-media-types.txt
// base38("appl/defl/..") = 0x9CC62_607F1000
#define WUFFS_BASE__MIME_TYPE__APPLICATION_DEFLATE 2757997688197120
// base38("appl/octe/..") = 0x9CC62_A9E37800
#define WUFFS_BASE__MIME_TYPE__APPLICATION_OCTET_STREAM 2757998919514112
// --------
// Quirks.
#define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1
@@ -1681,6 +1695,44 @@ wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {
#endif
}
// --------
static inline uint64_t //
wuffs_base__pack_u8x8le_as_u64(uint8_t a0,
uint8_t a1,
uint8_t a2,
uint8_t a3,
uint8_t a4,
uint8_t a5,
uint8_t a6,
uint8_t a7) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 8) | //
(((uint64_t)a2) << 16) | //
(((uint64_t)a3) << 24) | //
(((uint64_t)a4) << 32) | //
(((uint64_t)a5) << 40) | //
(((uint64_t)a6) << 48) | //
(((uint64_t)a7) << 56);
}
static inline uint64_t //
wuffs_base__pack_u16x4le_as_u64(uint16_t a0,
uint16_t a1,
uint16_t a2,
uint16_t a3) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 16) | //
(((uint64_t)a2) << 32) | //
(((uint64_t)a3) << 48);
}
static inline uint64_t //
wuffs_base__pack_u32x2le_as_u64(uint32_t a0, uint32_t a1) {
return (((uint64_t)a0) << 0) | //
(((uint64_t)a1) << 32);
}
// ---------------- Slices and Tables
// WUFFS_BASE__SLICE is a 1-dimensional buffer.
@@ -1753,7 +1805,7 @@ wuffs_base__make_slice_u64(uint64_t* ptr, size_t len) {
static inline wuffs_base__slice_u8 //
wuffs_base__make_slice_u8_ij(uint8_t* ptr, size_t i, size_t j) {
wuffs_base__slice_u8 ret;
ret.ptr = ptr ? (ptr + i) : NULL;
ret.ptr = i ? (ptr + i) : ptr;
ret.len = (j >= i) ? (j - i) : 0;
return ret;
}
@@ -1761,7 +1813,7 @@ wuffs_base__make_slice_u8_ij(uint8_t* ptr, size_t i, size_t j) {
static inline wuffs_base__slice_u16 //
wuffs_base__make_slice_u16_ij(uint16_t* ptr, size_t i, size_t j) {
wuffs_base__slice_u16 ret;
ret.ptr = ptr ? (ptr + i) : NULL;
ret.ptr = i ? (ptr + i) : ptr;
ret.len = (j >= i) ? (j - i) : 0;
return ret;
}
@@ -1769,7 +1821,7 @@ wuffs_base__make_slice_u16_ij(uint16_t* ptr, size_t i, size_t j) {
static inline wuffs_base__slice_u32 //
wuffs_base__make_slice_u32_ij(uint32_t* ptr, size_t i, size_t j) {
wuffs_base__slice_u32 ret;
ret.ptr = ptr ? (ptr + i) : NULL;
ret.ptr = i ? (ptr + i) : ptr;
ret.len = (j >= i) ? (j - i) : 0;
return ret;
}
@@ -1777,7 +1829,7 @@ wuffs_base__make_slice_u32_ij(uint32_t* ptr, size_t i, size_t j) {
static inline wuffs_base__slice_u64 //
wuffs_base__make_slice_u64_ij(uint64_t* ptr, size_t i, size_t j) {
wuffs_base__slice_u64 ret;
ret.ptr = ptr ? (ptr + i) : NULL;
ret.ptr = i ? (ptr + i) : ptr;
ret.len = (j >= i) ? (j - i) : 0;
return ret;
}
@@ -1918,7 +1970,12 @@ wuffs_base__slice_u8__overlaps(wuffs_base__slice_u8 s, wuffs_base__slice_u8 t) {
static inline wuffs_base__slice_u8 //
wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {
if ((i <= SIZE_MAX) && (i <= s.len)) {
return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(s.len - i)));
// The "i ? (s.ptr + i) : s.ptr" expression is equivalent to the plain
// "s.ptr + i", except for the fact that in C (prior to C29), but not in
// C++, "NULL + 0" is, technically, undefined behavior (and triggers
// ubsan). See C29 N3322 and https://reviews.llvm.org/D67122
return wuffs_base__make_slice_u8(i ? (s.ptr + i) : s.ptr,
((size_t)(s.len - i)));
}
return wuffs_base__empty_slice_u8();
}
@@ -1942,7 +1999,12 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
uint64_t i,
uint64_t j) {
if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {
return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(j - i)));
// The "i ? (s.ptr + i) : s.ptr" expression is equivalent to the plain
// "s.ptr + i", except for the fact that in C (prior to C29), but not in
// C++, "NULL + 0" is, technically, undefined behavior (and triggers
// ubsan). See C29 N3322 and https://reviews.llvm.org/D67122
return wuffs_base__make_slice_u8(i ? (s.ptr + i) : s.ptr,
((size_t)(j - i)));
}
return wuffs_base__empty_slice_u8();
}
@@ -3166,6 +3228,7 @@ typedef struct wuffs_base__more_information__struct {
inline uint32_t metadata__fourcc() const;
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
inline int32_t metadata_parsed__chrm(uint32_t component) const;
inline uint8_t metadata_parsed__cicp(uint32_t component) const;
inline uint32_t metadata_parsed__gama() const;
inline uint32_t metadata_parsed__srgb() const;
#endif // __cplusplus
@@ -3308,6 +3371,55 @@ wuffs_base__more_information__metadata_parsed__chrm(
return ((int32_t)(u << 8)) >> 8;
}
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__COLOR_PRIMARIES 0
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__TRANSFER_FUNCTION 1
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__MATRIX_COEFFICIENTS \
2
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__VIDEO_FULL_RANGE_FLAG \
3
// wuffs_base__more_information__metadata_parsed__cicp returns
// Coding-Independent Code Points values.
//
// - Component 0 is the Color Primaries.
// - Component 1 is the Transfer Function.
// - Component 2 is the Matrix Coefficients.
// - Component 3 is the Video Full Range Flag.
//
// The (CP, TF) pair is the most interesting of these four. Some examples:
//
// - (CP: 1, TF: 1) is "bt.709".
// - (CP: 1, TF: 8) is "linear-light-srgb".
// - (CP: 1, TF: 13) is "srgb".
// - (CP: 5, TF: 6) is "bt.601-pal".
// - (CP: 6, TF: 6) is "bt.601-ntsc".
// - (CP: 9, TF: 14) is "bt.2020-10-bit".
// - (CP: 9, TF: 15) is "bt.2020-12-bit".
// - (CP: 9, TF: 16) is "bt.2100-pq".
// - (CP: 9, TF: 18) is "bt.2100-hlg".
// - (CP: 11, TF: 17) is "dci-p3".
// - (CP: 12, TF: 13) is "display-p3".
// - (CP: 12, TF: 16) is "p3-d65-pq".
//
// For PNG, the MC value is always zero, as PNG uses the RGB color model. For
// H.273, valid values include 0, 1, 5, 6 and 9. See the AOMediaCodec page.
//
// For PNG, the VFRF value is 0 (for narrow range) or 1 (for full range).
//
// See:
//
// - https://github.com/AOMediaCodec/libavif/wiki/CICP
// - https://svgees.us/blog/cICP.html
// - https://www.itu.int/rec/T-REC-H.273-202407-I
// - https://www.w3.org/TR/png-3/#cICP-chunk
static inline uint8_t //
wuffs_base__more_information__metadata_parsed__cicp(
const wuffs_base__more_information* m,
uint32_t component) {
int shift = 8 * (component & 3);
return ((uint8_t)(m->x >> shift));
}
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
@@ -3372,6 +3484,11 @@ wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
}
inline uint8_t //
wuffs_base__more_information::metadata_parsed__cicp(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__cicp(this, component);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__gama() const {
return wuffs_base__more_information__metadata_parsed__gama(this);
@@ -3398,7 +3515,7 @@ typedef struct wuffs_base__io_buffer_meta__struct {
} wuffs_base__io_buffer_meta;
// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus
// additional metadata.
// additional metadata. It is a linear buffer, not a circular buffer.
//
// A value with all fields zero is a valid, empty buffer.
typedef struct wuffs_base__io_buffer__struct {
@@ -4018,7 +4135,7 @@ typedef struct wuffs_base__token_buffer_meta__struct {
} wuffs_base__token_buffer_meta;
// wuffs_base__token_buffer is a 1-dimensional buffer (a pointer and length)
// plus additional metadata.
// plus additional metadata. It is a linear buffer, not a circular buffer.
//
// A value with all fields zero is a valid, empty buffer.
typedef struct wuffs_base__token_buffer__struct {
@@ -4377,6 +4494,10 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {
// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.
typedef uint32_t wuffs_base__color_u32_argb_premul;
// wuffs_base__color_u32_argb_nonpremul is non-premultiplied version of
// wuffs_base__color_u32_argb_premul.
typedef uint32_t wuffs_base__color_u32_argb_nonpremul;
// wuffs_base__color_u32_argb_premul__is_valid returns whether c's Red, Green
// and Blue channels are all less than or equal to its Alpha channel. c uses
// premultiplied alpha, so 50% opaque 100% saturated red is 0x7F7F_0000 and a
@@ -4596,6 +4717,21 @@ wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(
return (a << 48) | (r << 32) | (g << 16) | (b << 0);
}
static inline uint64_t //
wuffs_base__color_u64_argb_nonpremul__as__color_u64_argb_premul(
uint64_t argb_nonpremul) {
uint64_t a = 0xFFFF & (argb_nonpremul >> 48);
uint64_t r = 0xFFFF & (argb_nonpremul >> 32);
r = (r * a) / 0xFFFF;
uint64_t g = 0xFFFF & (argb_nonpremul >> 16);
g = (g * a) / 0xFFFF;
uint64_t b = 0xFFFF & (argb_nonpremul >> 0);
b = (b * a) / 0xFFFF;
return (a << 48) | (r << 32) | (g << 16) | (b << 0);
}
static inline uint8_t //
wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray(
uint64_t argb_nonpremul) {
@@ -4827,6 +4963,11 @@ typedef uint8_t wuffs_base__pixel_blend;
#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
static inline wuffs_base__pixel_blend //
wuffs_base__make_pixel_blend(uint8_t repr) {
return repr;
}
// --------
// wuffs_base__pixel_alpha_transparency is a pixel format's alpha channel
@@ -5208,13 +5349,21 @@ wuffs_base__pixel_subsampling::denominator_y(uint32_t plane) const {
//
// For CMY, C = (100% - R), M = (100% - G) and Y = (100% - B). Black (K), if
// present, then modulates the three RGB values.
//
// ----
//
// The 0x02 bit means the fourth channel is an alpha channel and, if set, then
// the 0x01 bit gives the blend mode (WUFFS_BASE__PIXEL_BLEND__SRC is 0,
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER is 1).
// clang-format off
#define WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE 0x00
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE 0x01
#define WUFFS_BASE__YCC_MODEL__RGB 0x40
#define WUFFS_BASE__YCC_MODEL__CMY 0x80
#define WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE 0x00
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE 0x04
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC 0x06
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER 0x07
#define WUFFS_BASE__YCC_MODEL__RGB 0x40
#define WUFFS_BASE__YCC_MODEL__CMY 0x80
// clang-format on
@@ -5840,15 +5989,32 @@ typedef struct wuffs_base__pixel_buffer__struct {
inline wuffs_base__slice_u8 palette_or_else(wuffs_base__slice_u8 fallback);
inline wuffs_base__pixel_format pixel_format() const;
inline wuffs_base__table_u8 plane(uint32_t p);
// Deprecated: use color_u32_argb_premul_at.
inline wuffs_base__color_u32_argb_premul color_u32_at(uint32_t x,
uint32_t y) const;
inline wuffs_base__color_u32_argb_premul color_u32_argb_premul_at(
uint32_t x,
uint32_t y) const;
// Deprecated: use set_color_u32_argb_premul_at.
inline wuffs_base__status set_color_u32_at(
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_premul color);
inline wuffs_base__status set_color_u32_argb_premul_at(
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_premul color);
// Deprecated: use set_color_u32_argb_premul_fill_rect.
inline wuffs_base__status set_color_u32_fill_rect(
wuffs_base__rect_ie_u32 rect,
wuffs_base__color_u32_argb_premul color);
inline wuffs_base__status set_color_u32_argb_premul_fill_rect(
wuffs_base__rect_ie_u32 rect,
wuffs_base__color_u32_argb_premul color);
inline wuffs_base__status set_color_u32_argb_nonpremul_at(
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_nonpremul color);
inline bool is_opaque();
#endif // __cplusplus
@@ -6043,24 +6209,44 @@ wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* pb, uint32_t p) {
return ret;
}
// Deprecated: use the second name, not the first.
#define wuffs_base__pixel_buffer__color_u32_at \
wuffs_base__pixel_buffer__color_u32_argb_premul_at
// Deprecated: use the second name, not the first.
#define wuffs_base__pixel_buffer__set_color_u32_at \
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at
// Deprecated: use the second name, not the first.
#define wuffs_base__pixel_buffer__set_color_u32_fill_rect \
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect
WUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //
wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,
uint32_t x,
uint32_t y);
wuffs_base__pixel_buffer__color_u32_argb_premul_at(
const wuffs_base__pixel_buffer* pb,
uint32_t x,
uint32_t y);
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
wuffs_base__pixel_buffer__set_color_u32_at(
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
wuffs_base__pixel_buffer* pb,
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_premul color);
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
wuffs_base__pixel_buffer__set_color_u32_fill_rect(
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
wuffs_base__pixel_buffer* pb,
wuffs_base__rect_ie_u32 rect,
wuffs_base__color_u32_argb_premul color);
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(
wuffs_base__pixel_buffer* pb,
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_nonpremul color);
WUFFS_BASE__MAYBE_STATIC bool //
wuffs_base__pixel_buffer__is_opaque(const wuffs_base__pixel_buffer* pb);
@@ -6105,7 +6291,13 @@ wuffs_base__pixel_buffer::plane(uint32_t p) {
inline wuffs_base__color_u32_argb_premul //
wuffs_base__pixel_buffer::color_u32_at(uint32_t x, uint32_t y) const {
return wuffs_base__pixel_buffer__color_u32_at(this, x, y);
return wuffs_base__pixel_buffer__color_u32_argb_premul_at(this, x, y);
}
inline wuffs_base__color_u32_argb_premul //
wuffs_base__pixel_buffer::color_u32_argb_premul_at(uint32_t x,
uint32_t y) const {
return wuffs_base__pixel_buffer__color_u32_argb_premul_at(this, x, y);
}
inline wuffs_base__status //
@@ -6113,14 +6305,42 @@ wuffs_base__pixel_buffer::set_color_u32_at(
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_premul color) {
return wuffs_base__pixel_buffer__set_color_u32_at(this, x, y, color);
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(this, x, y,
color);
}
inline wuffs_base__status //
wuffs_base__pixel_buffer::set_color_u32_argb_premul_at(
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_premul color) {
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(this, x, y,
color);
}
inline wuffs_base__status //
wuffs_base__pixel_buffer::set_color_u32_fill_rect(
wuffs_base__rect_ie_u32 rect,
wuffs_base__color_u32_argb_premul color) {
return wuffs_base__pixel_buffer__set_color_u32_fill_rect(this, rect, color);
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
this, rect, color);
}
inline wuffs_base__status //
wuffs_base__pixel_buffer::set_color_u32_argb_premul_fill_rect(
wuffs_base__rect_ie_u32 rect,
wuffs_base__color_u32_argb_premul color) {
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
this, rect, color);
}
inline wuffs_base__status //
wuffs_base__pixel_buffer::set_color_u32_argb_nonpremul_at(
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_nonpremul color) {
return wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(this, x, y,
color);
}
inline bool //
@@ -13794,6 +14014,7 @@ struct wuffs_png__decoder__struct {
uint64_t f_pass_workbuf_length;
uint8_t f_call_sequence;
bool f_report_metadata_chrm;
bool f_report_metadata_cicp;
bool f_report_metadata_exif;
bool f_report_metadata_gama;
bool f_report_metadata_iccp;
@@ -13806,6 +14027,7 @@ struct wuffs_png__decoder__struct {
uint8_t f_interlace_pass;
bool f_seen_actl;
bool f_seen_chrm;
bool f_seen_cicp;
bool f_seen_fctl;
bool f_seen_exif;
bool f_seen_gama;
@@ -13871,6 +14093,7 @@ struct wuffs_png__decoder__struct {
uint32_t p_decode_other_chunk;
uint32_t p_decode_actl;
uint32_t p_decode_chrm;
uint32_t p_decode_cicp;
uint32_t p_decode_fctl;
uint32_t p_decode_gama;
uint32_t p_decode_iccp;
@@ -13913,6 +14136,9 @@ struct wuffs_png__decoder__struct {
struct {
uint64_t scratch;
} s_decode_chrm;
struct {
uint64_t scratch;
} s_decode_cicp;
struct {
uint32_t v_x0;
uint32_t v_x1;
@@ -15458,7 +15684,9 @@ struct wuffs_thumbhash__decoder__struct {
// ---------------- Status Codes
extern const char wuffs_vp8__error__bad_quirk_source_length[];
extern const char wuffs_vp8__error__bad_quirk_width_and_height[];
extern const char wuffs_vp8__error__bad_header[];
extern const char wuffs_vp8__error__inconsistent_width_and_height[];
extern const char wuffs_vp8__error__missing_quirk_source_length[];
extern const char wuffs_vp8__error__truncated_input[];
extern const char wuffs_vp8__error__unsupported_quirk_source_length[];
@@ -15466,7 +15694,11 @@ extern const char wuffs_vp8__error__unsupported_vp8_file[];
// ---------------- Public Consts
#define WUFFS_VP8__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 553648127u
#define WUFFS_VP8__QUIRK_HAS_ALPHA_SIDE_CHANNEL 1836840960u
#define WUFFS_VP8__QUIRK_WIDTH_AND_HEIGHT 1836840961u
#define WUFFS_VP8__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 822050816u
// ---------------- Struct Declarations
@@ -15637,8 +15869,10 @@ struct wuffs_vp8__decoder__struct {
uint32_t f_mbh;
uint8_t f_call_sequence;
bool f_is_key_frame;
bool f_quirk_has_alpha_side_channel;
uint64_t f_frame_config_io_position;
uint64_t f_quirk_source_length;
uint64_t f_quirk_width_and_height;
uint32_t f_partitioned_data_length;
uint32_t f_workbuf_yuv_y_stride;
uint32_t f_workbuf_yuv_uv_stride;
@@ -16215,18 +16449,20 @@ struct wuffs_wbmp__decoder__struct {
// ---------------- Status Codes
extern const char wuffs_webp__error__bad_alph_vp8l_combination[];
extern const char wuffs_webp__error__bad_huffman_code_over_subscribed[];
extern const char wuffs_webp__error__bad_huffman_code_under_subscribed[];
extern const char wuffs_webp__error__bad_huffman_code[];
extern const char wuffs_webp__error__bad_vp8x_chunk[];
extern const char wuffs_webp__error__bad_back_reference[];
extern const char wuffs_webp__error__bad_chunk_order[];
extern const char wuffs_webp__error__bad_color_cache[];
extern const char wuffs_webp__error__bad_header[];
extern const char wuffs_webp__error__bad_transform[];
extern const char wuffs_webp__error__short_chunk[];
extern const char wuffs_webp__error__truncated_input[];
extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[];
extern const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[];
extern const char wuffs_webp__error__unsupported_webp_file[];
extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[];
// ---------------- Public Consts
@@ -16395,16 +16631,19 @@ struct wuffs_webp__decoder__struct {
wuffs_base__vtable vtable_for__wuffs_base__image_decoder;
wuffs_base__vtable null_vtable;
uint32_t f_pixfmt;
uint32_t f_width;
uint32_t f_height;
uint8_t f_call_sequence;
uint8_t f_code_length_code_lengths[19];
bool f_sub_chunk_has_padding;
bool f_is_vp8_lossy;
uint8_t f_variant;
uint8_t f_vp8x_header_flags;
uint8_t f_vp8x_alph_flags;
uint64_t f_frame_config_io_position;
uint32_t f_riff_chunk_length;
uint32_t f_rcl_remaining;
uint32_t f_sub_chunk_length;
uint32_t f_sub_chunk_type;
uint32_t f_bits;
uint32_t f_n_bits;
bool f_seen_transform[4];
@@ -16423,24 +16662,28 @@ struct wuffs_webp__decoder__struct {
uint32_t f_workbuf_offset_for_color_indexing;
wuffs_base__pixel_swizzler f_swizzler;
uint32_t p_decode_alph;
uint32_t p_decode_alph_limited;
uint32_t p_decode_huffman_groups;
uint32_t p_decode_huffman_tree;
uint32_t p_decode_huffman_tree_simple;
uint32_t p_decode_code_length_code_lengths;
uint32_t p_build_code_lengths;
uint32_t p_decode_pixels_slow;
uint32_t p_decode_image_config;
uint32_t p_do_decode_image_config;
uint32_t p_do_decode_image_config_limited;
uint32_t p_do_decode_image_config_limited_vp8l;
uint32_t p_decode_frame_config;
uint32_t p_do_decode_frame_config;
uint32_t p_decode_frame;
uint32_t p_do_decode_frame;
uint32_t p_do_decode_frame_vp8l;
uint32_t p_decode_transform;
uint32_t p_decode_color_cache_parameters;
uint32_t p_decode_hg_table;
uint32_t p_decode_pixels;
uint32_t p_decode_image_config;
uint32_t p_do_decode_image_config;
uint32_t p_do_decode_image_config_limited;
uint32_t p_do_decode_image_config_limited_vp8l;
uint32_t p_do_decode_image_config_limited_vp8x;
uint32_t p_decode_frame_config;
uint32_t p_do_decode_frame_config;
uint32_t p_decode_frame;
uint32_t p_do_decode_frame;
} private_impl;
struct {
@@ -16491,6 +16734,16 @@ struct wuffs_webp__decoder__struct {
uint32_t v_back_ref_dist_premap_minus_1;
uint64_t v_color_cache_p;
} s_decode_pixels_slow;
struct {
uint32_t v_width;
} s_do_decode_frame_vp8l;
struct {
uint32_t v_transform_type;
uint32_t v_tile_size_log2;
} s_decode_transform;
struct {
uint32_t v_tile_size_log2;
} s_decode_hg_table;
struct {
uint64_t scratch;
} s_do_decode_image_config;
@@ -16501,15 +16754,11 @@ struct wuffs_webp__decoder__struct {
uint64_t scratch;
} s_do_decode_image_config_limited_vp8l;
struct {
uint32_t v_width;
uint64_t scratch;
} s_do_decode_image_config_limited_vp8x;
struct {
uint64_t scratch;
} s_do_decode_frame;
struct {
uint32_t v_transform_type;
uint32_t v_tile_size_log2;
} s_decode_transform;
struct {
uint32_t v_tile_size_log2;
} s_decode_hg_table;
} private_data;
#ifdef __cplusplus
@@ -17809,6 +18058,8 @@ class DecodeImageCallbacks {
// should be at least len_range.min_incl, but larger allocations (up to
// len_range.max_incl) may have better performance (by using more memory).
//
// The len_range argument will satisfy !len_range.is_empty().
//
// The default AllocWorkbuf implementation allocates len_range.max_incl bytes
// of either uninitialized or zeroed memory.
virtual AllocWorkbufResult //
@@ -17881,27 +18132,29 @@ struct DecodeImageArgFlags {
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
// Primary Chromaticities and White Point.
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
// Coding-Independent Code Points for video signal type identification.
static constexpr uint64_t REPORT_METADATA_CICP = 0x0004;
// Exchangeable Image File Format.
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0008;
// Gamma Correction.
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0010;
// International Color Consortium Profile.
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0020;
// Key-Value Pair.
//
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
// HandleMetadata callback, the raw argument contains UTF-8 strings.
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
static constexpr uint64_t REPORT_METADATA_KVP = 0x0040;
// Modification Time.
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0080;
// Offset (2-Dimensional).
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0100;
// Physical Dimensions.
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0200;
// Standard Red Green Blue (Rendering Intent).
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0400;
// Extensible Metadata Platform.
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
static constexpr uint64_t REPORT_METADATA_XMP = 0x0800;
uint64_t repr;
};
@@ -19174,13 +19427,19 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
uint8_t v2,
uint8_t v3,
uint8_t ycc_model,
bool triangle_filter_for_2to1,
uint8_t ycc_upsampling,
wuffs_base__slice_u8 scratch_buffer_2k);
// ---------------- Images (Utility)
#define wuffs_base__utility__make_pixel_blend wuffs_base__make_pixel_blend
#define wuffs_base__utility__make_pixel_format wuffs_base__make_pixel_format
static inline uint8_t //
wuffs_base__utility__demake_pixel_blend(wuffs_base__pixel_blend a) {
return a;
}
// ---------------- String Conversions
// ---------------- Unicode and UTF-8
@@ -21410,14 +21669,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
uint8_t* q = s.ptr + s.len;
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
// Parse sign.
do {
@@ -21430,14 +21687,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
break;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
} while (0);
// Parse digits, up to (and including) a '.', 'E' or 'e'. Examples for each
@@ -21489,9 +21744,12 @@ wuffs_private_impl__high_prec_dec__parse(wuffs_private_impl__high_prec_dec* h,
if (nd < WUFFS_PRIVATE_IMPL__HPD__DIGITS_PRECISION) {
h->digits[nd++] = (uint8_t)(*p - '0');
dp = (int32_t)nd;
} else if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
} else {
dp++;
if ('0' != *p) {
// Long-tail non-zeroes set the truncated bit.
h->truncated = true;
}
}
} else if (*p ==
((options &
@@ -21550,14 +21808,12 @@ after_sep:
after_exp:
do {
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
for (;; p++) {
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
} else if (*p != '_') {
break;
}
for (; (p < q) && (*p == '_'); p++) {
}
}
if (p >= q) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
int32_t exp_sign = +1;
if (*p == '+') {
@@ -23327,6 +23583,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto hexadecimal;
}
goto fail_bad_argument;
} else if ((*p == 'd') || (*p == 'D')) {
p++;
@@ -23337,6 +23594,7 @@ wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {
if (p < q) {
goto decimal;
}
goto fail_bad_argument;
}
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {
@@ -24319,6 +24577,26 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
// --------
static inline uint32_t //
wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(
uint32_t dst_nonpremul,
uint32_t src_nonpremul);
static inline uint64_t //
wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(
uint64_t dst_nonpremul,
uint64_t src_nonpremul);
static inline uint32_t //
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,
uint32_t src_nonpremul);
static inline uint64_t //
wuffs_private_impl__composite_premul_nonpremul_u64_axxx(uint64_t dst_premul,
uint64_t src_nonpremul);
// --------
static inline uint32_t //
wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) {
uint32_t a = ((uint32_t)(0xFF & (c >> 56)));
@@ -24426,7 +24704,7 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,
// --------
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
wuffs_base__pixel_buffer__set_color_u32_at(
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
wuffs_base__pixel_buffer* pb,
uint32_t x,
uint32_t y,
@@ -24539,6 +24817,365 @@ wuffs_base__pixel_buffer__set_color_u32_at(
return wuffs_base__make_status(NULL);
}
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(
wuffs_base__pixel_buffer* pb,
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_nonpremul color) {
if (!pb) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if ((x >= pb->pixcfg.private_impl.width) ||
(y >= pb->pixcfg.private_impl.height)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {
// TODO: support planar formats.
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
size_t stride = pb->private_impl.planes[0].stride;
uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));
switch (pb->pixcfg.private_impl.pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
wuffs_base__poke_u32le__no_bounds_check(
row + (4 * ((size_t)x)),
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color));
break;
// Common formats above. Rarer formats below.
case WUFFS_BASE__PIXEL_FORMAT__Y:
wuffs_base__poke_u8__no_bounds_check(
row + ((size_t)x),
wuffs_base__color_u32_argb_premul__as__color_u8_gray(
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color)));
break;
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
wuffs_base__poke_u16le__no_bounds_check(
row + (2 * ((size_t)x)),
wuffs_base__color_u32_argb_premul__as__color_u16_gray(
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color)));
break;
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
wuffs_base__poke_u16be__no_bounds_check(
row + (2 * ((size_t)x)),
wuffs_base__color_u32_argb_premul__as__color_u16_gray(
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color)));
break;
case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
wuffs_base__poke_u8__no_bounds_check(
row + (2 * ((size_t)x)),
wuffs_base__color_u32_argb_premul__as__color_u8_gray(color |
0xFF000000));
wuffs_base__poke_u8__no_bounds_check(row + (2 * ((size_t)x)) + 1,
((uint8_t)(color >> 24)));
break;
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
wuffs_base__poke_u8__no_bounds_check(
row + ((size_t)x),
wuffs_base__pixel_palette__closest_element(
wuffs_base__pixel_buffer__palette(pb),
pb->pixcfg.private_impl.pixfmt,
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color)));
break;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
wuffs_base__poke_u16le__no_bounds_check(
row + (2 * ((size_t)x)),
wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color)));
break;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
wuffs_base__poke_u24le__no_bounds_check(
row + (3 * ((size_t)x)),
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color));
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
wuffs_base__poke_u64le__no_bounds_check(
row + (8 * ((size_t)x)), wuffs_base__color_u32__as__color_u64(color));
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
wuffs_base__poke_u64le__no_bounds_check(
row + (8 * ((size_t)x)),
wuffs_base__color_u64_argb_nonpremul__as__color_u64_argb_premul(
wuffs_base__color_u32__as__color_u64(color)));
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
wuffs_base__poke_u32le__no_bounds_check(
row + (4 * ((size_t)x)),
(color >> 31)
? (wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color) |
0xFF000000)
: 0);
break;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
wuffs_base__poke_u24le__no_bounds_check(
row + (3 * ((size_t)x)),
wuffs_base__color_swap_u32_argb_abgr(
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color)));
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
wuffs_base__poke_u32le__no_bounds_check(
row + (4 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color));
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
wuffs_base__poke_u32le__no_bounds_check(
row + (4 * ((size_t)x)),
wuffs_base__color_swap_u32_argb_abgr(
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color)));
break;
default:
// TODO: support more formats.
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
return wuffs_base__make_status(NULL);
}
static inline wuffs_base__status //
wuffs_base__pixel_buffer__composite_color_u32_nonpremul_at(
wuffs_base__pixel_buffer* pb,
uint32_t x,
uint32_t y,
wuffs_base__color_u32_argb_nonpremul color) {
if (!pb) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if ((x >= pb->pixcfg.private_impl.width) ||
(y >= pb->pixcfg.private_impl.height)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {
// TODO: support planar formats.
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
size_t stride = pb->private_impl.planes[0].stride;
uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));
switch (pb->pixcfg.private_impl.pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: {
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__BGRX: {
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr) | 0xFF000000;
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
break;
}
// Common formats above. Rarer formats below.
case WUFFS_BASE__PIXEL_FORMAT__Y: {
uint8_t* ptr = row + ((size_t)x);
uint32_t dst = 0xFF000000 | (0x00010101 * ((uint32_t)(*ptr)));
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
*ptr = ((uint8_t)(dst));
break;
}
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: {
uint8_t* ptr = row + (2 * ((size_t)x));
uint64_t dst =
0xFFFF000000000000 |
(0x000100010001 *
((uint64_t)(wuffs_base__peek_u16le__no_bounds_check(ptr))));
dst = wuffs_private_impl__composite_premul_nonpremul_u64_axxx(
dst, wuffs_base__color_u32__as__color_u64(color));
wuffs_base__poke_u16le__no_bounds_check(ptr, ((uint16_t)(dst)));
break;
}
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: {
uint8_t* ptr = row + (2 * ((size_t)x));
uint64_t dst =
0xFFFF000000000000 |
(0x000100010001 *
((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(ptr))));
dst = wuffs_private_impl__composite_premul_nonpremul_u64_axxx(
dst, wuffs_base__color_u32__as__color_u64(color));
wuffs_base__poke_u16be__no_bounds_check(ptr, ((uint16_t)(dst)));
break;
}
case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: {
uint8_t* ptr = row + (2 * ((size_t)x));
uint32_t dst =
(((uint32_t)(ptr[1])) << 24) | (((uint32_t)(ptr[0])) * 0x00010101);
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(dst,
color);
ptr[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(dst |
0xFF000000);
ptr[1] = ((uint8_t)(dst >> 24));
break;
}
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {
wuffs_base__slice_u8 palette = wuffs_base__pixel_buffer__palette(pb);
if (palette.len) {
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(
palette.ptr + (4 * ((size_t)row[x])));
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(dst,
color);
row[x] = wuffs_base__pixel_palette__closest_element(
wuffs_base__pixel_buffer__palette(pb),
pb->pixcfg.private_impl.pixfmt,
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
dst));
}
break;
}
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {
wuffs_base__slice_u8 palette = wuffs_base__pixel_buffer__palette(pb);
if (palette.len) {
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(
palette.ptr + (4 * ((size_t)row[x])));
dst =
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
row[x] = wuffs_base__pixel_palette__closest_element(
wuffs_base__pixel_buffer__palette(pb),
pb->pixcfg.private_impl.pixfmt, dst);
}
break;
}
case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {
uint8_t* ptr = row + (2 * ((size_t)x));
uint32_t dst = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
wuffs_base__peek_u16le__no_bounds_check(ptr));
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
wuffs_base__poke_u16le__no_bounds_check(
ptr, wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(dst));
break;
}
case WUFFS_BASE__PIXEL_FORMAT__BGR: {
uint8_t* ptr = row + (3 * ((size_t)x));
uint32_t dst = 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
wuffs_base__poke_u24le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: {
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(dst,
color);
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: {
uint8_t* ptr = row + (8 * ((size_t)x));
uint64_t dst = wuffs_base__peek_u64le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(
dst, wuffs_base__color_u32__as__color_u64(color));
wuffs_base__poke_u64le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: {
uint8_t* ptr = row + (8 * ((size_t)x));
uint64_t dst = wuffs_base__peek_u64le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_premul_nonpremul_u64_axxx(
dst, wuffs_base__color_u32__as__color_u64(color));
wuffs_base__poke_u64le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: {
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
if (dst) {
dst =
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
} else if (color >> 31) {
dst = (wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
color) |
0xFF000000);
}
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__RGB: {
uint8_t* ptr = row + (3 * ((size_t)x));
uint32_t dst = 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
dst, wuffs_base__color_swap_u32_argb_abgr(color));
wuffs_base__poke_u24le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: {
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(
dst, wuffs_base__color_swap_u32_argb_abgr(color));
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: {
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
dst, wuffs_base__color_swap_u32_argb_abgr(color));
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
break;
}
case WUFFS_BASE__PIXEL_FORMAT__RGBX: {
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr) | 0xFF000000;
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
dst, wuffs_base__color_swap_u32_argb_abgr(color));
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
break;
}
default:
// TODO: support more formats.
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
return wuffs_base__make_status(NULL);
}
// --------
static inline void //
@@ -24666,7 +25303,7 @@ wuffs_private_impl__pixel_buffer__set_color_u32_fill_rect__xxxxxxxx(
}
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
wuffs_base__pixel_buffer__set_color_u32_fill_rect(
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
wuffs_base__pixel_buffer* pb,
wuffs_base__rect_ie_u32 rect,
wuffs_base__color_u32_argb_premul color) {
@@ -24738,7 +25375,7 @@ wuffs_base__pixel_buffer__set_color_u32_fill_rect(
for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {
uint32_t x;
for (x = rect.min_incl_x; x < rect.max_excl_x; x++) {
wuffs_base__pixel_buffer__set_color_u32_at(pb, x, y, color);
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(pb, x, y, color);
}
}
return wuffs_base__make_status(NULL);
@@ -32371,7 +33008,36 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
size_t src_len,
uint32_t h1v2_bias_ignored,
bool first_column,
bool last_column);
bool last_column,
uint8_t odd_column_rounding);
static const uint8_t* //
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2(
uint8_t* dst_ptr,
const uint8_t* src_ptr_major,
const uint8_t* src_ptr_minor,
size_t src_len,
uint32_t h1v2_bias_ignored,
bool first_column,
bool last_column) {
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
first_column, last_column, 7);
}
static const uint8_t* //
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp_x86_avx2(
uint8_t* dst_ptr,
const uint8_t* src_ptr_major,
const uint8_t* src_ptr_minor,
size_t src_len,
uint32_t h1v2_bias_ignored,
bool first_column,
bool last_column) {
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
first_column, last_column, 8);
}
#endif
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
@@ -32412,6 +33078,102 @@ typedef void (*wuffs_private_impl__swizzle_ycc__convert_4_func)(
const uint8_t* up2,
const uint8_t* up3);
static void //
wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_general(
wuffs_base__pixel_buffer* dst,
uint32_t x,
uint32_t x_end,
uint32_t y,
const uint8_t* up0,
const uint8_t* up1,
const uint8_t* up2,
const uint8_t* up3) {
for (; x < x_end; x++) {
uint32_t color = //
wuffs_base__color_ycc_bt601sr__as__color_u32( //
*up0++, *up1++, *up2++);
color &= 0xFFFFFFu;
color |= ((uint32_t)(*up3++)) << 24;
wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(dst, x, y, color);
}
}
static void //
wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_bgra_premul(
wuffs_base__pixel_buffer* dst,
uint32_t x,
uint32_t x_end,
uint32_t y,
const uint8_t* up0,
const uint8_t* up1,
const uint8_t* up2,
const uint8_t* up3) {
size_t stride = dst->private_impl.planes[0].stride;
uint8_t* row = dst->private_impl.planes[0].ptr + (stride * ((size_t)y));
for (; x < x_end; x++) {
uint32_t color = //
wuffs_base__color_ycc_bt601sr__as__color_u32( //
*up0++, *up1++, *up2++);
color &= 0xFFFFFFu;
color |= ((uint32_t)(*up3++)) << 24;
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst_color =
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(color);
wuffs_base__poke_u32le__no_bounds_check(ptr, dst_color);
}
}
static void //
wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_general(
wuffs_base__pixel_buffer* dst,
uint32_t x,
uint32_t x_end,
uint32_t y,
const uint8_t* up0,
const uint8_t* up1,
const uint8_t* up2,
const uint8_t* up3) {
for (; x < x_end; x++) {
uint32_t color = //
wuffs_base__color_ycc_bt601sr__as__color_u32( //
*up0++, *up1++, *up2++);
color &= 0xFFFFFFu;
color |= ((uint32_t)(*up3++)) << 24;
wuffs_base__pixel_buffer__composite_color_u32_nonpremul_at(dst, x, y,
color);
}
}
static void //
wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_bgra_premul(
wuffs_base__pixel_buffer* dst,
uint32_t x,
uint32_t x_end,
uint32_t y,
const uint8_t* up0,
const uint8_t* up1,
const uint8_t* up2,
const uint8_t* up3) {
size_t stride = dst->private_impl.planes[0].stride;
uint8_t* row = dst->private_impl.planes[0].ptr + (stride * ((size_t)y));
for (; x < x_end; x++) {
uint32_t color = //
wuffs_base__color_ycc_bt601sr__as__color_u32( //
*up0++, *up1++, *up2++);
color &= 0xFFFFFFu;
color |= ((uint32_t)(*up3++)) << 24;
uint8_t* ptr = row + (4 * ((size_t)x));
uint32_t dst_color = wuffs_base__peek_u32le__no_bounds_check(ptr);
dst_color = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
dst_color, color);
wuffs_base__poke_u32le__no_bounds_check(ptr, dst_color);
}
}
static void //
wuffs_private_impl__swizzle_cmyk__convert_4_general(
wuffs_base__pixel_buffer* dst,
@@ -32433,7 +33195,7 @@ wuffs_private_impl__swizzle_cmyk__convert_4_general(
r = ((r * w) + 0x7Fu) / 0xFFu;
g = ((g * w) + 0x7Fu) / 0xFFu;
b = ((b * w) + 0x7Fu) / 0xFFu;
wuffs_base__pixel_buffer__set_color_u32_at(
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
dst, x, y, 0xFF000000u | (r << 16u) | (g << 8u) | (b << 0u));
}
}
@@ -32460,7 +33222,7 @@ wuffs_private_impl__swizzle_ycck__convert_4_general(
r = ((r * w) + 0x7Fu) / 0xFFu;
g = ((g * w) + 0x7Fu) / 0xFFu;
b = ((b * w) + 0x7Fu) / 0xFFu;
wuffs_base__pixel_buffer__set_color_u32_at(
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
dst, x, y, 0xFF000000u | (r << 16u) | (g << 8u) | (b << 0u));
}
}
@@ -32490,7 +33252,7 @@ wuffs_private_impl__swizzle_rgb__convert_3_general(
(((uint32_t)(*up0++)) << 16u) | //
(((uint32_t)(*up1++)) << 8u) | //
(((uint32_t)(*up2++)) << 0u);
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
}
}
@@ -32507,7 +33269,7 @@ wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general(
uint32_t color = //
wuffs_base__color_ycc_bt601fr__as__color_u32( //
*up0++, *up1++, *up2++);
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
}
}
@@ -32568,7 +33330,7 @@ wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_general(
uint32_t color = //
wuffs_base__color_ycc_bt601sr__as__color_u32( //
*up0++, *up1++, *up2++);
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
}
}
@@ -32730,8 +33492,8 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle(
const uint8_t* src_ptr_minor,
size_t src_len,
uint32_t h1v2_bias,
bool first_column,
bool last_column) {
bool first_column_ignored,
bool last_column_ignored) {
uint8_t* dp = dst_ptr;
const uint8_t* sp_major = src_ptr_major;
const uint8_t* sp_minor = src_ptr_minor;
@@ -32803,10 +33565,12 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
size_t src_len,
uint32_t h1v2_bias_ignored,
bool first_column,
bool last_column) {
bool last_column,
uint8_t odd_column_rounding) {
uint8_t* dp = dst_ptr;
const uint8_t* sp_major = src_ptr_major;
const uint8_t* sp_minor = src_ptr_minor;
const uint8_t oc = odd_column_rounding;
if (first_column) {
src_len--;
@@ -32814,7 +33578,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + //
(4u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + 8u) >> 4u);
*dp++ = (uint8_t)((sv + 7u) >> 4u);
*dp++ = (uint8_t)((sv + oc) >> 4u);
return dst_ptr;
}
@@ -32826,7 +33590,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
(3u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
if (src_len <= 0u) {
return dst_ptr;
}
@@ -32845,7 +33609,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
(3u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
}
if (last_column) {
@@ -32857,12 +33621,40 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
(3u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
}
return dst_ptr;
}
static const uint8_t* //
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg(
uint8_t* dst_ptr,
const uint8_t* src_ptr_major,
const uint8_t* src_ptr_minor,
size_t src_len,
uint32_t h1v2_bias_ignored,
bool first_column,
bool last_column) {
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
first_column, last_column, 7);
}
static const uint8_t* //
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp(
uint8_t* dst_ptr,
const uint8_t* src_ptr_major,
const uint8_t* src_ptr_minor,
size_t src_len,
uint32_t h1v2_bias_ignored,
bool first_column,
bool last_column) {
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
first_column, last_column, 8);
}
// wuffs_private_impl__swizzle_ycc__upsample_funcs is indexed by inv_h and then
// inv_v.
static const wuffs_private_impl__swizzle_ycc__upsample_func
@@ -33614,7 +34406,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
uint8_t v2,
uint8_t v3,
uint8_t ycc_model,
bool triangle_filter_for_2to1,
uint8_t ycc_upsampling,
wuffs_base__slice_u8 scratch_buffer_2k) {
if (!p) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
@@ -33629,7 +34421,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
(4u <= ((unsigned int)v0 - 1u)) || //
(4u <= ((unsigned int)v1 - 1u)) || //
(4u <= ((unsigned int)v2 - 1u)) || //
(triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) ||
((ycc_upsampling != 0) && ((x_min_incl | y_min_incl) > 0u)) ||
(scratch_buffer_2k.len < 2048u)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
@@ -33744,7 +34536,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
}
if (wuffs_base__pixel_format__is_planar(&dst->pixcfg.private_impl.pixfmt)) {
// TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO.
// TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's TODO.
return wuffs_base__make_status(
wuffs_base__error__unsupported_pixel_swizzler_option);
}
@@ -33819,7 +34611,8 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
break;
default:
// TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO.
// TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's
// TODO.
return wuffs_base__make_status(
wuffs_base__error__unsupported_pixel_swizzler_option);
}
@@ -33832,7 +34625,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
if (ycc_model >= WUFFS_BASE__YCC_MODEL__RGB) {
conv3func = &wuffs_private_impl__swizzle_rgb__convert_3_general;
} else if (ycc_model == WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) {
} else if (ycc_model >= WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) {
switch (dst->pixcfg.private_impl.pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
@@ -33937,7 +34730,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs,
sizeof upfuncs);
if (triangle_filter_for_2to1 &&
if ((ycc_upsampling != 0) &&
(wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) ||
@@ -33947,7 +34740,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle;
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
upfuncs[1][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle;
upfuncs[1][1] =
(ycc_upsampling == 1)
? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg
: wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp;
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
#if defined(__GNUC__) && !defined(__clang__)
@@ -33965,21 +34761,48 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
#else
if (wuffs_base__cpu_arch__have_x86_avx2()) {
upfuncs[1][1] =
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2;
(ycc_upsampling == 1)
? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2
: wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp_x86_avx2;
}
#endif
#endif
}
if ((h3 != 0u) || (v3 != 0u)) {
if (ycc_model == WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) {
return wuffs_base__make_status(
wuffs_base__error__unsupported_pixel_swizzler_option);
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = NULL;
switch (ycc_model) {
case WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE:
conv4func = &wuffs_private_impl__swizzle_ycck__convert_4_general;
break;
case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC:
if (dst->pixcfg.private_impl.pixfmt.repr ==
WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) {
conv4func =
&wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_bgra_premul;
} else {
conv4func =
&wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_general;
}
break;
case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER:
if (dst->pixcfg.private_impl.pixfmt.repr ==
WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) {
conv4func =
&wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_bgra_premul;
} else {
conv4func =
&wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_general;
}
break;
case WUFFS_BASE__YCC_MODEL__CMY:
conv4func = &wuffs_private_impl__swizzle_cmyk__convert_4_general;
break;
default:
return wuffs_base__make_status(
wuffs_base__error__unsupported_pixel_swizzler_option);
}
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func =
(ycc_model >= WUFFS_BASE__YCC_MODEL__RGB)
? &wuffs_private_impl__swizzle_cmyk__convert_4_general
: &wuffs_private_impl__swizzle_ycck__convert_4_general;
(*func4)( //
dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
src0.ptr, src1.ptr, src2.ptr, src3.ptr, //
@@ -34440,10 +35263,12 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
size_t src_len,
uint32_t h1v2_bias_ignored,
bool first_column,
bool last_column) {
bool last_column,
uint8_t odd_column_rounding) {
uint8_t* dp = dst_ptr;
const uint8_t* sp_major = src_ptr_major;
const uint8_t* sp_minor = src_ptr_minor;
const uint8_t oc = odd_column_rounding;
if (first_column) {
src_len--;
@@ -34451,7 +35276,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + //
(4u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + 8u) >> 4u);
*dp++ = (uint8_t)((sv + 7u) >> 4u);
*dp++ = (uint8_t)((sv + oc) >> 4u);
return dst_ptr;
}
@@ -34463,7 +35288,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
(3u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
if (src_len <= 0u) {
return dst_ptr;
}
@@ -34484,7 +35309,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
(3u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
}
} else {
@@ -34557,8 +35382,8 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
// the u16 right value by 4. On the right (p1), shift right by 4 and then
// shift left by 8 so that, when still in the u16x16 little-endian
// interpretation, we have:
// - m1_element = (etcetera + 8) >> 4
// - p1_element = ((etcetera + 7) >> 4) << 8
// - m1_element = (etcetera + 8) >> 4
// - p1_element = ((etcetera + oc) >> 4) << 8
//
// step4_m1_lo = [0x00?? 0x00?? ... 0x00?? 0x00??]
// step4_p1_lo = [0x??00 0x??00 ... 0x??00 0x??00]
@@ -34567,14 +35392,14 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
__m256i step4_m1_lo = _mm256_srli_epi16(
_mm256_add_epi16(step3_m1_lo, _mm256_set1_epi16(8)), 4);
__m256i step4_p1_lo = _mm256_slli_epi16(
_mm256_srli_epi16(_mm256_add_epi16(step3_p1_lo, _mm256_set1_epi16(7)),
4),
_mm256_srli_epi16(
_mm256_add_epi16(step3_p1_lo, _mm256_set1_epi16(oc)), 4),
8);
__m256i step4_m1_hi = _mm256_srli_epi16(
_mm256_add_epi16(step3_m1_hi, _mm256_set1_epi16(8)), 4);
__m256i step4_p1_hi = _mm256_slli_epi16(
_mm256_srli_epi16(_mm256_add_epi16(step3_p1_hi, _mm256_set1_epi16(7)),
4),
_mm256_srli_epi16(
_mm256_add_epi16(step3_p1_hi, _mm256_set1_epi16(oc)), 4),
8);
// Bitwise-or two "0x00"-rich u16x16 vectors to get a u8x32 vector. Do
@@ -34625,7 +35450,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
(3u * ((uint32_t)(*sp_minor++)));
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
}
return dst_ptr;
@@ -35239,14 +36064,14 @@ wuffs_adler32__hasher__up_arm_neon(
v_p.len = 0;
}
v_v2 = vshlq_n_u32(v_v2, 5u);
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col0), ((uint16x4_t){32u, 31u, 30u, 29u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col0), ((uint16x4_t){28u, 27u, 26u, 25u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col1), ((uint16x4_t){24u, 23u, 22u, 21u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col1), ((uint16x4_t){20u, 19u, 18u, 17u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col2), ((uint16x4_t){16u, 15u, 14u, 13u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col2), ((uint16x4_t){12u, 11u, 10u, 9u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col3), ((uint16x4_t){8u, 7u, 6u, 5u}));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col3), ((uint16x4_t){4u, 3u, 2u, 1u}));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col0), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(32u, 31u, 30u, 29u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col0), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(28u, 27u, 26u, 25u))));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col1), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(24u, 23u, 22u, 21u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col1), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(20u, 19u, 18u, 17u))));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col2), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(16u, 15u, 14u, 13u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col2), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(12u, 11u, 10u, 9u))));
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col3), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(8u, 7u, 6u, 5u))));
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col3), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(4u, 3u, 2u, 1u))));
v_sum1 = vpadd_u32(vget_low_u32(v_v1), vget_high_u32(v_v1));
v_sum2 = vpadd_u32(vget_low_u32(v_v2), vget_high_u32(v_v2));
v_sum12 = vpadd_u32(v_sum1, v_sum2);
@@ -50632,42 +51457,6 @@ WUFFS_HANDSUM__ZIGZAG[2][15] WUFFS_BASE__POTENTIALLY_UNUSED = {
},
};
static const uint8_t
WUFFS_HANDSUM__SCALE_AND_BIAS_CHROMA_DOWN[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
60u, 60u, 61u, 61u, 62u, 62u, 63u, 63u,
64u, 64u, 65u, 65u, 66u, 66u, 67u, 67u,
68u, 68u, 69u, 69u, 70u, 70u, 71u, 71u,
72u, 72u, 73u, 73u, 74u, 74u, 75u, 75u,
76u, 76u, 77u, 77u, 78u, 78u, 79u, 79u,
80u, 80u, 81u, 81u, 82u, 82u, 83u, 83u,
84u, 84u, 85u, 85u, 86u, 86u, 87u, 87u,
88u, 88u, 89u, 89u, 90u, 90u, 91u, 91u,
92u, 92u, 93u, 93u, 94u, 94u, 95u, 95u,
96u, 96u, 97u, 97u, 98u, 98u, 99u, 99u,
100u, 100u, 101u, 101u, 102u, 102u, 103u, 103u,
104u, 104u, 105u, 105u, 106u, 106u, 107u, 107u,
108u, 108u, 109u, 109u, 110u, 110u, 111u, 111u,
112u, 112u, 113u, 113u, 114u, 114u, 115u, 115u,
116u, 116u, 117u, 117u, 118u, 118u, 119u, 119u,
120u, 120u, 121u, 121u, 122u, 122u, 123u, 123u,
124u, 124u, 125u, 125u, 126u, 126u, 127u, 127u,
128u, 128u, 129u, 129u, 130u, 130u, 131u, 131u,
132u, 132u, 133u, 133u, 134u, 134u, 135u, 135u,
136u, 136u, 137u, 137u, 138u, 138u, 139u, 139u,
140u, 140u, 141u, 141u, 142u, 142u, 143u, 143u,
144u, 144u, 145u, 145u, 146u, 146u, 147u, 147u,
148u, 148u, 149u, 149u, 150u, 150u, 151u, 151u,
152u, 152u, 153u, 153u, 154u, 154u, 155u, 155u,
156u, 156u, 157u, 157u, 158u, 158u, 159u, 159u,
160u, 160u, 161u, 161u, 162u, 162u, 163u, 163u,
164u, 164u, 165u, 165u, 166u, 166u, 167u, 167u,
168u, 168u, 169u, 169u, 170u, 170u, 171u, 171u,
172u, 172u, 173u, 173u, 174u, 174u, 175u, 175u,
176u, 176u, 177u, 177u, 178u, 178u, 179u, 179u,
180u, 180u, 181u, 181u, 182u, 182u, 183u, 183u,
184u, 184u, 185u, 185u, 186u, 186u, 187u, 187u,
};
static const uint8_t
WUFFS_HANDSUM__CUBE_ROOT[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 0u, 1u, 1u, 1u, 2u, 2u, 2u,
@@ -52176,8 +52965,8 @@ wuffs_handsum__decoder__scale_and_bias_chroma_down(
while (v_y < 8u) {
v_x = 0u;
while (v_x < 8u) {
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)] = WUFFS_HANDSUM__SCALE_AND_BIAS_CHROMA_DOWN[self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)]];
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)] = WUFFS_HANDSUM__SCALE_AND_BIAS_CHROMA_DOWN[self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)]];
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)] = ((uint8_t)(60u + ((uint8_t)(self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)] >> 1u))));
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)] = ((uint8_t)(60u + ((uint8_t)(self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)] >> 1u))));
v_x += 1u;
}
v_y += 1u;
@@ -57761,6 +58550,7 @@ wuffs_jpeg__decoder__swizzle_colorful(
uint32_t v_height1 = 0;
uint32_t v_height2 = 0;
uint32_t v_height3 = 0;
uint8_t v_ycc_upsampling = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
if (self->private_impl.f_swizzle_immediately) {
@@ -57822,6 +58612,10 @@ wuffs_jpeg__decoder__swizzle_colorful(
v_height3 = self->private_impl.f_components_workbuf_heights[3u];
}
}
v_ycc_upsampling = ((uint8_t)(0u));
if ( ! self->private_impl.f_use_lower_quality) {
v_ycc_upsampling = ((uint8_t)(1u));
}
v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler,
a_dst,
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
@@ -57854,7 +58648,7 @@ wuffs_jpeg__decoder__swizzle_colorful(
self->private_impl.f_components_v[2u],
self->private_impl.f_components_v[3u],
self->private_impl.f_ycc_model,
! self->private_impl.f_use_lower_quality,
v_ycc_upsampling,
wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048));
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
}
@@ -69632,6 +70426,12 @@ wuffs_png__decoder__decode_chrm(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_png__decoder__decode_cicp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_png__decoder__decode_exif(
@@ -72177,6 +72977,25 @@ wuffs_png__decoder__decode_other_chunk(
}
self->private_impl.f_seen_chrm = true;
}
} else if (self->private_impl.f_chunk_type == 1346586979u) {
if (self->private_impl.f_report_metadata_cicp) {
if (self->private_impl.f_seen_cicp) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_png__decoder__decode_cicp(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_cicp = true;
}
} else if (self->private_impl.f_chunk_type == 1280598886u) {
if (self->private_impl.f_seen_fctl) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
@@ -72185,7 +73004,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_png__decoder__decode_fctl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72203,7 +73022,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_png__decoder__decode_gama(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72222,7 +73041,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_png__decoder__decode_iccp(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72241,7 +73060,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
status = wuffs_png__decoder__decode_srgb(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72260,7 +73079,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
status = wuffs_png__decoder__decode_trns(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -72274,7 +73093,7 @@ wuffs_png__decoder__decode_other_chunk(
}
if (self->private_impl.f_metadata_fourcc == 0u) {
self->private_data.s_decode_other_chunk.scratch = self->private_impl.f_chunk_length;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
if (self->private_data.s_decode_other_chunk.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_other_chunk.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
@@ -72715,6 +73534,88 @@ wuffs_png__decoder__decode_chrm(
return status;
}
// -------- func png.decoder.decode_cicp
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_png__decoder__decode_cicp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_cicp;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 4u) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0u;
self->private_impl.f_metadata_flavor = 5u;
self->private_impl.f_metadata_fourcc = 1128874832u;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = ((uint64_t)(wuffs_base__peek_u32le__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_cicp.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_cicp.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint64_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
self->private_impl.f_metadata_x = t_0;
}
self->private_impl.f_metadata_y = 0u;
self->private_impl.f_metadata_z = 0u;
goto ok;
ok:
self->private_impl.p_decode_cicp = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_cicp = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_exif
WUFFS_BASE__GENERATED_C_CODE
@@ -74886,6 +75787,8 @@ wuffs_png__decoder__set_report_metadata(
if (a_fourcc == 1128813133u) {
self->private_impl.f_report_metadata_chrm = a_report;
} else if (a_fourcc == 1128874832u) {
self->private_impl.f_report_metadata_cicp = a_report;
} else if (a_fourcc == 1163413830u) {
self->private_impl.f_report_metadata_exif = a_report;
} else if (a_fourcc == 1195461953u) {
@@ -80899,7 +81802,9 @@ wuffs_thumbhash__decoder__workbuf_len(
// ---------------- Status Codes Implementations
const char wuffs_vp8__error__bad_quirk_source_length[] = "#vp8: bad QUIRK_SOURCE_LENGTH";
const char wuffs_vp8__error__bad_quirk_width_and_height[] = "#vp8: bad QUIRK_WIDTH_AND_HEIGHT";
const char wuffs_vp8__error__bad_header[] = "#vp8: bad header";
const char wuffs_vp8__error__inconsistent_width_and_height[] = "#vp8: inconsistent width and height";
const char wuffs_vp8__error__missing_quirk_source_length[] = "#vp8: missing QUIRK_SOURCE_LENGTH";
const char wuffs_vp8__error__truncated_input[] = "#vp8: truncated input";
const char wuffs_vp8__error__unsupported_quirk_source_length[] = "#vp8: unsupported QUIRK_SOURCE_LENGTH";
@@ -81794,6 +82699,8 @@ WUFFS_VP8__ZIGZAG[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
9u, 12u, 13u, 10u, 7u, 11u, 14u, 15u,
};
#define WUFFS_VP8__QUIRKS_BASE 1836840960u
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -81839,7 +82746,7 @@ wuffs_vp8__decoder__initialize_mb_coeffs(
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
wuffs_vp8__decoder__decode_block_coefficients(
wuffs_vp8__decoder__decode_subblock_coefficients(
wuffs_vp8__decoder* self,
wuffs_base__slice_u8 a_workbuf,
uint32_t a_mby,
@@ -81995,7 +82902,6 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_vp8__decoder__decode_macroblocks(
wuffs_vp8__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
@@ -82044,11 +82950,11 @@ wuffs_vp8__decoder__copy_from_yuv_cache(
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(
wuffs_vp8__decoder__swizzle(
wuffs_vp8__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf,
uint32_t a_mby);
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -82102,6 +83008,11 @@ wuffs_vp8__decoder__do_decode_image_config(
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_vp8__decoder__calculate_mbw_mbh(
wuffs_vp8__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_vp8__decoder__do_decode_frame_config(
@@ -82343,7 +83254,7 @@ wuffs_vp8__decoder__decode_coefficients(
self->private_data.f_mb_states_left &= 4286578687u;
v_tnz = (1u & (self->private_data.f_mb_states_top[a_mbx] >> 23u));
self->private_data.f_mb_states_top[a_mbx] &= 4286578687u;
v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self,
v_lnz = wuffs_vp8__decoder__decode_subblock_coefficients(self,
a_workbuf,
a_mby,
a_seg,
@@ -82364,7 +83275,7 @@ wuffs_vp8__decoder__decode_coefficients(
v_tnz = (1u & (self->private_data.f_mb_states_top[a_mbx] >> (24u + v_bx)));
self->private_data.f_mb_states_top[a_mbx] &= (4294967295u ^ (((uint32_t)(1u)) << (24u + v_bx)));
v_b = ((4u * v_by) + v_bx);
v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self,
v_lnz = wuffs_vp8__decoder__decode_subblock_coefficients(self,
a_workbuf,
a_mby,
a_seg,
@@ -82397,7 +83308,7 @@ wuffs_vp8__decoder__decode_coefficients(
(2u * v_by) +
v_bx +
16u);
v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self,
v_lnz = wuffs_vp8__decoder__decode_subblock_coefficients(self,
a_workbuf,
a_mby,
a_seg,
@@ -82445,11 +83356,11 @@ wuffs_vp8__decoder__initialize_mb_coeffs(
return wuffs_base__make_empty_struct();
}
// -------- func vp8.decoder.decode_block_coefficients
// -------- func vp8.decoder.decode_subblock_coefficients
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
wuffs_vp8__decoder__decode_block_coefficients(
wuffs_vp8__decoder__decode_subblock_coefficients(
wuffs_vp8__decoder* self,
wuffs_base__slice_u8 a_workbuf,
uint32_t a_mby,
@@ -83895,11 +84806,9 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_vp8__decoder__decode_macroblocks(
wuffs_vp8__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf) {
uint32_t v_mby = 0;
uint32_t v_mbx = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
v_mbx = 0u;
while (v_mbx < self->private_impl.f_mbw) {
@@ -83921,24 +84830,15 @@ wuffs_vp8__decoder__decode_macroblocks(
} else {
wuffs_vp8__decoder__filter_normal(self, a_workbuf, (v_mby - 1u));
}
v_status = wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(self, a_dst, a_workbuf, (v_mby - 1u));
if ( ! wuffs_base__status__is_ok(&v_status)) {
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
}
}
v_mby += 1u;
}
if (self->private_impl.f_mbh > 0u) {
v_mby = (self->private_impl.f_mbh - 1u);
if (self->private_impl.f_filt_level <= 0u) {
} else if (self->private_impl.f_filt_simple) {
wuffs_vp8__decoder__filter_simple(self, a_workbuf, v_mby);
wuffs_vp8__decoder__filter_simple(self, a_workbuf, (self->private_impl.f_mbh - 1u));
} else {
wuffs_vp8__decoder__filter_normal(self, a_workbuf, v_mby);
}
v_status = wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(self, a_dst, a_workbuf, v_mby);
if ( ! wuffs_base__status__is_ok(&v_status)) {
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
wuffs_vp8__decoder__filter_normal(self, a_workbuf, (self->private_impl.f_mbh - 1u));
}
}
return wuffs_base__make_status(NULL);
@@ -84197,76 +85097,80 @@ wuffs_vp8__decoder__copy_from_yuv_cache(
return wuffs_base__make_empty_struct();
}
// -------- func vp8.decoder.swizzle_one_row_of_macroblocks
// -------- func vp8.decoder.swizzle
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(
wuffs_vp8__decoder__swizzle(
wuffs_vp8__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf,
uint32_t a_mby) {
uint32_t v_y_min_incl = 0;
uint32_t v_y_max_excl = 0;
uint64_t v_o = 0;
wuffs_base__slice_u8 v_src0 = {0};
wuffs_base__slice_u8 v_src1 = {0};
wuffs_base__slice_u8 v_src2 = {0};
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf) {
uint64_t v_wh = 0;
wuffs_base__slice_u8 v_prefix = {0};
wuffs_base__slice_u8 v_suffix = {0};
uint32_t v_has_alpha = 0;
uint32_t v_ycc_model = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
if ((self->private_impl.f_workbuf_yuv_y_end > self->private_impl.f_workbuf_yuv_u_end) || (self->private_impl.f_workbuf_yuv_u_end > self->private_impl.f_workbuf_yuv_v_end) || (self->private_impl.f_workbuf_yuv_v_end > ((uint64_t)(a_workbuf.len)))) {
if (self->private_impl.f_quirk_has_alpha_side_channel) {
if (self->private_impl.f_quirk_width_and_height == 0u) {
return wuffs_base__make_status(wuffs_vp8__error__inconsistent_width_and_height);
}
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
if (v_wh > ((uint64_t)(a_workbuf.len))) {
return wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
}
v_prefix = wuffs_base__slice_u8__subslice_j(a_workbuf, v_wh);
v_suffix = wuffs_base__slice_u8__subslice_i(a_workbuf, v_wh);
v_has_alpha = 1u;
v_ycc_model = (6u | (1u & ((uint32_t)(wuffs_base__utility__demake_pixel_blend(a_blend)))));
} else {
v_prefix = wuffs_base__utility__empty_slice_u8();
v_suffix = a_workbuf;
v_has_alpha = 0u;
v_ycc_model = 4u;
}
if ((self->private_impl.f_workbuf_yuv_y_end > self->private_impl.f_workbuf_yuv_u_end) || (self->private_impl.f_workbuf_yuv_u_end > self->private_impl.f_workbuf_yuv_v_end) || (self->private_impl.f_workbuf_yuv_v_end > ((uint64_t)(v_suffix.len)))) {
return wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
}
v_y_min_incl = wuffs_base__u32__sat_sub((a_mby * 16u), 6u);
v_y_max_excl = ((a_mby * 16u) + 10u);
if ((a_mby + 1u) >= self->private_impl.f_mbh) {
v_y_max_excl = self->private_impl.f_height;
}
v_o = ((uint64_t)((v_y_min_incl * self->private_impl.f_workbuf_yuv_y_stride)));
if (v_o < self->private_impl.f_workbuf_yuv_y_end) {
v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_o, self->private_impl.f_workbuf_yuv_y_end);
}
v_o = (((uint64_t)(((v_y_min_incl / 2u) * self->private_impl.f_workbuf_yuv_uv_stride))) + self->private_impl.f_workbuf_yuv_y_end);
if (v_o < self->private_impl.f_workbuf_yuv_u_end) {
v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_o, self->private_impl.f_workbuf_yuv_u_end);
}
v_o = (((uint64_t)(((v_y_min_incl / 2u) * self->private_impl.f_workbuf_yuv_uv_stride))) + self->private_impl.f_workbuf_yuv_u_end);
if (v_o < self->private_impl.f_workbuf_yuv_v_end) {
v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_o, self->private_impl.f_workbuf_yuv_v_end);
}
v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler,
a_dst,
wuffs_base__pixel_buffer__palette(a_dst),
0u,
self->private_impl.f_width,
v_y_min_incl,
v_y_max_excl,
v_src0,
v_src1,
v_src2,
wuffs_base__utility__empty_slice_u8(),
0u,
self->private_impl.f_height,
wuffs_base__slice_u8__subslice_j(v_suffix, self->private_impl.f_workbuf_yuv_y_end),
wuffs_base__slice_u8__subslice_ij(v_suffix,
self->private_impl.f_workbuf_yuv_y_end,
self->private_impl.f_workbuf_yuv_u_end),
wuffs_base__slice_u8__subslice_ij(v_suffix,
self->private_impl.f_workbuf_yuv_u_end,
self->private_impl.f_workbuf_yuv_v_end),
v_prefix,
(self->private_impl.f_mbw * 16u),
(self->private_impl.f_mbw * 8u),
(self->private_impl.f_mbw * 8u),
0u,
wuffs_base__u32__sat_sub((self->private_impl.f_mbh * 16u), v_y_min_incl),
wuffs_base__u32__sat_sub((self->private_impl.f_mbh * 8u), (v_y_min_incl / 2u)),
wuffs_base__u32__sat_sub((self->private_impl.f_mbh * 8u), (v_y_min_incl / 2u)),
0u,
(self->private_impl.f_width * v_has_alpha),
(self->private_impl.f_mbh * 16u),
(self->private_impl.f_mbh * 8u),
(self->private_impl.f_mbh * 8u),
(self->private_impl.f_height * v_has_alpha),
(self->private_impl.f_mbw * 16u),
(self->private_impl.f_mbw * 8u),
(self->private_impl.f_mbw * 8u),
0u,
(self->private_impl.f_width * v_has_alpha),
2u,
1u,
1u,
0u,
((uint8_t)((2u * v_has_alpha))),
2u,
1u,
1u,
0u,
((uint8_t)(1u)),
false,
((uint8_t)((2u * v_has_alpha))),
((uint8_t)(v_ycc_model)),
((uint8_t)(2u)),
wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048));
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
}
@@ -85185,6 +86089,12 @@ wuffs_vp8__decoder__get_quirk(
if (a_key == 3u) {
return self->private_impl.f_quirk_source_length;
} else if (a_key == 1836840960u) {
if (self->private_impl.f_quirk_has_alpha_side_channel) {
return 1u;
}
} else if (a_key == 1836840961u) {
return self->private_impl.f_quirk_width_and_height;
}
return 0u;
}
@@ -85207,8 +86117,41 @@ wuffs_vp8__decoder__set_quirk(
: wuffs_base__error__initialize_not_called);
}
uint32_t v_w = 0;
uint32_t v_h = 0;
if (a_key == 3u) {
self->private_impl.f_quirk_source_length = a_value;
if ((a_value & 1u) == 0u) {
if (a_value != 0u) {
return wuffs_base__make_status(wuffs_vp8__error__bad_quirk_source_length);
}
self->private_impl.f_quirk_source_length = 0u;
self->private_impl.f_partitioned_data_length = 0u;
} else if ((a_value >> 1u) < 10u) {
return wuffs_base__make_status(wuffs_vp8__error__bad_quirk_source_length);
} else if ((a_value >> 1u) > 150994945u) {
return wuffs_base__make_status(wuffs_vp8__error__unsupported_quirk_source_length);
} else {
self->private_impl.f_quirk_source_length = a_value;
self->private_impl.f_partitioned_data_length = (((uint32_t)((a_value >> 1u))) - 10u);
}
return wuffs_base__make_status(NULL);
} else if (a_key == 1836840960u) {
self->private_impl.f_quirk_has_alpha_side_channel = (a_value != 0u);
return wuffs_base__make_status(NULL);
} else if (a_key == 1836840961u) {
v_w = ((uint32_t)(a_value));
v_h = ((uint32_t)((a_value >> 32u)));
if ((v_w < 1u) ||
(16383u < v_w) ||
(v_h < 1u) ||
(16383u < v_h)) {
return wuffs_base__make_status(wuffs_vp8__error__bad_quirk_width_and_height);
}
self->private_impl.f_quirk_width_and_height = a_value;
self->private_impl.f_width = v_w;
self->private_impl.f_height = v_h;
wuffs_vp8__decoder__calculate_mbw_mbh(self);
return wuffs_base__make_status(NULL);
}
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
@@ -85311,17 +86254,10 @@ wuffs_vp8__decoder__do_decode_image_config(
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
if ((self->private_impl.f_quirk_source_length & 1u) == 0u) {
if (self->private_impl.f_quirk_source_length == 0u) {
status = wuffs_base__make_status(wuffs_vp8__error__missing_quirk_source_length);
goto exit;
} else if ((self->private_impl.f_quirk_source_length >> 1u) < 10u) {
status = wuffs_base__make_status(wuffs_vp8__error__bad_quirk_source_length);
goto exit;
} else if ((self->private_impl.f_quirk_source_length >> 1u) > 150994945u) {
status = wuffs_base__make_status(wuffs_vp8__error__unsupported_quirk_source_length);
goto exit;
}
self->private_impl.f_partitioned_data_length = (((uint32_t)((self->private_impl.f_quirk_source_length >> 1u))) - 10u);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
@@ -85425,13 +86361,14 @@ wuffs_vp8__decoder__do_decode_image_config(
}
self->private_impl.f_width = (16383u & v_c32);
self->private_impl.f_height = (16383u & (v_c32 >> 16u));
self->private_impl.f_mbw = ((self->private_impl.f_width + 15u) / 16u);
self->private_impl.f_mbh = ((self->private_impl.f_height + 15u) / 16u);
self->private_impl.f_workbuf_yuv_y_stride = (self->private_impl.f_mbw * 16u);
self->private_impl.f_workbuf_yuv_uv_stride = (self->private_impl.f_mbw * 8u);
self->private_impl.f_workbuf_yuv_y_end = (((uint64_t)(self->private_impl.f_workbuf_yuv_y_stride)) * ((uint64_t)((self->private_impl.f_mbh * 16u))));
self->private_impl.f_workbuf_yuv_u_end = (self->private_impl.f_workbuf_yuv_y_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
self->private_impl.f_workbuf_yuv_v_end = (self->private_impl.f_workbuf_yuv_u_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
if ((self->private_impl.f_width == 0u) || (self->private_impl.f_height == 0u)) {
status = wuffs_base__make_status(wuffs_vp8__error__bad_header);
goto exit;
} else if ((self->private_impl.f_quirk_width_and_height != 0u) && (self->private_impl.f_quirk_width_and_height != (((uint64_t)(self->private_impl.f_width)) | (((uint64_t)(self->private_impl.f_height)) << 32u)))) {
status = wuffs_base__make_status(wuffs_vp8__error__inconsistent_width_and_height);
goto exit;
}
wuffs_vp8__decoder__calculate_mbw_mbh(self);
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if (a_dst != NULL) {
wuffs_base__image_config__set(
@@ -85464,6 +86401,22 @@ wuffs_vp8__decoder__do_decode_image_config(
return status;
}
// -------- func vp8.decoder.calculate_mbw_mbh
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_vp8__decoder__calculate_mbw_mbh(
wuffs_vp8__decoder* self) {
self->private_impl.f_mbw = ((self->private_impl.f_width + 15u) / 16u);
self->private_impl.f_mbh = ((self->private_impl.f_height + 15u) / 16u);
self->private_impl.f_workbuf_yuv_y_stride = (self->private_impl.f_mbw * 16u);
self->private_impl.f_workbuf_yuv_uv_stride = (self->private_impl.f_mbw * 8u);
self->private_impl.f_workbuf_yuv_y_end = (((uint64_t)(self->private_impl.f_workbuf_yuv_y_stride)) * ((uint64_t)((self->private_impl.f_mbh * 16u))));
self->private_impl.f_workbuf_yuv_u_end = (self->private_impl.f_workbuf_yuv_y_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
self->private_impl.f_workbuf_yuv_v_end = (self->private_impl.f_workbuf_yuv_u_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
return wuffs_base__make_empty_struct();
}
// -------- func vp8.decoder.decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
@@ -85649,37 +86602,65 @@ wuffs_vp8__decoder__decode_frame(
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_wh = 0;
uint64_t v_wb_len = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
wuffs_base__slice_u8 v_trimmed = {0};
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
v_trimmed = a_workbuf;
if (self->private_impl.f_quirk_has_alpha_side_channel) {
if (self->private_impl.f_quirk_width_and_height == 0u) {
status = wuffs_base__make_status(wuffs_vp8__error__inconsistent_width_and_height);
goto exit;
}
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
if (v_wh > ((uint64_t)(a_workbuf.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_trimmed = wuffs_base__slice_u8__subslice_i(a_workbuf, v_wh);
}
v_wb_len = (self->private_impl.f_workbuf_yuv_v_end + ((uint64_t)(self->private_impl.f_partitioned_data_length)) + 8u);
if (v_wb_len > ((uint64_t)(a_workbuf.len))) {
if (v_wb_len > ((uint64_t)(v_trimmed.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
} else {
a_workbuf = wuffs_base__slice_u8__subslice_j(a_workbuf, v_wb_len);
v_trimmed = wuffs_base__slice_u8__subslice_j(v_trimmed, v_wb_len);
}
{
wuffs_base__status t_0 = wuffs_vp8__decoder__do_decode_frame(self,
a_dst,
a_src,
a_blend,
a_workbuf,
v_trimmed,
a_opts);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_vp8__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
v_status = wuffs_vp8__decoder__swizzle(self, a_dst, a_blend, a_workbuf);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
ok:
self->private_impl.p_decode_frame = 0;
@@ -85781,7 +86762,7 @@ wuffs_vp8__decoder__do_decode_frame(
}
goto ok;
}
v_status = wuffs_vp8__decoder__decode_macroblocks(self, a_dst, a_workbuf);
v_status = wuffs_vp8__decoder__decode_macroblocks(self, a_workbuf);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
@@ -85982,10 +86963,17 @@ wuffs_vp8__decoder__workbuf_len(
return wuffs_base__utility__empty_range_ii_u64();
}
uint64_t v_wh = 0;
uint64_t v_wb_len = 0;
if (self->private_impl.f_quirk_source_length == 0u) {
return wuffs_base__utility__make_range_ii_u64(1u, 0u);
}
if (self->private_impl.f_quirk_has_alpha_side_channel) {
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
}
v_wb_len = (self->private_impl.f_workbuf_yuv_v_end + ((uint64_t)(self->private_impl.f_partitioned_data_length)) + 8u);
return wuffs_base__utility__make_range_ii_u64(v_wb_len, v_wb_len);
return wuffs_base__utility__make_range_ii_u64((v_wh + v_wb_len), (v_wh + v_wb_len));
}
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8)
@@ -86916,18 +87904,20 @@ wuffs_wbmp__decoder__workbuf_len(
// ---------------- Status Codes Implementations
const char wuffs_webp__error__bad_alph_vp8l_combination[] = "#webp: bad ALPH+VP8L combination";
const char wuffs_webp__error__bad_huffman_code_over_subscribed[] = "#webp: bad Huffman code (over-subscribed)";
const char wuffs_webp__error__bad_huffman_code_under_subscribed[] = "#webp: bad Huffman code (under-subscribed)";
const char wuffs_webp__error__bad_huffman_code[] = "#webp: bad Huffman code";
const char wuffs_webp__error__bad_vp8x_chunk[] = "#webp: bad VP8X chunk";
const char wuffs_webp__error__bad_back_reference[] = "#webp: bad back-reference";
const char wuffs_webp__error__bad_chunk_order[] = "#webp: bad chunk order";
const char wuffs_webp__error__bad_color_cache[] = "#webp: bad color cache";
const char wuffs_webp__error__bad_header[] = "#webp: bad header";
const char wuffs_webp__error__bad_transform[] = "#webp: bad transform";
const char wuffs_webp__error__short_chunk[] = "#webp: short chunk";
const char wuffs_webp__error__truncated_input[] = "#webp: truncated input";
const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups";
const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[] = "#webp: unsupported transform after color indexing transform";
const char wuffs_webp__error__unsupported_webp_file[] = "#webp: unsupported WebP file";
const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups";
const char wuffs_webp__error__internal_error_inconsistent_huffman_code[] = "#webp: internal error: inconsistent Huffman code";
const char wuffs_webp__error__internal_error_inconsistent_dst_buffer[] = "#webp: internal error: inconsistent dst buffer";
const char wuffs_webp__error__internal_error_inconsistent_n_bits[] = "#webp: internal error: inconsistent n_bits";
@@ -86979,6 +87969,44 @@ WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
// ---------------- Private Function Prototypes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph_limited(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__compact_alph(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_horizontal(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_vertical(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_gradient(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_groups(
@@ -87042,6 +88070,7 @@ static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_predictor(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
uint32_t a_width,
wuffs_base__slice_u8 a_tile_data);
WUFFS_BASE__GENERATED_C_CODE
@@ -87072,6 +88101,7 @@ static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_cross_color(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
uint32_t a_width,
wuffs_base__slice_u8 a_tile_data);
WUFFS_BASE__GENERATED_C_CODE
@@ -87084,38 +88114,12 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_color_indexing(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix);
wuffs_base__slice_u8 a_pix,
uint32_t a_width);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder__do_decode_frame_vp8l(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
@@ -87163,6 +88167,49 @@ wuffs_webp__decoder__swizzle(
wuffs_base__slice_u8 a_src,
wuffs_base__pixel_blend a_blend);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8x(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts);
// ---------------- VTables
const wuffs_base__image_decoder__func_ptrs
@@ -87279,6 +88326,375 @@ sizeof__wuffs_webp__decoder(void) {
// ---------------- Function Implementations
// -------- func webp.decoder.decode_alph
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_alph;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_0 = wuffs_webp__decoder__decode_alph_limited(self, a_src, a_workbuf);
v_status = t_0;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_alph = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_alph = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_alph_limited
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph_limited(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_n = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_alph_limited;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
self->private_impl.f_vp8x_alph_flags = t_0;
}
if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 3u)) == 0u) {
wuffs_private_impl__io_reader__limited_copy_u32_to_slice(
&iop_a_src, io2_a_src,(self->private_impl.f_width * self->private_impl.f_height), a_workbuf);
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 3u)) == 1u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_webp__decoder__do_decode_frame_vp8l(self,
NULL,
a_src,
wuffs_base__utility__make_pixel_blend(0u),
a_workbuf,
NULL);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
v_n = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height * 4u)));
if (v_n <= ((uint64_t)(a_workbuf.len))) {
wuffs_webp__decoder__compact_alph(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
}
} else {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
self->private_impl.f_vp8x_alph_flags |= 2u;
v_n = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
if (v_n <= ((uint64_t)(a_workbuf.len))) {
if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 4u) {
wuffs_webp__decoder__filter_alph_horizontal(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 8u) {
wuffs_webp__decoder__filter_alph_vertical(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 12u) {
wuffs_webp__decoder__filter_alph_gradient(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
}
}
goto ok;
ok:
self->private_impl.p_decode_alph_limited = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_alph_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.compact_alph
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__compact_alph(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint64_t v_i = 0;
uint64_t v_j = 0;
if (((uint64_t)(a_s.len)) > 1073741824u) {
return wuffs_base__make_empty_struct();
}
v_i = 0u;
v_j = 1u;
while ((v_i < ((uint64_t)(a_s.len))) && (v_j < ((uint64_t)(a_s.len)))) {
a_s.ptr[v_i] = a_s.ptr[v_j];
v_i += 1u;
v_j += 4u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.filter_alph_horizontal
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_horizontal(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_i = 0;
uint8_t v_pred = 0;
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_pred = 0u;
if (v_y > 0u) {
v_i = ((uint64_t)(((v_y - 1u) * self->private_impl.f_width)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_pred = a_s.ptr[v_i];
}
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
a_s.ptr[v_i] += v_pred;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_pred = a_s.ptr[v_i];
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.filter_alph_vertical
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_vertical(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_i = 0;
uint8_t v_pred = 0;
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_pred = 0u;
if (v_x > 0u) {
v_i = ((uint64_t)((v_x - 1u)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_pred = a_s.ptr[v_i];
}
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
a_s.ptr[v_i] += v_pred;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_pred = a_s.ptr[v_i];
v_y += 1u;
}
v_x += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.filter_alph_gradient
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_gradient(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_i = 0;
uint8_t v_pred = 0;
uint32_t v_grad = 0;
uint8_t v_l = 0;
uint8_t v_t = 0;
uint8_t v_tl = 0;
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_i = ((uint64_t)(v_x));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
a_s.ptr[v_i] += v_pred;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_pred = a_s.ptr[v_i];
v_x += 1u;
}
v_y = 1u;
while (v_y < self->private_impl.f_height) {
v_i = ((uint64_t)(((v_y - 1u) * self->private_impl.f_width)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_t = a_s.ptr[v_i];
v_tl = v_t;
v_l = v_t;
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_i = ((uint64_t)((((v_y - 1u) * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_t = a_s.ptr[v_i];
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_grad = ((uint32_t)(((uint32_t)(((uint32_t)(v_l)) + ((uint32_t)(v_t)))) - ((uint32_t)(v_tl))));
if (v_grad > 2147483647u) {
v_grad = 0u;
} else if (v_grad > 255u) {
v_grad = 255u;
}
v_l = ((uint8_t)(a_s.ptr[v_i] + ((uint8_t)(v_grad))));
a_s.ptr[v_i] = v_l;
v_tl = v_t;
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.decode_huffman_groups
WUFFS_BASE__GENERATED_C_CODE
@@ -88463,6 +89879,7 @@ static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_predictor(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
uint32_t a_width,
wuffs_base__slice_u8 a_tile_data) {
uint64_t v_w4 = 0;
wuffs_base__slice_u8 v_prev_row = {0};
@@ -88490,10 +89907,10 @@ wuffs_webp__decoder__apply_transform_predictor(
uint32_t v_sum_l = 0;
uint32_t v_sum_t = 0;
if ((self->private_impl.f_width <= 0u) || (self->private_impl.f_height <= 0u)) {
if ((a_width <= 0u) || (self->private_impl.f_height <= 0u)) {
return wuffs_base__make_empty_struct();
}
v_w4 = ((uint64_t)((self->private_impl.f_width * 4u)));
v_w4 = ((uint64_t)((a_width * 4u)));
v_curr_row = wuffs_base__utility__empty_slice_u8();
if (v_w4 <= ((uint64_t)(a_pix.len))) {
v_curr_row = wuffs_base__slice_u8__subslice_j(a_pix, v_w4);
@@ -88523,7 +89940,7 @@ wuffs_webp__decoder__apply_transform_predictor(
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
}
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[0u]));
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_tiles_per_row = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_y = 1u;
while (v_y < self->private_impl.f_height) {
@@ -88555,7 +89972,7 @@ wuffs_webp__decoder__apply_transform_predictor(
#endif
}
v_x = 1u;
while (v_x < self->private_impl.f_width) {
while (v_x < a_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
@@ -88851,6 +90268,7 @@ static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_cross_color(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
uint32_t a_width,
wuffs_base__slice_u8 a_tile_data) {
uint32_t v_tile_size_log2 = 0;
uint32_t v_tiles_per_row = 0;
@@ -88867,7 +90285,7 @@ wuffs_webp__decoder__apply_transform_cross_color(
uint8_t v_r = 0;
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[1u]));
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_tiles_per_row = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_y = 0u;
while (v_y < self->private_impl.f_height) {
@@ -88877,7 +90295,7 @@ wuffs_webp__decoder__apply_transform_cross_color(
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
}
v_x = 0u;
while (v_x < self->private_impl.f_width) {
while (v_x < a_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
v_g2r = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[0u]);
v_g2b = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[1u]);
@@ -88948,7 +90366,8 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_color_indexing(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix) {
wuffs_base__slice_u8 a_pix,
uint32_t a_width) {
uint32_t v_tile_size_log2 = 0;
uint32_t v_bits_per_pixel = 0;
uint32_t v_x_mask = 0;
@@ -88995,8 +90414,8 @@ wuffs_webp__decoder__apply_transform_color_indexing(
v_src_index = ((uint64_t)((self->private_impl.f_workbuf_offset_for_color_indexing + 1u)));
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_di = ((uint64_t)((4u * v_y * self->private_impl.f_width)));
v_dj = ((uint64_t)((4u * (v_y + 1u) * self->private_impl.f_width)));
v_di = ((uint64_t)((4u * v_y * a_width)));
v_dj = ((uint64_t)((4u * (v_y + 1u) * a_width)));
if ((v_di > v_dj) || (v_dj > ((uint64_t)(a_pix.len)))) {
break;
}
@@ -89025,866 +90444,11 @@ wuffs_webp__decoder__apply_transform_color_indexing(
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.get_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__get_quirk(
const wuffs_webp__decoder* self,
uint32_t a_key) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return 0u;
}
// -------- func webp.decoder.set_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__set_quirk(
wuffs_webp__decoder* self,
uint32_t a_key,
uint64_t a_value) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
// -------- func webp.decoder.decode_image_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 1)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_image_config(self, a_dst, a_src);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_image_config
// -------- func webp.decoder.do_decode_frame_vp8l
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 0u) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1179011410u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
self->private_impl.f_riff_chunk_length = t_1;
}
if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_riff_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_dst, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_riff_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_riff_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if ( ! self->private_impl.f_is_vp8_lossy && (a_dst != NULL)) {
wuffs_base__image_config__set(
a_dst,
self->private_impl.f_pixfmt,
0u,
self->private_impl.f_width,
self->private_impl.f_height,
self->private_impl.f_frame_config_io_position,
false);
}
self->private_impl.f_call_sequence = 32u;
ok:
self->private_impl.p_do_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1346520407u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
if (v_c32 == 540561494u) {
self->private_impl.f_is_vp8_lossy = true;
} else if (v_c32 == 1278758998u) {
} else if (v_c32 == 1480085590u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
} else {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
if (num_bits_2 == 24) {
t_2 = ((uint32_t)(*scratch));
break;
}
num_bits_2 += 8u;
*scratch |= ((uint64_t)(num_bits_2)) << 56;
}
}
self->private_impl.f_sub_chunk_length = t_2;
}
if (self->private_impl.f_sub_chunk_length < 4u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
if (self->private_impl.f_is_vp8_lossy) {
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
}
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
if (self->private_impl.f_is_vp8_lossy) {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_3 = wuffs_vp8__decoder__decode_image_config(&self->private_data.f_vp8, a_dst, a_src);
v_status = t_3;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
} else {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_4 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src);
v_status = t_4;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
}
ok:
self->private_impl.p_do_decode_image_config_limited = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited_vp8l
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint32_t v_transform_size = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_0 = *iop_a_src++;
v_c32 = t_0;
}
if (v_c32 != 47u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
self->private_impl.f_pixfmt = 2415954056u;
if ((v_c32 & 1u) != 0u) {
self->private_impl.f_pixfmt = 2164295816u;
}
v_c32 >>= 1u;
if (v_c32 != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + 0u);
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + v_transform_size);
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
goto ok;
ok:
self->private_impl.p_do_decode_image_config_limited_vp8l = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 2)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
if (self->private_impl.f_is_vp8_lossy) {
{
wuffs_base__status t_0 = wuffs_vp8__decoder__decode_frame_config(&self->private_data.f_vp8, a_dst, a_src);
v_status = t_0;
}
} else {
{
wuffs_base__status t_1 = wuffs_webp__decoder__do_decode_frame_config(self, a_dst, a_src);
v_status = t_1;
}
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 2 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__pixel_format v_pixfmt = {0};
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 32u) {
} else if (self->private_impl.f_call_sequence < 32u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_image_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 40u) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
} else if (self->private_impl.f_call_sequence == 64u) {
self->private_impl.f_call_sequence = 96u;
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
if (a_dst != NULL) {
v_pixfmt = wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt);
wuffs_base__frame_config__set(
a_dst,
wuffs_base__utility__make_rect_ie_u32(
0u,
0u,
self->private_impl.f_width,
self->private_impl.f_height),
((wuffs_base__flicks)(0u)),
0u,
self->private_impl.f_frame_config_io_position,
0u,
false,
false,
wuffs_base__pixel_format__default_background_color(&v_pixfmt));
}
self->private_impl.f_call_sequence = 64u;
ok:
self->private_impl.p_do_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_dst || !a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 3)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
if (self->private_impl.f_is_vp8_lossy) {
{
wuffs_base__status t_0 = wuffs_vp8__decoder__decode_frame(&self->private_data.f_vp8,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_0;
}
} else {
{
wuffs_base__status t_1 = wuffs_webp__decoder__do_decode_frame(self,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_1;
}
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder__do_decode_frame_vp8l(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
@@ -89916,30 +90480,13 @@ wuffs_webp__decoder__do_decode_frame(
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_vp8l;
if (coro_susp_point) {
v_width = self->private_data.s_do_decode_frame.v_width;
v_width = self->private_data.s_do_decode_frame_vp8l.v_width;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 64u) {
} else if (self->private_impl.f_call_sequence < 64u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
self->private_impl.f_seen_transform[0u] = false;
self->private_impl.f_seen_transform[1u] = false;
self->private_impl.f_seen_transform[2u] = false;
@@ -89948,7 +90495,7 @@ wuffs_webp__decoder__do_decode_frame(
while (true) {
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
@@ -89968,7 +90515,7 @@ wuffs_webp__decoder__do_decode_frame(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -89984,7 +90531,7 @@ wuffs_webp__decoder__do_decode_frame(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -89996,7 +90543,7 @@ wuffs_webp__decoder__do_decode_frame(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -90008,7 +90555,7 @@ wuffs_webp__decoder__do_decode_frame(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -90017,10 +90564,7 @@ wuffs_webp__decoder__do_decode_frame(
goto suspend;
}
while (true) {
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len)))) {
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
@@ -90050,13 +90594,18 @@ wuffs_webp__decoder__do_decode_frame(
break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
}
if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
v_width = self->private_impl.f_width;
if (self->private_impl.f_seen_transform[3u] && (((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) <= ((uint64_t)(v_pix.len)))) {
v_pix = wuffs_base__slice_u8__subslice_i(v_pix, ((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)));
v_width = self->private_impl.f_color_indexing_width;
}
v_which = self->private_impl.f_n_transforms;
while (v_which > 0u) {
v_which -= 1u;
@@ -90070,14 +90619,15 @@ wuffs_webp__decoder__do_decode_frame(
}
}
if (v_transform_type == 0u) {
wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_tile_data);
wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_width, v_tile_data);
} else if (v_transform_type == 1u) {
wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_tile_data);
wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_width, v_tile_data);
} else if (v_transform_type == 2u) {
wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix);
} else {
wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix);
} else if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) <= ((uint64_t)(a_workbuf.len))) {
v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
v_width = self->private_impl.f_width;
wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix, v_width);
}
}
v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, a_blend);
@@ -90094,14 +90644,14 @@ wuffs_webp__decoder__do_decode_frame(
self->private_impl.f_call_sequence = 96u;
ok:
self->private_impl.p_do_decode_frame = 0;
self->private_impl.p_do_decode_frame_vp8l = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_do_decode_frame.v_width = v_width;
self->private_impl.p_do_decode_frame_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_do_decode_frame_vp8l.v_width = v_width;
goto exit;
exit:
@@ -90126,6 +90676,7 @@ wuffs_webp__decoder__decode_transform(
uint8_t v_c8 = 0;
uint32_t v_transform_type = 0;
uint32_t v_tile_size_log2 = 0;
uint32_t v_width = 0;
wuffs_base__slice_u8 v_p = {0};
const uint8_t* iop_a_src = NULL;
@@ -90170,9 +90721,6 @@ wuffs_webp__decoder__decode_transform(
if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) {
status = wuffs_base__make_status(wuffs_webp__error__bad_transform);
goto exit;
} else if (self->private_impl.f_seen_transform[3u]) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_transform_after_color_indexing_transform);
goto exit;
}
self->private_impl.f_seen_transform[v_transform_type] = true;
self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type));
@@ -90222,6 +90770,10 @@ wuffs_webp__decoder__decode_transform(
goto suspend;
}
while (true) {
v_width = self->private_impl.f_width;
if (self->private_impl.f_seen_transform[3u]) {
v_width = self->private_impl.f_color_indexing_width;
}
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
@@ -90235,7 +90787,7 @@ wuffs_webp__decoder__decode_transform(
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))),
a_src,
((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
((v_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(),
0u);
@@ -90721,10 +91273,13 @@ wuffs_webp__decoder__swizzle(
wuffs_base__slice_u8 v_dst = {0};
uint32_t v_y = 0;
if (a_dst == NULL) {
return wuffs_base__make_status(NULL);
}
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
wuffs_base__pixel_buffer__pixel_format(a_dst),
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)),
wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt),
wuffs_base__utility__make_pixel_format(2164295816u),
wuffs_base__utility__empty_slice_u8(),
a_blend);
if ( ! wuffs_base__status__is_ok(&v_status)) {
@@ -90752,6 +91307,1308 @@ wuffs_webp__decoder__swizzle(
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.get_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__get_quirk(
const wuffs_webp__decoder* self,
uint32_t a_key) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return 0u;
}
// -------- func webp.decoder.set_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__set_quirk(
wuffs_webp__decoder* self,
uint32_t a_key,
uint64_t a_value) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
// -------- func webp.decoder.decode_image_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 1)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_image_config(self, a_dst, a_src);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_image_config
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 0u) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1179011410u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
self->private_impl.f_riff_chunk_length = t_1;
}
if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
self->private_impl.f_rcl_remaining = self->private_impl.f_riff_chunk_length;
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_rcl_remaining)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_dst, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rcl_remaining, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_rcl_remaining == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if ((self->private_impl.f_variant != 1u) && (a_dst != NULL)) {
wuffs_base__image_config__set(
a_dst,
2164295816u,
0u,
self->private_impl.f_width,
self->private_impl.f_height,
self->private_impl.f_frame_config_io_position,
false);
}
self->private_impl.f_call_sequence = 32u;
ok:
self->private_impl.p_do_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1346520407u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
if (v_c32 == 540561494u) {
self->private_impl.f_variant = 1u;
} else if (v_c32 == 1278758998u) {
self->private_impl.f_variant = 2u;
} else if (v_c32 == 1480085590u) {
self->private_impl.f_variant = 4u;
} else {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
if (num_bits_2 == 24) {
t_2 = ((uint32_t)(*scratch));
break;
}
num_bits_2 += 8u;
*scratch |= ((uint64_t)(num_bits_2)) << 56;
}
}
self->private_impl.f_sub_chunk_length = t_2;
}
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
if (self->private_impl.f_variant == 1u) {
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
} else if (self->private_impl.f_variant == 2u) {
} else if (self->private_impl.f_sub_chunk_length != 10u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
if (self->private_impl.f_variant == 1u) {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_3 = wuffs_vp8__decoder__decode_image_config(&self->private_data.f_vp8, a_dst, a_src);
v_status = t_3;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
} else if (self->private_impl.f_variant == 2u) {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_4 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src);
v_status = t_4;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
} else {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_5 = wuffs_webp__decoder__do_decode_image_config_limited_vp8x(self, a_src);
v_status = t_5;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
}
ok:
self->private_impl.p_do_decode_image_config_limited = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited_vp8l
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint32_t v_transform_size = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_0 = *iop_a_src++;
v_c32 = t_0;
}
if (v_c32 != 47u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
v_c32 >>= 1u;
if (v_c32 != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + 0u);
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + v_transform_size);
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
goto ok;
ok:
self->private_impl.p_do_decode_image_config_limited_vp8l = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited_vp8x
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8x(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint32_t v_transform_size = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8x;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited_vp8x.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8x.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if ((v_c32 & 4294967233u) != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
}
self->private_impl.f_vp8x_header_flags = ((uint8_t)((v_c32 | 1u)));
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) {
t_1 = ((uint32_t)(wuffs_base__peek_u24le__no_bounds_check(iop_a_src)));
iop_a_src += 3;
} else {
self->private_data.s_do_decode_image_config_limited_vp8x.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8x.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 16) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
if (v_c32 >= 16383u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
}
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) {
t_2 = ((uint32_t)(wuffs_base__peek_u24le__no_bounds_check(iop_a_src)));
iop_a_src += 3;
} else {
self->private_data.s_do_decode_image_config_limited_vp8x.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8x.scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
if (num_bits_2 == 16) {
t_2 = ((uint32_t)(*scratch));
break;
}
num_bits_2 += 8u;
*scratch |= ((uint64_t)(num_bits_2)) << 56;
}
}
v_c32 = t_2;
}
if (v_c32 >= 16383u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
}
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + 0u);
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + v_transform_size);
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
v_status = wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_riff_chunk_length)) << 1u) | 1u));
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
}
v_status = wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 1836840961u, (((uint64_t)(self->private_impl.f_width)) | (((uint64_t)(self->private_impl.f_height)) << 32u)));
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
}
goto ok;
ok:
self->private_impl.p_do_decode_image_config_limited_vp8x = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited_vp8x = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 2)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
if (self->private_impl.f_variant == 1u) {
{
wuffs_base__status t_0 = wuffs_vp8__decoder__decode_frame_config(&self->private_data.f_vp8, a_dst, a_src);
v_status = t_0;
}
} else {
{
wuffs_base__status t_1 = wuffs_webp__decoder__do_decode_frame_config(self, a_dst, a_src);
v_status = t_1;
}
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 2 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 32u) {
} else if (self->private_impl.f_call_sequence < 32u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_image_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 40u) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
} else if (self->private_impl.f_call_sequence == 64u) {
self->private_impl.f_call_sequence = 96u;
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
if ((self->private_impl.f_variant != 1u) && (a_dst != NULL)) {
wuffs_base__frame_config__set(
a_dst,
wuffs_base__utility__make_rect_ie_u32(
0u,
0u,
self->private_impl.f_width,
self->private_impl.f_height),
((wuffs_base__flicks)(0u)),
0u,
self->private_impl.f_frame_config_io_position,
0u,
false,
false,
0u);
}
self->private_impl.f_call_sequence = 64u;
ok:
self->private_impl.p_do_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_dst || !a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 3)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_frame(self,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 64u) {
} else if (self->private_impl.f_call_sequence < 64u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
while (((uint8_t)(self->private_impl.f_variant & 3u)) == 0u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_frame.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_frame.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
self->private_impl.f_sub_chunk_type = t_0;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_frame.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_frame.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
self->private_impl.f_sub_chunk_length = t_1;
}
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
if (self->private_impl.f_sub_chunk_length > 2147483647u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
}
if (self->private_impl.f_sub_chunk_type == 1346585417u) {
if (self->private_impl.f_variant > 4u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 32u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
self->private_impl.f_variant = 8u;
} else if (self->private_impl.f_sub_chunk_type == 1296649793u) {
if (self->private_impl.f_variant > 8u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 2u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
self->private_impl.f_variant = 16u;
} else if (self->private_impl.f_sub_chunk_type == 1179471425u) {
if (self->private_impl.f_variant > 16u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 2u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
self->private_impl.f_variant = 32u;
} else if (self->private_impl.f_sub_chunk_type == 1213221953u) {
if (self->private_impl.f_variant > 32u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 16u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
self->private_impl.f_variant = 64u;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_webp__decoder__decode_alph(self, a_src, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 1836840960u, 1u);
} else if (self->private_impl.f_sub_chunk_type == 540561494u) {
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
self->private_impl.f_variant = 129u;
break;
} else if (self->private_impl.f_sub_chunk_type == 1278758998u) {
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 16u)) != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_alph_vp8l_combination);
goto exit;
}
self->private_impl.f_variant = 130u;
break;
} else if (self->private_impl.f_sub_chunk_type == 542133592u) {
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 4u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
} else if (self->private_impl.f_sub_chunk_type == 1179211845u) {
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 8u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
}
self->private_data.s_do_decode_frame.scratch = self->private_impl.f_sub_chunk_length;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
if (self->private_data.s_do_decode_frame.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_do_decode_frame.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_do_decode_frame.scratch;
if (self->private_impl.f_sub_chunk_has_padding) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src++;
}
}
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
if (((uint8_t)(self->private_impl.f_variant & 1u)) != 0u) {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_vp8__decoder__decode_frame(&self->private_data.f_vp8,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
} else {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_3 = wuffs_webp__decoder__do_decode_frame_vp8l(self,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_3;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
}
ok:
self->private_impl.p_do_decode_frame = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.frame_dirty_rect
WUFFS_BASE__GENERATED_C_CODE
@@ -90766,7 +92623,7 @@ wuffs_webp__decoder__frame_dirty_rect(
return wuffs_base__utility__empty_rect_ie_u32();
}
if (self->private_impl.f_is_vp8_lossy) {
if (self->private_impl.f_variant == 1u) {
return wuffs_vp8__decoder__frame_dirty_rect(&self->private_data.f_vp8);
}
return wuffs_base__utility__make_rect_ie_u32(
@@ -90807,7 +92664,7 @@ wuffs_webp__decoder__num_decoded_frame_configs(
return 0;
}
if (self->private_impl.f_is_vp8_lossy) {
if (self->private_impl.f_variant == 1u) {
return wuffs_vp8__decoder__num_decoded_frame_configs(&self->private_data.f_vp8);
}
if (self->private_impl.f_call_sequence > 32u) {
@@ -90830,7 +92687,7 @@ wuffs_webp__decoder__num_decoded_frames(
return 0;
}
if (self->private_impl.f_is_vp8_lossy) {
if (self->private_impl.f_variant == 1u) {
return wuffs_vp8__decoder__num_decoded_frames(&self->private_data.f_vp8);
}
if (self->private_impl.f_call_sequence > 64u) {
@@ -90859,7 +92716,7 @@ wuffs_webp__decoder__restart_frame(
wuffs_base__status v_status = wuffs_base__make_status(NULL);
if (self->private_impl.f_is_vp8_lossy) {
if (self->private_impl.f_variant == 1u) {
v_status = wuffs_vp8__decoder__restart_frame(&self->private_data.f_vp8, a_index, a_io_position);
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
}
@@ -90941,10 +92798,21 @@ wuffs_webp__decoder__workbuf_len(
return wuffs_base__utility__empty_range_ii_u64();
}
if (self->private_impl.f_is_vp8_lossy) {
wuffs_base__range_ii_u64 v_r = {0};
wuffs_base__range_ii_u64 v_s = {0};
if (self->private_impl.f_variant == 1u) {
return wuffs_vp8__decoder__workbuf_len(&self->private_data.f_vp8);
}
return wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])));
v_r = wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])));
if (self->private_impl.f_variant != 2u) {
v_s = wuffs_vp8__decoder__workbuf_len(&self->private_data.f_vp8);
if (wuffs_base__range_ii_u64__is_empty(&v_s)) {
return v_s;
}
v_r = wuffs_base__utility__make_range_ii_u64(wuffs_base__u64__max(wuffs_private_impl__range_ii_u64__get_min_incl(&v_s), wuffs_private_impl__range_ii_u64__get_min_incl(&v_r)), wuffs_base__u64__max(wuffs_private_impl__range_ii_u64__get_max_incl(&v_s), wuffs_private_impl__range_ii_u64__get_max_incl(&v_r)));
}
return v_r;
}
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
@@ -95406,6 +97274,9 @@ redirect:
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_CICP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CICP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
interested_in_metadata_after_the_frame = true;
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
@@ -95499,8 +97370,9 @@ redirect:
}
wuffs_base__pixel_buffer pixel_buffer = alloc_pixbuf_result.pixbuf;
if (valid_background_color) {
wuffs_base__status pb_scufr_status = pixel_buffer.set_color_u32_fill_rect(
pixel_buffer.pixcfg.bounds(), background_color);
wuffs_base__status pb_scufr_status =
pixel_buffer.set_color_u32_argb_premul_fill_rect(
pixel_buffer.pixcfg.bounds(), background_color);
if (pb_scufr_status.repr != nullptr) {
return DecodeImageResult(pb_scufr_status.message());
}
@@ -95509,6 +97381,9 @@ redirect:
// Allocate the work buffer. Wuffs' decoders conventionally assume that this
// can be uninitialized memory.
wuffs_base__range_ii_u64 workbuf_len = image_decoder->workbuf_len();
if (workbuf_len.is_empty()) {
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
DecodeImageCallbacks::AllocWorkbufResult alloc_workbuf_result =
callbacks.AllocWorkbuf(workbuf_len, true);
if (!alloc_workbuf_result.error_message.empty()) {
@@ -96449,7 +98324,12 @@ wuffs_drop_in__stb__load1( //
}
uint64_t pixbuf_len = (uint64_t)w * (uint64_t)h * (uint64_t)desired_channels;
uint64_t workbuf_len = wuffs_base__image_decoder__workbuf_len(dec).max_incl;
wuffs_base__range_ii_u64 r = wuffs_base__image_decoder__workbuf_len(dec);
if (wuffs_base__range_ii_u64__is_empty(&r)) {
wuffs_drop_in__stb__g_failure_reason = "indeterminate workbuf length";
return NULL;
}
uint64_t workbuf_len = r.max_incl;
#if SIZE_MAX < 0xFFFFFFFFFFFFFFFFull
if ((pixbuf_len > ((uint64_t)SIZE_MAX)) ||
(workbuf_len > ((uint64_t)SIZE_MAX))) {
+260
View File
@@ -0,0 +1,260 @@
// Copyright 2026 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//go:build ignore
// +build ignore
package main
// convert-nie-to-png.go decodes NIA from stdin and encodes (animated) PNG to
// stdout.
//
// Usage: go run convert-nia-to-apng.go < foo.nia > foo.png
import (
"bytes"
"errors"
"io"
"os"
"github.com/google/wuffs/lib/uncompng"
)
func main() {
if err := main1(); err != nil {
os.Stderr.WriteString(err.Error() + "\n")
os.Exit(1)
}
}
func main1() error {
// When writing APNG, we need to know (at the start of the file) the
// animation's number of frames, but when reading NIA, we only know that at
// the end of the file.
//
// We therefore use io.ReadAll, slurping the entire NIA data into memory
// instead of using the io.Reader streaming API directly, so that we can
// make two passes over the NIA data.
niaBytes, err := io.ReadAll(os.Stdin)
if err != nil {
return err
} else if len(niaBytes) < 24 {
return errors.New("input is not in the NIA format")
}
premultiplied := niaBytes[6] == 'p'
depth8 := niaBytes[7] == '8'
width := u32le(niaBytes[8:])
height := u32le(niaBytes[12:])
padded := !depth8 && ((width & 1) != 0) && ((height & 1) != 0)
if (u32le(niaBytes[:]) != 0x41AF_C36E) || // 0x41AF_C36E is 'nïA'le.
(niaBytes[4] != 0xFF) ||
(niaBytes[5] != 'b') ||
((niaBytes[6] != 'n') && (niaBytes[6] != 'p')) ||
((niaBytes[7] != '4') && (niaBytes[7] != '8')) ||
(width >= 0x8000_0000) ||
(height >= 0x8000_0000) {
return errors.New("input is not in the NIA format")
} else if (width > 0xFF_FFFF) || (height > 0xFF_FFFF) {
return errors.New("input is in an unsupported NIA format")
}
nieSize := calculateNIESize(depth8, width, height)
if nieSize < 0 {
return errors.New("input image dimensions are unsupported (too large)")
} else if nieSize < 16 {
panic("unreachable")
}
// NIA's depth8 is measured in *bytes* per *pixel*, but uncompng's depth is
// measured *bits* per *channel* (times four channels, for BGRA).
depth := uncompng.Depth8
if depth8 {
depth = uncompng.Depth16
}
expectedNieHeader := append([]byte(nil), niaBytes[:16]...)
expectedNieHeader[3] = 'E'
numFrames := uint64(0)
prevCDD := uint64(0)
lastCDD := uint64(0)
for buf := niaBytes[16:]; len(buf) >= 8; numFrames++ {
cdd := u64le(buf)
if (cdd >> 32) == 0x8000_0000 {
lastCDD = cdd
break
} else if ((cdd >> 32) > 0x8000_0000) || (cdd < prevCDD) {
return errors.New("bad CDD (Cumulative Display Duration)")
}
buf = buf[8:]
if int64(len(buf)) < nieSize {
return errors.New("bad NIE frame")
} else if !bytes.Equal(buf[:16], expectedNieHeader) {
return errors.New("bad NIE header")
}
buf = buf[nieSize:]
if padded {
if len(buf) < 4 {
return errors.New("bad NIE padding")
}
buf = buf[4:]
}
prevCDD = cdd
}
enc := uncompng.AnimationEncoder{}
if err := enc.EncodeHeader(
os.Stdout, depth, uncompng.ColorTypeNRGBA,
int(width), int(height), uint32(numFrames), uint32(lastCDD)); err != nil {
return err
}
prevCDD = 0
for buf := niaBytes[16:]; len(buf) >= 8; {
cdd := u64le(buf)
if (cdd >> 32) >= 0x8000_0000 {
break
}
buf = buf[8:]
if depth8 {
swapBlueRedEndian8(buf[16:nieSize])
if premultiplied {
unpremultiply8(buf[16:nieSize])
}
} else {
swapBlueRedEndian4(buf[16:nieSize])
if premultiplied {
unpremultiply4(buf[16:nieSize])
}
}
numer, denom := calculateDurationRatio(cdd - prevCDD)
if err := enc.EncodeFrame(
os.Stdout, buf[16:nieSize], 4*int(width), numer, denom); err != nil {
return err
}
buf = buf[nieSize:]
if padded {
buf = buf[4:]
}
prevCDD = cdd
}
return nil
}
// swapBlueRedEndian4 corrects for the fact that NIA uses little-endian BGRA
// order but the *Go* lib/uncompng library (unlike the *C* snippet/uncompng.c)
// uses big-endian RGBA order, the same as the Go standard library (and PNG).
func swapBlueRedEndian4(buf []byte) {
for ; len(buf) >= 4; buf = buf[4:] {
buf[0], buf[2] = buf[2], buf[0]
}
}
func swapBlueRedEndian8(buf []byte) {
for ; len(buf) >= 8; buf = buf[8:] {
buf[0], buf[1], buf[4], buf[5] = buf[5], buf[4], buf[1], buf[0]
buf[2], buf[3], buf[6], buf[7] = buf[3], buf[2], buf[7], buf[6]
}
}
func unpremultiply4(buf []byte) {
for ; len(buf) >= 4; buf = buf[4:] {
r := 0x101 * uint32(buf[0])
g := 0x101 * uint32(buf[1])
b := 0x101 * uint32(buf[2])
a := 0x101 * uint32(buf[3])
if (a == 0xFFFF) || (a == 0x0000) {
continue
}
r = (r * 0xFFFF) / a
g = (g * 0xFFFF) / a
b = (b * 0xFFFF) / a
buf[0] = byte(r >> 8)
buf[1] = byte(g >> 8)
buf[2] = byte(b >> 8)
}
}
func unpremultiply8(buf []byte) {
for ; len(buf) >= 4; buf = buf[4:] {
r := (uint32(buf[0]) << 8) | uint32(buf[1])
g := (uint32(buf[2]) << 8) | uint32(buf[3])
b := (uint32(buf[4]) << 8) | uint32(buf[5])
a := (uint32(buf[6]) << 8) | uint32(buf[7])
if (a == 0xFFFF) || (a == 0x0000) {
continue
}
r = (r * 0xFFFF) / a
g = (g * 0xFFFF) / a
b = (b * 0xFFFF) / a
buf[0] = byte(r >> 8)
buf[1] = byte(r >> 0)
buf[2] = byte(g >> 8)
buf[3] = byte(g >> 0)
buf[4] = byte(b >> 8)
buf[5] = byte(b >> 0)
}
}
// calculateDurationRatio converts from a time duration measured in flicks
// (frame-ticks, 1 / 705600000 of a second, to APNG's representation, which is
// a ratio of two uint16 values.
//
// TODO: be smarter about how to express a durationInFlicks that isn't an
// integer number of milliseconds (or is over 65.535 seconds). For now, just
// hard-code the denominator to 1000, meaning milliseconds, and round to
// nearest (capped at 65535) to get the numerator.
func calculateDurationRatio(durationInFlicks uint64) (numerator uint16, denominator uint16) {
const flicksPerMillisecond = 705600
millis := (durationInFlicks + (flicksPerMillisecond / 2)) / flicksPerMillisecond
return uint16(min(0xFFFF, millis)), 1000
}
func calculateNIESize(depth8 bool, width uint32, height uint32) int64 {
const maxInt64 = (1 << 63) - 1
const maxUint64 = (1 << 64) - 1
n := uint64(width) * uint64(height) * 4
if depth8 {
if n > (maxUint64 / 2) {
return -1
}
n *= 2
}
if n > (maxInt64 - 16) {
return -1
}
return int64(n + 16)
}
func u32le(b []byte) uint32 {
return (uint32(b[0]) << 0) |
(uint32(b[1]) << 8) |
(uint32(b[2]) << 16) |
(uint32(b[3]) << 24)
}
func u64le(b []byte) uint64 {
return (uint64(b[0]) << 0) |
(uint64(b[1]) << 8) |
(uint64(b[2]) << 16) |
(uint64(b[3]) << 24) |
(uint64(b[4]) << 32) |
(uint64(b[5]) << 40) |
(uint64(b[6]) << 48) |
(uint64(b[7]) << 56)
}
+193
View File
@@ -0,0 +1,193 @@
// Copyright 2026 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// ----------------
// This exercises snippet/uncompng.c to write a large APNG image to stdout.
//
// It is a C port of lib/uncompng's TestAnimationEncoderLarge.
//
// Run it from the Wuffs root directory, the one that contains the
// wuffs-root-directory.txt file, so that it can find and read the
// test/data/hibiscus.regular.bmp file.
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>
#define UNCOMPNG_CONFIG__STATIC_FUNCTIONS
#define UNCOMPNG_IMPLEMENTATION
#include "../snippet/uncompng.c"
#define WUFFS_CONFIG__MODULES
#define WUFFS_CONFIG__MODULE__BASE
#define WUFFS_CONFIG__MODULE__BMP
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#define WUFFS_IMPLEMENTATION
#include "../release/c/wuffs-unsupported-snapshot.c"
#define IMAGE_HEIGHT 442
#define IMAGE_WIDTH 312
#define NUM_FRAMES 5
#define NUM_PLAYS 0
#define SRC_BMP_SIZE 413850
static uint8_t g_src_bmp[SRC_BMP_SIZE];
static uint8_t g_src_pixels[IMAGE_WIDTH * IMAGE_HEIGHT * 4];
bool //
load_src_bmp() {
int fd = open("test/data/hibiscus.regular.bmp", O_RDONLY, 0);
if (fd == -1) {
fprintf(stderr, "FAIL: open: %s\n", strerror(errno));
return false;
}
for (ssize_t num_read = 0; num_read < SRC_BMP_SIZE;) {
ssize_t n = read(fd, g_src_bmp + num_read, sizeof(g_src_bmp) - num_read);
if (n > 0) {
num_read += n;
} else if (n == 0) {
break;
} else if (errno == EINTR) {
// No-op.
} else {
close(fd);
fprintf(stderr, "FAIL: read: %s\n", strerror(errno));
return false;
}
}
close(fd);
return true;
}
bool //
load_src_pixels() {
static wuffs_bmp__decoder dec;
wuffs_base__io_buffer src = wuffs_base__make_io_buffer(
wuffs_base__make_slice_u8(g_src_bmp, SRC_BMP_SIZE),
wuffs_base__make_io_buffer_meta(SRC_BMP_SIZE, 0, 0, true));
wuffs_base__status status = wuffs_bmp__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION, WUFFS_INITIALIZE__DEFAULT_OPTIONS);
if (!wuffs_base__status__is_ok(&status)) {
fprintf(stderr, "FAIL: initialize: %s\n",
wuffs_base__status__message(&status));
return false;
}
wuffs_base__image_config ic;
status = wuffs_bmp__decoder__decode_image_config(&dec, &ic, &src);
if (!wuffs_base__status__is_ok(&status)) {
fprintf(stderr, "FAIL: decode_image_config: %s\n",
wuffs_base__status__message(&status));
return false;
}
uint32_t w = wuffs_base__pixel_config__width(&ic.pixcfg);
uint32_t h = wuffs_base__pixel_config__height(&ic.pixcfg);
uint32_t pixfmt = wuffs_base__pixel_config__pixel_format(&ic.pixcfg).repr;
if ((w != IMAGE_WIDTH) || (h != IMAGE_HEIGHT) ||
(pixfmt != WUFFS_BASE__PIXEL_FORMAT__BGRX)) {
fprintf(stderr, "FAIL: decode_image_config: unexpected configuration\n");
return false;
}
if ((WUFFS_BASE__PIXEL_FORMAT__BGRX != UNCOMPNG__PIXEL_FORMAT__BGRX) ||
(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL !=
UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL)) {
fprintf(stderr, "FAIL: wuffs and uncompng are incompatible\n");
return false;
}
wuffs_base__pixel_config__set(&ic.pixcfg,
WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL,
WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);
wuffs_base__pixel_buffer pb;
status = wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg,
wuffs_base__make_slice_u8(&g_src_pixels[0], sizeof g_src_pixels));
if (!wuffs_base__status__is_ok(&status)) {
fprintf(stderr, "FAIL: set_from_slice: %s\n",
wuffs_base__status__message(&status));
return false;
}
status = wuffs_bmp__decoder__decode_frame(&dec, &pb, &src,
WUFFS_BASE__PIXEL_BLEND__SRC,
wuffs_base__empty_slice_u8(), NULL);
if (!wuffs_base__status__is_ok(&status)) {
fprintf(stderr, "FAIL: decode_frame: %s\n",
wuffs_base__status__message(&status));
return false;
}
return true;
}
int //
my_write_func(void* context, const uint8_t* data_ptr, size_t data_len) {
static const int stdout_fd = 1;
return (write(stdout_fd, data_ptr, data_len) < 0) ? -errno : 0;
}
int //
main(int argc, char** argv) {
if (!load_src_bmp() || !load_src_pixels()) {
return 1;
}
// Change "if (0)" to "if (1)" to write a still (not animated) PNG.
if (0) {
const int frame = 0;
return uncompng__encode( //
&my_write_func, NULL, //
UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL, IMAGE_WIDTH, IMAGE_HEIGHT, //
&g_src_pixels[0], sizeof(g_src_pixels), IMAGE_WIDTH * 4);
}
static uint16_t delay_millis[NUM_FRAMES] = {300, 500, 600, 400, 200};
int err0 = uncompng__encode_apng_header( //
&my_write_func, NULL, //
UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL, IMAGE_WIDTH, IMAGE_HEIGHT, //
NUM_FRAMES, NUM_PLAYS);
if (err0) {
return err0;
}
for (int frame = 0; frame < NUM_FRAMES; frame++) {
int err1 = uncompng__encode_apng_frame( //
&my_write_func, NULL, //
delay_millis[frame], 1000, //
&g_src_pixels[0], sizeof(g_src_pixels), IMAGE_WIDTH * 4);
if (err1) {
return err1;
}
// Over time, set the R, G, B, A channel values to 0x80.
//
// Use RGBA order, not BGRA, to match the output of lib/uncompng's
// TestAnimationEncoderLarge, in Go.
if (frame < 4) {
static size_t order[4] = {2, 1, 0, 3};
for (size_t i = order[frame]; i < sizeof(g_src_pixels); i += 4) {
g_src_pixels[i] = 0x80;
}
}
}
return 0;
}
+87
View File
@@ -0,0 +1,87 @@
// Copyright 2026 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// ----------------
// This exercises snippet/uncompng.c to write a small APNG image to stdout.
//
// It is a C port of lib/uncompng's TestAnimationEncoderSmall.
#include <errno.h>
#include <unistd.h>
#define UNCOMPNG_CONFIG__STATIC_FUNCTIONS
#define UNCOMPNG_IMPLEMENTATION
#include "../snippet/uncompng.c"
#define IMAGE_HEIGHT 2
#define IMAGE_WIDTH 3
#define NUM_FRAMES 2
#define NUM_PLAYS 10
int //
my_write_func(void* context, const uint8_t* data_ptr, size_t data_len) {
static const int stdout_fd = 1;
return (write(stdout_fd, data_ptr, data_len) < 0) ? -errno : 0;
}
int //
main(int argc, char** argv) {
static uint8_t pixels[NUM_FRAMES][IMAGE_WIDTH * IMAGE_HEIGHT * 4] = {
{
0xFF, 0x00, 0x00, 0xFF, // Blue.
0xFF, 0xFF, 0xFF, 0xFF, // White.
0x00, 0x00, 0xFF, 0xFF, // Red.
0xFF, 0x00, 0x00, 0xFF, // Blue.
0xFF, 0xFF, 0xFF, 0xFF, // White.
0x00, 0x00, 0xFF, 0xFF, // Red.
},
{
0x00, 0xFF, 0x00, 0xFF, // Green.
0xFF, 0xFF, 0xFF, 0xFF, // White.
0x00, 0x00, 0xFF, 0xFF, // Red.
0x00, 0xFF, 0x00, 0xFF, // Green.
0xFF, 0xFF, 0xFF, 0xFF, // White.
0x00, 0x00, 0xFF, 0xFF, // Red.
}};
// Change "if (0)" to "if (1)" to write a still (not animated) PNG.
if (0) {
const int frame = 0;
return uncompng__encode( //
&my_write_func, NULL, //
UNCOMPNG__PIXEL_FORMAT__BGRX, IMAGE_WIDTH, IMAGE_HEIGHT, //
&pixels[frame][0], sizeof(pixels[frame]), IMAGE_WIDTH * 4);
}
static uint16_t delay_millis[NUM_FRAMES] = {1000, 2000};
int err0 = uncompng__encode_apng_header( //
&my_write_func, NULL, //
UNCOMPNG__PIXEL_FORMAT__BGRX, IMAGE_WIDTH, IMAGE_HEIGHT, //
NUM_FRAMES, NUM_PLAYS);
if (err0) {
return err0;
}
for (int frame = 0; frame < NUM_FRAMES; frame++) {
int err1 = uncompng__encode_apng_frame( //
&my_write_func, NULL, //
delay_millis[frame], 1000, //
&pixels[frame][0], sizeof(pixels[frame]), IMAGE_WIDTH * 4);
if (err1) {
return err1;
}
}
return 0;
}
+67
View File
@@ -0,0 +1,67 @@
// Copyright 2026 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// ----------------
// This exercises snippet/uncompng.c to write a Julia Set image to stdout.
//
// See also
// https://nigeltao.github.io/blog/2025/uncompressed-png.html
#include <errno.h>
#include <unistd.h>
#define UNCOMPNG_CONFIG__STATIC_FUNCTIONS
#define UNCOMPNG_IMPLEMENTATION
#include "../snippet/uncompng.c"
#define CONFIG_CX -0.70000f
#define CONFIG_CY +0.27015f
#define CONFIG_IMAGE_WIDTH 256
#define CONFIG_IMAGE_HEIGHT 256
int //
my_write_func(void* context, const uint8_t* data_ptr, size_t data_len) {
static const int stdout_fd = 1;
return (write(stdout_fd, data_ptr, data_len) < 0) ? -errno : 0;
}
uint8_t //
my_pixel_func(float fx, float fy) {
static const float escape_distance_squared = 100.0f;
for (int i = 255; i > 0; i--) {
float distance_squared = (fx * fx) + (fy * fy);
if (distance_squared >= escape_distance_squared) {
return i;
}
float gx = CONFIG_CX + (fx * fx) - (fy * fy);
float gy = CONFIG_CY + (2 * fx * fy);
fx = gx;
fy = gy;
}
return 0;
}
int //
main(int argc, char** argv) {
static const float w2 = CONFIG_IMAGE_WIDTH / 2;
static const float h2 = CONFIG_IMAGE_HEIGHT / 2;
static uint8_t pixels[CONFIG_IMAGE_HEIGHT][CONFIG_IMAGE_WIDTH];
for (int iy = 0; iy < CONFIG_IMAGE_HEIGHT; iy++) {
float fy = (iy - h2) / h2;
for (int ix = 0; ix < CONFIG_IMAGE_WIDTH; ix++) {
float fx = (ix - w2) / w2;
pixels[iy][ix] = my_pixel_func(fx, fy);
}
}
return uncompng__encode(&my_write_func, NULL, UNCOMPNG__PIXEL_FORMAT__Y,
CONFIG_IMAGE_WIDTH, CONFIG_IMAGE_HEIGHT,
&pixels[0][0], sizeof(pixels), CONFIG_IMAGE_WIDTH);
}
+6
View File
@@ -279,6 +279,11 @@ print_metadata(wuffs_base__image_decoder* dec,
printf(" %" PRId32 "\n", minfo.metadata_parsed__chrm(i));
}
break;
case WUFFS_BASE__FOURCC__CICP:
for (uint32_t i = 0; i < 4; i++) {
printf(" %" PRId32 "\n", minfo.metadata_parsed__cicp(i));
}
break;
case WUFFS_BASE__FOURCC__GAMA:
printf(" %" PRIu32 "\n", minfo.metadata_parsed__gama());
break;
@@ -417,6 +422,7 @@ redirect:
}
dec->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
dec->set_report_metadata(WUFFS_BASE__FOURCC__CICP, true);
dec->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
dec->set_report_metadata(WUFFS_BASE__FOURCC__GAMA, true);
dec->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
+10
View File
@@ -33,6 +33,11 @@
#ifndef BASIC_HANDSUM_DECODE_INCLUDE_GUARD
#define BASIC_HANDSUM_DECODE_INCLUDE_GUARD
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
#if defined(BASIC_HANDSUM_DECODE_CONFIG__STATIC_FUNCTIONS)
#define BASIC_HANDSUM_DECODE__MAYBE_STATIC static
#else
@@ -483,4 +488,9 @@ basic_handsum_decode__decode(basic_handsum_decode__pixel_buffer* dst,
}
#endif // BASIC_HANDSUM_DECODE_IMPLEMENTATION
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif // BASIC_HANDSUM_DECODE_INCLUDE_GUARD
+10
View File
@@ -27,6 +27,11 @@
#ifndef PARSE_COLOR_INCLUDE_GUARD
#define PARSE_COLOR_INCLUDE_GUARD
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
#if defined(PARSE_COLOR_CONFIG__STATIC_FUNCTIONS)
#define PARSE_COLOR__MAYBE_STATIC static
#else
@@ -200,4 +205,9 @@ parse_color(const char* s_ptr, size_t s_len) {
}
#endif // PARSE_COLOR_IMPLEMENTATION
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif // PARSE_COLOR_INCLUDE_GUARD
+399 -104
View File
@@ -29,6 +29,11 @@
#ifndef UNCOMPNG_INCLUDE_GUARD
#define UNCOMPNG_INCLUDE_GUARD
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
#if defined(UNCOMPNG_CONFIG__STATIC_FUNCTIONS)
#define UNCOMPNG__MAYBE_STATIC static
#else
@@ -62,8 +67,9 @@
// also return its own negative error codes, which are passed on.
#define UNCOMPNG__RESULT__OK 0
#define UNCOMPNG__RESULT__INVALID_ARGUMENT 1
#define UNCOMPNG__RESULT__UNSUPPORTED_IMAGE_SIZE 2
#define UNCOMPNG__RESULT__CONCURRENT_CALL 3
#define UNCOMPNG__RESULT__INVALID_CALL_SEQUENCE 2
#define UNCOMPNG__RESULT__UNSUPPORTED_IMAGE_SIZE 3
#define UNCOMPNG__RESULT__CONCURRENT_CALL 4
// UNCOMPNG__DATA_LEN__INCL_MAX is the inclusive maximum value of write_func's
// data_len argument. In hexadecimal, it equals 0x10000u.
@@ -101,6 +107,28 @@ uncompng__encode(int (*write_func)(void* context,
size_t pixel_len,
size_t stride);
UNCOMPNG__MAYBE_STATIC int //
uncompng__encode_apng_header(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
uint32_t pixel_format,
uint32_t width,
uint32_t height,
uint32_t num_frames,
uint32_t num_plays);
UNCOMPNG__MAYBE_STATIC int //
uncompng__encode_apng_frame(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
uint16_t delay_numerator,
uint16_t delay_denominator,
const uint8_t* pixel_ptr,
size_t pixel_len,
size_t stride);
// --------
#ifdef UNCOMPNG_IMPLEMENTATION
@@ -171,10 +199,109 @@ uncompng__private_impl_crc32_ieee(const uint8_t* ptr, size_t len) {
static uint8_t uncompng__private_impl_buffer[65536];
static void //
uncompng__private_impl_initialize_buffer(uint32_t width,
uint32_t height,
uint32_t pixel_format) {
static struct uncompng__private_impl_apng_encoder_state_struct {
uint32_t pixel_format;
uint32_t width;
uint32_t height;
uint32_t seq_num;
uint32_t num_frames;
uint32_t cur_frame;
} uncompng__private_impl_apng_encoder_state;
static int //
uncompng__private_impl_encode_frame_header(uint32_t delay_numerator,
uint32_t delay_denominator) {
uncompng__private_impl_buffer[0x0000] = 0;
uncompng__private_impl_buffer[0x0001] = 0;
uncompng__private_impl_buffer[0x0002] = 0;
uncompng__private_impl_buffer[0x0003] = 0x1A;
uncompng__private_impl_buffer[0x0004] = 'f';
uncompng__private_impl_buffer[0x0005] = 'c';
uncompng__private_impl_buffer[0x0006] = 'T';
uncompng__private_impl_buffer[0x0007] = 'L';
uncompng__private_impl_buffer[0x0008] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.seq_num >> 24);
uncompng__private_impl_buffer[0x0009] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.seq_num >> 16);
uncompng__private_impl_buffer[0x000A] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.seq_num >> 8);
uncompng__private_impl_buffer[0x000B] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.seq_num >> 0);
uncompng__private_impl_buffer[0x000C] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.width >> 24);
uncompng__private_impl_buffer[0x000D] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.width >> 16);
uncompng__private_impl_buffer[0x000E] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.width >> 8);
uncompng__private_impl_buffer[0x000F] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.width >> 0);
uncompng__private_impl_buffer[0x0010] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.height >> 24);
uncompng__private_impl_buffer[0x0011] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.height >> 16);
uncompng__private_impl_buffer[0x0012] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.height >> 8);
uncompng__private_impl_buffer[0x0013] =
(uint8_t)(uncompng__private_impl_apng_encoder_state.height >> 0);
uncompng__private_impl_buffer[0x0014] = 0;
uncompng__private_impl_buffer[0x0015] = 0;
uncompng__private_impl_buffer[0x0016] = 0;
uncompng__private_impl_buffer[0x0017] = 0;
uncompng__private_impl_buffer[0x0018] = 0;
uncompng__private_impl_buffer[0x0019] = 0;
uncompng__private_impl_buffer[0x001A] = 0;
uncompng__private_impl_buffer[0x001B] = 0;
uncompng__private_impl_buffer[0x001C] = (uint8_t)(delay_numerator >> 8);
uncompng__private_impl_buffer[0x001D] = (uint8_t)(delay_numerator >> 0);
uncompng__private_impl_buffer[0x001E] = (uint8_t)(delay_denominator >> 8);
uncompng__private_impl_buffer[0x001F] = (uint8_t)(delay_denominator >> 0);
uncompng__private_impl_buffer[0x0020] = 0;
uncompng__private_impl_buffer[0x0021] = 0;
uint32_t fctl_crc32 = uncompng__private_impl_crc32_ieee(
uncompng__private_impl_buffer + 0x0004, 0x0022 - 0x0004);
uncompng__private_impl_buffer[0x0022] = (uint8_t)(fctl_crc32 >> 24);
uncompng__private_impl_buffer[0x0023] = (uint8_t)(fctl_crc32 >> 16);
uncompng__private_impl_buffer[0x0024] = (uint8_t)(fctl_crc32 >> 8);
uncompng__private_impl_buffer[0x0025] = (uint8_t)(fctl_crc32 >> 0);
int use_idat = uncompng__private_impl_apng_encoder_state.seq_num ? 0 : 1;
uncompng__private_impl_apng_encoder_state.seq_num++;
uncompng__private_impl_buffer[0x0026] = 0;
uncompng__private_impl_buffer[0x0027] = 0;
uncompng__private_impl_buffer[0x0028] = 0;
uncompng__private_impl_buffer[0x0029] = 0;
uncompng__private_impl_buffer[0x002A] = "fI"[use_idat];
uncompng__private_impl_buffer[0x002B] = "dD"[use_idat];
uncompng__private_impl_buffer[0x002C] = 'A';
uncompng__private_impl_buffer[0x002D] = 'T';
int ej = 0x002E;
if (!use_idat) {
uint32_t seq_num = uncompng__private_impl_apng_encoder_state.seq_num++;
uncompng__private_impl_buffer[0x002E] = (uint8_t)(seq_num >> 24);
uncompng__private_impl_buffer[0x002F] = (uint8_t)(seq_num >> 16);
uncompng__private_impl_buffer[0x0030] = (uint8_t)(seq_num >> 8);
uncompng__private_impl_buffer[0x0031] = (uint8_t)(seq_num >> 0);
ej = 0x0032;
}
uncompng__private_impl_buffer[ej + 0x00] = 0x78;
uncompng__private_impl_buffer[ej + 0x01] = 0x01;
uncompng__private_impl_buffer[ej + 0x02] = 0;
uncompng__private_impl_buffer[ej + 0x03] = 0;
uncompng__private_impl_buffer[ej + 0x04] = 0;
uncompng__private_impl_buffer[ej + 0x05] = 0;
uncompng__private_impl_buffer[ej + 0x06] = 0;
return ej + 0x07;
}
static int //
uncompng__private_impl_encode_image_header(uint32_t pixel_format,
uint32_t width,
uint32_t height,
uint32_t num_frames,
uint32_t num_plays) {
uncompng__private_impl_buffer[0x0000] = 0x89;
uncompng__private_impl_buffer[0x0001] = 'P';
uncompng__private_impl_buffer[0x0002] = 'N';
@@ -230,7 +357,7 @@ uncompng__private_impl_initialize_buffer(uint32_t width,
color_type = 2;
break;
default:
return;
return 0;
}
uncompng__private_impl_buffer[0x0018] = depth;
uncompng__private_impl_buffer[0x0019] = color_type;
@@ -245,6 +372,32 @@ uncompng__private_impl_initialize_buffer(uint32_t width,
uncompng__private_impl_buffer[0x001F] = (uint8_t)(ihdr_crc32 >> 8);
uncompng__private_impl_buffer[0x0020] = (uint8_t)(ihdr_crc32 >> 0);
if (num_frames > 0) {
uncompng__private_impl_buffer[0x0021] = 0;
uncompng__private_impl_buffer[0x0022] = 0;
uncompng__private_impl_buffer[0x0023] = 0;
uncompng__private_impl_buffer[0x0024] = 0x08;
uncompng__private_impl_buffer[0x0025] = 'a';
uncompng__private_impl_buffer[0x0026] = 'c';
uncompng__private_impl_buffer[0x0027] = 'T';
uncompng__private_impl_buffer[0x0028] = 'L';
uncompng__private_impl_buffer[0x0029] = (uint8_t)(num_frames >> 24);
uncompng__private_impl_buffer[0x002A] = (uint8_t)(num_frames >> 16);
uncompng__private_impl_buffer[0x002B] = (uint8_t)(num_frames >> 8);
uncompng__private_impl_buffer[0x002C] = (uint8_t)(num_frames >> 0);
uncompng__private_impl_buffer[0x002D] = (uint8_t)(num_plays >> 24);
uncompng__private_impl_buffer[0x002E] = (uint8_t)(num_plays >> 16);
uncompng__private_impl_buffer[0x002F] = (uint8_t)(num_plays >> 8);
uncompng__private_impl_buffer[0x0030] = (uint8_t)(num_plays >> 0);
uint32_t actl_crc32 = uncompng__private_impl_crc32_ieee(
uncompng__private_impl_buffer + 0x0025, 0x0031 - 0x0025);
uncompng__private_impl_buffer[0x0031] = (uint8_t)(actl_crc32 >> 24);
uncompng__private_impl_buffer[0x0032] = (uint8_t)(actl_crc32 >> 16);
uncompng__private_impl_buffer[0x0033] = (uint8_t)(actl_crc32 >> 8);
uncompng__private_impl_buffer[0x0034] = (uint8_t)(actl_crc32 >> 0);
return 0x0035;
}
uncompng__private_impl_buffer[0x0021] = 0;
uncompng__private_impl_buffer[0x0022] = 0;
uncompng__private_impl_buffer[0x0023] = 0;
@@ -260,10 +413,7 @@ uncompng__private_impl_initialize_buffer(uint32_t width,
uncompng__private_impl_buffer[0x002D] = 0;
uncompng__private_impl_buffer[0x002E] = 0;
uncompng__private_impl_buffer[0x002F] = 0;
uncompng__private_impl_buffer[0xFFFC] = 0;
uncompng__private_impl_buffer[0xFFFD] = 0;
uncompng__private_impl_buffer[0xFFFE] = 0;
uncompng__private_impl_buffer[0xFFFF] = 1;
return 0x0030;
}
static void //
@@ -295,39 +445,41 @@ uncompng__private_impl_flush(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
int ej,
bool final) {
static const int ei_first = 0x0030;
static const int ei_later = 0x000D;
int crc32_start = 0;
int ei = 0;
if (uncompng__private_impl_buffer[0x0004] == 0x0D) {
uint32_t idat_chunk_len = ej - 0x0029;
if (final) {
idat_chunk_len += 4;
}
uncompng__private_impl_buffer[0x0021] = (uint8_t)(idat_chunk_len >> 24);
uncompng__private_impl_buffer[0x0022] = (uint8_t)(idat_chunk_len >> 16);
uncompng__private_impl_buffer[0x0023] = (uint8_t)(idat_chunk_len >> 8);
uncompng__private_impl_buffer[0x0024] = (uint8_t)(idat_chunk_len >> 0);
crc32_start = 0x0025;
ei = ei_first;
} else {
uint32_t idat_chunk_len = ej - 0x0008;
if (final) {
idat_chunk_len += 4;
}
uncompng__private_impl_buffer[0x0000] = (uint8_t)(idat_chunk_len >> 24);
uncompng__private_impl_buffer[0x0001] = (uint8_t)(idat_chunk_len >> 16);
uncompng__private_impl_buffer[0x0002] = (uint8_t)(idat_chunk_len >> 8);
uncompng__private_impl_buffer[0x0003] = (uint8_t)(idat_chunk_len >> 0);
crc32_start = 0x0004;
ei = ei_later;
uint32_t f_type,
int* ptr_to_ej,
bool final_idat_of_frame) {
int idat_chunk_start = 0;
if (uncompng__private_impl_buffer[0x0007] == 0x0A) {
idat_chunk_start = 0x0021;
} else if (uncompng__private_impl_buffer[0x0007] == 0x4C) {
idat_chunk_start = 0x0026;
}
int ei = idat_chunk_start + 13;
if (uncompng__private_impl_buffer[0x0007] != 0x54) {
ei += 2;
}
if ((f_type & 1) == 0) {
ei += 4;
}
int ej = *ptr_to_ej;
int idat_chunk_len = ej - (idat_chunk_start + 8);
if (final_idat_of_frame) {
idat_chunk_len += 4;
}
uncompng__private_impl_buffer[idat_chunk_start + 0] =
(uint8_t)(idat_chunk_len >> 24);
uncompng__private_impl_buffer[idat_chunk_start + 1] =
(uint8_t)(idat_chunk_len >> 16);
uncompng__private_impl_buffer[idat_chunk_start + 2] =
(uint8_t)(idat_chunk_len >> 8);
uncompng__private_impl_buffer[idat_chunk_start + 3] =
(uint8_t)(idat_chunk_len >> 0);
uint32_t deflate_block_len = (uint32_t)(ej - ei);
uncompng__private_impl_buffer[ei - 5] = final ? 1 : 0;
uncompng__private_impl_buffer[ei - 5] = final_idat_of_frame ? 1 : 0;
uncompng__private_impl_buffer[ei - 4] =
0x00u ^ (uint8_t)(deflate_block_len >> 0);
uncompng__private_impl_buffer[ei - 3] =
@@ -338,7 +490,7 @@ uncompng__private_impl_flush(int (*write_func)(void* context,
0xFFu ^ (uint8_t)(deflate_block_len >> 8);
uncompng__private_impl_update_adler32(ei, ej);
if (final) {
if (final_idat_of_frame) {
uncompng__private_impl_buffer[ej + 0] =
uncompng__private_impl_buffer[0xFFFC];
uncompng__private_impl_buffer[ej + 1] =
@@ -350,6 +502,7 @@ uncompng__private_impl_flush(int (*write_func)(void* context,
ej += 4;
}
int crc32_start = idat_chunk_start + 4;
uint32_t idat_crc32 = uncompng__private_impl_crc32_ieee(
uncompng__private_impl_buffer + crc32_start, ej - crc32_start);
uncompng__private_impl_buffer[ej + 0] = (uint8_t)(idat_crc32 >> 24);
@@ -358,19 +511,35 @@ uncompng__private_impl_flush(int (*write_func)(void* context,
uncompng__private_impl_buffer[ej + 3] = (uint8_t)(idat_crc32 >> 0);
ej += 4;
if (!final) {
if (!final_idat_of_frame) {
int err0 =
(*write_func)(context, uncompng__private_impl_buffer, (size_t)ej);
if (err0 != 0) {
return err0;
}
uncompng__private_impl_buffer[0x0004] = 'I';
uncompng__private_impl_buffer[0x0005] = 'D';
int t = f_type & 1;
uncompng__private_impl_buffer[0x0004] = "fI"[t];
uncompng__private_impl_buffer[0x0005] = "dD"[t];
uncompng__private_impl_buffer[0x0006] = 'A';
uncompng__private_impl_buffer[0x0007] = 'T';
if (t) {
*ptr_to_ej = 0x000D + 0;
return 0;
}
uint32_t seq_num = uncompng__private_impl_apng_encoder_state.seq_num++;
uncompng__private_impl_buffer[0x0008] = (uint8_t)(seq_num >> 24);
uncompng__private_impl_buffer[0x0009] = (uint8_t)(seq_num >> 16);
uncompng__private_impl_buffer[0x000A] = (uint8_t)(seq_num >> 8);
uncompng__private_impl_buffer[0x000B] = (uint8_t)(seq_num >> 0);
*ptr_to_ej = 0x000D + 4;
return 0;
}
if ((f_type & 2) == 0) {
return (*write_func)(context, uncompng__private_impl_buffer, (size_t)ej);
}
static const uint8_t iend_chunk[] = {
0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
};
@@ -398,31 +567,31 @@ uncompng__private_impl_flush(int (*write_func)(void* context,
}
static int //
uncompng__private_impl_do_encode(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
const uint8_t* pixel_ptr,
size_t pixel_len,
uint32_t width,
uint32_t height,
size_t stride,
uint32_t pixel_format) {
static const int ei_first = 0x0030;
static const int ei_later = 0x000D;
uncompng__private_impl_encode_frame_payload(
int (*write_func)(void* context, const uint8_t* data_ptr, size_t data_len),
void* context,
uint32_t f_type,
uint32_t pixel_format,
uint32_t width,
uint32_t height,
const uint8_t* pixel_ptr,
size_t pixel_len,
size_t stride,
int ej) {
uncompng__private_impl_buffer[0xFFFC] = 0;
uncompng__private_impl_buffer[0xFFFD] = 0;
uncompng__private_impl_buffer[0xFFFE] = 0;
uncompng__private_impl_buffer[0xFFFF] = 1;
static const int ej_max = 0xFFF8;
uncompng__private_impl_initialize_buffer(width, height, pixel_format);
int ej = ei_first;
for (uint32_t y = 0; y < height; y++) {
if ((ej + 1) > ej_max) {
int err = uncompng__private_impl_flush(write_func, context, ej, false);
int err =
uncompng__private_impl_flush(write_func, context, f_type, &ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = 0;
@@ -432,12 +601,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__Y:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 1) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[0];
row += 1;
@@ -447,12 +615,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__Y_16LE:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 2) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[1];
uncompng__private_impl_buffer[ej++] = row[0];
@@ -463,12 +630,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__YXXX:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 1) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[0];
row += 4;
@@ -478,12 +644,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__YXXX_4X16LE:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 2) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[1];
uncompng__private_impl_buffer[ej++] = row[0];
@@ -494,12 +659,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 4) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[2];
uncompng__private_impl_buffer[ej++] = row[1];
@@ -512,12 +676,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 8) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[5];
uncompng__private_impl_buffer[ej++] = row[4];
@@ -534,12 +697,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__BGRX:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 3) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[2];
uncompng__private_impl_buffer[ej++] = row[1];
@@ -551,12 +713,11 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
case UNCOMPNG__PIXEL_FORMAT__BGRX_4X16LE:
for (uint32_t x = 0; x < width; x++) {
if ((ej + 6) > ej_max) {
int err =
uncompng__private_impl_flush(write_func, context, ej, false);
int err = uncompng__private_impl_flush(write_func, context, f_type,
&ej, false);
if (err != 0) {
return err;
}
ej = ei_later;
}
uncompng__private_impl_buffer[ej++] = row[5];
uncompng__private_impl_buffer[ej++] = row[4];
@@ -573,21 +734,20 @@ uncompng__private_impl_do_encode(int (*write_func)(void* context,
}
}
return uncompng__private_impl_flush(write_func, context, ej, true);
return uncompng__private_impl_flush(write_func, context, f_type, &ej, true);
}
UNCOMPNG__MAYBE_STATIC int //
uncompng__encode(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
uint32_t pixel_format,
uint32_t width,
uint32_t height,
const uint8_t* pixel_ptr,
size_t pixel_len,
size_t stride) {
if (!write_func) {
static int //
uncompng__private_impl_check_arguments(
int (*write_func)(void* context, const uint8_t* data_ptr, size_t data_len),
uint32_t pixel_format,
uint32_t width,
uint32_t height,
uint32_t num_frames,
bool extras,
size_t pixel_len,
size_t stride) {
if (!write_func || !width || !height || !num_frames) {
return UNCOMPNG__RESULT__INVALID_ARGUMENT;
}
uint64_t bytes_per_pixel;
@@ -615,7 +775,7 @@ uncompng__encode(int (*write_func)(void* context,
return UNCOMPNG__RESULT__UNSUPPORTED_IMAGE_SIZE;
}
if (height > 0u) {
if (extras && (height > 0u)) {
// This calculation is similar to the one used in
// wuffs_base__table__flattened_length.
uint64_t n = ((uint64_t)stride * (uint64_t)(height - 1u)) +
@@ -625,6 +785,26 @@ uncompng__encode(int (*write_func)(void* context,
}
}
return 0;
}
UNCOMPNG__MAYBE_STATIC int //
uncompng__encode(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
uint32_t pixel_format,
uint32_t width,
uint32_t height,
const uint8_t* pixel_ptr,
size_t pixel_len,
size_t stride) {
int check = uncompng__private_impl_check_arguments(
write_func, pixel_format, width, height, 1, true, pixel_len, stride);
if (check != 0) {
return check;
}
// uncompng__private_impl_buffer is a global variable in this C code, unlike
// the original Go code, so try to reject concurrent use. This isn't perfect,
// as it doesn't use atomics, but it's better than nothing.
@@ -633,12 +813,127 @@ uncompng__encode(int (*write_func)(void* context,
return UNCOMPNG__RESULT__CONCURRENT_CALL;
}
concurrent = true;
int ret = uncompng__private_impl_do_encode(write_func, context, pixel_ptr,
pixel_len, width, height, stride,
pixel_format);
int ej = uncompng__private_impl_encode_image_header(pixel_format, width,
height, 0, 0);
int ret = uncompng__private_impl_encode_frame_payload( //
write_func, context, 3, //
pixel_format, width, height, //
pixel_ptr, pixel_len, stride, ej);
concurrent = false;
return ret;
}
UNCOMPNG__MAYBE_STATIC int //
uncompng__encode_apng_header(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
uint32_t pixel_format,
uint32_t width,
uint32_t height,
uint32_t num_frames,
uint32_t num_plays) {
int check = uncompng__private_impl_check_arguments(
write_func, pixel_format, width, height, num_frames, false, 0, 0);
if (check != 0) {
return check;
}
static volatile bool concurrent = false;
if (concurrent) {
return UNCOMPNG__RESULT__CONCURRENT_CALL;
}
concurrent = true;
uncompng__private_impl_apng_encoder_state.pixel_format = pixel_format;
uncompng__private_impl_apng_encoder_state.width = width;
uncompng__private_impl_apng_encoder_state.height = height;
uncompng__private_impl_apng_encoder_state.seq_num = 0;
uncompng__private_impl_apng_encoder_state.num_frames = num_frames;
uncompng__private_impl_apng_encoder_state.cur_frame = 0;
int ej = uncompng__private_impl_encode_image_header(
pixel_format, width, height, num_frames, num_plays);
int ret = (*write_func)(context, uncompng__private_impl_buffer, (size_t)ej);
concurrent = false;
return ret;
}
UNCOMPNG__MAYBE_STATIC int //
uncompng__encode_apng_frame(int (*write_func)(void* context,
const uint8_t* data_ptr,
size_t data_len),
void* context,
uint16_t delay_numerator,
uint16_t delay_denominator,
const uint8_t* pixel_ptr,
size_t pixel_len,
size_t stride) {
if (uncompng__private_impl_apng_encoder_state.num_frames == 0) {
return UNCOMPNG__RESULT__INVALID_CALL_SEQUENCE;
} else if (uncompng__private_impl_apng_encoder_state.seq_num >= 0x80000000u) {
return UNCOMPNG__RESULT__UNSUPPORTED_IMAGE_SIZE;
}
int check = uncompng__private_impl_check_arguments( //
write_func, //
uncompng__private_impl_apng_encoder_state.pixel_format, //
uncompng__private_impl_apng_encoder_state.width, //
uncompng__private_impl_apng_encoder_state.height, //
uncompng__private_impl_apng_encoder_state.num_frames, //
true, pixel_len, stride);
if (check != 0) {
return check;
}
static volatile bool concurrent = false;
if (concurrent) {
return UNCOMPNG__RESULT__CONCURRENT_CALL;
}
concurrent = true;
uint32_t f_type = 4;
if (uncompng__private_impl_apng_encoder_state.cur_frame == 0) {
f_type |= 1;
}
uncompng__private_impl_apng_encoder_state.cur_frame++;
if (uncompng__private_impl_apng_encoder_state.cur_frame ==
uncompng__private_impl_apng_encoder_state.num_frames) {
f_type |= 2;
}
int ej = uncompng__private_impl_encode_frame_header(delay_numerator,
delay_denominator);
int ret = uncompng__private_impl_encode_frame_payload( //
write_func, context, f_type, //
uncompng__private_impl_apng_encoder_state.pixel_format, //
uncompng__private_impl_apng_encoder_state.width, //
uncompng__private_impl_apng_encoder_state.height, //
pixel_ptr, pixel_len, stride, ej);
if (ret || (uncompng__private_impl_apng_encoder_state.num_frames ==
uncompng__private_impl_apng_encoder_state.cur_frame)) {
uncompng__private_impl_apng_encoder_state.pixel_format = 0;
uncompng__private_impl_apng_encoder_state.width = 0;
uncompng__private_impl_apng_encoder_state.height = 0;
uncompng__private_impl_apng_encoder_state.seq_num = 0;
uncompng__private_impl_apng_encoder_state.num_frames = 0;
uncompng__private_impl_apng_encoder_state.cur_frame = 0;
}
concurrent = false;
return ret;
}
#endif // UNCOMPNG_IMPLEMENTATION
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif // UNCOMPNG_INCLUDE_GUARD
+25
View File
@@ -32,6 +32,7 @@ pub struct decoder? implements base.image_decoder(
call_sequence : base.u8,
report_metadata_chrm : base.bool,
report_metadata_cicp : base.bool,
report_metadata_exif : base.bool,
report_metadata_gama : base.bool,
report_metadata_iccp : base.bool,
@@ -47,6 +48,7 @@ pub struct decoder? implements base.image_decoder(
seen_actl : base.bool,
seen_chrm : base.bool,
seen_cicp : base.bool,
seen_fctl : base.bool,
seen_exif : base.bool,
seen_gama : base.bool,
@@ -582,6 +584,15 @@ pri func decoder.decode_other_chunk?(src: base.io_reader, framy: base.bool) {
this.seen_chrm = true
}
} else if this.chunk_type == 'cICP'le {
if this.report_metadata_cicp {
if this.seen_cicp {
return "#bad chunk"
}
this.decode_cicp?(src: args.src)
this.seen_cicp = true
}
} else if this.chunk_type == 'fcTL'le {
if this.seen_fctl {
return "#bad chunk"
@@ -694,6 +705,18 @@ pri func decoder.decode_chrm?(src: base.io_reader) {
this.metadata_z |= (0xFF_FFFF & u) << 40
}
pri func decoder.decode_cicp?(src: base.io_reader) {
if this.chunk_length <> 4 {
return "#bad chunk"
}
this.chunk_length = 0
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_PARSED
this.metadata_fourcc = 'CICP'be
this.metadata_x = args.src.read_u32le_as_u64?()
this.metadata_y = 0
this.metadata_z = 0
}
pri func decoder.decode_exif?(src: base.io_reader) {
if this.chunk_length < 4 {
return "#bad chunk"
@@ -1410,6 +1433,8 @@ pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.sta
pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
if args.fourcc == 'CHRM'be {
this.report_metadata_chrm = args.report
} else if args.fourcc == 'CICP'be {
this.report_metadata_cicp = args.report
} else if args.fourcc == 'EXIF'be {
this.report_metadata_exif = args.report
} else if args.fourcc == 'GAMA'be {
+58
View File
@@ -1082,6 +1082,47 @@ test_wuffs_strconv_parse_number_f64_regular() {
}
}
// Input that ends right after a sign or an exponent marker must be rejected
// without reading past the end of the slice. Use DEFAULT_OPTIONS, as
// ALLOW_UNDERSCORES takes a different code path.
{
const char* strs[] = {"", "+", "-", "1e", "1E", "12.5e"};
for (size_t i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(strs); i++) {
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
wuffs_base__make_slice_u8((uint8_t*)(void*)strs[i], strlen(strs[i])),
WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
if (r.status.repr != wuffs_base__error__bad_argument) {
RETURN_FAIL("\"%s\": have \"%s\", want \"%s\"", strs[i], r.status.repr,
wuffs_base__error__bad_argument);
}
}
}
// Test the integer part being more than 800 digits.
{
// Initialize buf to "1222...222e-805" with 805 twos.
char buf[1024];
buf[0] = '1';
for (int i = 1; i < 806; i++) {
buf[i] = '2';
}
memcpy(buf + 806, "e-805", 5);
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
wuffs_base__make_slice_u8((uint8_t*)(void*)buf, 811),
WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
uint64_t have =
(r.status.repr == NULL)
? wuffs_base__ieee_754_bit_representation__from_f64_to_u64(r.value)
: fail;
uint64_t want = wuffs_base__ieee_754_bit_representation__from_f64_to_u64(
1.2222222222222222222222222222222222222222222222222222222222222222);
if (have != want) {
RETURN_FAIL("\"%s\": have 0x%016" PRIX64 ", want 0x%016" PRIX64,
"1222...222e-805", have, want);
}
}
return NULL;
}
@@ -1245,6 +1286,23 @@ test_wuffs_strconv_parse_number_u64() {
}
}
// A bare "0x" or "0d" prefix is invalid, even with
// ALLOW_MULTIPLE_LEADING_ZEROES. Pass an explicit length (not strlen) so
// that the byte just past the end of the slice is a digit, which must not be
// read.
{
const char* strs[] = {"0x7", "0X7", "0d7", "0D7"};
for (size_t i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(strs); i++) {
wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
wuffs_base__make_slice_u8((uint8_t*)(void*)strs[i], 2),
WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES);
if (r.status.repr != wuffs_base__error__bad_argument) {
RETURN_FAIL("\"%.2s\": have \"%s\", want \"%s\"", strs[i],
r.status.repr, wuffs_base__error__bad_argument);
}
}
}
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES.
{
for (int o = 0; o < 2; o++) {
Binary file not shown.
Binary file not shown.