Compare commits

...
Author SHA1 Message Date
Nigel Tao e88e28259e wuffs gen -version=0.3.0-beta.7 2021-07-18 11:36:39 +10:00
Nigel Tao 6a30c1ede0 Inline wuffs_aux::DecodeJson work_buf variable 2021-07-18 11:25:46 +10:00
Nigel Tao 9c07523a84 Have wuffs_aux::DecodeJson consume trailing filler
Prior to this commit, wuffs_aux::DecodeJson would almost always consume
(optional) trailing filler, but in rare coincidences, it might not if a
wuffs_base__suspension__short_write coroutine suspension was needed
between the last token of the actual JSON value and the first token of
the filler after that JSON value.

This commit should change behavior only if the wuffs_aux::DecodeJson
caller had opted into WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER or
WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF.

Also remove an unnecessary std::move on a size_t typed value.
2021-07-18 11:12:41 +10:00
Nigel Tao 816475b285 Add "b" (for "binary") to fopen calls
Updates #50
2021-07-07 20:28:35 +10:00
Nigel Tao d0451190ca wuffs gen -version=0.3.0-beta.6 2021-07-05 21:51:37 +10:00
Nigel Tao 3842c519c9 Delete the WUFFS_BASE__FALLTHROUGH macro
Getting it to work on various compilers has been more trouble than it's
worth. The previous commit ignores "-Wimplicit-fallthrough" instead.
2021-07-05 21:40:25 +10:00
Nigel Tao ea50956b5a Ignore "-Wimplicit-fallthrough" 2021-07-05 21:40:25 +10:00
Nigel Tao fd90553a8f Tweak the WUFFS_BASE__FALLTHROUGH macro
When compiling with "-Werror,-Wimplicit-fallthrough", commit c90cc7b6
tweaked WUFFS_BASE__FALLTHROUGH to work with newer clang compilers, when
defined(__cplusplus) is false, but inadvertently broke older clang
compilers, when __has_attribute(fallthrough) is false.

This commit reverts some of c90cc7b6 to handle more cases. The next two
commits will delete the WUFFS_BASE__FALLTHROUGH macro entirely and
render this commit redundant, as the whole business is proving more
trouble than it's worth. But it's checked into the commit history in
case somebody in the future wants to revive WUFFS_BASE__FALLTHROUGH.
2021-07-05 21:40:18 +10:00
Nigel Tao 963a574f7d wuffs gen -version=0.3.0-beta.5 2021-07-02 13:44:55 +10:00
Nigel Tao edd87f0eda Merge pull request #49 from pkasting/main
Fix -Wunreachable-code-aggressive.
2021-06-30 10:10:05 +10:00
Peter Kasting 56d5aa0907 Fix -Wunreachable-code-aggressive.
Bug: chromium:1066980
2021-06-29 12:00:03 -07:00
Nigel Tao 6bfaf0f008 wuffs gen -version=0.3.0-beta.4 2021-06-28 10:11:25 +10:00
Nigel Tao b9a10d051a Fix -Werror=conversion in fundamental-public.h 2021-06-28 10:10:13 +10:00
Nigel Tao 7f93a94e7a Tweak WUFFS_BASE__FALLTHROUGH comment 2021-06-28 10:07:01 +10:00
Nigel Tao a0698fc1a2 Add Peter Kasting to CONTRIBUTORS
"Google Inc." is already in AUTHORS.
2021-06-28 10:00:13 +10:00
Nigel Tao d8796aa6d9 Add wuffs_base__uxx__rotate_etc functions 2021-06-28 09:59:32 +10:00
Nigel Tao a12771373e Merge pull request #48 from pkasting/main
Fix -Wimplicit-fallthrough for Clang.
2021-06-28 09:58:23 +10:00
Peter Kasting c90cc7b657 Fix -Wimplicit-fallthrough for Clang.
WUFFS_BASE__FALLTHROUGH was not defined because the generated output is
C (so __cplusplus is never defined) and Clang was explicitly excluded
from the __attribute__ case (though it would have worked).

Instead test for the availability of the fallthrough attribute directly,
which should be more portable.

Bug: chromium:995993
2021-06-26 17:12:56 -07:00
Nigel Tao b2b8961126 wuffs gen -version=0.3.0-beta.3 2021-06-25 15:36:54 +10:00
Nigel Tao f6945c0612 Remove unnecessary "goto ok;" in generated C code 2021-06-25 14:47:10 +10:00
Nigel Tao 76e6872498 Have clang-cl ignore unused-function etc warnings 2021-06-25 13:51:27 +10:00
Nigel Tao 98c66ef761 wuffs gen -version=0.3.0-beta.2 2021-06-24 22:43:15 +10:00
Nigel Tao 91857f4c4b Disable cpu_arch specific code for Native Client 2021-06-24 22:40:54 +10:00
Nigel Tao 08797bc713 Have "x86_avx2" require PCLMUL, POPCNT and SSE4.2
The std/crc32 benchmark numbers get worse. The benches still run AVX2
code, but it runs slower for an unknown reason. The std/gzip and std/png
benchmark numbers are mixed.

