mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Compare commits
61
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7f70dda95c | ||
|
|
0d8b52336e | ||
|
|
0baab7fe72 | ||
|
|
c99f5af9fe | ||
|
|
fb8926614b | ||
|
|
2fa1d20d76 | ||
|
|
9d41525a2f | ||
|
|
2a6876f8bb | ||
|
|
c677bef7fd | ||
|
|
ab24b06450 | ||
|
|
1f513d8023 | ||
|
|
89b7cc7a36 | ||
|
|
b2e6da3024 | ||
|
|
72045c951e | ||
|
|
f31d952b62 | ||
|
|
fbb65550ac | ||
|
|
5f95a0d49a | ||
|
|
e0f1efc4a6 | ||
|
|
56250f1f27 | ||
|
|
b1adeeccb1 | ||
|
|
b77e1a67de | ||
|
|
c944c491c4 | ||
|
|
4abc399eaa | ||
|
|
901b740c00 | ||
|
|
3d46062176 | ||
|
|
1ca418ef16 | ||
|
|
742e8b78d9 | ||
|
|
5049107b90 | ||
|
|
193d0354b4 | ||
|
|
26ce8600a1 | ||
|
|
05a8209fa7 | ||
|
|
0f214ba59c | ||
|
|
504f8485f4 | ||
|
|
ce863060d6 | ||
|
|
2f7e714ab0 | ||
|
|
e772ccd47a | ||
|
|
1230506e7c | ||
|
|
b89fd2fa03 | ||
|
|
aad70fdfa5 | ||
|
|
466cf6f15d | ||
|
|
c4df79d82e | ||
|
|
59176bb0c7 | ||
|
|
16d6267451 | ||
|
|
5d5fb1d6d9 | ||
|
|
0fe5509f1b | ||
|
|
7b71d6840a | ||
|
|
d9cf0751ca | ||
|
|
5f398130e8 | ||
|
|
e7f6c79752 | ||
|
|
2a97911e02 | ||
|
|
9d8285b52e | ||
|
|
8e909c8ccf | ||
|
|
6e9e2e00c2 | ||
|
|
be6327a548 | ||
|
|
bd3b33770e | ||
|
|
e3bda4efc9 | ||
|
|
8515165bee | ||
|
|
183beab481 | ||
|
|
c2f44c84d1 | ||
|
|
0918f99bc1 | ||
|
|
30835a0132 |
No files matched your search
@@ -1,5 +1,7 @@
|
||||
name: CIFuzz
|
||||
on: [pull_request]
|
||||
permissions: read-all
|
||||
|
||||
jobs:
|
||||
Fuzzing:
|
||||
runs-on: ubuntu-latest
|
||||
@@ -16,7 +18,7 @@ jobs:
|
||||
fuzz-seconds: 600
|
||||
dry-run: false
|
||||
- name: Upload Crash
|
||||
uses: actions/upload-artifact@v1
|
||||
uses: actions/upload-artifact@v4
|
||||
if: failure()
|
||||
with:
|
||||
name: artifacts
|
||||
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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.
|
||||
|
||||
@@ -117,6 +117,39 @@ Some more examples:
|
||||
- `0x197816_7DF74000 = "text/html/.." = "text/html"`
|
||||
- `0x197816_B215E800 = "text/plai/.." = "text/plain"`
|
||||
|
||||
For another fits-in-53-bits example, BCP 47 language tags can use base38
|
||||
3+1/2+2/1+1 encoding, `lllx/ssrr/yz`, where the l, s and r base-38 digits hold
|
||||
the commonly-used language, script and region subtags. The x, y and z base-38
|
||||
digits hold the rarely-used extlang, variant and extension or other subtags.
|
||||
|
||||
- `0x0B2084_000004C0 = "ca../..../v." = ca-valencia`
|
||||
- `0x0D1688_00000000 = "en../..../.." = en`
|
||||
- `0x0D32BC_00060000 = "es../..41/.." = es-419`
|
||||
- `0x0E0370_000FC800 = "fr../..ca/.." = fr-CA`
|
||||
- `0x138442_00000000 = "mas./..../.." = mas`
|
||||
- `0x1DFF1E_7DF14800 = "yue./hthk/.." = yue-Hant-HK`
|
||||
- `0x1E89E8_7DAE2000 = "zh../hs../.." = zh-Hans`
|
||||
|
||||
|
||||
### Powers of 38
|
||||
|
||||
In case you want to roll your own bit-packing.
|
||||
|
||||
```
|
||||
38 ** 1 = 38 = 0x________________26 ≈ 6 bits
|
||||
38 ** 2 = 1444 = 0x_______________5A4 ≈ 11 bits
|
||||
38 ** 3 = 54872 = 0x______________D658 ≈ 16 bits
|
||||
38 ** 4 = 2_085136 = 0x____________1FD110 ≈ 21 bits
|
||||
38 ** 5 = 79_235168 = 0x___________4B90860 ≈ 27 bits
|
||||
38 ** 6 = 3010_936384 = 0x__________B3773E40 ≈ 32 bits
|
||||
38 ** 7 = 114415_582592 = 0x_______1A_A3B33D80 ≈ 37 bits
|
||||
38 ** 8 = 4_347792_138496 = 0x______3F4_4C9B2100 ≈ 42 bits
|
||||
38 ** 9 = 165_216101_262848 = 0x_____9643_5F06E600 ≈ 48 bits
|
||||
38 ** 10 = 6278_211847_988224 = 0x___164E00_1B062400 ≈ 53 bits
|
||||
38 ** 11 = 238572_050223_552512 = 0x__34F9404_02E95800 ≈ 58 bits
|
||||
38 ** 12 = 9_065737_908494_995456 = 0x_7DCFF898_6EA31000 ≈ 63 bits
|
||||
```
|
||||
|
||||
|
||||
### Base38 Alphabet
|
||||
|
||||
|
||||
@@ -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/*
|
||||
|
||||
|
||||
+3
-2
@@ -76,11 +76,12 @@ Common quirks:
|
||||
|
||||
Package-specific quirks:
|
||||
|
||||
- [GIF image decoder quirks](/std/gif/decode_quirks.wuffs)
|
||||
- [GIF decoder quirks](/std/gif/decode_quirks.wuffs)
|
||||
- [JPEG decoder quirks](/std/jpeg/decode_quirks.wuffs)
|
||||
- [JSON decoder quirks](/std/json/decode_quirks.wuffs)
|
||||
- [LZMA decoder quirks](/std/lzma/decode_quirks.wuffs)
|
||||
- [LZW decoder quirks](/std/lzw/decode_quirks.wuffs)
|
||||
- [TH decoder quirks](/std/thumbhash/decode_quirks.wuffs)
|
||||
- [THUMBHASH decoder quirks](/std/thumbhash/decode_quirks.wuffs)
|
||||
- [VP8 decoder quirks](/std/vp8/decode_quirks.wuffs)
|
||||
- [XZ decoder quirks](/std/xz/decode_quirks.wuffs)
|
||||
- [ZLIB decoder quirks](/std/zlib/decode_quirks.wuffs)
|
||||
@@ -3,3 +3,4 @@ Wuffs or stand-alone formats that were invented alongside Wuffs' development.
|
||||
|
||||
- [Naïve Image Formats: NIE, NII, NIA](/doc/spec/nie-spec.md)
|
||||
- [Random Access Compression: RAC](/doc/spec/rac-spec.md)
|
||||
- [Simple Uncompressed Interchange Tape Archive: SUITAR](/doc/spec/suitar-spec.md)
|
||||
@@ -0,0 +1,291 @@
|
||||
# Simple Uncompressed Interchange Tape Archive: SUITAR
|
||||
|
||||
Status: Draft (as of September 2026). There is no compatibility guarantee yet.
|
||||
|
||||
|
||||
## Overview
|
||||
|
||||
SUITAR is a common-denominator, trivial-to-parse interchange format for "the
|
||||
result of decompressing a compressed file or unpacking an archive file", such
|
||||
as ZIP, RAR, 7Z, TAR, GZIP, BZIP2, XZ, ZSTD, etc.
|
||||
|
||||
SUITAR is to archive files (including `foobar.dat.xz` compressed files as an
|
||||
archive containing 1 file) as [Farbfeld](https://tools.suckless.org/farbfeld/)
|
||||
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
|
||||
[Normalization](https://chromium.googlesource.com/chromium/src/+/master/docs/security/rule-of-2.md#normalization).
|
||||
|
||||
|
||||
## Subset of TAR
|
||||
|
||||
SUITAR is a subset of the well-known and widely-used TAR (Tape Archive, with
|
||||
GNU extensions) archive file format. Every valid SUITAR file is also a valid
|
||||
TAR file. These files work with popular tools like `/usr/bin/tar` and with
|
||||
popular TAR-reading libraries in a variety of programming languages.
|
||||
|
||||
SUITAR is a subset of "pure TAR", not of "TAR wrapped in GZIP", "TAR wrapped in
|
||||
BZIP2", etc. A separate compression step wrapping SUITAR is feasible, just like
|
||||
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 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.
|
||||
|
||||
|
||||
### Further Restrictions
|
||||
|
||||
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` 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.
|
||||
- These names must be encoded by a `GNUTYPE_LONGNAME` header block, regardless
|
||||
of whether the name's length is over or under 100 or 255 bytes.
|
||||
- File size and modTime (modification time, seconds since Unix epoch) integers
|
||||
must use base-256 encoding (not base-8 octal) and must be non-negative and
|
||||
less than `(1 << 53)`, which is `9007_199254_740992`.
|
||||
- Mode bits are either 0o644 (`rw-r--r--`) or 0o755 (`rwxr-xr-x`), encoded in
|
||||
base-8 octal (not base-256).
|
||||
- UID and GID are hard-coded to 65534 (as a number, equivalent to octal
|
||||
0o0177776) and "nobody" (as a string).
|
||||
- Any other fields are unused and must be NUL bytes.
|
||||
- Padding bytes (as TAR uses 512-byte blocks) must be NUL bytes.
|
||||
|
||||
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.
|
||||
|
||||
|
||||
### File Name Validity
|
||||
|
||||
These rules apply to both file names and directory names.
|
||||
|
||||
- Names must be valid UTF-8.
|
||||
- Names must not contain any ASCII control characters, including `'\n'` or
|
||||
`'\x00'`, the "new line" or NUL bytes.
|
||||
- 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 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
|
||||
|
||||
SUITAR files are a sequence of entries, followed by a 1024-byte "End Of File"
|
||||
marker. The EOF marker's bytes are all NUL. Each entry occupies an integer
|
||||
number of 512-byte blocks:
|
||||
|
||||
- 1 `GNUTYPE_LONGNAME` header block.
|
||||
- 1 or more payload blocks containing the file or directory name.
|
||||
- 1 `REGTYPE`, `AREGTYPE`, `GNUTYPE_SPARSE` or `DIRTYPE` header block.
|
||||
- If `REGTYPE`, 0 or more payload blocks containing the file contents.
|
||||
- If `AREGTYPE`, see "Implicitly-Sized Files" below.
|
||||
- If neither `REGTYPE` or `AREGTYPE`, no further 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
|
||||
SUITAR version 1. There are no other versions at this time.
|
||||
|
||||
The first 384 out of 512 bytes must match this template (arranged as 24 rows of
|
||||
16 bytes per row, plus commentary):
|
||||
|
||||
@@@@@@@@@@@@.... @@@@@@@@@@@@ = "\x13sUItAR\x00\xFE\xFDv1".
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
....0000???.0177 ??? = mode.
|
||||
776.0177776.$...
|
||||
????????$...???? ???????? = physical size, ???????? = modTime.
|
||||
??????????. ?... ?????? = checksum, ? = type.
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
.ustar .nobody.
|
||||
................
|
||||
.........nobody.
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
|
||||
In this template, `@` indicates the magic signature, `.` indicates a `0x00` NUL
|
||||
byte, `$` indicates a `0x80` byte and `?` indicates parts of the template that
|
||||
are variable, not hard-coded.
|
||||
|
||||
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.
|
||||
- `'L'` for `GNUTYPE_LONGNAME`, in which case mode must be `"644"` and modTime
|
||||
must be all zeroes.
|
||||
- `'S'` for `GNUTYPE_SPARSE`, in which case physical size must be all zeroes
|
||||
and offset and logical size (see below) must be the same number and, again,
|
||||
within the half-open range `0 .. (1 << 53)`.
|
||||
|
||||
The last 128 out of 512 bytes (8 rows of 16 bytes per row) must be all NUL
|
||||
bytes unless the type is `GNUTYPE_SPARSE`, in which case it must match this
|
||||
template (and `?` again indicates an 8-byte big-endian `uint64`):
|
||||
|
||||
..$...????????$. ???????? = sparse offset.
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
................
|
||||
...$...????????. ???????? = sparse logical size.
|
||||
................
|
||||
|
||||
|
||||
### Header Checksum
|
||||
|
||||
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
|
||||
|
||||
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
|
||||
NUL byte) is the first header block's physical size value, and must be within
|
||||
the half-open range `2 .. 4096`, and so the excluding-a-trailing-NUL length
|
||||
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` 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.
|
||||
|
||||
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
|
||||
|
||||
The [google/wuffs](https://github.com/google/wuffs) repository, which holds
|
||||
this specification document, also holds a
|
||||
[suitar](https://godoc.org/github.com/google/wuffs/lib/suitar) Go package and
|
||||
some `test/data/*.suitar` example files, readable by that Go package but also
|
||||
by `/usr/bin/tar`.
|
||||
|
||||
|
||||
---
|
||||
|
||||
Updated on September 2026.
|
||||
@@ -132,8 +132,9 @@ In Wuffs syntax, the `base.image_decoder` methods are:
|
||||
- [std/nie](/std/nie)
|
||||
- [std/png](/std/png)
|
||||
- [std/qoi](/std/qoi)
|
||||
- [std/tga](/std/tga)
|
||||
- [std/targa](/std/targa)
|
||||
- [std/thumbhash](/std/thumbhash)
|
||||
- [std/vp8](/std/vp8)
|
||||
- [std/wbmp](/std/wbmp)
|
||||
- [std/webp](/std/webp)
|
||||
|
||||
@@ -160,7 +161,8 @@ Examples in other repositories:
|
||||
|
||||
- [GIF decoder quirks](/std/gif/decode_quirks.wuffs)
|
||||
- [JPEG decoder quirks](/std/jpeg/decode_quirks.wuffs)
|
||||
- [TH decoder quirks](/std/thumbhash/decode_quirks.wuffs)
|
||||
- [THUMBHASH decoder quirks](/std/thumbhash/decode_quirks.wuffs)
|
||||
- [VP8 decoder quirks](/std/vp8/decode_quirks.wuffs)
|
||||
|
||||
|
||||
## Related Documentation
|
||||
|
||||
@@ -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* //
|
||||
@@ -609,8 +620,12 @@ redirect:
|
||||
WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);
|
||||
|
||||
// Configure the work buffer.
|
||||
uint64_t workbuf_len =
|
||||
wuffs_base__image_decoder__workbuf_len(g_image_decoder).max_incl;
|
||||
wuffs_base__range_ii_u64 r =
|
||||
wuffs_base__image_decoder__workbuf_len(g_image_decoder);
|
||||
if (wuffs_base__range_ii_u64__is_empty(&r)) {
|
||||
return "main: unsupported image (indeterminate work buffer length)";
|
||||
}
|
||||
uint64_t workbuf_len = r.max_incl;
|
||||
if (g_workbuf_slice.len < workbuf_len) {
|
||||
return "main: image is too large (to configure work buffer)";
|
||||
}
|
||||
@@ -800,10 +815,10 @@ print_uncompressed_png_frame() {
|
||||
uint32_t h = wuffs_base__pixel_config__height(&g_pixbuf.pixcfg);
|
||||
wuffs_base__table_u8 tab = wuffs_base__pixel_buffer__plane(&g_pixbuf, 0);
|
||||
return UNCOMPNG__RESULT__OK ==
|
||||
uncompng__encode(&my_uncompng_write_func, NULL, tab.ptr,
|
||||
uncompng__encode(&my_uncompng_write_func, NULL, pixfmt, w, h, tab.ptr,
|
||||
wuffs_base__table__flattened_length(
|
||||
tab.width, tab.height, tab.stride),
|
||||
w, h, tab.stride, pixfmt);
|
||||
tab.stride);
|
||||
}
|
||||
|
||||
void //
|
||||
@@ -1083,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));
|
||||
|
||||
+175
-137
@@ -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,9 +321,10 @@ try_allocate(wuffs_gif__decoder* dec) {
|
||||
return "could not allocate prev-dst buffer";
|
||||
}
|
||||
|
||||
uint64_t workbuf_len_max_incl = wuffs_gif__decoder__workbuf_len(dec).max_incl;
|
||||
if (workbuf_len_max_incl > 0) {
|
||||
g_workbuf = wuffs_base__malloc_slice_u8(malloc, workbuf_len_max_incl);
|
||||
if (wuffs_base__range_ii_u64__is_empty(&workbuf_len)) {
|
||||
return "indeterminate work buffer length";
|
||||
} 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";
|
||||
}
|
||||
@@ -336,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();
|
||||
@@ -352,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;
|
||||
@@ -375,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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -961,7 +961,7 @@ apply_background_color(uint32_t bg_color_premul,
|
||||
|
||||
// ----------------
|
||||
|
||||
#define MAX_INCL_DIMENSION 10000
|
||||
#define MAX_INCL_DIMENSION 16384
|
||||
|
||||
// BYTES_PER_COLOR_OUTPUT_CHARACTER is long enough to contain
|
||||
// "\x1B[38;2;255;255;255m\x1B[48;2;255;255;255mABC" plus a trailing NUL byte.
|
||||
|
||||
+6
-2
@@ -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));
|
||||
|
||||
@@ -2,4 +2,4 @@ module github.com/google/wuffs
|
||||
|
||||
go 1.25.0
|
||||
|
||||
require golang.org/x/image v0.38.0
|
||||
require golang.org/x/image v0.41.0
|
||||
@@ -1,2 +1,2 @@
|
||||
golang.org/x/image v0.38.0 h1:5l+q+Y9JDC7mBOMjo4/aPhMDcxEptsX+Tt3GgRQRPuE=
|
||||
golang.org/x/image v0.38.0/go.mod h1:/3f6vaXC+6CEanU4KJxbcUZyEePbyKbaLoDOe4ehFYY=
|
||||
golang.org/x/image v0.41.0 h1:8wS72eGJMJaBxK6okTzd4WaXumUlTVlb753MlsSvTCo=
|
||||
golang.org/x/image v0.41.0/go.mod h1:uIc348UZMSvS5Z65CVZ7iDPaNobNFEPeJ4kbqTOszmA=
|
||||
@@ -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);
|
||||
@@ -507,8 +510,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());
|
||||
}
|
||||
@@ -517,6 +521,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()) {
|
||||
|
||||
@@ -162,6 +162,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 //
|
||||
@@ -234,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;
|
||||
};
|
||||
|
||||
@@ -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 == '+') {
|
||||
|
||||
@@ -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.
|
||||
@@ -1466,7 +1511,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;
|
||||
}
|
||||
@@ -1474,7 +1519,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;
|
||||
}
|
||||
@@ -1482,7 +1527,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;
|
||||
}
|
||||
@@ -1490,7 +1535,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;
|
||||
}
|
||||
@@ -1631,7 +1676,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();
|
||||
}
|
||||
@@ -1655,7 +1705,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();
|
||||
}
|
||||
|
||||
@@ -73,4 +73,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
|
||||
// ---------------- 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;
|
||||
}
|
||||
@@ -32,6 +32,10 @@
|
||||
// 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
|
||||
@@ -251,6 +255,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) {
|
||||
@@ -482,6 +501,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
|
||||
@@ -863,13 +887,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
|
||||
|
||||
@@ -1495,15 +1527,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
|
||||
|
||||
@@ -1698,24 +1747,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);
|
||||
|
||||
@@ -1760,7 +1829,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 //
|
||||
@@ -1768,14 +1843,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 //
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -49,6 +49,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)));
|
||||
@@ -156,7 +176,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,
|
||||
@@ -269,6 +289,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 //
|
||||
@@ -396,7 +775,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) {
|
||||
@@ -468,7 +847,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);
|
||||
|
||||
@@ -115,6 +115,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,
|
||||
@@ -136,7 +232,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));
|
||||
}
|
||||
}
|
||||
@@ -163,7 +259,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));
|
||||
}
|
||||
}
|
||||
@@ -193,7 +289,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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -210,7 +306,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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -271,7 +367,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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1477,7 +1573,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);
|
||||
}
|
||||
@@ -1552,7 +1648,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);
|
||||
}
|
||||
@@ -1565,7 +1662,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:
|
||||
@@ -1710,14 +1807,39 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
}
|
||||
|
||||
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, //
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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
@@ -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 {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -230,7 +230,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))) {
|
||||
|
||||
@@ -551,8 +551,16 @@ func (g *gen) writeExprUserDefinedCall(b *buffer, n *a.Expr, depth uint32) error
|
||||
return fmt.Errorf("cannot generate user-defined method call %q for receiver type %q",
|
||||
n.Str(g.tm), recv.MType().Str(g.tm))
|
||||
}
|
||||
|
||||
qid := recvTyp.QID()
|
||||
b.printf("%s%s__%s(", g.packagePrefix(qid), qid[1].Str(g.tm), method.Ident().Str(g.tm))
|
||||
pkgStr := g.packagePrefix(qid)
|
||||
typStr := qid[1].Str(g.tm)
|
||||
methodStr := method.Ident().Str(g.tm)
|
||||
if (qid[0] == t.IDBase) && qid[1].IsRangeType() && strings.HasPrefix(methodStr, "get_") {
|
||||
pkgStr = "wuffs_private_impl__"
|
||||
}
|
||||
b.printf("%s%s__%s(", pkgStr, typStr, methodStr)
|
||||
|
||||
if !recvTyp.IsEtcUtilityType() {
|
||||
b.writes(addr)
|
||||
if err := g.writeExpr(b, recv, false, depth); err != nil {
|
||||
|
||||
+24
-1
@@ -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
|
||||
@@ -115,6 +125,11 @@ var Consts = [...]struct {
|
||||
|
||||
// ----
|
||||
|
||||
{t.IDU8, "0", "PIXEL_BLEND__SRC"},
|
||||
{t.IDU8, "1", "PIXEL_BLEND__SRC_OVER"},
|
||||
|
||||
// ----
|
||||
|
||||
{t.IDU32, "0x02000008", "PIXEL_FORMAT__A"},
|
||||
|
||||
{t.IDU32, "0x20000008", "PIXEL_FORMAT__Y"},
|
||||
@@ -245,7 +260,9 @@ var Consts = [...]struct {
|
||||
// ----
|
||||
|
||||
{t.IDU32, "0x00", "YCC_MODEL__BT_601_FULL_RANGE"},
|
||||
{t.IDU32, "0x01", "YCC_MODEL__BT_601_STUDIO_RANGE"},
|
||||
{t.IDU32, "0x04", "YCC_MODEL__BT_601_STUDIO_RANGE"},
|
||||
{t.IDU32, "0x06", "YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC"},
|
||||
{t.IDU32, "0x07", "YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER"},
|
||||
{t.IDU32, "0x40", "YCC_MODEL__RGB"},
|
||||
{t.IDU32, "0x80", "YCC_MODEL__CMY"},
|
||||
|
||||
@@ -396,6 +413,7 @@ var funcsOther = [...]string{
|
||||
// ---- utility
|
||||
|
||||
"utility.cpu_arch_is_32_bit() bool",
|
||||
"utility.demake_pixel_blend(a: pixel_blend) u8",
|
||||
"utility.empty_io_reader() io_reader",
|
||||
"utility.empty_io_writer() io_writer",
|
||||
"utility.empty_range_ii_u32() range_ii_u32",
|
||||
@@ -408,6 +426,7 @@ var funcsOther = [...]string{
|
||||
"utility.i64_divide(a: u64, b: u64[1 ..=]) u64",
|
||||
"utility.make_bitvec256(e00: u64, e01: u64, e02: u64, e03: u64) bitvec256",
|
||||
"utility.make_optional_u63(has_value: bool, value: u64[..= 0x7FFF_FFFF_FFFF_FFFF]) optional_u63",
|
||||
"utility.make_pixel_blend(repr: u8) pixel_blend",
|
||||
"utility.make_pixel_format(repr: u32) pixel_format",
|
||||
"utility.make_range_ii_u32(min_incl: u32, max_incl: u32) range_ii_u32",
|
||||
"utility.make_range_ie_u32(min_incl: u32, max_excl: u32) range_ie_u32",
|
||||
@@ -431,21 +450,25 @@ var funcsOther = [...]string{
|
||||
"range_ie_u32.get_min_incl() u32",
|
||||
"range_ie_u32.get_max_excl() u32",
|
||||
"range_ie_u32.intersect(r: range_ie_u32) range_ie_u32",
|
||||
"range_ie_u32.is_empty() bool",
|
||||
"range_ie_u32.unite(r: range_ie_u32) range_ie_u32",
|
||||
|
||||
"range_ii_u32.get_min_incl() u32",
|
||||
"range_ii_u32.get_max_incl() u32",
|
||||
"range_ii_u32.intersect(r: range_ii_u32) range_ii_u32",
|
||||
"range_ii_u32.is_empty() bool",
|
||||
"range_ii_u32.unite(r: range_ii_u32) range_ii_u32",
|
||||
|
||||
"range_ie_u64.get_min_incl() u64",
|
||||
"range_ie_u64.get_max_excl() u64",
|
||||
"range_ie_u64.intersect(r: range_ie_u64) range_ie_u64",
|
||||
"range_ie_u64.is_empty() bool",
|
||||
"range_ie_u64.unite(r: range_ie_u64) range_ie_u64",
|
||||
|
||||
"range_ii_u64.get_min_incl() u64",
|
||||
"range_ii_u64.get_max_incl() u64",
|
||||
"range_ii_u64.intersect(r: range_ii_u64) range_ii_u64",
|
||||
"range_ii_u64.is_empty() bool",
|
||||
"range_ii_u64.unite(r: range_ii_u64) range_ii_u64",
|
||||
|
||||
// ---- more_information
|
||||
|
||||
@@ -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
|
||||
|
||||
package suitar_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/google/wuffs/lib/suitar"
|
||||
)
|
||||
|
||||
func Example_minimal() {
|
||||
// This mimics Example_minimal from the standard library's archive/tar.
|
||||
//
|
||||
// This package's Writer is a little more strict, rejecting an (implicit)
|
||||
// zero-valued Header.Typeflag or Header.ModTime that archive/tar accepts.
|
||||
// Header.Mode must also be 0o644 (or 0o755), not 0o600.
|
||||
|
||||
// Create and add some files to the archive.
|
||||
var buf bytes.Buffer
|
||||
tw := suitar.NewWriter(&buf)
|
||||
var files = []struct {
|
||||
Name, Body string
|
||||
}{
|
||||
{"readme.txt", "This archive contains some text files."},
|
||||
{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
|
||||
{"todo.txt", "Get animal handling license."},
|
||||
}
|
||||
for _, file := range files {
|
||||
hdr := &suitar.Header{
|
||||
Typeflag: suitar.TypeReg,
|
||||
Name: file.Name,
|
||||
Size: int64(len(file.Body)),
|
||||
Mode: suitar.Mode644,
|
||||
ModTime: time.Unix(0, 0),
|
||||
}
|
||||
if err := tw.WriteHeader(hdr); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
if _, err := tw.Write([]byte(file.Body)); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := tw.Close(); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Open and iterate through the files in the archive.
|
||||
tr := suitar.NewReader(&buf)
|
||||
for {
|
||||
hdr, err := tr.Next()
|
||||
if err == io.EOF {
|
||||
break // End of archive
|
||||
}
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
fmt.Printf("Contents of %s:\n", hdr.Name)
|
||||
if _, err := io.Copy(os.Stdout, tr); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
fmt.Println()
|
||||
}
|
||||
|
||||
// Output:
|
||||
// Contents of readme.txt:
|
||||
// This archive contains some text files.
|
||||
// Contents of gopher.txt:
|
||||
// Gopher names:
|
||||
// George
|
||||
// Geoffrey
|
||||
// Gonzo
|
||||
// Contents of todo.txt:
|
||||
// Get animal handling license.
|
||||
}
|
||||
@@ -0,0 +1,846 @@
|
||||
// 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
|
||||
|
||||
// ----------------
|
||||
|
||||
// Package suitar implements the SUITAR archive file format.
|
||||
//
|
||||
// SUITAR is a subset of the TAR archive file format (including its popular
|
||||
// USTAR, PAX and GNU extensions). This package's API is a subset of the
|
||||
// standard library's archive/tar package.
|
||||
//
|
||||
// Being a subset means that this package's implementation is about 600 lines
|
||||
// of Go code, compared to archive/tar being about 3000, a factor of 5×.
|
||||
//
|
||||
// The SUITAR specification is at
|
||||
// https://github.com/google/wuffs/blob/main/doc/spec/suitar-spec.md
|
||||
package suitar
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"io"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
var (
|
||||
errBadFileName = errors.New("suitar: bad file name")
|
||||
errBadHeader = errors.New("suitar: bad header")
|
||||
errBadPadding = errors.New("suitar: bad padding")
|
||||
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.
|
||||
const lenMagic = 12
|
||||
|
||||
// headerBlockTemplate is the contents of each 512-byte header block. Each
|
||||
// SUITAR archive entry (a file or directory) consists of: 1 header block (with
|
||||
// typeflag typeGNULongName), the file name, 1 header block (with typeflag
|
||||
// TypeReg or TypeDir or TypeGNUSparse) and the file contents.
|
||||
//
|
||||
// '?' bytes mean that the header block's bytes can vary at that position.
|
||||
// Otherwise, the bytes are hard-coded. SUITAR is a stricter subset of TAR.
|
||||
const headerBlockTemplate = "\x13sUItAR\x00\xFE\xFDv1\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x000000???\x000177" + // ??? = mode bits, 0177776 = uid("nobody").
|
||||
"776\x000177776\x00\x80\x00\x00\x00" +
|
||||
|
||||
"????????\x80\x00\x00\x00????" + // ???????? = physical file size, ???????? = modTime.
|
||||
"??????????\x00 ?\x00\x00\x00" + // ?????? = checksum, ? = typeflag.
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
|
||||
"\x00ustar \x00nobody\x00" + // "ustar " mid-block magic signature, "nobody" ≈ uid.
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00nobody\x00" + // "nobody" ≈ gid.
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
|
||||
// The 128-byte tail of this headerBlockTemplate only applies to
|
||||
// TypeGNUSparse blocks. Otherwise, the final 128 bytes must be NUL.
|
||||
"\x00\x00\x80\x00\x00\x00????????\x80\x00" + // ???????? = sparse anti-hole offset (and its length is 0).
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
|
||||
"\x00\x00\x00\x80\x00\x00\x00????????\x00" + // ???????? = sparse logical file size.
|
||||
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
|
||||
|
||||
// Valid values for Header.Typeflag. The zero value is invalid.
|
||||
const (
|
||||
TypeReg = '0' // Regular file (with contents).
|
||||
TypeDir = '5' // Directory (with no contents).
|
||||
TypeGNUSparse = 'S' // Sparse file (its contents are all NUL bytes).
|
||||
|
||||
typeGNULongName = 'L'
|
||||
typeRegA = '\x00'
|
||||
)
|
||||
|
||||
// Valid values for Header.Mode. The zero value is invalid.
|
||||
const (
|
||||
Mode644 = int64(0o644) // "rw-r--r--" mode bits, also known as permission bits.
|
||||
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) &&
|
||||
(name != "") &&
|
||||
(name != ".") &&
|
||||
(name != "..") &&
|
||||
(name[0] != '/') &&
|
||||
(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, "/../") &&
|
||||
!containsASCIIControlCharactersOrDel(name) &&
|
||||
utf8.ValidString(name)
|
||||
}
|
||||
|
||||
func containsASCIIControlCharactersOrDel(s string) bool {
|
||||
for i := range len(s) {
|
||||
if c := s[i]; (c < 0x20) || (c == 0x7F) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func isAllZeroes(b []byte) bool {
|
||||
for _, c := range b {
|
||||
if c != 0 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func readFullNoEOF(r io.Reader, b []byte) (int, error) {
|
||||
n, err := io.ReadFull(r, b)
|
||||
if err == io.EOF {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
|
||||
func u64le(b []byte) uint64 {
|
||||
return (uint64(b[0]) << 56) |
|
||||
(uint64(b[1]) << 48) |
|
||||
(uint64(b[2]) << 40) |
|
||||
(uint64(b[3]) << 32) |
|
||||
(uint64(b[4]) << 24) |
|
||||
(uint64(b[5]) << 16) |
|
||||
(uint64(b[6]) << 8) |
|
||||
(uint64(b[7]) << 0)
|
||||
}
|
||||
|
||||
func roundUp512(n uint64) uint64 {
|
||||
return (n + 511) &^ 511
|
||||
}
|
||||
|
||||
type block [512]byte
|
||||
|
||||
func (b *block) calculateChecksum() uint32 {
|
||||
checksum := uint32(0)
|
||||
|
||||
for _, c := range b[0x000:0x094] {
|
||||
checksum += uint32(c)
|
||||
}
|
||||
|
||||
// The 8 checksum bytes have value 32 when calculating the checksum itself.
|
||||
checksum += 256
|
||||
|
||||
for _, c := range b[0x09C:0x200] {
|
||||
checksum += uint32(c)
|
||||
}
|
||||
|
||||
return checksum
|
||||
}
|
||||
|
||||
func (b *block) setChecksum() {
|
||||
checksum := b.calculateChecksum()
|
||||
|
||||
b[0x09B] = ' '
|
||||
b[0x09A] = '\x00'
|
||||
for i := range 6 {
|
||||
b[0x099-i] = '0' + byte(checksum&7)
|
||||
checksum >>= 3
|
||||
}
|
||||
}
|
||||
|
||||
func (b *block) isValidHeader(which int) bool {
|
||||
// Compare b to the headerBlockTemplate. Blocks that aren't TypeGNUSparse
|
||||
// must end in 128 NUL bytes.
|
||||
end := 0x200
|
||||
if typeflag := b[0x09C]; typeflag != TypeGNUSparse {
|
||||
end = 0x180
|
||||
}
|
||||
for i := range end {
|
||||
if c := headerBlockTemplate[i]; (c != '?') && (c != b[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
if (end == 0x180) && !isAllZeroes(b[0x180:0x200]) {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check the mode bits.
|
||||
if (b[0x068] == '6') && (b[0x069] == '4') && (b[0x06A] == '4') {
|
||||
// No-op.
|
||||
} else if (b[0x068] == '7') && (b[0x069] == '5') && (b[0x06A] == '5') && (which == 1) {
|
||||
// No-op.
|
||||
} else {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check the checksum.
|
||||
checksum := b.calculateChecksum()
|
||||
for i := range 6 {
|
||||
if b[0x099-i] != ('0' + byte(checksum&7)) {
|
||||
return false
|
||||
}
|
||||
checksum >>= 3
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Header is a single header in a SUITAR archive.
|
||||
//
|
||||
// It is a subset of tar.Header from the standard library's archive/tar
|
||||
// package, but it is stricter about what field values are valid.
|
||||
type Header struct {
|
||||
Typeflag byte
|
||||
Name string
|
||||
Size int64
|
||||
Mode int64
|
||||
ModTime time.Time
|
||||
}
|
||||
|
||||
// Valid returns whether h is valid to pass to a Writer. Specifically:
|
||||
//
|
||||
// - 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 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
|
||||
// be on or after 1 January 1970 and so cannot be the zero time.Time (which
|
||||
// is 1 January Year-1).
|
||||
// - Size and ModTime.Unix() must also be less than (1 << 53).
|
||||
//
|
||||
// A Header returned (without error) by a Reader will always be valid.
|
||||
func (h *Header) Valid() bool {
|
||||
if h == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
switch h.Typeflag {
|
||||
default:
|
||||
return false
|
||||
case TypeDir:
|
||||
if (h.Size != 0) || (h.Mode != Mode755) {
|
||||
return false
|
||||
}
|
||||
case TypeReg, TypeGNUSparse:
|
||||
if (h.Mode != Mode644) && (h.Mode != Mode755) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
size := h.Size
|
||||
if (size == -1) && (h.Typeflag == TypeReg) {
|
||||
size = 0
|
||||
}
|
||||
|
||||
const maxExcl = 1 << 53
|
||||
m := h.ModTime.Unix()
|
||||
return (0 <= size) && (size < maxExcl) &&
|
||||
(0 <= m) && (m < maxExcl) &&
|
||||
IsValidHeaderName(h.Name)
|
||||
}
|
||||
|
||||
// NewWriter creates a new Writer writing to w.
|
||||
func NewWriter(w io.Writer) *Writer {
|
||||
return &Writer{w: w}
|
||||
}
|
||||
|
||||
// Writer provides sequential writing of a SUITAR archive.
|
||||
type Writer struct {
|
||||
err error
|
||||
w io.Writer
|
||||
header Header
|
||||
remaining int64 // If negative, ^remaining is the accumulated implicit size.
|
||||
bIndex int32
|
||||
block block
|
||||
nameBuf [4096]byte
|
||||
}
|
||||
|
||||
func (w *Writer) flush() error {
|
||||
if w.err != nil {
|
||||
return w.err
|
||||
|
||||
} 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 {
|
||||
w.err = err
|
||||
return w.err
|
||||
}
|
||||
w.bIndex = 0
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// WriteHeader writes h and prepares to accept the file's contents (as w is
|
||||
// also an io.Writer).
|
||||
func (w *Writer) WriteHeader(h *Header) error {
|
||||
if err := w.flush(); err != nil {
|
||||
return err
|
||||
} else if !h.Valid() {
|
||||
w.err = errBadHeader
|
||||
return w.err
|
||||
}
|
||||
n := len(h.Name)
|
||||
copy(w.nameBuf[:], h.Name)
|
||||
w.nameBuf[n] = 0
|
||||
|
||||
initBlock(&w.block, typeGNULongName, int64(n+1), Mode644, 0)
|
||||
if _, err := w.w.Write(w.block[:]); err != nil {
|
||||
w.err = err
|
||||
return w.err
|
||||
}
|
||||
|
||||
// The w.Write call below writes this entry's name, not its contents, so
|
||||
// w.header must not (yet) say TypeDir or Write would reject it. Set
|
||||
// w.header after that call.
|
||||
w.header = Header{Typeflag: TypeReg}
|
||||
w.remaining = int64(n + 1)
|
||||
|
||||
if _, err := w.Write(w.nameBuf[:n+1]); err != nil {
|
||||
w.err = err
|
||||
return w.err
|
||||
} else if err = w.flush(); err != nil {
|
||||
w.err = err
|
||||
return w.err
|
||||
}
|
||||
|
||||
w.header = *h
|
||||
initBlock(&w.block, w.header.Typeflag, w.header.Size, w.header.Mode, w.header.ModTime.Unix())
|
||||
if _, err := w.w.Write(w.block[:]); err != nil {
|
||||
w.err = err
|
||||
return w.err
|
||||
}
|
||||
|
||||
w.remaining = w.header.Size
|
||||
return nil
|
||||
}
|
||||
|
||||
func initBlock(b *block, typeflag byte, size int64, mode int64, modTime int64) {
|
||||
// 0o0177776 octal is 65534, which is Debian's UID/GID for "nobody".
|
||||
const uidForNobody = "0177776"
|
||||
|
||||
clear(b[:])
|
||||
copy(b[:], headerBlockTemplate[:lenMagic])
|
||||
|
||||
modeBits := "0000644"
|
||||
if mode == Mode755 {
|
||||
modeBits = "0000755"
|
||||
}
|
||||
copy(b[0x064:], modeBits)
|
||||
copy(b[0x06C:], uidForNobody)
|
||||
copy(b[0x074:], uidForNobody)
|
||||
|
||||
physicalSize := size
|
||||
if typeflag == TypeGNUSparse {
|
||||
physicalSize = 0
|
||||
} else if size < 0 {
|
||||
physicalSize = 0
|
||||
typeflag = typeRegA
|
||||
}
|
||||
setI64(b, 0x07C, physicalSize)
|
||||
|
||||
setI64(b, 0x088, modTime)
|
||||
b[0x09C] = typeflag
|
||||
copy(b[0x101:], "ustar ")
|
||||
copy(b[0x109:], "nobody")
|
||||
copy(b[0x129:], "nobody")
|
||||
|
||||
if typeflag == TypeGNUSparse {
|
||||
setI64(b, 0x182, size)
|
||||
setI64(b, 0x18E, 0)
|
||||
setI64(b, 0x1E3, size)
|
||||
}
|
||||
|
||||
b.setChecksum()
|
||||
}
|
||||
|
||||
func setI64(b *block, offset int, value int64) {
|
||||
// The 0x80 uses base-256 instead of octal, allowing file sizes >= 8GiB.
|
||||
b[offset] = 0x80
|
||||
for i := range 8 {
|
||||
b[(offset+11)-i] = byte(value)
|
||||
value >>= 8
|
||||
}
|
||||
}
|
||||
|
||||
// Write satisfies io.Writer.
|
||||
func (w *Writer) Write(b []byte) (int, error) {
|
||||
if w.err != nil {
|
||||
return 0, w.err
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
for len(b) > 0 {
|
||||
if w.bIndex == 0 {
|
||||
split := len(b) &^ 511
|
||||
prefix, suffix := b[:split], b[split:]
|
||||
|
||||
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.block[:], suffix))
|
||||
ret += int(w.bIndex)
|
||||
}
|
||||
|
||||
b = nil
|
||||
break
|
||||
}
|
||||
|
||||
n := copy(w.block[w.bIndex:], b)
|
||||
w.bIndex += int32(n)
|
||||
ret += n
|
||||
b = b[n:]
|
||||
|
||||
if int(w.bIndex) < len(w.block) {
|
||||
continue
|
||||
} else if _, err := w.w.Write(w.block[:]); err != nil {
|
||||
return ret, err
|
||||
}
|
||||
w.bIndex = 0
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
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.
|
||||
func (w *Writer) Close() error {
|
||||
if err := w.flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
clear(w.nameBuf[:1024])
|
||||
if _, err := w.w.Write(w.nameBuf[:1024]); err != nil {
|
||||
w.err = err
|
||||
return err
|
||||
}
|
||||
w.err = errClosed
|
||||
return nil
|
||||
}
|
||||
|
||||
// NewReader creates a new Reader reading from r.
|
||||
func NewReader(r io.Reader) *Reader {
|
||||
return &Reader{r: r}
|
||||
}
|
||||
|
||||
// Reader provides sequential reading of a SUITAR archive.
|
||||
type Reader struct {
|
||||
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 {
|
||||
if _, err := io.Copy(io.Discard, r); err != nil {
|
||||
r.err = err
|
||||
return Header{}, r.err
|
||||
}
|
||||
}
|
||||
|
||||
if _, err := readFullNoEOF(r.r, r.block[:]); err != nil {
|
||||
r.err = err
|
||||
return Header{}, r.err
|
||||
} else if r.block[0] == 0 {
|
||||
// SUITAR ends with 2 blocks (1024 bytes) of zeroes.
|
||||
if !isAllZeroes(r.block[:]) {
|
||||
r.err = errBadHeader
|
||||
return Header{}, r.err
|
||||
} else if _, err := readFullNoEOF(r.r, r.block[:]); err != nil {
|
||||
r.err = err
|
||||
return Header{}, r.err
|
||||
} else if !isAllZeroes(r.block[:]) {
|
||||
r.err = errBadHeader
|
||||
return Header{}, r.err
|
||||
}
|
||||
r.err = io.EOF
|
||||
return Header{}, r.err
|
||||
}
|
||||
|
||||
nameLenInclNul, err := parseBlock0(&r.block)
|
||||
if err != nil {
|
||||
r.err = err
|
||||
return Header{}, r.err
|
||||
}
|
||||
|
||||
n1 := nameLenInclNul - 1
|
||||
n2 := roundUp512(nameLenInclNul)
|
||||
if _, err := readFullNoEOF(r.r, r.nameBuf[:n2]); err != nil {
|
||||
r.err = err
|
||||
return Header{}, r.err
|
||||
}
|
||||
name := string(r.nameBuf[:n1])
|
||||
if !IsValidHeaderName(name) || !isAllZeroes(r.nameBuf[n1:n2]) {
|
||||
r.err = errBadFileName
|
||||
return Header{}, r.err
|
||||
}
|
||||
|
||||
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,
|
||||
Name: name,
|
||||
Size: size,
|
||||
Mode: mode,
|
||||
ModTime: time.Unix(modTime, 0),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func parseBlock0(b *block) (uint64, error) {
|
||||
if !b.isValidHeader(0) {
|
||||
return 0, errBadHeader
|
||||
}
|
||||
|
||||
size := u64le(b[0x080:])
|
||||
modTime := u64le(b[0x08C:])
|
||||
if (size < 2) || (4097 <= size) {
|
||||
return 0, errBadFileName
|
||||
} else if (modTime != 0) || (b[0x09C] != 'L') {
|
||||
return 0, errBadHeader
|
||||
}
|
||||
|
||||
return size, nil
|
||||
}
|
||||
|
||||
func parseBlock1(b *block) (byte, int64, int64, int64, error) {
|
||||
if !b.isValidHeader(1) {
|
||||
return 0, 0, 0, 0, errBadHeader
|
||||
}
|
||||
|
||||
typeflag := b[0x09C]
|
||||
if (typeflag != TypeReg) && (typeflag != TypeDir) && (typeflag != TypeGNUSparse) && (typeflag != typeRegA) {
|
||||
return 0, 0, 0, 0, errBadHeader
|
||||
}
|
||||
|
||||
mode := Mode644
|
||||
if b[0x068] == '7' {
|
||||
mode = Mode755
|
||||
}
|
||||
size := int64(u64le(b[0x080:]))
|
||||
if size < 0 {
|
||||
return 0, 0, 0, 0, errBadHeader
|
||||
}
|
||||
modTime := int64(u64le(b[0x08C:]))
|
||||
if modTime < 0 {
|
||||
return 0, 0, 0, 0, errBadHeader
|
||||
}
|
||||
|
||||
if typeflag == TypeDir {
|
||||
if (size != 0) || (mode != Mode755) {
|
||||
return 0, 0, 0, 0, errBadHeader
|
||||
}
|
||||
} else if typeflag == TypeGNUSparse {
|
||||
if size != 0 {
|
||||
return 0, 0, 0, 0, errBadHeader
|
||||
}
|
||||
size0 := int64(u64le(b[0x186:]))
|
||||
size1 := int64(u64le(b[0x1E7:]))
|
||||
if (size0 != size1) || (size1 < 0) {
|
||||
return 0, 0, 0, 0, errBadHeader
|
||||
}
|
||||
size = size1
|
||||
}
|
||||
|
||||
return typeflag, size, mode, modTime, nil
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
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)
|
||||
r.remaining -= int64(n)
|
||||
if r.remaining == 0 {
|
||||
return n, io.EOF
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
n, err := r.r.Read(b)
|
||||
r.remaining -= int64(n)
|
||||
if r.remaining == 0 {
|
||||
if r.numPadding > 0 {
|
||||
padding := r.block[:r.numPadding]
|
||||
_, readFullErr := readFullNoEOF(r.r, padding)
|
||||
if err == nil {
|
||||
err = readFullErr
|
||||
if err == nil {
|
||||
for _, c := range padding {
|
||||
if c != 0 {
|
||||
err = errBadPadding
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
r.numPadding = 0
|
||||
}
|
||||
if (err == nil) || (err == io.EOF) {
|
||||
if r.sizeIsImplicit {
|
||||
return n, nil
|
||||
} else {
|
||||
return n, io.EOF
|
||||
}
|
||||
}
|
||||
|
||||
} else if err == io.EOF {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
@@ -0,0 +1,516 @@
|
||||
// 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
|
||||
|
||||
package suitar
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"hash/crc32"
|
||||
"io"
|
||||
"math/rand"
|
||||
"os"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type crcWriter uint32
|
||||
|
||||
func (c *crcWriter) Write(b []byte) (int, error) {
|
||||
state := uint32(*c)
|
||||
state = crc32.Update(state, crc32.IEEETable, b)
|
||||
*c = crcWriter(state)
|
||||
return len(b), nil
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
// Convert from t (tar, using the standard library) to s (suitar, using
|
||||
// this package).
|
||||
buf := bytes.Buffer{}
|
||||
sWriter := NewWriter(&buf)
|
||||
for tReader := tar.NewReader(f); ; {
|
||||
tHeader, err := tReader.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
} else if err != nil {
|
||||
tt.Fatalf("Next: %v", err)
|
||||
}
|
||||
|
||||
size := tHeader.Size
|
||||
if implicit {
|
||||
size = SizeIsImplicit
|
||||
}
|
||||
|
||||
sHeader := &Header{
|
||||
Typeflag: tHeader.Typeflag,
|
||||
Name: tHeader.Name,
|
||||
Size: size,
|
||||
Mode: tHeader.Mode,
|
||||
ModTime: tHeader.ModTime,
|
||||
}
|
||||
if sparse && (sHeader.Typeflag == TypeReg) {
|
||||
sHeader.Typeflag = TypeGNUSparse
|
||||
}
|
||||
if err := sWriter.WriteHeader(sHeader); err != nil {
|
||||
tt.Fatalf("WriteHeader: %v", err)
|
||||
}
|
||||
|
||||
dstWriter := (io.Writer)(sWriter)
|
||||
if sparse {
|
||||
dstWriter = io.Discard
|
||||
}
|
||||
if _, err := io.Copy(dstWriter, tReader); err != nil {
|
||||
tt.Fatalf("io.Copy: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
if err := sWriter.Close(); err != nil {
|
||||
tt.Fatalf("Close: %v", err)
|
||||
}
|
||||
|
||||
got := buf.Bytes()
|
||||
wantFilename := "../../test/data/archive.dense.suitar"
|
||||
if sparse {
|
||||
wantFilename = "../../test/data/archive.sparse.suitar"
|
||||
} else if implicit {
|
||||
wantFilename = "../../test/data/various-peacocks.implicit.suitar"
|
||||
}
|
||||
want, err := os.ReadFile(wantFilename)
|
||||
if err != nil {
|
||||
tt.Fatalf("os.ReadFile: %v", err)
|
||||
}
|
||||
|
||||
if !bytes.Equal(got, want) {
|
||||
tt.Fatalf("did not recreate golden test file")
|
||||
}
|
||||
}
|
||||
|
||||
func testReader(tt *testing.T, sparse bool, ignore bool) {
|
||||
filename, wantTypeflag := "../../test/data/archive.dense.suitar", " T:'0'"
|
||||
if sparse {
|
||||
filename, wantTypeflag = "../../test/data/archive.sparse.suitar", " T:'S'"
|
||||
}
|
||||
|
||||
wantChecksums := []string(nil)
|
||||
if ignore {
|
||||
wantChecksums = []string{
|
||||
"C:0x00000000",
|
||||
"C:0x00000000",
|
||||
"C:0x00000000",
|
||||
"C:0x00000000",
|
||||
"C:0x00000000",
|
||||
"C:0x00000000",
|
||||
"C:0x00000000",
|
||||
"C:0x00000000",
|
||||
}
|
||||
|
||||
} else if sparse {
|
||||
wantChecksums = []string{
|
||||
"C:0x00000000",
|
||||
"C:0xB69F8E37",
|
||||
"C:0x73FF3CAE",
|
||||
"C:0xD71F022F",
|
||||
"C:0xC446EAB8",
|
||||
"C:0x5F228EB9",
|
||||
"C:0x7BA7D011",
|
||||
"C:0x48792A7F",
|
||||
}
|
||||
|
||||
} else {
|
||||
wantChecksums = []string{
|
||||
"C:0x00000000",
|
||||
"C:0xFEDD8F35",
|
||||
"C:0x87EE5E05",
|
||||
"C:0x703E9270",
|
||||
"C:0xC37CB538",
|
||||
"C:0x2B0B23B0",
|
||||
"C:0xABE507EF",
|
||||
"C:0x67FABE9C",
|
||||
}
|
||||
}
|
||||
|
||||
want := "" +
|
||||
wantChecksums[0] + wantTypeflag + " S:0x0000 M:644 MT:0x5E3A5C50 N:artificial/0.bytes\n" +
|
||||
wantChecksums[1] + wantTypeflag + " S:0x0355 M:644 MT:0x5F33F6E6 N:github-tags.json\n" +
|
||||
wantChecksums[2] + wantTypeflag + " S:0x02B5 M:755 MT:0x608F960B N:hello.sh\n" +
|
||||
wantChecksums[3] + wantTypeflag + " S:0x0068 M:644 MT:0x608F954D N:non-ascii/αβ.txt\n" +
|
||||
wantChecksums[4] + wantTypeflag + " S:0x0097 M:644 MT:0x608F96C7 N:non-ascii/😻.txt\n" +
|
||||
wantChecksums[5] + wantTypeflag + " S:0x00D0 M:644 MT:0x5E3A5C50 N:pjw-thumbnail.png\n" +
|
||||
wantChecksums[6] + wantTypeflag + " S:0x03AE M:644 MT:0x5E3A5C50 N:romeo.txt\n" +
|
||||
wantChecksums[7] + wantTypeflag + " S:0x022E M:644 MT:0x5E3A5C50 N:romeo.txt.gz\n" +
|
||||
""
|
||||
|
||||
f, err := os.Open(filename)
|
||||
if err != nil {
|
||||
tt.Fatalf("os.Open: %v", err)
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
buf := bytes.Buffer{}
|
||||
for r := NewReader(f); ; {
|
||||
h, err := r.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
} else if err != nil {
|
||||
tt.Fatalf("Next: %v", err)
|
||||
}
|
||||
|
||||
checksum := crcWriter(0)
|
||||
if !ignore {
|
||||
if _, err := io.Copy(&checksum, r); err != nil {
|
||||
tt.Fatalf("io.Copy: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Fprintf(&buf, "C:0x%08X T:'%c' S:0x%04X M:%3o MT:0x%08X N:%s\n",
|
||||
checksum, h.Typeflag, h.Size, h.Mode, h.ModTime.Unix(), h.Name)
|
||||
}
|
||||
|
||||
if got := buf.String(); got != want {
|
||||
tt.Fatalf("\ngot:\n%s\nwant:\n%s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
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 buggy Writer (which would otherwise loop forever)
|
||||
// instead fails the surrounding test.
|
||||
type cappedWriter struct {
|
||||
buf bytes.Buffer
|
||||
limit int
|
||||
}
|
||||
|
||||
func (w *cappedWriter) Write(b []byte) (int, error) {
|
||||
if w.buf.Len()+len(b) > w.limit {
|
||||
return 0, errCappedWriter
|
||||
}
|
||||
return w.buf.Write(b)
|
||||
}
|
||||
|
||||
var errCappedWriter = errors.New("suitar_test: capped writer")
|
||||
|
||||
// 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}
|
||||
w := NewWriter(cw)
|
||||
err := w.WriteHeader(&Header{
|
||||
Typeflag: TypeReg,
|
||||
Name: "file.bin",
|
||||
Size: int64(size),
|
||||
Mode: Mode644,
|
||||
ModTime: time.Unix(12345678, 0),
|
||||
})
|
||||
if err != nil {
|
||||
tt.Fatalf("size=%d chunk=%d: WriteHeader: %v", size, chunk, err)
|
||||
}
|
||||
|
||||
contents := make([]byte, size)
|
||||
for i := range contents {
|
||||
contents[i] = byte(i)
|
||||
}
|
||||
|
||||
if chunk <= 0 {
|
||||
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(contents[i:j]); err != nil {
|
||||
tt.Fatalf("size=%d chunk=%d: Write[%d:%d]: %v", size, chunk, i, j, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if err := w.Close(); err != nil {
|
||||
tt.Fatalf("size=%d chunk=%d: Close: %v", size, chunk, err)
|
||||
}
|
||||
return cw.buf.Bytes()
|
||||
}
|
||||
|
||||
// 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.
|
||||
func TestWriterChunked(tt *testing.T) {
|
||||
for _, size := range []int{0, 1, 300, 511, 512, 513, 700, 1000, 1024, 5000} {
|
||||
want := writeOneFileChunked(tt, size, 0)
|
||||
|
||||
for _, chunk := range []int{1, 100, 300, 511, 512, 700, 1024} {
|
||||
if got := writeOneFileChunked(tt, size, chunk); !bytes.Equal(got, want) {
|
||||
tt.Fatalf("size=%d chunk=%d: chunk size changed the archive bytes", size, chunk)
|
||||
}
|
||||
}
|
||||
|
||||
r := NewReader(bytes.NewReader(want))
|
||||
h, err := r.Next()
|
||||
if err != nil {
|
||||
tt.Fatalf("size=%d: Next: %v", size, err)
|
||||
} else if (h.Typeflag != TypeReg) || (h.Size != int64(size)) {
|
||||
tt.Fatalf("size=%d: got T:'%c' S:%d", size, h.Typeflag, h.Size)
|
||||
}
|
||||
got, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
tt.Fatalf("size=%d: ReadAll: %v", size, err)
|
||||
} else if len(got) != size {
|
||||
tt.Fatalf("size=%d: read back %d bytes", size, len(got))
|
||||
} else {
|
||||
for i, c := range got {
|
||||
if c != byte(i) {
|
||||
tt.Fatalf("size=%d: contents differ at %d", size, i)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if _, err := r.Next(); err != io.EOF {
|
||||
tt.Fatalf("size=%d: Next after the last entry: %v", size, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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 headers {
|
||||
if err := w.WriteHeader(&h); err != nil {
|
||||
tt.Fatalf("WriteHeader(%q): %v", h.Name, 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(&buf)
|
||||
for _, hWant := range headers {
|
||||
hGot, err := r.Next()
|
||||
if err != nil {
|
||||
tt.Fatalf("Next: %v", err)
|
||||
} else if !reflect.DeepEqual(hGot, hWant) {
|
||||
tt.Fatalf("got vs want\n%#v\n%#v", hGot, hWant)
|
||||
}
|
||||
|
||||
if readAll, err := io.ReadAll(r); err != nil {
|
||||
tt.Fatalf("ReadAll: %v", err)
|
||||
} 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)
|
||||
}
|
||||
}
|
||||
}
|
||||
+459
-89
@@ -35,11 +35,11 @@
|
||||
// may be better (faster) overall to skip any compression and decompression on
|
||||
// either side of the communication channel.
|
||||
//
|
||||
// The Encoder.Encode method also makes no further memory allocations (above
|
||||
// whatever its given io.Writer makes, if any). It is a lower-level API. See
|
||||
// the encodeImage function in this package's test code for a higher-level API
|
||||
// (with more dependencies and without the no-allocation guarantee) that takes
|
||||
// an image.Image argument.
|
||||
// The Encoder and AnimationEncoder methods also make no further memory
|
||||
// allocations (above whatever its given io.Writer makes, if any). They are
|
||||
// lower-level APIs. See the encodeImage function in this package's test code
|
||||
// for a higher-level API (with more dependencies and without the no-allocation
|
||||
// guarantee) that takes an image.Image argument.
|
||||
package uncompng
|
||||
|
||||
import (
|
||||
@@ -101,7 +101,7 @@ const (
|
||||
)
|
||||
|
||||
// Encoder is an opaque type that can convert a slice of pixel data to
|
||||
// PNG-formatted bytes.
|
||||
// PNG-formatted bytes. For APNG (Animated PNG), see AnimationEncoder.
|
||||
//
|
||||
// It contains all of the buffers needed for the Encode method. Once the
|
||||
// Encoder itself is allocated, Encoder.Encode makes no further allocations
|
||||
@@ -155,19 +155,58 @@ type Encoder struct {
|
||||
//
|
||||
// After that long preamble, here's the data layout of the buf field. Each
|
||||
// time a slice of buf is passed to an io.Writer, it contains exactly one
|
||||
// IDAT chunk. The final time will also contain an IEND chunk after the
|
||||
// IDAT chunk, unless it won't fit, in which case there will be one more
|
||||
// Write call with just the 12-byte IEND chunk (and no IDAT chunk).
|
||||
// IDAT chunk (or fdAT chunk, for animated PNG). The final time will also
|
||||
// contain an IEND chunk after the IDAT/fdAT chunk, unless it won't fit, in
|
||||
// which case there will be one more Write call with just the 12-byte IEND
|
||||
// chunk (and no IDAT/fdAT chunk).
|
||||
//
|
||||
// For all but the first Write, the 4-byte IDAT chunk length starts at
|
||||
// buf[0x0000:]. For the first Write, it will start at buf[0x0021:], since
|
||||
// it is preceded by the magic signature and the IHDR chunk.
|
||||
// When Encode'ing still PNGs, for all but the first Write, the 4-byte
|
||||
// IDAT/fdAT chunk length starts at buf[0x0000:]. For the first Write, it
|
||||
// will start at buf[0x0021:], since it is preceded by the magic signature
|
||||
// and the IHDR chunk.
|
||||
//
|
||||
// Either way, each IDAT chunk contains exactly one DEFLATE block (an
|
||||
// Either way, each IDAT/fdAT chunk contains exactly one DEFLATE block (an
|
||||
// uncompressed block). The very first IDAT (in the very first Write) also
|
||||
// contains the 2-byte ZLIB header. The very last IDAT also contains the
|
||||
// 4-byte Adler-32 checksum.
|
||||
//
|
||||
// For example, here's how buf might be filled (four times) and shipped out
|
||||
// to an io.Writer, when calling Encode to produce a still image.
|
||||
//
|
||||
// +--------------------------------------+
|
||||
// | MAGIC | IHDR | IDAT | Encode
|
||||
// +--------------------------------------+ :
|
||||
// | IDAT | :
|
||||
// +--------------------------------------+ :
|
||||
// | IDAT | :
|
||||
// +--------------------------------------+ :
|
||||
// | IDAT | IEND | unused | :
|
||||
// +--------------------------------------+
|
||||
//
|
||||
// The buf-packing is more complicated for an animated PNG. Reference (§).
|
||||
//
|
||||
// +--------------------------------------+
|
||||
// | MAGIC | IHDR | acTL | unused | EncodeHeader
|
||||
// +--------------------------------------+
|
||||
// | fcTL | IDAT | EncodeFrame
|
||||
// +--------------------------------------+ :
|
||||
// | IDAT | :
|
||||
// +--------------------------------------+ :
|
||||
// | IDAT | unused | :
|
||||
// +--------------------------------------+
|
||||
// | fcTL | fdAT | EncodeFrame
|
||||
// +--------------------------------------+ :
|
||||
// | fdAT | :
|
||||
// +--------------------------------------+ :
|
||||
// | fdAT | unused | :
|
||||
// +--------------------------------------+
|
||||
// | fcTL | fdAT | EncodeFrame
|
||||
// +--------------------------------------+ :
|
||||
// | fdAT | :
|
||||
// +--------------------------------------+ :
|
||||
// | fdAT | IEND | unused | :
|
||||
// +--------------------------------------+
|
||||
//
|
||||
// Each DEFLATE uncompressed block's payload spans e.buf[ei:ej], for two
|
||||
// indexes ei and ej, either explicit local variables or implicit state.
|
||||
// Writing pixel data to the Encoder increments ej, flushing to the
|
||||
@@ -182,12 +221,47 @@ type Encoder struct {
|
||||
// checksum state, as these 4 bytes won't be overwritten unless emitting
|
||||
// the final IDAT chunk (containing the final DEFLATE block).
|
||||
buf [65536]byte
|
||||
|
||||
// For still PNG images, there's 1 Encode call, which leads to:
|
||||
//
|
||||
// - 1 encodeImageHeader call. This sets buf to hold the magic signature,
|
||||
// IHDR chunk and the start of the first IDAT chunk, but does not write
|
||||
// to the io.Writer yet.
|
||||
// - 1 encodeFramePayload call, with frameTypeStill. This fills in the
|
||||
// rest of the first IDAT, and all of any remaining IDATs, and the final
|
||||
// IEND, writing to the io.Writer one or more times (on every flush
|
||||
// call, and possibly once more for the IEND chunk). Each flush is
|
||||
// passed frameTypeStill.
|
||||
//
|
||||
// For animated PNG images, there's 1 EncodeHeader call, which leads to...
|
||||
//
|
||||
// - 1 encodeImageHeader call. This sets buf to hold the magic signature,
|
||||
// IHDR chunk and acTL chunk, but not any part of any IDAT chunks. It
|
||||
// does, however, write to the io.Writer.
|
||||
//
|
||||
// ...and then N EncodeFrame calls, N = numFrames, each of which leads to:
|
||||
//
|
||||
// - 1 encodeFrameHeader call. This sets buf to hold the fcTL chunk and
|
||||
// the start of an IDAT/fdAT chunk, but does not write to the io.Writer.
|
||||
// - 1 encodeFramePayload call. This fills in the rest of the first
|
||||
// IDAT/fdAT, and all of any remaining IDATs/fdATs for that frame (and
|
||||
// the IEND if the last frame), writing to the io.Writer via flush,
|
||||
// similar to the still image case.
|
||||
//
|
||||
// For animated PNG images, the frameType argument, for encodeFramePayload
|
||||
// and flush, will have the frameTypeBitAnimated bit on. Of the N frames,
|
||||
// the frameTypeBitFirstFrame and frameTypeBitLastFrame bits are on for the
|
||||
// first and last frames. If N == 1, both bits are set for the only frame.
|
||||
}
|
||||
|
||||
type frameType byte
|
||||
|
||||
const (
|
||||
eiFirst = 0x0030
|
||||
eiLater = 0x000D
|
||||
ejMax = 0xFFF8
|
||||
frameTypeBitFirstFrame = frameType(1)
|
||||
frameTypeBitLastFrame = frameType(2)
|
||||
frameTypeBitAnimated = frameType(4)
|
||||
|
||||
frameTypeStill = frameTypeBitFirstFrame | frameTypeBitLastFrame
|
||||
)
|
||||
|
||||
// Encode writes the pixel data to w. It makes no allocations above whatever
|
||||
@@ -196,24 +270,50 @@ const (
|
||||
// pix holds the pixel data, either 1 or 4 bytes per pixel (doubled for
|
||||
// Depth16) depending on the colorType. width and height are measured in
|
||||
// pixels. stride is measured in bytes. depth must be either Depth8 or Depth16.
|
||||
func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride int, depth Depth, colorType ColorType) error {
|
||||
if (width < 0) || (height < 0) ||
|
||||
((depth != Depth8) && (depth != Depth16)) ||
|
||||
(colorType.pngFileFormatEncoding() == 0xFF) {
|
||||
return errors.New("uncompng: invalid argument")
|
||||
} else if (width > 0xFFFFFF) || (height > 0xFFFFFF) {
|
||||
return errors.New("uncompng: unsupported image size")
|
||||
func (e *Encoder) Encode(
|
||||
w io.Writer,
|
||||
depth Depth,
|
||||
colorType ColorType,
|
||||
width int,
|
||||
height int,
|
||||
pix []byte,
|
||||
stride int) error {
|
||||
|
||||
if err := checkArguments(depth, colorType, width, height, 1, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
e.init(width, height, depth, colorType)
|
||||
ej := eiFirst
|
||||
ej := e.encodeImageHeader(depth, colorType, width, height, 0, 0)
|
||||
return e.encodeFramePayload(
|
||||
w, frameTypeStill, nil, depth, colorType, width, height, pix, stride, ej)
|
||||
}
|
||||
|
||||
func (e *Encoder) encodeFramePayload(
|
||||
w io.Writer,
|
||||
fType frameType,
|
||||
seqNumPtr *uint32,
|
||||
depth Depth,
|
||||
colorType ColorType,
|
||||
width int,
|
||||
height int,
|
||||
pix []byte,
|
||||
stride int,
|
||||
ej int) (err error) {
|
||||
|
||||
// AdlerB=0, Adler32A=1.
|
||||
e.buf[0xFFFC] = 0
|
||||
e.buf[0xFFFD] = 0
|
||||
e.buf[0xFFFE] = 0
|
||||
e.buf[0xFFFF] = 1
|
||||
|
||||
const ejMax = 0xFFF8
|
||||
|
||||
for y := 0; y < height; y++ {
|
||||
if (ej + 1) > ejMax {
|
||||
if err := e.flush(w, ej, false); err != nil {
|
||||
ej, err = e.flush(w, fType, seqNumPtr, ej, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ej = eiLater
|
||||
}
|
||||
e.buf[ej+0] = 0 // PNG 'none' filter.
|
||||
ej += 1
|
||||
@@ -225,10 +325,10 @@ func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride
|
||||
row = row[:1*width]
|
||||
for x := 0; x < width; x++ {
|
||||
if (ej + 1) > ejMax {
|
||||
if err := e.flush(w, ej, false); err != nil {
|
||||
ej, err = e.flush(w, fType, seqNumPtr, ej, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ej = eiLater
|
||||
}
|
||||
e.buf[ej+0] = row[0]
|
||||
ej += 1
|
||||
@@ -239,10 +339,10 @@ func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride
|
||||
row = row[:4*width]
|
||||
for x := 0; x < width; x++ {
|
||||
if (ej + 3) > ejMax {
|
||||
if err := e.flush(w, ej, false); err != nil {
|
||||
ej, err = e.flush(w, fType, seqNumPtr, ej, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ej = eiLater
|
||||
}
|
||||
e.buf[ej+0] = row[0]
|
||||
e.buf[ej+1] = row[1]
|
||||
@@ -255,10 +355,10 @@ func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride
|
||||
row = row[:4*width]
|
||||
for x := 0; x < width; x++ {
|
||||
if (ej + 4) > ejMax {
|
||||
if err := e.flush(w, ej, false); err != nil {
|
||||
ej, err = e.flush(w, fType, seqNumPtr, ej, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ej = eiLater
|
||||
}
|
||||
e.buf[ej+0] = row[0]
|
||||
e.buf[ej+1] = row[1]
|
||||
@@ -272,10 +372,10 @@ func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride
|
||||
row = row[:2*width]
|
||||
for x := 0; x < width; x++ {
|
||||
if (ej + 2) > ejMax {
|
||||
if err := e.flush(w, ej, false); err != nil {
|
||||
ej, err = e.flush(w, fType, seqNumPtr, ej, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ej = eiLater
|
||||
}
|
||||
e.buf[ej+0] = row[0]
|
||||
e.buf[ej+1] = row[1]
|
||||
@@ -287,10 +387,10 @@ func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride
|
||||
row = row[:8*width]
|
||||
for x := 0; x < width; x++ {
|
||||
if (ej + 6) > ejMax {
|
||||
if err := e.flush(w, ej, false); err != nil {
|
||||
ej, err = e.flush(w, fType, seqNumPtr, ej, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ej = eiLater
|
||||
}
|
||||
e.buf[ej+0] = row[0]
|
||||
e.buf[ej+1] = row[1]
|
||||
@@ -306,10 +406,10 @@ func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride
|
||||
row = row[:8*width]
|
||||
for x := 0; x < width; x++ {
|
||||
if (ej + 8) > ejMax {
|
||||
if err := e.flush(w, ej, false); err != nil {
|
||||
ej, err = e.flush(w, fType, seqNumPtr, ej, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ej = eiLater
|
||||
}
|
||||
e.buf[ej+0] = row[0]
|
||||
e.buf[ej+1] = row[1]
|
||||
@@ -325,10 +425,18 @@ func (e *Encoder) Encode(w io.Writer, pix []byte, width int, height int, stride
|
||||
}
|
||||
}
|
||||
|
||||
return e.flush(w, ej, true)
|
||||
_, err = e.flush(w, fType, seqNumPtr, ej, true)
|
||||
return err
|
||||
}
|
||||
|
||||
func (e *Encoder) init(width int, height int, depth Depth, colorType ColorType) {
|
||||
func (e *Encoder) encodeImageHeader(
|
||||
depth Depth,
|
||||
colorType ColorType,
|
||||
width int,
|
||||
height int,
|
||||
numFrames uint32,
|
||||
numPlays uint32) int {
|
||||
|
||||
// PNG magic signature.
|
||||
e.buf[0x0000] = 0x89
|
||||
e.buf[0x0001] = 'P'
|
||||
@@ -370,7 +478,36 @@ func (e *Encoder) init(width int, height int, depth Depth, colorType ColorType)
|
||||
e.buf[0x001F] = byte(ihdrCRC32 >> 8)
|
||||
e.buf[0x0020] = byte(ihdrCRC32 >> 0)
|
||||
|
||||
// IDAT chunk length placeholder.
|
||||
if numFrames > 0 {
|
||||
// acTL chunk length.
|
||||
e.buf[0x0021] = 0
|
||||
e.buf[0x0022] = 0
|
||||
e.buf[0x0023] = 0
|
||||
e.buf[0x0024] = 0x08
|
||||
// acTL chunk type.
|
||||
e.buf[0x0025] = 'a'
|
||||
e.buf[0x0026] = 'c'
|
||||
e.buf[0x0027] = 'T'
|
||||
e.buf[0x0028] = 'L'
|
||||
// acTL chunk payload.
|
||||
e.buf[0x0029] = byte(numFrames >> 24)
|
||||
e.buf[0x002A] = byte(numFrames >> 16)
|
||||
e.buf[0x002B] = byte(numFrames >> 8)
|
||||
e.buf[0x002C] = byte(numFrames >> 0)
|
||||
e.buf[0x002D] = byte(numPlays >> 24)
|
||||
e.buf[0x002E] = byte(numPlays >> 16)
|
||||
e.buf[0x002F] = byte(numPlays >> 8)
|
||||
e.buf[0x0030] = byte(numPlays >> 0)
|
||||
// acTL CRC-32/IEEE checksum.
|
||||
actlCRC32 := crc32IEEE(e.buf[0x0025:0x0031])
|
||||
e.buf[0x0031] = byte(actlCRC32 >> 24)
|
||||
e.buf[0x0032] = byte(actlCRC32 >> 16)
|
||||
e.buf[0x0033] = byte(actlCRC32 >> 8)
|
||||
e.buf[0x0034] = byte(actlCRC32 >> 0)
|
||||
return 0x0035
|
||||
}
|
||||
|
||||
// IDAT chunk length placeholder. idatChunkStart is 0x0021.
|
||||
e.buf[0x0021] = 0
|
||||
e.buf[0x0022] = 0
|
||||
e.buf[0x0023] = 0
|
||||
@@ -389,16 +526,13 @@ func (e *Encoder) init(width int, height int, depth Depth, colorType ColorType)
|
||||
e.buf[0x002D] = 0
|
||||
e.buf[0x002E] = 0
|
||||
e.buf[0x002F] = 0
|
||||
// eiFirst is therefore 0x0030.
|
||||
|
||||
// AdlerB=0, Adler32A=1.
|
||||
e.buf[0xFFFC] = 0
|
||||
e.buf[0xFFFD] = 0
|
||||
e.buf[0xFFFE] = 0
|
||||
e.buf[0xFFFF] = 1
|
||||
return 0x0030
|
||||
}
|
||||
|
||||
func (e *Encoder) updateAdler32(ei int, ej int) {
|
||||
func (e *Encoder) updateAdler32(
|
||||
ei int,
|
||||
ej int) {
|
||||
|
||||
b := (uint32(e.buf[0xFFFC]) << 8) | uint32(e.buf[0xFFFD])
|
||||
a := (uint32(e.buf[0xFFFE]) << 8) | uint32(e.buf[0xFFFF])
|
||||
for ei < ej {
|
||||
@@ -419,34 +553,52 @@ func (e *Encoder) updateAdler32(ei int, ej int) {
|
||||
e.buf[0xFFFF] = byte(a >> 0)
|
||||
}
|
||||
|
||||
func (e *Encoder) flush(w io.Writer, ej int, final bool) error {
|
||||
// Update the IDAT chunk length placeholder.
|
||||
crc32Start, ei := 0, 0
|
||||
if e.buf[0x0004] == 0x0D { // First IDAT chunk.
|
||||
idatChunkLen := ej - 0x0029
|
||||
if final {
|
||||
idatChunkLen += 4
|
||||
}
|
||||
e.buf[0x0021] = byte(idatChunkLen >> 24)
|
||||
e.buf[0x0022] = byte(idatChunkLen >> 16)
|
||||
e.buf[0x0023] = byte(idatChunkLen >> 8)
|
||||
e.buf[0x0024] = byte(idatChunkLen >> 0)
|
||||
crc32Start, ei = 0x0025, eiFirst
|
||||
} else { // Later IDAT chunk.
|
||||
idatChunkLen := ej - 0x0008
|
||||
if final {
|
||||
idatChunkLen += 4
|
||||
}
|
||||
e.buf[0x0000] = byte(idatChunkLen >> 24)
|
||||
e.buf[0x0001] = byte(idatChunkLen >> 16)
|
||||
e.buf[0x0002] = byte(idatChunkLen >> 8)
|
||||
e.buf[0x0003] = byte(idatChunkLen >> 0)
|
||||
crc32Start, ei = 0x0004, eiLater
|
||||
func (e *Encoder) flush(
|
||||
w io.Writer,
|
||||
fType frameType,
|
||||
seqNumPtr *uint32,
|
||||
ej int,
|
||||
finalIDATOfFrame bool) (retEj int, retErr error) {
|
||||
|
||||
// Calculate where the IDAT/fdAT chunk starts, in e.buf. See (§).
|
||||
idatChunkStart := 0
|
||||
if e.buf[0x0007] == 0x0A {
|
||||
// 0x0A is magicSignature[7]. First IDAT chunk of a still image.
|
||||
idatChunkStart = 0x0021
|
||||
} else if e.buf[0x0007] == 0x4C {
|
||||
// 0x4C is "????fcTL"[7]. First IDAT/fdAT chunk of an animated frame.
|
||||
idatChunkStart = 0x0026
|
||||
} else if e.buf[0x0007] == 0x54 {
|
||||
// 0x54 is "??????AT"[7]. Later IDAT/fdAT chunk.
|
||||
idatChunkStart = 0x0000
|
||||
} else {
|
||||
return 0, errors.New("uncompng: unreachable")
|
||||
}
|
||||
|
||||
// 13 is the 0x000D in "Write... 0x000D bytes total" below.
|
||||
ei := idatChunkStart + 13
|
||||
if e.buf[0x0007] != 0x54 {
|
||||
// 2 more bytes for the ZLIB header (CM, CINFO, FDICT, FLEVEL).
|
||||
ei += 2
|
||||
}
|
||||
if (fType & frameTypeBitFirstFrame) == 0 {
|
||||
// fdAT chunks are longer than IDAT chunks by 4 bytes.
|
||||
ei += 4
|
||||
}
|
||||
|
||||
// Update the IDAT/fdAT chunk length placeholder.
|
||||
idatChunkLen := ej - (idatChunkStart + 8)
|
||||
if finalIDATOfFrame {
|
||||
idatChunkLen += 4 // The Adler-32 checksum occupies 4 bytes.
|
||||
}
|
||||
e.buf[idatChunkStart+0] = byte(idatChunkLen >> 24)
|
||||
e.buf[idatChunkStart+1] = byte(idatChunkLen >> 16)
|
||||
e.buf[idatChunkStart+2] = byte(idatChunkLen >> 8)
|
||||
e.buf[idatChunkStart+3] = byte(idatChunkLen >> 0)
|
||||
|
||||
// Update the DEFLATE uncompressed block header placeholder.
|
||||
deflateBlockLen := ej - ei
|
||||
e.buf[ei-5] = btou8(final)
|
||||
e.buf[ei-5] = btou8(finalIDATOfFrame)
|
||||
e.buf[ei-4] = 0x00 ^ byte(deflateBlockLen>>0)
|
||||
e.buf[ei-3] = 0x00 ^ byte(deflateBlockLen>>8)
|
||||
e.buf[ei-2] = 0xFF ^ byte(deflateBlockLen>>0)
|
||||
@@ -454,7 +606,7 @@ func (e *Encoder) flush(w io.Writer, ej int, final bool) error {
|
||||
|
||||
// Update (and maybe write) the Adler-32 checksum.
|
||||
e.updateAdler32(ei, ej)
|
||||
if final {
|
||||
if finalIDATOfFrame {
|
||||
e.buf[ej+0] = e.buf[0xFFFC]
|
||||
e.buf[ej+1] = e.buf[0xFFFD]
|
||||
e.buf[ej+2] = e.buf[0xFFFE]
|
||||
@@ -463,28 +615,44 @@ func (e *Encoder) flush(w io.Writer, ej int, final bool) error {
|
||||
}
|
||||
|
||||
// Write the CRC-32/IEEE checksum.
|
||||
idatCRC32 := crc32IEEE(e.buf[crc32Start:ej])
|
||||
idatCRC32 := crc32IEEE(e.buf[idatChunkStart+4 : ej])
|
||||
e.buf[ej+0] = byte(idatCRC32 >> 24)
|
||||
e.buf[ej+1] = byte(idatCRC32 >> 16)
|
||||
e.buf[ej+2] = byte(idatCRC32 >> 8)
|
||||
e.buf[ej+3] = byte(idatCRC32 >> 0)
|
||||
ej += 4
|
||||
|
||||
if !final {
|
||||
if !finalIDATOfFrame {
|
||||
if _, err := w.Write(e.buf[:ej]); err != nil {
|
||||
return err
|
||||
return 0, err
|
||||
}
|
||||
// Write (or reserve space for) 0x000D bytes total:
|
||||
// - 4 bytes for the IDAT chunk length placeholder.
|
||||
// - 4 bytes for the IDAT chunk type.
|
||||
// - 4 bytes for the IDAT/fdAT chunk length placeholder.
|
||||
// - 4 bytes for the IDAT/fdAT chunk type.
|
||||
// - 5 bytes for the DEFLATE uncompressed block header placeholder.
|
||||
//
|
||||
// eiLater is therefore 0x000D.
|
||||
e.buf[0x0004] = 'I'
|
||||
e.buf[0x0005] = 'D'
|
||||
t := fType & frameTypeBitFirstFrame
|
||||
e.buf[0x0004] = "fI"[t]
|
||||
e.buf[0x0005] = "dD"[t]
|
||||
e.buf[0x0006] = 'A'
|
||||
e.buf[0x0007] = 'T'
|
||||
return nil
|
||||
if (t != 0) || (seqNumPtr == nil) {
|
||||
return 0x000D + 0, nil
|
||||
}
|
||||
|
||||
seqNum := *seqNumPtr
|
||||
*seqNumPtr++
|
||||
e.buf[0x0008] = byte(seqNum >> 24)
|
||||
e.buf[0x0009] = byte(seqNum >> 16)
|
||||
e.buf[0x000A] = byte(seqNum >> 8)
|
||||
e.buf[0x000B] = byte(seqNum >> 0)
|
||||
return 0x000D + 4, nil
|
||||
}
|
||||
|
||||
if (fType & frameTypeBitLastFrame) == 0 {
|
||||
if _, err := w.Write(e.buf[:ej]); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
const iendChunk = "\x00\x00\x00\x00IEND\xAE\x42\x60\x82"
|
||||
@@ -495,27 +663,229 @@ func (e *Encoder) flush(w io.Writer, ej int, final bool) error {
|
||||
}
|
||||
|
||||
if _, err := w.Write(e.buf[:ej]); err != nil {
|
||||
return err
|
||||
return 0, err
|
||||
}
|
||||
|
||||
if writeSeparateIENDChunk {
|
||||
copy(e.buf[:], iendChunk)
|
||||
if _, err := w.Write(e.buf[:len(iendChunk)]); err != nil {
|
||||
return err
|
||||
return 0, err
|
||||
}
|
||||
}
|
||||
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
// AnimationEncoder is like Encoder but for APNG (Animated PNG), not still PNG.
|
||||
//
|
||||
// It contains all of the buffers needed for the EncodeXxx methods. Once the
|
||||
// AnimationEncoder itself is allocated, AnimationEncoder.EncodeXxx makes no
|
||||
// further allocations (above whatever its given io.Writer makes, if any).
|
||||
//
|
||||
// To create one APNG, call EncodeHeader once (with a given numFrames > 0
|
||||
// argument) and then EncodeFrame numFrames times.
|
||||
//
|
||||
// It can be re-used (but it is not thread-safe). One AnimationEncoder can make
|
||||
// multiple (1 EncodeHeader + N EncodeFrame) call sequences, potentially with
|
||||
// different N values, each producing a complete, stand-alone APNG image.
|
||||
type AnimationEncoder struct {
|
||||
enc Encoder
|
||||
|
||||
depth Depth
|
||||
colorType ColorType
|
||||
|
||||
width uint32
|
||||
height uint32
|
||||
seqNum uint32
|
||||
numFrames uint32
|
||||
curFrame uint32
|
||||
}
|
||||
|
||||
// EncodeHeader writes the APNG header to w. It makes no allocations above
|
||||
// whatever w.Write makes, if any.
|
||||
//
|
||||
// The arguments are similar to Encoder.Encode, as well as numFrames > 0 being
|
||||
// the number of animation frames and numPlays being the number of times each
|
||||
// animation frame is played (zero means to loop forever).
|
||||
func (e *AnimationEncoder) EncodeHeader(
|
||||
w io.Writer,
|
||||
depth Depth,
|
||||
colorType ColorType,
|
||||
width int,
|
||||
height int,
|
||||
numFrames uint32,
|
||||
numPlays uint32) error {
|
||||
|
||||
if err := checkArguments(depth, colorType, width, height, numFrames, numPlays); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
e.depth = depth
|
||||
e.colorType = colorType
|
||||
|
||||
e.width = uint32(width)
|
||||
e.height = uint32(height)
|
||||
e.seqNum = 0
|
||||
e.numFrames = numFrames
|
||||
e.curFrame = 0
|
||||
|
||||
ej := e.enc.encodeImageHeader(depth, colorType, width, height, numFrames, numPlays)
|
||||
_, err := w.Write(e.enc.buf[:ej])
|
||||
return err
|
||||
}
|
||||
|
||||
// EncodeFrame writes an animation frame to w. It makes no allocations above
|
||||
// whatever w.Write makes, if any.
|
||||
//
|
||||
// The arguments are similar to Encoder.Encode, as well as (delayNumerator /
|
||||
// delayDenominator) being how many seconds to display the frame. For example,
|
||||
// if delayDenominator == 1000, delayNumerator is measured in milliseconds.
|
||||
func (e *AnimationEncoder) EncodeFrame(
|
||||
w io.Writer,
|
||||
pix []byte,
|
||||
stride int,
|
||||
delayNumerator uint16,
|
||||
delayDenominator uint16) error {
|
||||
|
||||
if e.numFrames == 0 {
|
||||
return errors.New("uncompng: EncodeHeader was not called")
|
||||
} else if e.curFrame >= e.numFrames {
|
||||
return errors.New("uncompng: too many EncodeFrame calls")
|
||||
} else if e.seqNum >= 0x80000000 {
|
||||
return errors.New("uncompng: too many frames")
|
||||
}
|
||||
|
||||
fType := frameTypeBitAnimated
|
||||
if e.curFrame == 0 {
|
||||
fType |= frameTypeBitFirstFrame
|
||||
}
|
||||
e.curFrame++
|
||||
if e.curFrame == e.numFrames {
|
||||
fType |= frameTypeBitLastFrame
|
||||
}
|
||||
|
||||
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(
|
||||
delayNumerator uint16,
|
||||
delayDenominator uint16) int {
|
||||
|
||||
// fcTL chunk length.
|
||||
e.enc.buf[0x0000] = 0
|
||||
e.enc.buf[0x0001] = 0
|
||||
e.enc.buf[0x0002] = 0
|
||||
e.enc.buf[0x0003] = 0x1A
|
||||
// fcTL chunk type.
|
||||
e.enc.buf[0x0004] = 'f'
|
||||
e.enc.buf[0x0005] = 'c'
|
||||
e.enc.buf[0x0006] = 'T'
|
||||
e.enc.buf[0x0007] = 'L'
|
||||
// fcTL payload.
|
||||
e.enc.buf[0x0008] = byte(e.seqNum >> 24)
|
||||
e.enc.buf[0x0009] = byte(e.seqNum >> 16)
|
||||
e.enc.buf[0x000A] = byte(e.seqNum >> 8)
|
||||
e.enc.buf[0x000B] = byte(e.seqNum >> 0)
|
||||
e.enc.buf[0x000C] = byte(e.width >> 24)
|
||||
e.enc.buf[0x000D] = byte(e.width >> 16)
|
||||
e.enc.buf[0x000E] = byte(e.width >> 8)
|
||||
e.enc.buf[0x000F] = byte(e.width >> 0)
|
||||
e.enc.buf[0x0010] = byte(e.height >> 24)
|
||||
e.enc.buf[0x0011] = byte(e.height >> 16)
|
||||
e.enc.buf[0x0012] = byte(e.height >> 8)
|
||||
e.enc.buf[0x0013] = byte(e.height >> 0)
|
||||
e.enc.buf[0x0014] = 0 // X offset.
|
||||
e.enc.buf[0x0015] = 0
|
||||
e.enc.buf[0x0016] = 0
|
||||
e.enc.buf[0x0017] = 0
|
||||
e.enc.buf[0x0018] = 0 // Y offset.
|
||||
e.enc.buf[0x0019] = 0
|
||||
e.enc.buf[0x001A] = 0
|
||||
e.enc.buf[0x001B] = 0
|
||||
e.enc.buf[0x001C] = byte(delayNumerator >> 8)
|
||||
e.enc.buf[0x001D] = byte(delayNumerator >> 0)
|
||||
e.enc.buf[0x001E] = byte(delayDenominator >> 8)
|
||||
e.enc.buf[0x001F] = byte(delayDenominator >> 0)
|
||||
e.enc.buf[0x0020] = 0 // APNG_DISPOSE_OP_NONE.
|
||||
e.enc.buf[0x0021] = 0 // APNG_BLEND_OP_SOURCE.
|
||||
// fcTL CRC-32/IEEE checksum.
|
||||
fctlCRC32 := crc32IEEE(e.enc.buf[0x0004:0x0022])
|
||||
e.enc.buf[0x0022] = byte(fctlCRC32 >> 24)
|
||||
e.enc.buf[0x0023] = byte(fctlCRC32 >> 16)
|
||||
e.enc.buf[0x0024] = byte(fctlCRC32 >> 8)
|
||||
e.enc.buf[0x0025] = byte(fctlCRC32 >> 0)
|
||||
|
||||
useIDAT := 0
|
||||
if e.seqNum == 0 {
|
||||
useIDAT = 1
|
||||
}
|
||||
e.seqNum++
|
||||
|
||||
// IDAT/fdAT chunk length placeholder. idatChunkStart is 0x0026.
|
||||
e.enc.buf[0x0026] = 0
|
||||
e.enc.buf[0x0027] = 0
|
||||
e.enc.buf[0x0028] = 0
|
||||
e.enc.buf[0x0029] = 0
|
||||
// IDAT/fdAT chunk type.
|
||||
e.enc.buf[0x002A] = "fI"[useIDAT]
|
||||
e.enc.buf[0x002B] = "dD"[useIDAT]
|
||||
e.enc.buf[0x002C] = 'A'
|
||||
e.enc.buf[0x002D] = 'T'
|
||||
ej := 0x002E
|
||||
|
||||
if useIDAT == 0 {
|
||||
e.enc.buf[0x002E] = byte(e.seqNum >> 24)
|
||||
e.enc.buf[0x002F] = byte(e.seqNum >> 16)
|
||||
e.enc.buf[0x0030] = byte(e.seqNum >> 8)
|
||||
e.enc.buf[0x0031] = byte(e.seqNum >> 0)
|
||||
e.seqNum++
|
||||
ej = 0x0032
|
||||
}
|
||||
|
||||
// ZLIB header: CM=8, CINFO=7, FDICT=0, FLEVEL=0. See RFC 1950.
|
||||
e.enc.buf[ej+0x00] = 0x78
|
||||
e.enc.buf[ej+0x01] = 0x01
|
||||
// DEFLATE uncompressed block header, with 4-byte placeholder for length.
|
||||
e.enc.buf[ej+0x02] = 0
|
||||
e.enc.buf[ej+0x03] = 0
|
||||
e.enc.buf[ej+0x04] = 0
|
||||
e.enc.buf[ej+0x05] = 0
|
||||
e.enc.buf[ej+0x06] = 0
|
||||
return ej + 0x07
|
||||
}
|
||||
|
||||
func checkArguments(
|
||||
depth Depth,
|
||||
colorType ColorType,
|
||||
width int,
|
||||
height int,
|
||||
numFrames uint32,
|
||||
numPlays uint32) error {
|
||||
|
||||
if ((depth != Depth8) && (depth != Depth16)) ||
|
||||
(colorType.pngFileFormatEncoding() == 0xFF) ||
|
||||
(width <= 0) || (height <= 0) || (numFrames <= 0) {
|
||||
return errors.New("uncompng: invalid argument")
|
||||
} else if (width > 0xFFFFFF) || (height > 0xFFFFFF) {
|
||||
return errors.New("uncompng: unsupported image size")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func btou8(a bool) uint8 {
|
||||
func btou8(
|
||||
a bool) uint8 {
|
||||
|
||||
if a {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func crc32IEEE(b []byte) uint32 {
|
||||
func crc32IEEE(
|
||||
b []byte) uint32 {
|
||||
|
||||
hash := uint32(0xFFFF_FFFF)
|
||||
for _, v := range b {
|
||||
hash = crc32IEEETable[uint8(hash)^v] ^ (hash >> 8)
|
||||
|
||||
+306
-10
@@ -12,6 +12,8 @@ package uncompng
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"hash/crc32"
|
||||
"image"
|
||||
"image/draw"
|
||||
"image/png"
|
||||
@@ -26,39 +28,39 @@ func encodeImage(w io.Writer, src image.Image) error {
|
||||
|
||||
switch src := src.(type) {
|
||||
case *image.Gray:
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeGray)
|
||||
return e.Encode(w, Depth8, ColorTypeGray, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
|
||||
case *image.Gray16:
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth16, ColorTypeGray)
|
||||
return e.Encode(w, Depth16, ColorTypeGray, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
|
||||
case *image.RGBA:
|
||||
if src.Opaque() {
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeRGBX)
|
||||
return e.Encode(w, Depth8, ColorTypeRGBX, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
}
|
||||
|
||||
case *image.RGBA64:
|
||||
if src.Opaque() {
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth16, ColorTypeRGBX)
|
||||
return e.Encode(w, Depth16, ColorTypeRGBX, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
}
|
||||
|
||||
case *image.NRGBA:
|
||||
if src.Opaque() {
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeRGBX)
|
||||
return e.Encode(w, Depth8, ColorTypeRGBX, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
} else {
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth8, ColorTypeNRGBA)
|
||||
return e.Encode(w, Depth8, ColorTypeNRGBA, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
}
|
||||
|
||||
case *image.NRGBA64:
|
||||
if src.Opaque() {
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth16, ColorTypeRGBX)
|
||||
return e.Encode(w, Depth16, ColorTypeRGBX, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
} else {
|
||||
return e.Encode(w, src.Pix, b.Dx(), b.Dy(), src.Stride, Depth16, ColorTypeNRGBA)
|
||||
return e.Encode(w, Depth16, ColorTypeNRGBA, b.Dx(), b.Dy(), src.Pix, src.Stride)
|
||||
}
|
||||
}
|
||||
|
||||
tmp := image.NewNRGBA(b)
|
||||
draw.Draw(tmp, b, src, b.Min, draw.Src)
|
||||
return e.Encode(w, tmp.Pix, b.Dx(), b.Dy(), tmp.Stride, Depth8, ColorTypeNRGBA)
|
||||
return e.Encode(w, Depth8, ColorTypeNRGBA, b.Dx(), b.Dy(), tmp.Pix, tmp.Stride)
|
||||
}
|
||||
|
||||
func getPix(m image.Image) []byte {
|
||||
@@ -144,7 +146,7 @@ func TestNoAllocation(tt *testing.T) {
|
||||
enc := Encoder{}
|
||||
pix := make([]byte, 4*3*5)
|
||||
got := testing.AllocsPerRun(100, func() {
|
||||
enc.Encode(io.Discard, pix, 3, 5, 4*3, Depth8, ColorTypeNRGBA)
|
||||
enc.Encode(io.Discard, Depth8, ColorTypeNRGBA, 3, 5, pix, 4*3)
|
||||
})
|
||||
if got != 0 {
|
||||
tt.Errorf("AllocsPerRun: got %v, want 0", got)
|
||||
@@ -184,3 +186,297 @@ func TestWriteSeparateIENDChunk(tt *testing.T) {
|
||||
tt.Fatalf("have not seen a separate IEND chunk")
|
||||
}
|
||||
}
|
||||
|
||||
// TestAnimationEncoder recreates the "Example NIA File" animation from
|
||||
// doc/spec/nie-spec.md, but in APNG format, not NIA format:
|
||||
//
|
||||
// This animated image is 3 pixels wide and 2 pixels high. It consists of 20
|
||||
// frames, being 10 loops of 2 frames. The total animation time of a single
|
||||
// loop is 3 seconds, so the 10 loops will take 30 seconds. The first frame is
|
||||
// a crude approximation to the French flag (blue, white and red) and is shown
|
||||
// for 1 second. The next frame is a crude approximation to the Italian flag
|
||||
// (green, white and red) and is shown for (3 - 1) seconds (i.e., 2 seconds).
|
||||
//
|
||||
// This test just hard-codes the expected golden output (in APNG format).
|
||||
// Saving the output to a file instead, and then transforming its contents via
|
||||
// convert-to-nia, should recover the same bytes (in NIA format) as given in
|
||||
// doc/spec/nie-spec.md.
|
||||
func TestAnimationEncoderSmall(tt *testing.T) {
|
||||
want := "" +
|
||||
"\x89PNG\x0D\x0A\x1A\x0A" + // PNG magic signature.
|
||||
"" +
|
||||
"\x00\x00\x00\x0DIHDR" + // Chunk length and type.
|
||||
"\x00\x00\x00\x03" + // Width.
|
||||
"\x00\x00\x00\x02" + // Height.
|
||||
"\x08\x02\x00\x00\x00" + // Depth and other fields.
|
||||
"\x12\x16\xF1\x4D" + // Chunk checksum (CRC-32).
|
||||
"" +
|
||||
"\x00\x00\x00\x08acTL" + // Chunk length and type.
|
||||
"\x00\x00\x00\x02" + // 2 frames.
|
||||
"\x00\x00\x00\x0A" + // 10 plays.
|
||||
"\x13\x58\x7A\x6E" + // Chunk checksum (CRC-32).
|
||||
"" + //
|
||||
"\x00\x00\x00\x1AfcTL" + // Chunk length and type.
|
||||
"\x00\x00\x00\x00" + // Animation sequence number.
|
||||
"\x00\x00\x00\x03" + // Width.
|
||||
"\x00\x00\x00\x02" + // Height.
|
||||
"\x00\x00\x00\x00" + // XOffset.
|
||||
"\x00\x00\x00\x00" + // YOffset.
|
||||
"\x03\xE8\x03\xE8" + // Delay (numerator = 1000, denominator = 1000).
|
||||
"\x00\x00" + // DisposeOp, BlendOp.
|
||||
"\x24\x35\x20\x78" + // Chunk checksum (CRC-32).
|
||||
"" + //
|
||||
"\x00\x00\x00\x1FIDAT" + // Chunk length and type.
|
||||
"\x78\x01\x01\x14\x00\xEB\xFF" + // ZLIB, final block, 20 bytes.
|
||||
"\x00" + // PNG row filter.
|
||||
"\x00\x00\xFF" + // RGB pixel.
|
||||
"\xFF\xFF\xFF" + // RGB pixel.
|
||||
"\xFF\x00\x00" + // RGB pixel.
|
||||
"\x00" + // PNG row filter.
|
||||
"\x00\x00\xFF" + // RGB pixel.
|
||||
"\xFF\xFF\xFF" + // RGB pixel.
|
||||
"\xFF\x00\x00" + // RGB pixel.
|
||||
"\x63\xB0\x09\xF7" + // ZLIB checksum (Adler32).
|
||||
"\xDD\xD2\x78\x8A" + // Chunk checksum (CRC-32).
|
||||
"" + //
|
||||
"\x00\x00\x00\x1AfcTL" + // Chunk length and type.
|
||||
"\x00\x00\x00\x01" + // Animation sequence number.
|
||||
"\x00\x00\x00\x03" + // Width.
|
||||
"\x00\x00\x00\x02" + // Height.
|
||||
"\x00\x00\x00\x00" + // XOffset.
|
||||
"\x00\x00\x00\x00" + // YOffset.
|
||||
"\x07\xD0\x03\xE8" + // Delay (numerator = 2000, denominator = 1000).
|
||||
"\x00\x00" + // DisposeOp, BlendOp.
|
||||
"\xB5\x86\x7B\xFD" + // Chunk checksum (CRC-32).
|
||||
"" + //
|
||||
"\x00\x00\x00\x23fdAT" + // Chunk length and type.
|
||||
"\x00\x00\x00\x02" + // Animation sequence number.
|
||||
"\x78\x01\x01\x14\x00\xEB\xFF" + // ZLIB, final block, 20 bytes.
|
||||
"\x00" + // PNG row filter.
|
||||
"\x00\xFF\x00" + // RGB pixel.
|
||||
"\xFF\xFF\xFF" + // RGB pixel.
|
||||
"\xFF\x00\x00" + // RGB pixel.
|
||||
"\x00" + // PNG row filter.
|
||||
"\x00\xFF\x00" + // RGB pixel.
|
||||
"\xFF\xFF\xFF" + // RGB pixel.
|
||||
"\xFF\x00\x00" + // RGB pixel.
|
||||
"\x65\xAE\x09\xF7" + // ZLIB checksum (Adler32).
|
||||
"\xFA\x44\x2A\xBE" + // Chunk checksum (CRC-32).
|
||||
"" + //
|
||||
"\x00\x00\x00\x00IEND" + // Chunk length and type.
|
||||
"\xAE\x42\x60\x82" + // Chunk checksum (CRC-32).
|
||||
""
|
||||
|
||||
const bytesPerPixel = 4
|
||||
const width = 3
|
||||
const height = 2
|
||||
const numFrames = 2
|
||||
const numPlays = 10
|
||||
|
||||
buf := bytes.Buffer{}
|
||||
e := AnimationEncoder{}
|
||||
|
||||
pixs := [numFrames][bytesPerPixel * width * height]byte{{
|
||||
0x00, 0x00, 0xFF, 0xFF, // Blue.
|
||||
0xFF, 0xFF, 0xFF, 0xFF, // White.
|
||||
0xFF, 0x00, 0x00, 0xFF, // Red.
|
||||
|
||||
0x00, 0x00, 0xFF, 0xFF, // Blue.
|
||||
0xFF, 0xFF, 0xFF, 0xFF, // White.
|
||||
0xFF, 0x00, 0x00, 0xFF, // Red.
|
||||
|
||||
}, {
|
||||
0x00, 0xFF, 0x00, 0xFF, // Green.
|
||||
0xFF, 0xFF, 0xFF, 0xFF, // White.
|
||||
0xFF, 0x00, 0x00, 0xFF, // Red.
|
||||
|
||||
0x00, 0xFF, 0x00, 0xFF, // Green.
|
||||
0xFF, 0xFF, 0xFF, 0xFF, // White.
|
||||
0xFF, 0x00, 0x00, 0xFF, // Red.
|
||||
}}
|
||||
|
||||
delayMillis := [numFrames]uint16{1000, 2000}
|
||||
|
||||
if err := e.EncodeHeader(&buf, Depth8, ColorTypeRGBX, width, height, numFrames, numPlays); err != nil {
|
||||
tt.Fatalf("EncodeHeader: %v", err)
|
||||
}
|
||||
|
||||
for f := range pixs {
|
||||
if err := e.EncodeFrame(&buf, pixs[f][:], bytesPerPixel*width, delayMillis[f], 1000); err != nil {
|
||||
tt.Fatalf("EncodeFrame(%d): %v", f, err)
|
||||
}
|
||||
}
|
||||
|
||||
asBytes := buf.Bytes()
|
||||
checkAPNGConsistency(tt, asBytes)
|
||||
|
||||
if got := string(asBytes); got != want {
|
||||
for i := range min(len(got), len(want)) {
|
||||
if got[i] != want[i] {
|
||||
tt.Fatalf("compare-to-golden: at byte %d\ngot % 02X\nwant % 02X", i, got, want)
|
||||
}
|
||||
}
|
||||
tt.Fatalf("compare-to-golden:\ngot % 02X\nwant % 02X", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnimationEncoderLarge(tt *testing.T) {
|
||||
srcFile, err := os.Open("../../test/data/hibiscus.regular.png")
|
||||
if err != nil {
|
||||
tt.Fatalf("os.Open: %v", err)
|
||||
}
|
||||
defer srcFile.Close()
|
||||
|
||||
srcImage, err := png.Decode(srcFile)
|
||||
if err != nil {
|
||||
tt.Fatalf("png.Decode: %v", err)
|
||||
}
|
||||
srcRGBA := srcImage.(*image.RGBA)
|
||||
if got, want := srcRGBA.Bounds(), image.Rect(0, 0, 312, 442); got != want {
|
||||
tt.Fatalf("Bounds: got %v, want %v", got, want)
|
||||
}
|
||||
srcPix := srcRGBA.Pix
|
||||
|
||||
// Make a copy of srcPix. PNG alpha is non-premul and Go's RGBA alpha is
|
||||
// premul. The fact that Go's png.Decode returned RGBA (instead of NRGBA)
|
||||
// means that all of the alpha values should be 0xFF, so that converting
|
||||
// srcPix (as RGBA) to srcPixAsNRGBA can just be a memcpy.
|
||||
srcPixAsNRGBA := append([]byte(nil), srcPix...)
|
||||
|
||||
buf := bytes.Buffer{}
|
||||
e := AnimationEncoder{}
|
||||
|
||||
const bytesPerPixel = 4
|
||||
const width = 312
|
||||
const height = 442
|
||||
const numFrames = 5
|
||||
const numPlays = 0
|
||||
delayMillis := [numFrames]uint16{300, 500, 600, 400, 200}
|
||||
|
||||
if err := e.EncodeHeader(&buf, Depth8, ColorTypeNRGBA, width, height, numFrames, numPlays); err != nil {
|
||||
tt.Fatalf("EncodeHeader: %v", err)
|
||||
}
|
||||
|
||||
for f, delay := range delayMillis {
|
||||
if err := e.EncodeFrame(&buf, srcPix, bytesPerPixel*width, delay, 1000); err != nil {
|
||||
tt.Fatalf("EncodeFrame(%d): %v", f, err)
|
||||
}
|
||||
|
||||
// Over time, set the R, G, B, A channel values to 0x80.
|
||||
if f < 4 {
|
||||
for i := f; i < len(srcPix); i += 4 {
|
||||
srcPix[i] = 0x80
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
asBytes := buf.Bytes()
|
||||
checkAPNGConsistency(tt, asBytes)
|
||||
|
||||
if got, want := crc32.ChecksumIEEE(asBytes), uint32(0x73B25773); got != want {
|
||||
tt.Fatalf("did not get golden-output hash")
|
||||
}
|
||||
|
||||
// png.Decode from Go's standard library doesn't recover all of the
|
||||
// animation's frames, but it should recover the first frame.
|
||||
//
|
||||
// We also passed ColorTypeNRGBA (not ColorTypeRGBX) to EncodeHeader, so
|
||||
// the decoded image is *image.NRGBA, not *image.RGBA.
|
||||
dstImage, err := png.Decode(bytes.NewReader(asBytes))
|
||||
if err != nil {
|
||||
tt.Fatalf("png.Decode: %v", err)
|
||||
}
|
||||
dstNRGBA := dstImage.(*image.NRGBA)
|
||||
if !bytes.Equal(dstNRGBA.Pix, srcPixAsNRGBA) {
|
||||
tt.Fatal("first frame pixels: round-trip failed")
|
||||
}
|
||||
|
||||
// Change false to true, for manual inspection in a viewer that supports
|
||||
// APNG, such as a web browser.
|
||||
if false {
|
||||
os.WriteFile("/tmp/TestAnimationEncoderLarge.png", asBytes, 0644)
|
||||
}
|
||||
}
|
||||
|
||||
func checkAPNGConsistency(tt *testing.T, pngEncodedBytes []byte) {
|
||||
if !bytes.HasPrefix(pngEncodedBytes, []byte("\x89PNG\x0D\x0A\x1A\x0A")) {
|
||||
tt.Fatalf("bad PNG magic signature")
|
||||
}
|
||||
|
||||
forEachChunk := func(f func(chunk []byte)) {
|
||||
for b := pngEncodedBytes[8:]; len(b) > 0; {
|
||||
if len(b) < 12 {
|
||||
tt.Fatalf("bad chunk structure")
|
||||
}
|
||||
n := int64(u32be(b))
|
||||
if (n + 12) > int64(len(b)) {
|
||||
tt.Fatalf("bad chunk structure")
|
||||
}
|
||||
f(b[:n+12])
|
||||
b = b[n+12:]
|
||||
}
|
||||
}
|
||||
|
||||
forEachChunk(func(chunk []byte) {
|
||||
checksum0 := u32be(chunk[len(chunk)-4:])
|
||||
checksum1 := crc32.ChecksumIEEE(chunk[4 : len(chunk)-4])
|
||||
if checksum0 != checksum1 {
|
||||
tt.Fatalf("bad chunk checksum")
|
||||
}
|
||||
})
|
||||
|
||||
nextSeqNum := uint32(0)
|
||||
forEachChunk(func(chunk []byte) {
|
||||
switch u32be(chunk[4:]) {
|
||||
case 0x6663544C, 0x66644154: // "fcTL"be, "fdAT"be.
|
||||
got := u32be(chunk[8:])
|
||||
want := nextSeqNum
|
||||
nextSeqNum++
|
||||
if got != want {
|
||||
tt.Fatalf("bad animation sequence number")
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
idatlikeData := [][]byte{}
|
||||
forEachChunk(func(chunk []byte) {
|
||||
dat := []byte(nil)
|
||||
|
||||
switch u32be(chunk[4:]) {
|
||||
case 0x6663544C: // "fcTL"be.
|
||||
idatlikeData = append(idatlikeData, nil)
|
||||
case 0x66644154: // "fdAT"be.
|
||||
dat = chunk[12 : len(chunk)-4]
|
||||
case 0x49444154: // "IDAT"be.
|
||||
dat = chunk[8 : len(chunk)-4]
|
||||
}
|
||||
|
||||
if dat != nil {
|
||||
last := len(idatlikeData) - 1
|
||||
idatlikeData[last] = append(idatlikeData[last], dat...)
|
||||
}
|
||||
})
|
||||
|
||||
decompressedLen := int64(0)
|
||||
for i, dat := range idatlikeData {
|
||||
r, err := zlib.NewReader(bytes.NewReader(dat))
|
||||
if err != nil {
|
||||
tt.Fatalf("IDAT/fdAT chunk data was not ZLIB-formatted")
|
||||
}
|
||||
defer r.Close()
|
||||
if n, err := io.Copy(io.Discard, r); err != nil {
|
||||
tt.Fatalf("IDAT/fdAT chunk data was not ZLIB-formatted")
|
||||
} else if i == 0 {
|
||||
decompressedLen = n
|
||||
} else if decompressedLen != n {
|
||||
tt.Fatalf("IDAT/fdAT chunk data has inconsistent lengths")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func u32be(b []byte) uint32 {
|
||||
return (uint32(b[0]) << 24) |
|
||||
(uint32(b[1]) << 16) |
|
||||
(uint32(b[2]) << 8) |
|
||||
(uint32(b[3]) << 0)
|
||||
}
|
||||
+2961
-1090
@@ -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.
|
||||
@@ -1752,7 +1804,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;
|
||||
}
|
||||
@@ -1760,7 +1812,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;
|
||||
}
|
||||
@@ -1768,7 +1820,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;
|
||||
}
|
||||
@@ -1776,7 +1828,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;
|
||||
}
|
||||
@@ -1917,7 +1969,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();
|
||||
}
|
||||
@@ -1941,7 +1998,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();
|
||||
}
|
||||
@@ -3165,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
|
||||
@@ -3307,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).
|
||||
@@ -3371,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);
|
||||
@@ -3397,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 {
|
||||
@@ -4017,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 {
|
||||
@@ -4376,6 +4493,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
|
||||
@@ -4595,6 +4716,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) {
|
||||
@@ -4826,6 +4962,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
|
||||
@@ -5207,13 +5348,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
|
||||
|
||||
@@ -5839,15 +5988,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
|
||||
|
||||
@@ -6042,24 +6208,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);
|
||||
|
||||
@@ -6104,7 +6290,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 //
|
||||
@@ -6112,14 +6304,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 //
|
||||
@@ -13793,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;
|
||||
@@ -13805,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;
|
||||
@@ -13870,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;
|
||||
@@ -13912,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;
|
||||
@@ -15457,7 +15683,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[];
|
||||
@@ -15465,7 +15693,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
|
||||
|
||||
@@ -15636,8 +15868,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;
|
||||
@@ -16214,18 +16448,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
|
||||
|
||||
@@ -16394,16 +16630,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];
|
||||
@@ -16422,24 +16661,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 {
|
||||
@@ -16490,6 +16733,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;
|
||||
@@ -16500,15 +16753,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
|
||||
@@ -17808,6 +18057,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 //
|
||||
@@ -17880,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;
|
||||
};
|
||||
@@ -19178,8 +19431,14 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
|
||||
// ---------------- 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
|
||||
@@ -21409,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 {
|
||||
@@ -21429,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
|
||||
@@ -21488,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 &
|
||||
@@ -21549,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 == '+') {
|
||||
@@ -23326,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++;
|
||||
@@ -23336,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) {
|
||||
@@ -24318,6 +24576,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)));
|
||||
@@ -24425,7 +24703,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,
|
||||
@@ -24538,6 +24816,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 //
|
||||
@@ -24665,7 +25302,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) {
|
||||
@@ -24737,7 +25374,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);
|
||||
@@ -32440,6 +33077,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,
|
||||
@@ -32461,7 +33194,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));
|
||||
}
|
||||
}
|
||||
@@ -32488,7 +33221,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));
|
||||
}
|
||||
}
|
||||
@@ -32518,7 +33251,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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32535,7 +33268,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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32596,7 +33329,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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -33802,7 +34535,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);
|
||||
}
|
||||
@@ -33877,7 +34610,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);
|
||||
}
|
||||
@@ -33890,7 +34624,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:
|
||||
@@ -34035,14 +34769,39 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
}
|
||||
|
||||
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, //
|
||||
@@ -35304,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);
|
||||
@@ -69666,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(
|
||||
@@ -72211,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);
|
||||
@@ -72219,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;
|
||||
@@ -72237,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;
|
||||
@@ -72256,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;
|
||||
@@ -72275,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;
|
||||
@@ -72294,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;
|
||||
@@ -72308,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;
|
||||
@@ -72749,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
|
||||
@@ -74920,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) {
|
||||
@@ -80933,7 +81801,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";
|
||||
@@ -81828,6 +82698,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
|
||||
@@ -82029,7 +82901,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
|
||||
@@ -82081,6 +82952,7 @@ static wuffs_base__status
|
||||
wuffs_vp8__decoder__swizzle(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__pixel_blend a_blend,
|
||||
wuffs_base__slice_u8 a_workbuf);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -82135,6 +83007,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(
|
||||
@@ -83928,11 +84805,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) {
|
||||
@@ -83964,10 +84839,6 @@ wuffs_vp8__decoder__decode_macroblocks(
|
||||
} else {
|
||||
wuffs_vp8__decoder__filter_normal(self, a_workbuf, (self->private_impl.f_mbh - 1u));
|
||||
}
|
||||
v_status = wuffs_vp8__decoder__swizzle(self, a_dst, a_workbuf);
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
|
||||
}
|
||||
}
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
@@ -84232,10 +85103,34 @@ static wuffs_base__status
|
||||
wuffs_vp8__decoder__swizzle(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
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_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler,
|
||||
@@ -84245,35 +85140,35 @@ wuffs_vp8__decoder__swizzle(
|
||||
self->private_impl.f_width,
|
||||
0u,
|
||||
self->private_impl.f_height,
|
||||
wuffs_base__slice_u8__subslice_j(a_workbuf, self->private_impl.f_workbuf_yuv_y_end),
|
||||
wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
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(a_workbuf,
|
||||
wuffs_base__slice_u8__subslice_ij(v_suffix,
|
||||
self->private_impl.f_workbuf_yuv_u_end,
|
||||
self->private_impl.f_workbuf_yuv_v_end),
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
v_prefix,
|
||||
(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),
|
||||
(self->private_impl.f_mbh * 16u),
|
||||
(self->private_impl.f_mbh * 8u),
|
||||
(self->private_impl.f_mbh * 8u),
|
||||
0u,
|
||||
(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)),
|
||||
((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);
|
||||
@@ -85193,6 +86088,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;
|
||||
}
|
||||
@@ -85215,8 +86116,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);
|
||||
@@ -85319,17 +86253,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;
|
||||
@@ -85433,13 +86360,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(
|
||||
@@ -85472,6 +86400,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
|
||||
@@ -85657,37 +86601,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;
|
||||
@@ -85789,7 +86761,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)) {
|
||||
@@ -85990,10 +86962,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)
|
||||
@@ -86924,18 +87903,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";
|
||||
@@ -86987,6 +87968,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(
|
||||
@@ -87050,6 +88069,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
|
||||
@@ -87080,6 +88100,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
|
||||
@@ -87092,38 +88113,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,
|
||||
@@ -87171,6 +88166,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
|
||||
@@ -87287,6 +88325,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
|
||||
@@ -88471,6 +89878,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};
|
||||
@@ -88498,10 +89906,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);
|
||||
@@ -88531,7 +89939,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) {
|
||||
@@ -88563,7 +89971,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);
|
||||
@@ -88859,6 +90267,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;
|
||||
@@ -88875,7 +90284,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) {
|
||||
@@ -88885,7 +90294,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]);
|
||||
@@ -88956,7 +90365,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;
|
||||
@@ -89003,8 +90413,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;
|
||||
}
|
||||
@@ -89033,866 +90443,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,
|
||||
@@ -89924,30 +90479,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;
|
||||
@@ -89956,7 +90494,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;
|
||||
@@ -89976,7 +90514,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;
|
||||
@@ -89992,7 +90530,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;
|
||||
@@ -90004,7 +90542,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;
|
||||
@@ -90016,7 +90554,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;
|
||||
@@ -90025,10 +90563,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;
|
||||
}
|
||||
@@ -90058,13 +90593,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;
|
||||
@@ -90078,14 +90618,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);
|
||||
@@ -90102,14 +90643,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:
|
||||
@@ -90134,6 +90675,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;
|
||||
@@ -90178,9 +90720,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));
|
||||
@@ -90230,6 +90769,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;
|
||||
@@ -90243,7 +90786,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);
|
||||
@@ -90729,10 +91272,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)) {
|
||||
@@ -90760,6 +91306,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
|
||||
@@ -90774,7 +92622,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(
|
||||
@@ -90815,7 +92663,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) {
|
||||
@@ -90838,7 +92686,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) {
|
||||
@@ -90867,7 +92715,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);
|
||||
}
|
||||
@@ -90949,10 +92797,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)
|
||||
@@ -95414,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);
|
||||
@@ -95507,8 +97369,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());
|
||||
}
|
||||
@@ -95517,6 +97380,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()) {
|
||||
@@ -96457,7 +98323,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))) {
|
||||
|
||||
+26
-27
@@ -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
@@ -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))) {
|
||||
|
||||
+29
-12
@@ -60,18 +60,35 @@ func main1() error {
|
||||
}
|
||||
|
||||
} else if len(arg) == 12 {
|
||||
// Assume that arg is of the form "aaaa/bbbb/cc".
|
||||
arg0 := arg[0:4]
|
||||
arg1 := arg[5:9]
|
||||
arg2 := ".." + arg[10:12]
|
||||
c0, ok0 := base38.Encode(arg0)
|
||||
c1, ok1 := base38.Encode(arg1)
|
||||
c2, ok2 := base38.Encode(arg2)
|
||||
if ok0 && ok1 && ok2 {
|
||||
c := (uint64(c0) << 32) | (uint64(c1) << 11) | uint64(c2)
|
||||
code := fmt.Sprintf("0x%014X", c)
|
||||
fmt.Printf("%s\t%16d\t%s\n", underscore8(code), c, arg)
|
||||
continue
|
||||
if (arg[4] == '/') && (arg[7] == '/') {
|
||||
// Assume that arg is of the form "aaaa/bb/cccc".
|
||||
arg0 := arg[0:4]
|
||||
arg1 := ".." + arg[5:7]
|
||||
arg2 := arg[8:12]
|
||||
c0, ok0 := base38.Encode(arg0)
|
||||
c1, ok1 := base38.Encode(arg1)
|
||||
c2, ok2 := base38.Encode(arg2)
|
||||
if ok0 && ok1 && ok2 {
|
||||
c := (uint64(c0) << 32) | (uint64(c1) << 21) | uint64(c2)
|
||||
code := fmt.Sprintf("0x%014X", c)
|
||||
fmt.Printf("%s\t%16d\t%s\n", underscore8(code), c, arg)
|
||||
continue
|
||||
}
|
||||
|
||||
} else if (arg[4] == '/') && (arg[9] == '/') {
|
||||
// Assume that arg is of the form "aaaa/bbbb/cc".
|
||||
arg0 := arg[0:4]
|
||||
arg1 := arg[5:9]
|
||||
arg2 := ".." + arg[10:12]
|
||||
c0, ok0 := base38.Encode(arg0)
|
||||
c1, ok1 := base38.Encode(arg1)
|
||||
c2, ok2 := base38.Encode(arg2)
|
||||
if ok0 && ok1 && ok2 {
|
||||
c := (uint64(c0) << 32) | (uint64(c1) << 11) | uint64(c2)
|
||||
code := fmt.Sprintf("0x%014X", c)
|
||||
fmt.Printf("%s\t%16d\t%s\n", underscore8(code), c, arg)
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
} else if len(arg) == 14 {
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
// 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
|
||||
|
||||
// print-png-chunks.go prints a PNG's chunks' position and type.
|
||||
//
|
||||
// Usage: go run print-png-chunks.go foo.png
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"hash/crc32"
|
||||
"os"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := main1(); err != nil {
|
||||
os.Stderr.WriteString(err.Error() + "\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
flag.Parse()
|
||||
args := flag.Args()
|
||||
if len(args) != 1 {
|
||||
return fmt.Errorf("usage: progname filename.png")
|
||||
}
|
||||
src, err := os.ReadFile(args[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
pos := 0
|
||||
if len(src) < 8 {
|
||||
return posError(pos, len(src))
|
||||
} else if len(src) > 0x7FFF_FFFF {
|
||||
return fmt.Errorf("PNG file is too large")
|
||||
}
|
||||
|
||||
pos = 8
|
||||
for pos < len(src) {
|
||||
if pos > (len(src) - 8) {
|
||||
return posError(pos, len(src))
|
||||
}
|
||||
|
||||
pos0 := pos
|
||||
n := int64(u32be(src[pos : pos+4]))
|
||||
name := clean(src[pos+4 : pos+8])
|
||||
pos += 8
|
||||
|
||||
if int64(len(src)-pos) < n {
|
||||
return posError(pos, len(src))
|
||||
}
|
||||
checksumHave := crc32.ChecksumIEEE(src[pos-4 : pos+int(n)])
|
||||
pos += int(n)
|
||||
|
||||
if int64(len(src)-pos) < 4 {
|
||||
return posError(pos, len(src))
|
||||
}
|
||||
checksumWant := u32be(src[pos : pos+4])
|
||||
pos += 4
|
||||
|
||||
badChecksum := ""
|
||||
if checksumHave != checksumWant {
|
||||
badChecksum = " (bad crc32)"
|
||||
}
|
||||
fmt.Printf("pos: 0x%08X %10d +8, len: 0x%08X %10d +4, %s%s\n",
|
||||
pos0, pos0, n, n, name, badChecksum)
|
||||
}
|
||||
|
||||
fmt.Printf("pos: 0x%08X %10d ~~~~\n",
|
||||
pos, pos)
|
||||
return nil
|
||||
}
|
||||
|
||||
func posError(pos int, lenSrc int) error {
|
||||
return fmt.Errorf("bad PNG, pos: 0x%08X %10d, len(src): 0x%08X %10d",
|
||||
pos, pos, lenSrc, lenSrc)
|
||||
}
|
||||
|
||||
func clean(b []byte) string {
|
||||
a := [4]byte{}
|
||||
for i, c := range b[:4] {
|
||||
if (c < '!') || ('~' < c) {
|
||||
c = '.'
|
||||
}
|
||||
a[i] = c
|
||||
}
|
||||
return string(a[:4])
|
||||
}
|
||||
|
||||
func u32be(b []byte) uint32 {
|
||||
return (uint32(b[0]) << 24) |
|
||||
(uint32(b[1]) << 16) |
|
||||
(uint32(b[2]) << 8) |
|
||||
(uint32(b[3]) << 0)
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
// 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
|
||||
|
||||
// print-riff-chunks.go prints a RIFF's chunks' position and type.
|
||||
//
|
||||
// ANI, AVI, WAV and WEBP files are all RIFF files.
|
||||
//
|
||||
// Usage: go run print-riff-chunks.go foo.webp
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := main1(); err != nil {
|
||||
os.Stderr.WriteString(err.Error() + "\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
flag.Parse()
|
||||
args := flag.Args()
|
||||
if len(args) != 1 {
|
||||
return fmt.Errorf("usage: progname filename.riff")
|
||||
}
|
||||
src, err := os.ReadFile(args[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
pos := 0
|
||||
if len(src) < 12 {
|
||||
return posError(pos, len(src))
|
||||
} else if len(src) > 0x7FFF_FFFF {
|
||||
return fmt.Errorf("RIFF file is too large")
|
||||
}
|
||||
chunkLen := int64(u32le(src[pos+4 : pos+8]))
|
||||
if int64(len(src)-8) < chunkLen {
|
||||
return posError(0, len(src))
|
||||
}
|
||||
isWEBP = string(src[8:12]) == "WEBP"
|
||||
fmt.Printf("pos: 0x%08X %10d +8, len: 0x%08X %10d, dep: %d, %s\n",
|
||||
0, 0, chunkLen, chunkLen, 0, clean(src[8:12]))
|
||||
|
||||
pos, err = do(src, 1, 12)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
fmt.Printf("pos: 0x%08X %10d ~~~~\n",
|
||||
pos, pos)
|
||||
return nil
|
||||
}
|
||||
|
||||
func do(src []byte, depth int, pos int) (int, error) {
|
||||
for pos < len(src) {
|
||||
if pos > (len(src) - 8) {
|
||||
return 0, posError(pos, len(src))
|
||||
}
|
||||
|
||||
n := int64(u32le(src[pos+4 : pos+8]))
|
||||
isWEBPANMF := isWEBP && (depth == 1) && (string(src[pos:pos+4]) == "ANMF")
|
||||
fmt.Printf("pos: 0x%08X %10d +8, len: 0x%08X %10d, dep: %d, %s\n",
|
||||
pos, pos, n, n, depth, clean(src[pos:pos+4]))
|
||||
pos += 8
|
||||
if (n & 1) != 0 {
|
||||
n++
|
||||
}
|
||||
|
||||
if int64(len(src)-pos) < n {
|
||||
return 0, posError(pos, len(src))
|
||||
|
||||
} else if isWEBPANMF && (n > 16) {
|
||||
pos1, err := do(src[:int64(pos)+n], depth+1, pos+16)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
pos = pos1
|
||||
|
||||
} else {
|
||||
pos += int(n)
|
||||
}
|
||||
}
|
||||
return pos, nil
|
||||
}
|
||||
|
||||
var isWEBP bool
|
||||
|
||||
func posError(pos int, lenSrc int) error {
|
||||
return fmt.Errorf("bad RIFF, pos: 0x%08X %10d, len(src): 0x%08X %10d",
|
||||
pos, pos, lenSrc, lenSrc)
|
||||
}
|
||||
|
||||
func clean(b []byte) string {
|
||||
a := [4]byte{}
|
||||
for i, c := range b[:4] {
|
||||
if (c < '!') || ('~' < c) {
|
||||
c = '.'
|
||||
}
|
||||
a[i] = c
|
||||
}
|
||||
return string(a[:4])
|
||||
}
|
||||
|
||||
func u32le(b []byte) uint32 {
|
||||
return (uint32(b[0]) << 0) |
|
||||
(uint32(b[1]) << 8) |
|
||||
(uint32(b[2]) << 16) |
|
||||
(uint32(b[3]) << 24)
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
+403
-108
@@ -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.
|
||||
@@ -94,12 +100,34 @@ uncompng__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 pixel_format,
|
||||
uint32_t width,
|
||||
uint32_t height,
|
||||
size_t stride,
|
||||
uint32_t pixel_format);
|
||||
const uint8_t* pixel_ptr,
|
||||
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);
|
||||
|
||||
// --------
|
||||
|
||||
@@ -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,
|
||||
const uint8_t* pixel_ptr,
|
||||
size_t pixel_len,
|
||||
uint32_t width,
|
||||
uint32_t height,
|
||||
size_t stride,
|
||||
uint32_t pixel_format) {
|
||||
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
|
||||
@@ -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 {
|
||||
|
||||
@@ -8,10 +8,9 @@
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
pri func decoder.decode_macroblocks!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status {
|
||||
var mby : base.u32
|
||||
var mbx : base.u32
|
||||
var status : base.status
|
||||
pri func decoder.decode_macroblocks!(workbuf: slice base.u8) base.status {
|
||||
var mby : base.u32
|
||||
var mbx : base.u32
|
||||
|
||||
mbx = 0
|
||||
while mbx < this.mbw {
|
||||
@@ -55,7 +54,7 @@ pri func decoder.decode_macroblocks!(dst: ptr base.pixel_buffer, workbuf: slice
|
||||
mby += 1
|
||||
}
|
||||
|
||||
// Filter the final row, already in args.workbuf, and swizzle to args.dst.
|
||||
// Filter the final row, already in args.workbuf.
|
||||
if this.mbh > 0 {
|
||||
if this.filt_level <= 0 {
|
||||
// No-op.
|
||||
@@ -65,10 +64,6 @@ pri func decoder.decode_macroblocks!(dst: ptr base.pixel_buffer, workbuf: slice
|
||||
this.filter_normal!(workbuf: args.workbuf, mby: this.mbh - 1)
|
||||
}
|
||||
|
||||
status = this.swizzle!(dst: args.dst, workbuf: args.workbuf)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
}
|
||||
|
||||
return ok
|
||||
@@ -348,16 +343,43 @@ pri func decoder.copy_from_yuv_cache!(
|
||||
|
||||
pri func decoder.swizzle!(
|
||||
dst: ptr base.pixel_buffer,
|
||||
blend: base.pixel_blend,
|
||||
workbuf: slice base.u8) base.status {
|
||||
var status : base.status
|
||||
var wh : base.u64[..= 0xFFF_8001]
|
||||
var prefix : slice base.u8
|
||||
var suffix : slice base.u8
|
||||
var has_alpha : base.u32[..= 1]
|
||||
var ycc_model : base.u32[..= 0xFF]
|
||||
var status : base.status
|
||||
|
||||
if this.quirk_has_alpha_side_channel {
|
||||
if this.quirk_width_and_height == 0 {
|
||||
return "#inconsistent width and height"
|
||||
}
|
||||
wh = (this.width * this.height) as base.u64
|
||||
if wh > args.workbuf.length() {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
prefix = args.workbuf[.. wh]
|
||||
suffix = args.workbuf[wh ..]
|
||||
has_alpha = 1
|
||||
ycc_model = base.YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC |
|
||||
(0x01 & (this.util.demake_pixel_blend(a: args.blend) as base.u32))
|
||||
|
||||
} else {
|
||||
prefix = this.util.empty_slice_u8()
|
||||
suffix = args.workbuf
|
||||
has_alpha = 0
|
||||
ycc_model = base.YCC_MODEL__BT_601_STUDIO_RANGE
|
||||
}
|
||||
|
||||
if (this.workbuf_yuv_y_end > this.workbuf_yuv_u_end) or
|
||||
(this.workbuf_yuv_u_end > this.workbuf_yuv_v_end) or
|
||||
(this.workbuf_yuv_v_end > args.workbuf.length()) {
|
||||
(this.workbuf_yuv_v_end > suffix.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
assert this.workbuf_yuv_u_end <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_v_end)
|
||||
assert this.workbuf_yuv_y_end <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_u_end)
|
||||
assert this.workbuf_yuv_u_end <= suffix.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_v_end)
|
||||
assert this.workbuf_yuv_y_end <= suffix.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_u_end)
|
||||
|
||||
status = this.swizzler.swizzle_ycck!(
|
||||
dst: args.dst,
|
||||
@@ -366,31 +388,31 @@ pri func decoder.swizzle!(
|
||||
x_max_excl: this.width,
|
||||
y_min_incl: 0,
|
||||
y_max_excl: this.height,
|
||||
src0: args.workbuf[.. this.workbuf_yuv_y_end],
|
||||
src1: args.workbuf[this.workbuf_yuv_y_end .. this.workbuf_yuv_u_end],
|
||||
src2: args.workbuf[this.workbuf_yuv_u_end .. this.workbuf_yuv_v_end],
|
||||
src3: this.util.empty_slice_u8(),
|
||||
src0: suffix[.. this.workbuf_yuv_y_end],
|
||||
src1: suffix[this.workbuf_yuv_y_end .. this.workbuf_yuv_u_end],
|
||||
src2: suffix[this.workbuf_yuv_u_end .. this.workbuf_yuv_v_end],
|
||||
src3: prefix,
|
||||
width0: this.mbw * 16,
|
||||
width1: this.mbw * 8,
|
||||
width2: this.mbw * 8,
|
||||
width3: 0,
|
||||
width3: this.width * has_alpha,
|
||||
height0: this.mbh * 16,
|
||||
height1: this.mbh * 8,
|
||||
height2: this.mbh * 8,
|
||||
height3: 0,
|
||||
height3: this.height * has_alpha,
|
||||
stride0: this.mbw * 16,
|
||||
stride1: this.mbw * 8,
|
||||
stride2: this.mbw * 8,
|
||||
stride3: 0,
|
||||
stride3: this.width * has_alpha,
|
||||
h0: 2,
|
||||
h1: 1,
|
||||
h2: 1,
|
||||
h3: 0,
|
||||
h3: (2 * has_alpha) as base.u8,
|
||||
v0: 2,
|
||||
v1: 1,
|
||||
v2: 1,
|
||||
v3: 0,
|
||||
ycc_model: base.YCC_MODEL__BT_601_STUDIO_RANGE as base.u8,
|
||||
v3: (2 * has_alpha) as base.u8,
|
||||
ycc_model: ycc_model as base.u8,
|
||||
ycc_upsampling: base.YCC_UPSAMPLING__FANCY_LIKE_LIBWEBP as base.u8,
|
||||
scratch_buffer_2k: this.swizzle_ycck_scratch_buffer_2k[..])
|
||||
return status
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
// 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
|
||||
|
||||
// --------
|
||||
|
||||
// Quirks are discussed in (/doc/note/quirks.md).
|
||||
//
|
||||
// The base38 encoding of "vp8." is 0x1B_5EFE. Left shifting by 10 gives
|
||||
// 0x6D7B_F800.
|
||||
pri const QUIRKS_BASE : base.u32 = 0x6D7B_F800
|
||||
|
||||
// --------
|
||||
|
||||
// When this quirk is enabled, the workbuf starts with (width × height) alpha
|
||||
// samples, decoded out-of-band (from the VP8 decoder's perspective, they are
|
||||
// typically decoded in-band from the surrounding WebP decoder's perspective).
|
||||
pub const QUIRK_HAS_ALPHA_SIDE_CHANNEL : base.u32 = 0x6D7B_F800 | 0x00
|
||||
|
||||
// Gives the image width and height out-of-band, in the u64 quirk value. The
|
||||
// low 32 bits are the width and the high 32 bits are the height. Both
|
||||
// dimensions should range within 0x0001 ..= 0x3FFF.
|
||||
//
|
||||
// A simple WebP file could contain one chunk, a VP8 chunk, that gives the
|
||||
// image width and height. A complex WebP file could contain three chunks:
|
||||
// VP8X, ALPH and VP8. The image dimensions are given in the VP8X chunk and are
|
||||
// then repeated in the VP8 chunk.
|
||||
//
|
||||
// After a webp.decoder decode_image_config call, the caller might next want to
|
||||
// query the workbuf length, to know how much memory to dynamically allocate,
|
||||
// especially before attempting to decode the ALPH chunk. The outer
|
||||
// webp.decoder workbuf_len method can delegate to the inner vp8.decoder
|
||||
// workbuf_len method, but the latter needs to know the image dimensions.
|
||||
//
|
||||
// This quirk mechanism lets the outer webp decoder tell the inner vp8 decoder
|
||||
// those dimensions, after parsing the VP8X chunk but before ALPH or VP8.
|
||||
pub const QUIRK_WIDTH_AND_HEIGHT : base.u32 = 0x6D7B_F800 | 0x01
|
||||
+124
-31
@@ -9,13 +9,15 @@
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
pub status "#bad QUIRK_SOURCE_LENGTH"
|
||||
pub status "#bad QUIRK_WIDTH_AND_HEIGHT"
|
||||
pub status "#bad header"
|
||||
pub status "#inconsistent width and height"
|
||||
pub status "#missing QUIRK_SOURCE_LENGTH"
|
||||
pub status "#truncated input"
|
||||
pub status "#unsupported QUIRK_SOURCE_LENGTH"
|
||||
pub status "#unsupported VP8 file"
|
||||
|
||||
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0x20FF_FFFF
|
||||
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0x30FF_8000
|
||||
|
||||
pub struct decoder? implements base.image_decoder(
|
||||
width : base.u32[..= 0x3FFF],
|
||||
@@ -31,17 +33,24 @@ pub struct decoder? implements base.image_decoder(
|
||||
|
||||
is_key_frame : base.bool,
|
||||
|
||||
quirk_has_alpha_side_channel : base.bool,
|
||||
|
||||
frame_config_io_position : base.u64,
|
||||
|
||||
// This uses the same representation as an wuffs_base__optional_u63:
|
||||
// ((value_as_u63 << 1) | has_value_as_u1).
|
||||
quirk_source_length : base.u64,
|
||||
|
||||
quirk_width_and_height : base.u64,
|
||||
|
||||
// Just under 144 MiB, for 9 partitions each up to 0xFF_FFFF bytes.
|
||||
partitioned_data_length : base.u32[..= 0x08FF_FFF7],
|
||||
|
||||
// args.workbuf strides and offsets.
|
||||
//
|
||||
// The foobar_end offsets are measured after any "prefix trimmed work
|
||||
// buffer" adjustment (if QUIRK_HAS_ALPHA_SIDE_CHANNEL is enabled).
|
||||
//
|
||||
// The workbuf holds the YUV buffers (after decoding from the source
|
||||
// bytes but before converting YUV to RGBX) and then also a copy of
|
||||
// most of the source bytes themselves - the "at least 2, up to 9"
|
||||
@@ -205,15 +214,54 @@ pub struct decoder? implements base.image_decoder(
|
||||
pub func decoder.get_quirk(key: base.u32) base.u64 {
|
||||
if args.key == base.QUIRK_SOURCE_LENGTH {
|
||||
return this.quirk_source_length
|
||||
} else if args.key == QUIRK_HAS_ALPHA_SIDE_CHANNEL {
|
||||
if this.quirk_has_alpha_side_channel {
|
||||
return 1
|
||||
}
|
||||
} else if args.key == QUIRK_WIDTH_AND_HEIGHT {
|
||||
return this.quirk_width_and_height
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
|
||||
var w : base.u32
|
||||
var h : base.u32
|
||||
|
||||
if args.key == base.QUIRK_SOURCE_LENGTH {
|
||||
this.quirk_source_length = args.value
|
||||
if (args.value & 1) == 0 {
|
||||
if args.value <> 0 {
|
||||
return "#bad QUIRK_SOURCE_LENGTH"
|
||||
}
|
||||
this.quirk_source_length = 0
|
||||
this.partitioned_data_length = 0
|
||||
} else if (args.value >> 1) < 10 {
|
||||
return "#bad QUIRK_SOURCE_LENGTH"
|
||||
} else if (args.value >> 1) > (0x08FF_FFF7 + 10) {
|
||||
return "#unsupported QUIRK_SOURCE_LENGTH"
|
||||
} else {
|
||||
this.quirk_source_length = args.value
|
||||
this.partitioned_data_length = ((args.value >> 1) as base.u32) - 10
|
||||
}
|
||||
return ok
|
||||
|
||||
} else if args.key == QUIRK_HAS_ALPHA_SIDE_CHANNEL {
|
||||
this.quirk_has_alpha_side_channel = args.value <> 0
|
||||
return ok
|
||||
|
||||
} else if args.key == QUIRK_WIDTH_AND_HEIGHT {
|
||||
w = (args.value & 0xFFFF_FFFF) as base.u32
|
||||
h = (args.value >> 32) as base.u32
|
||||
if (w < 1) or (0x3FFF < w) or (h < 1) or (0x3FFF < h) {
|
||||
return "#bad QUIRK_WIDTH_AND_HEIGHT"
|
||||
}
|
||||
this.quirk_width_and_height = args.value
|
||||
this.width = w
|
||||
this.height = h
|
||||
this.calculate_mbw_mbh!()
|
||||
return ok
|
||||
}
|
||||
|
||||
return base."#unsupported option"
|
||||
}
|
||||
|
||||
@@ -236,14 +284,9 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
return base."#bad call sequence"
|
||||
}
|
||||
|
||||
if (this.quirk_source_length & 1) == 0 {
|
||||
if this.quirk_source_length == 0 {
|
||||
return "#missing QUIRK_SOURCE_LENGTH"
|
||||
} else if (this.quirk_source_length >> 1) < 10 {
|
||||
return "#bad QUIRK_SOURCE_LENGTH"
|
||||
} else if (this.quirk_source_length >> 1) > (0x08FF_FFF7 + 10) {
|
||||
return "#unsupported QUIRK_SOURCE_LENGTH"
|
||||
}
|
||||
this.partitioned_data_length = ((this.quirk_source_length >> 1) as base.u32) - 10
|
||||
|
||||
// RFC 6386 Section 9. Frame Header, up to and including 9.1. Uncompressed
|
||||
// Data Chunk. decode_header_partition handles the rest of section 9.
|
||||
@@ -267,17 +310,13 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
c32 = args.src.read_u32le?()
|
||||
this.width = 0x3FFF & (c32 >> 0)
|
||||
this.height = 0x3FFF & (c32 >> 16)
|
||||
this.mbw = (this.width + 15) / 16
|
||||
this.mbh = (this.height + 15) / 16
|
||||
|
||||
this.workbuf_yuv_y_stride = this.mbw * 16
|
||||
this.workbuf_yuv_uv_stride = this.mbw * 8
|
||||
this.workbuf_yuv_y_end =
|
||||
((this.workbuf_yuv_y_stride as base.u64) * ((this.mbh * 16) as base.u64))
|
||||
this.workbuf_yuv_u_end = this.workbuf_yuv_y_end +
|
||||
((this.workbuf_yuv_uv_stride as base.u64) * ((this.mbh * 8) as base.u64))
|
||||
this.workbuf_yuv_v_end = this.workbuf_yuv_u_end +
|
||||
((this.workbuf_yuv_uv_stride as base.u64) * ((this.mbh * 8) as base.u64))
|
||||
if (this.width == 0) or (this.height == 0) {
|
||||
return "#bad header"
|
||||
} else if (this.quirk_width_and_height <> 0) and
|
||||
(this.quirk_width_and_height <> ((this.width as base.u64) | ((this.height as base.u64) << 32))) {
|
||||
return "#inconsistent width and height"
|
||||
}
|
||||
this.calculate_mbw_mbh!()
|
||||
|
||||
this.frame_config_io_position = args.src.position()
|
||||
|
||||
@@ -294,6 +333,20 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
this.call_sequence = 0x20
|
||||
}
|
||||
|
||||
pri func decoder.calculate_mbw_mbh!() {
|
||||
this.mbw = (this.width + 15) / 16
|
||||
this.mbh = (this.height + 15) / 16
|
||||
|
||||
this.workbuf_yuv_y_stride = this.mbw * 16
|
||||
this.workbuf_yuv_uv_stride = this.mbw * 8
|
||||
this.workbuf_yuv_y_end =
|
||||
((this.workbuf_yuv_y_stride as base.u64) * ((this.mbh * 16) as base.u64))
|
||||
this.workbuf_yuv_u_end = this.workbuf_yuv_y_end +
|
||||
((this.workbuf_yuv_uv_stride as base.u64) * ((this.mbh * 8) as base.u64))
|
||||
this.workbuf_yuv_v_end = this.workbuf_yuv_u_end +
|
||||
((this.workbuf_yuv_uv_stride as base.u64) * ((this.mbh * 8) as base.u64))
|
||||
}
|
||||
|
||||
pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
|
||||
var status : base.status
|
||||
|
||||
@@ -341,23 +394,52 @@ pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.
|
||||
}
|
||||
|
||||
pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
|
||||
var wh : base.u64[..= 0xFFF_8001]
|
||||
var wb_len : base.u64[..= DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE]
|
||||
var status : base.status
|
||||
|
||||
// The args.workbuf, with a "prefix trimmed work buffer" adjustment, if
|
||||
// QUIRK_HAS_ALPHA_SIDE_CHANNEL is enabled, in which case the first (width
|
||||
// × height) bytes of args.workbuf hold alpha samples that are e.g. part of
|
||||
// WebP, not part of VP8 per se.
|
||||
//
|
||||
// The prefix isn't used when decoding VP8 to YCbCr, but the final swizzle
|
||||
// to the destination pixel buffer should combine YCbCr and Alpha.
|
||||
var trimmed : slice base.u8
|
||||
|
||||
while true {
|
||||
wb_len = this.workbuf_yuv_v_end + (this.partitioned_data_length as base.u64) + 8
|
||||
if wb_len > args.workbuf.length() {
|
||||
return base."#bad workbuf length"
|
||||
} else {
|
||||
args.workbuf = args.workbuf[.. wb_len]
|
||||
trimmed = args.workbuf
|
||||
if this.quirk_has_alpha_side_channel {
|
||||
if this.quirk_width_and_height == 0 {
|
||||
return "#inconsistent width and height"
|
||||
}
|
||||
wh = (this.width * this.height) as base.u64
|
||||
if wh > args.workbuf.length() {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
trimmed = args.workbuf[wh ..]
|
||||
}
|
||||
|
||||
status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
|
||||
if (status == base."$short read") and args.src.is_closed() {
|
||||
wb_len = this.workbuf_yuv_v_end + (this.partitioned_data_length as base.u64) + 8
|
||||
if wb_len > trimmed.length() {
|
||||
return base."#bad workbuf length"
|
||||
} else {
|
||||
trimmed = trimmed[.. wb_len]
|
||||
}
|
||||
|
||||
status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: trimmed, opts: args.opts)
|
||||
if status.is_ok() {
|
||||
break
|
||||
} else if (status == base."$short read") and args.src.is_closed() {
|
||||
return "#truncated input"
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
|
||||
status = this.swizzle!(dst: args.dst, blend: args.blend, workbuf: args.workbuf)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
|
||||
@@ -404,7 +486,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
return status
|
||||
}
|
||||
|
||||
status = this.decode_macroblocks!(dst: args.dst, workbuf: args.workbuf)
|
||||
status = this.decode_macroblocks!(workbuf: args.workbuf)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
@@ -450,7 +532,7 @@ 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) {
|
||||
// No-op. VP8 doesn't support metadata (but WEBP does).
|
||||
// No-op. VP8 doesn't support metadata (but WebP does).
|
||||
}
|
||||
|
||||
pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
|
||||
@@ -458,10 +540,21 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
}
|
||||
|
||||
pub func decoder.workbuf_len() base.range_ii_u64 {
|
||||
var wb_len : base.u64[..= DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE]
|
||||
var wh : base.u64[..= 0xFFF_8001]
|
||||
var wb_len : base.u64[..= DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE - 0xFFF_8001]
|
||||
|
||||
if this.quirk_source_length == 0 {
|
||||
// (min_incl > max_incl) means an empty range_ii_u64. The workbuf
|
||||
// length isn't known yet, as we don't know partitioned_data_length.
|
||||
return this.util.make_range_ii_u64(min_incl: 1, max_incl: 0)
|
||||
}
|
||||
|
||||
if this.quirk_has_alpha_side_channel {
|
||||
wh = (this.width * this.height) as base.u64
|
||||
}
|
||||
|
||||
wb_len = this.workbuf_yuv_v_end + (this.partitioned_data_length as base.u64) + 8
|
||||
return this.util.make_range_ii_u64(
|
||||
min_incl: wb_len,
|
||||
max_incl: wb_len)
|
||||
min_incl: wh + wb_len,
|
||||
max_incl: wh + wb_len)
|
||||
}
|
||||
@@ -2,6 +2,8 @@
|
||||
|
||||
WebP is a still image format, described in the [WebP Container
|
||||
Specification](https://developers.google.com/speed/webp/docs/riff_container).
|
||||
It is a container for [VP8 Lossy](https://www.ietf.org/rfc/rfc6386.txt) or [VP8
|
||||
Lossless](https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification).
|
||||
|
||||
The ["Making Software - Image
|
||||
Compression"](https://www.makingsoftware.com/chapters/image-compression) book
|
||||
|
||||
@@ -0,0 +1,242 @@
|
||||
// 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
|
||||
|
||||
pri func decoder.decode_alph?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
var r_mark : base.u64
|
||||
var status : base.status
|
||||
|
||||
while true {
|
||||
io_limit (io: args.src, limit: this.sub_chunk_length as base.u64) {
|
||||
r_mark = args.src.mark()
|
||||
status =? this.decode_alph_limited?(src: args.src, workbuf: args.workbuf)
|
||||
this.sub_chunk_length ~sat-=
|
||||
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
}
|
||||
|
||||
if status.is_ok() {
|
||||
break
|
||||
} else if not status.is_suspension() {
|
||||
return status
|
||||
} else if (status == base."$short read") and (this.sub_chunk_length == 0) {
|
||||
return "#short chunk"
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_alph_limited?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
var n : base.u64
|
||||
|
||||
this.vp8x_alph_flags = args.src.read_u8?()
|
||||
|
||||
if (this.vp8x_alph_flags & 3) == 0 {
|
||||
args.src.limited_copy_u32_to_slice!(up_to: this.width * this.height, s: args.workbuf)
|
||||
} else if (this.vp8x_alph_flags & 3) == 1 {
|
||||
this.do_decode_frame_vp8l?(
|
||||
dst: nullptr,
|
||||
src: args.src,
|
||||
blend: this.util.make_pixel_blend(repr: base.PIXEL_BLEND__SRC),
|
||||
workbuf: args.workbuf,
|
||||
opts: nullptr)
|
||||
|
||||
n = (this.width * this.height * 4) as base.u64
|
||||
if n <= args.workbuf.length() {
|
||||
this.compact_alph!(s: args.workbuf[.. n])
|
||||
}
|
||||
} else {
|
||||
return "#bad VP8X chunk"
|
||||
}
|
||||
this.vp8x_alph_flags |= 2
|
||||
|
||||
n = (this.width * this.height) as base.u64
|
||||
if n <= args.workbuf.length() {
|
||||
if (this.vp8x_alph_flags & 0x0C) == 0x04 {
|
||||
this.filter_alph_horizontal!(s: args.workbuf[.. n])
|
||||
} else if (this.vp8x_alph_flags & 0x0C) == 0x08 {
|
||||
this.filter_alph_vertical!(s: args.workbuf[.. n])
|
||||
} else if (this.vp8x_alph_flags & 0x0C) == 0x0C {
|
||||
this.filter_alph_gradient!(s: args.workbuf[.. n])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.compact_alph!(s: slice base.u8) {
|
||||
var i : base.u64[..= 0x4000_0004]
|
||||
var j : base.u64[..= 0x4000_0004]
|
||||
|
||||
if args.s.length() > 0x4000_0000 {
|
||||
return nothing
|
||||
}
|
||||
|
||||
i = 0
|
||||
j = 1
|
||||
while (i < args.s.length()) and (j < args.s.length()),
|
||||
inv args.s.length() <= 0x4000_0000,
|
||||
{
|
||||
assert i <= 0x4000_0000 via "a <= b: a <= c; c <= b"(c: args.s.length())
|
||||
assert j <= 0x4000_0000 via "a <= b: a <= c; c <= b"(c: args.s.length())
|
||||
args.s[i] = args.s[j]
|
||||
i += 1
|
||||
j += 4
|
||||
}
|
||||
}
|
||||
|
||||
// libwebp calls this HorizontalUnfilter_C.
|
||||
pri func decoder.filter_alph_horizontal!(s: slice base.u8) {
|
||||
var y : base.u32
|
||||
var x : base.u32
|
||||
var i : base.u64
|
||||
var pred : base.u8
|
||||
|
||||
y = 0
|
||||
while y < this.height {
|
||||
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
|
||||
|
||||
pred = 0
|
||||
if y > 0 {
|
||||
i = ((y - 1) * this.width) as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
pred = args.s[i]
|
||||
}
|
||||
|
||||
x = 0
|
||||
while x < this.width,
|
||||
inv y < 0x4000,
|
||||
{
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
|
||||
|
||||
i = ((y * this.width) + x) as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
args.s[i] ~mod+= pred
|
||||
pred = args.s[i]
|
||||
|
||||
x += 1
|
||||
}
|
||||
y += 1
|
||||
}
|
||||
}
|
||||
|
||||
// libwebp calls this VerticalUnfilter_C.
|
||||
pri func decoder.filter_alph_vertical!(s: slice base.u8) {
|
||||
var y : base.u32
|
||||
var x : base.u32
|
||||
var i : base.u64
|
||||
var pred : base.u8
|
||||
|
||||
x = 0
|
||||
while x < this.width {
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
|
||||
|
||||
pred = 0
|
||||
if x > 0 {
|
||||
i = (x - 1) as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
pred = args.s[i]
|
||||
}
|
||||
|
||||
y = 0
|
||||
while y < this.height,
|
||||
inv x < 0x4000,
|
||||
{
|
||||
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
|
||||
|
||||
i = ((y * this.width) + x) as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
args.s[i] ~mod+= pred
|
||||
pred = args.s[i]
|
||||
|
||||
y += 1
|
||||
}
|
||||
x += 1
|
||||
}
|
||||
}
|
||||
|
||||
// libwebp calls this GradientUnfilter_C.
|
||||
pri func decoder.filter_alph_gradient!(s: slice base.u8) {
|
||||
var y : base.u32
|
||||
var x : base.u32
|
||||
var i : base.u64
|
||||
var pred : base.u8
|
||||
var grad : base.u32
|
||||
var l : base.u8 // Left sample.
|
||||
var t : base.u8 // Top sample.
|
||||
var tl : base.u8 // Top-Left sample.
|
||||
|
||||
// First row.
|
||||
x = 0
|
||||
while x < this.width {
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
|
||||
|
||||
i = x as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
args.s[i] ~mod+= pred
|
||||
pred = args.s[i]
|
||||
|
||||
x += 1
|
||||
}
|
||||
|
||||
// Other rows.
|
||||
y = 1
|
||||
while y < this.height,
|
||||
inv y >= 1,
|
||||
{
|
||||
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
|
||||
|
||||
i = (((y - 1) * this.width) + 0) as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
t = args.s[i]
|
||||
tl = t
|
||||
l = t
|
||||
|
||||
x = 0
|
||||
while x < this.width,
|
||||
inv y >= 1,
|
||||
inv y < 0x4000,
|
||||
{
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
|
||||
|
||||
i = (((y - 1) * this.width) + x) as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
t = args.s[i]
|
||||
|
||||
i = ((y * this.width) + x) as base.u64
|
||||
if i >= args.s.length() {
|
||||
break
|
||||
}
|
||||
grad = ((l as base.u32) ~mod+ (t as base.u32)) ~mod- (tl as base.u32)
|
||||
if grad > 0x7FFF_FFFF {
|
||||
grad = 0x00
|
||||
} else if grad > 0xFF {
|
||||
grad = 0xFF
|
||||
}
|
||||
l = args.s[i] ~mod+ ((grad & 0xFF) as base.u8)
|
||||
args.s[i] = l
|
||||
tl = t
|
||||
|
||||
x += 1
|
||||
}
|
||||
|
||||
y += 1
|
||||
}
|
||||
}
|
||||
@@ -8,7 +8,7 @@
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
pri func decoder.apply_transform_predictor!(pix: slice base.u8, tile_data: roslice base.u8) {
|
||||
pri func decoder.apply_transform_predictor!(pix: slice base.u8, width: base.u32[..= 0x4000], tile_data: roslice base.u8) {
|
||||
var w4 : base.u64[..= 0x1_0000]
|
||||
var prev_row : roslice base.u8
|
||||
var curr_row : slice base.u8
|
||||
@@ -37,11 +37,11 @@ pri func decoder.apply_transform_predictor!(pix: slice base.u8, tile_data: rosli
|
||||
var sum_l : base.u32
|
||||
var sum_t : base.u32
|
||||
|
||||
if (this.width <= 0) or (this.height <= 0) {
|
||||
if (args.width <= 0) or (this.height <= 0) {
|
||||
return nothing
|
||||
}
|
||||
|
||||
w4 = (this.width * 4) as base.u64
|
||||
w4 = (args.width * 4) as base.u64
|
||||
curr_row = this.util.empty_slice_u8()
|
||||
if w4 <= args.pix.length() {
|
||||
curr_row = args.pix[.. w4]
|
||||
@@ -62,7 +62,7 @@ pri func decoder.apply_transform_predictor!(pix: slice base.u8, tile_data: rosli
|
||||
}
|
||||
|
||||
tile_size_log2 = this.transform_tile_size_log2[0] as base.u32
|
||||
tiles_per_row = (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
|
||||
tiles_per_row = (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
|
||||
mask = ((1 as base.u32) << tile_size_log2) - 1
|
||||
|
||||
y = 1
|
||||
@@ -94,10 +94,10 @@ pri func decoder.apply_transform_predictor!(pix: slice base.u8, tile_data: rosli
|
||||
}
|
||||
|
||||
x = 1
|
||||
while x < this.width,
|
||||
while x < args.width,
|
||||
inv y < 0x4000,
|
||||
{
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: args.width)
|
||||
|
||||
if ((x & mask) == 0) and (tile_data.length() >= 4) {
|
||||
mode = tile_data[1] & 0x0F
|
||||
@@ -283,7 +283,7 @@ pri func decoder.mode13(l: base.u8, t: base.u8, tl: base.u8) base.u8 {
|
||||
return 0
|
||||
}
|
||||
|
||||
pri func decoder.apply_transform_cross_color!(pix: slice base.u8, tile_data: roslice base.u8) {
|
||||
pri func decoder.apply_transform_cross_color!(pix: slice base.u8, width: base.u32[..= 0x4000], tile_data: roslice base.u8) {
|
||||
var tile_size_log2 : base.u32[..= 9]
|
||||
var tiles_per_row : base.u32[..= 16895]
|
||||
var mask : base.u32
|
||||
@@ -301,7 +301,7 @@ pri func decoder.apply_transform_cross_color!(pix: slice base.u8, tile_data: ros
|
||||
var r : base.u8
|
||||
|
||||
tile_size_log2 = this.transform_tile_size_log2[1] as base.u32
|
||||
tiles_per_row = (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
|
||||
tiles_per_row = (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
|
||||
mask = ((1 as base.u32) << tile_size_log2) - 1
|
||||
|
||||
y = 0
|
||||
@@ -315,10 +315,10 @@ pri func decoder.apply_transform_cross_color!(pix: slice base.u8, tile_data: ros
|
||||
}
|
||||
|
||||
x = 0
|
||||
while x < this.width,
|
||||
while x < args.width,
|
||||
inv y < 0x4000,
|
||||
{
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
|
||||
assert x < 0x4000 via "a < b: a < c; c <= b"(c: args.width)
|
||||
|
||||
if ((x & mask) == 0) and (tile_data.length() >= 4) {
|
||||
g2r = this.util.sign_extend_convert_u8_u32(a: tile_data[0])
|
||||
@@ -357,7 +357,7 @@ pri func decoder.apply_transform_subtract_green!(pix: slice base.u8) {
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.apply_transform_color_indexing!(pix: slice base.u8) {
|
||||
pri func decoder.apply_transform_color_indexing!(pix: slice base.u8, width: base.u32[..= 0x4000]) {
|
||||
var tile_size_log2 : base.u32[..= 9]
|
||||
var bits_per_pixel : base.u32[..= 8]
|
||||
var x_mask : base.u32
|
||||
@@ -404,8 +404,8 @@ pri func decoder.apply_transform_color_indexing!(pix: slice base.u8) {
|
||||
while y < this.height {
|
||||
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
|
||||
|
||||
di = (4 * (y + 0) * this.width) as base.u64
|
||||
dj = (4 * (y + 1) * this.width) as base.u64
|
||||
di = (4 * (y + 0) * args.width) as base.u64
|
||||
dj = (4 * (y + 1) * args.width) as base.u64
|
||||
if (di > dj) or (dj > args.pix.length()) {
|
||||
break
|
||||
}
|
||||
|
||||
@@ -0,0 +1,484 @@
|
||||
// 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
|
||||
|
||||
pri func decoder.do_decode_frame_vp8l?(dst: nptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
|
||||
var c8 : base.u8
|
||||
var has_more : base.u32[..= 1]
|
||||
var width : base.u32[..= 0x4000]
|
||||
var dst : slice base.u8
|
||||
var tile_data : roslice base.u8
|
||||
var status : base.status
|
||||
var pix : slice base.u8
|
||||
var which : base.u32[..= 4]
|
||||
var transform_type : base.u32[..= 3]
|
||||
var ti : base.u64
|
||||
var tj : base.u64
|
||||
|
||||
this.seen_transform[0] = false
|
||||
this.seen_transform[1] = false
|
||||
this.seen_transform[2] = false
|
||||
this.seen_transform[3] = false
|
||||
this.n_transforms = 0
|
||||
|
||||
while true {
|
||||
if this.n_bits < 1 {
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32)
|
||||
this.n_bits = 8
|
||||
assert this.n_bits >= 1
|
||||
}
|
||||
has_more = this.bits & 1
|
||||
this.bits >>= 1
|
||||
this.n_bits -= 1
|
||||
|
||||
if has_more == 0 {
|
||||
break
|
||||
}
|
||||
this.decode_transform?(src: args.src, workbuf: args.workbuf)
|
||||
}
|
||||
|
||||
width = this.width
|
||||
if this.seen_transform[3] {
|
||||
width = this.color_indexing_width
|
||||
}
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.overall_color_cache_bits = this.color_cache_bits
|
||||
this.decode_hg_table?(src: args.src, width: width, workbuf: args.workbuf)
|
||||
this.color_cache_bits = this.overall_color_cache_bits
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: this.overall_n_huffman_groups)
|
||||
|
||||
while true {
|
||||
if ((this.workbuf_offset_for_color_indexing as base.u64) > (this.workbuf_offset_for_transform[0] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
assert (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_offset_for_transform[1] as base.u64)
|
||||
|
||||
dst = args.workbuf[
|
||||
(this.workbuf_offset_for_color_indexing as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[0] as base.u64)]
|
||||
tile_data = args.workbuf[
|
||||
(this.workbuf_offset_for_transform[0] as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[1] as base.u64)]
|
||||
status =? this.decode_pixels?(
|
||||
dst: dst,
|
||||
src: args.src,
|
||||
width: width,
|
||||
height: this.height,
|
||||
tile_data: tile_data,
|
||||
tile_size_log2: this.overall_tile_size_log2)
|
||||
if status.is_ok() {
|
||||
break
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
|
||||
if (this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length() {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)]
|
||||
width = this.width
|
||||
if this.seen_transform[3] and
|
||||
((this.workbuf_offset_for_color_indexing as base.u64) <= pix.length()) {
|
||||
pix = pix[this.workbuf_offset_for_color_indexing as base.u64 ..]
|
||||
width = this.color_indexing_width
|
||||
}
|
||||
|
||||
which = this.n_transforms
|
||||
while which > 0 {
|
||||
which -= 1
|
||||
transform_type = this.transform_type[which] as base.u32
|
||||
|
||||
tile_data = this.util.empty_slice_u8()
|
||||
if transform_type < 2 {
|
||||
ti = this.workbuf_offset_for_transform[transform_type + 1] as base.u64
|
||||
tj = this.workbuf_offset_for_transform[transform_type + 2] as base.u64
|
||||
if (ti <= tj) and (tj <= args.workbuf.length()) {
|
||||
tile_data = args.workbuf[ti .. tj]
|
||||
}
|
||||
}
|
||||
|
||||
if transform_type == 0 {
|
||||
this.apply_transform_predictor!(pix: pix, width: width, tile_data: tile_data)
|
||||
} else if transform_type == 1 {
|
||||
this.apply_transform_cross_color!(pix: pix, width: width, tile_data: tile_data)
|
||||
} else if transform_type == 2 {
|
||||
this.apply_transform_subtract_green!(pix: pix)
|
||||
} else if (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() {
|
||||
pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)]
|
||||
width = this.width
|
||||
this.apply_transform_color_indexing!(pix: pix, width: width)
|
||||
}
|
||||
}
|
||||
|
||||
status = this.swizzle!(
|
||||
dst: args.dst,
|
||||
src: pix,
|
||||
blend: args.blend)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
|
||||
this.call_sequence = 0x60
|
||||
}
|
||||
|
||||
pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
var status : base.status
|
||||
var c8 : base.u8
|
||||
var transform_type : base.u32[..= 3]
|
||||
var tile_size_log2 : base.u32[..= 9]
|
||||
var width : base.u32[..= 0x4000]
|
||||
var p : slice base.u8
|
||||
|
||||
if this.n_bits < 2 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 2 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 2
|
||||
}
|
||||
transform_type = this.bits & 3
|
||||
this.bits >>= 2
|
||||
this.n_bits -= 2
|
||||
|
||||
if this.seen_transform[transform_type] or (this.n_transforms >= 4) {
|
||||
return "#bad transform"
|
||||
}
|
||||
this.seen_transform[transform_type] = true
|
||||
this.transform_type[this.n_transforms] = transform_type as base.u8
|
||||
this.n_transforms += 1
|
||||
|
||||
if transform_type < 2 { // Predictor, Cross Color transform.
|
||||
if this.n_bits < 3 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 3 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 3
|
||||
}
|
||||
tile_size_log2 = (this.bits & 7) + 2
|
||||
this.transform_tile_size_log2[transform_type] = tile_size_log2 as base.u8
|
||||
this.bits >>= 3
|
||||
this.n_bits -= 3
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
|
||||
|
||||
while true,
|
||||
inv transform_type < 2,
|
||||
inv tile_size_log2 >= 2,
|
||||
{
|
||||
width = this.width
|
||||
if this.seen_transform[3] {
|
||||
width = this.color_indexing_width
|
||||
}
|
||||
|
||||
if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
status =? this.decode_pixels?(
|
||||
dst: args.workbuf[
|
||||
(this.workbuf_offset_for_transform[transform_type + 1] as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[transform_type + 2] as base.u64)],
|
||||
src: args.src,
|
||||
width: (width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
tile_data: this.util.empty_slice_u8(),
|
||||
tile_size_log2: 0)
|
||||
if status.is_ok() {
|
||||
break
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
|
||||
} else if transform_type == 2 { // Subtract Green transform.
|
||||
// No-op.
|
||||
|
||||
} else { // Color Indexing transform.
|
||||
if this.n_bits < 8 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 8 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 8
|
||||
}
|
||||
this.color_indexing_palette_size = (this.bits & 0xFF) + 1
|
||||
this.bits >>= 8
|
||||
this.n_bits -= 8
|
||||
|
||||
if this.color_indexing_palette_size <= 2 {
|
||||
this.color_indexing_width = (this.width + 7) / 8
|
||||
this.transform_tile_size_log2[3] = 3
|
||||
} else if this.color_indexing_palette_size <= 4 {
|
||||
this.color_indexing_width = (this.width + 3) / 4
|
||||
this.transform_tile_size_log2[3] = 2
|
||||
} else if this.color_indexing_palette_size <= 16 {
|
||||
this.color_indexing_width = (this.width + 1) / 2
|
||||
this.transform_tile_size_log2[3] = 1
|
||||
} else {
|
||||
this.color_indexing_width = this.width
|
||||
this.transform_tile_size_log2[3] = 0
|
||||
}
|
||||
|
||||
if this.width >= this.color_indexing_width {
|
||||
this.workbuf_offset_for_color_indexing = 4 * (this.width - this.color_indexing_width) * this.height
|
||||
}
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
|
||||
|
||||
this.decode_pixels?(
|
||||
dst: this.palette[.. 4 * this.color_indexing_palette_size],
|
||||
src: args.src,
|
||||
width: this.color_indexing_palette_size,
|
||||
height: 1,
|
||||
tile_data: this.util.empty_slice_u8(),
|
||||
tile_size_log2: 0)
|
||||
this.palette[4 * this.color_indexing_palette_size .. 1024].bulk_memset!(byte_value: 0)
|
||||
|
||||
p = this.palette[.. 4 * this.color_indexing_palette_size]
|
||||
while p.length() >= 8 {
|
||||
p[4] ~mod+= p[0]
|
||||
p[5] ~mod+= p[1]
|
||||
p[6] ~mod+= p[2]
|
||||
p[7] ~mod+= p[3]
|
||||
p = p[4 ..]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_color_cache_parameters?(src: base.io_reader) {
|
||||
var c8 : base.u8
|
||||
var use_color_cache : base.u32[..= 1]
|
||||
var color_cache_bits : base.u32[..= 15]
|
||||
|
||||
if this.n_bits < 1 {
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32)
|
||||
this.n_bits = 8
|
||||
assert this.n_bits >= 1
|
||||
}
|
||||
use_color_cache = this.bits & 1
|
||||
this.bits >>= 1
|
||||
this.n_bits -= 1
|
||||
|
||||
this.color_cache_bits = 0
|
||||
if use_color_cache <> 0 {
|
||||
if this.n_bits < 4 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 4 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 4
|
||||
}
|
||||
color_cache_bits = this.bits & 15
|
||||
this.bits >>= 4
|
||||
this.n_bits -= 4
|
||||
|
||||
if (color_cache_bits < 1) or (11 < color_cache_bits) {
|
||||
return "#bad color cache"
|
||||
}
|
||||
this.color_cache_bits = color_cache_bits
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) {
|
||||
var status : base.status
|
||||
var c8 : base.u8
|
||||
var use_hg_table : base.u32[..= 1]
|
||||
var tile_size_log2 : base.u32[..= 9]
|
||||
var hg_pixels : slice base.u8
|
||||
var n : base.u64
|
||||
var p : roslice base.u8
|
||||
var hg_plus_1 : base.u32[..= 256]
|
||||
|
||||
if this.n_bits < 1 {
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32)
|
||||
this.n_bits = 8
|
||||
assert this.n_bits >= 1
|
||||
}
|
||||
use_hg_table = this.bits & 1
|
||||
this.bits >>= 1
|
||||
this.n_bits -= 1
|
||||
|
||||
if use_hg_table == 0 {
|
||||
this.overall_n_huffman_groups = 1
|
||||
this.overall_tile_size_log2 = 0
|
||||
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
hg_pixels = args.workbuf[
|
||||
this.workbuf_offset_for_transform[0] as base.u64 ..
|
||||
this.workbuf_offset_for_transform[1] as base.u64]
|
||||
if hg_pixels.length() >= 4 {
|
||||
hg_pixels[0] = 0x00
|
||||
hg_pixels[1] = 0x00
|
||||
hg_pixels[2] = 0x00
|
||||
hg_pixels[3] = 0x00
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
if this.n_bits < 3 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 3 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 3
|
||||
}
|
||||
tile_size_log2 = (this.bits & 7) + 2
|
||||
this.bits >>= 3
|
||||
this.n_bits -= 3
|
||||
|
||||
this.overall_tile_size_log2 = tile_size_log2
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
|
||||
while true,
|
||||
inv tile_size_log2 >= 2,
|
||||
{
|
||||
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
status =? this.decode_pixels?(
|
||||
dst: args.workbuf[
|
||||
(this.workbuf_offset_for_transform[0] as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[1] as base.u64)],
|
||||
src: args.src,
|
||||
width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
tile_data: this.util.empty_slice_u8(),
|
||||
tile_size_log2: 0)
|
||||
if status.is_ok() {
|
||||
break
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
|
||||
this.overall_n_huffman_groups = 1
|
||||
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
hg_pixels = args.workbuf[
|
||||
this.workbuf_offset_for_transform[0] as base.u64 ..
|
||||
this.workbuf_offset_for_transform[1] as base.u64]
|
||||
n = (((args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
|
||||
((this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
|
||||
4) as base.u64
|
||||
if n > hg_pixels.length() {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
p = hg_pixels[.. n]
|
||||
while p.length() >= 4 {
|
||||
if p[2] <> 0 {
|
||||
return "#unsupported number of Huffman groups"
|
||||
}
|
||||
hg_plus_1 = (p[1] as base.u32) + 1
|
||||
if this.overall_n_huffman_groups < hg_plus_1 {
|
||||
this.overall_n_huffman_groups = hg_plus_1
|
||||
}
|
||||
p = p[4 ..]
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) {
|
||||
var i : base.u32
|
||||
var n : base.u32[..= 2048]
|
||||
|
||||
i = 0
|
||||
n = (1 as base.u32) << this.color_cache_bits
|
||||
while i < n {
|
||||
assert i < 2048 via "a < b: a < c; c <= b"(c: n)
|
||||
this.color_cache[i] = 0
|
||||
i += 1
|
||||
}
|
||||
|
||||
this.decode_pixels_slow?(
|
||||
dst: args.dst,
|
||||
src: args.src,
|
||||
width: args.width,
|
||||
height: args.height,
|
||||
tile_data: args.tile_data,
|
||||
tile_size_log2: args.tile_size_log2)
|
||||
}
|
||||
|
||||
pri func decoder.swizzle!(dst: nptr base.pixel_buffer, src: roslice base.u8, blend: base.pixel_blend) base.status {
|
||||
var status : base.status
|
||||
var dst_pixfmt : base.pixel_format
|
||||
var dst_bits_per_pixel : base.u32[..= 256]
|
||||
var dst_bytes_per_pixel : base.u32[..= 32]
|
||||
var dst_bytes_per_row : base.u64
|
||||
var dst_palette : slice base.u8
|
||||
var tab : table base.u8
|
||||
var src_bytes_per_row : base.u64
|
||||
var dst : slice base.u8
|
||||
var y : base.u32
|
||||
|
||||
if args.dst == nullptr {
|
||||
return ok
|
||||
}
|
||||
|
||||
status = this.swizzler.prepare!(
|
||||
dst_pixfmt: args.dst.pixel_format(),
|
||||
dst_palette: args.dst.palette_or_else(fallback: this.palette[..]),
|
||||
src_pixfmt: this.util.make_pixel_format(repr: base.PIXEL_FORMAT__BGRA_NONPREMUL),
|
||||
src_palette: this.util.empty_slice_u8(),
|
||||
blend: args.blend)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
|
||||
// TODO: the dst_pixfmt variable shouldn't be necessary. We should be able
|
||||
// to chain the two calls: "args.dst.pixel_format().bits_per_pixel()".
|
||||
dst_pixfmt = args.dst.pixel_format()
|
||||
dst_bits_per_pixel = dst_pixfmt.bits_per_pixel()
|
||||
if (dst_bits_per_pixel & 7) <> 0 {
|
||||
return base."#unsupported option"
|
||||
}
|
||||
dst_bytes_per_pixel = dst_bits_per_pixel / 8
|
||||
dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64
|
||||
dst_palette = args.dst.palette_or_else(fallback: this.palette[..])
|
||||
tab = args.dst.plane(p: 0)
|
||||
src_bytes_per_row = (this.width * 4) as base.u64
|
||||
|
||||
while src_bytes_per_row <= args.src.length() {
|
||||
dst = tab.row_u32(y: y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
}
|
||||
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst,
|
||||
dst_palette: dst_palette,
|
||||
src: args.src[.. src_bytes_per_row])
|
||||
|
||||
args.src = args.src[src_bytes_per_row ..]
|
||||
y ~mod+= 1
|
||||
}
|
||||
|
||||
return ok
|
||||
}
|
||||
+255
-481
@@ -10,18 +10,20 @@
|
||||
|
||||
use "std/vp8"
|
||||
|
||||
pub status "#bad ALPH+VP8L combination"
|
||||
pub status "#bad Huffman code (over-subscribed)"
|
||||
pub status "#bad Huffman code (under-subscribed)"
|
||||
pub status "#bad Huffman code"
|
||||
pub status "#bad VP8X chunk"
|
||||
pub status "#bad back-reference"
|
||||
pub status "#bad chunk order"
|
||||
pub status "#bad color cache"
|
||||
pub status "#bad header"
|
||||
pub status "#bad transform"
|
||||
pub status "#short chunk"
|
||||
pub status "#truncated input"
|
||||
pub status "#unsupported number of Huffman groups"
|
||||
pub status "#unsupported transform after color indexing transform"
|
||||
pub status "#unsupported WebP file"
|
||||
pub status "#unsupported number of Huffman groups"
|
||||
|
||||
pri status "#internal error: inconsistent Huffman code"
|
||||
pri status "#internal error: inconsistent dst buffer"
|
||||
@@ -32,7 +34,6 @@ pri status "#internal error: inconsistent n_bits"
|
||||
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0x4C00_0000
|
||||
|
||||
pub struct decoder? implements base.image_decoder(
|
||||
pixfmt : base.u32,
|
||||
width : base.u32[..= 0x4000],
|
||||
height : base.u32[..= 0x4000],
|
||||
|
||||
@@ -44,12 +45,49 @@ pub struct decoder? implements base.image_decoder(
|
||||
|
||||
sub_chunk_has_padding : base.bool,
|
||||
|
||||
is_vp8_lossy : base.bool,
|
||||
// 0x01 = VP8 lossy
|
||||
// 0x02 = VP8L lossless
|
||||
// 0x04 = VP8X and seen VP8X chunks
|
||||
// 0x08 = VP8X and seen VP8X, ICCP chunks
|
||||
// 0x10 = VP8X and seen VP8X, ICCP†, ANIM chunks
|
||||
// 0x20 = VP8X and seen VP8X, ICCP†, ANIM†, ANMF chunks
|
||||
// 0x40 = VP8X and seen VP8X, ICCP†, ANIM†, ANMF†, ALPH chunks
|
||||
// 0x81 = VP8X and seen VP8X, ICCP†, ANIM†, ANMF†, ALPH†, VP8 chunks
|
||||
// 0x82 = VP8X and seen VP8X, ICCP†, ANIM†, ANMF†, ALPH†, VP8L chunks
|
||||
//
|
||||
// Chunks marked with a † are optional.
|
||||
variant : base.u8,
|
||||
|
||||
// The "Rsv|I|L|E|X|A|R" bits from
|
||||
// https://developers.google.com/speed/webp/docs/riff_container#extended_file_format
|
||||
//
|
||||
// We also re-purpose the otherwise-unused 0x01 bit to mean VP8X-ness,
|
||||
// so that (vp8x_header_flags <> 0) is an easy check for VP8X versus
|
||||
// not-VP8X. Similarly, ((vp8x_header_flags & 0x11) == 0x01) is an easy
|
||||
// check for "VP8X without an ALPH chunk".
|
||||
//
|
||||
// See also libwebp's src/webp/mux_types.h:
|
||||
//
|
||||
// ANIMATION_FLAG = 0x00000002,
|
||||
// XMP_FLAG = 0x00000004,
|
||||
// EXIF_FLAG = 0x00000008,
|
||||
// ALPHA_FLAG = 0x00000010,
|
||||
// ICCP_FLAG = 0x00000020,
|
||||
vp8x_header_flags : base.u8,
|
||||
|
||||
// The "Rsv| P | F | C" bits from
|
||||
// https://developers.google.com/speed/webp/docs/riff_container#alpha
|
||||
//
|
||||
// We also re-purpose the otherwise-unused 0x02 bit to mean that we
|
||||
// have seen the ALPH chunk.
|
||||
vp8x_alph_flags : base.u8,
|
||||
|
||||
frame_config_io_position : base.u64,
|
||||
|
||||
riff_chunk_length : base.u32,
|
||||
rcl_remaining : base.u32,
|
||||
sub_chunk_length : base.u32,
|
||||
sub_chunk_type : base.u32,
|
||||
|
||||
bits : base.u32,
|
||||
n_bits : base.u32[..= 31],
|
||||
@@ -180,12 +218,13 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
if (this.riff_chunk_length & 1) <> 0 {
|
||||
return "#bad header"
|
||||
}
|
||||
this.rcl_remaining = this.riff_chunk_length
|
||||
|
||||
while true {
|
||||
io_limit (io: args.src, limit: this.riff_chunk_length as base.u64) {
|
||||
io_limit (io: args.src, limit: this.rcl_remaining as base.u64) {
|
||||
r_mark = args.src.mark()
|
||||
status =? this.do_decode_image_config_limited?(dst: args.dst, src: args.src)
|
||||
this.riff_chunk_length ~sat-=
|
||||
this.rcl_remaining ~sat-=
|
||||
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
}
|
||||
|
||||
@@ -193,7 +232,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
break
|
||||
} else if not status.is_suspension() {
|
||||
return status
|
||||
} else if (status == base."$short read") and (this.riff_chunk_length == 0) {
|
||||
} else if (status == base."$short read") and (this.rcl_remaining == 0) {
|
||||
return "#short chunk"
|
||||
}
|
||||
yield? status
|
||||
@@ -201,9 +240,9 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
|
||||
this.frame_config_io_position = args.src.position()
|
||||
|
||||
if (not this.is_vp8_lossy) and (args.dst <> nullptr) {
|
||||
if (this.variant <> 0x01) and (args.dst <> nullptr) {
|
||||
args.dst.set!(
|
||||
pixfmt: this.pixfmt,
|
||||
pixfmt: base.PIXEL_FORMAT__BGRA_NONPREMUL,
|
||||
pixsub: 0,
|
||||
width: this.width,
|
||||
height: this.height,
|
||||
@@ -226,35 +265,37 @@ pri func decoder.do_decode_image_config_limited?(dst: nptr base.image_config, sr
|
||||
|
||||
c32 = args.src.read_u32le?()
|
||||
if c32 == 'VP8 'le {
|
||||
this.is_vp8_lossy = true
|
||||
this.variant = 0x01
|
||||
} else if c32 == 'VP8L'le {
|
||||
// No-op.
|
||||
this.variant = 0x02
|
||||
} else if c32 == 'VP8X'le {
|
||||
return "#unsupported WebP file"
|
||||
this.variant = 0x04
|
||||
} else {
|
||||
return "#bad header"
|
||||
}
|
||||
|
||||
this.sub_chunk_length = args.src.read_u32le?()
|
||||
if this.sub_chunk_length < 4 {
|
||||
return "#bad header"
|
||||
}
|
||||
this.sub_chunk_has_padding = (this.sub_chunk_length & 1) <> 0
|
||||
|
||||
if this.is_vp8_lossy {
|
||||
if this.variant == 0x01 {
|
||||
this.vp8.set_quirk!(
|
||||
key: base.QUIRK_SOURCE_LENGTH,
|
||||
value: ((this.sub_chunk_length as base.u64) << 1) | 1)
|
||||
|
||||
} else if this.variant == 0x02 {
|
||||
// No-op.
|
||||
} else if this.sub_chunk_length <> 10 {
|
||||
return "#bad header"
|
||||
}
|
||||
|
||||
while true {
|
||||
io_limit (io: args.src, limit: this.sub_chunk_length as base.u64) {
|
||||
r_mark = args.src.mark()
|
||||
if this.is_vp8_lossy {
|
||||
if this.variant == 0x01 {
|
||||
status =? this.vp8.decode_image_config?(dst: args.dst, src: args.src)
|
||||
} else {
|
||||
} else if this.variant == 0x02 {
|
||||
status =? this.do_decode_image_config_limited_vp8l?(src: args.src)
|
||||
} else {
|
||||
status =? this.do_decode_image_config_limited_vp8x?(src: args.src)
|
||||
}
|
||||
this.sub_chunk_length ~sat-=
|
||||
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
@@ -284,10 +325,10 @@ pri func decoder.do_decode_image_config_limited_vp8l?(src: base.io_reader) {
|
||||
c32 >>= 14
|
||||
this.height = (c32 & 0x3FFF) + 1
|
||||
c32 >>= 14
|
||||
this.pixfmt = base.PIXEL_FORMAT__BGRX
|
||||
if (c32 & 1) <> 0 {
|
||||
this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
}
|
||||
// In theory, (c32 & 1) would let us discriminate between
|
||||
// base.PIXEL_FORMAT__BGRX and base.PIXEL_FORMAT__BGRA_NONPREMUL, but the
|
||||
// VP8 Lossless spec says that this bit "is a hint only, and *should not
|
||||
// impact decoding* [emphasis added]".
|
||||
c32 >>= 1
|
||||
if c32 <> 0 {
|
||||
return "#bad header"
|
||||
@@ -300,11 +341,90 @@ pri func decoder.do_decode_image_config_limited_vp8l?(src: base.io_reader) {
|
||||
this.workbuf_offset_for_transform[3] = (4 * this.width * this.height) + (3 * transform_size)
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_image_config_limited_vp8x?(src: base.io_reader) {
|
||||
var c32 : base.u32
|
||||
var transform_size : base.u32[..= 0x400_0000]
|
||||
var status : base.status
|
||||
|
||||
c32 = args.src.read_u32le?()
|
||||
if (c32 & 0xFFFF_FFC1) <> 0 {
|
||||
return "#unsupported WebP file"
|
||||
}
|
||||
this.vp8x_header_flags = ((c32 | 0x01) & 0xFF) as base.u8
|
||||
|
||||
c32 = args.src.read_u24le_as_u32?()
|
||||
if c32 >= 0x3FFF {
|
||||
return "#unsupported WebP file"
|
||||
}
|
||||
this.width = (c32 & 0x3FFF) + 1
|
||||
|
||||
c32 = args.src.read_u24le_as_u32?()
|
||||
if c32 >= 0x3FFF {
|
||||
return "#unsupported WebP file"
|
||||
}
|
||||
this.height = (c32 & 0x3FFF) + 1
|
||||
|
||||
// It's valid to call this.workbuf_len after this.decode_image_config
|
||||
// returns, for the caller to know how much dynamically-sized memory
|
||||
// (called workbuf memory) is needed to decode the image file.
|
||||
//
|
||||
// Unfortunately, having only seen the VP8X chunk, we don't know yet
|
||||
// whether it's ultimately a VP8 or VP8L image, but we wouldn't know until
|
||||
// after we've processed the ALPH chunk (if present), and processing the
|
||||
// ALPH chunk requires workbuf memory (as the amount of memory depends on
|
||||
// this.width and this.height).
|
||||
//
|
||||
// Wuffs' "decode an image" API assumes that the caller, not callee, is
|
||||
// responsible for dynamically allocating memory. But also, it only assumes
|
||||
// sequential access (not random access) to the io_reader.
|
||||
//
|
||||
// So, here, we have to cater for the worst case and set aside workbuf
|
||||
// memory just like plain VP8L, even if it might end up being unused, for
|
||||
// example: VP8X+VP8 instead of VP8X+VP8L or VP8X+ALPH+VP8.
|
||||
transform_size = 4 * ((this.width + 3) >> 2) * ((this.height + 3) >> 2)
|
||||
this.workbuf_offset_for_transform[0] = (4 * this.width * this.height) + (0 * transform_size)
|
||||
this.workbuf_offset_for_transform[1] = (4 * this.width * this.height) + (1 * transform_size)
|
||||
this.workbuf_offset_for_transform[2] = (4 * this.width * this.height) + (2 * transform_size)
|
||||
this.workbuf_offset_for_transform[3] = (4 * this.width * this.height) + (3 * transform_size)
|
||||
|
||||
// The RIFF chunk length (which we have seen) is an upper bound for the VP8
|
||||
// sub-chunk length (which we haven't seen yet). Set this now so that
|
||||
// this.vp8.workbuf_len will return something definitive (non-empty).
|
||||
//
|
||||
// TODO: for animated WebP images, this upper bound essentially allocates
|
||||
// O(numberOfAnimationFrames) memory. Ideally, it'd be O(1) instead.
|
||||
//
|
||||
// This might need tweaking the semantics of the wuffs_base__image_decoder
|
||||
// API (which applies to multiple image formats, not just WebP). The API is
|
||||
// that you can call workbuf_len as soon as decode_image_config returns.
|
||||
// workbuf_len returns a range and any value within that range should be a
|
||||
// valid length for the "dynamically allocated, not O(1) in terms of width
|
||||
// and height" workbuf memory passed to decode_frame.
|
||||
//
|
||||
// We could relax this so that decode_frame could return a "$short workbuf"
|
||||
// suspension, if the workbuf length is unknown at the time of the first
|
||||
// decode_frame call, and the caller is expected to essentially realloc the
|
||||
// workbuf, keeping any existing contents when growing it.
|
||||
status = this.vp8.set_quirk!(
|
||||
key: base.QUIRK_SOURCE_LENGTH,
|
||||
value: ((this.riff_chunk_length as base.u64) << 1) | 1)
|
||||
if not status.is_ok() {
|
||||
return "#unsupported WebP file"
|
||||
}
|
||||
|
||||
status = this.vp8.set_quirk!(
|
||||
key: vp8.QUIRK_WIDTH_AND_HEIGHT,
|
||||
value: ((this.width as base.u64) | ((this.height as base.u64) << 32)))
|
||||
if not status.is_ok() {
|
||||
return "#unsupported WebP file"
|
||||
}
|
||||
}
|
||||
|
||||
pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
|
||||
var status : base.status
|
||||
|
||||
while true {
|
||||
if this.is_vp8_lossy {
|
||||
if this.variant == 0x01 {
|
||||
status =? this.vp8.decode_frame_config?(dst: args.dst, src: args.src)
|
||||
} else {
|
||||
status =? this.do_decode_frame_config?(dst: args.dst, src: args.src)
|
||||
@@ -317,8 +437,6 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
|
||||
var pixfmt : base.pixel_format
|
||||
|
||||
if this.call_sequence == 0x20 {
|
||||
// No-op.
|
||||
} else if this.call_sequence < 0x20 {
|
||||
@@ -334,8 +452,7 @@ pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.
|
||||
return base."@end of data"
|
||||
}
|
||||
|
||||
if args.dst <> nullptr {
|
||||
pixfmt = this.util.make_pixel_format(repr: this.pixfmt)
|
||||
if (this.variant <> 0x01) and (args.dst <> nullptr) {
|
||||
args.dst.set!(bounds: this.util.make_rect_ie_u32(
|
||||
min_incl_x: 0,
|
||||
min_incl_y: 0,
|
||||
@@ -347,7 +464,7 @@ pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.
|
||||
disposal: 0,
|
||||
opaque_within_bounds: false,
|
||||
overwrite_instead_of_blend: false,
|
||||
background_color: pixfmt.default_background_color())
|
||||
background_color: 0x0000_0000)
|
||||
}
|
||||
|
||||
this.call_sequence = 0x40
|
||||
@@ -357,11 +474,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
var status : base.status
|
||||
|
||||
while true {
|
||||
if this.is_vp8_lossy {
|
||||
status =? this.vp8.decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
|
||||
} else {
|
||||
status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
|
||||
}
|
||||
status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
|
||||
if (status == base."$short read") and args.src.is_closed() {
|
||||
return "#truncated input"
|
||||
}
|
||||
@@ -370,17 +483,8 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
|
||||
var c8 : base.u8
|
||||
var has_more : base.u32[..= 1]
|
||||
var width : base.u32[..= 0x4000]
|
||||
var dst : slice base.u8
|
||||
var tile_data : roslice base.u8
|
||||
var status : base.status
|
||||
var pix : slice base.u8
|
||||
var which : base.u32[..= 4]
|
||||
var transform_type : base.u32[..= 3]
|
||||
var ti : base.u64
|
||||
var tj : base.u64
|
||||
var r_mark : base.u64
|
||||
var status : base.status
|
||||
|
||||
if this.call_sequence == 0x40 {
|
||||
// No-op.
|
||||
@@ -390,454 +494,106 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
return base."@end of data"
|
||||
}
|
||||
|
||||
this.seen_transform[0] = false
|
||||
this.seen_transform[1] = false
|
||||
this.seen_transform[2] = false
|
||||
this.seen_transform[3] = false
|
||||
this.n_transforms = 0
|
||||
|
||||
while true {
|
||||
if this.n_bits < 1 {
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32)
|
||||
this.n_bits = 8
|
||||
assert this.n_bits >= 1
|
||||
while (this.variant & 0x03) == 0 {
|
||||
this.sub_chunk_type = args.src.read_u32le?()
|
||||
this.sub_chunk_length = args.src.read_u32le?()
|
||||
this.sub_chunk_has_padding = (this.sub_chunk_length & 1) <> 0
|
||||
if this.sub_chunk_length > 0x7FFF_FFFF {
|
||||
return "#unsupported WebP file"
|
||||
}
|
||||
has_more = this.bits & 1
|
||||
this.bits >>= 1
|
||||
this.n_bits -= 1
|
||||
|
||||
if has_more == 0 {
|
||||
if this.sub_chunk_type == 'ICCP'le {
|
||||
if this.variant > 0x04 {
|
||||
return "#bad chunk order"
|
||||
} else if (this.vp8x_header_flags & 0x20) == 0 {
|
||||
return "#bad VP8X chunk"
|
||||
}
|
||||
this.variant = 0x08
|
||||
|
||||
} else if this.sub_chunk_type == 'ANIM'le {
|
||||
if this.variant > 0x08 {
|
||||
return "#bad chunk order"
|
||||
} else if (this.vp8x_header_flags & 0x02) == 0 {
|
||||
return "#bad VP8X chunk"
|
||||
}
|
||||
this.variant = 0x10
|
||||
|
||||
} else if this.sub_chunk_type == 'ANMF'le {
|
||||
if this.variant > 0x10 {
|
||||
return "#bad chunk order"
|
||||
} else if (this.vp8x_header_flags & 0x02) == 0 {
|
||||
return "#bad VP8X chunk"
|
||||
}
|
||||
this.variant = 0x20
|
||||
|
||||
} else if this.sub_chunk_type == 'ALPH'le {
|
||||
if this.variant > 0x20 {
|
||||
return "#bad chunk order"
|
||||
} else if (this.vp8x_header_flags & 0x10) == 0 {
|
||||
return "#bad VP8X chunk"
|
||||
}
|
||||
this.variant = 0x40
|
||||
this.decode_alph?(src: args.src, workbuf: args.workbuf)
|
||||
this.vp8.set_quirk!(
|
||||
key: vp8.QUIRK_HAS_ALPHA_SIDE_CHANNEL,
|
||||
value: 1)
|
||||
|
||||
} else if this.sub_chunk_type == 'VP8 'le {
|
||||
this.vp8.set_quirk!(
|
||||
key: base.QUIRK_SOURCE_LENGTH,
|
||||
value: ((this.sub_chunk_length as base.u64) << 1) | 1)
|
||||
this.variant = 0x81
|
||||
break
|
||||
|
||||
} else if this.sub_chunk_type == 'VP8L'le {
|
||||
if (this.vp8x_header_flags & 0x10) <> 0 {
|
||||
return "#bad ALPH+VP8L combination"
|
||||
}
|
||||
this.variant = 0x82
|
||||
break
|
||||
|
||||
} else if this.sub_chunk_type == 'XMP 'le {
|
||||
if (this.vp8x_header_flags & 0x04) == 0 {
|
||||
return "#bad VP8X chunk"
|
||||
}
|
||||
|
||||
} else if this.sub_chunk_type == 'EXIF'le {
|
||||
if (this.vp8x_header_flags & 0x08) == 0 {
|
||||
return "#bad VP8X chunk"
|
||||
}
|
||||
}
|
||||
this.decode_transform?(src: args.src, workbuf: args.workbuf)
|
||||
}
|
||||
|
||||
width = this.width
|
||||
if this.seen_transform[3] {
|
||||
width = this.color_indexing_width
|
||||
args.src.skip_u32?(n: this.sub_chunk_length)
|
||||
if this.sub_chunk_has_padding {
|
||||
args.src.skip_u32?(n: 1)
|
||||
}
|
||||
}
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.overall_color_cache_bits = this.color_cache_bits
|
||||
this.decode_hg_table?(src: args.src, width: width, workbuf: args.workbuf)
|
||||
this.color_cache_bits = this.overall_color_cache_bits
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: this.overall_n_huffman_groups)
|
||||
|
||||
while true {
|
||||
if ((this.workbuf_offset_for_color_indexing as base.u64) > (this.workbuf_offset_for_transform[0] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) or
|
||||
((this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
io_limit (io: args.src, limit: this.sub_chunk_length as base.u64) {
|
||||
r_mark = args.src.mark()
|
||||
if (this.variant & 0x01) <> 0 {
|
||||
status =? this.vp8.decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
|
||||
} else {
|
||||
status =? this.do_decode_frame_vp8l?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
|
||||
}
|
||||
this.sub_chunk_length ~sat-=
|
||||
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
}
|
||||
dst = args.workbuf[
|
||||
(this.workbuf_offset_for_color_indexing as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[0] as base.u64)]
|
||||
tile_data = args.workbuf[
|
||||
(this.workbuf_offset_for_transform[0] as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[1] as base.u64)]
|
||||
status =? this.decode_pixels?(
|
||||
dst: dst,
|
||||
src: args.src,
|
||||
width: width,
|
||||
height: this.height,
|
||||
tile_data: tile_data,
|
||||
tile_size_log2: this.overall_tile_size_log2)
|
||||
|
||||
if status.is_ok() {
|
||||
break
|
||||
} else if not status.is_suspension() {
|
||||
return status
|
||||
} else if (status == base."$short read") and (this.sub_chunk_length == 0) {
|
||||
return "#short chunk"
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
|
||||
if (this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length() {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)]
|
||||
|
||||
which = this.n_transforms
|
||||
while which > 0 {
|
||||
which -= 1
|
||||
transform_type = this.transform_type[which] as base.u32
|
||||
|
||||
tile_data = this.util.empty_slice_u8()
|
||||
if transform_type < 2 {
|
||||
ti = this.workbuf_offset_for_transform[transform_type + 1] as base.u64
|
||||
tj = this.workbuf_offset_for_transform[transform_type + 2] as base.u64
|
||||
if (ti <= tj) and (tj <= args.workbuf.length()) {
|
||||
tile_data = args.workbuf[ti .. tj]
|
||||
}
|
||||
}
|
||||
|
||||
if transform_type == 0 {
|
||||
this.apply_transform_predictor!(pix: pix, tile_data: tile_data)
|
||||
} else if transform_type == 1 {
|
||||
this.apply_transform_cross_color!(pix: pix, tile_data: tile_data)
|
||||
} else if transform_type == 2 {
|
||||
this.apply_transform_subtract_green!(pix: pix)
|
||||
} else {
|
||||
this.apply_transform_color_indexing!(pix: pix)
|
||||
width = this.width
|
||||
}
|
||||
}
|
||||
|
||||
status = this.swizzle!(
|
||||
dst: args.dst,
|
||||
src: pix,
|
||||
blend: args.blend)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
|
||||
this.call_sequence = 0x60
|
||||
}
|
||||
|
||||
pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
var status : base.status
|
||||
var c8 : base.u8
|
||||
var transform_type : base.u32[..= 3]
|
||||
var tile_size_log2 : base.u32[..= 9]
|
||||
var p : slice base.u8
|
||||
|
||||
if this.n_bits < 2 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 2 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 2
|
||||
}
|
||||
transform_type = this.bits & 3
|
||||
this.bits >>= 2
|
||||
this.n_bits -= 2
|
||||
|
||||
if this.seen_transform[transform_type] or (this.n_transforms >= 4) {
|
||||
return "#bad transform"
|
||||
} else if this.seen_transform[3] {
|
||||
return "#unsupported transform after color indexing transform"
|
||||
}
|
||||
this.seen_transform[transform_type] = true
|
||||
this.transform_type[this.n_transforms] = transform_type as base.u8
|
||||
this.n_transforms += 1
|
||||
|
||||
if transform_type < 2 { // Predictor, Cross Color transform.
|
||||
if this.n_bits < 3 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 3 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 3
|
||||
}
|
||||
tile_size_log2 = (this.bits & 7) + 2
|
||||
this.transform_tile_size_log2[transform_type] = tile_size_log2 as base.u8
|
||||
this.bits >>= 3
|
||||
this.n_bits -= 3
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
|
||||
|
||||
while true,
|
||||
inv transform_type < 2,
|
||||
inv tile_size_log2 >= 2,
|
||||
{
|
||||
if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
status =? this.decode_pixels?(
|
||||
dst: args.workbuf[
|
||||
(this.workbuf_offset_for_transform[transform_type + 1] as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[transform_type + 2] as base.u64)],
|
||||
src: args.src,
|
||||
width: (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
tile_data: this.util.empty_slice_u8(),
|
||||
tile_size_log2: 0)
|
||||
if status.is_ok() {
|
||||
break
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
|
||||
} else if transform_type == 2 { // Subtract Green transform.
|
||||
// No-op.
|
||||
|
||||
} else { // Color Indexing transform.
|
||||
if this.n_bits < 8 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 8 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 8
|
||||
}
|
||||
this.color_indexing_palette_size = (this.bits & 0xFF) + 1
|
||||
this.bits >>= 8
|
||||
this.n_bits -= 8
|
||||
|
||||
if this.color_indexing_palette_size <= 2 {
|
||||
this.color_indexing_width = (this.width + 7) / 8
|
||||
this.transform_tile_size_log2[3] = 3
|
||||
} else if this.color_indexing_palette_size <= 4 {
|
||||
this.color_indexing_width = (this.width + 3) / 4
|
||||
this.transform_tile_size_log2[3] = 2
|
||||
} else if this.color_indexing_palette_size <= 16 {
|
||||
this.color_indexing_width = (this.width + 1) / 2
|
||||
this.transform_tile_size_log2[3] = 1
|
||||
} else {
|
||||
this.color_indexing_width = this.width
|
||||
this.transform_tile_size_log2[3] = 0
|
||||
}
|
||||
|
||||
if this.width >= this.color_indexing_width {
|
||||
this.workbuf_offset_for_color_indexing = 4 * (this.width - this.color_indexing_width) * this.height
|
||||
}
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
|
||||
|
||||
this.decode_pixels?(
|
||||
dst: this.palette[.. 4 * this.color_indexing_palette_size],
|
||||
src: args.src,
|
||||
width: this.color_indexing_palette_size,
|
||||
height: 1,
|
||||
tile_data: this.util.empty_slice_u8(),
|
||||
tile_size_log2: 0)
|
||||
this.palette[4 * this.color_indexing_palette_size .. 1024].bulk_memset!(byte_value: 0)
|
||||
|
||||
p = this.palette[.. 4 * this.color_indexing_palette_size]
|
||||
while p.length() >= 8 {
|
||||
p[4] ~mod+= p[0]
|
||||
p[5] ~mod+= p[1]
|
||||
p[6] ~mod+= p[2]
|
||||
p[7] ~mod+= p[3]
|
||||
p = p[4 ..]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_color_cache_parameters?(src: base.io_reader) {
|
||||
var c8 : base.u8
|
||||
var use_color_cache : base.u32[..= 1]
|
||||
var color_cache_bits : base.u32[..= 15]
|
||||
|
||||
if this.n_bits < 1 {
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32)
|
||||
this.n_bits = 8
|
||||
assert this.n_bits >= 1
|
||||
}
|
||||
use_color_cache = this.bits & 1
|
||||
this.bits >>= 1
|
||||
this.n_bits -= 1
|
||||
|
||||
this.color_cache_bits = 0
|
||||
if use_color_cache <> 0 {
|
||||
if this.n_bits < 4 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 4 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 4
|
||||
}
|
||||
color_cache_bits = this.bits & 15
|
||||
this.bits >>= 4
|
||||
this.n_bits -= 4
|
||||
|
||||
if (color_cache_bits < 1) or (11 < color_cache_bits) {
|
||||
return "#bad color cache"
|
||||
}
|
||||
this.color_cache_bits = color_cache_bits
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) {
|
||||
var status : base.status
|
||||
var c8 : base.u8
|
||||
var use_hg_table : base.u32[..= 1]
|
||||
var tile_size_log2 : base.u32[..= 9]
|
||||
var hg_pixels : slice base.u8
|
||||
var n : base.u64
|
||||
var p : roslice base.u8
|
||||
var hg_plus_1 : base.u32[..= 256]
|
||||
|
||||
if this.n_bits < 1 {
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32)
|
||||
this.n_bits = 8
|
||||
assert this.n_bits >= 1
|
||||
}
|
||||
use_hg_table = this.bits & 1
|
||||
this.bits >>= 1
|
||||
this.n_bits -= 1
|
||||
|
||||
if use_hg_table == 0 {
|
||||
this.overall_n_huffman_groups = 1
|
||||
this.overall_tile_size_log2 = 0
|
||||
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
hg_pixels = args.workbuf[
|
||||
this.workbuf_offset_for_transform[0] as base.u64 ..
|
||||
this.workbuf_offset_for_transform[1] as base.u64]
|
||||
if hg_pixels.length() >= 4 {
|
||||
hg_pixels[0] = 0x00
|
||||
hg_pixels[1] = 0x00
|
||||
hg_pixels[2] = 0x00
|
||||
hg_pixels[3] = 0x00
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
if this.n_bits < 3 {
|
||||
c8 = args.src.read_u8?()
|
||||
if this.n_bits >= 3 {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
}
|
||||
this.bits |= (c8 as base.u32) << this.n_bits
|
||||
this.n_bits += 8
|
||||
assert this.n_bits >= 3
|
||||
}
|
||||
tile_size_log2 = (this.bits & 7) + 2
|
||||
this.bits >>= 3
|
||||
this.n_bits -= 3
|
||||
|
||||
this.overall_tile_size_log2 = tile_size_log2
|
||||
|
||||
this.decode_color_cache_parameters?(src: args.src)
|
||||
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
|
||||
while true,
|
||||
inv tile_size_log2 >= 2,
|
||||
{
|
||||
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
status =? this.decode_pixels?(
|
||||
dst: args.workbuf[
|
||||
(this.workbuf_offset_for_transform[0] as base.u64) ..
|
||||
(this.workbuf_offset_for_transform[1] as base.u64)],
|
||||
src: args.src,
|
||||
width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
|
||||
tile_data: this.util.empty_slice_u8(),
|
||||
tile_size_log2: 0)
|
||||
if status.is_ok() {
|
||||
break
|
||||
}
|
||||
yield? status
|
||||
}
|
||||
|
||||
this.overall_n_huffman_groups = 1
|
||||
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
|
||||
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
hg_pixels = args.workbuf[
|
||||
this.workbuf_offset_for_transform[0] as base.u64 ..
|
||||
this.workbuf_offset_for_transform[1] as base.u64]
|
||||
n = (((args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
|
||||
((this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
|
||||
4) as base.u64
|
||||
if n > hg_pixels.length() {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
p = hg_pixels[.. n]
|
||||
while p.length() >= 4 {
|
||||
if p[2] <> 0 {
|
||||
return "#unsupported number of Huffman groups"
|
||||
}
|
||||
hg_plus_1 = (p[1] as base.u32) + 1
|
||||
if this.overall_n_huffman_groups < hg_plus_1 {
|
||||
this.overall_n_huffman_groups = hg_plus_1
|
||||
}
|
||||
p = p[4 ..]
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) {
|
||||
var i : base.u32
|
||||
var n : base.u32[..= 2048]
|
||||
|
||||
i = 0
|
||||
n = (1 as base.u32) << this.color_cache_bits
|
||||
while i < n {
|
||||
assert i < 2048 via "a < b: a < c; c <= b"(c: n)
|
||||
this.color_cache[i] = 0
|
||||
i += 1
|
||||
}
|
||||
|
||||
this.decode_pixels_slow?(
|
||||
dst: args.dst,
|
||||
src: args.src,
|
||||
width: args.width,
|
||||
height: args.height,
|
||||
tile_data: args.tile_data,
|
||||
tile_size_log2: args.tile_size_log2)
|
||||
}
|
||||
|
||||
pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: roslice base.u8, blend: base.pixel_blend) base.status {
|
||||
var status : base.status
|
||||
var dst_pixfmt : base.pixel_format
|
||||
var dst_bits_per_pixel : base.u32[..= 256]
|
||||
var dst_bytes_per_pixel : base.u32[..= 32]
|
||||
var dst_bytes_per_row : base.u64
|
||||
var dst_palette : slice base.u8
|
||||
var tab : table base.u8
|
||||
var src_bytes_per_row : base.u64
|
||||
var dst : slice base.u8
|
||||
var y : base.u32
|
||||
|
||||
status = this.swizzler.prepare!(
|
||||
dst_pixfmt: args.dst.pixel_format(),
|
||||
dst_palette: args.dst.palette_or_else(fallback: this.palette[..]),
|
||||
src_pixfmt: this.util.make_pixel_format(repr: this.pixfmt),
|
||||
src_palette: this.util.empty_slice_u8(),
|
||||
blend: args.blend)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
|
||||
// TODO: the dst_pixfmt variable shouldn't be necessary. We should be able
|
||||
// to chain the two calls: "args.dst.pixel_format().bits_per_pixel()".
|
||||
dst_pixfmt = args.dst.pixel_format()
|
||||
dst_bits_per_pixel = dst_pixfmt.bits_per_pixel()
|
||||
if (dst_bits_per_pixel & 7) <> 0 {
|
||||
return base."#unsupported option"
|
||||
}
|
||||
dst_bytes_per_pixel = dst_bits_per_pixel / 8
|
||||
dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64
|
||||
dst_palette = args.dst.palette_or_else(fallback: this.palette[..])
|
||||
tab = args.dst.plane(p: 0)
|
||||
src_bytes_per_row = (this.width * 4) as base.u64
|
||||
|
||||
while src_bytes_per_row <= args.src.length() {
|
||||
dst = tab.row_u32(y: y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
}
|
||||
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst,
|
||||
dst_palette: dst_palette,
|
||||
src: args.src[.. src_bytes_per_row])
|
||||
|
||||
args.src = args.src[src_bytes_per_row ..]
|
||||
y ~mod+= 1
|
||||
}
|
||||
|
||||
return ok
|
||||
}
|
||||
|
||||
pub func decoder.frame_dirty_rect() base.rect_ie_u32 {
|
||||
if this.is_vp8_lossy {
|
||||
if this.variant == 0x01 {
|
||||
return this.vp8.frame_dirty_rect()
|
||||
}
|
||||
return this.util.make_rect_ie_u32(
|
||||
@@ -852,7 +608,7 @@ pub func decoder.num_animation_loops() base.u32 {
|
||||
}
|
||||
|
||||
pub func decoder.num_decoded_frame_configs() base.u64 {
|
||||
if this.is_vp8_lossy {
|
||||
if this.variant == 0x01 {
|
||||
return this.vp8.num_decoded_frame_configs()
|
||||
}
|
||||
if this.call_sequence > 0x20 {
|
||||
@@ -862,7 +618,7 @@ pub func decoder.num_decoded_frame_configs() base.u64 {
|
||||
}
|
||||
|
||||
pub func decoder.num_decoded_frames() base.u64 {
|
||||
if this.is_vp8_lossy {
|
||||
if this.variant == 0x01 {
|
||||
return this.vp8.num_decoded_frames()
|
||||
}
|
||||
if this.call_sequence > 0x40 {
|
||||
@@ -874,7 +630,7 @@ pub func decoder.num_decoded_frames() base.u64 {
|
||||
pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
|
||||
var status : base.status
|
||||
|
||||
if this.is_vp8_lossy {
|
||||
if this.variant == 0x01 {
|
||||
status = this.vp8.restart_frame!(index: args.index, io_position: args.io_position)
|
||||
return status
|
||||
}
|
||||
@@ -897,12 +653,30 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
}
|
||||
|
||||
pub func decoder.workbuf_len() base.range_ii_u64 {
|
||||
if this.is_vp8_lossy {
|
||||
var r : base.range_ii_u64
|
||||
var s : base.range_ii_u64
|
||||
|
||||
if this.variant == 0x01 {
|
||||
return this.vp8.workbuf_len()
|
||||
}
|
||||
return this.util.make_range_ii_u64(
|
||||
|
||||
r = this.util.make_range_ii_u64(
|
||||
min_incl: this.workbuf_offset_for_transform[3] as base.u64,
|
||||
max_incl: this.workbuf_offset_for_transform[3] as base.u64)
|
||||
|
||||
if this.variant <> 0x02 {
|
||||
s = this.vp8.workbuf_len()
|
||||
if s.is_empty() {
|
||||
// Empty means that the workbuf_len range isn't known yet.
|
||||
return s
|
||||
}
|
||||
|
||||
r = this.util.make_range_ii_u64(
|
||||
min_incl: s.get_min_incl().max(no_less_than: r.get_min_incl()),
|
||||
max_incl: s.get_max_incl().max(no_less_than: r.get_max_incl()))
|
||||
}
|
||||
|
||||
return r
|
||||
}
|
||||
|
||||
pri const DISTANCE_MAP : roarray[120] base.u8 = [
|
||||
|
||||
@@ -30,6 +30,7 @@ OK. d9f8441c test/3pdata/blinksuite/blue-10.png
|
||||
OK. 267741e0 test/3pdata/blinksuite/blue-100.png
|
||||
OK. 89449c01 test/3pdata/blinksuite/blue-wheel-srgb-color-profile.jpg
|
||||
OK. 8fce70a9 test/3pdata/blinksuite/blue-wheel-srgb-color-profile.png
|
||||
OK. 426a5623 test/3pdata/blinksuite/blue-wheel-srgb-color-profile.webp
|
||||
OK. 2d7bad9f test/3pdata/blinksuite/border-image-srgb-color-profile.png
|
||||
OK. 9ca73f21 test/3pdata/blinksuite/border-image.png
|
||||
OK. 277600f9 test/3pdata/blinksuite/boston.gif
|
||||
@@ -42,6 +43,8 @@ OK. 5ec78d7c test/3pdata/blinksuite/color-checker-adobe-color-profile.png
|
||||
OK. b3389858 test/3pdata/blinksuite/color-checker-srgb-color-profile.png
|
||||
OK. 10721531 test/3pdata/blinksuite/count-down-color-test.gif
|
||||
OK. 1abc4dc6 test/3pdata/blinksuite/count-down-color-test.png
|
||||
BAD d663b0e6 test/3pdata/blinksuite/count-down-color-test.webp
|
||||
OK. 18fbe8ca test/3pdata/blinksuite/crbug.364830.webp
|
||||
OK. 24ab1efd test/3pdata/blinksuite/crbug779261.gif
|
||||
OK. ae034abe test/3pdata/blinksuite/crbug807324.png
|
||||
OK. 4f50fdb0 test/3pdata/blinksuite/crbug827754.png
|
||||
@@ -66,6 +69,7 @@ OK. d97ce4e8 test/3pdata/blinksuite/cs-uma-ycbcr-other.jpg
|
||||
OK. a2a940bc test/3pdata/blinksuite/cs-uma-ycck.jpg
|
||||
OK. b6000be6 test/3pdata/blinksuite/dice.png
|
||||
BAD 1023c20a test/3pdata/blinksuite/empty-frame.png
|
||||
OK. 4a495d9f test/3pdata/blinksuite/flip.webp
|
||||
OK. eff36075 test/3pdata/blinksuite/flowchart.jpg
|
||||
OK. 20ff1df8 test/3pdata/blinksuite/full2loop.gif
|
||||
OK. dc814e29 test/3pdata/blinksuite/gif-loop-count.gif
|
||||
@@ -89,6 +93,11 @@ OK. 95641cb9 test/3pdata/blinksuite/icc-v2-gbr-420-height-not-whole-mcu.jpg
|
||||
OK. 93f21c2a test/3pdata/blinksuite/icc-v2-gbr-420-width-not-whole-mcu.jpg
|
||||
OK. f37cea44 test/3pdata/blinksuite/icc-v2-gbr-422-whole-mcus.jpg
|
||||
OK. 1de5a906 test/3pdata/blinksuite/icc-v2-gbr.jpg
|
||||
BAD 7c80a001 test/3pdata/blinksuite/invalid-animated-webp.webp
|
||||
BAD 1e37d000 test/3pdata/blinksuite/invalid-animated-webp2.webp
|
||||
BAD 97b2b706 test/3pdata/blinksuite/invalid-animated-webp3.webp
|
||||
BAD 145962c5 test/3pdata/blinksuite/invalid-animated-webp4.webp
|
||||
OK. 2ba1fc10 test/3pdata/blinksuite/invalid_vp8_vp8x.webp
|
||||
OK. 0da5f37e test/3pdata/blinksuite/jpeg-height-exif-orientation.jpg
|
||||
OK. 4409dca6 test/3pdata/blinksuite/large-gif-checkerboard.gif
|
||||
OK. d67648b6 test/3pdata/blinksuite/large.webp
|
||||
@@ -171,9 +180,24 @@ OK. 1b1f5f96 test/3pdata/blinksuite/stripes-large.png
|
||||
OK. 6b85cdb9 test/3pdata/blinksuite/stripes-small.png
|
||||
OK. 16c2c0fe test/3pdata/blinksuite/test-load.jpg
|
||||
OK. 6fbda804 test/3pdata/blinksuite/test.webp
|
||||
OK. eb16e76c test/3pdata/blinksuite/test2.webp
|
||||
OK. 19d3a207 test/3pdata/blinksuite/test3.webp
|
||||
OK. 56224156 test/3pdata/blinksuite/truncated.webp
|
||||
BAD 1dfa35c6 test/3pdata/blinksuite/truncated2.webp
|
||||
BAD b16eb1a2 test/3pdata/blinksuite/webp-animated-icc-xmp.webp
|
||||
BAD 45030792 test/3pdata/blinksuite/webp-animated-large.webp
|
||||
BAD 4519c83d test/3pdata/blinksuite/webp-animated-no-blend.webp
|
||||
BAD 4519c83d test/3pdata/blinksuite/webp-animated-opaque.webp
|
||||
BAD d26b2bd9 test/3pdata/blinksuite/webp-animated-semitransparent1.webp
|
||||
BAD 73e0b22f test/3pdata/blinksuite/webp-animated-semitransparent2.webp
|
||||
BAD d26b2bd9 test/3pdata/blinksuite/webp-animated-semitransparent3.webp
|
||||
BAD 0dba213a test/3pdata/blinksuite/webp-animated-semitransparent4.webp
|
||||
BAD ae7f1fcf test/3pdata/blinksuite/webp-animated.webp
|
||||
OK. eb191e45 test/3pdata/blinksuite/webp-color-no-profile-lossy.webp
|
||||
OK. 60116c2c test/3pdata/blinksuite/webp-color-profile-crash.webp
|
||||
BAD f234aa8a test/3pdata/blinksuite/webp-color-profile-lossless.webp
|
||||
OK. db8c197f test/3pdata/blinksuite/webp-color-profile-lossy-alpha.webp
|
||||
OK. 684e3635 test/3pdata/blinksuite/webp-color-profile-lossy.webp
|
||||
BAD ed67a9a5 test/3pdata/blinksuite/wrong-block-length.gif
|
||||
OK. 577c5c4c test/3pdata/blinksuite/ycbcr-420-fast-int-progressive.jpg
|
||||
OK. bf4cd8e2 test/3pdata/blinksuite/ycbcr-420-float-progressive.jpg
|
||||
|
||||
@@ -1,9 +1,23 @@
|
||||
# Generated by script/print-nia-checksums.sh
|
||||
OK. ca4c0038 test/3pdata/webpsuite/bad_palette_index.webp
|
||||
OK. a92322d0 test/3pdata/webpsuite/alpha_color_cache.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_0_method_0.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_0_method_1.webp
|
||||
OK. d955c04f test/3pdata/webpsuite/alpha_filter_1.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_1_method_0.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_1_method_1.webp
|
||||
OK. d955c04f test/3pdata/webpsuite/alpha_filter_2.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_2_method_0.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_2_method_1.webp
|
||||
OK. d955c04f test/3pdata/webpsuite/alpha_filter_3.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_3_method_0.webp
|
||||
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_3_method_1.webp
|
||||
OK. d955c04f test/3pdata/webpsuite/alpha_no_compression.webp
|
||||
OK. 0ecfd841 test/3pdata/webpsuite/bad_palette_index.webp
|
||||
OK. 79f9ca4a test/3pdata/webpsuite/big_endian_bug_393.webp
|
||||
OK. 3dd065ab test/3pdata/webpsuite/bryce.webp
|
||||
OK. 7794c8b2 test/3pdata/webpsuite/bug3.webp
|
||||
OK. 6fbda804 test/3pdata/webpsuite/color_cache_bits_11.webp
|
||||
BAD d338aed8 test/3pdata/webpsuite/dual_transform.webp
|
||||
OK. 0fecb95b test/3pdata/webpsuite/dual_transform.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/grid.bmp
|
||||
OK. 33b7a1f3 test/3pdata/webpsuite/grid.pgm
|
||||
OK. f79224e7 test/3pdata/webpsuite/grid.png
|
||||
@@ -20,35 +34,39 @@ OK. 289af407 test/3pdata/webpsuite/lossless_color_transform.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_0.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_1.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_10.webp
|
||||
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_11.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_11.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_12.webp
|
||||
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_13.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_13.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_14.webp
|
||||
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_15.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_15.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_2.webp
|
||||
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_3.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_3.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_4.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_5.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_6.webp
|
||||
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_7.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_7.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_8.webp
|
||||
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_9.webp
|
||||
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_9.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_0.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_1.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_10.webp
|
||||
BAD 79781cfb test/3pdata/webpsuite/lossless_vec_2_11.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_11.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_12.webp
|
||||
BAD 79781cfb test/3pdata/webpsuite/lossless_vec_2_13.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_13.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_14.webp
|
||||
BAD 79781cfb test/3pdata/webpsuite/lossless_vec_2_15.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_15.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_2.webp
|
||||
BAD 79781cfb test/3pdata/webpsuite/lossless_vec_2_3.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_3.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_4.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_5.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_6.webp
|
||||
BAD 79781cfb test/3pdata/webpsuite/lossless_vec_2_7.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_7.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_8.webp
|
||||
BAD 79781cfb test/3pdata/webpsuite/lossless_vec_2_9.webp
|
||||
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_9.webp
|
||||
OK. a62056d3 test/3pdata/webpsuite/lossy_alpha1.webp
|
||||
OK. 7d50b493 test/3pdata/webpsuite/lossy_alpha2.webp
|
||||
OK. 3a84e899 test/3pdata/webpsuite/lossy_alpha3.webp
|
||||
OK. a9d10d15 test/3pdata/webpsuite/lossy_alpha4.webp
|
||||
OK. ac62b1e6 test/3pdata/webpsuite/lossy_extreme_probabilities.webp
|
||||
OK. 84ff1fbf test/3pdata/webpsuite/lossy_q0_f100.webp
|
||||
OK. 6957defa test/3pdata/webpsuite/near_lossless_75.webp
|
||||
|
||||
+5
-1
@@ -126,7 +126,11 @@ test_wuffs_jpeg_decode_lower_quality() {
|
||||
&dec, WUFFS_BASE__QUIRK_QUALITY,
|
||||
WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY);
|
||||
}
|
||||
uint64_t m = wuffs_jpeg__decoder__workbuf_len(&dec).min_incl;
|
||||
wuffs_base__range_ii_u64 r = wuffs_jpeg__decoder__workbuf_len(&dec);
|
||||
if (wuffs_base__range_ii_u64__is_empty(&r)) {
|
||||
RETURN_FAIL("q=%d: indeterminate workbuf length", q);
|
||||
}
|
||||
uint64_t m = r.min_incl;
|
||||
if ((q == 0) && (m == 0)) {
|
||||
RETURN_FAIL("q=%d: have %" PRIu64 ", want non-zero", q, m);
|
||||
} else if ((q != 0) && (m != 0)) {
|
||||
|
||||
@@ -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++) {
|
||||
|
||||
+11
-10
@@ -261,9 +261,9 @@ test_wuffs_pixel_buffer_fill_rect() {
|
||||
// Reset to transparent black (or its closest approximation).
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
for (uint32_t x = 0; x < width; x++) {
|
||||
CHECK_STATUS(
|
||||
"set_color_u32_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(&dst_pixbuf, x, y, 0));
|
||||
CHECK_STATUS("set_color_u32_argb_premul_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
|
||||
&dst_pixbuf, x, y, 0));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -275,9 +275,10 @@ test_wuffs_pixel_buffer_fill_rect() {
|
||||
1 + (height / 2))
|
||||
: wuffs_base__make_rect_ie_u32(width / 2, 0,
|
||||
1 + (width / 2), height);
|
||||
CHECK_STATUS("set_color_u32_fill_rect",
|
||||
wuffs_base__pixel_buffer__set_color_u32_fill_rect(
|
||||
&dst_pixbuf, rect, dsts[d].color));
|
||||
CHECK_STATUS(
|
||||
"set_color_u32_argb_premul_fill_rect",
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
|
||||
&dst_pixbuf, rect, dsts[d].color));
|
||||
|
||||
// Check the middle dst pixel.
|
||||
wuffs_base__color_u32_argb_premul want_dst_pixel = dsts[d].color;
|
||||
@@ -447,8 +448,8 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
}
|
||||
|
||||
// Set and check the middle src pixel.
|
||||
CHECK_STATUS("set_color_u32_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
CHECK_STATUS("set_color_u32_argb_premul_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
|
||||
&src_pixbuf, width / 2, height / 2, srcs[s].color));
|
||||
wuffs_base__color_u32_argb_premul have_src_pixel =
|
||||
wuffs_base__pixel_buffer__color_u32_at(&src_pixbuf, width / 2,
|
||||
@@ -483,8 +484,8 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
|
||||
for (size_t b = 0; b < WUFFS_TESTLIB_ARRAY_SIZE(blends); b++) {
|
||||
// Set the middle dst pixel.
|
||||
CHECK_STATUS("set_color_u32_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
CHECK_STATUS("set_color_u32_argb_premul_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
|
||||
&dst_pixbuf, width / 2, height / 2, dsts[d].color));
|
||||
|
||||
// Swizzle.
|
||||
|
||||
+204
-2
@@ -114,6 +114,20 @@ test_wuffs_webp_decode_interface_lossy() {
|
||||
"test/data/bricks-color.lossy.webp", 0, SIZE_MAX, 160, 120, 0xFF032665);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_webp_decode_interface_vp8x_alpha_lossy() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_webp__decoder* dec = &g_webp_decoder;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_webp__decoder__initialize(
|
||||
dec, sizeof *dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
return do_test__wuffs_base__image_decoder(
|
||||
wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(dec),
|
||||
"test/data/hippopotamus.masked-with-muybridge.lossy.webp", 0, SIZE_MAX,
|
||||
36, 28, 0x7D787878);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_webp_decode_many_small_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
@@ -159,10 +173,14 @@ test_wuffs_webp_decode_many_small_reads() {
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
wuffs_base__pixel_buffer__set_color_u32_fill_rect(
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
|
||||
&pb, wuffs_base__make_rect_ie_u32(0, 0, w, h), 0xFF234567);
|
||||
|
||||
uint64_t m = wuffs_webp__decoder__workbuf_len(dec).min_incl;
|
||||
wuffs_base__range_ii_u64 r = wuffs_webp__decoder__workbuf_len(dec);
|
||||
if (wuffs_base__range_ii_u64__is_empty(&r)) {
|
||||
RETURN_FAIL("workbuf_len: indeterminate workbuf length");
|
||||
}
|
||||
uint64_t m = r.min_incl;
|
||||
wuffs_base__slice_u8 workbuf = g_work_slice_u8;
|
||||
if (workbuf.len > m) {
|
||||
workbuf.len = m;
|
||||
@@ -207,6 +225,188 @@ test_wuffs_webp_decode_many_small_reads() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_webp_decode_filter_alph() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
const int width = 41;
|
||||
const int height = 6;
|
||||
|
||||
// src is arbitrary bytes, a subset of a noise texture.
|
||||
const uint8_t src[1][246] = {
|
||||
{
|
||||
0x3C, 0xD4, 0xB6, 0x77, 0x64, 0xAB, 0xEF, 0x03, 0x7D, 0x2F, 0xC0,
|
||||
0x24, 0x79, 0x3E, 0x87, 0x9A, 0x36, 0x7F, 0xBC, 0xF0, 0x42, 0xAF,
|
||||
0x2D, 0x63, 0x22, 0xC3, 0x4E, 0x33, 0xE9, 0x67, 0x9C, 0x01, 0xA9,
|
||||
0x23, 0x50, 0xDD, 0x36, 0x26, 0x4B, 0x94, 0xDC,
|
||||
|
||||
0x14, 0xFB, 0x47, 0x5F, 0xF2, 0x13, 0x53, 0xE7, 0xD7, 0x28, 0x8A,
|
||||
0x07, 0xC6, 0x54, 0xE5, 0xB5, 0x0E, 0x78, 0xAE, 0x14, 0x84, 0xC0,
|
||||
0x20, 0x7D, 0x95, 0xEA, 0x06, 0x8A, 0xFA, 0xC3, 0x70, 0x5C, 0xA6,
|
||||
0x88, 0xCC, 0x09, 0xBA, 0xA6, 0x68, 0x1E, 0xB3,
|
||||
|
||||
0x5A, 0xA5, 0x68, 0xFD, 0x18, 0x90, 0x70, 0x3A, 0xF0, 0x5F, 0xCA,
|
||||
0x44, 0x2B, 0x58, 0x12, 0xBD, 0x43, 0x61, 0xB0, 0x9D, 0x0E, 0x3F,
|
||||
0xEC, 0xB6, 0x36, 0x6E, 0x94, 0xDE, 0x2F, 0xCE, 0x77, 0x92, 0x11,
|
||||
0xE2, 0x37, 0x81, 0xA0, 0x46, 0xCD, 0xDF, 0xA3,
|
||||
|
||||
0x05, 0x97, 0xDC, 0x73, 0xE4, 0x35, 0x6D, 0xF2, 0xC7, 0x1D, 0x56,
|
||||
0x7B, 0xCE, 0x2A, 0x17, 0x54, 0xE9, 0x21, 0x7E, 0x4E, 0xEB, 0x3B,
|
||||
0xF9, 0x47, 0xCA, 0x75, 0xB9, 0xD9, 0x0B, 0x5A, 0x27, 0x8A, 0x4D,
|
||||
0xF5, 0x1F, 0xB7, 0x8E, 0xD0, 0xA4, 0x28, 0x81,
|
||||
|
||||
0xD9, 0x32, 0xE4, 0xA3, 0x8F, 0x65, 0xD8, 0x9B, 0x42, 0xB2, 0x04,
|
||||
0x8B, 0x19, 0xBE, 0x9B, 0x00, 0x51, 0x22, 0x31, 0xF6, 0x7C, 0xBF,
|
||||
0x1A, 0x6C, 0xB0, 0x3C, 0x63, 0x0A, 0xF9, 0x53, 0x15, 0x93, 0x67,
|
||||
0xB8, 0x4B, 0x01, 0xF4, 0x82, 0xBE, 0x11, 0xFD,
|
||||
|
||||
0x61, 0xC4, 0xA4, 0x57, 0x6D, 0x2C, 0xDD, 0xED, 0xB1, 0x92, 0x63,
|
||||
0xA8, 0xE2, 0x35, 0xC8, 0x7F, 0xD5, 0x9D, 0x49, 0x85, 0xAE, 0xE2,
|
||||
0x41, 0x0C, 0xFE, 0x76, 0xC5, 0x20, 0x45, 0xAC, 0x30, 0xCB, 0x73,
|
||||
0x24, 0xEF, 0xDA, 0x80, 0xAB, 0x5E, 0x89, 0x6E,
|
||||
},
|
||||
};
|
||||
|
||||
const uint8_t wants[3][246] = {
|
||||
{
|
||||
0x3C, 0x10, 0xC6, 0x3D, 0xA1, 0x4C, 0x3B, 0x3E, 0xBB, 0xEA, 0xAA,
|
||||
0xCE, 0x47, 0x85, 0x0C, 0xA6, 0xDC, 0x5B, 0x17, 0x07, 0x49, 0xF8,
|
||||
0x25, 0x88, 0xAA, 0x6D, 0xBB, 0xEE, 0xD7, 0x3E, 0xDA, 0xDB, 0x84,
|
||||
0xA7, 0xF7, 0xD4, 0x0A, 0x30, 0x7B, 0x0F, 0xEB,
|
||||
|
||||
0x50, 0x4B, 0x92, 0xF1, 0xE3, 0xF6, 0x49, 0x30, 0x07, 0x2F, 0xB9,
|
||||
0xC0, 0x86, 0xDA, 0xBF, 0x74, 0x82, 0xFA, 0xA8, 0xBC, 0x40, 0x00,
|
||||
0x20, 0x9D, 0x32, 0x1C, 0x22, 0xAC, 0xA6, 0x69, 0xD9, 0x35, 0xDB,
|
||||
0x63, 0x2F, 0x38, 0xF2, 0x98, 0x00, 0x1E, 0xD1,
|
||||
|
||||
0xAA, 0x4F, 0xB7, 0xB4, 0xCC, 0x5C, 0xCC, 0x06, 0xF6, 0x55, 0x1F,
|
||||
0x63, 0x8E, 0xE6, 0xF8, 0xB5, 0xF8, 0x59, 0x09, 0xA6, 0xB4, 0xF3,
|
||||
0xDF, 0x95, 0xCB, 0x39, 0xCD, 0xAB, 0xDA, 0xA8, 0x1F, 0xB1, 0xC2,
|
||||
0xA4, 0xDB, 0x5C, 0xFC, 0x42, 0x0F, 0xEE, 0x91,
|
||||
|
||||
0xAF, 0x46, 0x22, 0x95, 0x79, 0xAE, 0x1B, 0x0D, 0xD4, 0xF1, 0x47,
|
||||
0xC2, 0x90, 0xBA, 0xD1, 0x25, 0x0E, 0x2F, 0xAD, 0xFB, 0xE6, 0x21,
|
||||
0x1A, 0x61, 0x2B, 0xA0, 0x59, 0x32, 0x3D, 0x97, 0xBE, 0x48, 0x95,
|
||||
0x8A, 0xA9, 0x60, 0xEE, 0xBE, 0x62, 0x8A, 0x0B,
|
||||
|
||||
0x88, 0xBA, 0x9E, 0x41, 0xD0, 0x35, 0x0D, 0xA8, 0xEA, 0x9C, 0xA0,
|
||||
0x2B, 0x44, 0x02, 0x9D, 0x9D, 0xEE, 0x10, 0x41, 0x37, 0xB3, 0x72,
|
||||
0x8C, 0xF8, 0xA8, 0xE4, 0x47, 0x51, 0x4A, 0x9D, 0xB2, 0x45, 0xAC,
|
||||
0x64, 0xAF, 0xB0, 0xA4, 0x26, 0xE4, 0xF5, 0xF2,
|
||||
|
||||
0xE9, 0xAD, 0x51, 0xA8, 0x15, 0x41, 0x1E, 0x0B, 0xBC, 0x4E, 0xB1,
|
||||
0x59, 0x3B, 0x70, 0x38, 0xB7, 0x8C, 0x29, 0x72, 0xF7, 0xA5, 0x87,
|
||||
0xC8, 0xD4, 0xD2, 0x48, 0x0D, 0x2D, 0x72, 0x1E, 0x4E, 0x19, 0x8C,
|
||||
0xB0, 0x9F, 0x79, 0xF9, 0xA4, 0x02, 0x8B, 0xF9,
|
||||
},
|
||||
|
||||
{
|
||||
0x3C, 0x10, 0xC6, 0x3D, 0xA1, 0x4C, 0x3B, 0x3E, 0xBB, 0xEA, 0xAA,
|
||||
0xCE, 0x47, 0x85, 0x0C, 0xA6, 0xDC, 0x5B, 0x17, 0x07, 0x49, 0xF8,
|
||||
0x25, 0x88, 0xAA, 0x6D, 0xBB, 0xEE, 0xD7, 0x3E, 0xDA, 0xDB, 0x84,
|
||||
0xA7, 0xF7, 0xD4, 0x0A, 0x30, 0x7B, 0x0F, 0xEB,
|
||||
|
||||
0x50, 0x0B, 0x0D, 0x9C, 0x93, 0x5F, 0x8E, 0x25, 0x92, 0x12, 0x34,
|
||||
0xD5, 0x0D, 0xD9, 0xF1, 0x5B, 0xEA, 0xD3, 0xC5, 0x1B, 0xCD, 0xB8,
|
||||
0x45, 0x05, 0x3F, 0x57, 0xC1, 0x78, 0xD1, 0x01, 0x4A, 0x37, 0x2A,
|
||||
0x2F, 0xC3, 0xDD, 0xC4, 0xD6, 0xE3, 0x2D, 0x9E,
|
||||
|
||||
0xAA, 0xB0, 0x75, 0x99, 0xAB, 0xEF, 0xFE, 0x5F, 0x82, 0x71, 0xFE,
|
||||
0x19, 0x38, 0x31, 0x03, 0x18, 0x2D, 0x34, 0x75, 0xB8, 0xDB, 0xF7,
|
||||
0x31, 0xBB, 0x75, 0xC5, 0x55, 0x56, 0x00, 0xCF, 0xC1, 0xC9, 0x3B,
|
||||
0x11, 0xFA, 0x5E, 0x64, 0x1C, 0xB0, 0x0C, 0x41,
|
||||
|
||||
0xAF, 0x47, 0x51, 0x0C, 0x8F, 0x24, 0x6B, 0x51, 0x49, 0x8E, 0x54,
|
||||
0x94, 0x06, 0x5B, 0x1A, 0x6C, 0x16, 0x55, 0xF3, 0x06, 0xC6, 0x32,
|
||||
0x2A, 0x02, 0x3F, 0x3A, 0x0E, 0x2F, 0x0B, 0x29, 0xE8, 0x53, 0x88,
|
||||
0x06, 0x19, 0x15, 0xF2, 0xEC, 0x54, 0x34, 0xC2,
|
||||
|
||||
0x88, 0x79, 0x35, 0xAF, 0x1E, 0x89, 0x43, 0xEC, 0x8B, 0x40, 0x58,
|
||||
0x1F, 0x1F, 0x19, 0xB5, 0x6C, 0x67, 0x77, 0x24, 0xFC, 0x42, 0xF1,
|
||||
0x44, 0x6E, 0xEF, 0x76, 0x71, 0x39, 0x04, 0x7C, 0xFD, 0xE6, 0xEF,
|
||||
0xBE, 0x64, 0x16, 0xE6, 0x6E, 0x12, 0x45, 0xBF,
|
||||
|
||||
0xE9, 0x3D, 0xD9, 0x06, 0x8B, 0xB5, 0x20, 0xD9, 0x3C, 0xD2, 0xBB,
|
||||
0xC7, 0x01, 0x4E, 0x7D, 0xEB, 0x3C, 0x14, 0x6D, 0x81, 0xF0, 0xD3,
|
||||
0x85, 0x7A, 0xED, 0xEC, 0x36, 0x59, 0x49, 0x28, 0x2D, 0xB1, 0x62,
|
||||
0xE2, 0x53, 0xF0, 0x66, 0x19, 0x70, 0xCE, 0x2D,
|
||||
},
|
||||
|
||||
{
|
||||
0x3C, 0x10, 0xC6, 0x3D, 0xA1, 0x4C, 0x3B, 0x3E, 0xBB, 0xEA, 0xAA,
|
||||
0xCE, 0x47, 0x85, 0x0C, 0xA6, 0xDC, 0x5B, 0x17, 0x07, 0x49, 0xF8,
|
||||
0x25, 0x88, 0xAA, 0x6D, 0xBB, 0xEE, 0xD7, 0x3E, 0xDA, 0xDB, 0x84,
|
||||
0xA7, 0xF7, 0xD4, 0x0A, 0x30, 0x7B, 0x0F, 0xEB,
|
||||
|
||||
0x50, 0x1F, 0x1C, 0x5F, 0xB5, 0x73, 0xB5, 0x9F, 0xD6, 0x27, 0x8A,
|
||||
0xB5, 0xF4, 0x53, 0xE5, 0xB4, 0xF8, 0xEF, 0x59, 0x5D, 0x23, 0x92,
|
||||
0x20, 0x00, 0xB7, 0x64, 0xB8, 0x75, 0x58, 0xC3, 0x6F, 0xCC, 0x1B,
|
||||
0xC6, 0xCB, 0xB1, 0xBA, 0x86, 0x39, 0x1E, 0xAD,
|
||||
|
||||
0xAA, 0x1E, 0x83, 0xC3, 0x17, 0x90, 0x42, 0x66, 0x8D, 0x5F, 0x8C,
|
||||
0xFB, 0x2A, 0x58, 0xFC, 0x88, 0x0F, 0x67, 0xB0, 0x51, 0x25, 0xD3,
|
||||
0x4D, 0xE3, 0x35, 0x6E, 0x56, 0xF1, 0x03, 0x3C, 0x77, 0x66, 0x11,
|
||||
0x9E, 0xDA, 0x41, 0xEA, 0xFC, 0x7C, 0x40, 0x72,
|
||||
|
||||
0xAF, 0xBA, 0xDB, 0x72, 0xE4, 0x34, 0x6D, 0x83, 0x71, 0x60, 0xE3,
|
||||
0x7A, 0xCE, 0x26, 0xE1, 0xC1, 0x31, 0xAA, 0x71, 0x60, 0x1F, 0x08,
|
||||
0xF9, 0x46, 0xCA, 0x74, 0x15, 0x89, 0x0B, 0x9E, 0x00, 0x8A, 0x82,
|
||||
0xF4, 0x1E, 0xB7, 0x8D, 0x6F, 0xA4, 0x90, 0x43,
|
||||
|
||||
0x88, 0xC5, 0xCA, 0x04, 0x05, 0x65, 0x76, 0x27, 0x57, 0xF8, 0x03,
|
||||
0x8B, 0xF8, 0x0E, 0x64, 0x44, 0x51, 0xEC, 0xE4, 0xC9, 0x04, 0xBF,
|
||||
0x19, 0x6C, 0xA0, 0x86, 0x8A, 0x08, 0xF9, 0x52, 0x15, 0x32, 0x91,
|
||||
0xB7, 0x4B, 0xE5, 0xAF, 0x13, 0x06, 0x11, 0xFD,
|
||||
|
||||
0xE9, 0xC3, 0x6C, 0x57, 0xC5, 0x2B, 0x19, 0xED, 0xB0, 0x91, 0x63,
|
||||
0x93, 0xE1, 0x35, 0x53, 0xB2, 0x94, 0x9C, 0xDD, 0x47, 0xAE, 0xE1,
|
||||
0x7C, 0xDB, 0xFD, 0x59, 0x22, 0x20, 0x44, 0xAC, 0x9F, 0x87, 0x59,
|
||||
0xA3, 0x26, 0x9A, 0xE4, 0xF3, 0x44, 0xD8, 0x6D,
|
||||
},
|
||||
};
|
||||
|
||||
wuffs_webp__decoder dec = {0};
|
||||
dec.private_impl.f_width = width;
|
||||
dec.private_impl.f_height = height;
|
||||
|
||||
for (int filter = 0; filter < 3; filter++) {
|
||||
uint8_t buf[246];
|
||||
memcpy(&buf[0], &src[0][0], 246);
|
||||
wuffs_base__slice_u8 s = wuffs_base__make_slice_u8(&buf[0], 246);
|
||||
|
||||
switch (filter) {
|
||||
case 0:
|
||||
wuffs_webp__decoder__filter_alph_horizontal(&dec, s);
|
||||
break;
|
||||
case 1:
|
||||
wuffs_webp__decoder__filter_alph_vertical(&dec, s);
|
||||
break;
|
||||
case 2:
|
||||
wuffs_webp__decoder__filter_alph_gradient(&dec, s);
|
||||
break;
|
||||
}
|
||||
|
||||
if (0 == memcmp(&buf[0], &wants[filter][0], 246)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (int y = 0; y < height; y++) {
|
||||
for (int x = 0; x < width; x++) {
|
||||
int i = (y * width) + x;
|
||||
int have = buf[i];
|
||||
int want = wants[filter][i];
|
||||
if (have != want) {
|
||||
RETURN_FAIL("filter=%d, y=%d, x=%d: have 0x%02X, want 0x%02X", filter,
|
||||
y, x, have, want);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "unreachable";
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// ---------------- Mimic Tests
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
@@ -518,8 +718,10 @@ bench_mimic_webp_lossy_decode_image_4002k_24bpp() {
|
||||
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_webp_decode_filter_alph,
|
||||
test_wuffs_webp_decode_interface_lossless,
|
||||
test_wuffs_webp_decode_interface_lossy,
|
||||
test_wuffs_webp_decode_interface_vp8x_alpha_lossy,
|
||||
test_wuffs_webp_decode_many_small_reads,
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
@@ -1237,6 +1237,17 @@ do_test__wuffs_base__image_decoder(
|
||||
CHECK_STATUS("decode_image_config",
|
||||
wuffs_base__image_decoder__decode_image_config(b, &ic, &src));
|
||||
|
||||
wuffs_base__slice_u8 workbuf = g_work_slice_u8;
|
||||
wuffs_base__range_ii_u64 workbuf_len =
|
||||
wuffs_base__image_decoder__workbuf_len(b);
|
||||
if (workbuf_len.min_incl > workbuf_len.max_incl) {
|
||||
return "indeterminate workbuf_len";
|
||||
}
|
||||
if (workbuf_len.max_incl > workbuf.len) {
|
||||
return "workbuf_len is too large";
|
||||
}
|
||||
workbuf.len = workbuf_len.max_incl;
|
||||
|
||||
uint32_t have_width = wuffs_base__pixel_config__width(&ic.pixcfg);
|
||||
if (have_width != want_width) {
|
||||
RETURN_FAIL("width: have %" PRIu32 ", want %" PRIu32, have_width,
|
||||
@@ -1254,9 +1265,9 @@ do_test__wuffs_base__image_decoder(
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
CHECK_STATUS("decode_frame", wuffs_base__image_decoder__decode_frame(
|
||||
b, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
g_work_slice_u8, NULL));
|
||||
CHECK_STATUS("decode_frame",
|
||||
wuffs_base__image_decoder__decode_frame(
|
||||
b, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, workbuf, NULL));
|
||||
|
||||
uint64_t n = wuffs_base__pixel_config__pixbuf_len(&ic.pixcfg);
|
||||
if (n < 4) {
|
||||
@@ -1297,7 +1308,7 @@ do_test__wuffs_base__io_transformer(wuffs_base__io_transformer* b,
|
||||
wuffs_base__range_ii_u64 workbuf_len =
|
||||
wuffs_base__io_transformer__workbuf_len(b);
|
||||
if (workbuf_len.min_incl > workbuf_len.max_incl) {
|
||||
return "inconsistent workbuf_len";
|
||||
return "indeterminate workbuf_len";
|
||||
}
|
||||
if (workbuf_len.max_incl > IO_BUFFER_ARRAY_SIZE) {
|
||||
return "workbuf_len is too large";
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 836 B |
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
After Width: | Height: | Size: 1.0 KiB |
Binary file not shown.
Binary file not shown.
@@ -17,6 +17,7 @@ OK. 14a5b4b0 test/data/animated-red-blue.000003.nie
|
||||
OK. 76e40058 test/data/animated-red-blue.apng
|
||||
OK. 76e40058 test/data/animated-red-blue.gif
|
||||
OK. 76e40058 test/data/animated-red-blue.nia
|
||||
BAD c4a44cef test/data/animated-red-blue.webp
|
||||
OK. f9a10dac test/data/artificial-gif/background-color.gif
|
||||
OK. 36e7d9c7 test/data/artificial-gif/empty-palette.gif
|
||||
OK. db4c30eb test/data/artificial-gif/frame-out-of-bounds.gif
|
||||
@@ -134,6 +135,7 @@ OK. 56cf6ae1 test/data/hippopotamus.lossy.webp
|
||||
OK. 2535637e test/data/hippopotamus.masked-with-muybridge.etc2.bgra-binary.pkm
|
||||
OK. 720180ee test/data/hippopotamus.masked-with-muybridge.etc2.bgra-nonpremul.pkm
|
||||
OK. d3bbed27 test/data/hippopotamus.masked-with-muybridge.gif
|
||||
OK. 1d8cd8b2 test/data/hippopotamus.masked-with-muybridge.lossy.webp
|
||||
OK. 7e6acf01 test/data/hippopotamus.masked-with-muybridge.png
|
||||
OK. dcbb225a test/data/hippopotamus.nie
|
||||
OK. 57d9a4dd test/data/hippopotamus.pgm
|
||||
|
||||
Reference in new issue
Block a user