Still, it's cleaner for Wuffs' "x86_avx2" to be a superset of
"x86_sse42" (and apart from PCLMUL, they're now similar to Clang 12 and
GCC 11's "x86-64-v3" and "x86-64-v2" micro-architecture feature levels).
Maybe future compiler versions can claw back the std/crc32 performance.

On a mid-range x86_64 laptop (2016, Skylake):

name                                                               old speed      new speed      delta

wuffs_crc32_ieee_10k/clang9                                        8.07GB/s ± 0%  7.61GB/s ± 1%   -5.72%  (p=0.000 n=8+8)
wuffs_crc32_ieee_100k/clang9                                       11.0GB/s ± 1%   9.7GB/s ± 3%  -11.45%  (p=0.000 n=7+8)

wuffs_crc32_ieee_10k/gcc10                                         9.77GB/s ± 1%  7.72GB/s ± 1%  -21.00%  (p=0.000 n=10+9)
wuffs_crc32_ieee_100k/gcc10                                        12.7GB/s ± 2%  11.9GB/s ± 2%   -5.84%  (p=0.000 n=9+9)

wuffs_gzip_decode_10k/clang9                                        217MB/s ± 2%   221MB/s ± 0%   +1.80%  (p=0.000 n=10+8)
wuffs_gzip_decode_100k/clang9                                       280MB/s ± 1%   283MB/s ± 0%   +1.38%  (p=0.000 n=9+8)

wuffs_gzip_decode_10k/gcc10                                         215MB/s ± 1%   220MB/s ± 1%   +2.52%  (p=0.000 n=10+9)
wuffs_gzip_decode_100k/gcc10                                        272MB/s ± 0%   274MB/s ± 1%   +0.74%  (p=0.000 n=9+10)

wuffs_png_decode_image_19k_8bpp/clang9                              136MB/s ± 0%   142MB/s ± 0%   +3.95%  (p=0.000 n=8+8)
wuffs_png_decode_image_40k_24bpp/clang9                             171MB/s ± 1%   172MB/s ± 0%   +0.84%  (p=0.000 n=10+8)
wuffs_png_decode_image_77k_8bpp/clang9                              492MB/s ± 3%   501MB/s ± 2%   +1.88%  (p=0.009 n=10+10)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9            456MB/s ± 1%   461MB/s ± 1%   +1.04%  (p=0.000 n=9+9)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9            439MB/s ± 1%   440MB/s ± 3%     ~     (p=0.173 n=8+10)
wuffs_png_decode_image_4002k_24bpp/clang9                           172MB/s ± 1%   174MB/s ± 1%   +1.29%  (p=0.005 n=10+10)

wuffs_png_decode_image_19k_8bpp/gcc10                               152MB/s ± 0%   149MB/s ± 1%   -1.92%  (p=0.000 n=9+9)
wuffs_png_decode_image_40k_24bpp/gcc10                              184MB/s ± 0%   186MB/s ± 1%   +1.37%  (p=0.000 n=8+9)
wuffs_png_decode_image_77k_8bpp/gcc10                               550MB/s ± 1%   542MB/s ± 2%   -1.46%  (p=0.000 n=10+10)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10             473MB/s ± 1%   478MB/s ± 1%   +1.23%  (p=0.000 n=9+10)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10             453MB/s ± 1%   458MB/s ± 1%   +0.91%  (p=0.000 n=9+10)
wuffs_png_decode_image_4002k_24bpp/gcc10                            185MB/s ± 2%   188MB/s ± 0%   +1.82%  (p=0.000 n=9+8)
2021-06-22 13:27:25 +10:00
Nigel Tao ec32eb3eb7 Add fuzz/c/std/gif_fuzzer.c quirks 2021-06-18 22:37:29 +10:00
Nigel Tao a51867dc63 Fix "forseen" typo 2021-05-19 21:34:09 +10:00
Nigel Tao 3358730f6f Have std/png reject zero width or height 2021-05-11 12:34:19 +10:00
Nigel Tao 97f5bec0e3 Fix doc/spec/rac-related-work.md typo 2021-05-04 13:29:22 +10:00
Nigel Tao b0826d2ab7 Add test/data/archive.*
$ 7z a     archive.7z \
    artificial/0.bytes github-tags.json hello.sh non-ascii/αβ.txt \
    non-ascii/😻.txt pjw-thumbnail.png romeo.txt romeo.txt.gz
$ zip      archive.zip     etc etc
$ rar a    archive.rar     etc etc
$ tar cvf  archive.tar     etc etc
$ tar cvjf archive.tar.bz2 etc etc
$ tar cvzf archive.tar.gz  etc etc
$ lcab etc etc archive.cab

And after curating a data/ directory (without non-ascii/😻.txt):

$ genisoimage -v -J -r -V WUFFS_TEST_DATA_SUBSET -o archive.iso data/
2021-05-03 22:25:35 +10:00
Nigel Tao a0984dcdd3 Limit the number of coroutines per type to 0x7FFF 2021-05-02 16:50:29 +10:00
Nigel Tao b8f87debe3 Tweak wuffs_base__cpu_arch__have_foo_bar impl 2021-04-29 17:52:10 +10:00
Nigel Tao e77d73e3ce Add std/adler32 bench comment for the roll back 2021-04-28 22:38:10 +10:00
Nigel Tao 0a6cce5e0e Tweak some adler32 hasher.up_x86_sse42 var names 2021-04-28 00:32:32 +10:00
Nigel Tao abd37fa3f8 Roll back 'Add std/adler32 hasher.up_x86_avx2'
See the previous commit for the rationale.
2021-04-28 00:26:54 +10:00
Nigel Tao baec831fc8 Add std/adler32 hasher.up_x86_avx2
While the std/adler32 benchmarks got better, the std/zlib and std/png
benchmarks got worse.

This commit will soon be followed by a rollback, but it is committed
anyway so that we can refer to these numbers in the git log.

Binary size, before:
4056 gen/lib/c/clang-9-dynamic/wuffs-std-adler32.lo
4104 gen/lib/c/clang-9-static/wuffs-std-adler32.o
4624 gen/lib/c/gcc-dynamic/wuffs-std-adler32.lo
4680 gen/lib/c/gcc-static/wuffs-std-adler32.o

After:
4952 gen/lib/c/clang-9-dynamic/wuffs-std-adler32.lo
5016 gen/lib/c/clang-9-static/wuffs-std-adler32.o
5512 gen/lib/c/gcc-dynamic/wuffs-std-adler32.lo
5576 gen/lib/c/gcc-static/wuffs-std-adler32.o

name                                                      old speed      new speed      delta

wuffs_adler32_10k/clang9                                  11.5GB/s ± 1%  15.0GB/s ± 5%  +30.73%  (p=0.000 n=9+10)
wuffs_adler32_100k/clang9                                 13.5GB/s ± 1%  15.6GB/s ±14%  +16.06%  (p=0.001 n=9+10)

wuffs_adler32_10k/gcc10                                   11.3GB/s ± 2%  15.6GB/s ± 1%  +38.27%  (p=0.000 n=9+9)
wuffs_adler32_100k/gcc10                                  11.3GB/s ± 1%  19.4GB/s ± 1%  +71.20%  (p=0.000 n=7+9)

wuffs_zlib_decode_10k/clang9                               223MB/s ± 1%   216MB/s ± 2%   -3.45%  (p=0.000 n=10+10)
wuffs_zlib_decode_100k/clang9                              285MB/s ± 1%   284MB/s ± 1%     ~     (p=0.243 n=9+10)

wuffs_zlib_decode_10k/gcc10                                232MB/s ± 1%   216MB/s ± 1%   -6.70%  (p=0.000 n=10+9)
wuffs_zlib_decode_100k/gcc10                               291MB/s ± 1%   280MB/s ± 1%   -3.70%  (p=0.000 n=9+8)

wuffs_png_decode_image_19k_8bpp/clang9                     152MB/s ± 1%   143MB/s ± 3%   -5.89%  (p=0.000 n=8+9)
wuffs_png_decode_image_40k_24bpp/clang9                    171MB/s ± 1%   173MB/s ± 1%     ~     (p=0.094 n=9+9)
wuffs_png_decode_image_77k_8bpp/clang9                     541MB/s ± 1%   509MB/s ± 1%   -5.77%  (p=0.000 n=8+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   479MB/s ± 1%   464MB/s ± 3%   -3.20%  (p=0.000 n=8+10)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   461MB/s ± 1%   452MB/s ± 1%   -2.02%  (p=0.000 n=8+10)
wuffs_png_decode_image_4002k_24bpp/clang9                  177MB/s ± 1%   175MB/s ± 2%   -1.14%  (p=0.004 n=10+10)

wuffs_png_decode_image_19k_8bpp/gcc10                      159MB/s ± 1%   153MB/s ± 1%   -3.54%  (p=0.000 n=8+10)
wuffs_png_decode_image_40k_24bpp/gcc10                     188MB/s ± 1%   187MB/s ± 1%   -0.47%  (p=0.021 n=10+9)
wuffs_png_decode_image_77k_8bpp/gcc10                      557MB/s ± 0%   546MB/s ± 4%   -1.94%  (p=0.000 n=8+10)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10    510MB/s ± 0%   493MB/s ± 0%   -3.33%  (p=0.000 n=10+9)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10    486MB/s ± 1%   478MB/s ± 0%   -1.77%  (p=0.000 n=8+9)
wuffs_png_decode_image_4002k_24bpp/gcc10                   189MB/s ± 1%   187MB/s ± 1%   -1.26%  (p=0.000 n=10+10)
2021-04-28 00:18:20 +10:00
Nigel Tao 8ccaf81e96 Fix s/bit_BMI2/bit_AVX2/ typo 2021-04-26 22:52:27 +10:00
Nigel Tao be546c3587 Be able to test and bench the libdeflate library
name                                                               old speed      new speed       delta

wuffs_adler32_10k/clang9                                           11.4GB/s ± 2%   11.6GB/s ± 2%     +1.26%  (p=0.013 n=9+10)
wuffs_adler32_100k/clang9                                          13.7GB/s ± 1%   13.6GB/s ± 1%       ~     (p=0.277 n=8+9)

wuffs_adler32_10k/gcc10                                            12.2GB/s ± 0%   11.4GB/s ± 1%     -7.01%  (p=0.000 n=8+9)
wuffs_adler32_100k/gcc10                                           12.0GB/s ± 1%   11.7GB/s ± 1%     -2.80%  (p=0.000 n=9+9)

mimic_adler32_10k                                                  1.91GB/s ± 0%  25.24GB/s ± 1%  +1218.88%  (p=0.000 n=9+9)
mimic_adler32_100k                                                 1.87GB/s ± 0%  22.94GB/s ± 1%  +1126.66%  (p=0.000 n=10+10)

wuffs_crc32_ieee_10k/clang9                                        7.81GB/s ± 0%   7.70GB/s ± 0%     -1.41%  (p=0.000 n=8+8)
wuffs_crc32_ieee_100k/clang9                                       10.0GB/s ± 2%   10.6GB/s ± 1%     +5.25%  (p=0.000 n=7+8)

wuffs_crc32_ieee_10k/gcc10                                         9.80GB/s ± 1%  10.03GB/s ± 1%     +2.35%  (p=0.000 n=9+10)
wuffs_crc32_ieee_100k/gcc10                                        13.1GB/s ± 0%   12.9GB/s ± 0%     -1.52%  (p=0.000 n=10+9)

mimic_crc32_ieee_10k                                                842MB/s ± 1%  12952MB/s ± 0%  +1437.67%  (p=0.000 n=10+9)
mimic_crc32_ieee_100k                                               838MB/s ± 2%  13363MB/s ± 1%  +1493.79%  (p=0.000 n=10+9)

wuffs_deflate_decode_1k_full_init/clang9                            101MB/s ± 0%    106MB/s ± 1%     +4.22%  (p=0.000 n=8+10)
wuffs_deflate_decode_1k_part_init/clang9                            119MB/s ± 1%    121MB/s ± 1%     +1.39%  (p=0.000 n=10+10)
wuffs_deflate_decode_10k_full_init/clang9                           222MB/s ± 0%    215MB/s ± 0%     -3.24%  (p=0.000 n=9+9)
wuffs_deflate_decode_10k_part_init/clang9                           228MB/s ± 0%    218MB/s ± 3%     -4.47%  (p=0.000 n=10+9)
wuffs_deflate_decode_100k_just_one_read/clang9                      291MB/s ± 0%    286MB/s ± 3%     -1.85%  (p=0.000 n=10+10)
wuffs_deflate_decode_100k_many_big_reads/clang9                     189MB/s ± 1%    178MB/s ± 1%     -5.50%  (p=0.000 n=10+10)

wuffs_deflate_decode_1k_full_init/gcc10                            99.1MB/s ± 2%  102.1MB/s ± 1%     +3.12%  (p=0.000 n=10+9)
wuffs_deflate_decode_1k_part_init/gcc10                             117MB/s ± 1%    121MB/s ± 1%     +3.41%  (p=0.000 n=10+9)
wuffs_deflate_decode_10k_full_init/gcc10                            215MB/s ± 1%    218MB/s ± 1%     +1.55%  (p=0.000 n=10+10)
wuffs_deflate_decode_10k_part_init/gcc10                            220MB/s ± 1%    225MB/s ± 0%     +2.08%  (p=0.000 n=10+8)
wuffs_deflate_decode_100k_just_one_read/gcc10                       281MB/s ± 1%    279MB/s ± 1%       ~     (p=0.105 n=10+10)
wuffs_deflate_decode_100k_many_big_reads/gcc10                      182MB/s ± 1%    180MB/s ± 0%     -1.14%  (p=0.000 n=9+7)

mimic_deflate_decode_1k_full_init                                   138MB/s ± 1%    179MB/s ± 1%    +29.56%  (p=0.000 n=10+10)
mimic_deflate_decode_10k_full_init                                  155MB/s ± 2%    268MB/s ± 1%    +72.15%  (p=0.000 n=9+10)
mimic_deflate_decode_100k_just_one_read                             191MB/s ± 0%    269MB/s ± 1%    +40.38%  (p=0.000 n=10+10)
mimic_deflate_decode_100k_many_big_reads                            147MB/s ± 1%         skipped

wuffs_gzip_decode_10k/clang9                                        218MB/s ± 1%    211MB/s ± 1%     -3.18%  (p=0.000 n=8+9)
wuffs_gzip_decode_100k/clang9                                       282MB/s ± 0%    282MB/s ± 0%       ~     (p=0.113 n=9+9)

wuffs_gzip_decode_10k/gcc10                                         215MB/s ± 1%    231MB/s ± 1%     +7.34%  (p=0.000 n=10+10)
wuffs_gzip_decode_100k/gcc10                                        271MB/s ± 2%    293MB/s ± 0%     +7.84%  (p=0.000 n=10+9)

mimic_gzip_decode_10k                                               132MB/s ± 1%    263MB/s ± 0%    +99.23%  (p=0.000 n=10+9)
mimic_gzip_decode_100k                                              156MB/s ± 1%    262MB/s ± 3%    +67.93%  (p=0.000 n=9+10)

wuffs_zlib_decode_10k/clang9                                        223MB/s ± 0%    212MB/s ± 1%     -5.05%  (p=0.000 n=7+10)
wuffs_zlib_decode_100k/clang9                                       280MB/s ± 0%    280MB/s ± 0%       ~     (p=0.867 n=8+7)

wuffs_zlib_decode_10k/gcc10                                         232MB/s ± 2%    220MB/s ± 1%     -5.42%  (p=0.000 n=10+10)
wuffs_zlib_decode_100k/gcc10                                        286MB/s ± 5%    277MB/s ± 0%     -2.88%  (p=0.002 n=10+9)

mimic_zlib_decode_10k                                               145MB/s ± 0%    266MB/s ± 0%    +84.02%  (p=0.000 n=10+9)
mimic_zlib_decode_100k                                              173MB/s ± 1%    265MB/s ± 2%    +53.31%  (p=0.000 n=10+9)
2021-04-20 23:33:58 +10:00
Nigel Tao 5764f77913 Have std/png produce PIXEL_FORMAT__Y_16LE
Updates #46
2021-04-16 14:34:48 +10:00
Nigel Tao 2dddd388bc Add crc32.ieee_hasher.up_x86_avx2
name                                                      old speed      new speed      delta

wuffs_crc32_ieee_10k/clang9                               8.42GB/s ± 1%  8.12GB/s ± 1%   -3.55%  (p=0.000 n=9+8)
wuffs_crc32_ieee_100k/clang9                              11.0GB/s ± 1%  10.9GB/s ± 1%     ~     (p=0.931 n=9+9)

wuffs_crc32_ieee_10k/gcc10                                9.20GB/s ± 0%  9.71GB/s ± 0%   +5.54%  (p=0.000 n=8+10)
wuffs_crc32_ieee_100k/gcc10                               11.9GB/s ± 2%  13.1GB/s ± 1%  +10.22%  (p=0.000 n=10+8)

wuffs_gzip_decode_10k/clang9                               219MB/s ± 1%   218MB/s ± 2%     ~     (p=0.497 n=9+10)
wuffs_gzip_decode_100k/clang9                              283MB/s ± 2%   281MB/s ± 1%     ~     (p=0.063 n=10+10)

wuffs_gzip_decode_10k/gcc10                                224MB/s ± 1%   223MB/s ± 1%     ~     (p=0.489 n=9+9)
wuffs_gzip_decode_100k/gcc10                               285MB/s ± 4%   290MB/s ± 0%   +1.68%  (p=0.004 n=10+8)

wuffs_png_decode_image_19k_8bpp/clang9                     138MB/s ± 2%   138MB/s ± 1%     ~     (p=0.156 n=10+9)
wuffs_png_decode_image_40k_24bpp/clang9                    171MB/s ± 2%   172MB/s ± 1%     ~     (p=0.971 n=10+10)
wuffs_png_decode_image_77k_8bpp/clang9                     495MB/s ± 4%   504MB/s ± 1%   +1.79%  (p=0.000 n=9+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   457MB/s ± 4%   463MB/s ± 0%   +1.35%  (p=0.002 n=9+9)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   435MB/s ± 5%   445MB/s ± 1%   +2.31%  (p=0.000 n=10+9)
wuffs_png_decode_image_4002k_24bpp/clang9                  172MB/s ± 2%   174MB/s ± 1%     ~     (p=0.053 n=10+9)

wuffs_png_decode_image_19k_8bpp/gcc10                      157MB/s ± 1%   157MB/s ± 1%     ~     (p=0.549 n=9+10)
wuffs_png_decode_image_40k_24bpp/gcc10                     187MB/s ± 1%   186MB/s ± 1%     ~     (p=0.182 n=10+9)
wuffs_png_decode_image_77k_8bpp/gcc10                      554MB/s ± 1%   559MB/s ± 0%   +0.84%  (p=0.000 n=9+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10    502MB/s ± 1%   500MB/s ± 0%   -0.38%  (p=0.011 n=10+10)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10    481MB/s ± 1%   478MB/s ± 0%   -0.46%  (p=0.002 n=8+9)
wuffs_png_decode_image_4002k_24bpp/gcc10                   189MB/s ± 2%   190MB/s ± 0%   +0.62%  (p=0.008 n=10+9)
2021-04-09 23:12:32 +10:00
Nigel Tao 1dd7ad4413 Optimize std/deflate decoding for RLE sections
name                                                      old speed      new speed      delta

wuffs_deflate_decode_1k_full_init/clang9                   104MB/s ± 1%   104MB/s ± 1%     ~     (p=0.161 n=9+9)
wuffs_deflate_decode_1k_part_init/clang9                   121MB/s ± 1%   119MB/s ± 1%   -0.92%  (p=0.000 n=9+9)
wuffs_deflate_decode_10k_full_init/clang9                  223MB/s ± 1%   223MB/s ± 1%     ~     (p=0.796 n=9+9)
wuffs_deflate_decode_10k_part_init/clang9                  230MB/s ± 1%   228MB/s ± 2%     ~     (p=0.065 n=10+9)
wuffs_deflate_decode_100k_just_one_read/clang9             279MB/s ± 1%   292MB/s ± 0%   +4.78%  (p=0.000 n=9+8)
wuffs_deflate_decode_100k_many_big_reads/clang9            178MB/s ± 5%   189MB/s ± 2%   +6.41%  (p=0.000 n=10+10)

wuffs_deflate_decode_1k_full_init/gcc10                    103MB/s ± 1%   102MB/s ± 1%   -0.57%  (p=0.022 n=10+9)
wuffs_deflate_decode_1k_part_init/gcc10                    122MB/s ± 1%   121MB/s ± 3%   -1.46%  (p=0.000 n=10+9)
wuffs_deflate_decode_10k_full_init/gcc10                   235MB/s ± 1%   231MB/s ± 1%   -1.34%  (p=0.000 n=10+8)
wuffs_deflate_decode_10k_part_init/gcc10                   242MB/s ± 1%   239MB/s ± 0%   -1.40%  (p=0.001 n=9+8)
wuffs_deflate_decode_100k_just_one_read/gcc10              300MB/s ± 4%   297MB/s ± 2%     ~     (p=0.156 n=10+9)
wuffs_deflate_decode_100k_many_big_reads/gcc10             193MB/s ± 2%   197MB/s ± 1%   +2.29%  (p=0.000 n=10+9)

wuffs_gzip_decode_10k/clang9                               220MB/s ± 1%   219MB/s ± 1%     ~     (p=0.605 n=9+9)
wuffs_gzip_decode_100k/clang9                              269MB/s ± 2%   283MB/s ± 2%   +4.98%  (p=0.000 n=9+10)

wuffs_gzip_decode_10k/gcc10                                227MB/s ± 1%   224MB/s ± 1%   -1.42%  (p=0.000 n=10+9)
wuffs_gzip_decode_100k/gcc10                               283MB/s ± 1%   285MB/s ± 4%     ~     (p=0.182 n=9+10)

wuffs_zlib_decode_10k/clang9                               226MB/s ± 1%   220MB/s ± 4%   -2.66%  (p=0.000 n=9+10)
wuffs_zlib_decode_100k/clang9                              272MB/s ± 2%   285MB/s ± 1%   +4.77%  (p=0.000 n=10+8)

wuffs_zlib_decode_10k/gcc10                                227MB/s ± 1%   212MB/s ± 1%   -6.80%  (p=0.000 n=10+9)
wuffs_zlib_decode_100k/gcc10                               282MB/s ± 1%   273MB/s ± 0%   -3.32%  (p=0.000 n=9+8)

wuffs_png_decode_image_19k_8bpp/clang9                     148MB/s ± 1%   138MB/s ± 2%   -6.79%  (p=0.000 n=9+10)
wuffs_png_decode_image_40k_24bpp/clang9                    170MB/s ± 1%   171MB/s ± 2%     ~     (p=0.133 n=9+10)
wuffs_png_decode_image_77k_8bpp/clang9                     525MB/s ± 1%   495MB/s ± 4%   -5.81%  (p=0.000 n=8+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   400MB/s ± 2%   457MB/s ± 4%  +14.16%  (p=0.000 n=9+9)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   388MB/s ± 1%   435MB/s ± 5%  +12.17%  (p=0.000 n=9+10)
wuffs_png_decode_image_4002k_24bpp/clang9                  175MB/s ± 1%   172MB/s ± 2%   -1.78%  (p=0.005 n=10+10)

wuffs_png_decode_image_19k_8bpp/gcc10                      154MB/s ± 3%   157MB/s ± 1%   +1.72%  (p=0.001 n=9+9)
wuffs_png_decode_image_40k_24bpp/gcc10                     182MB/s ± 1%   187MB/s ± 1%   +2.56%  (p=0.000 n=9+10)
wuffs_png_decode_image_77k_8bpp/gcc10                      552MB/s ± 3%   554MB/s ± 1%     ~     (p=0.863 n=9+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10    426MB/s ± 2%   502MB/s ± 1%  +17.85%  (p=0.000 n=10+10)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10    410MB/s ± 2%   481MB/s ± 1%  +17.17%  (p=0.000 n=9+8)
wuffs_png_decode_image_4002k_24bpp/gcc10                   186MB/s ± 1%   189MB/s ± 2%   +1.33%  (p=0.001 n=9+10)
2021-04-09 14:31:52 +10:00
Nigel Tao a7ef82f7db Add deflate.decoder.decode_huffman_bmi2
Binary size, before:
21864 gen/lib/c/clang-9-dynamic/wuffs-std-deflate.lo
21488 gen/lib/c/clang-9-static/wuffs-std-deflate.o
21136 gen/lib/c/gcc-dynamic/wuffs-std-deflate.lo
21536 gen/lib/c/gcc-static/wuffs-std-deflate.o

After:
24592 gen/lib/c/clang-9-dynamic/wuffs-std-deflate.lo
24368 gen/lib/c/clang-9-static/wuffs-std-deflate.o
23320 gen/lib/c/gcc-dynamic/wuffs-std-deflate.lo
23928 gen/lib/c/gcc-static/wuffs-std-deflate.o

I've upgraded my kernel and compilers recently, so the absolute Wuffs
benchmark numbers below aren't directly comparable to those reported in
previous commits, but the relative changes still seems valid.

On a mid-range x86_64 laptop:

name                                                      old speed      new speed      delta

wuffs_deflate_decode_1k_full_init/clang9                   107MB/s ± 1%   104MB/s ± 1%   -2.36%  (p=0.000 n=8+9)
wuffs_deflate_decode_1k_part_init/clang9                   123MB/s ± 1%   121MB/s ± 1%   -1.78%  (p=0.000 n=10+9)
wuffs_deflate_decode_10k_full_init/clang9                  221MB/s ± 2%   223MB/s ± 1%   +0.86%  (p=0.035 n=10+9)
wuffs_deflate_decode_10k_part_init/clang9                  228MB/s ± 0%   230MB/s ± 1%   +0.59%  (p=0.003 n=8+10)
wuffs_deflate_decode_100k_just_one_read/clang9             276MB/s ± 0%   279MB/s ± 1%   +1.12%  (p=0.001 n=8+9)
wuffs_deflate_decode_100k_many_big_reads/clang9            174MB/s ± 1%   178MB/s ± 5%   +2.38%  (p=0.028 n=9+10)

wuffs_deflate_decode_1k_full_init/gcc10                    103MB/s ± 3%   103MB/s ± 1%     ~     (p=0.105 n=10+10)
wuffs_deflate_decode_1k_part_init/gcc10                    123MB/s ± 1%   122MB/s ± 1%   -0.94%  (p=0.001 n=9+10)
wuffs_deflate_decode_10k_full_init/gcc10                   216MB/s ± 2%   235MB/s ± 1%   +8.83%  (p=0.000 n=10+10)
wuffs_deflate_decode_10k_part_init/gcc10                   223MB/s ± 1%   242MB/s ± 1%   +8.45%  (p=0.000 n=9+9)
wuffs_deflate_decode_100k_just_one_read/gcc10              270MB/s ± 4%   300MB/s ± 4%  +11.08%  (p=0.000 n=9+10)
wuffs_deflate_decode_100k_many_big_reads/gcc10             179MB/s ± 1%   193MB/s ± 2%   +7.97%  (p=0.000 n=10+10)

wuffs_gzip_decode_10k/clang9                               218MB/s ± 3%   220MB/s ± 1%     ~     (p=0.549 n=10+9)
wuffs_gzip_decode_100k/clang9                              270MB/s ± 0%   269MB/s ± 2%     ~     (p=0.730 n=9+9)

wuffs_gzip_decode_10k/gcc10                                208MB/s ± 1%   227MB/s ± 1%   +8.87%  (p=0.000 n=9+10)
wuffs_gzip_decode_100k/gcc10                               267MB/s ± 1%   283MB/s ± 1%   +6.05%  (p=0.000 n=10+9)

wuffs_zlib_decode_10k/clang9                               214MB/s ± 2%   226MB/s ± 1%   +5.69%  (p=0.000 n=10+9)
wuffs_zlib_decode_100k/clang9                              259MB/s ± 6%   272MB/s ± 2%   +5.05%  (p=0.000 n=9+10)

wuffs_zlib_decode_10k/gcc10                                211MB/s ± 1%   227MB/s ± 1%   +7.53%  (p=0.000 n=10+10)
wuffs_zlib_decode_100k/gcc10                               262MB/s ± 1%   282MB/s ± 1%   +7.69%  (p=0.000 n=10+9)

wuffs_png_decode_image_19k_8bpp/clang9                     144MB/s ± 0%   148MB/s ± 1%   +2.68%  (p=0.000 n=9+9)
wuffs_png_decode_image_40k_24bpp/clang9                    166MB/s ± 1%   170MB/s ± 1%   +2.38%  (p=0.000 n=9+9)
wuffs_png_decode_image_77k_8bpp/clang9                     515MB/s ± 1%   525MB/s ± 1%   +1.91%  (p=0.000 n=9+8)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   401MB/s ± 1%   400MB/s ± 2%     ~     (p=0.913 n=9+9)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   387MB/s ± 1%   388MB/s ± 1%     ~     (p=0.546 n=9+9)
wuffs_png_decode_image_4002k_24bpp/clang9                  170MB/s ± 3%   175MB/s ± 1%   +3.02%  (p=0.000 n=9+10)

wuffs_png_decode_image_19k_8bpp/gcc10                      143MB/s ± 2%   154MB/s ± 3%   +8.32%  (p=0.000 n=9+9)
wuffs_png_decode_image_40k_24bpp/gcc10                     174MB/s ± 2%   182MB/s ± 1%   +4.42%  (p=0.000 n=10+9)
wuffs_png_decode_image_77k_8bpp/gcc10                      513MB/s ± 2%   552MB/s ± 3%   +7.66%  (p=0.000 n=10+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10    408MB/s ± 1%   426MB/s ± 2%   +4.43%  (p=0.000 n=9+10)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10    390MB/s ± 4%   410MB/s ± 2%   +5.05%  (p=0.000 n=10+9)
wuffs_png_decode_image_4002k_24bpp/gcc10                   177MB/s ± 1%   186MB/s ± 1%   +5.13%  (p=0.000 n=9+9)
2021-04-09 00:06:33 +10:00
Nigel Tao 9b228fab2a Make deflate.decoder.decode_huffman_fast64 choosy 2021-04-09 00:06:32 +10:00
Nigel Tao 96f097c51f Fix doc/note/assertions.md typo 2021-04-09 00:06:32 +10:00
Nigel Tao 08f7e3dba4 Merge pull request #45 from landaire/rust-bench-with-iterators
Use iterators for converting RGB to BGRA in the Rust PNG benchmark
2021-04-09 00:04:12 +10:00
Lander Brandt ab5f974b66 Use iterators for converting RGB to BGRA in the Rust PNG benchmark 2021-04-07 14:34:35 -07:00
66 changed files with 2719 additions and 495 deletions

No files matched your search

+1
View File
@@ -39,3 +39,4 @@ Leo Neat <lneat@google.com>
Mike Kaufman <mkaufman@microsoft.com>
Muhammad Aldo Firmansyah <TheCrott@users.noreply.github.com>
Nigel Tao <nigeltao@golang.org>
Peter Kasting <pkasting@chromium.org>
+16
View File
@@ -167,8 +167,12 @@ const grSingleFileGuidance = `
const grPragmaPush = `
// Wuffs' C code is generated automatically, not hand-written. These warnings'
// costs outweigh the benefits.
//
// The "elif defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wunreachable-code"
#pragma GCC diagnostic ignored "-Wunused-function"
@@ -176,6 +180,16 @@ const grPragmaPush = `
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
#elif defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunused-function"
#pragma clang diagnostic ignored "-Wunused-parameter"
#if defined(__cplusplus)
#pragma clang diagnostic ignored "-Wold-style-cast"
#endif
#endif
`
@@ -183,6 +197,8 @@ const grPragmaPush = `
const grPragmaPop = `
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#endif
`
+1 -1
View File
@@ -27,7 +27,7 @@ if x < 5 {
} else {
x = 1
// At this point, "x == 1" is a fact, but "x < 5" is not.
// At this point, "x == 1" is a fact, but "x < 5" is not.
// This assertion creates the "x < 5" fact.
assert x < 5
+1 -1
View File
@@ -190,5 +190,5 @@ on its title, but primarily concerns lossy compression of volumetric data.
Robert and Nadarajan's ["New Algorithms For Random Access Text
Compression"](https://www.researchgate.net/publication/4231766_New_Algorithms_For_Random_Access_Text_Compression)
cannot compress aribrary data, only 7-bit ASCII. The largest document they
cannot compress arbitrary data, only 7-bit ASCII. The largest document they
consider is also only 17 KiB in size.
+2 -2
View File
@@ -747,7 +747,7 @@ main1(int argc, char** argv) {
if (g_flags.remaining_argc > 1) {
return g_usage;
} else if (g_flags.remaining_argc == 1) {
in = fopen(g_flags.remaining_argv[0], "r");
in = fopen(g_flags.remaining_argv[0], "rb");
if (!in) {
return std::string("main: cannot read input file");
}
@@ -767,7 +767,7 @@ compute_exit_code(std::string status_msg) {
}
fputs(status_msg.c_str(), stderr);
fputc('\n', stderr);
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+1 -1
View File
@@ -605,7 +605,7 @@ compute_exit_code(const char* status_msg) {
}
ignore_return_value(write(STDERR_FD, status_msg, n));
ignore_return_value(write(STDERR_FD, "\n", 1));
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+1 -1
View File
@@ -94,7 +94,7 @@ load_image(const char* filename) {
FILE* file = stdin;
const char* adj_filename = "<stdin>";
if (filename) {
FILE* f = fopen(filename, "r");
FILE* f = fopen(filename, "rb");
if (f == NULL) {
printf("%s: could not open file\n", filename);
return false;
+2 -2
View File
@@ -339,7 +339,7 @@ main1(int argc, char** argv) {
if (g_flags.remaining_argc > 1) {
return g_usage;
} else if (g_flags.remaining_argc == 1) {
in = fopen(g_flags.remaining_argv[0], "r");
in = fopen(g_flags.remaining_argv[0], "rb");
if (!in) {
return std::string("main: cannot read input file");
}
@@ -362,7 +362,7 @@ compute_exit_code(std::string status_msg) {
}
fputs(status_msg.c_str(), stderr);
fputc('\n', stderr);
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+2 -2
View File
@@ -548,7 +548,7 @@ main1(int argc, char** argv) {
if (g_flags.remaining_argc > 1) {
return g_usage;
} else if (g_flags.remaining_argc == 1) {
in = fopen(g_flags.remaining_argv[0], "r");
in = fopen(g_flags.remaining_argv[0], "rb");
if (!in) {
return std::string("main: cannot read input file");
}
@@ -571,7 +571,7 @@ compute_exit_code(std::string status_msg) {
return 0;
}
std::cerr << status_msg << '\n';
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+1 -1
View File
@@ -1446,7 +1446,7 @@ compute_exit_code(const char* status_msg) {
const int stderr_fd = 2;
ignore_return_value(write(stderr_fd, status_msg, n));
ignore_return_value(write(stderr_fd, "\n", 1));
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+1 -1
View File
@@ -224,7 +224,7 @@ compute_exit_code(const char* status_msg) {
const int stderr_fd = 2;
ignore_return_value(write(stderr_fd, status_msg, n));
ignore_return_value(write(stderr_fd, "\n", 1));
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+1 -1
View File
@@ -66,7 +66,7 @@ fuzz(wuffs_base__io_buffer* src, uint64_t hash) {
wuffs_base__status status = wuffs_bmp__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
(hash & 1) ? WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED : 0);
hash >>= 1;
hash = wuffs_base__u64__rotate_right(hash, 1);
if (!wuffs_base__status__is_ok(&status)) {
return wuffs_base__status__message(&status);
}
+12 -11
View File
@@ -221,12 +221,13 @@ fuzz_one_token(wuffs_base__token t,
}
uint64_t //
buffer_limit(uint64_t hash_6_bits, uint64_t min, uint64_t max) {
buffer_limit(uint64_t hash, uint64_t min, uint64_t max) {
hash &= 0x3F;
uint64_t n;
if (hash_6_bits < 0x20) {
n = min + hash_6_bits;
if (hash < 0x20) {
n = min + hash;
} else {
n = max - (0x3F - hash_6_bits);
n = max - (0x3F - hash);
}
if (n < min) {
return min;
@@ -237,15 +238,15 @@ buffer_limit(uint64_t hash_6_bits, uint64_t min, uint64_t max) {
}
const char* //
fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash_56_bits) {
fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash) {
uint64_t tok_limit = buffer_limit(
hash_56_bits & 0x3F, WUFFS_CBOR__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL,
hash & 0x3F, WUFFS_CBOR__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL,
TOK_BUFFER_ARRAY_SIZE);
uint64_t hash_50_bits = hash_56_bits >> 6;
hash = wuffs_base__u64__rotate_right(hash, 6);
uint64_t src_limit =
buffer_limit(hash_50_bits & 0x3F,
WUFFS_CBOR__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL, 4096);
uint64_t src_limit = buffer_limit(
hash & 0x3F, WUFFS_CBOR__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL, 4096);
hash = wuffs_base__u64__rotate_right(hash, 6);
// ----
@@ -407,7 +408,7 @@ fuzz(wuffs_base__io_buffer* full_src, uint64_t hash) {
// The fuzz_complex implementation adds many more Wuffs API specific checks
// (e.g. that the sum of the tokens' lengths do not exceed the input length).
if ((hash & 0xFF) != 0xA5) {
return fuzz_complex(full_src, hash >> 8);
return fuzz_complex(full_src, wuffs_base__u64__rotate_right(hash, 8));
}
return fuzz_simple(full_src);
}
+26 -2
View File
@@ -61,17 +61,41 @@ It should print "PASS", amongst other information, and exit(0).
#include "../fuzzlib/fuzzlib.c"
#include "../fuzzlib/fuzzlib_image_decoder.c"
void set_quirks(wuffs_gif__decoder* dec, uint64_t hash) {
uint32_t quirks[] = {
WUFFS_GIF__QUIRK_DELAY_NUM_DECODED_FRAMES,
WUFFS_GIF__QUIRK_FIRST_FRAME_LOCAL_PALETTE_MEANS_BLACK_BACKGROUND,
WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR,
WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA,
WUFFS_GIF__QUIRK_IMAGE_BOUNDS_ARE_STRICT,
WUFFS_GIF__QUIRK_REJECT_EMPTY_FRAME,
WUFFS_GIF__QUIRK_REJECT_EMPTY_PALETTE,
0,
};
uint32_t i;
for (i = 0; quirks[i]; i++) {
uint64_t bit = 1 << (i & 63);
if (hash & bit) {
wuffs_gif__decoder__set_quirk_enabled(dec, quirks[i], true);
}
}
}
const char* //
fuzz(wuffs_base__io_buffer* src, uint64_t hash) {
wuffs_gif__decoder dec;
wuffs_base__status status = wuffs_gif__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
(hash & 1) ? WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED : 0);
hash >>= 1;
hash = wuffs_base__u64__rotate_right(hash, 1);
uint64_t hash_8_bits = hash & 0xFF;
hash = wuffs_base__u64__rotate_right(hash, 8);
if (!wuffs_base__status__is_ok(&status)) {
return wuffs_base__status__message(&status);
}
set_quirks(&dec, hash);
return fuzz_image_decoder(
src, hash,
src, hash_8_bits,
wuffs_gif__decoder__upcast_as__wuffs_base__image_decoder(&dec));
}
+16 -16
View File
@@ -209,12 +209,13 @@ fuzz_one_token(wuffs_base__token t,
}
uint64_t //
buffer_limit(uint64_t hash_6_bits, uint64_t min, uint64_t max) {
buffer_limit(uint64_t hash, uint64_t min, uint64_t max) {
hash &= 0x3F;
uint64_t n;
if (hash_6_bits < 0x20) {
n = min + hash_6_bits;
if (hash < 0x20) {
n = min + hash;
} else {
n = max - (0x3F - hash_6_bits);
n = max - (0x3F - hash);
}
if (n < min) {
return min;
@@ -224,7 +225,7 @@ buffer_limit(uint64_t hash_6_bits, uint64_t min, uint64_t max) {
return n;
}
void set_quirks(wuffs_json__decoder* dec, uint64_t hash_44_bits) {
void set_quirks(wuffs_json__decoder* dec, uint64_t hash) {
uint32_t quirks[] = {
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U,
@@ -247,24 +248,23 @@ void set_quirks(wuffs_json__decoder* dec, uint64_t hash_44_bits) {
uint32_t i;
for (i = 0; quirks[i]; i++) {
uint64_t bit = 1 << (i % 44);
if (hash_44_bits & bit) {
uint64_t bit = 1 << (i & 63);
if (hash & bit) {
wuffs_json__decoder__set_quirk_enabled(dec, quirks[i], true);
}
}
}
const char* //
fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash_56_bits) {
fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash) {
uint64_t tok_limit = buffer_limit(
hash_56_bits & 0x3F, WUFFS_JSON__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL,
hash & 0x3F, WUFFS_JSON__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL,
TOK_BUFFER_ARRAY_SIZE);
uint64_t hash_50_bits = hash_56_bits >> 6;
hash = wuffs_base__u64__rotate_right(hash, 6);
uint64_t src_limit =
buffer_limit(hash_50_bits & 0x3F,
WUFFS_JSON__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL, 4096);
uint64_t hash_44_bits = hash_50_bits >> 6;
uint64_t src_limit = buffer_limit(
hash & 0x3F, WUFFS_JSON__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL, 4096);
hash = wuffs_base__u64__rotate_right(hash, 6);
// ----
@@ -275,7 +275,7 @@ fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash_56_bits) {
if (!wuffs_base__status__is_ok(&status)) {
return wuffs_base__status__message(&status);
}
set_quirks(&dec, hash_44_bits);
set_quirks(&dec, hash);
wuffs_base__token tok_array[TOK_BUFFER_ARRAY_SIZE];
wuffs_base__token_buffer tok = ((wuffs_base__token_buffer){
@@ -427,7 +427,7 @@ fuzz(wuffs_base__io_buffer* full_src, uint64_t hash) {
// The fuzz_complex implementation adds many more Wuffs API specific checks
// (e.g. that the sum of the tokens' lengths do not exceed the input length).
if ((hash & 0xFF) != 0xA5) {
return fuzz_complex(full_src, hash >> 8);
return fuzz_complex(full_src, wuffs_base__u64__rotate_right(hash, 8));
}
return fuzz_simple(full_src);
}
+1 -1
View File
@@ -70,7 +70,7 @@ fuzz(wuffs_base__io_buffer* src, uint64_t hash) {
wuffs_base__status status = wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
(hash & 1) ? WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED : 0);
hash >>= 1;
hash = wuffs_base__u64__rotate_right(hash, 1);
if (!wuffs_base__status__is_ok(&status)) {
return wuffs_base__status__message(&status);
}
+67 -51
View File
@@ -40,54 +40,50 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
// --------
#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \
while (tok_buf.meta.ri >= tok_buf.meta.wi) { \
if (tok_status.repr == nullptr) { \
} else if (tok_status.repr == wuffs_base__suspension__short_write) { \
tok_buf.compact(); \
} else if (tok_status.repr == wuffs_base__suspension__short_read) { \
if (!io_error_message.empty()) { \
ret_error_message = std::move(io_error_message); \
goto done; \
} else if (cursor_index != io_buf->meta.ri) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad cursor_index"; \
goto done; \
} else if (io_buf->meta.closed) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is closed"; \
goto done; \
} \
io_buf->compact(); \
if (io_buf->meta.wi >= io_buf->data.len) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is full"; \
goto done; \
} \
cursor_index = io_buf->meta.ri; \
io_error_message = input.CopyIn(io_buf); \
} else { \
ret_error_message = tok_status.message(); \
goto done; \
} \
if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN"; \
goto done; \
} \
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8(); \
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf); \
} \
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
uint64_t token_len = token.length(); \
if ((io_buf->meta.ri < cursor_index) || \
((io_buf->meta.ri - cursor_index) < token_len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad token indexes"; \
goto done; \
} \
uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \
(void)(token_ptr); \
#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \
while (tok_buf.meta.ri >= tok_buf.meta.wi) { \
if (tok_status.repr == nullptr) { \
goto done; \
} else if (tok_status.repr == wuffs_base__suspension__short_write) { \
tok_buf.compact(); \
} else if (tok_status.repr == wuffs_base__suspension__short_read) { \
if (!io_error_message.empty()) { \
ret_error_message = std::move(io_error_message); \
goto done; \
} else if (cursor_index != io_buf->meta.ri) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad cursor_index"; \
goto done; \
} else if (io_buf->meta.closed) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is closed"; \
goto done; \
} \
io_buf->compact(); \
if (io_buf->meta.wi >= io_buf->data.len) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is full"; \
goto done; \
} \
cursor_index = io_buf->meta.ri; \
io_error_message = input.CopyIn(io_buf); \
} else { \
ret_error_message = tok_status.message(); \
goto done; \
} \
tok_status = \
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \
} \
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
uint64_t token_len = token.length(); \
if ((io_buf->meta.ri < cursor_index) || \
((io_buf->meta.ri - cursor_index) < token_len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad token indexes"; \
goto done; \
} \
uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \
(void)(token_ptr); \
cursor_index += static_cast<size_t>(token_len)
// --------
@@ -358,6 +354,10 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
if (!dec) {
ret_error_message = "wuffs_aux::DecodeJson: out of memory";
goto done;
} else if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN";
goto done;
}
bool allow_tilde_n_tilde_r_tilde_t = false;
for (size_t i = 0; i < quirks.len; i++) {
@@ -373,7 +373,8 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
wuffs_base__token_buffer tok_buf =
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
&tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
wuffs_base__status tok_status =
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());
// Prepare other state.
uint32_t depth = 0;
@@ -387,7 +388,7 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
}
std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(
json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);
i = std::move(split.second);
i = split.second;
if (i == 0) {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
@@ -522,7 +523,22 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done;
parsed_a_value:
if (!ret_error_message.empty() || (depth == 0)) {
// If an error was encountered, we are done. Otherwise, (depth == 0)
// after parsing a value is equivalent to having decoded the entire JSON
// value (for an empty json_pointer query) or having decoded the
// pointed-to JSON value (for a non-empty json_pointer query). In the
// latter case, we are also done.
//
// However, if quirks like WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER or
// WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF are passed, decoding
// the entire JSON value should also consume any trailing filler, in case
// the DecodeJson caller wants to subsequently check that the input is
// completely exhausted (and otherwise raise "valid JSON followed by
// further (unexpected) data"). We aren't done yet. Instead, keep the
// loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's
// decode_tokens returns an ok status.
if (!ret_error_message.empty() ||
((depth == 0) && !json_pointer.empty())) {
goto done;
}
}
+2 -12
View File
@@ -29,26 +29,16 @@
// Its (non-zero) value is arbitrary, based on md5sum("disabled").
#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)
// Denote intentional fallthroughs for -Wimplicit-fallthrough.
//
// The order matters here. Clang also defines "__GNUC__".
#if defined(__clang__) && defined(__cplusplus) && (__cplusplus >= 201103L)
#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]
#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)
#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))
#else
#define WUFFS_BASE__FALLTHROUGH
#endif
// Use switch cases for coroutine suspension points, similar to the technique
// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
//
// The implicit fallthrough is intentional.
//
// We use trivial macros instead of an explicit assignment and case statement
// so that clang-format doesn't get confused by the unusual "case"s.
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \
coro_susp_point = n; \
WUFFS_BASE__FALLTHROUGH; \
case n:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \
+140 -9
View File
@@ -60,8 +60,8 @@
// To simplify Wuffs code, "cpu_arch >= arm_xxx" requires xxx but also
// unaligned little-endian load/stores.
#if defined(__ARM_FEATURE_UNALIGNED) && defined(__BYTE_ORDER__) && \
(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
#if defined(__ARM_FEATURE_UNALIGNED) && !defined(__native_client__) && \
defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
// Not all gcc versions define __ARM_ACLE, even if they support crc32
// intrinsics. Look for __ARM_FEATURE_CRC32 instead.
#if defined(__ARM_FEATURE_CRC32)
@@ -76,11 +76,13 @@
// Similarly, "cpu_arch >= x86_sse42" requires SSE4.2 but also PCLMUL and
// POPCNT. This is checked at runtime via cpuid, not at compile time.
#if defined(__x86_64__)
//
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
#if defined(__x86_64__) && !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__)
#endif // defined(__x86_64__) && !defined(__native_client__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
@@ -148,6 +150,82 @@ wuffs_base__cpu_arch__have_arm_neon() {
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
}
static inline bool //
wuffs_base__cpu_arch__have_x86_avx2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
// - bit_SSE4_2 = (1 << 20)
const unsigned int avx2_ecx1 = 0x00900002;
// clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
#if defined(__GNUC__)
unsigned int eax7 = 0;
unsigned int ebx7 = 0;
unsigned int ecx7 = 0;
unsigned int edx7 = 0;
if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&
((ebx7 & avx2_ebx7) == avx2_ebx7)) {
unsigned int eax1 = 0;
unsigned int ebx1 = 0;
unsigned int ecx1 = 0;
unsigned int edx1 = 0;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
((ecx1 & avx2_ecx1) == avx2_ecx1)) {
return true;
}
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x7[4];
__cpuidex(x7, 7, 0);
if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) {
int x1[4];
__cpuid(x1, 1);
if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) {
return true;
}
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_bmi2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
// clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
#if defined(__GNUC__)
unsigned int eax7 = 0;
unsigned int ebx7 = 0;
unsigned int ecx7 = 0;
unsigned int edx7 = 0;
if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&
((ebx7 & bmi2_ebx7) == bmi2_ebx7)) {
return true;
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x7[4];
__cpuidex(x7, 7, 0);
if ((((unsigned int)(x7[1])) & bmi2_ebx7) == bmi2_ebx7) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_sse42() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -163,13 +241,16 @@ wuffs_base__cpu_arch__have_x86_sse42() {
unsigned int ebx1 = 0;
unsigned int ecx1 = 0;
unsigned int edx1 = 0;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1)) {
return (ecx1 & sse42_ecx1) == sse42_ecx1;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
((ecx1 & sse42_ecx1) == sse42_ecx1)) {
return true;
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x[4];
__cpuid(x, 1);
return (((unsigned int)(x[2])) & sse42_ecx1) == sse42_ecx1;
int x1[4];
__cpuid(x1, 1);
if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
@@ -500,6 +581,56 @@ wuffs_base__u64__max(uint64_t x, uint64_t y) {
// --------
static inline uint8_t //
wuffs_base__u8__rotate_left(uint8_t x, uint32_t n) {
n &= 7;
return ((uint8_t)(x << n)) | ((uint8_t)(x >> (8 - n)));
}
static inline uint8_t //
wuffs_base__u8__rotate_right(uint8_t x, uint32_t n) {
n &= 7;
return ((uint8_t)(x >> n)) | ((uint8_t)(x << (8 - n)));
}
static inline uint16_t //
wuffs_base__u16__rotate_left(uint16_t x, uint32_t n) {
n &= 15;
return ((uint16_t)(x << n)) | ((uint16_t)(x >> (16 - n)));
}
static inline uint16_t //
wuffs_base__u16__rotate_right(uint16_t x, uint32_t n) {
n &= 15;
return ((uint16_t)(x >> n)) | ((uint16_t)(x << (16 - n)));
}
static inline uint32_t //
wuffs_base__u32__rotate_left(uint32_t x, uint32_t n) {
n &= 31;
return ((uint32_t)(x << n)) | ((uint32_t)(x >> (32 - n)));
}
static inline uint32_t //
wuffs_base__u32__rotate_right(uint32_t x, uint32_t n) {
n &= 31;
return ((uint32_t)(x >> n)) | ((uint32_t)(x << (32 - n)));
}
static inline uint64_t //
wuffs_base__u64__rotate_left(uint64_t x, uint32_t n) {
n &= 63;
return ((uint64_t)(x << n)) | ((uint64_t)(x >> (64 - n)));
}
static inline uint64_t //
wuffs_base__u64__rotate_right(uint64_t x, uint32_t n) {
n &= 63;
return ((uint64_t)(x >> n)) | ((uint64_t)(x << (64 - n)));
}
// --------
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
+40
View File
@@ -228,6 +228,46 @@ wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast
// copies the previous byte (the one immediately before *ptr_iop_w), copying 8
// byte chunks at a time. Each chunk contains 8 repetitions of the same byte.
//
// In terms of number of bytes copied, length is rounded up to a multiple of 8.
// As a special case, a zero length rounds up to 8 (even though 0 is already a
// multiple of 8), since there is always at least one 8 byte chunk copied.
//
// In terms of advancing *ptr_iop_w, length is not rounded up.
//
// The caller needs to prove that:
// - (length + 8) <= (io2_w - *ptr_iop_w)
// - distance == 1
// - distance <= (*ptr_iop_w - io1_w)
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
uint8_t** ptr_iop_w,
uint8_t* io1_w,
uint8_t* io2_w,
uint32_t length,
uint32_t distance) {
uint8_t* p = *ptr_iop_w;
uint64_t x = p[-1];
x |= x << 8;
x |= x << 16;
x |= x << 32;
uint32_t n = length;
while (1) {
wuffs_base__poke_u64le__no_bounds_check(p, x);
if (n <= 8) {
p += n;
break;
}
p += 8;
n -= 8;
}
*ptr_iop_w = p;
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast is
// like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function
// above, but copies 8 byte chunks at a time.
+34 -1
View File
@@ -4094,6 +4094,34 @@ wuffs_base__pixel_swizzler__y__y_16be(uint8_t* dst_ptr,
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__y_16le__y_16be(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len2 = src_len / 2;
size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
d[0] = s1;
d[1] = s0;
s += 1 * 2;
d += 1 * 2;
n -= 1;
}
return len;
}
// --------
static uint64_t //
@@ -4180,13 +4208,18 @@ wuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__Y:
return wuffs_base__pixel_swizzler__y__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
return wuffs_base__pixel_swizzler__y_16le__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
return wuffs_base__pixel_swizzler__copy_2_2;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
return wuffs_base__pixel_swizzler__bgr_565__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
case WUFFS_BASE__PIXEL_FORMAT__RGB:
return wuffs_base__pixel_swizzler__xxx__y_16be;
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
+24 -1
View File
@@ -308,6 +308,7 @@ func (g *gen) writeBuiltinIOWriter(b *buffer, recv *a.Expr, method t.ID, args []
switch method {
case t.IDLimitedCopyU32FromHistory,
t.IDLimitedCopyU32FromHistory8ByteChunksDistance1Fast,
t.IDLimitedCopyU32FromHistory8ByteChunksFast,
t.IDLimitedCopyU32FromHistoryFast:
b.printf("wuffs_base__io_writer__%s(\n&%s%s, %s%s, %s%s",
@@ -451,7 +452,8 @@ func (g *gen) writeBuiltinCPUArch(b *buffer, recv *a.Expr, method t.ID, args []*
return g.writeBuiltinCPUArchARMCRC32(b, recv, method, args, sideEffectsOnly, depth)
case id.IsBuiltInCPUArchARMNeon():
return g.writeBuiltinCPUArchARMNeon(b, recv, method, args, sideEffectsOnly, depth)
case id == t.IDX86SSE42Utility, id == t.IDX86M128I:
case id == t.IDX86SSE42Utility, id == t.IDX86M128I,
id == t.IDX86AVX2Utility, id == t.IDX86M256I:
return g.writeBuiltinCPUArchX86(b, recv, method, args, sideEffectsOnly, depth)
}
return fmt.Errorf("internal error: unsupported cpu_arch method %s.%s",
@@ -629,6 +631,27 @@ func (g *gen) writeBuiltinCPUArchX86(b *buffer, recv *a.Expr, method t.ID, args
fName, tName, ptr = "_mm_lddqu_si128", "const __m128i*)(const void*", true
case "make_m128i_zeroes":
fName, tName = "_mm_setzero_si128", ""
case "make_m256i_multiple_u8":
fName, tName = "_mm256_set_epi8", "int8_t"
case "make_m256i_multiple_u16":
fName, tName = "_mm256_set_epi16", "int16_t"
case "make_m256i_multiple_u32":
fName, tName = "_mm256_set_epi32", "int32_t"
case "make_m256i_multiple_u64":
fName, tName = "_mm256_set_epi64x", "int64_t"
case "make_m256i_repeat_u8":
fName, tName = "_mm256_set1_epi8", "int8_t"
case "make_m256i_repeat_u16":
fName, tName = "_mm256_set1_epi16", "int16_t"
case "make_m256i_repeat_u32":
fName, tName = "_mm256_set1_epi32", "int32_t"
case "make_m256i_repeat_u64":
fName, tName = "_mm256_set1_epi64x", "int64_t"
case "make_m256i_slice256":
fName, tName, ptr = "_mm256_lddqu_si256", "const __m256i*)(const void*", true
case "make_m256i_zeroes":
fName, tName = "_mm256_setzero_si256", ""
default:
return fmt.Errorf("internal error: unsupported cpu_arch method %q", methodStr)
}
+66 -57
View File
@@ -29,9 +29,8 @@ const BaseAllImplC = "" +
""
const BaseFundamentalPrivateH = "" +
"// ---------------- Fundamentals\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolproof, given C doesn't automatically zero memory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71)\n\n// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\n\n// Denote intentional fallthroughs for -Wimplicit-fallthrough.\n//\n// The order matters here. Clang also defines \"__GNUC__\".\n#if defined(__clang__) && defined(__cplusplus) && (__cplusplus >= 201103L)\n#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]\n#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)\n#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))\n#else\n#define WUFFS_BASE__FALLTHROUGH\n#endif\n\n// Use switch " +
"cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \\\n coro_susp_point = n; \\\n WUFFS_BASE__FALLTHROUGH; \\\n case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (!status.repr) { \\\n goto ok; \\\n } else if (*status.repr != '$') { \\\n goto exit; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; " +
" \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n" +
"// ---------------- Fundamentals\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolproof, given C doesn't automatically zero memory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71)\n\n// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\n\n// Use switch cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// The implicit fallthrough is intentional.\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_" +
"POINT(n) \\\n coro_susp_point = n; \\\n case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (!status.repr) { \\\n goto ok; \\\n } else if (*status.repr != '$') { \\\n goto exit; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n" +
"" +
"// --------\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__ignore_status(wuffs_base__status z) {\n return wuffs_base__make_empty_struct();\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__status__ensure_not_a_suspension(wuffs_base__status z) {\n if (z.repr && (*z.repr == '$')) {\n z.repr = wuffs_base__error__cannot_return_a_suspension;\n }\n return z;\n}\n\n" +
"" +
@@ -54,14 +53,17 @@ const BaseFundamentalPublicH = "" +
"// ---------------- Version\n\n// WUFFS_VERSION is the major.minor.patch version, as per https://semver.org/,\n// as a uint64_t. The major number is the high 32 bits. The minor number is the\n// middle 16 bits. The patch number is the low 16 bits. The pre-release label\n// and build metadata are part of the string representation (such as\n// \"1.2.3-beta+456.20181231\") but not the uint64_t representation.\n//\n// WUFFS_VERSION_PRE_RELEASE_LABEL (such as \"\", \"beta\" or \"rc.1\") being\n// non-empty denotes a developer preview, not a release version, and has no\n// backwards or forwards compatibility guarantees.\n//\n// WUFFS_VERSION_BUILD_METADATA_XXX, if non-zero, are the number of commits and\n// the last commit date in the repository used to build this library. Within\n// each major.minor branch, the commit count should increase monotonically.\n//\n// ¡ Some code generation programs can override WUFFS_VERSION.\n#define WUFFS_VERSION 0\n#define WUFFS_VERSION_MAJOR 0\n#define WUFFS_VERSION_MINOR 0\n#define WUFFS_VERSION_PATCH 0\n#de" +
"fine WUFFS_VERSION_PRE_RELEASE_LABEL \"work.in.progress\"\n#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0\n#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0\n#define WUFFS_VERSION_STRING \"0.0.0+0.00000000\"\n\n" +
"" +
"// ---------------- Configuration\n\n// Define WUFFS_CONFIG__AVOID_CPU_ARCH to avoid any code tied to a specific CPU\n// architecture, such as SSE SIMD for the x86 CPU family.\n#if defined(WUFFS_CONFIG__AVOID_CPU_ARCH) // (#if-chain ref AVOID_CPU_ARCH_0)\n// No-op.\n#else // (#if-chain ref AVOID_CPU_ARCH_0)\n\n// The \"defined(__clang__)\" isn't redundant. While vanilla clang defines\n// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.\n#if defined(__GNUC__) || defined(__clang__)\n#define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg) __attribute__((target(arg)))\n#else\n#define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg)\n#endif // defined(__GNUC__) || defined(__clang__)\n\n#if defined(__GNUC__) // (#if-chain ref AVOID_CPU_ARCH_1)\n\n// To simplify Wuffs code, \"cpu_arch >= arm_xxx\" requires xxx but also\n// unaligned little-endian load/stores.\n#if defined(__ARM_FEATURE_UNALIGNED) && defined(__BYTE_ORDER__) && \\\n (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)\n// Not all gcc versions define __ARM_ACLE, even if they support crc32" +
"\n// intrinsics. Look for __ARM_FEATURE_CRC32 instead.\n#if defined(__ARM_FEATURE_CRC32)\n#include <arm_acle.h>\n#define WUFFS_BASE__CPU_ARCH__ARM_CRC32\n#endif // defined(__ARM_FEATURE_CRC32)\n#if defined(__ARM_NEON)\n#include <arm_neon.h>\n#define WUFFS_BASE__CPU_ARCH__ARM_NEON\n#endif // defined(__ARM_NEON)\n#endif // defined(__ARM_FEATURE_UNALIGNED) etc\n\n// Similarly, \"cpu_arch >= x86_sse42\" requires SSE4.2 but also PCLMUL and\n// POPCNT. This is checked at runtime via cpuid, not at compile time.\n#if defined(__x86_64__)\n#include <cpuid.h>\n#include <x86intrin.h>\n#define WUFFS_BASE__CPU_ARCH__X86_64\n#endif // defined(__x86_64__)\n\n#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)\n\n#if defined(_M_X64)\n#if defined(__AVX__) || defined(__clang__)\n\n// We need <intrin.h> for the __cpuid function.\n#include <intrin.h>\n// That's not enough for X64 SIMD, with clang-cl, if we want to use\n// \"__attribute__((target(arg)))\" without e.g. \"/arch:AVX\".\n//\n// Some web pages suggest that <immintrin.h> is all you need, as i" +
"t pulls in\n// the earlier SIMD families like SSE4.2, but that doesn't seem to work in\n// practice, possibly for the same reason that just <intrin.h> doesn't work.\n#include <immintrin.h> // AVX, AVX2, FMA, POPCNT\n#include <nmmintrin.h> // SSE4.2\n#include <wmmintrin.h> // AES, PCLMUL\n#define WUFFS_BASE__CPU_ARCH__X86_64\n\n#else // defined(__AVX__) || defined(__clang__)\n\n// clang-cl (which defines both __clang__ and _MSC_VER) supports\n// \"__attribute__((target(arg)))\".\n//\n// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time\n// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not\n// of individual functions (that can be conditionally selected at runtime).\n#pragma message(\"Wuffs with MSVC+X64 needs /arch:AVX for best performance\")\n\n#endif // defined(__AVX__) || defined(__clang__)\n#endif // defined(_M_X64)\n\n#endif // (#if-chain ref AVOID_CPU_ARCH_1)\n#endif // (#if-chain ref AVOID_CPU_ARCH_0)\n\n" +
"// ---------------- Configuration\n\n// Define WUFFS_CONFIG__AVOID_CPU_ARCH to avoid any code tied to a specific CPU\n// architecture, such as SSE SIMD for the x86 CPU family.\n#if defined(WUFFS_CONFIG__AVOID_CPU_ARCH) // (#if-chain ref AVOID_CPU_ARCH_0)\n// No-op.\n#else // (#if-chain ref AVOID_CPU_ARCH_0)\n\n// The \"defined(__clang__)\" isn't redundant. While vanilla clang defines\n// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.\n#if defined(__GNUC__) || defined(__clang__)\n#define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg) __attribute__((target(arg)))\n#else\n#define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg)\n#endif // defined(__GNUC__) || defined(__clang__)\n\n#if defined(__GNUC__) // (#if-chain ref AVOID_CPU_ARCH_1)\n\n// To simplify Wuffs code, \"cpu_arch >= arm_xxx\" requires xxx but also\n// unaligned little-endian load/stores.\n#if defined(__ARM_FEATURE_UNALIGNED) && !defined(__native_client__) && \\\n defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)\n// Not all gcc versions define __ARM_A" +
"CLE, even if they support crc32\n// intrinsics. Look for __ARM_FEATURE_CRC32 instead.\n#if defined(__ARM_FEATURE_CRC32)\n#include <arm_acle.h>\n#define WUFFS_BASE__CPU_ARCH__ARM_CRC32\n#endif // defined(__ARM_FEATURE_CRC32)\n#if defined(__ARM_NEON)\n#include <arm_neon.h>\n#define WUFFS_BASE__CPU_ARCH__ARM_NEON\n#endif // defined(__ARM_NEON)\n#endif // defined(__ARM_FEATURE_UNALIGNED) etc\n\n// Similarly, \"cpu_arch >= x86_sse42\" requires SSE4.2 but also PCLMUL and\n// POPCNT. This is checked at runtime via cpuid, not at compile time.\n//\n// Likewise, \"cpu_arch >= x86_avx2\" also requires PCLMUL, POPCNT and SSE4.2.\n#if defined(__x86_64__) && !defined(__native_client__)\n#include <cpuid.h>\n#include <x86intrin.h>\n#define WUFFS_BASE__CPU_ARCH__X86_64\n#endif // defined(__x86_64__) && !defined(__native_client__)\n\n#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)\n\n#if defined(_M_X64)\n#if defined(__AVX__) || defined(__clang__)\n\n// We need <intrin.h> for the __cpuid function.\n#include <intrin.h>\n// That's not enough for" +
" X64 SIMD, with clang-cl, if we want to use\n// \"__attribute__((target(arg)))\" without e.g. \"/arch:AVX\".\n//\n// Some web pages suggest that <immintrin.h> is all you need, as it pulls in\n// the earlier SIMD families like SSE4.2, but that doesn't seem to work in\n// practice, possibly for the same reason that just <intrin.h> doesn't work.\n#include <immintrin.h> // AVX, AVX2, FMA, POPCNT\n#include <nmmintrin.h> // SSE4.2\n#include <wmmintrin.h> // AES, PCLMUL\n#define WUFFS_BASE__CPU_ARCH__X86_64\n\n#else // defined(__AVX__) || defined(__clang__)\n\n// clang-cl (which defines both __clang__ and _MSC_VER) supports\n// \"__attribute__((target(arg)))\".\n//\n// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time\n// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not\n// of individual functions (that can be conditionally selected at runtime).\n#pragma message(\"Wuffs with MSVC+X64 needs /arch:AVX for best performance\")\n\n#endif // defined(__AVX__) || defined(__clang__)\n#endif // defi" +
"ned(_M_X64)\n\n#endif // (#if-chain ref AVOID_CPU_ARCH_1)\n#endif // (#if-chain ref AVOID_CPU_ARCH_0)\n\n" +
"" +
"// --------\n\n// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have\n// static storage. The motivation is discussed in the \"ALLOW STATIC\n// IMPLEMENTATION\" section of\n// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt\n#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)\n#define WUFFS_BASE__MAYBE_STATIC static\n#else\n#define WUFFS_BASE__MAYBE_STATIC\n#endif // defined(WUFFS_CONFIG__STATIC_FUNCTIONS)\n\n" +
"" +
"// ---------------- CPU Architecture\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_arm_crc32() {\n#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)\n return true;\n#else\n return false;\n#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_arm_neon() {\n#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)\n return true;\n#else\n return false;\n#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_x86_sse42() {\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n // GCC defines these macros but MSVC does not.\n // - bit_PCLMUL = (1 << 1)\n // - bit_POPCNT = (1 << 23)\n // - bit_SSE4_2 = (1 << 20)\n const unsigned int sse42_ecx1 = 0x00900002;\n\n // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).\n#if defined(__GNUC__)\n unsigned int eax1 = 0;\n unsigned int ebx1 = 0;\n unsigned int ecx1 = 0;\n unsigned int edx1 = 0;\n if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1)) {\n return (ecx1 & sse42_ecx1) == sse42_" +
"ecx1;\n }\n#elif defined(_MSC_VER) // defined(__GNUC__)\n int x[4];\n __cpuid(x, 1);\n return (((unsigned int)(x[2])) & sse42_ecx1) == sse42_ecx1;\n#else\n#error \"WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler\"\n#endif // defined(__GNUC__); defined(_MSC_VER)\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n return false;\n}\n\n" +
"// ---------------- CPU Architecture\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_arm_crc32() {\n#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)\n return true;\n#else\n return false;\n#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_arm_neon() {\n#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)\n return true;\n#else\n return false;\n#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_x86_avx2() {\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n // GCC defines these macros but MSVC does not.\n // - bit_AVX2 = (1 << 5)\n const unsigned int avx2_ebx7 = 0x00000020;\n // GCC defines these macros but MSVC does not.\n // - bit_PCLMUL = (1 << 1)\n // - bit_POPCNT = (1 << 23)\n // - bit_SSE4_2 = (1 << 20)\n const unsigned int avx2_ecx1 = 0x00900002;\n\n // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).\n#if defined(__GNUC__)\n unsigned int eax7 = 0;\n unsigned int ebx7 = 0;\n unsigned int ecx7 =" +
" 0;\n unsigned int edx7 = 0;\n if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&\n ((ebx7 & avx2_ebx7) == avx2_ebx7)) {\n unsigned int eax1 = 0;\n unsigned int ebx1 = 0;\n unsigned int ecx1 = 0;\n unsigned int edx1 = 0;\n if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&\n ((ecx1 & avx2_ecx1) == avx2_ecx1)) {\n return true;\n }\n }\n#elif defined(_MSC_VER) // defined(__GNUC__)\n int x7[4];\n __cpuidex(x7, 7, 0);\n if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) {\n int x1[4];\n __cpuid(x1, 1);\n if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) {\n return true;\n }\n }\n#else\n#error \"WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler\"\n#endif // defined(__GNUC__); defined(_MSC_VER)\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n return false;\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_x86_bmi2() {\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n // GCC defines these macros but MSVC does not.\n // - bit_BMI2 = (1 << 8)\n const u" +
"nsigned int bmi2_ebx7 = 0x00000100;\n\n // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).\n#if defined(__GNUC__)\n unsigned int eax7 = 0;\n unsigned int ebx7 = 0;\n unsigned int ecx7 = 0;\n unsigned int edx7 = 0;\n if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&\n ((ebx7 & bmi2_ebx7) == bmi2_ebx7)) {\n return true;\n }\n#elif defined(_MSC_VER) // defined(__GNUC__)\n int x7[4];\n __cpuidex(x7, 7, 0);\n if ((((unsigned int)(x7[1])) & bmi2_ebx7) == bmi2_ebx7) {\n return true;\n }\n#else\n#error \"WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler\"\n#endif // defined(__GNUC__); defined(_MSC_VER)\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n return false;\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_x86_sse42() {\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n // GCC defines these macros but MSVC does not.\n // - bit_PCLMUL = (1 << 1)\n // - bit_POPCNT = (1 << 23)\n // - bit_SSE4_2 = (1 << 20)\n const unsigned int sse42_ecx1 = 0x00900002;\n\n // clan" +
"g defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).\n#if defined(__GNUC__)\n unsigned int eax1 = 0;\n unsigned int ebx1 = 0;\n unsigned int ecx1 = 0;\n unsigned int edx1 = 0;\n if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&\n ((ecx1 & sse42_ecx1) == sse42_ecx1)) {\n return true;\n }\n#elif defined(_MSC_VER) // defined(__GNUC__)\n int x1[4];\n __cpuid(x1, 1);\n if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) {\n return true;\n }\n#else\n#error \"WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler\"\n#endif // defined(__GNUC__); defined(_MSC_VER)\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n return false;\n}\n\n" +
"" +
"// ---------------- Fundamentals\n\n// Wuffs assumes that:\n// - converting a uint32_t to a size_t will never overflow.\n// - converting a size_t to a uint64_t will never overflow.\n#if defined(__WORDSIZE)\n#if (__WORDSIZE != 32) && (__WORDSIZE != 64)\n#error \"Wuffs requires a word size of either 32 or 64 bits\"\n#endif\n#endif\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))\n#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))\n#else\n#define WUFFS_BASE__POTENTIALLY_UNUSED\n#define WUFFS_BASE__WARN_UNUSED_RESULT\n#endif\n\n" +
"" +
@@ -88,6 +90,9 @@ const BaseFundamentalPublicH = "" +
"int32_t //\nwuffs_base__i32__max(int32_t x, int32_t y) {\n return x > y ? x : y;\n}\n\nstatic inline int64_t //\nwuffs_base__i64__min(int64_t x, int64_t y) {\n return x < y ? x : y;\n}\n\nstatic inline int64_t //\nwuffs_base__i64__max(int64_t x, int64_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__min(uint8_t x, uint8_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__max(uint8_t x, uint8_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__min(uint16_t x, uint16_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__max(uint16_t x, uint16_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__min(uint32_t x, uint32_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__max(uint32_t x, uint32_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__min(uint64_t x, uint64_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__m" +
"ax(uint64_t x, uint64_t y) {\n return x > y ? x : y;\n}\n\n" +
"" +
"// --------\n\nstatic inline uint8_t //\nwuffs_base__u8__rotate_left(uint8_t x, uint32_t n) {\n n &= 7;\n return ((uint8_t)(x << n)) | ((uint8_t)(x >> (8 - n)));\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__rotate_right(uint8_t x, uint32_t n) {\n n &= 7;\n return ((uint8_t)(x >> n)) | ((uint8_t)(x << (8 - n)));\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__rotate_left(uint16_t x, uint32_t n) {\n n &= 15;\n return ((uint16_t)(x << n)) | ((uint16_t)(x >> (16 - n)));\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__rotate_right(uint16_t x, uint32_t n) {\n n &= 15;\n return ((uint16_t)(x >> n)) | ((uint16_t)(x << (16 - n)));\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__rotate_left(uint32_t x, uint32_t n) {\n n &= 31;\n return ((uint32_t)(x << n)) | ((uint32_t)(x >> (32 - n)));\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__rotate_right(uint32_t x, uint32_t n) {\n n &= 31;\n return ((uint32_t)(x >> n)) | ((uint32_t)(x << (32 - n)));\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__rotate_left(uint64_t x, uint32_t n) " +
"{\n n &= 63;\n return ((uint64_t)(x << n)) | ((uint64_t)(x >> (64 - n)));\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__rotate_right(uint64_t x, uint32_t n) {\n n &= 63;\n return ((uint64_t)(x >> n)) | ((uint64_t)(x << (64 - n)));\n}\n\n" +
"" +
"// --------\n\n// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms\n// are per https://locklessinc.com/articles/sat_arithmetic/\n//\n// It is important that the underlying types are unsigned integers, as signed\n// integer arithmetic overflow is undefined behavior in C.\n\nstatic inline uint8_t //\nwuffs_base__u8__sat_add(uint8_t x, uint8_t y) {\n uint8_t res = (uint8_t)(x + y);\n res |= (uint8_t)(-(res < x));\n return res;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__sat_sub(uint8_t x, uint8_t y) {\n uint8_t res = (uint8_t)(x - y);\n res &= (uint8_t)(-(res <= x));\n return res;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__sat_add(uint16_t x, uint16_t y) {\n uint16_t res = (uint16_t)(x + y);\n res |= (uint16_t)(-(res < x));\n return res;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__sat_sub(uint16_t x, uint16_t y) {\n uint16_t res = (uint16_t)(x - y);\n res &= (uint16_t)(-(res <= x));\n return res;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__sat_add(uint32_t x, uint32_t y) {\n uint32" +
"_t res = (uint32_t)(x + y);\n res |= (uint32_t)(-(res < x));\n return res;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {\n uint32_t res = (uint32_t)(x - y);\n res &= (uint32_t)(-(res <= x));\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n uint64_t res = (uint64_t)(x + y);\n res |= (uint64_t)(-(res < x));\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n uint64_t res = (uint64_t)(x - y);\n res &= (uint64_t)(-(res <= x));\n return res;\n}\n\n" +
"" +
@@ -222,10 +227,12 @@ const BaseIOPrivateH = "" +
"" +
"// --------\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return (uint64_t)(n);\n}\n\nstatic inline void //\nwuffs_base__io_writer__limit(uint8_t** ptr_io2_w,\n uint8_t* iop_w,\n uint64_t limit) {\n if (((uint64_t)(*ptr_io2_w - iop_w)) > limit) {\n *ptr_io2_w = iop_w + limit;\n }\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n " +
" uint32_t distance) {\n if (!distance) {\n return 0;\n }\n uint8_t* p = *ptr_iop_w;\n if ((size_t)(p - io1_w) < (size_t)(distance)) {\n return 0;\n }\n uint8_t* q = p - distance;\n size_t n = (size_t)(io2_w - p);\n if ((size_t)(length) > n) {\n length = (uint32_t)(n);\n } else {\n n = (size_t)(length);\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // limited_copy_u32_from_history Wuffs method should also take an unroll hint\n // argument, and the cgen can look if that argument is the constant\n // expression '3'.\n //\n // See also wuffs_base__io_writer__limited_copy_u32_from_history_fast below.\n for (; n >= 3; n -= 3) {\n *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\n return length;\n}\n\n// wuffs_base__io_w" +
"riter__limited_copy_u32_from_history_fast is like the\n// wuffs_base__io_writer__limited_copy_u32_from_history function above, but has\n// stronger pre-conditions.\n//\n// The caller needs to prove that:\n// - length <= (io2_w - *ptr_iop_w)\n// - distance >= 1\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint8_t* q = p - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\n return length;\n}\n\n// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast" +
" is\n// like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function\n// above, but copies 8 byte chunks at a time.\n//\n// In terms of number of bytes copied, length is rounded up to a multiple of 8.\n// As a special case, a zero length rounds up to 8 (even though 0 is already a\n// multiple of 8), since there is always at least one 8 byte chunk copied.\n//\n// In terms of advancing *ptr_iop_w, length is not rounded up.\n//\n// The caller needs to prove that:\n// - (length + 8) <= (io2_w - *ptr_iop_w)\n// - distance >= 8\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(\n uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint8_t* q = p - distance;\n uint32_t n = length;\n while (1) {\n memcpy(p, q, 8);\n if (n <= 8) {\n p += n;\n break;\n }\n p += 8;\n q += 8;\n n -= 8;\n }\n *ptr_iop_w = p;\n ret" +
"urn length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_reader(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t length,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = length;\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n const uint8_t* iop_r = *ptr_iop_r;\n if (n > ((size_t)(io2_r - iop_r))) {\n n = (size_t)(io2_r - iop_r);\n }\n if (n > 0) {\n memmove(iop_w, iop_r, n);\n *ptr_iop_w += n;\n *ptr_iop_r += n;\n }\n return (uint32_t)(n);\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t length,\n " +
" wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return (uint32_t)(n);\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_writer__set(wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_w,\n uint8_t** ptr_io0_w,\n uint8_t** ptr_io1_w,\n uint8_t** ptr_io2_w,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_w = data.ptr;\n *ptr_io0_w = data.ptr;\n *ptr_io1_w = data.ptr;\n *ptr_io2_w = data.ptr + data.len;\n\n return b;\n}\n\n" +
"riter__limited_copy_u32_from_history_fast is like the\n// wuffs_base__io_writer__limited_copy_u32_from_history function above, but has\n// stronger pre-conditions.\n//\n// The caller needs to prove that:\n// - length <= (io2_w - *ptr_iop_w)\n// - distance >= 1\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint8_t* q = p - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\n return length;\n}\n\n// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_dist" +
"ance_1_fast\n// copies the previous byte (the one immediately before *ptr_iop_w), copying 8\n// byte chunks at a time. Each chunk contains 8 repetitions of the same byte.\n//\n// In terms of number of bytes copied, length is rounded up to a multiple of 8.\n// As a special case, a zero length rounds up to 8 (even though 0 is already a\n// multiple of 8), since there is always at least one 8 byte chunk copied.\n//\n// In terms of advancing *ptr_iop_w, length is not rounded up.\n//\n// The caller needs to prove that:\n// - (length + 8) <= (io2_w - *ptr_iop_w)\n// - distance == 1\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(\n uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint64_t x = p[-1];\n x |= x << 8;\n x |= x << 16;\n x |= x << 32;\n uint32_t n = length;\n while (1) {\n wuffs_base__poke_u64le__no_bounds_check(" +
"p, x);\n if (n <= 8) {\n p += n;\n break;\n }\n p += 8;\n n -= 8;\n }\n *ptr_iop_w = p;\n return length;\n}\n\n// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast is\n// like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function\n// above, but copies 8 byte chunks at a time.\n//\n// In terms of number of bytes copied, length is rounded up to a multiple of 8.\n// As a special case, a zero length rounds up to 8 (even though 0 is already a\n// multiple of 8), since there is always at least one 8 byte chunk copied.\n//\n// In terms of advancing *ptr_iop_w, length is not rounded up.\n//\n// The caller needs to prove that:\n// - (length + 8) <= (io2_w - *ptr_iop_w)\n// - distance >= 8\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(\n uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n u" +
"int8_t* q = p - distance;\n uint32_t n = length;\n while (1) {\n memcpy(p, q, 8);\n if (n <= 8) {\n p += n;\n break;\n }\n p += 8;\n q += 8;\n n -= 8;\n }\n *ptr_iop_w = p;\n return length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_reader(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t length,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = length;\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n const uint8_t* iop_r = *ptr_iop_r;\n if (n > ((size_t)(io2_r - iop_r))) {\n n = (size_t)(io2_r - iop_r);\n }\n if (n > 0) {\n memmove(iop_w, iop_r, n);\n *ptr_iop_w += n;\n *ptr_iop_r += n;\n }\n return (uint32_t)(n);\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_co" +
"py_u32_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return (uint32_t)(n);\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_writer__set(wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_w,\n uint8_t** ptr_io0_w,\n uint8_t** ptr_io1_w,\n uint8_t** ptr_io2_w,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_w = data.ptr;\n *ptr_io0_w = data.ptr;\n *ptr_io1_" +
"w = data.ptr;\n *ptr_io2_w = data.ptr + data.len;\n\n return b;\n}\n\n" +
"" +
"// ---------------- I/O (Utility)\n\n#define wuffs_base__utility__empty_io_reader wuffs_base__empty_io_reader\n#define wuffs_base__utility__empty_io_writer wuffs_base__empty_io_writer\n" +
""
@@ -706,45 +713,46 @@ const BasePixConvSubmoduleC = "" +
" size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), 0xFFFF000000000000 | (0x010101010101 * (uint64_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxxxxxx__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n " +
" size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint64_t s0 =\n ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(s + (0 * 2))));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0));\n\n s += 1 * 2;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__y__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len < src_len2) ? dst_len : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n d[0] = s[0];\n\n s += 1 * 2;\n d += 1 * 1;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__y__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len < src_len2) ? dst_len : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n d[0] = s[0];\n\n s += 1 * 2;\n d += 1 * 1;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__y_16le__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n " +
" size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n d[0] = s1;\n d[1] = s0;\n\n s += 1 * 2;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__transparent_black_src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n uint64_t num_pixels,\n uint32_t dst_pixfmt_bytes_per_pixel) {\n uint64_t n = ((uint64_t)dst_len) / dst_pixfmt_bytes_per_pixel;\n if (n > num_pixels) {\n n = num_pixels;\n }\n memset(dst_ptr, 0, ((size_t)(n * dst_pixfmt_bytes_per_pixel)));\n return n;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__transparent_black_src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n uint64_t num_pixels,\n uint32_t dst_pixfmt_bytes_per_pixel) {\n uint64_t n = ((uint64_t)dst_len) / dst_pixfmt_bytes_per_pixel;\n if (n > num_pixels) {\n n = num_pixels;\n }\n return n;\n}\n\n" +
"" +
"// --------\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return wuffs_base__pixel_swizzler__copy_1_1;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__y;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__xxx__y;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BA" +
"SE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__xxxx__y__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__xxxx__y;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__xxxxxxxx__y;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n " +
" wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return wuffs_base__pixel_swizzler__y__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__xxx__y_16be;\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__xxxx__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:\n" +
" case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__xxxxxxxx__y_16be;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(\n " +
" dst_palette.ptr, dst_palette.len, src_palette.ptr,\n src_palette.len, true) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgr_565__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgr_565__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n " +
" return NULL;\n }\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxx__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:" +
"\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxxxxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n " +
" if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_P" +
"REMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__" +
"func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n if (wuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(\n dst_palette.ptr, dst_palette.len, src_palette.ptr,\n src_palette.len, false) !=\n (WUFFS_BASE__PI" +
"XEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n if " +
"(wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxxxxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxxxxxx__index_binary_alpha__src_over;\n }\n return" +
" NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (b" +
"lend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgr_565(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__copy_2_2;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__bgr__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__bgr" +
"w__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__rgbw__bgr_565;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__bgr;\n\n case WUFFS_BASE__" +
"PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__copy_3_3;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__bgrw__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__swap_rgb_bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__bgrw__rgb;\n }\n return NULL;\n}\n\nstatic wuff" +
"s_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:" +
"\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n " +
" case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremu" +
"l__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpre" +
"mul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_8_8;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n " +
" return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src_over;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src;\n case WUF" +
"FS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_premul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE_" +
"_PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n s" +
"witch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEN" +
"D__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgrx(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__xxx__xxxx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__pixel_swizzler__bgrw__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT_" +
"_BGRA_NONPREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__copy_4_4;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__bgrw__rgbx;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base" +
"__pixel_swizzler__bgr_565__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__swap_rgb_bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__bgrw__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__copy_3_3;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__bgrw__bgr;\n }\n return NULL;\n}\n\nstatic wuffs" +
"_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgba_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n" +
" switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_" +
"premul__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul" +
"__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgba_premul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__rgba_premul__src;\n case WUFFS_BASE_" +
"_PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n " +
"if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;\n }\n ret" +
"urn NULL;\n }\n return NULL;\n}\n\n" +
" wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return wuffs_base__pixel_swizzler__y__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:\n return wuffs_base__pixel_swizzler__y_16le__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n return wuffs_base__pixel_swizzler__copy_2_2;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__xxx__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__xxx" +
"x__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__xxxxxxxx__y_16be;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;" +
"\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(\n dst_palette.ptr, dst_palette.len, src_palette.ptr,\n src_palette.len, true) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgr_565__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgr_565__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n " +
" dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxx__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_O" +
"VER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxxxxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__P" +
"ALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PI" +
"XEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgra_premul__ind" +
"ex_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n if (wuff" +
"s_base__pixel_swizzler__squash_align4_bgr_565_8888(\n dst_palette.ptr, dst_palette.len, src_palette.ptr,\n src_palette.len, false) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n " +
" }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_sw" +
"izzler__xxxxxxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxxxxxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette." +
"len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgr_565(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__copy_2_2;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__bgr__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL" +
":\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__bgrw__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__rgbw__bgr_565;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n " +
"wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__copy_3_3;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__bgrw__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__swap_rgb_bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch" +
"__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__bgrw__rgb;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src;\n case WUFFS_" +
"BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__b" +
"gra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n retur" +
"n wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src_over;\n }\n " +
" return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_8_8;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x" +
"16le__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src_over;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT" +
"__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_premul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n " +
" return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__S" +
"RC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n " +
" return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgrx(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__xxx__xxxx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n " +
" case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__pixel_swizzler__bgrw__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__copy_4_4;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__bgrw__rgbx;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 " +
"src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__swap_rgb_bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__bgrw__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__copy_3_3;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_" +
"PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__bgrw__bgr;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgba_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src;\n case WUFFS_B" +
"ASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src_over;\n }\n " +
" return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return" +
" wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgba_premul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_" +
"BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src_over;\n }\n " +
" return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return w" +
"uffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\n" +
"" +
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_pixfmt,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n if (!p) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n p->private_impl.func = NULL;\n p->private_impl.transparent_black_func = NULL;\n p->private_impl.dst_pixfmt_bytes_per_pixel = 0;\n p->private_impl.src_pixfmt_bytes_per_pixel = 0;\n\n wuffs_base__pixel_swizzler__func func = NULL;\n wuffs_base__pixel_swizzler__transparent_black_func transparent_black_func =\n NULL;\n\n uint32_t dst_pixfmt_bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&dst_pixfmt);\n if ((dst_pixfmt_bits_per_pixel == " +
"0) ||\n ((dst_pixfmt_bits_per_pixel & 7) != 0)) {\n return wuffs_base__make_status(\n wuffs_base__error__unsupported_pixel_swizzler_option);\n }\n\n uint32_t src_pixfmt_bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&src_pixfmt);\n if ((src_pixfmt_bits_per_pixel == 0) ||\n ((src_pixfmt_bits_per_pixel & 7) != 0)) {\n return wuffs_base__make_status(\n wuffs_base__error__unsupported_pixel_swizzler_option);\n }\n\n // TODO: support many more formats.\n\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n transparent_black_func =\n wuffs_base__pixel_swizzler__transparent_black_src;\n break;\n\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n transparent_black_func =\n wuffs_base__pixel_swizzler__transparent_black_src_over;\n break;\n }\n\n switch (src_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n func = wuffs_base__pixel_swizzler__prepare__y(p, dst_pixfmt, dst_palette,\n src_palette" +
@@ -849,10 +857,10 @@ const AuxImageHh = "" +
const AuxJsonCc = "" +
"// ---------------- Auxiliary - JSON\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeJsonResult::DecodeJsonResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nDecodeJsonCallbacks::~DecodeJsonCallbacks() {}\n\nvoid //\nDecodeJsonCallbacks::Done(DecodeJsonResult& result,\n sync_io::Input& input,\n IOBuffer& buffer) {}\n\nconst char DecodeJson_BadJsonPointer[] =\n \"wuffs_aux::DecodeJson: bad JSON Pointer\";\nconst char DecodeJson_NoMatch[] = \"wuffs_aux::DecodeJson: no match\";\n\n" +
"" +
"// --------\n\n#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \\\n while (tok_buf.meta.ri >= tok_buf.meta.wi) { \\\n if (tok_status.repr == nullptr) { \\\n } else if (tok_status.repr == wuffs_base__suspension__short_write) { \\\n tok_buf.compact(); \\\n } else if (tok_status.repr == wuffs_base__suspension__short_read) { \\\n if (!io_error_message.empty()) { \\\n ret_error_message = std::move(io_error_message); \\\n goto done; \\\n } else if (cursor_index != io_buf->meta.ri) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: bad cursor_index\"; \\\n goto done; \\\n } else if (io_buf->meta.closed" +
") { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is closed\"; \\\n goto done; \\\n } \\\n io_buf->compact(); \\\n if (io_buf->meta.wi >= io_buf->data.len) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is full\"; \\\n goto done; \\\n } \\\n cursor_index = io_buf->meta.ri; \\\n io_error_message = input.CopyIn(io_buf); \\\n } else { \\\n ret_" +
"error_message = tok_status.message(); \\\n goto done; \\\n } \\\n if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN\"; \\\n goto done; \\\n } \\\n wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8(); \\\n tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf); \\\n } \\\n wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \\\n uint64_t token_len = token.length(); \\\n if ((io_buf->meta.ri < cursor_index) || " +
" \\\n ((io_buf->meta.ri - cursor_index) < token_len)) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: bad token indexes\"; \\\n goto done; \\\n } \\\n uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \\\n (void)(token_ptr); \\\n cursor_index += static_cast<size_t>(token_len)\n\n" +
"// --------\n\n#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \\\n while (tok_buf.meta.ri >= tok_buf.meta.wi) { \\\n if (tok_status.repr == nullptr) { \\\n goto done; \\\n } else if (tok_status.repr == wuffs_base__suspension__short_write) { \\\n tok_buf.compact(); \\\n } else if (tok_status.repr == wuffs_base__suspension__short_read) { \\\n if (!io_error_message.empty()) { \\\n ret_error_message = std::move(io_error_message); \\\n goto done; \\\n } else if (cursor_index != io_buf->meta.ri) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: bad cursor_index\"; " +
" \\\n goto done; \\\n } else if (io_buf->meta.closed) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is closed\"; \\\n goto done; \\\n } \\\n io_buf->compact(); \\\n if (io_buf->meta.wi >= io_buf->data.len) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is full\"; \\\n goto done; \\\n } \\\n cursor_index = io_buf->meta.ri; \\\n i" +
"o_error_message = input.CopyIn(io_buf); \\\n } else { \\\n ret_error_message = tok_status.message(); \\\n goto done; \\\n } \\\n tok_status = \\\n dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \\\n } \\\n wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \\\n uint64_t token_len = token.length(); \\\n if ((io_buf->meta.ri < cursor_index) || \\\n ((io_buf->meta.ri - cursor_index) < token_len)) { \\\n ret_error_message = \\\n \"wuffs_au" +
"x::DecodeJson: internal error: bad token indexes\"; \\\n goto done; \\\n } \\\n uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \\\n (void)(token_ptr); \\\n cursor_index += static_cast<size_t>(token_len)\n\n" +
"" +
"// --------\n\nnamespace {\n\n// DecodeJson_SplitJsonPointer returns (\"bar\", 8) for (\"/foo/bar/b~1z/qux\", 5,\n// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.\n//\n// The string returned is unescaped. If calling it again, this time with i=8,\n// the \"b~1z\" substring would be returned as \"b/z\".\nstd::pair<std::string, size_t> //\nDecodeJson_SplitJsonPointer(std::string& s,\n size_t i,\n bool allow_tilde_n_tilde_r_tilde_t) {\n std::string fragment;\n while (i < s.size()) {\n char c = s[i];\n if (c == '/') {\n break;\n } else if (c != '~') {\n fragment.push_back(c);\n i++;\n continue;\n }\n i++;\n if (i >= s.size()) {\n return std::make_pair(std::string(), 0);\n }\n c = s[i];\n if (c == '0') {\n fragment.push_back('~');\n i++;\n continue;\n } else if (c == '1') {\n fragment.push_back('/');\n i++;\n continue;\n } else if (allow_tilde_n_tilde_r_tilde_t) {\n if (c == 'n') {\n " +
"fragment.push_back('\\n');\n i++;\n continue;\n } else if (c == 'r') {\n fragment.push_back('\\r');\n i++;\n continue;\n } else if (c == 't') {\n fragment.push_back('\\t');\n i++;\n continue;\n }\n }\n return std::make_pair(std::string(), 0);\n }\n return std::make_pair(std::move(fragment), i);\n}\n\n" +
@@ -865,13 +873,14 @@ const AuxJsonCc = "" +
"__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {\n continue;\n }\n\n // Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that\n // we're only peeking at the next token.\n tok_buf.meta.ri--;\n cursor_index -= static_cast<size_t>(token_len);\n\n if ((vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) &&\n (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP)) {\n return DecodeJson_NoMatch;\n }\n return \"\";\n } // check_that_a_value_follows\n\nfail:\n return \"wuffs_aux::DecodeJson: internal error: unexpected token\";\ndone:\n return ret_error_message;\n}\n\n} // namespace\n\n" +
"" +
"// --------\n\nDecodeJsonResult //\nDecodeJson(DecodeJsonCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks,\n std::string json_pointer) {\n // Prepare the wuffs_base__io_buffer and the resultant error_message.\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[4096]);\n fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);\n io_buf = &fallback_io_buf;\n }\n // cursor_index is discussed at\n // https://nigeltao.github.io/blog/2020/jsonptr.html#the-cursor-index\n size_t cursor_index = 0;\n std::string ret_error_message;\n std::string io_error_message;\n\n do {\n // Prepare the low-level JSON decoder.\n wuffs_json__decoder::unique_ptr dec = wuffs_json__decoder::alloc();\n if (!dec) {\n ret_error_message = " +
"\"wuffs_aux::DecodeJson: out of memory\";\n goto done;\n }\n bool allow_tilde_n_tilde_r_tilde_t = false;\n for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\n if (quirks.ptr[i] ==\n WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {\n allow_tilde_n_tilde_r_tilde_t = true;\n }\n }\n\n // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.\n wuffs_base__token tok_array[256];\n wuffs_base__token_buffer tok_buf =\n wuffs_base__slice_token__writer(wuffs_base__make_slice_token(\n &tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));\n wuffs_base__status tok_status = wuffs_base__make_status(nullptr);\n\n // Prepare other state.\n uint32_t depth = 0;\n std::string str;\n\n // Walk the (optional) JSON Pointer.\n for (size_t i = 0; i < json_pointer.size();) {\n if (json_pointer[i] != '/') {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n std::pair<" +
"std::string, size_t> split = DecodeJson_SplitJsonPointer(\n json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);\n i = std::move(split.second);\n if (i == 0) {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n ret_error_message = DecodeJson_WalkJsonPointerFragment(\n tok_buf, tok_status, dec, io_buf, io_error_message, cursor_index,\n input, split.first);\n if (!ret_error_message.empty()) {\n goto done;\n }\n }\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n switch (vbc) {\n case WUFFS_BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n ret_error_message = callbacks.Push(static_cas" +
"t<uint32_t>(vbd));\n if (!ret_error_message.empty()) {\n goto done;\n }\n depth++;\n continue;\n }\n ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));\n depth--;\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } else if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(token_ptr));\n str.append(ptr, static_cast<size_t>(token_len));\n } else {\n goto fail;\n }\n if (token.continued()) {\n continue;\n }\n ret_error_message = callbacks.AppendTextString(std::move(str));\n str.clear();\n goto parsed_a_value;\n }\n\n case WUFFS_" +
"BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&u[0]));\n str.append(ptr, n);\n if (token.continued()) {\n continue;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__LITERAL: {\n ret_error_message =\n (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL)\n ? callbacks.AppendNull()\n : callbacks.AppendBool(vbd &\n WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT) {\n " +
" if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED) {\n wuffs_base__result_i64 r = wuffs_base__parse_number_i64(\n wuffs_base__make_slice_u8(token_ptr,\n static_cast<size_t>(token_len)),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendI64(r.value);\n goto parsed_a_value;\n }\n }\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT) {\n wuffs_base__result_f64 r = wuffs_base__parse_number_f64(\n wuffs_base__make_slice_u8(token_ptr,\n static_cast<size_t>(token_len)),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendF64(r.value);\n goto parsed_a_value;\n }" +
"\n }\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee" +
"_754_bit_representation__from_u64_to_f64(\n 0x7FFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n }\n goto fail;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::DecodeJson: internal error: unexpected token\";\n goto done;\n\n parsed_a_value:\n if (!ret_error_message.empty() || (depth == 0)) {\n goto done;\n }\n }\n } while (false);\n\ndone:\n DecodeJsonResult result(\n std::move(ret_error_message),\n wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));\n callbacks.Done(result, input, *io_buf);\n return result;\n}\n\n#undef WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n" +
"\"wuffs_aux::DecodeJson: out of memory\";\n goto done;\n } else if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {\n ret_error_message =\n \"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN\";\n goto done;\n }\n bool allow_tilde_n_tilde_r_tilde_t = false;\n for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\n if (quirks.ptr[i] ==\n WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {\n allow_tilde_n_tilde_r_tilde_t = true;\n }\n }\n\n // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.\n wuffs_base__token tok_array[256];\n wuffs_base__token_buffer tok_buf =\n wuffs_base__slice_token__writer(wuffs_base__make_slice_token(\n &tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));\n wuffs_base__status tok_status =\n dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());\n\n // Prepare other state.\n uint32_t depth = 0;\n std::string str;" +
"\n\n // Walk the (optional) JSON Pointer.\n for (size_t i = 0; i < json_pointer.size();) {\n if (json_pointer[i] != '/') {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(\n json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);\n i = split.second;\n if (i == 0) {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n ret_error_message = DecodeJson_WalkJsonPointerFragment(\n tok_buf, tok_status, dec, io_buf, io_error_message, cursor_index,\n input, split.first);\n if (!ret_error_message.empty()) {\n goto done;\n }\n }\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n switch (vbc) {\n case WUFFS_" +
"BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n ret_error_message = callbacks.Push(static_cast<uint32_t>(vbd));\n if (!ret_error_message.empty()) {\n goto done;\n }\n depth++;\n continue;\n }\n ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));\n depth--;\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } else if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(token_ptr));\n str.append(ptr, static_cast<size_t>(token_len));\n } else {\n goto fail;\n }\n " +
"if (token.continued()) {\n continue;\n }\n ret_error_message = callbacks.AppendTextString(std::move(str));\n str.clear();\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&u[0]));\n str.append(ptr, n);\n if (token.continued()) {\n continue;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__LITERAL: {\n ret_error_message =\n (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL)\n ? callbacks.AppendNull()\n : callbacks.AppendBool(vbd &\n " +
" WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED) {\n wuffs_base__result_i64 r = wuffs_base__parse_number_i64(\n wuffs_base__make_slice_u8(token_ptr,\n static_cast<size_t>(token_len)),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendI64(r.value);\n goto parsed_a_value;\n }\n }\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT) {\n wuffs_base__result_f64 r = wuffs_base__parse_number_f64(\n wuffs_base__make_slice_u8(token_ptr,\n static_cast<size_t>(token_len)),\n " +
" WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendF64(r.value);\n goto parsed_a_value;\n }\n }\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xF" +
"FFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n }\n goto fail;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::DecodeJson: internal error: unexpected token\";\n goto done;\n\n parsed_a_value:\n // If an error was encountered, we are done. Otherwise, (depth == 0)\n // after parsing a value is equivalent to having decoded the entire JSON\n // value (for an empty json_pointer query) or having decoded the\n // pointed-to JSON value (for a non-empty json_pointer query). In the\n // latter case, we are also done.\n //\n // However, if quirks like WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER or\n // WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF are pass" +
"ed, decoding\n // the entire JSON value should also consume any trailing filler, in case\n // the DecodeJson caller wants to subsequently check that the input is\n // completely exhausted (and otherwise raise \"valid JSON followed by\n // further (unexpected) data\"). We aren't done yet. Instead, keep the\n // loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's\n // decode_tokens returns an ok status.\n if (!ret_error_message.empty() ||\n ((depth == 0) && !json_pointer.empty())) {\n goto done;\n }\n }\n } while (false);\n\ndone:\n DecodeJsonResult result(\n std::move(ret_error_message),\n wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));\n callbacks.Done(result, input, *io_buf);\n return result;\n}\n\n#undef WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n" +
""
const AuxJsonHh = "" +
+1
View File
@@ -587,6 +587,7 @@ var cTypeNames = [...]string{
t.IDARMNeonU32x4: "uint32x4_t",
t.IDARMNeonU64x2: "uint64x2_t",
t.IDX86M128I: "__m128i",
t.IDX86M256I: "__m256i",
}
const noSuchCOperator = " no_such_C_operator "
+11 -5
View File
@@ -271,7 +271,7 @@ func (g *gen) writeFuncImpl(b *buffer, n *a.Func) error {
if n.Effect().Coroutine() {
b.writex(k.bBodySuspend)
} else if k.hasGotoOK {
b.writes("\ngoto ok;\nok:\n") // The goto avoids the "unused label" warning.
b.writes("\nok:\n")
}
}
@@ -292,6 +292,9 @@ func (g *gen) gatherFuncImpl(_ *buffer, n *a.Func) error {
if n.Public() && n.Effect().Coroutine() {
g.numPublicCoroutines[n.Receiver()]++
coroID = g.numPublicCoroutines[n.Receiver()]
if coroID >= 0x8000 {
return fmt.Errorf("too many coroutines for %q", n.Receiver().Str(g.tm))
}
}
g.currFunk = funk{
@@ -498,11 +501,17 @@ func (g *gen) writeFuncImplBody(b *buffer) error {
}
func (g *gen) writeFuncImplBodySuspend(b *buffer) error {
if (g.currFunk.coroSuspPoint > 0) || g.currFunk.astFunc.Effect().Coroutine() {
if !g.currFunk.hasGotoOK {
b.writes("\ngoto ok;") // Avoid the "unused label" warning.
}
b.writes("\nok:\n")
}
if g.currFunk.coroSuspPoint > 0 {
// We've reached the end of the function body. Reset the coroutine
// suspension point so that the next call to this function starts at
// the top.
b.writes("\ngoto ok;\nok:\n") // The goto avoids the "unused label" warning.
b.printf("self->private_impl.%s%s[0] = 0;\n",
pPrefix, g.currFunk.astFunc.FuncName().Str(g.tm))
b.writes("goto exit;\n}\n\n") // Close the coroutine switch.
@@ -520,9 +529,6 @@ func (g *gen) writeFuncImplBodySuspend(b *buffer) error {
return err
}
b.writes("\n")
} else if g.currFunk.astFunc.Effect().Coroutine() {
b.writes("\ngoto ok;\nok:\n") // The goto avoids the "unused label" warning.
}
return nil
}
+9
View File
@@ -279,6 +279,14 @@ func cpuArchCNames(asserts []*a.Node) (caMacro string, caName string, caAttribut
caMacro, caName, caAttribute =
"X86_64", "x86_sse42",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")"
case t.IDX86AVX2:
caMacro, caName, caAttribute =
"X86_64", "x86_avx2",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2,avx2\")"
case t.IDX86BMI2:
caMacro, caName, caAttribute =
"X86_64", "x86_bmi2",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"bmi2\")"
}
}
}
@@ -670,6 +678,7 @@ func (g *gen) writeCoroSuspPoint(b *buffer, maybeSuspend bool) error {
macro := ""
if maybeSuspend {
macro = "_MAYBE_SUSPEND"
g.currFunk.hasGotoOK = true
}
b.printf("WUFFS_BASE__COROUTINE_SUSPENSION_POINT%s(%d);\n", macro, g.currFunk.coroSuspPoint)
return nil
+1 -1
View File
@@ -491,7 +491,7 @@ func (n *Assert) IsChooseCPUArch() bool {
return false
}
switch rhs.Ident() {
case t.IDARMCRC32, t.IDARMNeon, t.IDX86SSE42, t.IDX86AVX2:
case t.IDARMCRC32, t.IDARMNeon, t.IDX86SSE42, t.IDX86AVX2, t.IDX86BMI2:
return true
}
return false
+62
View File
@@ -306,6 +306,9 @@ var Types = []string{
"x86_sse42_utility",
"x86_m128i",
"x86_avx2_utility",
"x86_m256i",
}
var Funcs = [][]string{
@@ -549,6 +552,13 @@ var funcsOther = [...]string{
// For now, that's all implicitly checked (i.e. hard coded).
"io_writer.limited_copy_u32_from_history_8_byte_chunks_fast!(up_to: u32, distance: u32) u32",
// TODO: this should have explicit pre-conditions:
// - (up_to + 8) <= this.length()
// - distance == 1
// - distance <= this.history_length()
// For now, that's all implicitly checked (i.e. hard coded).
"io_writer.limited_copy_u32_from_history_8_byte_chunks_distance_1_fast!(up_to: u32, distance: u32) u32",
// ---- token_writer
"token_writer.write_simple_token_fast!(" +
@@ -766,6 +776,58 @@ var funcsOther = [...]string{
"x86_m128i._mm_unpacklo_epi64(b: x86_m128i) x86_m128i",
"x86_m128i._mm_unpacklo_epi8(b: x86_m128i) x86_m128i",
"x86_m128i._mm_xor_si128(b: x86_m128i) x86_m128i",
// ---- x86_avx2_utility
"x86_avx2_utility.make_m256i_multiple_u8(" +
"a00: u8, a01: u8, a02: u8, a03: u8," +
"a04: u8, a05: u8, a06: u8, a07: u8," +
"a08: u8, a09: u8, a10: u8, a11: u8," +
"a12: u8, a13: u8, a14: u8, a15: u8," +
"a16: u8, a17: u8, a18: u8, a19: u8," +
"a20: u8, a21: u8, a22: u8, a23: u8," +
"a24: u8, a25: u8, a26: u8, a27: u8," +
"a28: u8, a29: u8, a30: u8, a31: u8) x86_m256i",
"x86_avx2_utility.make_m256i_multiple_u16(" +
"a00: u16, a01: u16, a02: u16, a03: u16," +
"a04: u16, a05: u16, a06: u16, a07: u16," +
"a08: u16, a09: u16, a10: u16, a11: u16," +
"a12: u16, a13: u16, a14: u16, a15: u16) x86_m256i",
"x86_avx2_utility.make_m256i_multiple_u32(" +
"a00: u32, a01: u32, a02: u32, a03: u32," +
"a04: u32, a05: u32, a06: u32, a07: u32) x86_m256i",
"x86_avx2_utility.make_m256i_multiple_u64(" +
"a00: u64, a01: u64, a02: u64, a03: u64) x86_m256i",
"x86_avx2_utility.make_m256i_repeat_u8(a: u8) x86_m256i",
"x86_avx2_utility.make_m256i_repeat_u16(a: u16) x86_m256i",
"x86_avx2_utility.make_m256i_repeat_u32(a: u32) x86_m256i",
"x86_avx2_utility.make_m256i_repeat_u64(a: u64) x86_m256i",
"x86_avx2_utility.make_m256i_slice256(a: slice base.u8) x86_m256i",
"x86_avx2_utility.make_m256i_zeroes() x86_m256i",
// ---- x86_m256i
// TODO: generate these methods automatically?
"x86_m256i._mm256_add_epi16(b: x86_m256i) x86_m256i",
"x86_m256i._mm256_add_epi32(b: x86_m256i) x86_m256i",
"x86_m256i._mm256_add_epi64(b: x86_m256i) x86_m256i",
"x86_m256i._mm256_add_epi8(b: x86_m256i) x86_m256i",
"x86_m256i._mm256_extracti128_si256(imm8: u32) x86_m128i",
"x86_m256i._mm256_madd_epi16(b: x86_m256i) x86_m256i",
"x86_m256i._mm256_maddubs_epi16(b: x86_m256i) x86_m256i",
"x86_m256i._mm256_sad_epu8(b: x86_m256i) x86_m256i",
"x86_m256i._mm256_slli_epi16(imm8: u32) x86_m256i",
"x86_m256i._mm256_slli_epi32(imm8: u32) x86_m256i",
"x86_m256i._mm256_slli_epi64(imm8: u32) x86_m256i",
"x86_m256i._mm256_slli_si256(imm8: u32) x86_m256i",
"x86_m256i._mm256_srli_epi16(imm8: u32) x86_m256i",
"x86_m256i._mm256_srli_epi32(imm8: u32) x86_m256i",
"x86_m256i._mm256_srli_epi64(imm8: u32) x86_m256i",
"x86_m256i._mm256_srli_si256(imm8: u32) x86_m256i",
}
var Interfaces = []string{
+31 -7
View File
@@ -1160,13 +1160,18 @@ func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (bounds, e
return bounds{}, err
}
} else if method == t.IDLimitedCopyU32FromHistory8ByteChunksDistance1Fast {
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), eight, nil, one); err != nil {
return bounds{}, err
}
} else if method == t.IDLimitedCopyU32FromHistory8ByteChunksFast {
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), eight, eight); err != nil {
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), eight, eight, nil); err != nil {
return bounds{}, err
}
} else if method == t.IDLimitedCopyU32FromHistoryFast {
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), nil, one); err != nil {
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), nil, one, nil); err != nil {
return bounds{}, err
}
@@ -1272,10 +1277,11 @@ func (q *checker) canUndoByte(recv *a.Expr) error {
return fmt.Errorf("check: could not prove %s.can_undo_byte()", recv.Str(q.tm))
}
func (q *checker) canLimitedCopyU32FromHistoryFast(recv *a.Expr, args []*a.Node, adj *big.Int, minDistance *big.Int) error {
func (q *checker) canLimitedCopyU32FromHistoryFast(recv *a.Expr, args []*a.Node, adj *big.Int, minDistance *big.Int, exactDistance *big.Int) error {
// As per cgen's io-private.h, there are three pre-conditions:
// - (upTo + adj) <= this.length()
// - distance >= minDistance
// - either (distance >= minDistance) or (distance == exactDistance),
// depending on which of minDistance and exactDistance is non-nil.
// - distance <= this.history_length()
//
// adj may be nil, in which case (upTo + adj) is just upTo.
@@ -1335,8 +1341,8 @@ check0:
}
// Check "distance >= minDistance".
check1:
for {
check1a:
for minDistance != nil {
for _, x := range q.facts {
if x.Operator() != t.IDXBinaryGreaterEq {
continue
@@ -1347,11 +1353,29 @@ check1:
if rcv := x.RHS().AsExpr().ConstValue(); (rcv == nil) || (rcv.Cmp(minDistance) < 0) {
continue
}
break check1
break check1a
}
return fmt.Errorf("check: could not prove %s >= %v", distance.Str(q.tm), minDistance)
}
// Check "distance == exactDistance".
check1b:
for exactDistance != nil {
for _, x := range q.facts {
if x.Operator() != t.IDXBinaryEqEq {
continue
}
if lhs := x.LHS().AsExpr(); !lhs.Eq(distance) {
continue
}
if rcv := x.RHS().AsExpr().ConstValue(); (rcv == nil) || (rcv.Cmp(exactDistance) != 0) {
continue
}
break check1b
}
return fmt.Errorf("check: could not prove %s == %v", distance.Str(q.tm), exactDistance)
}
// Check "distance <= this.history_length()".
check2:
for {
+6
View File
@@ -91,6 +91,9 @@ var (
typeExprX86SSE42Utility = a.NewTypeExpr(0, t.IDBase, t.IDX86SSE42Utility, nil, nil, nil)
typeExprX86M128I = a.NewTypeExpr(0, t.IDBase, t.IDX86M128I, nil, nil, nil)
typeExprX86AVX2Utility = a.NewTypeExpr(0, t.IDBase, t.IDX86AVX2Utility, nil, nil, nil)
typeExprX86M256I = a.NewTypeExpr(0, t.IDBase, t.IDX86M256I, nil, nil, nil)
typeExprSliceU8 = a.NewTypeExpr(t.IDSlice, 0, 0, nil, nil, typeExprU8)
typeExprTableU8 = a.NewTypeExpr(t.IDTable, 0, 0, nil, nil, typeExprU8)
)
@@ -154,6 +157,9 @@ var builtInTypeMap = typeMap{
t.IDX86SSE42Utility: typeExprX86SSE42Utility,
t.IDX86M128I: typeExprX86M128I,
t.IDX86AVX2Utility: typeExprX86AVX2Utility,
t.IDX86M256I: typeExprX86M256I,
}
func (c *Checker) parseBuiltInFuncs(m map[t.QQID]*a.Func, ss []string) error {
+3
View File
@@ -28,6 +28,7 @@ const (
cpuArchBitsARMCRC32 = cpuArchBits(0x00000001)
cpuArchBitsARMNeon = cpuArchBits(0x00000002)
cpuArchBitsX86SSE42 = cpuArchBits(0x00000004)
cpuArchBitsX86AVX2 = cpuArchBits(0x00000008)
)
func calcCPUArchBits(n *a.Func) (ret cpuArchBits) {
@@ -43,6 +44,8 @@ func calcCPUArchBits(n *a.Func) (ret cpuArchBits) {
ret |= cpuArchBitsARMNeon
case t.IDX86SSE42:
ret |= cpuArchBitsX86SSE42
case t.IDX86AVX2:
ret |= cpuArchBitsX86SSE42 | cpuArchBitsX86AVX2
}
}
return ret
+20 -14
View File
@@ -504,13 +504,14 @@ const (
IDSkipU32 = ID(0x16B)
IDSkipU32Fast = ID(0x16C)
IDCopyFromSlice = ID(0x170)
IDLimitedCopyU32FromHistory = ID(0x171)
IDLimitedCopyU32FromHistory8ByteChunksFast = ID(0x172)
IDLimitedCopyU32FromHistoryFast = ID(0x173)
IDLimitedCopyU32FromReader = ID(0x174)
IDLimitedCopyU32FromSlice = ID(0x175)
IDLimitedCopyU32ToSlice = ID(0x176)
IDCopyFromSlice = ID(0x170)
IDLimitedCopyU32FromHistory = ID(0x171)
IDLimitedCopyU32FromHistory8ByteChunksDistance1Fast = ID(0x172)
IDLimitedCopyU32FromHistory8ByteChunksFast = ID(0x173)
IDLimitedCopyU32FromHistoryFast = ID(0x174)
IDLimitedCopyU32FromReader = ID(0x175)
IDLimitedCopyU32FromSlice = ID(0x176)
IDLimitedCopyU32ToSlice = ID(0x177)
// -------- 0x180 block.
@@ -709,8 +710,10 @@ const (
IDX86SSE42Utility = ID(0x391)
IDX86AVX2 = ID(0x392)
IDX86AVX2Utility = ID(0x393)
IDX86BMI2 = ID(0x394)
IDX86M128I = ID(0x3A0)
IDX86M256I = ID(0x3A1)
)
var builtInsByID = [nBuiltInIDs]string{
@@ -928,13 +931,14 @@ var builtInsByID = [nBuiltInIDs]string{
IDSkipU32: "skip_u32",
IDSkipU32Fast: "skip_u32_fast",
IDCopyFromSlice: "copy_from_slice",
IDLimitedCopyU32FromHistory: "limited_copy_u32_from_history",
IDLimitedCopyU32FromHistory8ByteChunksFast: "limited_copy_u32_from_history_8_byte_chunks_fast",
IDLimitedCopyU32FromHistoryFast: "limited_copy_u32_from_history_fast",
IDLimitedCopyU32FromReader: "limited_copy_u32_from_reader",
IDLimitedCopyU32FromSlice: "limited_copy_u32_from_slice",
IDLimitedCopyU32ToSlice: "limited_copy_u32_to_slice",
IDCopyFromSlice: "copy_from_slice",
IDLimitedCopyU32FromHistory: "limited_copy_u32_from_history",
IDLimitedCopyU32FromHistory8ByteChunksDistance1Fast: "limited_copy_u32_from_history_8_byte_chunks_distance_1_fast",
IDLimitedCopyU32FromHistory8ByteChunksFast: "limited_copy_u32_from_history_8_byte_chunks_fast",
IDLimitedCopyU32FromHistoryFast: "limited_copy_u32_from_history_fast",
IDLimitedCopyU32FromReader: "limited_copy_u32_from_reader",
IDLimitedCopyU32FromSlice: "limited_copy_u32_from_slice",
IDLimitedCopyU32ToSlice: "limited_copy_u32_to_slice",
// -------- 0x180 block.
@@ -1120,8 +1124,10 @@ var builtInsByID = [nBuiltInIDs]string{
IDX86SSE42Utility: "x86_sse42_utility",
IDX86AVX2: "x86_avx2",
IDX86AVX2Utility: "x86_avx2_utility",
IDX86BMI2: "x86_bmi2",
IDX86M128I: "x86_m128i",
IDX86M256I: "x86_m256i",
}
var builtInsByName = map[string]ID{}
+685 -121
View File
@@ -10,8 +10,12 @@
// Wuffs' C code is generated automatically, not hand-written. These warnings'
// costs outweigh the benefits.
//
// The "elif defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wunreachable-code"
#pragma GCC diagnostic ignored "-Wunused-function"
@@ -19,6 +23,16 @@
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
#elif defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunused-function"
#pragma clang diagnostic ignored "-Wunused-parameter"
#if defined(__cplusplus)
#pragma clang diagnostic ignored "-Wold-style-cast"
#endif
#endif
// Copyright 2017 The Wuffs Authors.
@@ -99,8 +113,8 @@ extern "C" {
// To simplify Wuffs code, "cpu_arch >= arm_xxx" requires xxx but also
// unaligned little-endian load/stores.
#if defined(__ARM_FEATURE_UNALIGNED) && defined(__BYTE_ORDER__) && \
(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
#if defined(__ARM_FEATURE_UNALIGNED) && !defined(__native_client__) && \
defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
// Not all gcc versions define __ARM_ACLE, even if they support crc32
// intrinsics. Look for __ARM_FEATURE_CRC32 instead.
#if defined(__ARM_FEATURE_CRC32)
@@ -115,11 +129,13 @@ extern "C" {
// Similarly, "cpu_arch >= x86_sse42" requires SSE4.2 but also PCLMUL and
// POPCNT. This is checked at runtime via cpuid, not at compile time.
#if defined(__x86_64__)
//
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
#if defined(__x86_64__) && !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__)
#endif // defined(__x86_64__) && !defined(__native_client__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
@@ -187,6 +203,82 @@ wuffs_base__cpu_arch__have_arm_neon() {
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
}
static inline bool //
wuffs_base__cpu_arch__have_x86_avx2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
// - bit_SSE4_2 = (1 << 20)
const unsigned int avx2_ecx1 = 0x00900002;
// clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
#if defined(__GNUC__)
unsigned int eax7 = 0;
unsigned int ebx7 = 0;
unsigned int ecx7 = 0;
unsigned int edx7 = 0;
if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&
((ebx7 & avx2_ebx7) == avx2_ebx7)) {
unsigned int eax1 = 0;
unsigned int ebx1 = 0;
unsigned int ecx1 = 0;
unsigned int edx1 = 0;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
((ecx1 & avx2_ecx1) == avx2_ecx1)) {
return true;
}
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x7[4];
__cpuidex(x7, 7, 0);
if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) {
int x1[4];
__cpuid(x1, 1);
if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) {
return true;
}
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_bmi2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
// clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
#if defined(__GNUC__)
unsigned int eax7 = 0;
unsigned int ebx7 = 0;
unsigned int ecx7 = 0;
unsigned int edx7 = 0;
if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&
((ebx7 & bmi2_ebx7) == bmi2_ebx7)) {
return true;
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x7[4];
__cpuidex(x7, 7, 0);
if ((((unsigned int)(x7[1])) & bmi2_ebx7) == bmi2_ebx7) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_sse42() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -202,13 +294,16 @@ wuffs_base__cpu_arch__have_x86_sse42() {
unsigned int ebx1 = 0;
unsigned int ecx1 = 0;
unsigned int edx1 = 0;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1)) {
return (ecx1 & sse42_ecx1) == sse42_ecx1;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
((ecx1 & sse42_ecx1) == sse42_ecx1)) {
return true;
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x[4];
__cpuid(x, 1);
return (((unsigned int)(x[2])) & sse42_ecx1) == sse42_ecx1;
int x1[4];
__cpuid(x1, 1);
if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
@@ -711,6 +806,56 @@ wuffs_base__u64__max(uint64_t x, uint64_t y) {
// --------
static inline uint8_t //
wuffs_base__u8__rotate_left(uint8_t x, uint32_t n) {
n &= 7;
return ((uint8_t)(x << n)) | ((uint8_t)(x >> (8 - n)));
}
static inline uint8_t //
wuffs_base__u8__rotate_right(uint8_t x, uint32_t n) {
n &= 7;
return ((uint8_t)(x >> n)) | ((uint8_t)(x << (8 - n)));
}
static inline uint16_t //
wuffs_base__u16__rotate_left(uint16_t x, uint32_t n) {
n &= 15;
return ((uint16_t)(x << n)) | ((uint16_t)(x >> (16 - n)));
}
static inline uint16_t //
wuffs_base__u16__rotate_right(uint16_t x, uint32_t n) {
n &= 15;
return ((uint16_t)(x >> n)) | ((uint16_t)(x << (16 - n)));
}
static inline uint32_t //
wuffs_base__u32__rotate_left(uint32_t x, uint32_t n) {
n &= 31;
return ((uint32_t)(x << n)) | ((uint32_t)(x >> (32 - n)));
}
static inline uint32_t //
wuffs_base__u32__rotate_right(uint32_t x, uint32_t n) {
n &= 31;
return ((uint32_t)(x >> n)) | ((uint32_t)(x << (32 - n)));
}
static inline uint64_t //
wuffs_base__u64__rotate_left(uint64_t x, uint32_t n) {
n &= 63;
return ((uint64_t)(x << n)) | ((uint64_t)(x >> (64 - n)));
}
static inline uint64_t //
wuffs_base__u64__rotate_right(uint64_t x, uint32_t n) {
n &= 63;
return ((uint64_t)(x >> n)) | ((uint64_t)(x << (64 - n)));
}
// --------
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
@@ -6966,6 +7111,10 @@ struct wuffs_deflate__decoder__struct {
uint32_t p_decode_blocks[1];
uint32_t p_decode_uncompressed[1];
uint32_t p_init_dynamic_huffman[1];
wuffs_base__status (*choosy_decode_huffman_fast64)(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
uint32_t p_decode_huffman_slow[1];
} private_impl;
@@ -9962,26 +10111,16 @@ extern "C" {
// Its (non-zero) value is arbitrary, based on md5sum("disabled").
#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)
// Denote intentional fallthroughs for -Wimplicit-fallthrough.
//
// The order matters here. Clang also defines "__GNUC__".
#if defined(__clang__) && defined(__cplusplus) && (__cplusplus >= 201103L)
#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]
#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)
#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))
#else
#define WUFFS_BASE__FALLTHROUGH
#endif
// Use switch cases for coroutine suspension points, similar to the technique
// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
//
// The implicit fallthrough is intentional.
//
// We use trivial macros instead of an explicit assignment and case statement
// so that clang-format doesn't get confused by the unusual "case"s.
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \
coro_susp_point = n; \
WUFFS_BASE__FALLTHROUGH; \
case n:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \
@@ -10435,6 +10574,46 @@ wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast
// copies the previous byte (the one immediately before *ptr_iop_w), copying 8
// byte chunks at a time. Each chunk contains 8 repetitions of the same byte.
//
// In terms of number of bytes copied, length is rounded up to a multiple of 8.
// As a special case, a zero length rounds up to 8 (even though 0 is already a
// multiple of 8), since there is always at least one 8 byte chunk copied.
//
// In terms of advancing *ptr_iop_w, length is not rounded up.
//
// The caller needs to prove that:
// - (length + 8) <= (io2_w - *ptr_iop_w)
// - distance == 1
// - distance <= (*ptr_iop_w - io1_w)
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
uint8_t** ptr_iop_w,
uint8_t* io1_w,
uint8_t* io2_w,
uint32_t length,
uint32_t distance) {
uint8_t* p = *ptr_iop_w;
uint64_t x = p[-1];
x |= x << 8;
x |= x << 16;
x |= x << 32;
uint32_t n = length;
while (1) {
wuffs_base__poke_u64le__no_bounds_check(p, x);
if (n <= 8) {
p += n;
break;
}
p += 8;
n -= 8;
}
*ptr_iop_w = p;
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast is
// like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function
// above, but copies 8 byte chunks at a time.
@@ -19020,6 +19199,34 @@ wuffs_base__pixel_swizzler__y__y_16be(uint8_t* dst_ptr,
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__y_16le__y_16be(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len2 = src_len / 2;
size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
d[0] = s1;
d[1] = s0;
s += 1 * 2;
d += 1 * 2;
n -= 1;
}
return len;
}
// --------
static uint64_t //
@@ -19106,13 +19313,18 @@ wuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__Y:
return wuffs_base__pixel_swizzler__y__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
return wuffs_base__pixel_swizzler__y_16le__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
return wuffs_base__pixel_swizzler__copy_2_2;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
return wuffs_base__pixel_swizzler__bgr_565__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
case WUFFS_BASE__PIXEL_FORMAT__RGB:
return wuffs_base__pixel_swizzler__xxx__y_16be;
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
@@ -20754,8 +20966,8 @@ wuffs_adler32__hasher__up_x86_sse42(
__m128i v_ones = {0};
__m128i v_weights__left = {0};
__m128i v_weights_right = {0};
__m128i v_p__left = {0};
__m128i v_p_right = {0};
__m128i v_q__left = {0};
__m128i v_q_right = {0};
__m128i v_v1 = {0};
__m128i v_v2 = {0};
__m128i v_v2j = {0};
@@ -20786,13 +20998,13 @@ wuffs_adler32__hasher__up_x86_sse42(
v_p.len = 32;
uint8_t* i_end0_p = v_p.ptr + (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 32) * 32);
while (v_p.ptr < i_end0_p) {
v_p__left = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr));
v_p_right = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16));
v_q__left = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr));
v_q_right = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16));
v_v2j = _mm_add_epi32(v_v2j, v_v1);
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_p__left, v_zeroes));
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_p_right, v_zeroes));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_p__left, v_weights__left)));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_p_right, v_weights_right)));
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_q__left, v_zeroes));
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_q_right, v_zeroes));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_q__left, v_weights__left)));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_q_right, v_weights_right)));
v_p.ptr += 32;
}
v_p.len = 0;
@@ -21926,7 +22138,6 @@ wuffs_bmp__decoder__decode_image_config(
}
self->private_impl.f_call_sequence = 3;
goto ok;
ok:
self->private_impl.p_decode_image_config[0] = 0;
goto exit;
@@ -22035,7 +22246,6 @@ wuffs_bmp__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -22223,7 +22433,6 @@ wuffs_bmp__decoder__decode_frame(
}
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -22337,7 +22546,6 @@ wuffs_bmp__decoder__swizzle_none(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22600,7 +22808,6 @@ wuffs_bmp__decoder__swizzle_rle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22741,7 +22948,6 @@ wuffs_bmp__decoder__swizzle_bitfields(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22910,7 +23116,6 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -23996,7 +24201,6 @@ wuffs_cbor__decoder__decode_tokens(
label__outer__break:;
self->private_impl.f_end_of_data = true;
goto ok;
ok:
self->private_impl.p_decode_tokens[0] = 0;
goto exit;
@@ -24614,6 +24818,13 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_sse42(
@@ -24733,6 +24944,9 @@ wuffs_crc32__ieee_hasher__update_u32(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
wuffs_base__cpu_arch__have_arm_crc32() ? &wuffs_crc32__ieee_hasher__up_arm_crc32 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
#endif
@@ -24920,6 +25134,125 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
// ‼ WUFFS MULTI-FILE SECTION -arm_crc32
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func crc32.ieee_hasher.up_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
uint32_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_k = {0};
__m128i v_x0 = {0};
__m128i v_x1 = {0};
__m128i v_x2 = {0};
__m128i v_x3 = {0};
__m128i v_y0 = {0};
__m128i v_y1 = {0};
__m128i v_y2 = {0};
__m128i v_y3 = {0};
uint64_t v_tail_index = 0;
v_s = (4294967295 ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0) && ((15 & ((uint32_t)(0xFFF & (uintptr_t)(a_x.ptr)))) != 0)) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0][(((uint8_t)((v_s & 255))) ^ a_x.ptr[0])] ^ (v_s >> 8));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1);
}
if (((uint64_t)(a_x.len)) < 64) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
uint8_t* i_end0_p = i_slice_p.ptr + i_slice_p.len;
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0][(((uint8_t)((v_s & 255))) ^ v_p.ptr[0])] ^ (v_s >> 8));
v_p.ptr += 1;
}
v_p.len = 0;
}
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K1K2));
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, 64);
v_p.ptr = i_slice_p.ptr;
v_p.len = 64;
uint8_t* i_end0_p = v_p.ptr + (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 64) * 64);
while (v_p.ptr < i_end0_p) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_y1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0));
v_y2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(0));
v_y3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(17));
v_x2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(17));
v_x3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(_mm_xor_si128(v_x0, v_y0), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 0)));
v_x1 = _mm_xor_si128(_mm_xor_si128(v_x1, v_y1), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16)));
v_x2 = _mm_xor_si128(_mm_xor_si128(v_x2, v_y2), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 32)));
v_x3 = _mm_xor_si128(_mm_xor_si128(v_x3, v_y3), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 48)));
v_p.ptr += 64;
}
v_p.len = 0;
}
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K3K4));
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(v_x0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(v_x0, v_x3);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_x1 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(16));
v_x2 = _mm_set_epi32((int32_t)(0), (int32_t)(4294967295), (int32_t)(0), (int32_t)(4294967295));
v_x0 = _mm_srli_si128(v_x0, (int32_t)(8));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ));
v_x1 = _mm_srli_si128(v_x0, (int32_t)(4));
v_x0 = _mm_and_si128(v_x0, v_x2);
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_PXMU));
v_x1 = _mm_and_si128(v_x0, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(16));
v_x1 = _mm_and_si128(v_x1, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_s = ((uint32_t)(_mm_extract_epi32(v_x0, (int32_t)(1))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551552u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
uint8_t* i_end0_p = i_slice_p.ptr + i_slice_p.len;
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0][(((uint8_t)((v_s & 255))) ^ v_p.ptr[0])] ^ (v_s >> 8));
v_p.ptr += 1;
}
v_p.len = 0;
}
}
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc32.ieee_hasher.up_x86_sse42
@@ -25161,6 +25494,14 @@ wuffs_deflate__decoder__init_huff(
uint32_t a_n_codes1,
uint32_t a_base_symbol);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_bmi2(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast32(
wuffs_deflate__decoder* self,
@@ -25173,6 +25514,12 @@ wuffs_deflate__decoder__decode_huffman_fast64(
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_slow(
wuffs_deflate__decoder* self,
@@ -25234,6 +25581,8 @@ wuffs_deflate__decoder__initialize(
}
}
self->private_impl.choosy_decode_huffman_fast64 = &wuffs_deflate__decoder__decode_huffman_fast64__choosy_default;
self->private_impl.magic = WUFFS_BASE__MAGIC;
self->private_impl.vtable_for__wuffs_base__io_transformer.vtable_name =
wuffs_base__io_transformer__vtable_name;
@@ -25380,6 +25729,11 @@ wuffs_deflate__decoder__transform_io(
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
self->private_impl.choosy_decode_huffman_fast64 = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
#endif
self->private_impl.choosy_decode_huffman_fast64);
while (true) {
v_mark = ((uint64_t)(iop_a_dst - io0_a_dst));
{
@@ -25407,7 +25761,6 @@ wuffs_deflate__decoder__transform_io(
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -25565,7 +25918,6 @@ wuffs_deflate__decoder__decode_blocks(
}
}
goto ok;
ok:
self->private_impl.p_decode_blocks[0] = 0;
goto exit;
@@ -25685,7 +26037,6 @@ wuffs_deflate__decoder__decode_uncompressed(
}
}
goto ok;
ok:
self->private_impl.p_decode_uncompressed[0] = 0;
goto exit;
@@ -26268,6 +26619,216 @@ wuffs_deflate__decoder__init_huff(
return wuffs_base__make_status(NULL);
}
// ‼ WUFFS MULTI-FILE SECTION +x86_bmi2
// -------- func deflate.decoder.decode_huffman_bmi2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_bmi2(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_bits = 0;
uint32_t v_n_bits = 0;
uint32_t v_table_entry = 0;
uint32_t v_table_entry_n_bits = 0;
uint64_t v_lmask = 0;
uint64_t v_dmask = 0;
uint32_t v_redir_top = 0;
uint32_t v_redir_mask = 0;
uint32_t v_length = 0;
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_dst) {
io0_a_dst = a_dst->data.ptr;
io1_a_dst = io0_a_dst + a_dst->meta.wi;
iop_a_dst = io1_a_dst;
io2_a_dst = io0_a_dst + a_dst->data.len;
if (a_dst->meta.closed) {
io2_a_dst = iop_a_dst;
}
}
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) {
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;
}
if ((self->private_impl.f_n_bits >= 8) || ((self->private_impl.f_bits >> (self->private_impl.f_n_bits & 7)) != 0)) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_n_bits);
goto exit;
}
v_bits = ((uint64_t)(self->private_impl.f_bits));
v_n_bits = self->private_impl.f_n_bits;
v_lmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
v_dmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
label__loop__continue:;
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 8)) {
v_bits |= ((uint64_t)(wuffs_base__peek_u64le__no_bounds_check(iop_a_src) << (v_n_bits & 63)));
iop_a_src += ((63 - (v_n_bits & 63)) >> 3);
v_n_bits |= 56;
v_table_entry = self->private_data.f_huffs[0][(v_bits & v_lmask)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
if ((v_table_entry >> 31) != 0) {
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(((v_table_entry >> 8) & 255)))), iop_a_dst += 1);
goto label__loop__continue;
} else if ((v_table_entry >> 30) != 0) {
} else if ((v_table_entry >> 29) != 0) {
self->private_impl.f_end_of_block = true;
goto label__loop__break;
} else if ((v_table_entry >> 28) != 0) {
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
v_table_entry = self->private_data.f_huffs[0][((v_redir_top + (((uint32_t)((v_bits & 4294967295))) & v_redir_mask)) & 1023)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
if ((v_table_entry >> 31) != 0) {
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(((v_table_entry >> 8) & 255)))), iop_a_dst += 1);
goto label__loop__continue;
} else if ((v_table_entry >> 30) != 0) {
} else if ((v_table_entry >> 29) != 0) {
self->private_impl.f_end_of_block = true;
goto label__loop__break;
} else if ((v_table_entry >> 28) != 0) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
} else if ((v_table_entry >> 27) != 0) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code);
goto exit;
} else {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
}
} else if ((v_table_entry >> 27) != 0) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code);
goto exit;
} else {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
}
v_length = (((v_table_entry >> 8) & 255) + 3);
v_table_entry_n_bits = ((v_table_entry >> 4) & 15);
if (v_table_entry_n_bits > 0) {
v_length = (((v_length + 253 + ((uint32_t)(((v_bits) & WUFFS_BASE__LOW_BITS_MASK__U64(v_table_entry_n_bits))))) & 255) + 3);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
}
v_table_entry = self->private_data.f_huffs[1][(v_bits & v_dmask)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
if ((v_table_entry >> 28) == 1) {
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
v_table_entry = self->private_data.f_huffs[1][((v_redir_top + (((uint32_t)((v_bits & 4294967295))) & v_redir_mask)) & 1023)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
}
if ((v_table_entry >> 24) != 64) {
if ((v_table_entry >> 24) == 8) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code);
goto exit;
}
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
}
v_dist_minus_1 = ((v_table_entry >> 8) & 32767);
v_table_entry_n_bits = ((v_table_entry >> 4) & 15);
v_dist_minus_1 = ((v_dist_minus_1 + ((uint32_t)(((v_bits) & WUFFS_BASE__LOW_BITS_MASK__U64(v_table_entry_n_bits))))) & 32767);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
while (true) {
if (((uint64_t)((v_dist_minus_1 + 1))) > ((uint64_t)(iop_a_dst - io0_a_dst))) {
v_hlen = 0;
v_hdist = ((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) - ((uint64_t)(iop_a_dst - io0_a_dst)))));
if (v_length > v_hdist) {
v_length -= v_hdist;
v_hlen = v_hdist;
} else {
v_hlen = v_length;
v_length = 0;
}
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
wuffs_base__io_writer__limited_copy_u32_from_slice(
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
if (v_length == 0) {
goto label__loop__continue;
}
if ((((uint64_t)((v_dist_minus_1 + 1))) > ((uint64_t)(iop_a_dst - io0_a_dst))) || (((uint64_t)(v_length)) > ((uint64_t)(io2_a_dst - iop_a_dst))) || (((uint64_t)((v_length + 8))) > ((uint64_t)(io2_a_dst - iop_a_dst)))) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_distance);
goto exit;
}
}
if ((v_dist_minus_1 + 1) >= 8) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else if ((v_dist_minus_1 + 1) == 1) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else {
wuffs_base__io_writer__limited_copy_u32_from_history_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
}
goto label__0__break;
}
label__0__break:;
}
label__loop__break:;
if (v_n_bits > 63) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_n_bits);
goto exit;
}
while (v_n_bits >= 8) {
v_n_bits -= 8;
if (iop_a_src > io1_a_src) {
iop_a_src--;
} else {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_i_o);
goto exit;
}
}
self->private_impl.f_bits = ((uint32_t)((v_bits & ((((uint64_t)(1)) << v_n_bits) - 1))));
self->private_impl.f_n_bits = v_n_bits;
if ((self->private_impl.f_n_bits >= 8) || ((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_n_bits);
goto exit;
}
goto exit;
exit:
if (a_dst) {
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
// -------- func deflate.decoder.decode_huffman_fast32
static wuffs_base__status
@@ -26525,6 +27086,14 @@ wuffs_deflate__decoder__decode_huffman_fast64(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src) {
return (*self->private_impl.choosy_decode_huffman_fast64)(self, a_dst, a_src);
}
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_bits = 0;
@@ -26680,6 +27249,9 @@ wuffs_deflate__decoder__decode_huffman_fast64(
if ((v_dist_minus_1 + 1) >= 8) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else if ((v_dist_minus_1 + 1) == 1) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else {
wuffs_base__io_writer__limited_copy_u32_from_history_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
@@ -27055,7 +27627,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_huffman_slow[0] = 0;
goto exit;
@@ -27327,7 +27898,6 @@ wuffs_lzw__decoder__transform_io(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -27571,7 +28141,6 @@ wuffs_lzw__decoder__write_to(
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
goto ok;
ok:
self->private_impl.p_write_to[0] = 0;
goto exit;
@@ -28127,7 +28696,6 @@ wuffs_gif__decoder__tell_me_more(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
self->private_impl.p_tell_me_more[0] = 0;
goto exit;
@@ -28395,7 +28963,6 @@ wuffs_gif__decoder__decode_frame_config(
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frame_configs_value, 1);
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -29061,7 +29628,6 @@ wuffs_gif__decoder__decode_extension(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_extension[0] = 0;
goto exit;
@@ -29130,7 +29696,6 @@ wuffs_gif__decoder__skip_blocks(
iop_a_src += self->private_data.s_skip_blocks[0].scratch;
}
goto ok;
ok:
self->private_impl.p_skip_blocks[0] = 0;
goto exit;
@@ -29349,7 +29914,6 @@ wuffs_gif__decoder__decode_ae(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_ae[0] = 0;
goto exit;
@@ -29819,7 +30383,6 @@ wuffs_gif__decoder__decode_id_part1(
wuffs_lzw__decoder__set_literal_width(&self->private_data.f_lzw, ((uint32_t)(v_lw)));
self->private_impl.f_previous_lzw_decode_ended_abruptly = true;
goto ok;
ok:
self->private_impl.p_decode_id_part1[0] = 0;
goto exit;
@@ -30026,7 +30589,6 @@ wuffs_gif__decoder__decode_id_part2(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_id_part2[0] = 0;
goto exit;
@@ -30636,7 +31198,6 @@ wuffs_gzip__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -32093,7 +32654,6 @@ wuffs_json__decoder__decode_tokens(
}
self->private_impl.f_end_of_data = true;
goto ok;
ok:
self->private_impl.p_decode_tokens[0] = 0;
goto exit;
@@ -32395,7 +32955,6 @@ wuffs_json__decoder__decode_leading(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_decode_leading[0] = 0;
goto exit;
@@ -32576,7 +33135,6 @@ wuffs_json__decoder__decode_comment(
}
}
goto ok;
ok:
self->private_impl.p_decode_comment[0] = 0;
goto exit;
@@ -32737,7 +33295,6 @@ wuffs_json__decoder__decode_inf_nan(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_inf_nan[0] = 0;
goto exit;
@@ -32883,7 +33440,6 @@ wuffs_json__decoder__decode_trailer(
}
label__outer__break:;
goto ok;
ok:
self->private_impl.p_decode_trailer[0] = 0;
goto exit;
@@ -33358,7 +33914,6 @@ wuffs_nie__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -33467,7 +34022,6 @@ wuffs_nie__decoder__decode_frame(
label__0__break:;
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -33557,7 +34111,6 @@ wuffs_nie__decoder__swizzle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -34157,7 +34710,6 @@ wuffs_zlib__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -36309,7 +36861,6 @@ wuffs_png__decoder__decode_image_config(
}
self->private_impl.f_call_sequence = 3;
goto ok;
ok:
self->private_impl.p_decode_image_config[0] = 0;
goto exit;
@@ -36388,7 +36939,7 @@ wuffs_png__decoder__decode_ihdr(
}
v_a32 = t_0;
}
if (v_a32 >= 2147483648) {
if ((v_a32 == 0) || (v_a32 >= 2147483648)) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
} else if (v_a32 >= 16777216) {
@@ -36425,7 +36976,7 @@ wuffs_png__decoder__decode_ihdr(
}
v_a32 = t_1;
}
if (v_a32 >= 2147483648) {
if ((v_a32 == 0) || (v_a32 >= 2147483648)) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
} else if (v_a32 >= 16777216) {
@@ -36558,7 +37109,7 @@ wuffs_png__decoder__assign_filter_distance(
self->private_impl.f_src_pixfmt = 536870920;
self->private_impl.f_filter_distance = 1;
} else if (self->private_impl.f_depth == 16) {
self->private_impl.f_dst_pixfmt = 536870920;
self->private_impl.f_dst_pixfmt = 536870923;
self->private_impl.f_src_pixfmt = 537919499;
self->private_impl.f_filter_distance = 2;
}
@@ -37035,7 +37586,6 @@ wuffs_png__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -37162,7 +37712,6 @@ wuffs_png__decoder__decode_frame(
label__0__break:;
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -37461,7 +38010,6 @@ wuffs_png__decoder__decode_pass(
}
}
goto ok;
ok:
self->private_impl.p_decode_pass[0] = 0;
goto exit;
@@ -38265,7 +38813,6 @@ wuffs_wbmp__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -38430,7 +38977,6 @@ wuffs_wbmp__decoder__decode_frame(
}
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -39507,54 +40053,50 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
// --------
#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \
while (tok_buf.meta.ri >= tok_buf.meta.wi) { \
if (tok_status.repr == nullptr) { \
} else if (tok_status.repr == wuffs_base__suspension__short_write) { \
tok_buf.compact(); \
} else if (tok_status.repr == wuffs_base__suspension__short_read) { \
if (!io_error_message.empty()) { \
ret_error_message = std::move(io_error_message); \
goto done; \
} else if (cursor_index != io_buf->meta.ri) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad cursor_index"; \
goto done; \
} else if (io_buf->meta.closed) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is closed"; \
goto done; \
} \
io_buf->compact(); \
if (io_buf->meta.wi >= io_buf->data.len) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is full"; \
goto done; \
} \
cursor_index = io_buf->meta.ri; \
io_error_message = input.CopyIn(io_buf); \
} else { \
ret_error_message = tok_status.message(); \
goto done; \
} \
if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN"; \
goto done; \
} \
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8(); \
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf); \
} \
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
uint64_t token_len = token.length(); \
if ((io_buf->meta.ri < cursor_index) || \
((io_buf->meta.ri - cursor_index) < token_len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad token indexes"; \
goto done; \
} \
uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \
(void)(token_ptr); \
#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \
while (tok_buf.meta.ri >= tok_buf.meta.wi) { \
if (tok_status.repr == nullptr) { \
goto done; \
} else if (tok_status.repr == wuffs_base__suspension__short_write) { \
tok_buf.compact(); \
} else if (tok_status.repr == wuffs_base__suspension__short_read) { \
if (!io_error_message.empty()) { \
ret_error_message = std::move(io_error_message); \
goto done; \
} else if (cursor_index != io_buf->meta.ri) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad cursor_index"; \
goto done; \
} else if (io_buf->meta.closed) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is closed"; \
goto done; \
} \
io_buf->compact(); \
if (io_buf->meta.wi >= io_buf->data.len) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is full"; \
goto done; \
} \
cursor_index = io_buf->meta.ri; \
io_error_message = input.CopyIn(io_buf); \
} else { \
ret_error_message = tok_status.message(); \
goto done; \
} \
tok_status = \
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \
} \
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
uint64_t token_len = token.length(); \
if ((io_buf->meta.ri < cursor_index) || \
((io_buf->meta.ri - cursor_index) < token_len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad token indexes"; \
goto done; \
} \
uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \
(void)(token_ptr); \
cursor_index += static_cast<size_t>(token_len)
// --------
@@ -39825,6 +40367,10 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
if (!dec) {
ret_error_message = "wuffs_aux::DecodeJson: out of memory";
goto done;
} else if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN";
goto done;
}
bool allow_tilde_n_tilde_r_tilde_t = false;
for (size_t i = 0; i < quirks.len; i++) {
@@ -39840,7 +40386,8 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
wuffs_base__token_buffer tok_buf =
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
&tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
wuffs_base__status tok_status =
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());
// Prepare other state.
uint32_t depth = 0;
@@ -39854,7 +40401,7 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
}
std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(
json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);
i = std::move(split.second);
i = split.second;
if (i == 0) {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
@@ -39989,7 +40536,22 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done;
parsed_a_value:
if (!ret_error_message.empty() || (depth == 0)) {
// If an error was encountered, we are done. Otherwise, (depth == 0)
// after parsing a value is equivalent to having decoded the entire JSON
// value (for an empty json_pointer query) or having decoded the
// pointed-to JSON value (for a non-empty json_pointer query). In the
// latter case, we are also done.
//
// However, if quirks like WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER or
// WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF are passed, decoding
// the entire JSON value should also consume any trailing filler, in case
// the DecodeJson caller wants to subsequently check that the input is
// completely exhausted (and otherwise raise "valid JSON followed by
// further (unexpected) data"). We aren't done yet. Instead, keep the
// loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's
// decode_tokens returns an ok status.
if (!ret_error_message.empty() ||
((depth == 0) && !json_pointer.empty())) {
goto done;
}
}
@@ -40016,6 +40578,8 @@ done:
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#endif
#endif // WUFFS_INCLUDE_GUARD
+690 -126
View File
@@ -10,8 +10,12 @@
// Wuffs' C code is generated automatically, not hand-written. These warnings'
// costs outweigh the benefits.
//
// The "elif defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wunreachable-code"
#pragma GCC diagnostic ignored "-Wunused-function"
@@ -19,6 +23,16 @@
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
#elif defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunused-function"
#pragma clang diagnostic ignored "-Wunused-parameter"
#if defined(__cplusplus)
#pragma clang diagnostic ignored "-Wold-style-cast"
#endif
#endif
// Copyright 2017 The Wuffs Authors.
@@ -70,15 +84,15 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// c86ac5baef05b2e373b818eca0cf2c9c38785197 committed on 2021-04-03.
// 6a30c1ede0dc765fbbc443b2536b7691485be9fb committed on 2021-07-18.
#define WUFFS_VERSION 0x000030000
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 3
#define WUFFS_VERSION_PATCH 0
#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.1"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3024
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20210403
#define WUFFS_VERSION_STRING "0.3.0-beta.1+3024.20210403"
#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.7"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3069
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20210718
#define WUFFS_VERSION_STRING "0.3.0-beta.7+3069.20210718"
// ---------------- Configuration
@@ -100,8 +114,8 @@ extern "C" {
// To simplify Wuffs code, "cpu_arch >= arm_xxx" requires xxx but also
// unaligned little-endian load/stores.
#if defined(__ARM_FEATURE_UNALIGNED) && defined(__BYTE_ORDER__) && \
(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
#if defined(__ARM_FEATURE_UNALIGNED) && !defined(__native_client__) && \
defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
// Not all gcc versions define __ARM_ACLE, even if they support crc32
// intrinsics. Look for __ARM_FEATURE_CRC32 instead.
#if defined(__ARM_FEATURE_CRC32)
@@ -116,11 +130,13 @@ extern "C" {
// Similarly, "cpu_arch >= x86_sse42" requires SSE4.2 but also PCLMUL and
// POPCNT. This is checked at runtime via cpuid, not at compile time.
#if defined(__x86_64__)
//
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
#if defined(__x86_64__) && !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__)
#endif // defined(__x86_64__) && !defined(__native_client__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
@@ -188,6 +204,82 @@ wuffs_base__cpu_arch__have_arm_neon() {
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
}
static inline bool //
wuffs_base__cpu_arch__have_x86_avx2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
// - bit_SSE4_2 = (1 << 20)
const unsigned int avx2_ecx1 = 0x00900002;
// clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
#if defined(__GNUC__)
unsigned int eax7 = 0;
unsigned int ebx7 = 0;
unsigned int ecx7 = 0;
unsigned int edx7 = 0;
if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&
((ebx7 & avx2_ebx7) == avx2_ebx7)) {
unsigned int eax1 = 0;
unsigned int ebx1 = 0;
unsigned int ecx1 = 0;
unsigned int edx1 = 0;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
((ecx1 & avx2_ecx1) == avx2_ecx1)) {
return true;
}
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x7[4];
__cpuidex(x7, 7, 0);
if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) {
int x1[4];
__cpuid(x1, 1);
if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) {
return true;
}
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_bmi2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
// clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
#if defined(__GNUC__)
unsigned int eax7 = 0;
unsigned int ebx7 = 0;
unsigned int ecx7 = 0;
unsigned int edx7 = 0;
if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&
((ebx7 & bmi2_ebx7) == bmi2_ebx7)) {
return true;
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x7[4];
__cpuidex(x7, 7, 0);
if ((((unsigned int)(x7[1])) & bmi2_ebx7) == bmi2_ebx7) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_sse42() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -203,13 +295,16 @@ wuffs_base__cpu_arch__have_x86_sse42() {
unsigned int ebx1 = 0;
unsigned int ecx1 = 0;
unsigned int edx1 = 0;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1)) {
return (ecx1 & sse42_ecx1) == sse42_ecx1;
if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
((ecx1 & sse42_ecx1) == sse42_ecx1)) {
return true;
}
#elif defined(_MSC_VER) // defined(__GNUC__)
int x[4];
__cpuid(x, 1);
return (((unsigned int)(x[2])) & sse42_ecx1) == sse42_ecx1;
int x1[4];
__cpuid(x1, 1);
if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#endif // defined(__GNUC__); defined(_MSC_VER)
@@ -712,6 +807,56 @@ wuffs_base__u64__max(uint64_t x, uint64_t y) {
// --------
static inline uint8_t //
wuffs_base__u8__rotate_left(uint8_t x, uint32_t n) {
n &= 7;
return ((uint8_t)(x << n)) | ((uint8_t)(x >> (8 - n)));
}
static inline uint8_t //
wuffs_base__u8__rotate_right(uint8_t x, uint32_t n) {
n &= 7;
return ((uint8_t)(x >> n)) | ((uint8_t)(x << (8 - n)));
}
static inline uint16_t //
wuffs_base__u16__rotate_left(uint16_t x, uint32_t n) {
n &= 15;
return ((uint16_t)(x << n)) | ((uint16_t)(x >> (16 - n)));
}
static inline uint16_t //
wuffs_base__u16__rotate_right(uint16_t x, uint32_t n) {
n &= 15;
return ((uint16_t)(x >> n)) | ((uint16_t)(x << (16 - n)));
}
static inline uint32_t //
wuffs_base__u32__rotate_left(uint32_t x, uint32_t n) {
n &= 31;
return ((uint32_t)(x << n)) | ((uint32_t)(x >> (32 - n)));
}
static inline uint32_t //
wuffs_base__u32__rotate_right(uint32_t x, uint32_t n) {
n &= 31;
return ((uint32_t)(x >> n)) | ((uint32_t)(x << (32 - n)));
}
static inline uint64_t //
wuffs_base__u64__rotate_left(uint64_t x, uint32_t n) {
n &= 63;
return ((uint64_t)(x << n)) | ((uint64_t)(x >> (64 - n)));
}
static inline uint64_t //
wuffs_base__u64__rotate_right(uint64_t x, uint32_t n) {
n &= 63;
return ((uint64_t)(x >> n)) | ((uint64_t)(x << (64 - n)));
}
// --------
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
@@ -6967,6 +7112,10 @@ struct wuffs_deflate__decoder__struct {
uint32_t p_decode_blocks[1];
uint32_t p_decode_uncompressed[1];
uint32_t p_init_dynamic_huffman[1];
wuffs_base__status (*choosy_decode_huffman_fast64)(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
uint32_t p_decode_huffman_slow[1];
} private_impl;
@@ -9963,26 +10112,16 @@ extern "C" {
// Its (non-zero) value is arbitrary, based on md5sum("disabled").
#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)
// Denote intentional fallthroughs for -Wimplicit-fallthrough.
//
// The order matters here. Clang also defines "__GNUC__".
#if defined(__clang__) && defined(__cplusplus) && (__cplusplus >= 201103L)
#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]
#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)
#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))
#else
#define WUFFS_BASE__FALLTHROUGH
#endif
// Use switch cases for coroutine suspension points, similar to the technique
// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
//
// The implicit fallthrough is intentional.
//
// We use trivial macros instead of an explicit assignment and case statement
// so that clang-format doesn't get confused by the unusual "case"s.
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \
coro_susp_point = n; \
WUFFS_BASE__FALLTHROUGH; \
case n:;
#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \
@@ -10436,6 +10575,46 @@ wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast
// copies the previous byte (the one immediately before *ptr_iop_w), copying 8
// byte chunks at a time. Each chunk contains 8 repetitions of the same byte.
//
// In terms of number of bytes copied, length is rounded up to a multiple of 8.
// As a special case, a zero length rounds up to 8 (even though 0 is already a
// multiple of 8), since there is always at least one 8 byte chunk copied.
//
// In terms of advancing *ptr_iop_w, length is not rounded up.
//
// The caller needs to prove that:
// - (length + 8) <= (io2_w - *ptr_iop_w)
// - distance == 1
// - distance <= (*ptr_iop_w - io1_w)
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
uint8_t** ptr_iop_w,
uint8_t* io1_w,
uint8_t* io2_w,
uint32_t length,
uint32_t distance) {
uint8_t* p = *ptr_iop_w;
uint64_t x = p[-1];
x |= x << 8;
x |= x << 16;
x |= x << 32;
uint32_t n = length;
while (1) {
wuffs_base__poke_u64le__no_bounds_check(p, x);
if (n <= 8) {
p += n;
break;
}
p += 8;
n -= 8;
}
*ptr_iop_w = p;
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast is
// like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function
// above, but copies 8 byte chunks at a time.
@@ -19021,6 +19200,34 @@ wuffs_base__pixel_swizzler__y__y_16be(uint8_t* dst_ptr,
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__y_16le__y_16be(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len2 = src_len / 2;
size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
d[0] = s1;
d[1] = s0;
s += 1 * 2;
d += 1 * 2;
n -= 1;
}
return len;
}
// --------
static uint64_t //
@@ -19107,13 +19314,18 @@ wuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__Y:
return wuffs_base__pixel_swizzler__y__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
return wuffs_base__pixel_swizzler__y_16le__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
return wuffs_base__pixel_swizzler__copy_2_2;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
return wuffs_base__pixel_swizzler__bgr_565__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
case WUFFS_BASE__PIXEL_FORMAT__RGB:
return wuffs_base__pixel_swizzler__xxx__y_16be;
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
@@ -20755,8 +20967,8 @@ wuffs_adler32__hasher__up_x86_sse42(
__m128i v_ones = {0};
__m128i v_weights__left = {0};
__m128i v_weights_right = {0};
__m128i v_p__left = {0};
__m128i v_p_right = {0};
__m128i v_q__left = {0};
__m128i v_q_right = {0};
__m128i v_v1 = {0};
__m128i v_v2 = {0};
__m128i v_v2j = {0};
@@ -20787,13 +20999,13 @@ wuffs_adler32__hasher__up_x86_sse42(
v_p.len = 32;
uint8_t* i_end0_p = v_p.ptr + (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 32) * 32);
while (v_p.ptr < i_end0_p) {
v_p__left = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr));
v_p_right = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16));
v_q__left = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr));
v_q_right = _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16));
v_v2j = _mm_add_epi32(v_v2j, v_v1);
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_p__left, v_zeroes));
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_p_right, v_zeroes));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_p__left, v_weights__left)));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_p_right, v_weights_right)));
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_q__left, v_zeroes));
v_v1 = _mm_add_epi32(v_v1, _mm_sad_epu8(v_q_right, v_zeroes));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_q__left, v_weights__left)));
v_v2k = _mm_add_epi32(v_v2k, _mm_madd_epi16(v_ones, _mm_maddubs_epi16(v_q_right, v_weights_right)));
v_p.ptr += 32;
}
v_p.len = 0;
@@ -21927,7 +22139,6 @@ wuffs_bmp__decoder__decode_image_config(
}
self->private_impl.f_call_sequence = 3;
goto ok;
ok:
self->private_impl.p_decode_image_config[0] = 0;
goto exit;
@@ -22036,7 +22247,6 @@ wuffs_bmp__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -22224,7 +22434,6 @@ wuffs_bmp__decoder__decode_frame(
}
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -22338,7 +22547,6 @@ wuffs_bmp__decoder__swizzle_none(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22601,7 +22809,6 @@ wuffs_bmp__decoder__swizzle_rle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22742,7 +22949,6 @@ wuffs_bmp__decoder__swizzle_bitfields(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22911,7 +23117,6 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -23997,7 +24202,6 @@ wuffs_cbor__decoder__decode_tokens(
label__outer__break:;
self->private_impl.f_end_of_data = true;
goto ok;
ok:
self->private_impl.p_decode_tokens[0] = 0;
goto exit;
@@ -24615,6 +24819,13 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_sse42(
@@ -24734,6 +24945,9 @@ wuffs_crc32__ieee_hasher__update_u32(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
wuffs_base__cpu_arch__have_arm_crc32() ? &wuffs_crc32__ieee_hasher__up_arm_crc32 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
#endif
@@ -24921,6 +25135,125 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
// ‼ WUFFS MULTI-FILE SECTION -arm_crc32
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func crc32.ieee_hasher.up_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
uint32_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_k = {0};
__m128i v_x0 = {0};
__m128i v_x1 = {0};
__m128i v_x2 = {0};
__m128i v_x3 = {0};
__m128i v_y0 = {0};
__m128i v_y1 = {0};
__m128i v_y2 = {0};
__m128i v_y3 = {0};
uint64_t v_tail_index = 0;
v_s = (4294967295 ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0) && ((15 & ((uint32_t)(0xFFF & (uintptr_t)(a_x.ptr)))) != 0)) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0][(((uint8_t)((v_s & 255))) ^ a_x.ptr[0])] ^ (v_s >> 8));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1);
}
if (((uint64_t)(a_x.len)) < 64) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
uint8_t* i_end0_p = i_slice_p.ptr + i_slice_p.len;
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0][(((uint8_t)((v_s & 255))) ^ v_p.ptr[0])] ^ (v_s >> 8));
v_p.ptr += 1;
}
v_p.len = 0;
}
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K1K2));
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, 64);
v_p.ptr = i_slice_p.ptr;
v_p.len = 64;
uint8_t* i_end0_p = v_p.ptr + (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 64) * 64);
while (v_p.ptr < i_end0_p) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_y1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0));
v_y2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(0));
v_y3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(17));
v_x2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(17));
v_x3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(_mm_xor_si128(v_x0, v_y0), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 0)));
v_x1 = _mm_xor_si128(_mm_xor_si128(v_x1, v_y1), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16)));
v_x2 = _mm_xor_si128(_mm_xor_si128(v_x2, v_y2), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 32)));
v_x3 = _mm_xor_si128(_mm_xor_si128(v_x3, v_y3), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 48)));
v_p.ptr += 64;
}
v_p.len = 0;
}
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K3K4));
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(v_x0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17));
v_x0 = _mm_xor_si128(v_x0, v_x3);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_x1 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(16));
v_x2 = _mm_set_epi32((int32_t)(0), (int32_t)(4294967295), (int32_t)(0), (int32_t)(4294967295));
v_x0 = _mm_srli_si128(v_x0, (int32_t)(8));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ));
v_x1 = _mm_srli_si128(v_x0, (int32_t)(4));
v_x0 = _mm_and_si128(v_x0, v_x2);
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_PXMU));
v_x1 = _mm_and_si128(v_x0, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(16));
v_x1 = _mm_and_si128(v_x1, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_s = ((uint32_t)(_mm_extract_epi32(v_x0, (int32_t)(1))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551552u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
uint8_t* i_end0_p = i_slice_p.ptr + i_slice_p.len;
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0][(((uint8_t)((v_s & 255))) ^ v_p.ptr[0])] ^ (v_s >> 8));
v_p.ptr += 1;
}
v_p.len = 0;
}
}
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc32.ieee_hasher.up_x86_sse42
@@ -25162,6 +25495,14 @@ wuffs_deflate__decoder__init_huff(
uint32_t a_n_codes1,
uint32_t a_base_symbol);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_bmi2(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast32(
wuffs_deflate__decoder* self,
@@ -25174,6 +25515,12 @@ wuffs_deflate__decoder__decode_huffman_fast64(
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_slow(
wuffs_deflate__decoder* self,
@@ -25235,6 +25582,8 @@ wuffs_deflate__decoder__initialize(
}
}
self->private_impl.choosy_decode_huffman_fast64 = &wuffs_deflate__decoder__decode_huffman_fast64__choosy_default;
self->private_impl.magic = WUFFS_BASE__MAGIC;
self->private_impl.vtable_for__wuffs_base__io_transformer.vtable_name =
wuffs_base__io_transformer__vtable_name;
@@ -25381,6 +25730,11 @@ wuffs_deflate__decoder__transform_io(
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
self->private_impl.choosy_decode_huffman_fast64 = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
#endif
self->private_impl.choosy_decode_huffman_fast64);
while (true) {
v_mark = ((uint64_t)(iop_a_dst - io0_a_dst));
{
@@ -25408,7 +25762,6 @@ wuffs_deflate__decoder__transform_io(
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -25566,7 +25919,6 @@ wuffs_deflate__decoder__decode_blocks(
}
}
goto ok;
ok:
self->private_impl.p_decode_blocks[0] = 0;
goto exit;
@@ -25686,7 +26038,6 @@ wuffs_deflate__decoder__decode_uncompressed(
}
}
goto ok;
ok:
self->private_impl.p_decode_uncompressed[0] = 0;
goto exit;
@@ -26269,6 +26620,216 @@ wuffs_deflate__decoder__init_huff(
return wuffs_base__make_status(NULL);
}
// ‼ WUFFS MULTI-FILE SECTION +x86_bmi2
// -------- func deflate.decoder.decode_huffman_bmi2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_bmi2(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_bits = 0;
uint32_t v_n_bits = 0;
uint32_t v_table_entry = 0;
uint32_t v_table_entry_n_bits = 0;
uint64_t v_lmask = 0;
uint64_t v_dmask = 0;
uint32_t v_redir_top = 0;
uint32_t v_redir_mask = 0;
uint32_t v_length = 0;
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_dst) {
io0_a_dst = a_dst->data.ptr;
io1_a_dst = io0_a_dst + a_dst->meta.wi;
iop_a_dst = io1_a_dst;
io2_a_dst = io0_a_dst + a_dst->data.len;
if (a_dst->meta.closed) {
io2_a_dst = iop_a_dst;
}
}
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) {
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;
}
if ((self->private_impl.f_n_bits >= 8) || ((self->private_impl.f_bits >> (self->private_impl.f_n_bits & 7)) != 0)) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_n_bits);
goto exit;
}
v_bits = ((uint64_t)(self->private_impl.f_bits));
v_n_bits = self->private_impl.f_n_bits;
v_lmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
v_dmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
label__loop__continue:;
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 8)) {
v_bits |= ((uint64_t)(wuffs_base__peek_u64le__no_bounds_check(iop_a_src) << (v_n_bits & 63)));
iop_a_src += ((63 - (v_n_bits & 63)) >> 3);
v_n_bits |= 56;
v_table_entry = self->private_data.f_huffs[0][(v_bits & v_lmask)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
if ((v_table_entry >> 31) != 0) {
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(((v_table_entry >> 8) & 255)))), iop_a_dst += 1);
goto label__loop__continue;
} else if ((v_table_entry >> 30) != 0) {
} else if ((v_table_entry >> 29) != 0) {
self->private_impl.f_end_of_block = true;
goto label__loop__break;
} else if ((v_table_entry >> 28) != 0) {
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
v_table_entry = self->private_data.f_huffs[0][((v_redir_top + (((uint32_t)((v_bits & 4294967295))) & v_redir_mask)) & 1023)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
if ((v_table_entry >> 31) != 0) {
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(((v_table_entry >> 8) & 255)))), iop_a_dst += 1);
goto label__loop__continue;
} else if ((v_table_entry >> 30) != 0) {
} else if ((v_table_entry >> 29) != 0) {
self->private_impl.f_end_of_block = true;
goto label__loop__break;
} else if ((v_table_entry >> 28) != 0) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
} else if ((v_table_entry >> 27) != 0) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code);
goto exit;
} else {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
}
} else if ((v_table_entry >> 27) != 0) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code);
goto exit;
} else {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
}
v_length = (((v_table_entry >> 8) & 255) + 3);
v_table_entry_n_bits = ((v_table_entry >> 4) & 15);
if (v_table_entry_n_bits > 0) {
v_length = (((v_length + 253 + ((uint32_t)(((v_bits) & WUFFS_BASE__LOW_BITS_MASK__U64(v_table_entry_n_bits))))) & 255) + 3);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
}
v_table_entry = self->private_data.f_huffs[1][(v_bits & v_dmask)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
if ((v_table_entry >> 28) == 1) {
v_redir_top = ((v_table_entry >> 8) & 65535);
v_redir_mask = ((((uint32_t)(1)) << ((v_table_entry >> 4) & 15)) - 1);
v_table_entry = self->private_data.f_huffs[1][((v_redir_top + (((uint32_t)((v_bits & 4294967295))) & v_redir_mask)) & 1023)];
v_table_entry_n_bits = (v_table_entry & 15);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
}
if ((v_table_entry >> 24) != 64) {
if ((v_table_entry >> 24) == 8) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code);
goto exit;
}
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state);
goto exit;
}
v_dist_minus_1 = ((v_table_entry >> 8) & 32767);
v_table_entry_n_bits = ((v_table_entry >> 4) & 15);
v_dist_minus_1 = ((v_dist_minus_1 + ((uint32_t)(((v_bits) & WUFFS_BASE__LOW_BITS_MASK__U64(v_table_entry_n_bits))))) & 32767);
v_bits >>= v_table_entry_n_bits;
v_n_bits -= v_table_entry_n_bits;
while (true) {
if (((uint64_t)((v_dist_minus_1 + 1))) > ((uint64_t)(iop_a_dst - io0_a_dst))) {
v_hlen = 0;
v_hdist = ((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) - ((uint64_t)(iop_a_dst - io0_a_dst)))));
if (v_length > v_hdist) {
v_length -= v_hdist;
v_hlen = v_hdist;
} else {
v_hlen = v_length;
v_length = 0;
}
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
wuffs_base__io_writer__limited_copy_u32_from_slice(
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
if (v_length == 0) {
goto label__loop__continue;
}
if ((((uint64_t)((v_dist_minus_1 + 1))) > ((uint64_t)(iop_a_dst - io0_a_dst))) || (((uint64_t)(v_length)) > ((uint64_t)(io2_a_dst - iop_a_dst))) || (((uint64_t)((v_length + 8))) > ((uint64_t)(io2_a_dst - iop_a_dst)))) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_distance);
goto exit;
}
}
if ((v_dist_minus_1 + 1) >= 8) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else if ((v_dist_minus_1 + 1) == 1) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else {
wuffs_base__io_writer__limited_copy_u32_from_history_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
}
goto label__0__break;
}
label__0__break:;
}
label__loop__break:;
if (v_n_bits > 63) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_n_bits);
goto exit;
}
while (v_n_bits >= 8) {
v_n_bits -= 8;
if (iop_a_src > io1_a_src) {
iop_a_src--;
} else {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_i_o);
goto exit;
}
}
self->private_impl.f_bits = ((uint32_t)((v_bits & ((((uint64_t)(1)) << v_n_bits) - 1))));
self->private_impl.f_n_bits = v_n_bits;
if ((self->private_impl.f_n_bits >= 8) || ((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
status = wuffs_base__make_status(wuffs_deflate__error__internal_error_inconsistent_n_bits);
goto exit;
}
goto exit;
exit:
if (a_dst) {
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
// -------- func deflate.decoder.decode_huffman_fast32
static wuffs_base__status
@@ -26526,6 +27087,14 @@ wuffs_deflate__decoder__decode_huffman_fast64(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src) {
return (*self->private_impl.choosy_decode_huffman_fast64)(self, a_dst, a_src);
}
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
wuffs_deflate__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_bits = 0;
@@ -26681,6 +27250,9 @@ wuffs_deflate__decoder__decode_huffman_fast64(
if ((v_dist_minus_1 + 1) >= 8) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else if ((v_dist_minus_1 + 1) == 1) {
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
} else {
wuffs_base__io_writer__limited_copy_u32_from_history_fast(
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
@@ -27056,7 +27628,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_huffman_slow[0] = 0;
goto exit;
@@ -27328,7 +27899,6 @@ wuffs_lzw__decoder__transform_io(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -27572,7 +28142,6 @@ wuffs_lzw__decoder__write_to(
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
goto ok;
ok:
self->private_impl.p_write_to[0] = 0;
goto exit;
@@ -28128,7 +28697,6 @@ wuffs_gif__decoder__tell_me_more(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
self->private_impl.p_tell_me_more[0] = 0;
goto exit;
@@ -28396,7 +28964,6 @@ wuffs_gif__decoder__decode_frame_config(
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frame_configs_value, 1);
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -29062,7 +29629,6 @@ wuffs_gif__decoder__decode_extension(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_extension[0] = 0;
goto exit;
@@ -29131,7 +29697,6 @@ wuffs_gif__decoder__skip_blocks(
iop_a_src += self->private_data.s_skip_blocks[0].scratch;
}
goto ok;
ok:
self->private_impl.p_skip_blocks[0] = 0;
goto exit;
@@ -29350,7 +29915,6 @@ wuffs_gif__decoder__decode_ae(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_ae[0] = 0;
goto exit;
@@ -29820,7 +30384,6 @@ wuffs_gif__decoder__decode_id_part1(
wuffs_lzw__decoder__set_literal_width(&self->private_data.f_lzw, ((uint32_t)(v_lw)));
self->private_impl.f_previous_lzw_decode_ended_abruptly = true;
goto ok;
ok:
self->private_impl.p_decode_id_part1[0] = 0;
goto exit;
@@ -30027,7 +30590,6 @@ wuffs_gif__decoder__decode_id_part2(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_id_part2[0] = 0;
goto exit;
@@ -30637,7 +31199,6 @@ wuffs_gzip__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -32094,7 +32655,6 @@ wuffs_json__decoder__decode_tokens(
}
self->private_impl.f_end_of_data = true;
goto ok;
ok:
self->private_impl.p_decode_tokens[0] = 0;
goto exit;
@@ -32396,7 +32956,6 @@ wuffs_json__decoder__decode_leading(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_decode_leading[0] = 0;
goto exit;
@@ -32577,7 +33136,6 @@ wuffs_json__decoder__decode_comment(
}
}
goto ok;
ok:
self->private_impl.p_decode_comment[0] = 0;
goto exit;
@@ -32738,7 +33296,6 @@ wuffs_json__decoder__decode_inf_nan(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_inf_nan[0] = 0;
goto exit;
@@ -32884,7 +33441,6 @@ wuffs_json__decoder__decode_trailer(
}
label__outer__break:;
goto ok;
ok:
self->private_impl.p_decode_trailer[0] = 0;
goto exit;
@@ -33359,7 +33915,6 @@ wuffs_nie__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -33468,7 +34023,6 @@ wuffs_nie__decoder__decode_frame(
label__0__break:;
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -33558,7 +34112,6 @@ wuffs_nie__decoder__swizzle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -34158,7 +34711,6 @@ wuffs_zlib__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -36310,7 +36862,6 @@ wuffs_png__decoder__decode_image_config(
}
self->private_impl.f_call_sequence = 3;
goto ok;
ok:
self->private_impl.p_decode_image_config[0] = 0;
goto exit;
@@ -36389,7 +36940,7 @@ wuffs_png__decoder__decode_ihdr(
}
v_a32 = t_0;
}
if (v_a32 >= 2147483648) {
if ((v_a32 == 0) || (v_a32 >= 2147483648)) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
} else if (v_a32 >= 16777216) {
@@ -36426,7 +36977,7 @@ wuffs_png__decoder__decode_ihdr(
}
v_a32 = t_1;
}
if (v_a32 >= 2147483648) {
if ((v_a32 == 0) || (v_a32 >= 2147483648)) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
} else if (v_a32 >= 16777216) {
@@ -36559,7 +37110,7 @@ wuffs_png__decoder__assign_filter_distance(
self->private_impl.f_src_pixfmt = 536870920;
self->private_impl.f_filter_distance = 1;
} else if (self->private_impl.f_depth == 16) {
self->private_impl.f_dst_pixfmt = 536870920;
self->private_impl.f_dst_pixfmt = 536870923;
self->private_impl.f_src_pixfmt = 537919499;
self->private_impl.f_filter_distance = 2;
}
@@ -37036,7 +37587,6 @@ wuffs_png__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -37163,7 +37713,6 @@ wuffs_png__decoder__decode_frame(
label__0__break:;
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -37462,7 +38011,6 @@ wuffs_png__decoder__decode_pass(
}
}
goto ok;
ok:
self->private_impl.p_decode_pass[0] = 0;
goto exit;
@@ -38266,7 +38814,6 @@ wuffs_wbmp__decoder__decode_frame_config(
}
self->private_impl.f_call_sequence = 4;
goto ok;
ok:
self->private_impl.p_decode_frame_config[0] = 0;
goto exit;
@@ -38431,7 +38978,6 @@ wuffs_wbmp__decoder__decode_frame(
}
self->private_impl.f_call_sequence = 255;
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -39508,54 +40054,50 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
// --------
#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \
while (tok_buf.meta.ri >= tok_buf.meta.wi) { \
if (tok_status.repr == nullptr) { \
} else if (tok_status.repr == wuffs_base__suspension__short_write) { \
tok_buf.compact(); \
} else if (tok_status.repr == wuffs_base__suspension__short_read) { \
if (!io_error_message.empty()) { \
ret_error_message = std::move(io_error_message); \
goto done; \
} else if (cursor_index != io_buf->meta.ri) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad cursor_index"; \
goto done; \
} else if (io_buf->meta.closed) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is closed"; \
goto done; \
} \
io_buf->compact(); \
if (io_buf->meta.wi >= io_buf->data.len) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is full"; \
goto done; \
} \
cursor_index = io_buf->meta.ri; \
io_error_message = input.CopyIn(io_buf); \
} else { \
ret_error_message = tok_status.message(); \
goto done; \
} \
if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN"; \
goto done; \
} \
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8(); \
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf); \
} \
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
uint64_t token_len = token.length(); \
if ((io_buf->meta.ri < cursor_index) || \
((io_buf->meta.ri - cursor_index) < token_len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad token indexes"; \
goto done; \
} \
uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \
(void)(token_ptr); \
#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \
while (tok_buf.meta.ri >= tok_buf.meta.wi) { \
if (tok_status.repr == nullptr) { \
goto done; \
} else if (tok_status.repr == wuffs_base__suspension__short_write) { \
tok_buf.compact(); \
} else if (tok_status.repr == wuffs_base__suspension__short_read) { \
if (!io_error_message.empty()) { \
ret_error_message = std::move(io_error_message); \
goto done; \
} else if (cursor_index != io_buf->meta.ri) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad cursor_index"; \
goto done; \
} else if (io_buf->meta.closed) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is closed"; \
goto done; \
} \
io_buf->compact(); \
if (io_buf->meta.wi >= io_buf->data.len) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: io_buf is full"; \
goto done; \
} \
cursor_index = io_buf->meta.ri; \
io_error_message = input.CopyIn(io_buf); \
} else { \
ret_error_message = tok_status.message(); \
goto done; \
} \
tok_status = \
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \
} \
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
uint64_t token_len = token.length(); \
if ((io_buf->meta.ri < cursor_index) || \
((io_buf->meta.ri - cursor_index) < token_len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad token indexes"; \
goto done; \
} \
uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \
(void)(token_ptr); \
cursor_index += static_cast<size_t>(token_len)
// --------
@@ -39826,6 +40368,10 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
if (!dec) {
ret_error_message = "wuffs_aux::DecodeJson: out of memory";
goto done;
} else if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN";
goto done;
}
bool allow_tilde_n_tilde_r_tilde_t = false;
for (size_t i = 0; i < quirks.len; i++) {
@@ -39841,7 +40387,8 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
wuffs_base__token_buffer tok_buf =
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
&tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
wuffs_base__status tok_status =
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());
// Prepare other state.
uint32_t depth = 0;
@@ -39855,7 +40402,7 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
}
std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(
json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);
i = std::move(split.second);
i = split.second;
if (i == 0) {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
@@ -39990,7 +40537,22 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done;
parsed_a_value:
if (!ret_error_message.empty() || (depth == 0)) {
// If an error was encountered, we are done. Otherwise, (depth == 0)
// after parsing a value is equivalent to having decoded the entire JSON
// value (for an empty json_pointer query) or having decoded the
// pointed-to JSON value (for a non-empty json_pointer query). In the
// latter case, we are also done.
//
// However, if quirks like WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER or
// WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF are passed, decoding
// the entire JSON value should also consume any trailing filler, in case
// the DecodeJson caller wants to subsequently check that the input is
// completely exhausted (and otherwise raise "valid JSON followed by
// further (unexpected) data"). We aren't done yet. Instead, keep the
// loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's
// decode_tokens returns an ok status.
if (!ret_error_message.empty() ||
((depth == 0) && !json_pointer.empty())) {
goto done;
}
}
@@ -40017,6 +40579,8 @@ done:
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#endif
#endif // WUFFS_INCLUDE_GUARD
+36 -7
View File
@@ -31,6 +31,7 @@ extern crate png;
extern crate rustc_version_runtime;
use std::time::Instant;
use std::convert::TryInto;
const ITERSCALE: u64 = 50;
const REPS: u64 = 5;
@@ -153,13 +154,9 @@ fn decode(dst0: &mut [u8], dst1: &mut [u8], src: &[u8]) -> u64 {
return num_bytes;
} else if info.color_type == png::ColorType::RGB {
// Convert RGB => BGRA.
for i in 0..((num_bytes / 3) as usize) {
dst1[(4 * i) + 0] = dst0[(3 * i) + 2];
dst1[(4 * i) + 1] = dst0[(3 * i) + 1];
dst1[(4 * i) + 2] = dst0[(3 * i) + 0];
dst1[(4 * i) + 3] = 0xFF;
}
return (num_bytes / 3) * 4;
let new_size = ((num_bytes / 3) * 4) as usize;
rgb_to_bgra(&dst0[..num_bytes as usize], &mut dst1[..new_size]);
return new_size as u64;
} else if info.color_type == png::ColorType::RGBA {
// Convert RGBA => BGRA.
for i in 0..((num_bytes / 4) as usize) {
@@ -172,3 +169,35 @@ fn decode(dst0: &mut [u8], dst1: &mut [u8], src: &[u8]) -> u64 {
// Returning 0 should lead to a panic (when want_num_bytes != 0).
0
}
/// Copy `src` (treated as 3-byte chunks) into `dst`
/// (treated as 4-byte chunks), filling out `dst` by adding
/// a `0xff` "alpha value" at the end of each entry.
///
/// # Panics:
///
/// Will panic if
///
/// * The length of `src` is not a multiple of 3.
/// * The length of `dst` is not a multiple of 4.
/// * `src` and `dst` do not have the same length in chunks.
#[inline]
pub fn rgb_to_bgra(src: &[u8], dst: &mut [u8]) {
let nsrc = src.len();
let ndst = dst.len();
assert_eq!(0, nsrc % 3);
assert_eq!(0, ndst % 4);
assert_eq!(nsrc, (ndst / 4) * 3);
for (s, d) in src.chunks_exact(3).zip(dst.chunks_exact_mut(4)) {
let s: &[u8; 3] = s.try_into().unwrap();
let d: &mut [u8; 4] = d.try_into().unwrap();
// R
d[0] = s[2];
// G
d[1] = s[1];
// B
d[2] = s[0];
// A
d[3] = 0xff;
}
}
+1 -1
View File
@@ -261,7 +261,7 @@ process_file(char* filename) {
g_file = NULL;
}
g_filename = filename;
g_file = fopen(g_filename, "r");
g_file = fopen(g_filename, "rb");
if (!g_file) {
fprintf(stderr, "main: could not open %s\n", g_filename);
return false;
+1 -1
View File
@@ -416,7 +416,7 @@ compute_exit_code(const char* status_msg) {
n = strnlen(status_msg, 2047);
}
fprintf(stderr, "%s\n", status_msg);
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+1 -1
View File
@@ -304,7 +304,7 @@ compute_exit_code(const char* status_msg) {
n = strnlen(status_msg, 2047);
}
fprintf(stderr, "%s\n", status_msg);
// Return an exit code of 1 for regular (forseen) errors, e.g. badly
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly
// formatted or unsupported input.
//
// Return an exit code of 2 for internal (exceptional) errors, e.g. defensive
+4
View File
@@ -25,6 +25,10 @@ pub func hasher.update_u32!(x: slice base.u8) base.u32 {
if not this.started {
this.started = true
this.state = 1
// There used to be an up_x86_avx2 implementation too, but while it
// made the std/adler32 micro-benchmarks better, it also made the
// std/zlib and std/png micro-benchmarks worse. See commit baec831f
// "Add std/adler32 hasher.up_x86_avx2".
choose up = [
up_arm_neon,
up_x86_sse42]
+19 -19
View File
@@ -28,8 +28,8 @@ pri func hasher.up_x86_sse42!(x: slice base.u8),
var ones : base.x86_m128i
var weights__left : base.x86_m128i
var weights_right : base.x86_m128i
var p__left : base.x86_m128i
var p_right : base.x86_m128i
var q__left : base.x86_m128i
var q_right : base.x86_m128i
var v1 : base.x86_m128i
var v2 : base.x86_m128i
var v2j : base.x86_m128i
@@ -92,13 +92,13 @@ pri func hasher.up_x86_sse42!(x: slice base.u8),
// The inner loop.
iterate (p = args.x)(length: 32, advance: 32, unroll: 1) {
// Split the 32-byte p into left and right halves. SSE4.2 works
// with 16-byte registers.
// SSE4.2 works with 16-byte registers. Split the 32-byte p into
// left and right halves.
//
// Let p__left = [u8×16: p00, p01, p02, ..., p15]
// Let p_right = [u8×16: p16, p17, p18, ..., p31]
p__left = util.make_m128i_slice128(a: p[.. 16])
p_right = util.make_m128i_slice128(a: p[16 .. 32])
// Let q__left = [u8×16: p00, p01, p02, ..., p15]
// Let q_right = [u8×16: p16, p17, p18, ..., p31]
q__left = util.make_m128i_slice128(a: p[.. 16])
q_right = util.make_m128i_slice128(a: p[16 .. 32])
// For v2j, we need to calculate the sums of the s1j terms for each
// of p's 32 elements. This is simply 32 times the same number,
@@ -108,14 +108,14 @@ pri func hasher.up_x86_sse42!(x: slice base.u8),
// For v1, we need to add the elements of p. Computing the sum of
// absolute differences (_mm_sad_epu8) with zero just sums the
// elements. p__left._mm_sad_epu8(b: zeroes) equals
// elements. q__left._mm_sad_epu8(b: zeroes) equals
// [u64×2: p00 + p01 + ... + p07, p08 + p09 + ... + p15]
// This is equivalent (little-endian) to:
// [u32×4: p00 + p01 + ... + p07, 0, p08 + p09 + ... + p15, 0]
// We accumulate those "sum of p__left elements" in v1, and ditto
// for the p_right elements.
v1 = v1._mm_add_epi32(b: p__left._mm_sad_epu8(b: zeroes))
v1 = v1._mm_add_epi32(b: p_right._mm_sad_epu8(b: zeroes))
// We accumulate those "sum of q__left's elements" in v1, and ditto
// for q_right's elements.
v1 = v1._mm_add_epi32(b: q__left._mm_sad_epu8(b: zeroes))
v1 = v1._mm_add_epi32(b: q_right._mm_sad_epu8(b: zeroes))
// For v2k, we need to calculate a weighted sum: ((32 * p00) + (31
// * p01) + (30 * p02) + ... + (1 * p31)), which splits naturally
@@ -128,19 +128,19 @@ pri func hasher.up_x86_sse42!(x: slice base.u8),
// ...
// ((18*p14)+(17*p15))]
//
// The ones._mm_madd_epi16(b: etc) call is likewise a multiply-add
// (note that it's "madd" not "add"). Multiplying by 1 is a no-op,
// so this sums u16 pairs to produce u32 values:
// The ones._mm_madd_epi16(b: etc) call is a multiply-add (note
// that it's "madd" not "add"). Multiplying by 1 is a no-op, so
// this sums u16 pairs to produce u32 values:
// [u32×4: ((32*p00)+(31*p01)+(30*p02)+(29*p03)),
// ((28*p04)+(27*p05)+(26*p06)+(25*p07)),
// ...
// ((20*p12)+(19*p13)+(18*p14)+(17*p15))]
//
// Ditto again for the p_right elements.
// Ditto again for q_right's elements.
v2k = v2k._mm_add_epi32(b: ones._mm_madd_epi16(b:
p__left._mm_maddubs_epi16(b: weights__left)))
q__left._mm_maddubs_epi16(b: weights__left)))
v2k = v2k._mm_add_epi32(b: ones._mm_madd_epi16(b:
p_right._mm_maddubs_epi16(b: weights_right)))
q_right._mm_maddubs_epi16(b: weights_right)))
}
// Merge the four parallel u32 sums (v1) into the single u32 sum (s1).
+1
View File
@@ -27,6 +27,7 @@ pub func ieee_hasher.update_u32!(x: slice base.u8) base.u32 {
if this.state == 0 {
choose up = [
up_arm_crc32,
up_x86_avx2,
up_x86_sse42]
}
this.up!(x: args.x)
+138
View File
@@ -0,0 +1,138 @@
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// --------
// See "SIMD Implementations" in README.md for a link to Gopal et al. "Fast CRC
// Computation for Generic Polynomials Using PCLMULQDQ Instruction".
// up_x86_avx2 is exactly the same as up_x86_sse42 except for the "choose
// cpu_arch >= x86_avx2". With AVX, PCLMULQDQ has a three-operand form, not
// just a two-operand form: https://www.felixcloutier.com/x86/pclmulqdq
pri func ieee_hasher.up_x86_avx2!(x: slice base.u8),
choose cpu_arch >= x86_avx2,
{
var s : base.u32
var p : slice base.u8
var util : base.x86_sse42_utility
var k : base.x86_m128i
var x0 : base.x86_m128i
var x1 : base.x86_m128i
var x2 : base.x86_m128i
var x3 : base.x86_m128i
var y0 : base.x86_m128i
var y1 : base.x86_m128i
var y2 : base.x86_m128i
var y3 : base.x86_m128i
var tail_index : base.u64
s = 0xFFFF_FFFF ^ this.state
// Align to a 16-byte boundary.
while (args.x.length() > 0) and ((15 & args.x.uintptr_low_12_bits()) <> 0) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ args.x[0]] ^ (s >> 8)
args.x = args.x[1 ..]
} endwhile
// For short inputs, just do a simple loop.
if args.x.length() < 64 {
iterate (p = args.x)(length: 1, advance: 1, unroll: 1) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
}
this.state = 0xFFFF_FFFF ^ s
return nothing
}
// Load 128×4 = 512 bits from the first 64-byte chunk.
x0 = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])
x1 = util.make_m128i_slice128(a: args.x[0x10 .. 0x20])
x2 = util.make_m128i_slice128(a: args.x[0x20 .. 0x30])
x3 = util.make_m128i_slice128(a: args.x[0x30 .. 0x40])
// Combine with the initial state.
x0 = x0._mm_xor_si128(b: util.make_m128i_single_u32(a: s))
// Process the remaining 64-byte chunks.
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K1K2[.. 16])
iterate (p = args.x[64 ..])(length: 64, advance: 64, unroll: 1) {
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
y1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x00)
y2 = x2._mm_clmulepi64_si128(b: k, imm8: 0x00)
y3 = x3._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x11)
x2 = x2._mm_clmulepi64_si128(b: k, imm8: 0x11)
x3 = x3._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: y0)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x00 .. 0x10]))
x1 = x1._mm_xor_si128(b: y1)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x10 .. 0x20]))
x2 = x2._mm_xor_si128(b: y2)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x20 .. 0x30]))
x3 = x3._mm_xor_si128(b: y3)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x30 .. 0x40]))
}
// Reduce 128×4 = 512 bits to 128 bits.
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K3K4[.. 16])
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x1)
x0 = x0._mm_xor_si128(b: y0)
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x2)
x0 = x0._mm_xor_si128(b: y0)
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x3)
x0 = x0._mm_xor_si128(b: y0)
// Reduce 128 bits to 64 bits.
x1 = x0._mm_clmulepi64_si128(b: k, imm8: 0x10)
x2 = util.make_m128i_multiple_u32(
a00: 0xFFFF_FFFF,
a01: 0x0000_0000,
a02: 0xFFFF_FFFF,
a03: 0x0000_0000)
x0 = x0._mm_srli_si128(imm8: 8)
x0 = x0._mm_xor_si128(b: x1)
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K5ZZ[.. 16])
x1 = x0._mm_srli_si128(imm8: 4)
x0 = x0._mm_and_si128(b: x2)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_xor_si128(b: x1)
// Reduce 64 bits to 32 bits (Barrett Reduction) and extract.
//
// Barrett Reduction is Algorithm 1 (page 14) of Gopal et al., after
// adjusting for bit-reflection as per Figure 12 (page 21).
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_PXMU[.. 16])
x1 = x0._mm_and_si128(b: x2)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x10)
x1 = x1._mm_and_si128(b: x2)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_xor_si128(b: x1)
s = x0._mm_extract_epi32(imm8: 1)
// Handle the tail of args.x that wasn't a complete 64-byte chunk.
tail_index = args.x.length() & 0xFFFF_FFFF_FFFF_FFC0 // And-not 64.
if tail_index < args.x.length() {
iterate (p = args.x[tail_index ..])(length: 1, advance: 1, unroll: 1) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
}
}
this.state = 0xFFFF_FFFF ^ s
}
+2
View File
@@ -203,6 +203,8 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
var mark : base.u64
var status : base.status
choose decode_huffman_fast64 = [decode_huffman_bmi2]
while true {
mark = args.dst.mark()
status =? this.decode_blocks?(dst: args.dst, src: args.src)
+299
View File
@@ -0,0 +1,299 @@
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// decode_huffman_bmi2 is exactly the same as decode_huffman_fast64 except for
// the "choose cpu_arch >= x86_bmi2". Unsurprisingly, having Bit Manipulation
// Instructions available to the compiler can help this function's performance.
pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader) base.status,
choose cpu_arch >= x86_bmi2,
{
// When editing this function, consider making the equivalent change to the
// decode_huffman_slow function. Keep the diff between the two
// decode_huffman_*.wuffs files as small as possible, while retaining both
// correctness and performance.
var bits : base.u64
var n_bits : base.u32
var table_entry : base.u32
var table_entry_n_bits : base.u32[..= 15]
var lmask : base.u64[..= 511]
var dmask : base.u64[..= 511]
var redir_top : base.u32[..= 0xFFFF]
var redir_mask : base.u32[..= 0x7FFF]
var length : base.u32[..= 258]
var dist_minus_1 : base.u32[..= 0x7FFF]
var hlen : base.u32[..= 0x7FFF]
var hdist : base.u32
if (this.n_bits >= 8) or ((this.bits >> (this.n_bits & 7)) <> 0) {
return "#internal error: inconsistent n_bits"
}
bits = this.bits as base.u64
n_bits = this.n_bits
lmask = ((1 as base.u64) << this.n_huffs_bits[0]) - 1
dmask = ((1 as base.u64) << this.n_huffs_bits[1]) - 1
// Check up front, on each iteration, that we have enough buffer space to
// both read (8 bytes) and write (266 bytes) as much as we need to. Doing
// this check once (per iteration), up front, removes the need to check
// multiple times inside the loop body, so it's faster overall.
//
// For writing, a literal code obviously corresponds to writing 1 byte, and
// 258 is the maximum length in a length-distance pair, as specified in the
// RFC section 3.2.5. Compressed blocks (length and distance codes).
//
// We adjust 258 up to (258 + 8) = 266 since it can be faster to overshoot
// a little and make multiple-of-8-byte copies even when the length in the
// length-distance pair isn't an exact multiple-of-8. Strictly speaking,
// 264 (an exact multiple-of-8) is the tight bound but (258 + 8) is easier
// for the Wuffs proof system, as length's type is refined to [..= 258],
//
// For reading, strictly speaking, we only need 6 bytes (48 bits) of
// available input, because the H-L Literal/Length code is up to 15 bits
// plus up to 5 extra bits, the H-D Distance code is up to 15 bits plus up
// to 13 extra bits and 15 + 5 + 15 + 13 == 48. However, it's faster to
// read 64 bits than 48 bits or (48 - n_bits) bits.
while.loop(args.dst.length() >= 266) and (args.src.length() >= 8) {
// Ensure that we have at least 56 bits of input.
//
// This is "Variant 4" of
// https://fgiesen.wordpress.com/2018/02/20/reading-bits-in-far-too-many-ways-part-2/
//
// 56, the number of bits in 7 bytes, is a property of that "Variant 4"
// bit-reading technique, and not related to the DEFLATE format per se.
//
// The "& 63" is a no-op, and not part of the original "Variant 4"
// technique, but satisfies Wuffs' overflow/underflow checks.
bits |= args.src.peek_u64le() ~mod<< (n_bits & 63)
args.src.skip_u32_fast!(actual: (63 - (n_bits & 63)) >> 3, worst_case: 8)
n_bits |= 56
// Decode an lcode symbol from H-L.
table_entry = this.huffs[0][bits & lmask]
table_entry_n_bits = table_entry & 0x0F
bits >>= table_entry_n_bits
n_bits ~mod-= table_entry_n_bits
if (table_entry >> 31) <> 0 {
// Literal.
args.dst.write_u8_fast!(a: ((table_entry >> 8) & 0xFF) as base.u8)
continue.loop
} else if (table_entry >> 30) <> 0 {
// No-op; code continues past the if-else chain.
} else if (table_entry >> 29) <> 0 {
// End of block.
this.end_of_block = true
break.loop
} else if (table_entry >> 28) <> 0 {
// Redirect.
redir_top = (table_entry >> 8) & 0xFFFF
redir_mask = ((1 as base.u32) << ((table_entry >> 4) & 0x0F)) - 1
table_entry = this.huffs[0][
(redir_top + (((bits & 0xFFFF_FFFF) as base.u32) & redir_mask)) & HUFFS_TABLE_MASK]
table_entry_n_bits = table_entry & 0x0F
bits >>= table_entry_n_bits
n_bits ~mod-= table_entry_n_bits
if (table_entry >> 31) <> 0 {
// Literal.
args.dst.write_u8_fast!(a: ((table_entry >> 8) & 0xFF) as base.u8)
continue.loop
} else if (table_entry >> 30) <> 0 {
// No-op; code continues past the if-else chain.
} else if (table_entry >> 29) <> 0 {
// End of block.
this.end_of_block = true
break.loop
} else if (table_entry >> 28) <> 0 {
return "#internal error: inconsistent Huffman decoder state"
} else if (table_entry >> 27) <> 0 {
return "#bad Huffman code"
} else {
return "#internal error: inconsistent Huffman decoder state"
}
} else if (table_entry >> 27) <> 0 {
return "#bad Huffman code"
} else {
return "#internal error: inconsistent Huffman decoder state"
}
// length = base_number_minus_3 + 3 + extra_bits.
//
// The -3 is from the bias in script/print-deflate-magic-numbers.go.
// That bias makes the "& 0xFF" 1 and 15-ish lines below correct.
length = ((table_entry >> 8) & 0xFF) + 3
table_entry_n_bits = (table_entry >> 4) & 0x0F
if table_entry_n_bits > 0 {
// The "+ 253" is the same as "- 3", after the "& 0xFF", but the
// plus form won't require an underflow check.
length = ((length + 253 + (bits.low_bits(n: table_entry_n_bits) as base.u32)) & 0xFF) + 3
bits >>= table_entry_n_bits
n_bits ~mod-= table_entry_n_bits
}
// Decode a dcode symbol from H-D.
table_entry = this.huffs[1][bits & dmask]
table_entry_n_bits = table_entry & 15
bits >>= table_entry_n_bits
n_bits ~mod-= table_entry_n_bits
// Check for a redirect.
if (table_entry >> 28) == 1 {
redir_top = (table_entry >> 8) & 0xFFFF
redir_mask = ((1 as base.u32) << ((table_entry >> 4) & 0x0F)) - 1
table_entry = this.huffs[1][
(redir_top + (((bits & 0xFFFF_FFFF) as base.u32) & redir_mask)) & HUFFS_TABLE_MASK]
table_entry_n_bits = table_entry & 0x0F
bits >>= table_entry_n_bits
n_bits ~mod-= table_entry_n_bits
}
// For H-D, all symbols should be base_number + extra_bits.
if (table_entry >> 24) <> 0x40 {
if (table_entry >> 24) == 0x08 {
return "#bad Huffman code"
}
return "#internal error: inconsistent Huffman decoder state"
}
// dist_minus_1 = base_number_minus_1 + extra_bits.
// distance = dist_minus_1 + 1.
//
// The -1 is from the bias in script/print-deflate-magic-numbers.go.
// That bias makes the "& 0x7FFF" 2 and 15-ish lines below correct and
// undoing that bias makes proving (dist_minus_1 + 1) > 0 trivial.
dist_minus_1 = (table_entry >> 8) & 0x7FFF
table_entry_n_bits = (table_entry >> 4) & 0x0F
dist_minus_1 = (dist_minus_1 + (bits.low_bits(n: table_entry_n_bits) as base.u32)) & 0x7FFF
bits >>= table_entry_n_bits
n_bits ~mod-= table_entry_n_bits
// The "while true { etc; break }" is a redundant version of "etc", but
// its presence minimizes the diff between decode_huffman_fastxx and
// decode_huffman_slow.
while true,
pre args.dst.length() >= 266,
{
// We can therefore prove:
assert (length as base.u64) <= args.dst.length() via "a <= b: a <= c; c <= b"(c: 266)
assert ((length + 8) as base.u64) <= args.dst.length() via "a <= b: a <= c; c <= b"(c: 266)
// Copy from this.history.
if ((dist_minus_1 + 1) as base.u64) > args.dst.history_length() {
// Set (hlen, hdist) to be the length-distance pair to copy
// from this.history, and (length, distance) to be the
// remaining length-distance pair to copy from args.dst.
hlen = 0
hdist = (((dist_minus_1 + 1) as base.u64) - args.dst.history_length()) as base.u32
if length > hdist {
assert hdist < length via "a < b: b > a"()
assert hdist < 0x8000 via "a < b: a < c; c <= b"(c: length)
length -= hdist
hlen = hdist
} else {
hlen = length
length = 0
}
if this.history_index < hdist {
return "#bad distance"
}
// Re-purpose the hdist variable as the this.history index to
// start copying from.
hdist = this.history_index - hdist
// Copy from hdist to the end of this.history.
//
// This copying is simpler than the decode_huffman_slow version
// because it cannot yield. We have already checked that
// args.dst.length() is large enough.
args.dst.limited_copy_u32_from_slice!(
up_to: hlen, s: this.history[hdist & 0x7FFF ..])
if length == 0 {
// No need to copy from args.dst.
continue.loop
}
if (((dist_minus_1 + 1) as base.u64) > args.dst.history_length()) or
((length as base.u64) > args.dst.length()) or
(((length + 8) as base.u64) > args.dst.length()) {
return "#internal error: inconsistent distance"
}
}
// Once again, redundant but explicit assertions.
assert (dist_minus_1 + 1) >= 1
assert ((dist_minus_1 + 1) as base.u64) <= args.dst.history_length()
assert (length as base.u64) <= args.dst.length()
assert ((length + 8) as base.u64) <= args.dst.length()
// Copy from args.dst.
//
// For short distances, less than 8 bytes, copying atomic 8-byte
// chunks can result in incorrect output, so we fall back to a
// slower 1-byte-at-a-time copy. Deflate's copy-from-history can
// pick up freshly written bytes. A length = 5, distance = 2 copy
// starting with "abc" should give "abcbcbcb" but the 8-byte chunk
// technique would give "abcbc???", the exact output depending on
// what was previously in the writer buffer.
if (dist_minus_1 + 1) >= 8 {
args.dst.limited_copy_u32_from_history_8_byte_chunks_fast!(
up_to: length, distance: (dist_minus_1 + 1))
} else if (dist_minus_1 + 1) == 1 {
// (distance == 1) is essentially RLE (Run Length Encoding). It
// happens often enough that it's worth special-casing.
args.dst.limited_copy_u32_from_history_8_byte_chunks_distance_1_fast!(
up_to: length, distance: (dist_minus_1 + 1))
} else {
args.dst.limited_copy_u32_from_history_fast!(
up_to: length, distance: (dist_minus_1 + 1))
}
break
} endwhile
} endwhile.loop
// Ensure n_bits < 8 by rewindng args.src, if we loaded too many of its
// bytes into the bits variable.
//
// Note that we can unconditionally call undo_read (without resulting in an
// "invalid I/O operation" error code) only because this whole function can
// never suspend, as all of its I/O operations were checked beforehand for
// sufficient buffer space. Otherwise, resuming from the suspension could
// mean that the (possibly different) args.src is no longer rewindable,
// even if conceptually, this function was responsible for reading the
// bytes we want to rewind.
if n_bits > 63 {
return "#internal error: inconsistent n_bits"
}
while n_bits >= 8,
post n_bits < 8,
{
n_bits -= 8
if args.src.can_undo_byte() {
args.src.undo_byte!()
} else {
return "#internal error: inconsistent I/O"
}
} endwhile
this.bits = (bits & (((1 as base.u64) << n_bits) - 1)) as base.u32
this.n_bits = n_bits
if (this.n_bits >= 8) or ((this.bits >> this.n_bits) <> 0) {
return "#internal error: inconsistent n_bits"
}
}
+8 -1
View File
@@ -14,7 +14,9 @@
// TODO: describe how the xxx_fastxx version differs from the xxx_slow one, the
// assumptions that xxx_fastxx makes, and how that makes it fast.
pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader) base.status {
pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader) base.status,
choosy,
{
// When editing this function, consider making the equivalent change to the
// decode_huffman_slow function. Keep the diff between the two
// decode_huffman_*.wuffs files as small as possible, while retaining both
@@ -250,6 +252,11 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
if (dist_minus_1 + 1) >= 8 {
args.dst.limited_copy_u32_from_history_8_byte_chunks_fast!(
up_to: length, distance: (dist_minus_1 + 1))
} else if (dist_minus_1 + 1) == 1 {
// (distance == 1) is essentially RLE (Run Length Encoding). It
// happens often enough that it's worth special-casing.
args.dst.limited_copy_u32_from_history_8_byte_chunks_distance_1_fast!(
up_to: length, distance: (dist_minus_1 + 1))
} else {
args.dst.limited_copy_u32_from_history_fast!(
up_to: length, distance: (dist_minus_1 + 1))
+3 -3
View File
@@ -219,7 +219,7 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
var a8 : base.u8
a32 = args.src.read_u32be?()
if a32 >= 0x8000_0000 {
if (a32 == 0) or (a32 >= 0x8000_0000) {
return "#bad header"
} else if a32 >= 0x0100_0000 {
return "#unsupported PNG file"
@@ -227,7 +227,7 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
this.width = a32
a32 = args.src.read_u32be?()
if a32 >= 0x8000_0000 {
if (a32 == 0) or (a32 >= 0x8000_0000) {
return "#bad header"
} else if a32 >= 0x0100_0000 {
return "#unsupported PNG file"
@@ -303,7 +303,7 @@ pri func decoder.assign_filter_distance!() {
this.src_pixfmt = base.PIXEL_FORMAT__Y
this.filter_distance = 1
} else if this.depth == 16 {
this.dst_pixfmt = base.PIXEL_FORMAT__Y // TODO: PIXEL_FORMAT__Y_16LE
this.dst_pixfmt = base.PIXEL_FORMAT__Y_16LE
this.src_pixfmt = base.PIXEL_FORMAT__Y_16BE
this.filter_distance = 2
}
+171 -4
View File
@@ -14,12 +14,171 @@
// ----------------
// Uncomment this line to test and bench miniz instead of zlib-the-library.
// Uncomment one of these #define lines to test and bench alternative mimic
// libraries (libdeflate or miniz) instead of zlib-the-library.
//
// These are collectively referred to as
// WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB.
//
// #define WUFFS_MIMICLIB_USE_LIBDEFLATE_INSTEAD_OF_ZLIB 1
// #define WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB 1
#ifdef WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB
// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
#if defined(WUFFS_MIMICLIB_USE_LIBDEFLATE_INSTEAD_OF_ZLIB)
#include "libdeflate.h"
#define WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING 1
#define WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES 1
uint32_t global_mimiclib_deflate_unused_u32;
typedef enum libdeflate_result (*libdeflate_decompress_func)(
struct libdeflate_decompressor* decompressor,
const void* in,
size_t in_nbytes,
void* out,
size_t out_nbytes_avail,
size_t* actual_in_nbytes_ret,
size_t* actual_out_nbytes_ret);
const char* //
libdeflate_result_as_const_char_star(enum libdeflate_result r) {
switch (r) {
case LIBDEFLATE_SUCCESS:
return NULL;
case LIBDEFLATE_BAD_DATA:
return "libdeflate: bad data";
case LIBDEFLATE_SHORT_OUTPUT:
return "libdeflate: short output";
case LIBDEFLATE_INSUFFICIENT_SPACE:
return "libdeflate: insufficient space";
}
return "libdeflate: unknown error";
}
const char* //
mimic_bench_adler32(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint32_t wuffs_initialize_flags,
uint64_t wlimit,
uint64_t rlimit) {
global_mimiclib_deflate_unused_u32 = 1;
while (src->meta.ri < src->meta.wi) {
uint8_t* ptr = src->data.ptr + src->meta.ri;
size_t len = src->meta.wi - src->meta.ri;
if (len > 0x7FFFFFFF) {
return "src length is too large";
} else if (len > rlimit) {
len = rlimit;
}
global_mimiclib_deflate_unused_u32 =
libdeflate_adler32(global_mimiclib_deflate_unused_u32, ptr, len);
src->meta.ri += len;
}
return NULL;
}
const char* //
mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint32_t wuffs_initialize_flags,
uint64_t wlimit,
uint64_t rlimit) {
global_mimiclib_deflate_unused_u32 = 0;
while (src->meta.ri < src->meta.wi) {
uint8_t* ptr = src->data.ptr + src->meta.ri;
size_t len = src->meta.wi - src->meta.ri;
if (len > 0x7FFFFFFF) {
return "src length is too large";
} else if (len > rlimit) {
len = rlimit;
}
global_mimiclib_deflate_unused_u32 =
libdeflate_crc32(global_mimiclib_deflate_unused_u32, ptr, len);
src->meta.ri += len;
}
return NULL;
}
const char* //
mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint32_t wuffs_initialize_flags,
uint64_t wlimit,
uint64_t rlimit,
libdeflate_decompress_func func) {
struct libdeflate_decompressor* dec = libdeflate_alloc_decompressor();
if (!dec) {
return "libdeflate: alloc failed";
}
size_t n_dst = 0;
size_t n_src = 0;
enum libdeflate_result res =
(*func)(dec, wuffs_base__io_buffer__reader_pointer(src),
((size_t)wuffs_base__u64__min(
rlimit, wuffs_base__io_buffer__reader_length(src))),
wuffs_base__io_buffer__writer_pointer(dst),
((size_t)wuffs_base__u64__min(
wlimit, wuffs_base__io_buffer__writer_length(dst))),
&n_src, &n_dst);
if (res == LIBDEFLATE_SUCCESS) {
dst->meta.wi += n_dst;
src->meta.ri += n_src;
}
libdeflate_free_decompressor(dec);
return libdeflate_result_as_const_char_star(res);
}
const char* //
mimic_deflate_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint32_t wuffs_initialize_flags,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
wlimit, rlimit,
&libdeflate_deflate_decompress_ex);
}
const char* //
mimic_gzip_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint32_t wuffs_initialize_flags,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
wlimit, rlimit,
&libdeflate_gzip_decompress_ex);
}
const char* //
mimic_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint32_t wuffs_initialize_flags,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_gzip_zlib_decode(dst, src, wuffs_initialize_flags,
wlimit, rlimit,
&libdeflate_zlib_decompress_ex);
}
const char* //
mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
wuffs_base__slice_u8 dictionary) {
return "libdeflate does not implement zlib dictionaries";
}
// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
#elif defined(WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB)
#include "/path/to/your/copy/of/github.com/richgel999/miniz/miniz_tinfl.c"
// We deliberately do not define the
// WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING macro.
#define WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES 1
const char* //
mimic_bench_adler32(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
@@ -101,9 +260,16 @@ mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
return "miniz does not implement zlib dictionaries";
}
#else // WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB
// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
#else
#include "zlib.h"
// We deliberately do not define the
// WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING macro.
// We deliberately do not define the
// WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES macro.
uint32_t global_mimiclib_deflate_unused_u32;
const char* //
@@ -299,4 +465,5 @@ mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
UINT64_MAX, zlib_flavor_zlib);
}
#endif // WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB
#endif
// -------------------------------- WUFFS_MIMICLIB_USE_XXX_INSTEAD_OF_ZLIB
+1 -1
View File
@@ -37,7 +37,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -lz
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -ldeflate -lz
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
+1 -1
View File
@@ -37,7 +37,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -lz
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -ldeflate -lz
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
+8 -5
View File
@@ -37,7 +37,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -lz
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -ldeflate -lz
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
@@ -749,10 +749,9 @@ test_mimic_deflate_decode_deflate_distance_code_31() {
const char* have = do_test_io_buffers(mimic_deflate_decode,
&g_deflate_deflate_distance_code_31_gt,
UINT64_MAX, UINT64_MAX);
const char* want = "inflate failed (data error)";
if ((have != want) &&
((have == NULL) || (want == NULL) || strcmp(have, want))) {
RETURN_FAIL("have \"%s\", want \"%s\"", have, want);
if (!strings_are_equal(have, "inflate failed (data error)") &&
!strings_are_equal(have, "libdeflate: bad data")) {
RETURN_FAIL("have \"%s\", want \"bad data\" or similar", have);
}
return NULL;
}
@@ -924,7 +923,9 @@ proc g_tests[] = {
test_mimic_deflate_decode_deflate_huffman_primlen_9,
test_mimic_deflate_decode_midsummer,
test_mimic_deflate_decode_pi_just_one_read,
#ifndef WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING
test_mimic_deflate_decode_pi_many_big_reads,
#endif
test_mimic_deflate_decode_romeo,
test_mimic_deflate_decode_romeo_fixed,
@@ -947,7 +948,9 @@ proc g_benches[] = {
bench_mimic_deflate_decode_1k_full_init,
bench_mimic_deflate_decode_10k_full_init,
bench_mimic_deflate_decode_100k_just_one_read,
#ifndef WUFFS_MIMICLIB_DEFLATE_DOES_NOT_SUPPORT_STREAMING
bench_mimic_deflate_decode_100k_many_big_reads,
#endif
#endif // WUFFS_MIMIC
+1 -1
View File
@@ -37,7 +37,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -lz
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -ldeflate -lz
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
+3 -1
View File
@@ -37,7 +37,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -lz
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -ldeflate -lz
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
@@ -384,7 +384,9 @@ proc g_tests[] = {
test_mimic_zlib_decode_midsummer,
test_mimic_zlib_decode_pi,
#ifndef WUFFS_MIMICLIB_ZLIB_DOES_NOT_SUPPORT_DICTIONARIES
test_mimic_zlib_decode_sheep,
#endif
#endif // WUFFS_MIMIC
+11 -1
View File
@@ -671,7 +671,7 @@ read_file(wuffs_base__io_buffer* dst, const char* path) {
original_path);
}
FILE* f = fopen(path, "r");
FILE* f = fopen(path, "rb");
if (!f) {
RETURN_FAIL("read_file(\"%s\"): %s (errno=%d)", path, strerror(errno),
errno);
@@ -819,6 +819,16 @@ check_io_buffers_equal(const char* prefix,
return g_fail_msg;
}
bool //
strings_are_equal(const char* s, const char* t) {
if (s == t) {
return true;
} else if ((s == NULL) || (t == NULL)) {
return false;
}
return strcmp(s, t) == 0;
}
// throughput_counter is whether to count dst or src bytes, or neither, when
// calculating a benchmark's MB/s throughput number.
//
+8
View File
@@ -24,6 +24,12 @@ world examples of various file formats, or deriviations of them.
---
The non-ascii directory holds trivial UTF-8 (but not ASCII) text files.
---
`archive.*` archives a subset of other files in this directory.
`animated-red-blue.gif` is an original animation by Nigel Tao
<nigeltao@golang.org>.
@@ -60,6 +66,8 @@ Museum of art.
[www.metmuseum.org](http://www.metmuseum.org/art/collection/search/436532)
lists that image as in the public domain.
`hello.sh` is a trivial shell script.
`hibiscus.regular.*` are various encodings of a photo of "Hibiscus and Parrots"
by Louis Comfort Tiffany, held by the Metropolitan Museum of Art.
[www.metmuseum.org](http://www.metmuseum.org/art/collection/search/13503) lists
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+20
View File
@@ -0,0 +1,20 @@
#!/bin/bash -eu
# Copyright 2021 The Wuffs Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ----------------
# This file should have the "executable" Unix permission bit.
echo hello
+2
View File
@@ -0,0 +1,2 @@
α U+03B1 GREEK SMALL LETTER ALPHA. UTF-8: [C3 B1].
β U+03B2 GREEK SMALL LETTER BETA. UTF-8: [C3 B2].
+3
View File
@@ -0,0 +1,3 @@
😻 U+1F63B SMILING CAT FACE WITH HEART-SHAPED EYES. UTF-8: [F0 9F 98 BB].
This code point is outside of the Unicode BMP (Basic Multilingual Plane).
Binary file not shown.