Compare commits

...
Author SHA1 Message Date
Nigel Tao 66cfd3e02f wuffs gen -version=0.3.0-beta.11 2021-11-18 19:19:02 +11:00
Nigel Tao 161e4730d8 Tweak default WUFFS_VERSION_PRE_RELEASE_LABEL 2021-11-18 19:18:34 +11:00
Nigel Tao d5066c1aae Add wuffs_aux::private_impl::ErrorMessages type 2021-11-18 17:30:11 +11:00
Nigel Tao 8562375fd9 Update test/nia-checksums-of-data.txt 2021-11-18 08:11:06 +11:00
Nigel Tao bb028ae764 Update tests for artificial/* filename rename 2021-11-18 08:10:12 +11:00
Nigel Tao 29560a336b Convert std/png text from Latin-1 to UTF-8
Fixes #55
2021-11-17 23:04:49 +11:00
Nigel Tao e0cdaeb54f Fix std/png tell_me_more minfo with suspensions 2021-11-17 13:04:04 +11:00
Nigel Tao e7ed1dd43e Add std/png tell_me_more while.loop name 2021-11-17 13:01:05 +11:00
Nigel Tao bfce0e0a16 Let wuffs_aux::DecodeImage re-use raw metadata buf 2021-11-17 12:44:21 +11:00
Nigel Tao 417b03a0ad Add std/png "#unsupported PNG compression method" 2021-11-17 12:07:44 +11:00
Nigel Tao 7dd0dd264b Delete superfluous "// --------" comment 2021-11-17 12:03:43 +11:00
Nigel Tao 0d37acd6f6 Factor out std/png/common_consts.wuffs 2021-11-17 12:01:37 +11:00
Nigel Tao 6737565c20 Let std/png decode iTXt, tEXt and zTXt chunks
Updates #55
2021-11-17 11:56:49 +11:00
Nigel Tao 3642d73714 Factor test/data/artificial into many directories 2021-11-16 15:37:57 +11:00
Nigel Tao 37ac4def8e Move some test/data/artificial files up one dir 2021-11-16 15:12:29 +11:00
Nigel Tao 07c053af6f Have reset! LEAVE_INTERNAL_BUFFERS_UNINITIALIZED 2021-11-16 13:16:43 +11:00
Nigel Tao f0c2a40d66 Resize std/png chunk_length field from u64 to u32 2021-11-16 13:06:30 +11:00
Nigel Tao ce9ab13ecd Let std/png decode first fcTL after the last IDAT 2021-11-16 12:55:43 +11:00
Nigel Tao 6c2a591e84 Let script/make-artificial.go generate PNG files 2021-11-16 11:08:04 +11:00
Nigel Tao d40bf000a9 Rename wuffs_base__table_u8__row as etc__row_u32 2021-11-15 17:26:51 +11:00
Nigel Tao 0045ce49f3 Rename table.row as table.row_u32 2021-11-15 10:49:42 +11:00
Nigel Tao fa56d92410 Clip std/png frame_dirty_rect to frame rect 2021-11-15 10:46:28 +11:00
Nigel Tao 8f1adea523 Hoist subslice out of std/png filter_and_swizzle
On an Intel NUC (Comet Lake, BXNUC10i5FNKPA):

name                                                      old speed      new speed      delta

wuffs_png_decode_image_19k_8bpp/clang9                     274MB/s ± 0%   273MB/s ± 0%  -0.25%  (p=0.008 n=5+5)
wuffs_png_decode_image_40k_24bpp/clang9                    309MB/s ± 0%   308MB/s ± 0%  -0.22%  (p=0.008 n=5+5)
wuffs_png_decode_image_77k_8bpp/clang9                     985MB/s ± 0%   982MB/s ± 0%  -0.29%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   846MB/s ± 0%   841MB/s ± 0%  -0.56%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   812MB/s ± 0%   808MB/s ± 0%  -0.55%  (p=0.008 n=5+5)
wuffs_png_decode_image_4002k_24bpp/clang9                  320MB/s ± 0%   320MB/s ± 0%  -0.15%  (p=0.008 n=5+5)

wuffs_png_decode_image_19k_8bpp/gcc10                      263MB/s ± 0%   276MB/s ± 0%  +5.00%  (p=0.008 n=5+5)
wuffs_png_decode_image_40k_24bpp/gcc10                     328MB/s ± 0%   333MB/s ± 0%  +1.49%  (p=0.016 n=5+4)
wuffs_png_decode_image_77k_8bpp/gcc10                      950MB/s ± 0%   976MB/s ± 0%  +2.78%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10    865MB/s ± 0%   912MB/s ± 0%  +5.45%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10    825MB/s ± 0%   868MB/s ± 0%  +5.19%  (p=0.008 n=5+5)
wuffs_png_decode_image_4002k_24bpp/gcc10                   336MB/s ± 0%   341MB/s ± 0%  +1.37%  (p=0.008 n=5+5)
2021-11-15 10:43:55 +11:00
Nigel Tao 962a515dd2 Add wuffs_base__table_u8__subtable_ij 2021-11-15 09:58:02 +11:00
Nigel Tao 8025bf1bd7 Fix std/png filter benches 2021-11-14 21:20:05 +11:00
Nigel Tao 4d64aff554 Rename std/png/decode_swizzle_fallback.wuffs 2021-11-14 19:58:23 +11:00
Nigel Tao 54bdcc1b57 Update wuffs_aux::DecodeImageArgFlags comment 2021-11-14 19:57:18 +11:00
Nigel Tao a4fa6a2554 Let std/png decode (animated) APNG
The test/nia-checksums-of-data.txt checksums for the *.apng files now
match the (multiple frame) *.gif files. Previously, they matched the
(single frame) *.000000.nie files.

Fixes #41
2021-11-14 18:20:15 +11:00
Nigel Tao 22eed1fd8d Let example/convert-to-nia decode NIE 2021-11-13 11:21:35 +11:00
Nigel Tao c19e3b1cab Add script/extract-nia-frames.go 2021-11-11 11:47:08 +11:00
Nigel Tao 9af2666aec Move std/png first_frame_io_position earlier 2021-11-10 16:52:59 +11:00
Nigel Tao 9c3d27fb43 Fix std/png decode_other_chunk skipping chunks 2021-11-09 22:10:00 +11:00
Nigel Tao 2373340f83 Add base.ANIMATION_DISPOSAL__ETC constants 2021-11-09 09:53:29 +11:00
Nigel Tao e847766b02 Tweak std/png decode_other_chunk if-else chain 2021-11-09 09:05:11 +11:00
Nigel Tao 74c1dfce96 Rename std/gif num_loops field 2021-11-09 08:55:15 +11:00
Nigel Tao f4c2d4652e Fix test/data/animated-red-blue.apng loop count
The diff of the "hd" hex dump shows that the acTL chunk's nominal loop
count changed from 2 to 3. The 4-byte CRC-32 checksum was also updated.
 00000000  89 50 4e 47 0d 0a 1a 0a  00 00 00 0d 49 48 44 52  |.PNG........IHDR|
 00000010  00 00 00 40 00 00 00 30  08 02 00 00 00 2e 29 eb  |...@...0......).|
 00000020  48 00 00 00 08 61 63 54  4c 00 00 00 04 00 00 00  |H....acTL.......|
-00000030  02 92 c3 07 fc 00 00 00  06 74 52 4e 53 00 00 00  |.........tRNS...|
+00000030  03 e5 c4 37 6a 00 00 00  06 74 52 4e 53 00 00 00  |...7j....tRNS...|
 00000040  00 00 10 73 11 17 f5 00  00 00 1a 66 63 54 4c 00  |...s.......fcTL.|
 00000050  00 00 00 00 00 00 40 00  00 00 30 00 00 00 00 00  |......@...0.....|
 00000060  00 00 00 00 0a 00 64 00  00 80 50 f1 a2 00 00 03  |......d...P.....|
2021-11-07 10:43:32 +11:00
Nigel Tao ca76a01ac2 Have std/png support remapped transparency 2021-11-07 09:51:04 +11:00
Nigel Tao 00b329872a Tighten png.INTERLACING type refinement 2021-11-06 09:54:56 +11:00
Nigel Tao 0a7168fd64 Add test/data/*.apng 2021-11-05 22:28:08 +11:00
Nigel Tao f854646586 Fix -Wshadow warnings 2021-11-05 17:51:22 +11:00
Nigel Tao f148f5c5b3 Make "// - etc" bullet point comments consistent 2021-11-05 16:50:38 +11:00
Nigel Tao 750df217dd Rename deprecated ETC__FLAVOR__METADATA 2021-11-05 16:48:58 +11:00
Nigel Tao 744fbdd732 Have std/png decode iCCP chunks
Updates #39
2021-11-05 16:29:11 +11:00
Nigel Tao 0854344580 Add wuffs_aux::sync_io::DynIOBuffer 2021-11-04 22:58:45 +11:00
Nigel Tao d5075c7e94 Push "int i" into "for (int i = etc; etc; etc)" 2021-11-02 14:07:58 +11:00
Nigel Tao 16b51dd2a4 Fix -Wshadow warnings 2021-10-31 16:27:47 +11:00
Nigel Tao badce3ffa4 Tweak magic_number_guess_fourcc negative codes 2021-10-31 16:27:17 +11:00
Nigel Tao f40ef01244 Have make-red-blue-gradient use iCCP profile name 2021-10-31 15:35:14 +11:00
Nigel Tao 8f9a4f40c2 Rename METADATA_RAW as METADATA_RAW_PASSTHROUGH 2021-10-31 15:17:46 +11:00
Nigel Tao c754f81634 Have wuffs_aux::DecodeImage report ICCP, XMP 2021-10-31 15:09:55 +11:00
Nigel Tao a9a6332be2 Have etc__magic_number_guess_fourcc find ICO 2021-10-22 15:51:44 +11:00
Nigel Tao d557bc3836 Embiggen test/data/red-blue-gradient.*.png 2021-10-22 09:23:49 +11:00
Nigel Tao 01a5b8842b Update test/nia-checksums-of-data.txt 2021-10-20 19:38:43 +11:00
Nigel Tao 35cb4df973 Rename test/data/red-blue-gradient.dcip3d65.png 2021-10-20 19:38:24 +11:00
Nigel Tao 15b6285d1c Add example/imageviewer -screen_gamma=N.N flag 2021-10-20 15:42:26 +11:00
Nigel Tao 6ea3144379 Add test/data/checkerboard.*.png 2021-10-20 09:58:42 +11:00
Nigel Tao b003f9fe65 Let wuffs_aux::DecodeImage handle metadata
Updates #39
2021-10-19 22:09:21 +11:00
Nigel Tao d259f7a579 Fix json_fuzzer for wuffs_aux::FooArgBar types 2021-10-18 00:46:50 +11:00
Nigel Tao 2b7b6e12ea Add wuffs_aux::DecodeImageArgQuirks 2021-10-18 00:40:11 +11:00
Nigel Tao ca33506c01 Add wuffs_aux::FooArgBar types for optional args
Prior to this commit, with a "wuffs_aux::Foo(x, y, 0, 0, 4, 5)" call,
with arguments after "y" optional, it was not a compile-time error to
give the wrong number of "0"s or to transpose "4" and "5".
2021-10-18 00:25:13 +11:00
Nigel Tao 0460bfcd7a Add FourCC comment 2021-10-17 23:18:58 +11:00
Nigel Tao 9437d1a265 Tighten magic number guessing for WBMP 2021-10-17 22:57:42 +11:00
Nigel Tao 2e821791a9 Update test/nia-checksums-of-data.txt 2021-10-17 13:08:24 +11:00
Nigel Tao e317f04bfd Add defined(__clang__) to defined(__GNUC__) checks 2021-10-17 12:14:54 +11:00
Nigel Tao db5a407bab Have std/png decode sRGB chunks
Updates #39
2021-10-16 09:27:30 +11:00
Nigel Tao 9323549eeb Update doc/changelog.md 2021-10-15 16:34:04 +11:00
Nigel Tao 911049e9f9 Have std/png decode cHRM and gAMA chunks
Updates #39
2021-10-15 15:08:47 +11:00
Nigel Tao ae9ca94501 Fix etc__more_information__metadata_parsed__chrm 2021-10-15 14:15:39 +11:00
Nigel Tao d8ad363ef5 Tweak png.decoder.decode_image_config indentation 2021-10-15 13:35:15 +11:00
Nigel Tao e6733aec19 Add test/data/red-blue-gradient.dcip3d65.png 2021-10-15 11:29:26 +11:00
Nigel Tao ad1d983698 Add ETC__MORE_INFORMATION__FLAVOR__METADATA_PARSED 2021-10-14 17:17:11 +11:00
Nigel Tao dbc209dd7e Add test/data/red-blue-gradient.*.png 2021-10-14 15:58:03 +11:00
Nigel Tao 1a94a6f1b3 Choose fuzzer's static-ness on program vs library
Some sanitizers don't work well with static functions.

Updates https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=39767
2021-10-10 10:46:05 +11:00
Nigel Tao 34e2786dd2 wuffs gen -version=0.3.0-beta.10 2021-10-07 17:03:51 +11:00
Nigel Tao 5a4dd303f0 Remove hippopotamus.interlaced.png "wuffs test"
Coverage now comes from build-all.sh's nia-checksums-of-data.txt test.
2021-10-07 16:52:17 +11:00
Nigel Tao 62125d8967 Add test/nia-checksums-of-data.txt 2021-10-07 16:49:38 +11:00
Nigel Tao eb6703425a Tweak build-*.sh "Wuffs root directory" check 2021-10-07 14:59:13 +11:00
Nigel Tao 6fb7697b4a Have scripts use WUFFS_CONFIG__STATIC_FUNCTIONS 2021-10-07 14:36:35 +11:00
Nigel Tao 55784030e4 Have fuzzers use WUFFS_CONFIG__STATIC_FUNCTIONS
Compile time:
$ time ./build-fuzz.sh
Before: user 0m36.656s
After:  user 0m18.534s
2021-10-07 14:26:08 +11:00
Nigel Tao feb050b418 Add CFLAGS, CXXFLAGS, LDFLAGS to build-fuzz.sh 2021-10-07 14:12:16 +11:00
Nigel Tao f9c029c788 Fix std/png history_position for interlacing 2021-10-07 13:52:40 +11:00
Nigel Tao 90d3232eae Let example/imageviewer minify (negative zoom) 2021-10-07 12:59:38 +11:00
Nigel Tao 2945ef2b29 Have example/imageviewer avoid big xcb_image_put's 2021-10-07 12:35:12 +11:00
Nigel Tao ea4c85bfa2 Add comment re previous commit (strip examples) 2021-10-04 23:37:37 +11:00
Nigel Tao 41fce8a8de Strip examples of unused data and functions
Compile time:
$ time ./build-example.sh
Before: user 0m40.885s
After:  user 0m41.011s

Binary size (for example-toy-genlib):
$ ls -l gen/bin/example-toy-genlib) | awk '{print $5}'
Before: 830168
After:  809896
Note that the majority of this is a statically linked libc.

Binary size (excluding the statically linked example-toy-genlib):
$ ls -l gen/bin/example-* | awk '{print $5 " " $9}'

Before:
 85280 gen/bin/example-cbor-to-json
242216 gen/bin/example-convert-to-nia
 37112 gen/bin/example-crc32
 53328 gen/bin/example-gifplayer
282840 gen/bin/example-imageviewer
 95152 gen/bin/example-json-to-cbor
122720 gen/bin/example-jsonfindptrs
 60448 gen/bin/example-jsonptr
267672 gen/bin/example-sdl-imageviewer
 64792 gen/bin/example-zcat

After:
 73104 gen/bin/example-cbor-to-json
231560 gen/bin/example-convert-to-nia
 34640 gen/bin/example-crc32
 47632 gen/bin/example-gifplayer
269632 gen/bin/example-imageviewer
 83032 gen/bin/example-json-to-cbor
118664 gen/bin/example-jsonfindptrs
 58040 gen/bin/example-jsonptr
253424 gen/bin/example-sdl-imageviewer
 58200 gen/bin/example-zcat

Before total: 1311560
After  total: 1227928
2021-10-04 13:28:42 +11:00
Nigel Tao 9699c49f55 Have example/crc32 use WUFFS_CONFIG__MODULES
Compile time:
$ time ./build-example.sh example/crc32
Before: user 10.637s
After:  user  1.314s

Binary size:
$ ls -l gen/bin/example-crc32 | awk '{print $5}'
Before: 344744
After:   37112
2021-10-04 13:03:27 +11:00
Nigel Tao 7f9f37ce5a Have examples use WUFFS_CONFIG__STATIC_FUNCTIONS
Compile time:
$ time ./build-example.sh
Before: user 1m15.750s
After:  user 0m50.343s

Binary size (excluding the statically linked example-toy-genlib):
$ ls -l gen/bin/example-* | awk '{print $5 " " $9}'

Before:
212624 gen/bin/example-cbor-to-json
284192 gen/bin/example-convert-to-nia
344744 gen/bin/example-crc32
184304 gen/bin/example-gifplayer
324952 gen/bin/example-imageviewer
209632 gen/bin/example-json-to-cbor
241432 gen/bin/example-jsonfindptrs
196320 gen/bin/example-jsonptr
309768 gen/bin/example-sdl-imageviewer
200704 gen/bin/example-zcat

After:
 85280 gen/bin/example-cbor-to-json
242216 gen/bin/example-convert-to-nia
344744 gen/bin/example-crc32
 53328 gen/bin/example-gifplayer
282840 gen/bin/example-imageviewer
 95152 gen/bin/example-json-to-cbor
122720 gen/bin/example-jsonfindptrs
 60448 gen/bin/example-jsonptr
267672 gen/bin/example-sdl-imageviewer
 64792 gen/bin/example-zcat

Before total: 2508672
After  total: 1619192
2021-10-04 12:35:32 +11:00
Nigel Tao 774340ae27 Add CFLAGS, CXXFLAGS, LDFLAGS to build-example.sh 2021-10-04 12:31:34 +11:00
Nigel Tao 7753368324 Add const to example/imageviewer zooms variable 2021-10-04 09:33:33 +11:00
Nigel Tao 8eaa222592 Add example/imageviewer zoom and filter 2021-10-03 16:42:58 +11:00
Nigel Tao 1cf0df9da4 Tweak example{,sdl-}imageviewer 2021-10-03 15:30:04 +11:00
Nigel Tao 68acf24515 Remove Makefiles
They don't work for me (on Debian bullseye). For example, from the
example/sdl-imageviewer directory:

$ make
g++   -lSDL2 -lSDL2_image  sdl-imageviewer.cc   -o sdl-imageviewer
/usr/bin/ld: /tmp/cciX1mj2.o: in function `draw(SDL_Window*)':
sdl-imageviewer.cc:(.text+0x36e44): undefined reference to `SDL_GetWindowSurface'
/usr/bin/ld: sdl-imageviewer.cc:(.text+0x36e69): undefined reference to `SDL_CreateRenderer'
/usr/bin/ld: sdl-imageviewer.cc:(.text+0x36e79): undefined reference to `SDL_RenderClear'
etc
collect2: error: ld returned 1 exit status
make: *** [<builtin>: sdl-imageviewer] Error 1

Swapping the g++ args around to

g++ sdl-imageviewer.cc -lSDL2 -lSDL2_image -o sdl-imageviewer

works, but the recommended approach is to use the existing top-level
build-example.sh script instead.
2021-10-03 14:06:16 +11:00
Nigel Tao 2453a8d52a Run "clang-format-9 -style=Chromium"
Also replace /*...*/ comments with //... comments. The former don't nest
when using /*...*/ to comment out blocks of code.
2021-10-03 13:53:27 +11:00
Nigel Tao bb7b75ff86 Add Přemysl Eric Janouch to A+C 2021-10-03 13:34:48 +11:00
Nigel Tao 66bcef6fff Merge pull request #54 from pjanx/main
Fix both imageviewers on X.org with DefaultDepth 30
2021-10-03 13:33:29 +11:00
Přemysl Eric Janouch 7ee081f4b9 Add Makefiles to image viewer demos
There doesn't seem to be much of a point in making it difficult
to try out Wuffs's most practical feature.
2021-09-30 12:38:32 +02:00
Přemysl Eric Janouch 6f39b9641b Fix the sdl-imageviewer demo on DefaultDepth 30
Using SDL renderers should make this work reliably
with pratically any root window visual.
2021-09-30 12:35:43 +02:00
Přemysl Eric Janouch 550fabd15d Fix the imageviewer demo on DefaultDepth 30
Using Render compositing should make this work reliably
with pratically any root window visual.
2021-09-30 12:14:51 +02:00
Přemysl Eric Janouch a1d9c6a8e6 Make imageviewer not segfault on XCB errors
Fixing the issue properly doesn't seem worth the effort,
shared memory is ugly, and incremental loading is a lot of code.

Xlib - XCB 1:0
2021-09-30 07:31:45 +02:00
Nigel Tao de45ab1d2b Add archive.password-is-asdf.zip
$ zip --password asdf archive.password-is-asdf.zip etc etc
2021-09-21 11:54:02 +10:00
Nigel Tao c8592d2b7a Remove obsolete comments re s/gAMA/hAMA/ PNG chunk
The one-byte patch was added in commit 88616cc9 but no longer applied as
of commit 54771322.
2021-09-06 23:14:29 +10:00
Nigel Tao 9d10438914 Add test/data/bricks-dither.no-ancillary.png 2021-09-06 22:57:55 +10:00
Nigel Tao 0d57d6a2e1 Add internal/cgen/base/README.md 2021-09-04 15:54:31 +10:00
Nigel Tao 26d9ec41fd Fix some markdown links to /doc/glossary.md 2021-09-04 15:48:25 +10:00
Nigel Tao a66a083e82 Have X86_FAMILY allow 32-bit x86, not just x86_64
Fixes #53
2021-08-22 22:37:48 +10:00
Nigel Tao cb2e49ab09 Rename CPU arch macro s/X86_64/X86_FAMILY/ 2021-08-22 22:23:49 +10:00
Nigel Tao 75faea996d Add parse "122.416294033786585" test case 2021-08-22 16:02:44 +10:00
Nigel Tao 1d19157668 Remove After editing... run "go generate" lines 2021-08-22 12:57:39 +10:00
Nigel Tao bdfee5053c Delete obsolete ".../internal/cgen/data" package 2021-08-22 12:54:07 +10:00
Nigel Tao 2f65d6fc74 Use go:embed instead of ".../internal/cgen/data" 2021-08-22 12:52:52 +10:00
Nigel Tao 226c476994 Remove calls to Go's deprecated "io/ioutil" 2021-08-22 11:17:34 +10:00
Nigel Tao 788479dd64 Run "gofmt -w ." for new "//go:build" lines 2021-08-22 10:53:06 +10:00
Nigel Tao d3c7d103ca Update script/*.go module dependencies 2021-08-22 10:49:18 +10:00
Nigel Tao 17b624c038 Bump go.mod from "go 1.13" to "go 1.16" 2021-08-22 09:58:58 +10:00
Nigel Tao 786fc74b92 wuffs gen -version=0.3.0-beta.9 2021-08-15 13:49:26 +10:00
Nigel Tao a86fd7fa79 Fix -Werror=sign-conversion in intconv-submodule.c 2021-08-15 13:48:04 +10:00
Nigel Tao 341dd50800 Add more internal errors to wuffs_aux Cbor, Json 2021-08-15 13:40:17 +10:00
Nigel Tao a83b5cabaf Fix "-(int64_t)0x8000000000000000" undef behavior
Updates https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=37191
2021-08-15 12:39:01 +10:00
Nigel Tao 8a4f61501b Add NULL-check for io_{read,writ}er.position() 2021-08-15 11:13:26 +10:00
Nigel Tao 592bc14ed1 Have std/deflate allow non-compact dst history
Fixes #52

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

name                                                      old speed      new speed      delta

wuffs_deflate_decode_1k_full_init/clang9                   101MB/s ± 1%   100MB/s ± 1%   -1.22%  (p=0.000 n=9+9)
wuffs_deflate_decode_1k_part_init/clang9                   119MB/s ± 1%   119MB/s ± 1%     ~     (p=0.139 n=8+9)
wuffs_deflate_decode_10k_full_init/clang9                  221MB/s ± 1%   210MB/s ± 1%   -4.94%  (p=0.000 n=9+9)
wuffs_deflate_decode_10k_part_init/clang9                  225MB/s ± 3%   215MB/s ± 1%   -4.33%  (p=0.000 n=10+8)
wuffs_deflate_decode_100k_just_one_read/clang9             290MB/s ± 0%   284MB/s ± 1%   -2.26%  (p=0.000 n=8+9)
wuffs_deflate_decode_100k_many_big_reads/clang9            188MB/s ± 3%   177MB/s ± 1%   -5.78%  (p=0.000 n=9+10)

wuffs_deflate_decode_1k_full_init/gcc10                    101MB/s ± 0%    97MB/s ± 1%   -3.65%  (p=0.000 n=8+9)
wuffs_deflate_decode_1k_part_init/gcc10                    119MB/s ± 1%   113MB/s ± 2%   -4.65%  (p=0.000 n=9+9)
wuffs_deflate_decode_10k_full_init/gcc10                   214MB/s ± 3%   224MB/s ± 1%   +4.83%  (p=0.000 n=10+10)
wuffs_deflate_decode_10k_part_init/gcc10                   222MB/s ± 1%   231MB/s ± 1%   +4.03%  (p=0.000 n=9+10)
wuffs_deflate_decode_100k_just_one_read/gcc10              281MB/s ± 2%   297MB/s ± 0%   +5.78%  (p=0.000 n=9+9)
wuffs_deflate_decode_100k_many_big_reads/gcc10             184MB/s ± 0%   194MB/s ± 0%   +5.85%  (p=0.000 n=10+8)

mimic_deflate_decode_1k_full_init                          138MB/s ± 1%   138MB/s ± 0%     ~     (p=0.546 n=9+9)
mimic_deflate_decode_10k_full_init                         156MB/s ± 2%   156MB/s ± 0%     ~     (p=0.387 n=9+9)
mimic_deflate_decode_100k_just_one_read                    191MB/s ± 1%   190MB/s ± 2%   -0.94%  (p=0.004 n=9+10)
mimic_deflate_decode_100k_many_big_reads                   147MB/s ± 1%   147MB/s ± 1%     ~     (p=0.356 n=9+10)

wuffs_gzip_decode_10k/clang9                               220MB/s ± 1%   209MB/s ± 1%   -5.29%  (p=0.000 n=10+9)
wuffs_gzip_decode_100k/clang9                              283MB/s ± 2%   279MB/s ± 1%   -1.47%  (p=0.002 n=10+10)

wuffs_gzip_decode_10k/gcc10                                218MB/s ± 1%   214MB/s ± 2%   -1.76%  (p=0.000 n=9+10)
wuffs_gzip_decode_100k/gcc10                               274MB/s ± 0%   264MB/s ± 2%   -3.61%  (p=0.000 n=7+10)

mimic_gzip_decode_10k                                      131MB/s ± 2%   132MB/s ± 0%   +0.81%  (p=0.000 n=10+8)
mimic_gzip_decode_100k                                     156MB/s ± 0%   156MB/s ± 1%     ~     (p=0.423 n=8+9)

wuffs_zlib_decode_10k/clang9                               223MB/s ± 2%   209MB/s ± 2%   -6.41%  (p=0.000 n=10+10)
wuffs_zlib_decode_100k/clang9                              285MB/s ± 0%   280MB/s ± 0%   -1.87%  (p=0.000 n=8+9)

wuffs_zlib_decode_10k/gcc10                                235MB/s ± 0%   215MB/s ± 1%   -8.22%  (p=0.000 n=10+9)
wuffs_zlib_decode_100k/gcc10                               293MB/s ± 0%   268MB/s ± 1%   -8.38%  (p=0.000 n=8+10)

mimic_zlib_decode_10k                                      145MB/s ± 1%   145MB/s ± 1%   -0.45%  (p=0.004 n=9+9)
mimic_zlib_decode_100k                                     175MB/s ± 1%   174MB/s ± 0%     ~     (p=0.055 n=10+8)

wuffs_png_decode_image_19k_8bpp/clang9                     142MB/s ± 1%   152MB/s ± 1%   +6.98%  (p=0.000 n=9+9)
wuffs_png_decode_image_40k_24bpp/clang9                    172MB/s ± 0%   170MB/s ± 0%   -1.63%  (p=0.000 n=8+9)
wuffs_png_decode_image_77k_8bpp/clang9                     504MB/s ± 2%   540MB/s ± 1%   +7.28%  (p=0.000 n=9+10)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   462MB/s ± 1%   470MB/s ± 0%   +1.57%  (p=0.000 n=9+10)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   445MB/s ± 1%   451MB/s ± 0%   +1.49%  (p=0.000 n=8+10)
wuffs_png_decode_image_4002k_24bpp/clang9                  175MB/s ± 3%   175MB/s ± 1%     ~     (p=0.356 n=9+10)

wuffs_png_decode_image_19k_8bpp/gcc10                      150MB/s ± 0%   153MB/s ± 1%   +2.03%  (p=0.000 n=10+10)
wuffs_png_decode_image_40k_24bpp/gcc10                     186MB/s ± 0%   186MB/s ± 0%     ~     (p=0.408 n=10+8)
wuffs_png_decode_image_77k_8bpp/gcc10                      543MB/s ± 0%   542MB/s ± 0%   -0.23%  (p=0.019 n=9+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10    478MB/s ± 1%   498MB/s ± 0%   +4.12%  (p=0.000 n=10+9)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10    451MB/s ± 4%   476MB/s ± 0%   +5.37%  (p=0.000 n=10+9)
wuffs_png_decode_image_4002k_24bpp/gcc10                   185MB/s ± 2%   190MB/s ± 1%   +2.78%  (p=0.000 n=10+9)

mimic_png_decode_image_19k_8bpp                           63.0MB/s ± 0%  62.9MB/s ± 1%     ~     (p=0.673 n=8+9)
mimic_png_decode_image_40k_24bpp                          78.7MB/s ± 0%  78.9MB/s ± 0%     ~     (p=0.059 n=9+8)
mimic_png_decode_image_77k_8bpp                            192MB/s ± 1%   193MB/s ± 3%   +0.44%  (p=0.028 n=10+9)
mimic_png_decode_image_552k_32bpp_verify_checksum          157MB/s ± 0%   158MB/s ± 1%     ~     (p=0.053 n=10+9)
mimic_png_decode_image_4002k_24bpp                         113MB/s ± 1%   113MB/s ± 1%     ~     (p=0.053 n=10+9)
2021-08-15 10:50:41 +10:00
Nigel Tao f73f95b698 Rename from ast.IOBind to ast.IOManip 2021-08-15 08:40:05 +10:00
Nigel Tao 28a54baa19 Add io_bind history_position arg 2021-08-15 08:36:14 +10:00
Nigel Tao b60a2cacd9 Add io_writer.history_position 2021-08-15 08:19:40 +10:00
Nigel Tao f7b1b87c70 Fix "-Wnarrowing -m32" warning for some fuzzers 2021-08-14 12:49:04 +10:00
Nigel Tao 13f2e44aca Have JSON fuzzer segfault on internal errors 2021-08-13 17:45:23 +10:00
Nigel Tao 128d0386bd Fuzz wuffs_aux::DecodeJson 2021-08-12 23:07:26 +10:00
Nigel Tao 1b9a6cb85b wuffs gen -version=0.3.0-beta.8 2021-07-20 14:21:21 +10:00
Nigel Tao 77f855206d Have JSON line-comment tokens exclude the "\n"
Before this commit, line-comment token chains included the final "\n"
the way block-comments included the final "*/". The "\n" was mandatory.

However, when parsing with both QUIRK_ALLOW_COMMENT_LINE and
QUIRK_ALLOW_TRAILING_FILLER, input like "123//xyz" (without a "\n"
before the EOF) was rejected before and accepted after this commit.

So that line-comments are consistent, in that they either always or
never include the final "\n", they now never include the final "\n".

An input fragment (parsed with QUIRK_ALLOW_COMMENT_LINE) like
"//abc\n\t\t" was, before this commit, parsed as a 6 byte comment token
and a 2 byte other-filler token. That split is now 5+3.
2021-07-20 14:17:09 +10:00
Nigel Tao 40ffa334ee Add more json allow_trailing_comments test cases 2021-07-18 23:27:56 +10:00
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
248 changed files with 13837 additions and 4003 deletions

No files matched your search

+1
View File
@@ -15,3 +15,4 @@ Google Inc.
Jimmy Casey <casey.jimmy@gmail.com>
Mike Kaufman <mkaufman@microsoft.com>
Muhammad Aldo Firmansyah <TheCrott@users.noreply.github.com>
Přemysl Eric Janouch <p@janouch.name>
+2
View File
@@ -39,3 +39,5 @@ 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>
Přemysl Eric Janouch <p@janouch.name>
+26 -2
View File
@@ -37,7 +37,7 @@
# gcc ./example/zcat/zcat.c
# ./a.out < ./test/data/romeo.txt.gz
if [ ! -e release/c/wuffs-unsupported-snapshot.c ]; then
if [ ! -e wuffs-root-directory.txt ]; then
echo "$0 should be run from the Wuffs root directory."
exit 1
fi
@@ -70,12 +70,19 @@ wuffs test -skipgen -mimic
wuffs bench -skipgen -mimic -reps=1 -iterscale=1
./build-example.sh
./build-fuzz.sh
# ----
echo "Running gen/bin/example-crc32"
JSON_THINGS_CRC32=$(gen/bin/example-crc32 < test/data/json-things.formatted.json)
if [ "$JSON_THINGS_CRC32" != "cdcc7e35" ]; then
echo "example-crc32 failed on json-things data"
exit 1
fi
# ----
echo "Running gen/bin/example-jsonptr"
JSON_THINGS_CRC32=$(gen/bin/example-jsonptr < test/data/json-things.unformatted.json | gen/bin/example-crc32)
if [ "$JSON_THINGS_CRC32" != "cdcc7e35" ]; then
@@ -83,8 +90,25 @@ if [ "$JSON_THINGS_CRC32" != "cdcc7e35" ]; then
exit 1
fi
./build-fuzz.sh
# ----
echo "Running gen/bin/example-convert-to-nia"
set +e
script/print-nia-checksums.sh | \
diff --unified test/nia-checksums-of-data.txt /dev/stdin
if [ $? != 0 ]; then
echo "Unexpected change in test/nia-checksums-of-data.txt"
exit 1
fi
set -e
# ----
for f in gen/bin/fuzz-*; do
echo "Running $f"
$f test/data > /dev/null
done
# ----
echo "DONE: build-all.sh"
+24 -13
View File
@@ -17,13 +17,19 @@
# See build-all.sh for commentary.
if [ ! -e release/c/wuffs-unsupported-snapshot.c ]; then
if [ ! -e wuffs-root-directory.txt ]; then
echo "$0 should be run from the Wuffs root directory."
exit 1
fi
CC=${CC:-gcc}
CXX=${CXX:-g++}
LDFLAGS=${LDFLAGS:-}
# The "-fdata-sections -ffunction-sections -Wl,--gc-sections" produces smaller
# binaries. See commit 41fce8a8 "Strip examples of unused data and functions".
CFLAGS=${CFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
CXXFLAGS=${CXXFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
mkdir -p gen/bin
@@ -41,30 +47,35 @@ for f in $sources; do
if [ $f = imageviewer ]; then
# example/imageviewer is unusual in that needs additional libraries.
echo "Building gen/bin/example-$f"
$CXX -O3 example/$f/*.cc -lxcb -lxcb-image -o gen/bin/example-$f
echo "Building (C++) gen/bin/example-$f"
$CXX $CXXFLAGS example/$f/*.cc \
$LDFLAGS -lxcb -lxcb-image -lxcb-render -lxcb-render-util \
-o gen/bin/example-$f
elif [ $f = "sdl-imageviewer" ]; then
# example/sdl-imageviewer is unusual in that needs additional libraries.
echo "Building gen/bin/example-$f"
$CXX -O3 example/$f/*.cc -lSDL2 -lSDL2_image -o gen/bin/example-$f
echo "Building (C++) gen/bin/example-$f"
$CXX $CXXFLAGS example/$f/*.cc \
$LDFLAGS -lSDL2 -lSDL2_image \
-o gen/bin/example-$f
elif [ $f = "toy-genlib" ]; then
# example/toy-genlib is unusual in that it uses separately compiled
# libraries (built by "wuffs genlib", e.g. by running build-all.sh) instead
# of directly #include'ing Wuffs' .c files.
if [ -e gen/lib/c/$CC-static/libwuffs.a ]; then
echo "Building gen/bin/example-$f"
$CC -O3 -static -I.. example/$f/*.c gen/lib/c/$CC-static/libwuffs.a -o gen/bin/example-$f
echo "Building (C) gen/bin/example-$f"
$CC $CFLAGS -static -I.. example/$f/*.c gen/lib/c/$CC-static/libwuffs.a \
$LDFLAGS -o gen/bin/example-$f
else
echo "Skipping gen/bin/example-$f; run \"wuffs genlib\" first"
fi
elif [ -e example/$f/*.c ]; then
echo "Building gen/bin/example-$f"
$CC -O3 example/$f/*.c -o gen/bin/example-$f
echo "Building (C) gen/bin/example-$f"
$CC $CFLAGS example/$f/*.c $LDFLAGS -o gen/bin/example-$f
elif [ $f = "jsonfindptrs" ]; then
echo "Building gen/bin/example-$f"
$CXX -O3 -std=c++17 example/$f/*.cc -o gen/bin/example-$f
echo "Building (C++) gen/bin/example-$f"
$CXX $CXXFLAGS -std=c++17 example/$f/*.cc $LDFLAGS -o gen/bin/example-$f
elif [ -e example/$f/*.cc ]; then
echo "Building gen/bin/example-$f"
$CXX -O3 example/$f/*.cc -o gen/bin/example-$f
echo "Building (C++) gen/bin/example-$f"
$CXX $CXXFLAGS example/$f/*.cc $LDFLAGS -o gen/bin/example-$f
fi
done
+18 -4
View File
@@ -17,29 +17,43 @@
# See build-all.sh for commentary.
if [ ! -e release/c/wuffs-unsupported-snapshot.c ]; then
if [ ! -e wuffs-root-directory.txt ]; then
echo "$0 should be run from the Wuffs root directory."
exit 1
fi
CC=${CC:-gcc}
CXX=${CXX:-g++}
LDFLAGS=${LDFLAGS:-}
# The "-fdata-sections -ffunction-sections -Wl,--gc-sections" produces smaller
# binaries. See commit 41fce8a8 "Strip examples of unused data and functions".
CFLAGS=${CFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
CXXFLAGS=${CXXFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
mkdir -p gen/bin
sources=$@
if [ $# -eq 0 ]; then
sources=fuzz/c/std/*_fuzzer.c
sources=fuzz/c/std/*_fuzzer.c*
fi
for f in $sources; do
f=${f%_fuzzer.c}
f=${f%_fuzzer.cc}
f=${f%/}
f=${f##*/}
if [ -z $f ]; then
continue
fi
echo "Building gen/bin/fuzz-$f"
$CC -DWUFFS_CONFIG__FUZZLIB_MAIN fuzz/c/std/${f}_fuzzer.c -o gen/bin/fuzz-$f
if [ -e fuzz/c/std/${f}_fuzzer.c ]; then
echo "Building (C) gen/bin/fuzz-$f"
$CC $CFLAGS -DWUFFS_CONFIG__FUZZLIB_MAIN fuzz/c/std/${f}_fuzzer.c \
$LDFLAGS -o gen/bin/fuzz-$f
elif [ -e fuzz/c/std/${f}_fuzzer.cc ]; then
echo "Building (C++) gen/bin/fuzz-$f"
$CXX $CXXFLAGS -DWUFFS_CONFIG__FUZZLIB_MAIN fuzz/c/std/${f}_fuzzer.cc \
$LDFLAGS -o gen/bin/fuzz-$f
fi
done
+3 -4
View File
@@ -61,7 +61,6 @@ import (
"flag"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"runtime"
@@ -146,9 +145,9 @@ func walk(filename string, info os.FileInfo, err error) error {
func do(r io.Reader, filename string) error {
src, err := []byte(nil), error(nil)
if r != nil {
src, err = ioutil.ReadAll(r)
src, err = io.ReadAll(r)
} else {
src, err = ioutil.ReadFile(filename)
src, err = os.ReadFile(filename)
}
if err != nil {
return err
@@ -180,7 +179,7 @@ func do(r io.Reader, filename string) error {
const chmodSupported = runtime.GOOS != "windows"
func writeFile(filename string, b []byte) error {
f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename))
f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))
if err != nil {
return err
}
+3 -3
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -24,7 +25,6 @@ import (
"bytes"
"fmt"
"go/format"
"io/ioutil"
"os"
)
@@ -36,7 +36,7 @@ func main() {
}
func main1() error {
src, err := ioutil.ReadFile("main.go")
src, err := os.ReadFile("main.go")
if err != nil {
return err
}
@@ -80,5 +80,5 @@ const usageStr = ` + "`")
if err != nil {
return err
}
return ioutil.WriteFile("data.go", formatted, 0644)
return os.WriteFile("data.go", formatted, 0644)
}
+3 -4
View File
@@ -251,7 +251,6 @@ import (
"flag"
"fmt"
"io"
"io/ioutil"
"os"
"runtime"
"strconv"
@@ -415,7 +414,7 @@ func decode(inFile *os.File) error {
// This seek-to-end error isn't fatal. The input might not actually be
// seekable, despite being an *os.File: "cat foo | ractool -decode".
// Instead, read all of the inFile into memory.
if inBytes, err := ioutil.ReadAll(inFile); err != nil {
if inBytes, err := io.ReadAll(inFile); err != nil {
return err
} else {
rs = bytes.NewReader(inBytes)
@@ -532,7 +531,7 @@ func encode(r io.Reader) error {
if *resourcesFlag != "" {
for _, filename := range strings.Split(*resourcesFlag, ",") {
resource, err := ioutil.ReadFile(filename)
resource, err := os.ReadFile(filename)
if err != nil {
return err
}
@@ -590,7 +589,7 @@ func makeTempFile() (io.ReadWriter, error) {
return &bytes.Buffer{}, nil
}
f, err := ioutil.TempFile(*tmpdirFlag, "ractool-")
f, err := os.CreateTemp(*tmpdirFlag, "ractool-")
if err != nil {
return nil, err
}
+24 -9
View File
@@ -18,13 +18,12 @@ import (
"bytes"
"flag"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"sort"
"strings"
"github.com/google/wuffs/internal/cgen/data"
"github.com/google/wuffs/internal/cgen"
cf "github.com/google/wuffs/cmd/commonflags"
)
@@ -83,7 +82,7 @@ func doGenrelease(args []string) error {
}
relFilename := filename[len(baseDirSlash):]
s, err := ioutil.ReadFile(filename)
s, err := os.ReadFile(filename)
if err != nil {
return err
}
@@ -108,10 +107,10 @@ func doGenrelease(args []string) error {
}
out.WriteString("#if defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
out.WriteString(data.AuxBaseHh)
out.WriteString(cgen.EmbeddedString_AuxBaseHh.Trim())
out.WriteString("\n")
for _, f := range data.AuxNonBaseHhFiles {
out.WriteString(f)
for _, f := range cgen.EmbeddedStrings_AuxNonBaseHhFiles {
out.WriteString(f.Trim())
out.WriteString("\n")
}
out.WriteString("#endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n")
@@ -127,10 +126,10 @@ func doGenrelease(args []string) error {
}
out.WriteString("#if defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
out.WriteString(data.AuxBaseCc)
out.WriteString(cgen.EmbeddedString_AuxBaseCc.Trim())
out.WriteString("\n")
for _, f := range data.AuxNonBaseCcFiles {
out.WriteString(f)
for _, f := range cgen.EmbeddedStrings_AuxNonBaseCcFiles {
out.WriteString(f.Trim())
out.WriteString("\n")
}
out.WriteString("#endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
@@ -167,8 +166,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 +179,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 +196,8 @@ const grPragmaPush = `
const grPragmaPop = `
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#endif
`
+1 -2
View File
@@ -18,7 +18,6 @@ import (
"bufio"
"flag"
"fmt"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
@@ -83,7 +82,7 @@ func doBenchTest(args []string, bench bool) error {
func doBenchTest1(filename string, bench bool, ccompilers string, focus string,
iterscale int, mimic bool, reps int) (failed bool, err error) {
workDir, err := ioutil.TempDir("", "wuffs-c")
workDir, err := os.MkdirTemp("", "wuffs-c")
if err != nil {
return false, err
}
+2 -3
View File
@@ -21,7 +21,6 @@ import (
"bytes"
"flag"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"sort"
@@ -142,14 +141,14 @@ func appendDir(dstQF []string, qualDirname string, suffix string, returnSubdirs
}
func writeFile(filename string, contents []byte) error {
if existing, err := ioutil.ReadFile(filename); err == nil && bytes.Equal(existing, contents) {
if existing, err := os.ReadFile(filename); err == nil && bytes.Equal(existing, contents) {
fmt.Println("gen unchanged: ", filename)
return nil
}
if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
return err
}
if err := ioutil.WriteFile(filename, contents, 0644); err != nil {
if err := os.WriteFile(filename, contents, 0644); err != nil {
return err
}
fmt.Println("gen wrote: ", filename)
+3 -4
View File
@@ -29,7 +29,6 @@ import (
"flag"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"runtime"
@@ -113,9 +112,9 @@ func walk(filename string, info os.FileInfo, err error) error {
func do(r io.Reader, filename string) error {
src, err := []byte(nil), error(nil)
if r != nil {
src, err = ioutil.ReadAll(r)
src, err = io.ReadAll(r)
} else {
src, err = ioutil.ReadFile(filename)
src, err = os.ReadFile(filename)
}
if err != nil {
return err
@@ -160,7 +159,7 @@ func do(r io.Reader, filename string) error {
const chmodSupported = runtime.GOOS != "windows"
func writeFile(filename string, b []byte) error {
f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename))
f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))
if err != nil {
return err
}
+1 -1
View File
@@ -20,10 +20,10 @@
- Added `example/json-to-cbor`.
- Added `example/jsonfindptrs`.
- Added `example/jsonptr`.
- Added `example/sdl-imageviewer`.
- Added `slice base.u8 peek/poke` methods.
- Added `std/bmp`.
- Added `std/cbor`.
- Added `std/gif.config_decoder`.
- Added `std/json`.
- Added `std/nie`.
- Added `std/png`.
+3 -3
View File
@@ -82,9 +82,9 @@ reserved for impure effects.
Expressions involving the standard arithmetic operators (e.g. `*`, `+`), will
not compile if overflow is possible. Some of these operators have alternative
'tilde' forms (e.g. `~mod*`, `~sat+`) which provide
[modular](/doc/glossary.md#modular-arithmetic.md) and
[saturating](/doc/glossary.md#saturating-arithmetic.md) arithmetic. By
definition, these never overflow.
[modular](/doc/glossary.md#modular-arithmetic) and
[saturating](/doc/glossary.md#saturating-arithmetic) arithmetic. By definition,
these never overflow.
The `as` operator, e.g. `x as T`, converts an expression `x` to the type `T`.
+11 -1
View File
@@ -46,6 +46,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -747,7 +757,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");
}
+25 -6
View File
@@ -39,6 +39,16 @@ https://skia-review.googlesource.com/c/skia/+/290618
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -54,6 +64,7 @@ https://skia-review.googlesource.com/c/skia/+/290618
#define WUFFS_CONFIG__MODULE__DEFLATE
#define WUFFS_CONFIG__MODULE__GIF
#define WUFFS_CONFIG__MODULE__LZW
#define WUFFS_CONFIG__MODULE__NIE
#define WUFFS_CONFIG__MODULE__PNG
#define WUFFS_CONFIG__MODULE__WBMP
#define WUFFS_CONFIG__MODULE__ZLIB
@@ -123,6 +134,7 @@ wuffs_base__image_decoder* g_image_decoder = NULL;
union {
wuffs_bmp__decoder bmp;
wuffs_gif__decoder gif;
wuffs_nie__decoder nie;
wuffs_png__decoder png;
wuffs_wbmp__decoder wbmp;
} g_potential_decoders;
@@ -266,6 +278,16 @@ initialize_image_decoder() {
&g_potential_decoders.gif);
return NULL;
case WUFFS_BASE__FOURCC__NIE:
status = wuffs_nie__decoder__initialize(
&g_potential_decoders.nie, sizeof g_potential_decoders.nie,
WUFFS_VERSION, WUFFS_INITIALIZE__DEFAULT_OPTIONS);
TRY(wuffs_base__status__message(&status));
g_image_decoder =
wuffs_nie__decoder__upcast_as__wuffs_base__image_decoder(
&g_potential_decoders.nie);
return NULL;
case WUFFS_BASE__FOURCC__PNG:
status = wuffs_png__decoder__initialize(
&g_potential_decoders.png, sizeof g_potential_decoders.png,
@@ -414,12 +436,10 @@ fill_rectangle(wuffs_base__rect_ie_u32 rect,
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(color);
wuffs_base__table_u8 tab = wuffs_base__pixel_buffer__plane(&g_pixbuf, 0);
uint32_t y;
for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {
for (uint32_t y = rect.min_incl_y; y < rect.max_excl_y; y++) {
uint8_t* p =
tab.ptr + (y * tab.stride) + (rect.min_incl_x * BYTES_PER_PIXEL);
uint32_t x;
for (x = rect.min_incl_x; x < rect.max_excl_x; x++) {
for (uint32_t x = rect.min_incl_x; x < rect.max_excl_x; x++) {
wuffs_base__poke_u32le__no_bounds_check(p, nonpremul);
p += BYTES_PER_PIXEL;
}
@@ -451,8 +471,7 @@ print_nie_frame() {
if (tab.width == tab.stride) {
ignore_return_value(write(STDOUT_FD, tab.ptr, tab.width * tab.height));
} else {
size_t y;
for (y = 0; y < tab.height; y++) {
for (size_t y = 0; y < tab.height; y++) {
ignore_return_value(
write(STDOUT_FD, tab.ptr + (y * tab.stride), tab.width));
break;
+18 -3
View File
@@ -42,12 +42,27 @@ for a C++ compiler $CXX, such as clang++ or g++.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but it
// demonstrates making all of Wuffs' functions have static storage. The
// motivation is discussed in the "ALLOW STATIC IMPLEMENTATION" section of
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
// formats. Without this macro definition, an optimizing compiler or linker may
// very well discard Wuffs code for unused codecs, but listing the Wuffs
// modules we use makes that process explicit. Preprocessing means that such
// code simply isn't compiled.
#define WUFFS_CONFIG__MODULES
#define WUFFS_CONFIG__MODULE__BASE
#define WUFFS_CONFIG__MODULE__CRC32
// If building this program in an environment that doesn't easily accommodate
// relative includes, you can use the script/inline-c-relative-includes.go
// program to generate a stand-alone C++ file.
+17 -14
View File
@@ -71,6 +71,16 @@ micros_since_start(struct timespec* now) {
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -205,11 +215,9 @@ restore_background(wuffs_base__pixel_buffer* pb,
wuffs_base__rect_ie_u32 bounds,
wuffs_base__color_u32_argb_premul background_color) {
size_t width4 = (size_t)(wuffs_base__pixel_config__width(&pb->pixcfg)) * 4;
size_t y;
for (y = bounds.min_incl_y; y < bounds.max_excl_y; y++) {
size_t x;
for (size_t y = bounds.min_incl_y; y < bounds.max_excl_y; y++) {
uint8_t* d = g_curr_dst_buffer + (y * width4) + (bounds.min_incl_x * 4);
for (x = bounds.min_incl_x; x < bounds.max_excl_x; x++) {
for (size_t x = bounds.min_incl_x; x < bounds.max_excl_x; x++) {
wuffs_base__poke_u32le__no_bounds_check(d, background_color);
d += sizeof(wuffs_base__color_u32_argb_premul);
}
@@ -224,10 +232,8 @@ print_ascii_art(wuffs_base__pixel_buffer* pb) {
uint8_t* d = g_curr_dst_buffer;
uint8_t* p = g_printbuf.ptr;
*p++ = '\n';
uint32_t y;
for (y = 0; y < height; y++) {
uint32_t x;
for (x = 0; x < width; x++) {
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
wuffs_base__color_u32_argb_premul c =
wuffs_base__peek_u32le__no_bounds_check(d);
d += sizeof(wuffs_base__color_u32_argb_premul);
@@ -255,10 +261,8 @@ print_color_art(wuffs_base__pixel_buffer* pb) {
uint8_t* p = g_printbuf.ptr;
*p++ = '\n';
p += sprintf((char*)p, "%s", g_reset_color);
uint32_t y;
for (y = 0; y < height; y++) {
uint32_t x;
for (x = 0; x < width; x++) {
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
wuffs_base__color_u32_argb_premul c =
wuffs_base__peek_u32le__no_bounds_check(d);
d += sizeof(wuffs_base__color_u32_argb_premul);
@@ -406,10 +410,9 @@ play() {
if (wuffs_base__frame_config__index(&fc) == 0) {
wuffs_base__color_u32_argb_premul background_color =
wuffs_base__frame_config__background_color(&fc);
size_t i;
size_t n = g_dst_len / sizeof(wuffs_base__color_u32_argb_premul);
uint8_t* p = g_curr_dst_buffer;
for (i = 0; i < n; i++) {
for (size_t i = 0; i < n; i++) {
wuffs_base__poke_u32le__no_bounds_check(p, background_color);
p += sizeof(wuffs_base__color_u32_argb_premul);
}
+338 -32
View File
@@ -18,7 +18,7 @@
imageviewer is a simple GUI program for viewing images. On Linux, GUI means
X11. To run:
$CXX imageviewer.cc -lxcb -lxcb-image && \
$CXX imageviewer.cc -lxcb -lxcb-image -lxcb-render -lxcb-render-util && \
./a.out ../../test/data/bricks-*.gif; rm -f a.out
for a C++ compiler $CXX, such as clang++ or g++.
@@ -29,10 +29,17 @@ stdin.
The Return key is equivalent to the Space key.
The ',' Comma and '.' Period keys cycle through background colors, which
matters if the image has fully or partially transparent pixels.
The '1' to '8' keys change the magnification zoom (or minification zoom with
the shift key). The '0' key toggles nearest neighbor and bilinear filtering.
The Escape key quits.
*/
#include <inttypes.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
@@ -44,6 +51,16 @@ The Escape key quits.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -71,10 +88,11 @@ The Escape key quits.
// program to generate a stand-alone C file.
#include "../../release/c/wuffs-unsupported-snapshot.c"
// X11 limits its image dimensions to uint16_t.
#define MAX_INCL_DIMENSION 65535
// X11 limits its image dimensions to uint16_t and some coordinates to int16_t.
#define MAX_INCL_DIMENSION 32767
#define NUM_BACKGROUND_COLORS 3
#define NUM_ZOOMS 8
#define SRC_BUFFER_ARRAY_SIZE (64 * 1024)
wuffs_base__color_u32_argb_premul g_background_colors[NUM_BACKGROUND_COLORS] = {
@@ -88,13 +106,128 @@ uint32_t g_height = 0;
wuffs_aux::MemOwner g_pixbuf_mem_owner(nullptr, &free);
wuffs_base__pixel_buffer g_pixbuf = {0};
uint32_t g_background_color_index = 0;
int32_t g_zoom = 0;
bool g_filter = false;
struct {
int remaining_argc;
char** remaining_argv;
double screen_gamma;
} g_flags = {0};
static const char* g_usage =
"Usage: imageviewer -flags input0.gif input1.png\n"
"\n"
"Flags:\n"
" -screen_gamma=N.N (default 2.2; 0 disables gamma correction)";
const char* //
parse_flags(int argc, char** argv) {
g_flags.screen_gamma = 2.2;
int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name.
for (; c < argc; c++) {
char* arg = argv[c];
if (*arg++ != '-') {
break;
}
// A double-dash "--foo" is equivalent to a single-dash "-foo". As special
// cases, a bare "-" is not a flag (some programs may interpret it as
// stdin) and a bare "--" means to stop parsing flags.
if (*arg == '\x00') {
break;
} else if (*arg == '-') {
arg++;
if (*arg == '\x00') {
c++;
break;
}
}
if (!strncmp(arg, "screen_gamma=", 13)) {
g_flags.screen_gamma = atof(arg + 13);
continue;
}
return g_usage;
}
g_flags.remaining_argc = argc - c;
g_flags.remaining_argv = argv + c;
return NULL;
}
class MyDecodeImageCallbacks : public wuffs_aux::DecodeImageCallbacks {
public:
MyDecodeImageCallbacks() : m_combined_gamma(1.0) {}
private:
std::string //
HandleMetadata(const wuffs_base__more_information& minfo,
wuffs_base__slice_u8 raw) override {
if (minfo.flavor == WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED) {
switch (minfo.metadata__fourcc()) {
case WUFFS_BASE__FOURCC__GAMA:
// metadata_parsed__gama returns the inverse gamma scaled by 1e5.
m_combined_gamma =
1e5 / (g_flags.screen_gamma * minfo.metadata_parsed__gama());
break;
}
}
return wuffs_aux::DecodeImageCallbacks::HandleMetadata(minfo, raw);
}
void //
Done(wuffs_aux::DecodeImageResult& result,
wuffs_aux::sync_io::Input& input,
wuffs_aux::IOBuffer& buffer,
wuffs_base__image_decoder::unique_ptr image_decoder) override {
// Apply basic color correction - gamma correction. Proper color correction
// should also involve considering any CHRM, ICCP and SRGB metadata but
// that requires a non-trivial amount of code (such as skcms, Skia's Color
// Management System). To keep this example program simple, we only
// consider GAMA metadata (and 8-bit color channels) here.
//
// This code also assumes that wuffs_aux::DecodeImageCallbacks defaults to
// producing a WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL pixel buffer.
if ((result.pixbuf.pixel_format().repr ==
WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) &&
((m_combined_gamma < 0.9999) || (1.0001 < m_combined_gamma))) {
uint8_t lut[256];
lut[0x00] = 0x00;
lut[0xFF] = 0xFF;
for (uint32_t i = 1; i < 0xFF; i++) {
lut[i] =
(uint8_t)(floor(255.0 * pow(i / 255.0, m_combined_gamma) + 0.5));
}
wuffs_base__table_u8 t = result.pixbuf.plane(0);
size_t w4 = t.width / 4;
for (size_t y = 0; y < t.height; y++) {
uint8_t* ptr = t.ptr + (y * t.stride);
for (size_t x = 0; x < w4; x++) {
ptr[0] = lut[ptr[0]];
ptr[1] = lut[ptr[1]];
ptr[2] = lut[ptr[2]];
ptr += 4;
}
}
}
}
// m_combined_gamma holds the product of the screen gamma and the image
// file's inverse gamma.
double m_combined_gamma;
};
bool //
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;
@@ -108,14 +241,22 @@ load_image(const char* filename) {
g_pixbuf_mem_owner.reset();
g_pixbuf = wuffs_base__null_pixel_buffer();
wuffs_aux::DecodeImageCallbacks callbacks;
uint64_t dia_flags = 0;
if (g_flags.screen_gamma > 0) {
dia_flags |= wuffs_aux::DecodeImageArgFlags::REPORT_METADATA_GAMA;
}
MyDecodeImageCallbacks callbacks;
wuffs_aux::sync_io::FileInput input(file);
wuffs_aux::DecodeImageResult res = wuffs_aux::DecodeImage(
callbacks, input,
callbacks, input, wuffs_aux::DecodeImageArgQuirks::DefaultValue(),
wuffs_aux::DecodeImageArgFlags(dia_flags),
// Use PIXEL_BLEND__SRC_OVER, not the default PIXEL_BLEND__SRC, because
// we also pass a background color.
WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
g_background_colors[g_background_color_index], MAX_INCL_DIMENSION);
wuffs_aux::DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC_OVER),
wuffs_aux::DecodeImageArgBackgroundColor(
g_background_colors[g_background_color_index]),
wuffs_aux::DecodeImageArgMaxInclDimension(MAX_INCL_DIMENSION));
if (filename) {
fclose(file);
}
@@ -158,18 +299,24 @@ load_image(const char* filename) {
#if defined(__linux__)
#define SUPPORTED_OPERATING_SYSTEM
#include <xcb/render.h>
#include <xcb/xcb.h>
#include <xcb/xcb_image.h>
#include <xcb/xcb_renderutil.h>
#define XK_BackSpace 0xFF08
#define XK_Escape 0xFF1B
#define XK_Return 0xFF0D
uint32_t g_maximum_request_length = 0; // Measured in 4-byte units.
xcb_atom_t g_atom_net_wm_name = XCB_NONE;
xcb_atom_t g_atom_utf8_string = XCB_NONE;
xcb_atom_t g_atom_wm_protocols = XCB_NONE;
xcb_atom_t g_atom_wm_delete_window = XCB_NONE;
xcb_pixmap_t g_pixmap = XCB_NONE;
xcb_gcontext_t g_pixmap_gc = XCB_NONE;
xcb_render_picture_t g_pixmap_picture = XCB_NONE;
xcb_render_pictforminfo_t* g_pictforminfo = NULL;
xcb_keysym_t* g_keysyms = NULL;
xcb_get_keyboard_mapping_reply_t* g_keyboard_mapping = NULL;
@@ -199,13 +346,71 @@ make_window(xcb_connection_t* c, xcb_screen_t* s) {
return w;
}
void //
apply_zoom_and_filter(xcb_connection_t* c) {
static const xcb_render_fixed_t neg_zooms[NUM_ZOOMS] = {
0x00010000, // 1/1 as 16.16 fixed point
0x00020000, // 2/1
0x00040000, // 4/1
0x00080000, // 8/1
0x00100000, // 16/1
0x00200000, // 32/1
0x00400000, // 64/1
0x00800000, // 128/1
};
static const xcb_render_fixed_t pos_zooms[NUM_ZOOMS] = {
0x00010000, // 1/1 as 16.16 fixed point
0x00008000, // 1/2
0x00004000, // 1/4
0x00002000, // 1/8
0x00001000, // 1/16
0x00000800, // 1/32
0x00000400, // 1/64
0x00000200, // 1/128
};
xcb_render_fixed_t z = g_zoom < 0
? neg_zooms[((uint32_t)(-g_zoom)) % NUM_ZOOMS]
: pos_zooms[((uint32_t)(+g_zoom)) % NUM_ZOOMS];
xcb_render_set_picture_transform(c, g_pixmap_picture,
((xcb_render_transform_t){
z, 0, 0, //
0, z, 0, //
0, 0, 0x10000, //
}));
uint16_t f_len = 7;
const char* f_ptr = "nearest";
if (g_filter && (g_zoom != 0)) {
f_len = 8;
f_ptr = "bilinear";
}
xcb_render_set_picture_filter(c, g_pixmap_picture, f_len, f_ptr, 0, NULL);
}
// zoom_shift returns (a << g_zoom), roughly speaking, but saturates at an
// arbitrary value called M.
//
// The final two arguments to xcb_render_composite have uint16_t type (and
// UINT16_MAX is 65535), but in practice, values above M sometimes don't work
// in that the xcb_render_composite call has no visible effect.
//
// Some xrender debugging could potentially derive a more accurate maximum but
// for now, the M = 30000 round number will do.
uint16_t //
zoom_shift(uint32_t a) {
uint16_t M = 30000;
uint64_t b = g_zoom < 0
? (((uint64_t)a) >> (((uint32_t)(-g_zoom)) % NUM_ZOOMS))
: (((uint64_t)a) << (((uint32_t)(+g_zoom)) % NUM_ZOOMS));
return (b < M) ? b : M;
}
bool //
load(xcb_connection_t* c,
xcb_screen_t* s,
xcb_window_t w,
xcb_gcontext_t g,
const char* filename) {
load(xcb_connection_t* c, xcb_window_t w, const char* filename) {
if (g_pixmap != XCB_NONE) {
xcb_render_free_picture(c, g_pixmap_picture);
xcb_free_gc(c, g_pixmap_gc);
xcb_free_pixmap(c, g_pixmap);
}
@@ -214,21 +419,83 @@ load(xcb_connection_t* c,
}
wuffs_base__table_u8 tab = g_pixbuf.plane(0);
xcb_create_pixmap(c, s->root_depth, g_pixmap, w, g_width, g_height);
xcb_image_t* image = xcb_image_create_native(
c, g_width, g_height, XCB_IMAGE_FORMAT_Z_PIXMAP, s->root_depth, NULL,
tab.height * tab.stride, tab.ptr);
xcb_image_put(c, g_pixmap, g, image, 0, 0, 0);
xcb_image_destroy(image);
xcb_create_pixmap(c, g_pictforminfo->depth, g_pixmap, w, g_width, g_height);
xcb_create_gc(c, g_pixmap_gc, g_pixmap, 0, NULL);
xcb_render_create_picture(c, g_pixmap_picture, g_pixmap, g_pictforminfo->id,
0, NULL);
apply_zoom_and_filter(c);
// Copy the pixels from the X11 client process (this process) to the X11
// server process. For large images, this may involve multiple xcb_image_put
// calls, each copying part of the pixels (a strip that has the same width
// but smaller height), to avoid XCB_CONN_CLOSED_REQ_LEN_EXCEED.
if (g_width > 0) {
uint32_t max_strip_height = g_maximum_request_length / g_width;
for (uint32_t y = 0; y < g_height;) {
uint32_t h = g_height - y;
if (h > max_strip_height) {
h = max_strip_height;
}
// Make libxcb-image interpret WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL as
// XCB_PICT_STANDARD_ARGB_32 with byte_order XCB_IMAGE_ORDER_LSB_FIRST.
xcb_image_t* unconverted =
xcb_image_create(g_width, // width
h, // height
XCB_IMAGE_FORMAT_Z_PIXMAP, // format
32, // xpad
g_pictforminfo->depth, // depth
32, // bpp
32, // unit
XCB_IMAGE_ORDER_LSB_FIRST, // byte_order
XCB_IMAGE_ORDER_MSB_FIRST, // bit_order
NULL, // base
h * tab.stride, // bytes
tab.ptr + (y * tab.stride)); // data
xcb_image_t* converted =
xcb_image_native(c, unconverted, true); // true means to convert.
if (converted != unconverted) {
xcb_image_destroy(unconverted);
}
xcb_image_put(c, g_pixmap, g_pixmap_gc, converted, 0, y, 0);
xcb_image_destroy(converted);
y += h;
}
}
return true;
}
int //
main(int argc, char** argv) {
const char* status = parse_flags(argc, argv);
if (status) {
fprintf(stderr, "%s\n", status);
return 1;
}
xcb_connection_t* c = xcb_connect(NULL, NULL);
g_maximum_request_length = xcb_get_maximum_request_length(c);
// Our X11 requests (especially xcb_image_put) also need a header, in terms
// of wire format. 256 4-byte units should be big enough.
const uint32_t max_req_len_adjustment = 256;
if (g_maximum_request_length < max_req_len_adjustment) {
printf("XCB failure (maximum request length is too short)\n");
exit(EXIT_FAILURE);
}
g_maximum_request_length -= max_req_len_adjustment;
const xcb_setup_t* z = xcb_get_setup(c);
xcb_screen_t* s = xcb_setup_roots_iterator(z).data;
const xcb_render_query_pict_formats_reply_t* pict_formats =
xcb_render_util_query_formats(c);
g_pictforminfo = xcb_render_util_find_standard_format(
pict_formats, XCB_PICT_STANDARD_ARGB_32);
{
xcb_intern_atom_cookie_t cookie0 =
xcb_intern_atom(c, 1, 12, "_NET_WM_NAME");
@@ -252,24 +519,37 @@ main(int argc, char** argv) {
}
xcb_window_t w = make_window(c, s);
xcb_gcontext_t g = xcb_generate_id(c);
xcb_create_gc(c, g, w, 0, NULL);
xcb_render_picture_t p = xcb_generate_id(c);
xcb_render_create_picture(
c, p, w,
xcb_render_util_find_visual_format(pict_formats, s->root_visual)->format,
0, NULL);
init_keymap(c, z);
xcb_flush(c);
g_pixmap = xcb_generate_id(c);
bool loaded = load(c, s, w, g, (argc > 1) ? argv[1] : NULL);
int arg = 1;
g_pixmap = xcb_generate_id(c);
g_pixmap_gc = xcb_generate_id(c);
g_pixmap_picture = xcb_generate_id(c);
bool loaded = load(
c, w, (g_flags.remaining_argc > 0) ? g_flags.remaining_argv[0] : NULL);
int arg = 0;
while (true) {
xcb_generic_event_t* event = xcb_wait_for_event(c);
bool reload = false;
if (!event) {
printf("XCB failure (error code %d)\n", xcb_connection_has_error(c));
exit(EXIT_FAILURE);
}
bool reload = false;
switch (event->response_type & 0x7F) {
case XCB_EXPOSE: {
xcb_expose_event_t* e = (xcb_expose_event_t*)event;
if (loaded && (e->count == 0)) {
xcb_copy_area(c, g_pixmap, w, g, 0, 0, 0, 0, g_width, g_height);
xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, g_pixmap_picture,
XCB_NONE, p, 0, 0, 0, 0, 0, 0,
zoom_shift(g_width), zoom_shift(g_height));
xcb_flush(c);
}
break;
@@ -288,14 +568,14 @@ main(int argc, char** argv) {
case ' ':
case XK_BackSpace:
case XK_Return:
if (argc <= 2) {
if (g_flags.remaining_argc <= 1) {
break;
}
arg += (i != XK_BackSpace) ? +1 : -1;
if (arg == 0) {
arg = argc - 1;
} else if (arg == argc) {
arg = 1;
if (arg < 0) {
arg = g_flags.remaining_argc - 1;
} else if (arg == g_flags.remaining_argc) {
arg = 0;
}
reload = true;
break;
@@ -307,6 +587,32 @@ main(int argc, char** argv) {
g_background_color_index %= NUM_BACKGROUND_COLORS;
reload = true;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
if (i == '0') {
g_filter = !g_filter;
} else {
int32_t z = i - '1';
if (e->state & XCB_MOD_MASK_SHIFT) {
z = -z;
}
if (g_zoom == z) {
break;
}
g_zoom = z;
}
apply_zoom_and_filter(c);
xcb_clear_area(c, 1, w, 0, 0, 0xFFFF, 0xFFFF);
xcb_flush(c);
break;
}
}
break;
@@ -324,7 +630,7 @@ main(int argc, char** argv) {
free(event);
if (reload) {
loaded = load(c, s, w, g, argv[arg]);
loaded = load(c, w, g_flags.remaining_argv[arg]);
xcb_clear_area(c, 1, w, 0, 0, 0xFFFF, 0xFFFF);
xcb_flush(c);
}
+12 -2
View File
@@ -46,6 +46,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -339,7 +349,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");
}
@@ -349,7 +359,7 @@ main1(int argc, char** argv) {
wuffs_aux::sync_io::FileInput input(in);
return wuffs_aux::DecodeJson(
callbacks, input,
wuffs_base__make_slice_u32(g_quirks.data(), g_quirks.size()))
wuffs_aux::DecodeJsonArgQuirks(g_quirks.data(), g_quirks.size()))
.error_message;
}
+14 -3
View File
@@ -78,6 +78,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -548,7 +558,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");
}
@@ -558,8 +568,9 @@ main1(int argc, char** argv) {
wuffs_aux::sync_io::FileInput input(in);
return wuffs_aux::DecodeJson(
callbacks, input,
wuffs_base__make_slice_u32(g_quirks.data(), g_quirks.size()),
(g_flags.query_c_string ? g_flags.query_c_string : ""))
wuffs_aux::DecodeJsonArgQuirks(g_quirks.data(), g_quirks.size()),
wuffs_aux::DecodeJsonArgJsonPointer(
g_flags.query_c_string ? g_flags.query_c_string : ""))
.error_message;
}
+24 -33
View File
@@ -114,6 +114,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -1074,7 +1084,7 @@ write_dst(const void* s, size_t n) {
return write_dst_slow(s, n);
}
#define TRY_INDENT_WITH_LEADING_NEW_LINE \
#define TRY_INDENT \
do { \
uint32_t adj = (g_num_input_blank_lines > 1) ? 1 : 0; \
g_num_input_blank_lines = 0; \
@@ -1086,20 +1096,6 @@ write_dst(const void* s, size_t n) {
} \
} while (false)
// TRY_INDENT_SANS_LEADING_NEW_LINE is used after comments, which print their
// own "\n".
#define TRY_INDENT_SANS_LEADING_NEW_LINE \
do { \
uint32_t adj = (g_num_input_blank_lines > 1) ? 1 : 0; \
g_num_input_blank_lines = 0; \
uint32_t indent = g_depth * g_bytes_per_indent_depth; \
TRY(write_dst(g_two_new_lines_then_256_indent_bytes + 2 - adj, \
adj + (indent & 0xFF))); \
for (indent >>= 8; indent > 0; indent--) { \
TRY(write_dst(g_two_new_lines_then_256_indent_bytes + 2, 0x100)); \
} \
} while (false)
// ----
const char* //
@@ -1155,12 +1151,12 @@ handle_token(wuffs_base__token t, bool start_of_token_chain) {
(g_ctx != context::in_dict_after_brace) &&
!g_flags.compact_output) {
if (g_is_after_comment) {
TRY_INDENT_SANS_LEADING_NEW_LINE;
TRY_INDENT;
} else {
if (g_flags.output_extra_comma) {
TRY(write_dst(",", 1));
}
TRY_INDENT_WITH_LEADING_NEW_LINE;
TRY_INDENT;
}
} else {
g_num_input_blank_lines = 0;
@@ -1181,7 +1177,7 @@ handle_token(wuffs_base__token t, bool start_of_token_chain) {
// continuation of a multi-token chain.
if (start_of_token_chain) {
if (g_is_after_comment) {
TRY_INDENT_SANS_LEADING_NEW_LINE;
TRY_INDENT;
} else if (g_ctx == context::in_dict_after_key) {
TRY(write_dst(": ", g_flags.compact_output ? 1 : 2));
} else if (g_ctx != context::none) {
@@ -1190,7 +1186,7 @@ handle_token(wuffs_base__token t, bool start_of_token_chain) {
TRY(write_dst(",", 1));
}
if (!g_flags.compact_output) {
TRY_INDENT_WITH_LEADING_NEW_LINE;
TRY_INDENT;
}
}
@@ -1336,11 +1332,16 @@ main1(int argc, char** argv) {
if (g_flags.compact_output) {
TRY(write_dst(g_src.data.ptr + g_cursor_index - token_length,
token_length));
if (!t.continued() &&
(t.value_base_detail() &
WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE)) {
TRY(write_dst("\n", 1));
}
} else {
if (start_of_token_chain) {
if (g_is_after_comment) {
TRY_INDENT_SANS_LEADING_NEW_LINE;
TRY_INDENT;
} else if (g_ctx != context::none) {
if (g_ctx == context::in_dict_after_key) {
TRY(write_dst(":", 1));
@@ -1349,16 +1350,11 @@ main1(int argc, char** argv) {
(g_ctx != context::end_of_data)) {
TRY(write_dst(",", 1));
}
TRY_INDENT_WITH_LEADING_NEW_LINE;
TRY_INDENT;
}
}
TRY(write_dst(g_src.data.ptr + g_cursor_index - token_length,
token_length));
if (!t.continued() &&
(t.value_base_detail() &
WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK)) {
TRY(write_dst("\n", 1));
}
g_is_after_comment = true;
}
if (g_ctx == context::in_list_after_bracket) {
@@ -1366,11 +1362,7 @@ main1(int argc, char** argv) {
} else if (g_ctx == context::in_dict_after_brace) {
g_ctx = context::in_dict_after_value;
}
g_num_input_blank_lines =
(t.value_base_detail() &
WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE)
? 1
: 0;
g_num_input_blank_lines = 0;
} else {
uint8_t* p = g_src.data.ptr + g_cursor_index - token_length;
@@ -1468,8 +1460,7 @@ main(int argc, char** argv) {
// Flags start with "-", unless it comes after a bare "--" arg.
{
bool dash_dash = false;
int a;
for (a = 1; a < argc; a++) {
for (int a = 1; a < argc; a++) {
char* arg = argv[a];
if ((arg[0] == '-') && !dash_dash) {
dash_dash = (arg[1] == '-') && (arg[2] == '\x00');
@@ -51,6 +51,16 @@ isn't otherwise doing anything.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -80,6 +90,7 @@ isn't otherwise doing anything.
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_render.h>
// --------
@@ -229,6 +240,28 @@ bool g_load_via_sdl_image = false;
bool //
draw(SDL_Window* window) {
SDL_Surface* ws = SDL_GetWindowSurface(window);
if (!ws) {
// Use an indirect approach, for exotic window pixel formats (e.g. X.org 10
// bits per RGB channel), when we can't get the window surface directly.
//
// See https://github.com/google/wuffs/issues/51
SDL_Renderer* r = SDL_CreateRenderer(window, -1, 0);
if (!r) {
fprintf(stderr, "main: SDL_CreateRenderer: %s\n", SDL_GetError());
return false;
}
SDL_RenderClear(r);
if (g_image) {
SDL_Texture* texture = SDL_CreateTextureFromSurface(r, g_image);
SDL_RenderCopy(r, texture, NULL, &g_image->clip_rect);
SDL_DestroyTexture(texture);
}
SDL_RenderPresent(r);
SDL_DestroyRenderer(r);
return true;
}
// Use a direct approach.
SDL_FillRect(ws, NULL, SDL_MapRGB(ws->format, 0x00, 0x00, 0x00));
if (g_image) {
SDL_BlitSurface(g_image, NULL, ws, NULL);
+10
View File
@@ -35,6 +35,16 @@ for a C compiler $CC, such as clang or gcc.
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
+1 -2
View File
@@ -337,8 +337,7 @@ main(int argc, char** argv) {
fprintf(stderr, "FAIL: %s\n", z);
return 1;
}
int i;
for (i = 0; i < g_flags.remaining_argc; i++) {
for (int i = 0; i < g_flags.remaining_argc; i++) {
int v = visit(g_flags.remaining_argv[i]);
if (v) {
return v;
+13 -1
View File
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
// compiling it.
#define WUFFS_IMPLEMENTATION
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -66,7 +78,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);
}
+27 -13
View File
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
// compiling it.
#define WUFFS_IMPLEMENTATION
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -221,12 +233,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 +250,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);
// ----
@@ -261,8 +274,9 @@ fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash_56_bits) {
wuffs_base__token_buffer tok = ((wuffs_base__token_buffer){
.data = ((wuffs_base__slice_token){
.ptr = tok_array,
.len = (tok_limit < TOK_BUFFER_ARRAY_SIZE) ? tok_limit
: TOK_BUFFER_ARRAY_SIZE,
.len = (size_t)((tok_limit < TOK_BUFFER_ARRAY_SIZE)
? tok_limit
: TOK_BUFFER_ARRAY_SIZE),
}),
});
@@ -407,7 +421,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);
}
+19 -8
View File
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
// compiling it.
#define WUFFS_IMPLEMENTATION
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -61,7 +73,7 @@ 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_55_bits) {
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,
@@ -73,10 +85,9 @@ void set_quirks(wuffs_gif__decoder* dec, uint64_t hash_55_bits) {
0,
};
uint32_t i;
for (i = 0; quirks[i]; i++) {
uint64_t bit = 1 << (i % 55);
if (hash_55_bits & bit) {
for (uint32_t i = 0; quirks[i]; i++) {
uint64_t bit = 1 << (i & 63);
if (hash & bit) {
wuffs_gif__decoder__set_quirk_enabled(dec, quirks[i], true);
}
}
@@ -88,13 +99,13 @@ fuzz(wuffs_base__io_buffer* src, uint64_t hash) {
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;
uint64_t hash_55_bits = hash >> 8;
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_55_bits);
set_quirks(&dec, hash);
return fuzz_image_decoder(
src, hash_8_bits,
wuffs_gif__decoder__upcast_as__wuffs_base__image_decoder(&dec));
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
// compiling it.
#define WUFFS_IMPLEMENTATION
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -50,6 +62,8 @@ It should print "PASS", amongst other information, and exit(0).
// modules we use makes that process explicit. Preprocessing means that such
// code simply isn't compiled.
#define WUFFS_CONFIG__MODULES
#define WUFFS_CONFIG__MODULE__AUX__BASE
#define WUFFS_CONFIG__MODULE__AUX__JSON
#define WUFFS_CONFIG__MODULE__BASE
#define WUFFS_CONFIG__MODULE__JSON
@@ -209,12 +223,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,47 +239,46 @@ 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) {
uint32_t quirks[] = {
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO,
WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK,
WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE,
WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA,
WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS,
WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR,
WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK,
WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER,
WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE,
0,
};
uint32_t g_quirks[] = {
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS,
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO,
WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK,
WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE,
WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA,
WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS,
WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR,
WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK,
WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER,
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T,
WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE,
0,
};
uint32_t i;
for (i = 0; quirks[i]; i++) {
uint64_t bit = 1 << (i % 44);
if (hash_44_bits & bit) {
wuffs_json__decoder__set_quirk_enabled(dec, quirks[i], true);
void set_quirks(wuffs_json__decoder* dec, uint64_t hash) {
for (uint32_t i = 0; g_quirks[i]; i++) {
uint64_t bit = 1 << (i & 63);
if (hash & bit) {
wuffs_json__decoder__set_quirk_enabled(dec, g_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,14 +289,15 @@ 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){
.data = ((wuffs_base__slice_token){
.ptr = tok_array,
.len = (tok_limit < TOK_BUFFER_ARRAY_SIZE) ? tok_limit
: TOK_BUFFER_ARRAY_SIZE,
.len = (size_t)((tok_limit < TOK_BUFFER_ARRAY_SIZE)
? tok_limit
: TOK_BUFFER_ARRAY_SIZE),
}),
});
@@ -413,8 +428,104 @@ fuzz_simple(wuffs_base__io_buffer* full_src) {
return NULL;
}
#if defined(__cplusplus)
#include <vector>
class Callbacks : public wuffs_aux::DecodeJsonCallbacks {
public:
Callbacks() : m_depth(0) {}
std::string AppendNull() override { return ""; }
std::string AppendBool(bool val) override { return ""; }
std::string AppendI64(int64_t val) override { return ""; }
std::string AppendF64(double val) override { return ""; }
std::string AppendTextString(std::string&& val) override { return ""; }
std::string Push(uint32_t flags) override {
m_depth++;
return "";
}
std::string Pop(uint32_t flags) override {
m_depth--;
if (m_depth < 0) {
fprintf(stderr, "negative depth\n");
intentional_segfault();
}
return "";
}
void Done(wuffs_aux::DecodeJsonResult& result,
wuffs_aux::sync_io::Input& input,
wuffs_aux::IOBuffer& buffer) override {
if (result.error_message.empty()) {
if (m_depth != 0) {
fprintf(stderr, "no error message but final depth is non-zero\n");
intentional_segfault();
}
} else if (result.error_message.find("internal error:") !=
std::string::npos) {
fprintf(stderr, "internal errors shouldn't occur: \"%s\"\n",
result.error_message.c_str());
intentional_segfault();
}
}
private:
int64_t m_depth;
};
void //
fuzz_cpp(const uint8_t* in_ptr, size_t in_len, uint64_t hash) {
static const char* json_pointers[16] = {
"", //
"", //
"", //
"", //
"", //
"", //
"", //
"", //
"", //
"", //
"/", //
"/2/3/4/5", //
"/k0", //
"/k0/1", //
"/x/y", //
"/~0/~1/~n", //
};
const char* json_pointer = json_pointers[hash & 15];
hash = wuffs_base__u64__rotate_right(hash, 4);
std::vector<uint32_t> quirks;
for (uint32_t i = 0; g_quirks[i]; i++) {
uint64_t bit = 1 << (i & 63);
if (hash & bit) {
quirks.push_back(g_quirks[i]);
}
}
Callbacks callbacks;
wuffs_aux::sync_io::MemoryInput input(in_ptr, in_len);
wuffs_aux::DecodeJson(
callbacks, input,
wuffs_aux::DecodeJsonArgQuirks(quirks.data(), quirks.size()),
wuffs_aux::DecodeJsonArgJsonPointer(json_pointer));
}
#endif // defined(__cplusplus)
const char* //
fuzz(wuffs_base__io_buffer* full_src, uint64_t hash) {
#if defined(__cplusplus)
fuzz_cpp(full_src->reader_pointer(), full_src->reader_length(),
wuffs_base__u64__rotate_right(hash, 32));
#endif // defined(__cplusplus)
// Send 99.6% of inputs to fuzz_complex and the remainder to fuzz_simple. The
// 0xA5 constant is arbitrary but non-zero. If the hash function maps the
// empty input to 0, this still sends the empty input to fuzz_complex.
@@ -427,7 +538,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);
}
+12
View File
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
// compiling it.
#define WUFFS_IMPLEMENTATION
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
+13 -1
View File
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
// compiling it.
#define WUFFS_IMPLEMENTATION
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -70,7 +82,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);
}
+12
View File
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
// compiling it.
#define WUFFS_IMPLEMENTATION
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
+3 -4
View File
@@ -1,9 +1,8 @@
module github.com/google/wuffs
go 1.13
go 1.16
require (
github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
golang.org/x/image v0.0.0-20200119044424-58c23975cae1 // indirect
gopkg.in/russross/blackfriday.v2 v2.0.0 // indirect
github.com/russross/blackfriday/v2 v2.1.0 // indirect
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d // indirect
)
+6 -7
View File
@@ -1,7 +1,6 @@
github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
golang.org/x/image v0.0.0-20200119044424-58c23975cae1 h1:5h3ngYt7+vXCDZCup/HkCQgW5XwmSvR/nA2JmJ0RErg=
golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
gopkg.in/russross/blackfriday.v2 v2.0.0 h1:+FlnIV8DSQnT7NZ43hcVKcdJdzZoeCmJj4Ql8gq5keA=
gopkg.in/russross/blackfriday.v2 v2.0.0/go.mod h1:6sSBNz/GtOm/pJTuh5UmBK2ZHfmnxGbl2NZg1UliSOI=
github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d h1:RNPAfi2nHY7C2srAV8A49jpsYr0ADedCk1wq6fTMTvs=
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+7
View File
@@ -1 +1,8 @@
# C++ Auxiliary Code
This directory contains C++ [Auxiliary code](/doc/note/auxiliary-code.md).
After editing source code in this directory, see the [sibling `base`
directory's README.md](/internal/cgen/base/README.md#making-changes) file for
instructions on how to see those changes when generating the C/C++ form of
Wuffs code.
+223 -2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,6 +25,71 @@ namespace sync_io {
// --------
DynIOBuffer::DynIOBuffer(uint64_t max_incl)
: m_buf(wuffs_base__empty_io_buffer()), m_max_incl(max_incl) {}
DynIOBuffer::~DynIOBuffer() {
if (m_buf.data.ptr) {
free(m_buf.data.ptr);
}
}
void //
DynIOBuffer::drop() {
if (m_buf.data.ptr) {
free(m_buf.data.ptr);
}
m_buf = wuffs_base__empty_io_buffer();
}
DynIOBuffer::GrowResult //
DynIOBuffer::grow(uint64_t min_incl) {
uint64_t n = round_up(min_incl, m_max_incl);
if (n == 0) {
return ((min_incl == 0) && (m_max_incl == 0))
? DynIOBuffer::GrowResult::OK
: DynIOBuffer::GrowResult::FailedMaxInclExceeded;
} else if (n > m_buf.data.len) {
uint8_t* ptr = static_cast<uint8_t*>(realloc(m_buf.data.ptr, n));
if (!ptr) {
return DynIOBuffer::GrowResult::FailedOutOfMemory;
}
m_buf.data.ptr = ptr;
m_buf.data.len = n;
}
return DynIOBuffer::GrowResult::OK;
}
// round_up rounds min_incl up, returning the smallest value x satisfying
// (min_incl <= x) and (x <= max_incl) and some other constraints. It returns 0
// if there is no such x.
//
// When max_incl <= 4096, the other constraints are:
// - (x == max_incl)
//
// When max_incl > 4096, the other constraints are:
// - (x == max_incl) or (x is a power of 2)
// - (x >= 4096)
uint64_t //
DynIOBuffer::round_up(uint64_t min_incl, uint64_t max_incl) {
if (min_incl > max_incl) {
return 0;
}
uint64_t n = 4096;
if (n >= max_incl) {
return max_incl;
}
while (n < min_incl) {
if (n >= (max_incl / 2)) {
return max_incl;
}
n *= 2;
}
return n;
}
// --------
Input::~Input() {}
IOBuffer* //
@@ -101,6 +164,164 @@ MemoryInput::CopyIn(IOBuffer* dst) {
} // namespace sync_io
namespace private_impl {
struct ErrorMessages {
const char* max_incl_metadata_length_exceeded;
const char* out_of_memory;
const char* unexpected_end_of_file;
const char* unsupported_metadata;
const char* unsupported_negative_advance;
// If adding new "const char*" typed fields to this struct, either add them
// after existing fields or, if re-ordering fields, make sure that you update
// all of the "const private_impl::ErrorMessages FooBarErrorMessages" values
// in all of the sibling *.cc files.
static inline const char* resolve(const char* s) {
return s ? s : "wuffs_aux::private_impl: unknown error";
};
};
std::string //
AdvanceIOBufferTo(const ErrorMessages& error_messages,
sync_io::Input& input,
IOBuffer& io_buf,
uint64_t absolute_position) {
if (absolute_position < io_buf.reader_position()) {
return error_messages.resolve(error_messages.unsupported_negative_advance);
}
while (true) {
uint64_t relative_position = absolute_position - io_buf.reader_position();
if (relative_position <= io_buf.reader_length()) {
io_buf.meta.ri += (size_t)relative_position;
break;
} else if (io_buf.meta.closed) {
return error_messages.resolve(error_messages.unexpected_end_of_file);
}
io_buf.meta.ri = io_buf.meta.wi;
if (!input.BringsItsOwnIOBuffer()) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
return "";
}
std::string //
HandleMetadata(
const ErrorMessages& error_messages,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
sync_io::DynIOBuffer& raw,
wuffs_base__status (*tell_me_more_func)(void*,
wuffs_base__io_buffer*,
wuffs_base__more_information*,
wuffs_base__io_buffer*),
void* tell_me_more_receiver,
std::string (*handle_metadata_func)(void*,
const wuffs_base__more_information*,
wuffs_base__slice_u8),
void* handle_metadata_receiver) {
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
// Reset raw but keep its backing array (the raw.m_buf.data slice).
raw.m_buf.meta = wuffs_base__empty_io_buffer_meta();
while (true) {
minfo = wuffs_base__empty_more_information();
wuffs_base__status status = (*tell_me_more_func)(
tell_me_more_receiver, &raw.m_buf, &minfo, &io_buf);
switch (minfo.flavor) {
case 0:
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM:
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED:
break;
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH: {
wuffs_base__range_ie_u64 r = minfo.metadata_raw_passthrough__range();
if (r.is_empty()) {
break;
}
uint64_t num_to_copy = r.length();
if (num_to_copy > (raw.m_max_incl - raw.m_buf.meta.wi)) {
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
} else if (num_to_copy > (raw.m_buf.data.len - raw.m_buf.meta.wi)) {
switch (raw.grow(num_to_copy + raw.m_buf.meta.wi)) {
case sync_io::DynIOBuffer::GrowResult::OK:
break;
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
return error_messages.resolve(error_messages.out_of_memory);
}
}
if (io_buf.reader_position() > r.min_incl) {
return error_messages.resolve(error_messages.unsupported_metadata);
} else {
std::string error_message =
AdvanceIOBufferTo(error_messages, input, io_buf, r.min_incl);
if (!error_message.empty()) {
return error_message;
}
}
while (true) {
uint64_t n =
wuffs_base__u64__min(num_to_copy, io_buf.reader_length());
memcpy(raw.m_buf.writer_pointer(), io_buf.reader_pointer(), n);
raw.m_buf.meta.wi += n;
io_buf.meta.ri += n;
num_to_copy -= n;
if (num_to_copy == 0) {
break;
} else if (io_buf.meta.closed) {
return error_messages.resolve(
error_messages.unexpected_end_of_file);
} else if (!input.BringsItsOwnIOBuffer()) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
break;
}
default:
return error_messages.resolve(error_messages.unsupported_metadata);
}
if (status.repr == nullptr) {
break;
} else if (status.repr != wuffs_base__suspension__even_more_information) {
if (status.repr != wuffs_base__suspension__short_write) {
return status.message();
}
switch (raw.grow(wuffs_base__u64__sat_add(raw.m_buf.data.len, 1))) {
case sync_io::DynIOBuffer::GrowResult::OK:
break;
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
return error_messages.resolve(error_messages.out_of_memory);
}
}
}
return (*handle_metadata_func)(handle_metadata_receiver, &minfo,
raw.m_buf.reader_slice());
}
} // namespace private_impl
} // namespace wuffs_aux
#endif // !defined(WUFFS_CONFIG__MODULES) ||
+57 -2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -38,6 +36,63 @@ namespace sync_io {
// --------
// DynIOBuffer is an IOBuffer that is backed by a dynamically sized byte array.
// It owns that backing array and will free it in its destructor.
//
// The array size can be explicitly extended (by calling the grow method) but,
// unlike a C++ std::vector, there is no implicit extension (e.g. by calling
// std::vector::insert) and its maximum size is capped by the max_incl
// constructor argument.
//
// It contains an IOBuffer-typed field whose reader side provides access to
// previously written bytes and whose writer side provides access to the
// allocated but not-yet-written-to slack space. For Go programmers, this slack
// space is roughly analogous to the s[len(s):cap(s)] space of a slice s.
class DynIOBuffer {
public:
enum GrowResult {
OK = 0,
FailedMaxInclExceeded = 1,
FailedOutOfMemory = 2,
};
// m_buf holds the dynamically sized byte array and its read/write indexes:
// - m_buf.meta.wi is roughly analogous to a Go slice's length.
// - m_buf.data.len is roughly analogous to a Go slice's capacity. It is
// also equal to the m_buf.data.ptr malloc/realloc size.
//
// Users should not modify the m_buf.data.ptr or m_buf.data.len fields (as
// they are conceptually private to this class), but they can modify the
// bytes referenced by that pointer-length pair (e.g. compactions).
IOBuffer m_buf;
// m_max_incl is an inclusive upper bound on the backing array size.
const uint64_t m_max_incl;
// Constructor and destructor.
explicit DynIOBuffer(uint64_t max_incl);
~DynIOBuffer();
// Drop frees the byte array and resets m_buf. The DynIOBuffer can still be
// used after a drop call. It just restarts from zero.
void drop();
// grow ensures that the byte array size is at least min_incl and at most
// max_incl. It returns FailedMaxInclExceeded if that would require
// allocating more than max_incl bytes, including the case where (min_incl >
// max_incl). It returns FailedOutOfMemory if memory allocation failed.
GrowResult grow(uint64_t min_incl);
private:
// Delete the copy and assign constructors.
DynIOBuffer(const DynIOBuffer&) = delete;
DynIOBuffer& operator=(const DynIOBuffer&) = delete;
static uint64_t round_up(uint64_t min_incl, uint64_t max_incl);
};
// --------
class Input {
public:
virtual ~Input();
+41 -14
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -34,10 +32,21 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeCborArgQuirks //
DecodeCborArgQuirks::DefaultValue() {
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks) {
DecodeCborArgQuirks quirks) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
@@ -57,11 +66,11 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
// Prepare the low-level CBOR decoder.
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
if (!dec) {
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
goto done;
}
for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
for (size_t i = 0; i < quirks.repr.len; i++) {
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
}
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
@@ -72,7 +81,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
// Prepare other state.
uint32_t depth = 0;
int32_t depth = 0;
std::string str;
int64_t extension_category = 0;
uint64_t extension_detail = 0;
@@ -99,17 +108,17 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
goto done;
} else if (cursor_index != io_buf->meta.ri) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
"wuffs_aux::DecodeCbor: internal error: bad cursor_index";
goto done;
} else if (io_buf->meta.closed) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
"wuffs_aux::DecodeCbor: 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::CborDecoder: internal error: io_buf is full";
"wuffs_aux::DecodeCbor: internal error: io_buf is full";
goto done;
}
cursor_index = io_buf->meta.ri;
@@ -121,11 +130,19 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
"wuffs_aux::DecodeCbor: 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);
if ((tok_buf.meta.ri > tok_buf.meta.wi) ||
(tok_buf.meta.wi > tok_buf.data.len) ||
(io_buf->meta.ri > io_buf->meta.wi) ||
(io_buf->meta.wi > io_buf->data.len)) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad buffer indexes";
goto done;
}
}
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
@@ -133,7 +150,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
if ((io_buf->meta.ri < cursor_index) ||
((io_buf->meta.ri - cursor_index) < token_len)) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad token indexes";
"wuffs_aux::DecodeCbor: internal error: bad token indexes";
goto done;
}
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
@@ -169,7 +186,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
}
}
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad extended token";
"wuffs_aux::DecodeCbor: internal error: bad extended token";
goto done;
}
@@ -184,10 +201,20 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
goto done;
}
depth++;
if (depth > WUFFS_CBOR__DECODER_DEPTH_MAX_INCL) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad depth";
goto done;
}
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
if (depth < 0) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad depth";
goto done;
}
goto parsed_a_value;
}
@@ -324,7 +351,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
fail:
ret_error_message =
"wuffs_aux::CborDecoder: internal error: unexpected token";
"wuffs_aux::DecodeCbor: internal error: unexpected token";
goto done;
parsed_a_value:
+21 -3
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -70,6 +68,26 @@ class DecodeCborCallbacks {
Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);
};
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
struct DecodeCborArgQuirks {
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeCborArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
@@ -79,6 +97,6 @@ class DecodeCborCallbacks {
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());
DecodeCborArgQuirks quirks = DecodeCborArgQuirks::DefaultValue());
} // namespace wuffs_aux
+158 -37
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -95,6 +93,12 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
}
std::string //
DecodeImageCallbacks::HandleMetadata(const wuffs_base__more_information& minfo,
wuffs_base__slice_u8 raw) {
return "";
}
wuffs_base__pixel_format //
DecodeImageCallbacks::SelectPixfmt(
const wuffs_base__image_config& image_config) {
@@ -159,12 +163,16 @@ const char DecodeImage_BufferIsTooShort[] = //
"wuffs_aux::DecodeImage: buffer is too short";
const char DecodeImage_MaxInclDimensionExceeded[] = //
"wuffs_aux::DecodeImage: max_incl_dimension exceeded";
const char DecodeImage_MaxInclMetadataLengthExceeded[] = //
"wuffs_aux::DecodeImage: max_incl_metadata_length exceeded";
const char DecodeImage_OutOfMemory[] = //
"wuffs_aux::DecodeImage: out of memory";
const char DecodeImage_UnexpectedEndOfFile[] = //
"wuffs_aux::DecodeImage: unexpected end of file";
const char DecodeImage_UnsupportedImageFormat[] = //
"wuffs_aux::DecodeImage: unsupported image format";
const char DecodeImage_UnsupportedMetadata[] = //
"wuffs_aux::DecodeImage: unsupported metadata";
const char DecodeImage_UnsupportedPixelBlend[] = //
"wuffs_aux::DecodeImage: unsupported pixel blend";
const char DecodeImage_UnsupportedPixelConfiguration[] = //
@@ -172,38 +180,105 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
const char DecodeImage_UnsupportedPixelFormat[] = //
"wuffs_aux::DecodeImage: unsupported pixel format";
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeImageArgQuirks //
DecodeImageArgQuirks::DefaultValue() {
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
DecodeImageArgFlags //
DecodeImageArgFlags::DefaultValue() {
return DecodeImageArgFlags(0);
}
DecodeImageArgPixelBlend::DecodeImageArgPixelBlend(
wuffs_base__pixel_blend repr0)
: repr(repr0) {}
DecodeImageArgPixelBlend //
DecodeImageArgPixelBlend::DefaultValue() {
return DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC);
}
DecodeImageArgBackgroundColor::DecodeImageArgBackgroundColor(
wuffs_base__color_u32_argb_premul repr0)
: repr(repr0) {}
DecodeImageArgBackgroundColor //
DecodeImageArgBackgroundColor::DefaultValue() {
return DecodeImageArgBackgroundColor(1);
}
DecodeImageArgMaxInclDimension::DecodeImageArgMaxInclDimension(uint32_t repr0)
: repr(repr0) {}
DecodeImageArgMaxInclDimension //
DecodeImageArgMaxInclDimension::DefaultValue() {
return DecodeImageArgMaxInclDimension(1048575);
}
DecodeImageArgMaxInclMetadataLength::DecodeImageArgMaxInclMetadataLength(
uint64_t repr0)
: repr(repr0) {}
DecodeImageArgMaxInclMetadataLength //
DecodeImageArgMaxInclMetadataLength::DefaultValue() {
return DecodeImageArgMaxInclMetadataLength(16777215);
}
// --------
namespace {
const private_impl::ErrorMessages DecodeImageErrorMessages = {
DecodeImage_MaxInclMetadataLengthExceeded, //
DecodeImage_OutOfMemory, //
DecodeImage_UnexpectedEndOfFile, //
DecodeImage_UnsupportedMetadata, //
DecodeImage_UnsupportedImageFormat, //
};
std::string //
DecodeImageAdvanceIOBuf(sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
bool compactable,
uint64_t min_excl_pos,
uint64_t pos) {
if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {
// Redirects must go forward.
return DecodeImage_UnsupportedImageFormat;
}
while (true) {
uint64_t relative_pos = pos - io_buf.reader_position();
if (relative_pos <= io_buf.reader_length()) {
io_buf.meta.ri += (size_t)relative_pos;
break;
} else if (io_buf.meta.closed) {
return DecodeImage_UnexpectedEndOfFile;
}
io_buf.meta.ri = io_buf.meta.wi;
if (compactable) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
return "";
DecodeImageAdvanceIOBufferTo(sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
uint64_t absolute_position) {
return private_impl::AdvanceIOBufferTo(DecodeImageErrorMessages, input,
io_buf, absolute_position);
}
wuffs_base__status //
DIHM0(void* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src) {
return wuffs_base__image_decoder__tell_me_more(
static_cast<wuffs_base__image_decoder*>(self), a_dst, a_minfo, a_src);
}
std::string //
DIHM1(void* self,
const wuffs_base__more_information* minfo,
wuffs_base__slice_u8 raw) {
return static_cast<DecodeImageCallbacks*>(self)->HandleMetadata(*minfo, raw);
}
std::string //
DecodeImageHandleMetadata(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
sync_io::DynIOBuffer& raw_metadata_buf) {
return private_impl::HandleMetadata(DecodeImageErrorMessages, input, io_buf,
raw_metadata_buf, DIHM0,
static_cast<void*>(image_decoder.get()),
DIHM1, static_cast<void*>(&callbacks));
}
DecodeImageResult //
@@ -211,9 +286,12 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
wuffs_base__slice_u32 quirks,
uint64_t flags,
wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color,
uint32_t max_incl_dimension) {
uint32_t max_incl_dimension,
uint64_t max_incl_metadata_length) {
// Check args.
switch (pixel_blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -224,6 +302,7 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
}
wuffs_base__image_config image_config = wuffs_base__null_image_config();
sync_io::DynIOBuffer raw_metadata_buf(max_incl_metadata_length);
uint64_t start_pos = io_buf.reader_position();
bool redirected = false;
int32_t fourcc = 0;
@@ -258,8 +337,12 @@ redirect:
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
uint64_t pos = minfo.io_redirect__range().min_incl;
std::string error_message = DecodeImageAdvanceIOBuf(
input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);
if (pos <= start_pos) {
// Redirects must go forward.
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
std::string error_message =
DecodeImageAdvanceIOBufferTo(input, io_buf, pos);
if (!error_message.empty()) {
return DecodeImageResult(std::move(error_message));
}
@@ -278,6 +361,33 @@ redirect:
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
// Apply quirks.
for (size_t i = 0; i < quirks.len; i++) {
image_decoder->set_quirk_enabled(quirks.ptr[i], true);
}
// Apply flags.
if (flags != 0) {
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_GAMA) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__GAMA, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_ICCP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_KVP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__KVP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_SRGB) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__SRGB, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_XMP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__XMP, true);
}
}
// Decode the image config.
while (true) {
wuffs_base__status id_dic_status =
@@ -290,6 +400,12 @@ redirect:
}
redirected = true;
goto redirect;
} else if (id_dic_status.repr == wuffs_base__note__metadata_reported) {
std::string error_message = DecodeImageHandleMetadata(
image_decoder, callbacks, input, io_buf, raw_metadata_buf);
if (!error_message.empty()) {
return DecodeImageResult(std::move(error_message));
}
} else if (id_dic_status.repr != wuffs_base__suspension__short_read) {
return DecodeImageResult(id_dic_status.message());
} else if (io_buf.meta.closed) {
@@ -302,6 +418,7 @@ redirect:
}
}
} while (false);
raw_metadata_buf.drop();
// Select the pixel format.
uint32_t w = image_config.pixcfg.width();
@@ -412,9 +529,12 @@ redirect:
DecodeImageResult //
DecodeImage(DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color,
uint32_t max_incl_dimension) {
DecodeImageArgQuirks quirks,
DecodeImageArgFlags flags,
DecodeImageArgPixelBlend pixel_blend,
DecodeImageArgBackgroundColor background_color,
DecodeImageArgMaxInclDimension max_incl_dimension,
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length) {
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
@@ -427,8 +547,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
DecodeImageResult result =
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
background_color, max_incl_dimension);
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
flags.repr, pixel_blend.repr, background_color.repr,
max_incl_dimension.repr, max_incl_metadata_length.repr);
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
return result;
}
+136 -10
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,10 +30,11 @@ struct DecodeImageResult {
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
// called in this order:
// 1. SelectDecoder
// 2. SelectPixfmt
// 3. AllocPixbuf
// 4. AllocWorkbuf
// 5. Done
// 2. HandleMetadata
// 3. SelectPixfmt
// 4. AllocPixbuf
// 5. AllocWorkbuf
// 6. Done
//
// It may return early - the third callback might not be invoked if the second
// one fails - but the final callback (Done) is always invoked.
@@ -92,6 +91,22 @@ class DecodeImageCallbacks {
virtual wuffs_base__image_decoder::unique_ptr //
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
// HandleMetadata acknowledges image metadata. minfo.flavor will be one of:
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED
// If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those
// bytes should not be retained beyond the the HandleMetadata call.
//
// minfo.metadata__fourcc() will typically match one of the
// DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM |
// REPORT_METADATA_GAMA) was passed to DecodeImage then the metadata FourCC
// will be either WUFFS_BASE__FOURCC__CHRM or WUFFS_BASE__FOURCC__GAMA.
//
// It returns an error message, or an empty string on success.
virtual std::string //
HandleMetadata(const wuffs_base__more_information& minfo,
wuffs_base__slice_u8 raw);
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
// should return wuffs_base__make_pixel_format(etc) called with one of:
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
@@ -158,13 +173,116 @@ class DecodeImageCallbacks {
extern const char DecodeImage_BufferIsTooShort[];
extern const char DecodeImage_MaxInclDimensionExceeded[];
extern const char DecodeImage_MaxInclMetadataLengthExceeded[];
extern const char DecodeImage_OutOfMemory[];
extern const char DecodeImage_UnexpectedEndOfFile[];
extern const char DecodeImage_UnsupportedImageFormat[];
extern const char DecodeImage_UnsupportedMetadata[];
extern const char DecodeImage_UnsupportedPixelBlend[];
extern const char DecodeImage_UnsupportedPixelConfiguration[];
extern const char DecodeImage_UnsupportedPixelFormat[];
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeImageArgQuirks wraps an optional argument to DecodeImage.
struct DecodeImageArgQuirks {
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeImageArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeImageArgFlags wraps an optional argument to DecodeImage.
struct DecodeImageArgFlags {
explicit DecodeImageArgFlags(uint64_t repr0);
// DefaultValue returns 0.
static DecodeImageArgFlags DefaultValue();
// TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, GAMA,
// ICCP, KVP, SRGB and XMP.
// Background Color.
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
// Primary Chromaticities and White Point.
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
// Exchangeable Image File Format.
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
// Gamma Correction.
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
// International Color Consortium Profile.
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
// Key-Value Pair.
//
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
// HandleMetadata callback, the raw argument contains UTF-8 strings.
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
// Modification Time.
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
// Offset (2-Dimensional).
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
// Physical Dimensions.
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
// Standard Red Green Blue (Rendering Intent).
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
// Extensible Metadata Platform.
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
uint64_t repr;
};
// DecodeImageArgPixelBlend wraps an optional argument to DecodeImage.
struct DecodeImageArgPixelBlend {
explicit DecodeImageArgPixelBlend(wuffs_base__pixel_blend repr0);
// DefaultValue returns WUFFS_BASE__PIXEL_BLEND__SRC.
static DecodeImageArgPixelBlend DefaultValue();
wuffs_base__pixel_blend repr;
};
// DecodeImageArgBackgroundColor wraps an optional argument to DecodeImage.
struct DecodeImageArgBackgroundColor {
explicit DecodeImageArgBackgroundColor(
wuffs_base__color_u32_argb_premul repr0);
// DefaultValue returns 1, an invalid wuffs_base__color_u32_argb_premul.
static DecodeImageArgBackgroundColor DefaultValue();
wuffs_base__color_u32_argb_premul repr;
};
// DecodeImageArgMaxInclDimension wraps an optional argument to DecodeImage.
struct DecodeImageArgMaxInclDimension {
explicit DecodeImageArgMaxInclDimension(uint32_t repr0);
// DefaultValue returns 1048575 = 0x000F_FFFF, more than 1 million pixels.
static DecodeImageArgMaxInclDimension DefaultValue();
uint32_t repr;
};
// DecodeImageArgMaxInclMetadataLength wraps an optional argument to
// DecodeImage.
struct DecodeImageArgMaxInclMetadataLength {
explicit DecodeImageArgMaxInclMetadataLength(uint64_t repr0);
// DefaultValue returns 16777215 = 0x00FF_FFFF, one less than 16 MiB.
static DecodeImageArgMaxInclMetadataLength DefaultValue();
uint64_t repr;
};
// DecodeImage decodes the image data in input. A variety of image file formats
// can be decoded, depending on what callbacks.SelectDecoder returns.
//
@@ -207,12 +325,20 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.
//
// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's
// width or height is greater than max_incl_dimension.
// width or height is greater than max_incl_dimension or if any opted-in (via
// flags bits) metadata is longer than max_incl_metadata_length.
DecodeImageResult //
DecodeImage(DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
DecodeImageArgQuirks quirks = DecodeImageArgQuirks::DefaultValue(),
DecodeImageArgFlags flags = DecodeImageArgFlags::DefaultValue(),
DecodeImageArgPixelBlend pixel_blend =
DecodeImageArgPixelBlend::DefaultValue(),
DecodeImageArgBackgroundColor background_color =
DecodeImageArgBackgroundColor::DefaultValue(),
DecodeImageArgMaxInclDimension max_incl_dimension =
DecodeImageArgMaxInclDimension::DefaultValue(),
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length =
DecodeImageArgMaxInclMetadataLength::DefaultValue());
} // namespace wuffs_aux
+123 -67
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -34,60 +32,84 @@ DecodeJsonCallbacks::Done(DecodeJsonResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
const char DecodeJson_BadJsonPointer[] =
const char DecodeJson_BadJsonPointer[] = //
"wuffs_aux::DecodeJson: bad JSON Pointer";
const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
const char DecodeJson_NoMatch[] = //
"wuffs_aux::DecodeJson: no match";
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeJsonArgQuirks //
DecodeJsonArgQuirks::DefaultValue() {
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
: repr(repr0) {}
DecodeJsonArgJsonPointer //
DecodeJsonArgJsonPointer::DefaultValue() {
return DecodeJsonArgJsonPointer(std::string());
}
// --------
#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()); \
if ((tok_buf.meta.ri > tok_buf.meta.wi) || \
(tok_buf.meta.wi > tok_buf.data.len) || \
(io_buf->meta.ri > io_buf->meta.wi) || \
(io_buf->meta.wi > io_buf->data.len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \
goto done; \
} \
} \
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)
// --------
@@ -95,7 +117,8 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
namespace {
// DecodeJson_SplitJsonPointer returns ("bar", 8) for ("/foo/bar/b~1z/qux", 5,
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax or i is
// out of bounds.
//
// The string returned is unescaped. If calling it again, this time with i=8,
// the "b~1z" substring would be returned as "b/z".
@@ -104,6 +127,9 @@ DecodeJson_SplitJsonPointer(std::string& s,
size_t i,
bool allow_tilde_n_tilde_r_tilde_t) {
std::string fragment;
if (i > s.size()) {
return std::make_pair(std::string(), 0);
}
while (i < s.size()) {
char c = s[i];
if (c == '/') {
@@ -310,8 +336,8 @@ check_that_a_value_follows:
continue;
}
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that
// we're only peeking at the next token.
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so
// that we're only peeking at the next token.
tok_buf.meta.ri--;
cursor_index -= static_cast<size_t>(token_len);
@@ -335,8 +361,8 @@ done:
DecodeJsonResult //
DecodeJson(DecodeJsonCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks,
std::string json_pointer) {
DecodeJsonArgQuirks quirks,
DecodeJsonArgJsonPointer json_pointer) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
@@ -358,11 +384,15 @@ 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++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
if (quirks.ptr[i] ==
for (size_t i = 0; i < quirks.repr.len; i++) {
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
if (quirks.repr.ptr[i] ==
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
allow_tilde_n_tilde_r_tilde_t = true;
}
@@ -373,21 +403,22 @@ 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;
int32_t depth = 0;
std::string str;
// Walk the (optional) JSON Pointer.
for (size_t i = 0; i < json_pointer.size();) {
if (json_pointer[i] != '/') {
for (size_t i = 0; i < json_pointer.repr.size();) {
if (json_pointer.repr[i] != '/') {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
}
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);
json_pointer.repr, i + 1, allow_tilde_n_tilde_r_tilde_t);
i = split.second;
if (i == 0) {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
@@ -419,10 +450,20 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done;
}
depth++;
if (depth > WUFFS_JSON__DECODER_DEPTH_MAX_INCL) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad depth";
goto done;
}
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
if (depth < 0) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad depth";
goto done;
}
goto parsed_a_value;
}
@@ -522,7 +563,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.repr.empty())) {
goto done;
}
}
+33 -4
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -71,6 +69,36 @@ class DecodeJsonCallbacks {
extern const char DecodeJson_BadJsonPointer[];
extern const char DecodeJson_NoMatch[];
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
struct DecodeJsonArgQuirks {
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeJsonArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
struct DecodeJsonArgJsonPointer {
explicit DecodeJsonArgJsonPointer(std::string repr0);
// DefaultValue returns an empty string.
static DecodeJsonArgJsonPointer DefaultValue();
std::string repr;
};
// DecodeJson calls callbacks based on the JSON-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
@@ -88,7 +116,8 @@ extern const char DecodeJson_NoMatch[];
DecodeJsonResult //
DecodeJson(DecodeJsonCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),
std::string json_pointer = std::string());
DecodeJsonArgQuirks quirks = DecodeJsonArgQuirks::DefaultValue(),
DecodeJsonArgJsonPointer json_pointer =
DecodeJsonArgJsonPointer::DefaultValue());
} // namespace wuffs_aux
+36
View File
@@ -0,0 +1,36 @@
# C Base Code
This directory (`base`) and its sibling
([`auxiliary`](/internal/cgen/auxiliary)) contain C and C++ code respectively.
This C/C++ code combines with the transpiled-to-C/C++ form of the Wuffs code in
the top-level [`std`](/std) directory to create the "single file C/C++ library"
form of the Wuffs standard library.
- From Wuffs-the-language's point of view, this directory contains
implementations of the built-in `base` package types, such as [I/O
buffers](/doc/note/io-input-output.md), [ranges and
rects](/doc/note/ranges-and-rects.md) and [statuses](/doc/note/statuses.md).
- From application code's point of view (Wuffs is for writing libraries not
applications), this directory also contains helper functions for working with
those `base` types, such as constructing an I/O buffer from a pointer and a
length, that aren't relevant to Wuffs-the-language code.
- This directory also contains some functionality (e.g. pixel conversion and
string conversion) that, in the future, could possibly be Wuffs packages
under `std`. For optimal performance, they sometimes require programming
language features (e.g. function-pointer typed variables, SIMD acceleration)
that are not yet available in Wuffs-the-language (or were not available at
the time they were added). In the short term, it was more practical to
implement them in carefully hand-written C/C++, in this directory. In the
long term, they could migrate out of `base` to be under `std`, but any `base`
API removal would require a Wuffs version number bump.
## Making Changes
After editing source code in this directory, to see those changes when
generating the C/C++ form of Wuffs' standard library:
go install github.com/google/wuffs/cmd/wuffs-c && wuffs gen base
This should modify the
[`wuffs-unsupported-snapshot.c`](/release/c/wuffs-unsupported-snapshot.c) file.
+3 -4
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -31,13 +29,14 @@
#include <stdlib.h>
#include <string.h>
// Note that Clang also defines __GNUC__.
#ifdef __cplusplus
#if (__cplusplus >= 201103L) || defined(_MSC_VER)
#include <memory>
#define WUFFS_BASE__HAVE_EQ_DELETE
#define WUFFS_BASE__HAVE_UNIQUE_PTR
#elif defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#elif defined(__GNUC__) || defined(__clang__)
#warning "Wuffs' C++ code expects -std=c++11 or later"
#endif
+12 -14
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -177,14 +175,14 @@ wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {
// padded with implicit zeroes.
//
// For example, if num_digits is 3 and digits is "\x07\x08\x09":
// - A decimal_point of -2 means ".00789"
// - A decimal_point of -1 means ".0789"
// - A decimal_point of +0 means ".789"
// - A decimal_point of +1 means "7.89"
// - A decimal_point of +2 means "78.9"
// - A decimal_point of +3 means "789."
// - A decimal_point of +4 means "7890."
// - A decimal_point of +5 means "78900."
// - A decimal_point of -2 means ".00789"
// - A decimal_point of -1 means ".0789"
// - A decimal_point of +0 means ".789"
// - A decimal_point of +1 means "7.89"
// - A decimal_point of +2 means "78.9"
// - A decimal_point of +3 means "789."
// - A decimal_point of +4 means "7890."
// - A decimal_point of +5 means "78900."
//
// As above, a decimal_point higher than +2047 means that the overall value is
// infinity, lower than -2047 means zero.
@@ -529,10 +527,10 @@ wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns
// the integral (non-fractional) part of h, provided that it is 18 or fewer
// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
// and that IEEE 754 double precision has 52 mantissa bits.
//
// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
+6 -17
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -29,26 +27,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) \
@@ -61,8 +49,9 @@
goto suspend; \
case n:;
// Clang also defines "__GNUC__".
#if defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__) || defined(__clang__)
#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))
#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))
#else
@@ -220,7 +209,7 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
// --------
static inline wuffs_base__slice_u8 //
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
wuffs_base__table_u8__row_u32(wuffs_base__table_u8 t, uint32_t y) {
if (y < t.height) {
return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);
}
+111 -24
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -35,7 +33,7 @@
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 0
#define WUFFS_VERSION_PATCH 0
#define WUFFS_VERSION_PRE_RELEASE_LABEL "work.in.progress"
#define WUFFS_VERSION_PRE_RELEASE_LABEL "unsupported.snapshot"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0
#define WUFFS_VERSION_STRING "0.0.0+0.00000000"
@@ -78,15 +76,18 @@
// POPCNT. This is checked at runtime via cpuid, not at compile time.
//
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
#if defined(__x86_64__) && !defined(__native_client__)
#if defined(__i386__) || defined(__x86_64__)
#if !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__) && !defined(__native_client__)
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#endif // !defined(__native_client__)
#endif // defined(__i386__) || defined(__x86_64__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_X64)
#if defined(_M_IX86) || defined(_M_X64)
#if defined(__AVX__) || defined(__clang__)
// We need <intrin.h> for the __cpuid function.
@@ -100,7 +101,8 @@
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL
#define WUFFS_BASE__CPU_ARCH__X86_64
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#else // defined(__AVX__) || defined(__clang__)
@@ -110,19 +112,22 @@
// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time
// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#pragma message("Wuffs with MSVC+X64 needs /arch:AVX for best performance")
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
#endif // defined(__AVX__) || defined(__clang__)
#endif // defined(_M_X64)
#endif // defined(_M_IX86) || defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
// --------
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
// static storage. The motivation is discussed in the "ALLOW STATIC
// IMPLEMENTATION" section of
// Define WUFFS_CONFIG__STATIC_FUNCTIONS (combined with WUFFS_IMPLEMENTATION)
// to make all of Wuffs' functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)
#define WUFFS_BASE__MAYBE_STATIC static
@@ -152,7 +157,7 @@ wuffs_base__cpu_arch__have_arm_neon() {
static inline bool //
wuffs_base__cpu_arch__have_x86_avx2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
@@ -192,13 +197,13 @@ wuffs_base__cpu_arch__have_x86_avx2() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_bmi2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
@@ -222,13 +227,13 @@ wuffs_base__cpu_arch__have_x86_bmi2() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_sse42() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
@@ -254,7 +259,7 @@ wuffs_base__cpu_arch__have_x86_sse42() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
@@ -269,8 +274,9 @@ wuffs_base__cpu_arch__have_x86_sse42() {
#endif
#endif
// Clang also defines "__GNUC__".
#if defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__) || defined(__clang__)
#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))
#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))
#else
@@ -468,7 +474,17 @@ typedef struct wuffs_base__transform__output__struct {
// --------
// FourCC constants.
// FourCC constants. Four Character Codes are literally four ASCII characters
// (sometimes padded with ' ' spaces) that pack neatly into a signed or
// unsigned 32-bit integer. ASCII letters are conventionally upper case.
//
// They are often used to identify video codecs (e.g. "H265") and pixel formats
// (e.g. "YV12"). Wuffs uses them for that but also generally for naming
// various things: compression formats (e.g. "BZ2 "), image metadata (e.g.
// "EXIF"), file formats (e.g. "HTML"), etc.
//
// Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to
// preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320.
// ¡ INSERT FourCCs.
@@ -581,6 +597,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/
//
@@ -681,7 +747,9 @@ wuffs_base__multiply_u64(uint64_t x, uint64_t y) {
// --------
#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
static inline uint32_t //
wuffs_base__count_leading_zeroes_u64(uint64_t u) {
@@ -725,7 +793,7 @@ wuffs_base__count_leading_zeroes_u64(uint64_t u) {
return n;
}
#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
#endif // (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
// --------
@@ -1289,6 +1357,25 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
return wuffs_base__make_slice_u8(NULL, 0);
}
// wuffs_base__table_u8__subtable_ij returns t[ix:jx, iy:jy].
//
// It returns an empty table if i or j is out of bounds.
static inline wuffs_base__table_u8 //
wuffs_base__table_u8__subtable_ij(wuffs_base__table_u8 t,
uint64_t ix,
uint64_t iy,
uint64_t jx,
uint64_t jy) {
if ((ix <= jx) && (jx <= SIZE_MAX) && (jx <= t.width) && //
(iy <= jy) && (jy <= SIZE_MAX) && (jy <= t.height)) {
return wuffs_base__make_table_u8(t.ptr + ix + (iy * t.stride), //
((size_t)(jx - ix)), //
((size_t)(jy - iy)), //
t.stride); //
}
return wuffs_base__make_table_u8(NULL, 0, 0, 0);
}
// wuffs_base__table__flattened_length returns the number of elements covered
// by the 1-dimensional span that backs a 2-dimensional table. This counts the
// elements inside the table and, when width != stride, the elements outside
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
+11 -8
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -139,13 +137,18 @@ wuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {
ret.value = 0;
return ret;
} else if (negative) {
if (r.value > 0x8000000000000000) {
goto fail_out_of_bounds;
if (r.value < 0x8000000000000000) {
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = -(int64_t)(r.value);
return ret;
} else if (r.value == 0x8000000000000000) {
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = INT64_MIN;
return ret;
}
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = -(int64_t)(r.value);
return ret;
goto fail_out_of_bounds;
} else if (r.value > 0x7FFFFFFFFFFFFFFF) {
goto fail_out_of_bounds;
} else {
+6 -6
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -117,11 +115,12 @@ wuffs_base__io_reader__set(wuffs_base__io_buffer* b,
const uint8_t** ptr_io0_r,
const uint8_t** ptr_io1_r,
const uint8_t** ptr_io2_r,
wuffs_base__slice_u8 data) {
wuffs_base__slice_u8 data,
uint64_t history_position) {
b->data = data;
b->meta.wi = data.len;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.pos = history_position;
b->meta.closed = false;
*ptr_iop_r = data.ptr;
@@ -355,11 +354,12 @@ wuffs_base__io_writer__set(wuffs_base__io_buffer* b,
uint8_t** ptr_io0_w,
uint8_t** ptr_io1_w,
uint8_t** ptr_io2_w,
wuffs_base__slice_u8 data) {
wuffs_base__slice_u8 data,
uint64_t history_position) {
b->data = data;
b->meta.wi = 0;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.pos = history_position;
b->meta.closed = false;
*ptr_iop_w = data.ptr;
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
+43 -23
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,19 +22,22 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
//
// Keep it sorted by magic[1], then magic[0] descending and finally by
// magic[2:]. When multiple entries match, the longest one wins.
//
// The fourcc field might be negated, in which case there's further
// specialization (see § below).
static struct {
int32_t fourcc;
const char* magic;
} table[] = {
{0x57424D50, "\x01\x00\x00"}, // WBMP
{0x424D5020, "\x01\x42\x4D"}, // BMP
{0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
{0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
{0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
{0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF (see § below)
{0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
{0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
{0x4A504547, "\x01\xFF\xD8"}, // JPEG
{-0x30302020, "\x01\x00\x00"}, // '00 'be
{+0x424D5020, "\x01\x42\x4D"}, // BMP
{+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
{+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
{+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
{-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF
{+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
{+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
{+0x4A504547, "\x01\xFF\xD8"}, // JPEG
};
static const size_t table_len = sizeof(table) / sizeof(table[0]);
@@ -77,19 +78,38 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
return 0;
match:
// Some FourCC values (see § above) are further specialized.
if (fourcc == 0x52494646) { // 'RIFF'be
if (prefix.len < 16) {
return -1;
}
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
if (x == 0x57454250) { // 'WEBP'be
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
if (y == 0x56503820) { // 'VP8 'be
return 0x57503820; // 'WP8 'be
} else if (y == 0x5650384C) { // 'VP8L'be
return 0x5750384C; // 'WP8L'be
// Negative FourCC values (see § above) are further specialized.
if (fourcc < 0) {
fourcc = -fourcc;
if (fourcc == 0x52494646) { // 'RIFF'be
if (prefix.len < 16) {
return -1;
}
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
if (x == 0x57454250) { // 'WEBP'be
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
if (y == 0x56503820) { // 'VP8 'be
return 0x57503820; // 'WP8 'be
} else if (y == 0x5650384C) { // 'VP8L'be
return 0x5750384C; // 'WP8L'be
}
}
} else if (fourcc == 0x30302020) { // '00 'be
// Binary data starting with multiple 0x00 NUL bytes is quite common.
if (prefix.len < 4) {
return -1;
} else if ((prefix.ptr[2] != 0x00) &&
((prefix.ptr[2] >= 0x80) || (prefix.ptr[3] != 0x00))) {
// Roughly speaking, this could be a non-degenerate (non-0-width and
// non-0-height) WBMP image.
return 0x57424D50; // 'WBMP'be
} else if (((prefix.ptr[2] == 0x01) || (prefix.ptr[2] == 0x02)) &&
(prefix.ptr[3] == 0x00)) {
return 0x49434F20; // 'ICO 'be
}
return 0;
}
}
return fourcc;
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
+13 -16
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -812,7 +810,7 @@ wuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
@@ -856,7 +854,7 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
}
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -3135,7 +3133,7 @@ wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
@@ -3188,7 +3186,7 @@ wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -3847,7 +3845,7 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
@@ -3894,7 +3892,7 @@ wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -4182,7 +4180,7 @@ wuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__xxxx__y__sse42;
}
@@ -4220,7 +4218,6 @@ wuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,
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:
@@ -4566,7 +4563,7 @@ wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
}
@@ -4641,7 +4638,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -4822,7 +4819,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_premul(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -4890,7 +4887,7 @@ wuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
}
@@ -4941,7 +4938,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -5052,7 +5049,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_premul(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
+129 -2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -831,14 +829,24 @@ typedef struct wuffs_base__more_information__struct {
inline wuffs_base__range_ie_u64 io_redirect__range() const;
inline uint64_t io_seek__position() const;
inline uint32_t metadata__fourcc() const;
// Deprecated: use metadata_raw_passthrough__range.
inline wuffs_base__range_ie_u64 metadata__range() const;
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
inline int32_t metadata_parsed__chrm(uint32_t component) const;
inline uint32_t metadata_parsed__gama() const;
inline uint32_t metadata_parsed__srgb() const;
#endif // __cplusplus
} wuffs_base__more_information;
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT 1
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2
// Deprecated: use
// WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH.
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH 3
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM 4
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED 5
static inline wuffs_base__more_information //
wuffs_base__empty_more_information() {
@@ -895,6 +903,8 @@ wuffs_base__more_information__metadata__fourcc(
return m->w;
}
// Deprecated: use
// wuffs_base__more_information__metadata_raw_passthrough__range.
static inline wuffs_base__range_ie_u64 //
wuffs_base__more_information__metadata__range(
const wuffs_base__more_information* m) {
@@ -904,6 +914,103 @@ wuffs_base__more_information__metadata__range(
return ret;
}
static inline wuffs_base__range_ie_u64 //
wuffs_base__more_information__metadata_raw_passthrough__range(
const wuffs_base__more_information* m) {
wuffs_base__range_ie_u64 ret;
ret.min_incl = m->y;
ret.max_excl = m->z;
return ret;
}
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_X 0
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_Y 1
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_X 2
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_Y 3
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_X 4
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_Y 5
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_X 6
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_Y 7
// wuffs_base__more_information__metadata_parsed__chrm returns chromaticity
// values (scaled by 100000) like the PNG "cHRM" chunk. For example, the sRGB
// color space corresponds to:
// - ETC__CHRM__WHITE_X 31270
// - ETC__CHRM__WHITE_Y 32900
// - ETC__CHRM__RED_X 64000
// - ETC__CHRM__RED_Y 33000
// - ETC__CHRM__GREEN_X 30000
// - ETC__CHRM__GREEN_Y 60000
// - ETC__CHRM__BLUE_X 15000
// - ETC__CHRM__BLUE_Y 6000
//
// See
// https://ciechanow.ski/color-spaces/#chromaticity-and-white-point-coordinates
static inline int32_t //
wuffs_base__more_information__metadata_parsed__chrm(
const wuffs_base__more_information* m,
uint32_t component) {
// After the flavor and the w field (holding a FourCC), a
// wuffs_base__more_information holds 24 bytes of data in three uint64_t
// typed fields (x, y and z). We pack the eight chromaticity values (wx, wy,
// rx, ..., by), basically int24_t values, into 24 bytes like this:
// - LSB MSB
// - x: wx wx wx wy wy wy rx rx
// - y: rx ry ry ry gx gx gx gy
// - z: gy gy bx bx bx by by by
uint32_t u = 0;
switch (component & 7) {
case 0:
u = ((uint32_t)(m->x >> 0));
break;
case 1:
u = ((uint32_t)(m->x >> 24));
break;
case 2:
u = ((uint32_t)((m->x >> 48) | (m->y << 16)));
break;
case 3:
u = ((uint32_t)(m->y >> 8));
break;
case 4:
u = ((uint32_t)(m->y >> 32));
break;
case 5:
u = ((uint32_t)((m->y >> 56) | (m->z << 8)));
break;
case 6:
u = ((uint32_t)(m->z >> 16));
break;
case 7:
u = ((uint32_t)(m->z >> 40));
break;
}
// The left-right shifts sign-extend from 24-bit to 32-bit integers.
return ((int32_t)(u << 8)) >> 8;
}
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
static inline uint32_t //
wuffs_base__more_information__metadata_parsed__gama(
const wuffs_base__more_information* m) {
return ((uint32_t)(m->x));
}
#define WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL 0
#define WUFFS_BASE__SRGB_RENDERING_INTENT__RELATIVE_COLORIMETRIC 1
#define WUFFS_BASE__SRGB_RENDERING_INTENT__SATURATION 2
#define WUFFS_BASE__SRGB_RENDERING_INTENT__ABSOLUTE_COLORIMETRIC 3
// wuffs_base__more_information__metadata_parsed__srgb returns the sRGB
// rendering intent like the PNG "sRGB" chunk.
static inline uint32_t //
wuffs_base__more_information__metadata_parsed__srgb(
const wuffs_base__more_information* m) {
return m->x & 3;
}
#ifdef __cplusplus
inline void //
@@ -941,4 +1048,24 @@ wuffs_base__more_information::metadata__range() const {
return wuffs_base__more_information__metadata__range(this);
}
inline wuffs_base__range_ie_u64 //
wuffs_base__more_information::metadata_raw_passthrough__range() const {
return wuffs_base__more_information__metadata_raw_passthrough__range(this);
}
inline int32_t //
wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__gama() const {
return wuffs_base__more_information__metadata_parsed__gama(this);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__srgb() const {
return wuffs_base__more_information__metadata_parsed__srgb(this);
}
#endif // __cplusplus
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
+3 -5
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -98,9 +96,9 @@
// wuffs_base__ieee_754_bit_representation__etc converts between a double
// precision numerical value and its IEEE 754 representations:
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
//
// For example, it converts between:
// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
-2
View File
@@ -1,5 +1,3 @@
// After editing this file, run "go generate" in the ../data directory.
// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
+19 -6
View File
@@ -250,8 +250,8 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args []
return nil
case t.IDPosition:
b.printf("wuffs_base__u64__sat_add(%s->meta.pos, ((uint64_t)(%s%s - %s%s)))",
recvName, iopPrefix, recvName, io0Prefix, recvName)
b.printf("wuffs_base__u64__sat_add((%s ? %s->meta.pos : 0), ((uint64_t)(%s%s - %s%s)))",
recvName, recvName, iopPrefix, recvName, io0Prefix, recvName)
return nil
case t.IDSince:
@@ -358,9 +358,13 @@ func (g *gen) writeBuiltinIOWriter(b *buffer, recv *a.Expr, method t.ID, args []
b.printf("((uint64_t)(%s%s - %s%s))", iopPrefix, recvName, io0Prefix, recvName)
return nil
case t.IDHistoryPosition:
b.printf("(%s ? %s->meta.pos : 0)", recvName, recvName)
return nil
case t.IDPosition:
b.printf("wuffs_base__u64__sat_add(%s->meta.pos, ((uint64_t)(%s%s - %s%s)))",
recvName, iopPrefix, recvName, io0Prefix, recvName)
b.printf("wuffs_base__u64__sat_add((%s ? %s->meta.pos : 0), ((uint64_t)(%s%s - %s%s)))",
recvName, recvName, iopPrefix, recvName, io0Prefix, recvName)
return nil
case t.IDSince:
@@ -1022,9 +1026,18 @@ func (g *gen) writeBuiltinTable(b *buffer, recv *a.Expr, method t.ID, args []*a.
case t.IDWidth:
field = "width"
case t.IDRow:
case t.IDRowU32:
// TODO: don't assume that the table is a table of base.u8.
b.writes("wuffs_base__table_u8__row(")
b.writes("wuffs_base__table_u8__row_u32(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes(", ")
return g.writeArgs(b, args, depth)
case t.IDSubtable:
// TODO: don't assume that the table is a table of base.u8.
b.writes("wuffs_base__table_u8__subtable_ij(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
+27 -25
View File
@@ -22,7 +22,6 @@ import (
"sort"
"strings"
"github.com/google/wuffs/internal/cgen/data"
"github.com/google/wuffs/lang/builtin"
"github.com/google/wuffs/lang/generate"
"github.com/google/wuffs/lib/dumbindent"
@@ -122,7 +121,7 @@ func Do(args []string) error {
return nil, fmt.Errorf("base package shouldn't have any .wuffs files")
}
buf := make(buffer, 0, 128*1024)
if err := expandBangBangInsert(&buf, data.BaseAllImplC, map[string]func(*buffer) error{
if err := expandBangBangInsert(&buf, embedBaseAllImplC.Trim(), map[string]func(*buffer) error{
"// ¡ INSERT InterfaceDeclarations.\n": insertInterfaceDeclarations,
"// ¡ INSERT InterfaceDefinitions.\n": insertInterfaceDefinitions,
"// ¡ INSERT base/all-private.h.\n": insertBaseAllPrivateH,
@@ -200,8 +199,8 @@ const (
)
const (
maxIOBinds = 100
maxTemp = 10000
maxIOManips = 100
maxTemp = 10000
)
type status struct {
@@ -270,24 +269,24 @@ func expandBangBangInsert(b *buffer, s string, m map[string]func(*buffer) error)
}
func insertBaseAllPrivateH(buf *buffer) error {
buf.writes(data.BaseFundamentalPrivateH)
buf.writes(embedBaseFundamentalPrivateH.Trim())
buf.writeb('\n')
buf.writes(data.BaseRangePrivateH)
buf.writes(embedBaseRangePrivateH.Trim())
buf.writeb('\n')
buf.writes(data.BaseIOPrivateH)
buf.writes(embedBaseIOPrivateH.Trim())
buf.writeb('\n')
buf.writes(data.BaseTokenPrivateH)
buf.writes(embedBaseTokenPrivateH.Trim())
buf.writeb('\n')
buf.writes(data.BaseMemoryPrivateH)
buf.writes(embedBaseMemoryPrivateH.Trim())
buf.writeb('\n')
buf.writes(data.BaseImagePrivateH)
buf.writes(embedBaseImagePrivateH.Trim())
buf.writeb('\n')
buf.writes(data.BaseStrConvPrivateH)
buf.writes(embedBaseStrConvPrivateH.Trim())
return nil
}
func insertBaseAllPublicH(buf *buffer) error {
if err := expandBangBangInsert(buf, data.BaseFundamentalPublicH, map[string]func(*buffer) error{
if err := expandBangBangInsert(buf, embedBaseFundamentalPublicH.Trim(), map[string]func(*buffer) error{
"// ¡ INSERT FourCCs.\n": func(b *buffer) error {
for i, z := range builtin.FourCCs {
if i != 0 {
@@ -340,49 +339,52 @@ func insertBaseAllPublicH(buf *buffer) error {
}
buf.writeb('\n')
buf.writes(data.BaseRangePublicH)
buf.writes(embedBaseRangePublicH.Trim())
buf.writeb('\n')
buf.writes(data.BaseIOPublicH)
buf.writes(embedBaseIOPublicH.Trim())
buf.writeb('\n')
buf.writes(data.BaseTokenPublicH)
buf.writes(embedBaseTokenPublicH.Trim())
buf.writeb('\n')
buf.writes(data.BaseMemoryPublicH)
buf.writes(embedBaseMemoryPublicH.Trim())
buf.writeb('\n')
buf.writes(data.BaseImagePublicH)
buf.writes(embedBaseImagePublicH.Trim())
buf.writeb('\n')
buf.writes(data.BaseStrConvPublicH)
buf.writes(embedBaseStrConvPublicH.Trim())
return nil
}
func insertBaseCopyright(buf *buffer) error {
buf.writes(data.BaseCopyright)
s := string(embedBaseAllImplC)
if i := strings.Index(s, "\n\n"); i >= 0 {
buf.writes(s[:i+1])
}
return nil
}
func insertBaseFloatConvSubmoduleC(buf *buffer) error {
buf.writes(data.BaseFloatConvSubmoduleDataC)
buf.writes(embedBaseFloatConvSubmoduleDataC.Trim())
buf.writeb('\n')
buf.writes(data.BaseFloatConvSubmoduleCodeC)
buf.writes(embedBaseFloatConvSubmoduleCodeC.Trim())
return nil
}
func insertBaseIntConvSubmoduleC(buf *buffer) error {
buf.writes(data.BaseIntConvSubmoduleC)
buf.writes(embedBaseIntConvSubmoduleC.Trim())
return nil
}
func insertBaseMagicSubmoduleC(buf *buffer) error {
buf.writes(data.BaseMagicSubmoduleC)
buf.writes(embedBaseMagicSubmoduleC.Trim())
return nil
}
func insertBasePixConvSubmoduleC(buf *buffer) error {
buf.writes(data.BasePixConvSubmoduleC)
buf.writes(embedBasePixConvSubmoduleC.Trim())
return nil
}
func insertBaseUTF8SubmoduleC(buf *buffer) error {
buf.writes(data.BaseUTF8SubmoduleC)
buf.writes(embedBaseUTF8SubmoduleC.Trim())
return nil
}
-904
View File
@@ -1,904 +0,0 @@
// Code generated by running "go generate". DO NOT EDIT.
// Copyright 2017 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.
package data
const BaseAllImplC = "" +
"#ifndef WUFFS_INCLUDE_GUARD__BASE\n#define WUFFS_INCLUDE_GUARD__BASE\n\n#if defined(WUFFS_IMPLEMENTATION) && !defined(WUFFS_CONFIG__MODULES)\n#define WUFFS_CONFIG__MODULES\n#define WUFFS_CONFIG__MODULE__BASE\n#endif\n\n// ¡ WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING ABOVE.\n\n// ¡ INSERT base/copyright\n\n#include <stdbool.h>\n#include <stdint.h>\n#include <stdlib.h>\n#include <string.h>\n\n// Note that Clang also defines __GNUC__.\n#ifdef __cplusplus\n#if (__cplusplus >= 201103L) || defined(_MSC_VER)\n#include <memory>\n#define WUFFS_BASE__HAVE_EQ_DELETE\n#define WUFFS_BASE__HAVE_UNIQUE_PTR\n#elif defined(__GNUC__)\n#warning \"Wuffs' C++ code expects -std=c++11 or later\"\n#endif\n\nextern \"C\" {\n#endif\n\n// ¡ INSERT base/all-public.h.\n\n// ¡ INSERT InterfaceDeclarations.\n\n" +
"" +
"// ----------------\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n// ‼ WUFFS C HEADER ENDS HERE.\n#ifdef WUFFS_IMPLEMENTATION\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// ¡ INSERT base/all-private.h.\n\n" +
"" +
"// ----------------\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__CORE)\n\nconst uint8_t wuffs_base__low_bits_mask__u8[8] = {\n 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F,\n};\n\nconst uint16_t wuffs_base__low_bits_mask__u16[16] = {\n 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F,\n 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF,\n};\n\nconst uint32_t wuffs_base__low_bits_mask__u32[32] = {\n 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F,\n 0x0000003F, 0x0000007F, 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,\n 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, 0x0001FFFF,\n 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,\n 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF,\n 0x3FFFFFFF, 0x7FFFFFFF,\n};\n\nconst uint64_t wuffs_base__low_bits_mask__u64[64] = {\n 0x0000000000000000, 0x0000000000000001, 0x000000000" +
"0000003,\n 0x0000000000000007, 0x000000000000000F, 0x000000000000001F,\n 0x000000000000003F, 0x000000000000007F, 0x00000000000000FF,\n 0x00000000000001FF, 0x00000000000003FF, 0x00000000000007FF,\n 0x0000000000000FFF, 0x0000000000001FFF, 0x0000000000003FFF,\n 0x0000000000007FFF, 0x000000000000FFFF, 0x000000000001FFFF,\n 0x000000000003FFFF, 0x000000000007FFFF, 0x00000000000FFFFF,\n 0x00000000001FFFFF, 0x00000000003FFFFF, 0x00000000007FFFFF,\n 0x0000000000FFFFFF, 0x0000000001FFFFFF, 0x0000000003FFFFFF,\n 0x0000000007FFFFFF, 0x000000000FFFFFFF, 0x000000001FFFFFFF,\n 0x000000003FFFFFFF, 0x000000007FFFFFFF, 0x00000000FFFFFFFF,\n 0x00000001FFFFFFFF, 0x00000003FFFFFFFF, 0x00000007FFFFFFFF,\n 0x0000000FFFFFFFFF, 0x0000001FFFFFFFFF, 0x0000003FFFFFFFFF,\n 0x0000007FFFFFFFFF, 0x000000FFFFFFFFFF, 0x000001FFFFFFFFFF,\n 0x000003FFFFFFFFFF, 0x000007FFFFFFFFFF, 0x00000FFFFFFFFFFF,\n 0x00001FFFFFFFFFFF, 0x00003FFFFFFFFFFF, 0x00007FFFFFFFFFFF,\n 0x0000FFFFFFFFFFFF, 0x0001FFFFFFFFFFFF, 0x0003FFFFF" +
"FFFFFFF,\n 0x0007FFFFFFFFFFFF, 0x000FFFFFFFFFFFFF, 0x001FFFFFFFFFFFFF,\n 0x003FFFFFFFFFFFFF, 0x007FFFFFFFFFFFFF, 0x00FFFFFFFFFFFFFF,\n 0x01FFFFFFFFFFFFFF, 0x03FFFFFFFFFFFFFF, 0x07FFFFFFFFFFFFFF,\n 0x0FFFFFFFFFFFFFFF, 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF,\n 0x7FFFFFFFFFFFFFFF,\n};\n\nconst uint32_t wuffs_base__pixel_format__bits_per_channel[16] = {\n 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\n 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,\n};\n\n// ¡ INSERT wuffs_base__status strings.\n\n// ¡ INSERT vtable names.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__CORE)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__INTERFACES)\n\n// ¡ INSERT InterfaceDefinitions.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__INTERFACES)\n\n#if !define" +
"d(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__FLOATCONV)\n\n// ¡ INSERT base/floatconv-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__FLOATCONV)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__INTCONV)\n\n// ¡ INSERT base/intconv-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__INTCONV)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__MAGIC)\n\n// ¡ INSERT base/magic-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__MAGIC)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODUL" +
"E__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)\n\n// ¡ INSERT base/pixconv-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__UTF8)\n\n// ¡ INSERT base/utf8-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__UTF8)\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_IMPLEMENTATION\n\n// ¡ WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING BELOW.\n\n#endif // WUFFS_INCLUDE_GUARD__BASE\n" +
""
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" +
"" +
"// --------\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" +
"" +
"// --------\n\n// wuffs_base__iterate_total_advance returns the exclusive pointer-offset at\n// which iteration should stop. The overall slice has length total_len, each\n// iteration's sub-slice has length iter_len and are placed iter_advance apart.\n//\n// The iter_advance may not be larger than iter_len. The iter_advance may be\n// smaller than iter_len, in which case the sub-slices will overlap.\n//\n// The return value r satisfies ((0 <= r) && (r <= total_len)).\n//\n// For example, if total_len = 15, iter_len = 5 and iter_advance = 3, there are\n// four iterations at offsets 0, 3, 6 and 9. This function returns 12.\n//\n// 0123456789012345\n// [....]\n// [....]\n// [....]\n// [....]\n// $\n// 0123456789012345\n//\n// For example, if total_len = 15, iter_len = 5 and iter_advance = 5, there are\n// three iterations at offsets 0, 5 and 10. This function returns 15.\n//\n// 0123456789012345\n// [....]\n// [....]\n// [....]\n// $\n// 0123456789012345\nstatic inline size_t //\nwuf" +
"fs_base__iterate_total_advance(size_t total_len,\n size_t iter_len,\n size_t iter_advance) {\n if (total_len >= iter_len) {\n size_t n = total_len - iter_len;\n return ((n / iter_advance) * iter_advance) + iter_advance;\n }\n return 0;\n}\n\n" +
"" +
"// ---------------- Numeric Types\n\nextern const uint8_t wuffs_base__low_bits_mask__u8[8];\nextern const uint16_t wuffs_base__low_bits_mask__u16[16];\nextern const uint32_t wuffs_base__low_bits_mask__u32[32];\nextern const uint64_t wuffs_base__low_bits_mask__u64[64];\n\n#define WUFFS_BASE__LOW_BITS_MASK__U8(n) (wuffs_base__low_bits_mask__u8[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U16(n) (wuffs_base__low_bits_mask__u16[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U32(n) (wuffs_base__low_bits_mask__u32[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U64(n) (wuffs_base__low_bits_mask__u64[n])\n\n" +
"" +
"// --------\n\nstatic inline void //\nwuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_sub(*x, y);\n}\n\n" +
"" +
"// ---------------- Slices and Tables\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if (((uint64_t)(s.len)) > up_to) {\n s.len = ((size_t)up_to);\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if (((uint64_t)(s.len)) > up_to) {\n s.ptr += ((uint64_t)(s.len)) - up_to;\n s.len = ((size_t)up_to);\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, len)\n// where len is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t //\nwuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 s" +
"rc) {\n size_t len = dst.len < src.len ? dst.len : src.len;\n if (len > 0) {\n memmove(dst.ptr, src.ptr, len);\n }\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {\n if (y < t.height) {\n return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n" +
"" +
"// ---------------- Slices and Tables (Utility)\n\n#define wuffs_base__utility__empty_slice_u8 wuffs_base__empty_slice_u8\n" +
""
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(__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_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" +
"" +
"// --------\n\n// Options (bitwise or'ed together) for wuffs_foo__bar__initialize functions.\n\n#define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_INITIALIZE__ALREADY_ZEROED means that the \"self\" receiver struct value\n// has already been set to all zeroes.\n#define WUFFS_INITIALIZE__ALREADY_ZEROED ((uint32_t)0x00000001)\n\n// WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED means that, absent\n// WUFFS_INITIALIZE__ALREADY_ZEROED, only some of the \"self\" receiver struct\n// value will be set to all zeroes. Internal buffers, which tend to be a large\n// proportion of the struct's size, will be left uninitialized. Internal means\n// that the buffer is contained by the receiver struct, as opposed to being\n// passed as a separately allocated \"work buffer\".\n//\n// For more detail, see:\n// https://github.com/google/wuffs/blob/main/doc/note/initialization.md\n#define WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED \\\n ((uint32_t)0x00000002)\n\n" +
"" +
"// --------\n\n// wuffs_base__empty_struct is used when a Wuffs function returns an empty\n// struct. In C, if a function f returns void, you can't say \"x = f()\", but in\n// Wuffs, if a function g returns empty, you can say \"y = g()\".\ntypedef struct wuffs_base__empty_struct__struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n //\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct is always 1.\n uint8_t private_impl;\n} wuffs_base__empty_struct;\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__make_empty_struct() {\n wuffs_base__empty_struct ret;\n ret.private_impl = 0;\n return " +
"ret;\n}\n\n// wuffs_base__utility is a placeholder receiver type. It enables what Java\n// calls static methods, as opposed to regular methods.\ntypedef struct wuffs_base__utility__struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n //\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct is always 1.\n uint8_t private_impl;\n} wuffs_base__utility;\n\ntypedef struct wuffs_base__vtable__struct {\n const char* vtable_name;\n const void* function_pointers;\n} wuffs_base__vtable;\n\n" +
"" +
"// --------\n\n// See https://github.com/google/wuffs/blob/main/doc/note/statuses.md\ntypedef struct wuffs_base__status__struct {\n const char* repr;\n\n#ifdef __cplusplus\n inline bool is_complete() const;\n inline bool is_error() const;\n inline bool is_note() const;\n inline bool is_ok() const;\n inline bool is_suspension() const;\n inline const char* message() const;\n#endif // __cplusplus\n\n} wuffs_base__status;\n\n// ¡ INSERT wuffs_base__status names.\n\nstatic inline wuffs_base__status //\nwuffs_base__make_status(const char* repr) {\n wuffs_base__status z;\n z.repr = repr;\n return z;\n}\n\nstatic inline bool //\nwuffs_base__status__is_complete(const wuffs_base__status* z) {\n return (z->repr == NULL) || ((*z->repr != '$') && (*z->repr != '#'));\n}\n\nstatic inline bool //\nwuffs_base__status__is_error(const wuffs_base__status* z) {\n return z->repr && (*z->repr == '#');\n}\n\nstatic inline bool //\nwuffs_base__status__is_note(const wuffs_base__status* z) {\n return z->repr && (*z->repr != '$') && (*z->repr != '#');\n}\n\n" +
"static inline bool //\nwuffs_base__status__is_ok(const wuffs_base__status* z) {\n return z->repr == NULL;\n}\n\nstatic inline bool //\nwuffs_base__status__is_suspension(const wuffs_base__status* z) {\n return z->repr && (*z->repr == '$');\n}\n\n// wuffs_base__status__message strips the leading '$', '#' or '@'.\nstatic inline const char* //\nwuffs_base__status__message(const wuffs_base__status* z) {\n if (z->repr) {\n if ((*z->repr == '$') || (*z->repr == '#') || (*z->repr == '@')) {\n return z->repr + 1;\n }\n }\n return z->repr;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__status::is_complete() const {\n return wuffs_base__status__is_complete(this);\n}\n\ninline bool //\nwuffs_base__status::is_error() const {\n return wuffs_base__status__is_error(this);\n}\n\ninline bool //\nwuffs_base__status::is_note() const {\n return wuffs_base__status__is_note(this);\n}\n\ninline bool //\nwuffs_base__status::is_ok() const {\n return wuffs_base__status__is_ok(this);\n}\n\ninline bool //\nwuffs_base__status::is_suspension() co" +
"nst {\n return wuffs_base__status__is_suspension(this);\n}\n\ninline const char* //\nwuffs_base__status::message() const {\n return wuffs_base__status__message(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\n// WUFFS_BASE__RESULT is a result type: either a status (an error) or a value.\n//\n// A result with all fields NULL or zero is as valid as a zero-valued T.\n#define WUFFS_BASE__RESULT(T) \\\n struct { \\\n wuffs_base__status status; \\\n T value; \\\n }\n\ntypedef WUFFS_BASE__RESULT(double) wuffs_base__result_f64;\ntypedef WUFFS_BASE__RESULT(int64_t) wuffs_base__result_i64;\ntypedef WUFFS_BASE__RESULT(uint64_t) wuffs_base__result_u64;\n\n" +
"" +
"// --------\n\n// wuffs_base__transform__output is the result of transforming from a src slice\n// to a dst slice.\ntypedef struct wuffs_base__transform__output__struct {\n wuffs_base__status status;\n size_t num_dst;\n size_t num_src;\n} wuffs_base__transform__output;\n\n" +
"" +
"// --------\n\n// FourCC constants.\n\n// ¡ INSERT FourCCs.\n\n" +
"" +
"// --------\n\n// Quirks.\n\n// ¡ INSERT Quirks.\n\n" +
"" +
"// --------\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef int64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000)\n#define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600)\n\n" +
"" +
"// ---------------- Numeric Types\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline int8_t //\nwuffs_base__i8__min(int8_t x, int8_t y) {\n return x < y ? x : y;\n}\n\nstatic inline int8_t //\nwuffs_base__i8__max(int8_t x, int8_t y) {\n return x > y ? x : y;\n}\n\nstatic inline int16_t //\nwuffs_base__i16__min(int16_t x, int16_t y) {\n return x < y ? x : y;\n}\n\nstatic inline int16_t //\nwuffs_base__i16__max(int16_t x, int16_t y) {\n return x > y ? x : y;\n}\n\nstatic inline int32_t //\nwuffs_base__i32__min(int32_t x, int32_t y) {\n return x < y ? x : y;\n}\n\nstatic inline " +
"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\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" +
"" +
"// --------\n\ntypedef struct wuffs_base__multiply_u64__output__struct {\n uint64_t lo;\n uint64_t hi;\n} wuffs_base__multiply_u64__output;\n\n// wuffs_base__multiply_u64 returns x*y as a 128-bit value.\n//\n// The maximum inclusive output hi_lo is 0xFFFFFFFFFFFFFFFE_0000000000000001.\nstatic inline wuffs_base__multiply_u64__output //\nwuffs_base__multiply_u64(uint64_t x, uint64_t y) {\n#if defined(__SIZEOF_INT128__)\n __uint128_t z = ((__uint128_t)x) * ((__uint128_t)y);\n wuffs_base__multiply_u64__output o;\n o.lo = ((uint64_t)(z));\n o.hi = ((uint64_t)(z >> 64));\n return o;\n#else\n // TODO: consider using the _mul128 intrinsic if defined(_MSC_VER).\n uint64_t x0 = x & 0xFFFFFFFF;\n uint64_t x1 = x >> 32;\n uint64_t y0 = y & 0xFFFFFFFF;\n uint64_t y1 = y >> 32;\n uint64_t w0 = x0 * y0;\n uint64_t t = (x1 * y0) + (w0 >> 32);\n uint64_t w1 = t & 0xFFFFFFFF;\n uint64_t w2 = t >> 32;\n w1 += x0 * y1;\n wuffs_base__multiply_u64__output o;\n o.lo = x * y;\n o.hi = (x1 * y1) + w2 + (w1 >> 32);\n return o;\n#endif\n}\n\n" +
"" +
"// --------\n\n#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)\n\nstatic inline uint32_t //\nwuffs_base__count_leading_zeroes_u64(uint64_t u) {\n return u ? ((uint32_t)(__builtin_clzl(u))) : 64u;\n}\n\n#else\n// TODO: consider using the _BitScanReverse intrinsic if defined(_MSC_VER).\n\nstatic inline uint32_t //\nwuffs_base__count_leading_zeroes_u64(uint64_t u) {\n if (u == 0) {\n return 64;\n }\n\n uint32_t n = 0;\n if ((u >> 32) == 0) {\n n |= 32;\n u <<= 32;\n }\n if ((u >> 48) == 0) {\n n |= 16;\n u <<= 16;\n }\n if ((u >> 56) == 0) {\n n |= 8;\n u <<= 8;\n }\n if ((u >> 60) == 0) {\n n |= 4;\n u <<= 4;\n }\n if ((u >> 62) == 0) {\n n |= 2;\n u <<= 2;\n }\n if ((u >> 63) == 0) {\n n |= 1;\n u <<= 1;\n }\n return n;\n}\n\n#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)\n\n" +
"" +
"// --------\n\n#define wuffs_base__peek_u8be__no_bounds_check \\\n wuffs_base__peek_u8__no_bounds_check\n#define wuffs_base__peek_u8le__no_bounds_check \\\n wuffs_base__peek_u8__no_bounds_check\n\nstatic inline uint8_t //\nwuffs_base__peek_u8__no_bounds_check(const uint8_t* p) {\n return p[0];\n}\n\nstatic inline uint16_t //\nwuffs_base__peek_u16be__no_bounds_check(const uint8_t* p) {\n return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0));\n}\n\nstatic inline uint16_t //\nwuffs_base__peek_u16le__no_bounds_check(const uint8_t* p) {\n return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8));\n}\n\nstatic inline uint32_t //\nwuffs_base__peek_u24be__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__peek_u24le__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16);\n}\n\nstatic inline uint32_t //\nwuffs_base" +
"__peek_u32be__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__peek_u32le__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u40be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |\n ((uint64_t)(p[4]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u40le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u48be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[" +
"1]) << 32) |\n ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |\n ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u48le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u56be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) |\n ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) |\n ((uint64_t)(p[6]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u56le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[" +
"6]) << 48);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u64be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) |\n ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) |\n ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) |\n ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u64le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56);\n}\n\n" +
"" +
"// --------\n\n#define wuffs_base__poke_u8be__no_bounds_check \\\n wuffs_base__poke_u8__no_bounds_check\n#define wuffs_base__poke_u8le__no_bounds_check \\\n wuffs_base__poke_u8__no_bounds_check\n\nstatic inline void //\nwuffs_base__poke_u8__no_bounds_check(uint8_t* p, uint8_t x) {\n p[0] = x;\n}\n\nstatic inline void //\nwuffs_base__poke_u16be__no_bounds_check(uint8_t* p, uint16_t x) {\n p[0] = (uint8_t)(x >> 8);\n p[1] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u16le__no_bounds_check(uint8_t* p, uint16_t x) {\n#if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)\n // This seems to perform better on gcc 10 (but not clang 9). Clang also\n // defines \"__GNUC__\".\n memcpy(p, &x, 2);\n#else\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n#endif\n}\n\nstatic inline void //\nwuffs_base__poke_u24be__no_bounds_check(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 16);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u24le__no_bounds_chec" +
"k(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n}\n\nstatic inline void //\nwuffs_base__poke_u32be__no_bounds_check(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 24);\n p[1] = (uint8_t)(x >> 16);\n p[2] = (uint8_t)(x >> 8);\n p[3] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u32le__no_bounds_check(uint8_t* p, uint32_t x) {\n#if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)\n // This seems to perform better on gcc 10 (but not clang 9). Clang also\n // defines \"__GNUC__\".\n memcpy(p, &x, 4);\n#else\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n#endif\n}\n\nstatic inline void //\nwuffs_base__poke_u40be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 32);\n p[1] = (uint8_t)(x >> 24);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 8);\n p[4] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u40le__no_bounds_chec" +
"k(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n}\n\nstatic inline void //\nwuffs_base__poke_u48be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 40);\n p[1] = (uint8_t)(x >> 32);\n p[2] = (uint8_t)(x >> 24);\n p[3] = (uint8_t)(x >> 16);\n p[4] = (uint8_t)(x >> 8);\n p[5] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u48le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n}\n\nstatic inline void //\nwuffs_base__poke_u56be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 48);\n p[1] = (uint8_t)(x >> 40);\n p[2] = (uint8_t)(x >> 32);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 16);\n p[5] = (uint8_t)(x >> 8);\n p[6] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_" +
"base__poke_u56le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n}\n\nstatic inline void //\nwuffs_base__poke_u64be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 56);\n p[1] = (uint8_t)(x >> 48);\n p[2] = (uint8_t)(x >> 40);\n p[3] = (uint8_t)(x >> 32);\n p[4] = (uint8_t)(x >> 24);\n p[5] = (uint8_t)(x >> 16);\n p[6] = (uint8_t)(x >> 8);\n p[7] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {\n#if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)\n // This seems to perform better on gcc 10 (but not clang 9). Clang also\n // defines \"__GNUC__\".\n memcpy(p, &x, 8);\n#else\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uin" +
"t8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n p[7] = (uint8_t)(x >> 56);\n#endif\n}\n\n" +
"" +
"// --------\n\n// Load and Store functions are deprecated. Use Peek and Poke instead.\n\n#define wuffs_base__load_u8__no_bounds_check \\\n wuffs_base__peek_u8__no_bounds_check\n#define wuffs_base__load_u16be__no_bounds_check \\\n wuffs_base__peek_u16be__no_bounds_check\n#define wuffs_base__load_u16le__no_bounds_check \\\n wuffs_base__peek_u16le__no_bounds_check\n#define wuffs_base__load_u24be__no_bounds_check \\\n wuffs_base__peek_u24be__no_bounds_check\n#define wuffs_base__load_u24le__no_bounds_check \\\n wuffs_base__peek_u24le__no_bounds_check\n#define wuffs_base__load_u32be__no_bounds_check \\\n wuffs_base__peek_u32be__no_bounds_check\n#define wuffs_base__load_u32le__no_bounds_check \\\n wuffs_base__peek_u32le__no_bounds_check\n#define wuffs_base__load_u40be__no_bounds_check \\\n wuffs_base__peek_u40be__no_bounds_check\n#define wuffs_base__load_u40le__no_bounds_check \\\n wuffs_base__peek_u40le__no_bounds_check\n#define wuffs_base__load_u48be__no_bounds_check \\\n wuffs_base__peek_u48be__no_bounds_check\n#define wuffs_base__load_" +
"u48le__no_bounds_check \\\n wuffs_base__peek_u48le__no_bounds_check\n#define wuffs_base__load_u56be__no_bounds_check \\\n wuffs_base__peek_u56be__no_bounds_check\n#define wuffs_base__load_u56le__no_bounds_check \\\n wuffs_base__peek_u56le__no_bounds_check\n#define wuffs_base__load_u64be__no_bounds_check \\\n wuffs_base__peek_u64be__no_bounds_check\n#define wuffs_base__load_u64le__no_bounds_check \\\n wuffs_base__peek_u64le__no_bounds_check\n\n#define wuffs_base__store_u8__no_bounds_check \\\n wuffs_base__poke_u8__no_bounds_check\n#define wuffs_base__store_u16be__no_bounds_check \\\n wuffs_base__poke_u16be__no_bounds_check\n#define wuffs_base__store_u16le__no_bounds_check \\\n wuffs_base__poke_u16le__no_bounds_check\n#define wuffs_base__store_u24be__no_bounds_check \\\n wuffs_base__poke_u24be__no_bounds_check\n#define wuffs_base__store_u24le__no_bounds_check \\\n wuffs_base__poke_u24le__no_bounds_check\n#define wuffs_base__store_u32be__no_bounds_check \\\n wuffs_base__poke_u32be__no_bounds_check\n#define wuffs_base__store_u32le__no_" +
"bounds_check \\\n wuffs_base__poke_u32le__no_bounds_check\n#define wuffs_base__store_u40be__no_bounds_check \\\n wuffs_base__poke_u40be__no_bounds_check\n#define wuffs_base__store_u40le__no_bounds_check \\\n wuffs_base__poke_u40le__no_bounds_check\n#define wuffs_base__store_u48be__no_bounds_check \\\n wuffs_base__poke_u48be__no_bounds_check\n#define wuffs_base__store_u48le__no_bounds_check \\\n wuffs_base__poke_u48le__no_bounds_check\n#define wuffs_base__store_u56be__no_bounds_check \\\n wuffs_base__poke_u56be__no_bounds_check\n#define wuffs_base__store_u56le__no_bounds_check \\\n wuffs_base__poke_u56le__no_bounds_check\n#define wuffs_base__store_u64be__no_bounds_check \\\n wuffs_base__poke_u64be__no_bounds_check\n#define wuffs_base__store_u64le__no_bounds_check \\\n wuffs_base__poke_u64le__no_bounds_check\n\n" +
"" +
"// ---------------- Slices and Tables\n\n// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// len measures a number of elements, not necessarily a size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\n#define WUFFS_BASE__SLICE(T) \\\n struct { \\\n T* ptr; \\\n size_t len; \\\n }\n\n// WUFFS_BASE__TABLE is a 2-dimensional buffer.\n//\n// width, height and stride measure a number of elements, not necessarily a\n// size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty table.\n#define WUFFS_BASE__TABLE(T) \\\n struct { \\\n T* ptr; \\\n size_t width; \\\n size_t height; \\\n size_t stride; \\\n }\n\ntypedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8;\ntypedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16;\ntypedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32;\ntypedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64;\n\ntypedef WUFFS_BASE__TABLE(u" +
"int8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__make_slice_u8(uint8_t* ptr, size_t len) {\n wuffs_base__slice_u8 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u16 //\nwuffs_base__make_slice_u16(uint16_t* ptr, size_t len) {\n wuffs_base__slice_u16 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__make_slice_u32(uint32_t* ptr, size_t len) {\n wuffs_base__slice_u32 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__make_slice_u64(uint64_t* ptr, size_t len) {\n wuffs_base__slice_u64 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__empty_slice_u8() {\n wuffs_base__slice_u8 ret;\n ret.ptr = NULL;\n" +
" ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u16 //\nwuffs_base__empty_slice_u16() {\n wuffs_base__slice_u16 ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__empty_slice_u32() {\n wuffs_base__slice_u32 ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__empty_slice_u64() {\n wuffs_base__slice_u64 ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__make_table_u8(uint8_t* ptr,\n size_t width,\n size_t height,\n size_t stride) {\n wuffs_base__table_u8 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u16 //\nwuffs_base__make_table_u16(uint16_t* ptr,\n size_t width,\n size_t height,\n size_t stride) " +
"{\n wuffs_base__table_u16 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u32 //\nwuffs_base__make_table_u32(uint32_t* ptr,\n size_t width,\n size_t height,\n size_t stride) {\n wuffs_base__table_u32 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u64 //\nwuffs_base__make_table_u64(uint64_t* ptr,\n size_t width,\n size_t height,\n size_t stride) {\n wuffs_base__table_u64 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__empty_table_u8() {\n wuffs_base__table_u8 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline wuffs_base__ta" +
"ble_u16 //\nwuffs_base__empty_table_u16() {\n wuffs_base__table_u16 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline wuffs_base__table_u32 //\nwuffs_base__empty_table_u32() {\n wuffs_base__table_u32 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline wuffs_base__table_u64 //\nwuffs_base__empty_table_u64() {\n wuffs_base__table_u64 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__slice_u8__overlaps(wuffs_base__slice_u8 s, wuffs_base__slice_u8 t) {\n return ((s.ptr <= t.ptr) && (t.ptr < (s.ptr + s.len))) ||\n ((t.ptr <= s.ptr) && (s.ptr < (t.ptr + t.len)));\n}\n\n// wuffs_base__slice_u8__subslice_i returns s[i:].\n//\n// It returns an empty slice if i is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n " +
" return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(s.len - i)));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n// wuffs_base__slice_u8__subslice_j returns s[:j].\n//\n// It returns an empty slice if j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return wuffs_base__make_slice_u8(s.ptr, ((size_t)j));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n// wuffs_base__slice_u8__subslice_ij returns s[i:j].\n//\n// It returns an empty slice if i or j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(j - i)));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n// wuffs_base__table__flattened_length returns the number o" +
"f elements covered\n// by the 1-dimensional span that backs a 2-dimensional table. This counts the\n// elements inside the table and, when width != stride, the elements outside\n// the table but between its rows.\n//\n// For example, consider a width 10, height 4, stride 10 table. Mark its first\n// and last (inclusive) elements with 'a' and 'z'. This function returns 40.\n//\n// a123456789\n// 0123456789\n// 0123456789\n// 012345678z\n//\n// Now consider the sub-table of that from (2, 1) inclusive to (8, 4) exclusive.\n//\n// a123456789\n// 01iiiiiioo\n// ooiiiiiioo\n// ooiiiiii8z\n//\n// This function (called with width 6, height 3, stride 10) returns 26: 18 'i'\n// inside elements plus 8 'o' outside elements. Note that 26 is less than a\n// naive (height * stride = 30) computation. Indeed, advancing 29 elements from\n// the first 'i' would venture past 'z', out of bounds of the original table.\n//\n// It does not check for overflow, but if the arguments come from a table that\n// exists in memory and each el" +
"ement occupies a positive number of bytes then\n// the result should be bounded by the amount of allocatable memory (which\n// shouldn't overflow SIZE_MAX).\nstatic inline size_t //\nwuffs_base__table__flattened_length(size_t width,\n size_t height,\n size_t stride) {\n if (height == 0) {\n return 0;\n }\n return ((height - 1) * stride) + width;\n}\n\n" +
"" +
"// ---------------- Magic Numbers\n\n// wuffs_base__magic_number_guess_fourcc guesses the file format of some data,\n// given its opening bytes. It returns a positive FourCC value on success.\n//\n// It returns zero if nothing matches its hard-coded list of 'magic numbers'.\n//\n// It returns a negative value if a longer prefix is required for a conclusive\n// result. For example, seeing a single 'B' byte is not enough to discriminate\n// the BMP and BPG image file formats.\n//\n// It does not do a full validity check. Like any guess made from a short\n// prefix of the data, it may return false positives. Data that starts with 99\n// bytes of valid JPEG followed by corruption or truncation is an invalid JPEG\n// image overall, but this function will still return WUFFS_BASE__FOURCC__JPEG.\n//\n// Another source of false positives is that some 'magic numbers' are valid\n// ASCII data. A file starting with \"GIF87a and GIF89a are the two versions of\n// GIF\" will match GIF's 'magic number' even if it's plain text, not an image.\n//" +
"\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__MAGIC sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC int32_t //\nwuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix);\n" +
""
const BaseMemoryPrivateH = "" +
"// ---------------- Memory Allocation\n" +
""
const BaseMemoryPublicH = "" +
"// ---------------- Memory Allocation\n\n// The memory allocation related functions in this section aren't used by Wuffs\n// per se, but they may be helpful to the code that uses Wuffs.\n\n// wuffs_base__malloc_slice_uxx wraps calling a malloc-like function, except\n// that it takes a uint64_t number of elements instead of a size_t size in\n// bytes, and it returns a slice (a pointer and a length) instead of just a\n// pointer.\n//\n// You can pass the C stdlib's malloc as the malloc_func.\n//\n// It returns an empty slice (containing a NULL ptr field) if (num_uxx *\n// sizeof(uintxx_t)) would overflow SIZE_MAX.\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) {\n if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) {\n void* p = (*malloc_func)((size_t)(num_u8 * sizeof(uint8_t)));\n if (p) {\n return wuffs_base__make_slice_u8((uint8_t*)(p), (size_t)num_u8);\n }\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__s" +
"lice_u16 //\nwuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) {\n if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) {\n void* p = (*malloc_func)((size_t)(num_u16 * sizeof(uint16_t)));\n if (p) {\n return wuffs_base__make_slice_u16((uint16_t*)(p), (size_t)num_u16);\n }\n }\n return wuffs_base__make_slice_u16(NULL, 0);\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) {\n if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) {\n void* p = (*malloc_func)((size_t)(num_u32 * sizeof(uint32_t)));\n if (p) {\n return wuffs_base__make_slice_u32((uint32_t*)(p), (size_t)num_u32);\n }\n }\n return wuffs_base__make_slice_u32(NULL, 0);\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {\n if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) {\n void* p = (*malloc_func)((size_t)(num_u64 * sizeof(uint64_t))" +
");\n if (p) {\n return wuffs_base__make_slice_u64((uint64_t*)(p), (size_t)num_u64);\n }\n }\n return wuffs_base__make_slice_u64(NULL, 0);\n}\n" +
""
const BaseImagePrivateH = "" +
"// ---------------- Images\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n uint32_t up_to_num_pixels,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r);\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r);\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n uint64_t num_pixels);\n\n" +
"" +
"// ---------------- Images (Utility)\n\n#define wuffs_base__utility__make_pixel_format wuffs_base__make_pixel_format\n" +
""
const BaseImagePublicH = "" +
"// ---------------- Images\n\n// wuffs_base__color_u32_argb_premul is an 8 bit per channel premultiplied\n// Alpha, Red, Green, Blue color, as a uint32_t value. Its value is always\n// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.\ntypedef uint32_t wuffs_base__color_u32_argb_premul;\n\n// wuffs_base__color_u32_argb_premul__is_valid returns whether c's Red, Green\n// and Blue channels are all less than or equal to its Alpha channel. c uses\n// premultiplied alpha, so 50% opaque 100% saturated red is 0x7F7F_0000 and a\n// value like 0x7F80_0000 is invalid.\nstatic inline bool //\nwuffs_base__color_u32_argb_premul__is_valid(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t a = 0xFF & (c >> 24);\n uint32_t r = 0xFF & (c >> 16);\n uint32_t g = 0xFF & (c >> 8);\n uint32_t b = 0xFF & (c >> 0);\n return (a >= r) && (a >= g) && (a >= b);\n}\n\nstatic inline uint16_t //\nwuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t r5 = 0xF800 & (c >" +
"> 8);\n uint32_t g6 = 0x07E0 & (c >> 5);\n uint32_t b5 = 0x001F & (c >> 3);\n return (uint16_t)(r5 | g6 | b5);\n}\n\nstatic inline wuffs_base__color_u32_argb_premul //\nwuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(uint16_t rgb_565) {\n uint32_t b5 = 0x1F & (rgb_565 >> 0);\n uint32_t b = (b5 << 3) | (b5 >> 2);\n uint32_t g6 = 0x3F & (rgb_565 >> 5);\n uint32_t g = (g6 << 2) | (g6 >> 4);\n uint32_t r5 = 0x1F & (rgb_565 >> 11);\n uint32_t r = (r5 << 3) | (r5 >> 2);\n return 0xFF000000 | (r << 16) | (g << 8) | (b << 0);\n}\n\nstatic inline uint8_t //\nwuffs_base__color_u32_argb_premul__as__color_u8_gray(\n wuffs_base__color_u32_argb_premul c) {\n // Work in 16-bit color.\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same\n // as those given by the JFIF specification.\n //\n // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We\n //" +
" shift by 24, not just by 16, because the return value is 8-bit color, not\n // 16-bit color.\n uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768;\n return (uint8_t)(weighted_average >> 24);\n}\n\nstatic inline uint16_t //\nwuffs_base__color_u32_argb_premul__as__color_u16_gray(\n wuffs_base__color_u32_argb_premul c) {\n // Work in 16-bit color.\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same\n // as those given by the JFIF specification.\n //\n // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16).\n uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768;\n return (uint16_t)(weighted_average >> 16);\n}\n\n// wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul converts\n// from non-premultiplied alpha to premultiplied alpha.\nstatic inline wuffs_base__color_u32_argb_premul //\nwuf" +
"fs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n uint32_t argb_nonpremul) {\n // Multiplying by 0x101 (twice, once for alpha and once for color) converts\n // from 8-bit to 16-bit color. Shifting right by 8 undoes that.\n //\n // Working in the higher bit depth can produce slightly different (and\n // arguably slightly more accurate) results. For example, given 8-bit blue\n // and alpha of 0x80 and 0x81:\n //\n // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40\n // - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41\n uint32_t a = 0xFF & (argb_nonpremul >> 24);\n uint32_t a16 = a * (0x101 * 0x101);\n\n uint32_t r = 0xFF & (argb_nonpremul >> 16);\n r = ((r * a16) / 0xFFFF) >> 8;\n uint32_t g = 0xFF & (argb_nonpremul >> 8);\n g = ((g * a16) / 0xFFFF) >> 8;\n uint32_t b = 0xFF & (argb_nonpremul >> 0);\n b = ((b * a16) / 0xFFFF) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n// wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul converts\n// from premul" +
"tiplied alpha to non-premultiplied alpha.\nstatic inline uint32_t //\nwuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t a = 0xFF & (c >> 24);\n if (a == 0xFF) {\n return c;\n } else if (a == 0) {\n return 0;\n }\n uint32_t a16 = a * 0x101;\n\n uint32_t r = 0xFF & (c >> 16);\n r = ((r * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t g = 0xFF & (c >> 8);\n g = ((g * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t b = 0xFF & (c >> 0);\n b = ((b * (0x101 * 0xFFFF)) / a16) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n// wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul converts\n// from 4x16LE non-premultiplied alpha to 4x8 premultiplied alpha.\nstatic inline wuffs_base__color_u32_argb_premul //\nwuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n uint64_t argb_nonpremul) {\n uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48)));\n\n uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32)));\n r16 =" +
" (r16 * a16) / 0xFFFF;\n uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16)));\n g16 = (g16 * a16) / 0xFFFF;\n uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0)));\n b16 = (b16 * a16) / 0xFFFF;\n\n return ((a16 >> 8) << 24) | ((r16 >> 8) << 16) | ((g16 >> 8) << 8) |\n ((b16 >> 8) << 0);\n}\n\n// wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul converts\n// from 4x8 premultiplied alpha to 4x16LE non-premultiplied alpha.\nstatic inline uint64_t //\nwuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t a = 0xFF & (c >> 24);\n if (a == 0xFF) {\n uint64_t r16 = 0x101 * (0xFF & (c >> 16));\n uint64_t g16 = 0x101 * (0xFF & (c >> 8));\n uint64_t b16 = 0x101 * (0xFF & (c >> 0));\n return 0xFFFF000000000000u | (r16 << 32) | (g16 << 16) | (b16 << 0);\n } else if (a == 0) {\n return 0;\n }\n uint64_t a16 = a * 0x101;\n\n uint64_t r = 0xFF & (c >> 16);\n uint64_t r16 = (r * (0x101 * 0xFFFF)) / a16;\n uint64_t g = 0xFF" +
" & (c >> 8);\n uint64_t g16 = (g * (0x101 * 0xFFFF)) / a16;\n uint64_t b = 0xFF & (c >> 0);\n uint64_t b16 = (b * (0x101 * 0xFFFF)) / a16;\n\n return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__color_u32__as__color_u64(uint32_t c) {\n uint64_t a16 = 0x101 * (0xFF & (c >> 24));\n uint64_t r16 = 0x101 * (0xFF & (c >> 16));\n uint64_t g16 = 0x101 * (0xFF & (c >> 8));\n uint64_t b16 = 0x101 * (0xFF & (c >> 0));\n return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__color_u64__as__color_u32(uint64_t c) {\n uint32_t a = ((uint32_t)(0xFF & (c >> 56)));\n uint32_t r = ((uint32_t)(0xFF & (c >> 40)));\n uint32_t g = ((uint32_t)(0xFF & (c >> 24)));\n uint32_t b = ((uint32_t)(0xFF & (c >> 8)));\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n" +
"" +
"// --------\n\ntypedef uint8_t wuffs_base__pixel_blend;\n\n// wuffs_base__pixel_blend encodes how to blend source and destination pixels,\n// accounting for transparency. It encompasses the Porter-Duff compositing\n// operators as well as the other blending modes defined by PDF.\n//\n// TODO: implement the other modes.\n#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)\n#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)\n\n" +
"" +
"// --------\n\n// wuffs_base__pixel_alpha_transparency is a pixel format's alpha channel\n// model. It is a property of the pixel format in general, not of a specific\n// pixel. An RGBA pixel format (with alpha) can still have fully opaque pixels.\ntypedef uint32_t wuffs_base__pixel_alpha_transparency;\n\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__OPAQUE 0\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NONPREMULTIPLIED_ALPHA 1\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__PREMULTIPLIED_ALPHA 2\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__BINARY_ALPHA 3\n\n// Deprecated: use WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NONPREMULTIPLIED_ALPHA\n// instead.\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NON_PREMULTIPLIED_ALPHA 1\n\n" +
"" +
"// --------\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__INDEX_PLANE 0\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3\n\n// A palette is 256 entries × 4 bytes per entry (e.g. BGRA).\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data.\n//\n// See https://github.com/google/wuffs/blob/main/doc/note/pixel-formats.md\n//\n// Do not manipulate its bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef struct wuffs_base__pixel_format__struct {\n uint32_t repr;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n inline uint32_t bits_per_pixel() const;\n inline bool is_direct() const;\n inline bool is_indexed() const;\n inline bool is_interleaved() const;\n inline bool is_planar() const;\n inline uint32_t num_planes() const;\n inline wuffs_base__pixel_alpha_tran" +
"sparency transparency() const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_format;\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__make_pixel_format(uint32_t repr) {\n wuffs_base__pixel_format f;\n f.repr = repr;\n return f;\n}\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID 0x00000000\n\n#define WUFFS_BASE__PIXEL_FORMAT__A 0x02000008\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008\n#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B\n#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000008\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL 0x22000008\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCR 0x40020888\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCRA_NONPREMUL 0x41038888\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCRK 0x50038888\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCG 0x60020888\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCGA_NONPREMUL 0x61038888\n#define WUFFS" +
"_BASE__PIXEL_FORMAT__YCOCGK 0x70038888\n\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565\n#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB\n#define WUFFS_BASE__PIXEL_F" +
"ORMAT__RGBA_BINARY 0xA3008888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY 0xC0020888\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK 0xD0038888\n\nextern const uint32_t wuffs_base__pixel_format__bits_per_channel[16];\n\nstatic inline bool //\nwuffs_base__pixel_format__is_valid(const wuffs_base__pixel_format* f) {\n return f->repr != 0;\n}\n\n// wuffs_base__pixel_format__bits_per_pixel returns the number of bits per\n// pixel for interleaved pixel formats, and returns 0 for planar pixel formats.\nstatic inline uint32_t //\nwuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) {\n if (((f->repr >> 16) & 0x03) != 0) {\n return 0;\n }\n return wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 0)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 4)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 8)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 12)];\n}\n\nstatic inline bool //\n" +
"wuffs_base__pixel_format__is_direct(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 18) & 0x01) == 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 18) & 0x01) != 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_interleaved(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 16) & 0x03) == 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 16) & 0x03) != 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_format__num_planes(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 16) & 0x03) + 1;\n}\n\nstatic inline wuffs_base__pixel_alpha_transparency //\nwuffs_base__pixel_format__transparency(const wuffs_base__pixel_format* f) {\n return (wuffs_base__pixel_alpha_transparency)((f->repr >> 24) & 0x03);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__pixel_format::is_valid() const {\n return wuffs_base__pixel_format__is_valid(this);\n}\n\n" +
"inline uint32_t //\nwuffs_base__pixel_format::bits_per_pixel() const {\n return wuffs_base__pixel_format__bits_per_pixel(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_direct() const {\n return wuffs_base__pixel_format__is_direct(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_indexed() const {\n return wuffs_base__pixel_format__is_indexed(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_interleaved() const {\n return wuffs_base__pixel_format__is_interleaved(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_planar() const {\n return wuffs_base__pixel_format__is_planar(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_format::num_planes() const {\n return wuffs_base__pixel_format__num_planes(this);\n}\n\ninline wuffs_base__pixel_alpha_transparency //\nwuffs_base__pixel_format::transparency() const {\n return wuffs_base__pixel_format__transparency(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\n// wuffs_base__pixel_subsampling encodes whether sample values cover one pixel\n// or cover multiple pixels.\n//\n// See https://github.com/google/wuffs/blob/main/doc/note/pixel-subsampling.md\n//\n// Do not manipulate its bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef struct wuffs_base__pixel_subsampling__struct {\n uint32_t repr;\n\n#ifdef __cplusplus\n inline uint32_t bias_x(uint32_t plane) const;\n inline uint32_t denominator_x(uint32_t plane) const;\n inline uint32_t bias_y(uint32_t plane) const;\n inline uint32_t denominator_y(uint32_t plane) const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_subsampling;\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__make_pixel_subsampling(uint32_t repr) {\n wuffs_base__pixel_subsampling s;\n s.repr = repr;\n return s;\n}\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE 0x00000000\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 0x000000\n#define WUFFS_BASE__PIXEL_SUBSAMPLIN" +
"G__440 0x010100\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 0x101000\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 0x111100\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 0x303000\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 0x313100\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_x(const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s->repr >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_x(\n const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return ((s->repr >> shift) & 0x03) + 1;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_y(const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s->repr >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_y(\n con" +
"st wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return ((s->repr >> shift) & 0x03) + 1;\n}\n\n#ifdef __cplusplus\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::bias_x(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__bias_x(this, plane);\n}\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::denominator_x(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__denominator_x(this, plane);\n}\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::bias_y(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__bias_y(this, plane);\n}\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::denominator_y(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__denominator_y(this, plane);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__pixel_config__struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height);\n inline void invalidate();\n inline bool is_valid() const;\n inline wuffs_base__pixel_format pixel_format() const;\n inline wuffs_base__pixel_subsampling pixel_subsampling() const;\n inline wuffs_base__rect_ie_u32 bounds() const;\n inline uint32_t width() const;\n inline uint32_t height() const;\n inline uint64_t pixbuf_len() const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_config;\n\nstatic inline wuffs_base__pixel_config //\nwuffs_base__null_pixel_config() {\n wuffs_base__pixel_config ret;\n ret.private_im" +
"pl.pixfmt.repr = 0;\n ret.private_impl.pixsub.repr = 0;\n ret.private_impl.width = 0;\n ret.private_impl.height = 0;\n return ret;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__pixel_config__set(wuffs_base__pixel_config* c,\n uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height) {\n if (!c) {\n return;\n }\n if (pixfmt_repr) {\n uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n // TODO: handle things other than 1 byte per pixel.\n if (wh <= ((uint64_t)SIZE_MAX)) {\n c->private_impl.pixfmt.repr = pixfmt_repr;\n c->private_impl.pixsub.repr = pixsub_repr;\n c->private_impl.width = width;\n c->private_impl.height = height;\n return;\n }\n }\n\n c->private_impl.pixfmt.repr = 0;\n c->private_impl.pixsub.repr = 0;\n c->private_impl.width = 0;\n c->private_impl.height = 0;\n}\n\nstatic inline void " +
" //\nwuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {\n if (c) {\n c->private_impl.pixfmt.repr = 0;\n c->private_impl.pixsub.repr = 0;\n c->private_impl.width = 0;\n c->private_impl.height = 0;\n }\n}\n\nstatic inline bool //\nwuffs_base__pixel_config__is_valid(const wuffs_base__pixel_config* c) {\n return c && c->private_impl.pixfmt.repr;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_config__pixel_format(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixfmt : wuffs_base__make_pixel_format(0);\n}\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config__pixel_subsampling(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixsub : wuffs_base__make_pixel_subsampling(0);\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config__bounds(const wuffs_base__pixel_config* c) {\n if (c) {\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = c->private_impl.width;\n r" +
"et.max_excl_y = c->private_impl.height;\n return ret;\n }\n\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not interleaved) pixbufs? Should it\n// allow decoding into a color model different from the format's intrinsic one?\n// For example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t //\nwuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) {\n if (!c) {\n return 0;\n }\n if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return 0;\n }\n uint32_t bits_per" +
"_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return 0;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t n =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n if (n > (UINT64_MAX / bytes_per_pixel)) {\n return 0;\n }\n n *= bytes_per_pixel;\n\n if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) {\n if (n >\n (UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) {\n return 0;\n }\n n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n }\n\n return n;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__pixel_config::set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt_repr, pixsub_" +
"repr, width, height);\n}\n\ninline void //\nwuffs_base__pixel_config::invalidate() {\n wuffs_base__pixel_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__pixel_config::is_valid() const {\n return wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_config::pixel_format() const {\n return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config::pixel_subsampling() const {\n return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config::bounds() const {\n return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::width() const {\n return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::height() const {\n return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t //\nwuffs_base__pixel_config::pixbuf_len() const {\n return wuffs_base__pixel_config__pixbuf_len(this);" +
"\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__image_config__struct {\n wuffs_base__pixel_config pixcfg;\n\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n uint64_t first_frame_io_position;\n bool first_frame_is_opaque;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque);\n inline void invalidate();\n inline bool is_valid() const;\n inline uint64_t first_frame_io_position() const;\n inline bool first_frame_is_opaque() const;\n#endif // __cplusplus\n\n} wuffs_base__image_config;\n\nstatic inline wuffs_base__image_config //\nwuffs_base__null_image_config() {\n wuffs_base__image_config ret;\n ret.pixcfg = wuffs_base__null_pixel_config();\n ret.private_impl.first_frame_io_position = 0;\n ret.private_im" +
"pl.first_frame_is_opaque = false;\n return ret;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__image_config__set(wuffs_base__image_config* c,\n uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n if (!c) {\n return;\n }\n if (pixfmt_repr) {\n c->pixcfg.private_impl.pixfmt.repr = pixfmt_repr;\n c->pixcfg.private_impl.pixsub.repr = pixsub_repr;\n c->pixcfg.private_impl.width = width;\n c->pixcfg.private_impl.height = height;\n c->private_impl.first_frame_io_position = first_frame_io_position;\n c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n\n c->pixcfg.private_impl.pixfmt.repr = 0;\n c->pixcfg.private_impl.pixsub.repr = 0;\n c->pixcfg.private_impl.width" +
" = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n}\n\nstatic inline void //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n if (c) {\n c->pixcfg.private_impl.pixfmt.repr = 0;\n c->pixcfg.private_impl.pixsub.repr = 0;\n c->pixcfg.private_impl.width = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n }\n}\n\nstatic inline bool //\nwuffs_base__image_config__is_valid(const wuffs_base__image_config* c) {\n return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t //\nwuffs_base__image_config__first_frame_io_position(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool //\nwuffs_base__image_config__first_frame_is_opaque(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaque : false;\n}" +
"\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__image_config::set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__set(this, pixfmt_repr, pixsub_repr, width, height,\n first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void //\nwuffs_base__image_config::invalidate() {\n wuffs_base__image_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__image_config::is_valid() const {\n return wuffs_base__image_config__is_valid(this);\n}\n\ninline uint64_t //\nwuffs_base__image_config::first_frame_io_position() const {\n return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool //\nwuffs_base__image_config::first_frame_is_opaque() const {\n return wuffs_base__image_config__first_frame_is_opaque(t" +
"his);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\n// wuffs_base__animation_disposal encodes, for an animated image, how to\n// dispose of a frame after displaying it:\n// - None means to draw the next frame on top of this one.\n// - Restore Background means to clear the frame's dirty rectangle to \"the\n// background color\" (in practice, this means transparent black) before\n// drawing the next frame.\n// - Restore Previous means to undo the current frame, so that the next frame\n// is drawn on top of the previous one.\ntypedef uint8_t wuffs_base__animation_disposal;\n\n#define WUFFS_BASE__ANIMATION_DISPOSAL__NONE ((wuffs_base__animation_disposal)0)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND \\\n ((wuffs_base__animation_disposal)1)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS \\\n ((wuffs_base__animation_disposal)2)\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__frame_config__struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__rect_ie_u32 bounds;\n wuffs_base__flicks duration;\n uint64_t index;\n uint64_t io_position;\n wuffs_base__animation_disposal disposal;\n bool opaque_within_bounds;\n bool overwrite_instead_of_blend;\n wuffs_base__color_u32_argb_premul background_color;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_disposal disposal,\n bool opaque_within_bounds,\n bool overwrite_instead_of_blend,\n wuffs_base__color_u32_argb_premul background_color);\n inline wuffs_base__rect_ie_u32 bounds() const;\n inline uint32_t width() const;\n inline uint32_t hei" +
"ght() const;\n inline wuffs_base__flicks duration() const;\n inline uint64_t index() const;\n inline uint64_t io_position() const;\n inline wuffs_base__animation_disposal disposal() const;\n inline bool opaque_within_bounds() const;\n inline bool overwrite_instead_of_blend() const;\n inline wuffs_base__color_u32_argb_premul background_color() const;\n#endif // __cplusplus\n\n} wuffs_base__frame_config;\n\nstatic inline wuffs_base__frame_config //\nwuffs_base__null_frame_config() {\n wuffs_base__frame_config ret;\n ret.private_impl.bounds = wuffs_base__make_rect_ie_u32(0, 0, 0, 0);\n ret.private_impl.duration = 0;\n ret.private_impl.index = 0;\n ret.private_impl.io_position = 0;\n ret.private_impl.disposal = 0;\n ret.private_impl.opaque_within_bounds = false;\n ret.private_impl.overwrite_instead_of_blend = false;\n return ret;\n}\n\nstatic inline void //\nwuffs_base__frame_config__set(\n wuffs_base__frame_config* c,\n wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_" +
"t io_position,\n wuffs_base__animation_disposal disposal,\n bool opaque_within_bounds,\n bool overwrite_instead_of_blend,\n wuffs_base__color_u32_argb_premul background_color) {\n if (!c) {\n return;\n }\n\n c->private_impl.bounds = bounds;\n c->private_impl.duration = duration;\n c->private_impl.index = index;\n c->private_impl.io_position = io_position;\n c->private_impl.disposal = disposal;\n c->private_impl.opaque_within_bounds = opaque_within_bounds;\n c->private_impl.overwrite_instead_of_blend = overwrite_instead_of_blend;\n c->private_impl.background_color = background_color;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config__bounds(const wuffs_base__frame_config* c) {\n if (c) {\n return c->private_impl.bounds;\n }\n\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__width(const wuffs_base__frame_config* c) {\n return c ? wuffs_base__re" +
"ct_ie_u32__width(&c->private_impl.bounds) : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__height(const wuffs_base__frame_config* c) {\n return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0;\n}\n\n// wuffs_base__frame_config__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks //\nwuffs_base__frame_config__duration(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.duration : 0;\n}\n\n// wuffs_base__frame_config__index returns the index of this frame. The first\n// frame in an image has index 0, the second frame has index 1, and so on.\nstatic inline uint64_t //\nwuffs_base__frame_config__index(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.index : 0;\n}\n\n// wuffs_base__frame_config__io_position returns the I/O stream position before\n// the frame config.\nstatic inline uint64_t //\nwuffs_base__frame_config__io_position(const wuffs_base__frame_config* c" +
") {\n return c ? c->private_impl.io_position : 0;\n}\n\n// wuffs_base__frame_config__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal //\nwuffs_base__frame_config__disposal(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.disposal : 0;\n}\n\n// wuffs_base__frame_config__opaque_within_bounds returns whether all pixels\n// within the frame's bounds are fully opaque. It makes no claim about pixels\n// outside the frame bounds but still inside the overall image. The two\n// bounding rectangles can differ for animated images.\n//\n// Its semantics are conservative. It is valid for a fully opaque frame to have\n// this value be false: a false negative.\n//\n// If true, drawing the frame with WUFFS_BASE__PIXEL_BLEND__SRC and\n// WUFFS_BASE__PIXEL_BLEND__SRC_OVER should be equivalent, in terms of\n// resultant pixels, but the former may be faster.\nstatic inline bool //\nwuffs_base__frame_config__opaque_within_bounds(\n const " +
"wuffs_base__frame_config* c) {\n return c && c->private_impl.opaque_within_bounds;\n}\n\n// wuffs_base__frame_config__overwrite_instead_of_blend returns, for an\n// animated image, whether to ignore the previous image state (within the frame\n// bounds) when drawing this incremental frame. Equivalently, whether to use\n// WUFFS_BASE__PIXEL_BLEND__SRC instead of WUFFS_BASE__PIXEL_BLEND__SRC_OVER.\n//\n// The WebP spec (https://developers.google.com/speed/webp/docs/riff_container)\n// calls this the \"Blending method\" bit. WebP's \"Do not blend\" corresponds to\n// Wuffs' \"overwrite_instead_of_blend\".\nstatic inline bool //\nwuffs_base__frame_config__overwrite_instead_of_blend(\n const wuffs_base__frame_config* c) {\n return c && c->private_impl.overwrite_instead_of_blend;\n}\n\nstatic inline wuffs_base__color_u32_argb_premul //\nwuffs_base__frame_config__background_color(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.background_color : 0;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__frame_config::set" +
"(\n wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_disposal disposal,\n bool opaque_within_bounds,\n bool overwrite_instead_of_blend,\n wuffs_base__color_u32_argb_premul background_color) {\n wuffs_base__frame_config__set(this, bounds, duration, index, io_position,\n disposal, opaque_within_bounds,\n overwrite_instead_of_blend, background_color);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config::bounds() const {\n return wuffs_base__frame_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::width() const {\n return wuffs_base__frame_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::height() const {\n return wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks //\nwuffs_base__frame_config::duration() const {\n return wuffs_base__frame_config__duration(this);\n}\n\ninline uint64_t //\nwuffs_b" +
"ase__frame_config::index() const {\n return wuffs_base__frame_config__index(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::io_position() const {\n return wuffs_base__frame_config__io_position(this);\n}\n\ninline wuffs_base__animation_disposal //\nwuffs_base__frame_config::disposal() const {\n return wuffs_base__frame_config__disposal(this);\n}\n\ninline bool //\nwuffs_base__frame_config::opaque_within_bounds() const {\n return wuffs_base__frame_config__opaque_within_bounds(this);\n}\n\ninline bool //\nwuffs_base__frame_config::overwrite_instead_of_blend() const {\n return wuffs_base__frame_config__overwrite_instead_of_blend(this);\n}\n\ninline wuffs_base__color_u32_argb_premul //\nwuffs_base__frame_config::background_color() const {\n return wuffs_base__frame_config__background_color(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__pixel_buffer__struct {\n wuffs_base__pixel_config pixcfg;\n\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n // TODO: color spaces.\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_interleaved(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 primary_memory,\n wuffs_base__slice_u8 palette_memory);\n inline wuffs_base__status set_from_slice(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline wuffs_base__status set_from_table(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 primary_memory);\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__slice_u8 palette_or_else(wuffs_base__slice_u8 fallback);\n inline wuffs_base__pixel_format pixel_format() const;\n inline wuffs_base__table" +
"_u8 plane(uint32_t p);\n inline wuffs_base__color_u32_argb_premul color_u32_at(uint32_t x,\n uint32_t y) const;\n inline wuffs_base__status set_color_u32_at(\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color);\n inline wuffs_base__status set_color_u32_fill_rect(\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color);\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__pixel_buffer //\nwuffs_base__null_pixel_buffer() {\n wuffs_base__pixel_buffer ret;\n ret.pixcfg = wuffs_base__null_pixel_config();\n ret.private_impl.planes[0] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[1] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[2] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[3] = wuffs_base__empty_table_u8();\n return ret;\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_interleaved(\n wuffs_base__pixel_buffer* pb,\n co" +
"nst wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 primary_memory,\n wuffs_base__slice_u8 palette_memory) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(pb, 0, sizeof(*pb));\n if (!pixcfg ||\n wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) &&\n (palette_memory.len <\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per" +
"_pixel / 8;\n\n uint64_t width_in_bytes =\n ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;\n if ((width_in_bytes > primary_memory.width) ||\n (pixcfg->private_impl.height > primary_memory.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n pb->pixcfg = *pixcfg;\n pb->private_impl.planes[0] = primary_memory;\n if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = palette_memory.ptr;\n tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n tab->height = 1;\n tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n }\n return wuffs_base__make_status(NULL);\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* pb,\n const wuffs_base__pixel_config* pixcfg,\n " +
" wuffs_base__slice_u8 pixbuf_memory) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(pb, 0, sizeof(*pb));\n if (!pixcfg) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint8_t* ptr = pixbuf_memory.ptr;\n uint64_t len = pixbuf_memory.len;\n if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) {\n // Split a WU" +
"FFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH byte\n // chunk (1024 bytes = 256 palette entries × 4 bytes per entry) from the\n // start of pixbuf_memory. We split from the start, not the end, so that\n // the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n tab->height = 1;\n tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n }\n\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n " +
" ((uint64_t)pixcfg->private_impl.height);\n size_t width = (size_t)(pixcfg->private_impl.width);\n if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n (width > (SIZE_MAX / bytes_per_pixel))) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n wh *= bytes_per_pixel;\n width = ((size_t)(width * bytes_per_pixel));\n if (wh > len) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n\n pb->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &pb->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = width;\n return wuffs_base__make_status(NULL);\n}\n\n// Deprecated: does not handle indexed pixel configurations. Use\n// wuffs_base__pixel_buffer__set_interleaved instead.\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* pb,\n const wuffs_base__pixel_config* pixcfg,\n " +
" wuffs_base__table_u8 primary_memory) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(pb, 0, sizeof(*pb));\n if (!pixcfg ||\n wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) ||\n wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t width_in_bytes =\n ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;\n if ((width_in_bytes > primary_memory.width) ||\n (pixcfg->private_impl.height > primary_memory.height)) {\n return wuffs_base__make_status(" +
"wuffs_base__error__bad_argument);\n }\n\n pb->pixcfg = *pixcfg;\n pb->private_impl.planes[0] = primary_memory;\n return wuffs_base__make_status(NULL);\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it will have length\n// WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) {\n if (pb &&\n wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width ==\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) &&\n (tab->height == 1)) {\n return wuffs_base__make_slice_u8(\n tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH);\n }\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette_or_else(wuffs" +
"_base__pixel_buffer* pb,\n wuffs_base__slice_u8 fallback) {\n if (pb &&\n wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width ==\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) &&\n (tab->height == 1)) {\n return wuffs_base__make_slice_u8(\n tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH);\n }\n }\n return fallback;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer__pixel_format(const wuffs_base__pixel_buffer* pb) {\n if (pb) {\n return pb->pixcfg.private_impl.pixfmt;\n }\n return wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__INVALID);\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* pb, uint32_t p) {\n if (pb && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) {\n " +
" return pb->private_impl.planes[p];\n }\n\n wuffs_base__table_u8 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //\nwuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y);\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_at(\n wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color);\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color);\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_interleaved(\n const wuffs_base__pixel_config* pixcfg_arg,\n wuffs_base__table_u8 primary_memory,\n wuffs_base__slice_" +
"u8 palette_memory) {\n return wuffs_base__pixel_buffer__set_interleaved(\n this, pixcfg_arg, primary_memory, palette_memory);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(\n const wuffs_base__pixel_config* pixcfg_arg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg_arg,\n pixbuf_memory);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_table(\n const wuffs_base__pixel_config* pixcfg_arg,\n wuffs_base__table_u8 primary_memory) {\n return wuffs_base__pixel_buffer__set_from_table(this, pixcfg_arg,\n primary_memory);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette_or_else(wuffs_base__slice_u8 fallback) {\n return wuffs_base__pixel_buffer__palette_or_else(this, fall" +
"back);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer::pixel_format() const {\n return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\ninline wuffs_base__color_u32_argb_premul //\nwuffs_base__pixel_buffer::color_u32_at(uint32_t x, uint32_t y) const {\n return wuffs_base__pixel_buffer__color_u32_at(this, x, y);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color);\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_color_u32_at(\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color) {\n return wuffs_base__pixel_buffer__set_color_u32_at(this, x, y, color);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_color_u32_fill_rect(\n wuffs_base__rect_ie_u32 rect,\n " +
" wuffs_base__color_u32_argb_premul color) {\n return wuffs_base__pixel_buffer__set_color_u32_fill_rect(this, rect, color);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__decode_frame_options__struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n uint8_t TODO;\n } private_impl;\n\n#ifdef __cplusplus\n#endif // __cplusplus\n\n} wuffs_base__decode_frame_options;\n\n#ifdef __cplusplus\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\n// wuffs_base__pixel_palette__closest_element returns the index of the palette\n// element that minimizes the sum of squared differences of the four ARGB\n// channels, working in premultiplied alpha. Ties favor the smaller index.\n//\n// The palette_slice.len may equal (N*4), for N less than 256, which means that\n// only the first N palette elements are considered. It returns 0 when N is 0.\n//\n// Applying this function on a per-pixel basis will not produce whole-of-image\n// dithering.\nWUFFS_BASE__MAYBE_STATIC uint8_t //\nwuffs_base__pixel_palette__closest_element(\n wuffs_base__slice_u8 palette_slice,\n wuffs_base__pixel_format palette_format,\n wuffs_base__color_u32_argb_premul c);\n\n" +
"" +
"// --------\n\n// TODO: should the func type take restrict pointers?\ntypedef uint64_t (*wuffs_base__pixel_swizzler__func)(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\ntypedef uint64_t (*wuffs_base__pixel_swizzler__transparent_black_func)(\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\ntypedef struct wuffs_base__pixel_swizzler__struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_swizzler__func func;\n wuffs_base__pixel_swizzler__transpa" +
"rent_black_func transparent_black_func;\n uint32_t dst_pixfmt_bytes_per_pixel;\n uint32_t src_pixfmt_bytes_per_pixel;\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status prepare(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 inline uint64_t swizzle_interleaved_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_swizzler;\n\n// wuffs_base__pixel_swizzler__prepare readies the pixel swizzler so that its\n// other methods may be called.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__PIXCONV sub-module, not\n// just WUFFS_CONFIG__MOD" +
"ULE__BASE__CORE.\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\n// wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice converts pixels\n// from a source format to a destination format.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__PIXCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n " +
" wuffs_base__slice_u8 src);\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_swizzler::prepare(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 return wuffs_base__pixel_swizzler__prepare(this, dst_pixfmt, dst_palette,\n src_pixfmt, src_palette, blend);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler::swizzle_interleaved_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) const {\n return wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(\n this, dst, dst_palette, src);\n}\n\n#endif // __cplusplus\n" +
""
const BaseIOPrivateH = "" +
"// ---------------- I/O\n\nstatic inline uint64_t //\nwuffs_base__io__count_since(uint64_t mark, uint64_t index) {\n if (index >= mark) {\n return index - mark;\n }\n return 0;\n}\n\n// TODO: drop the \"const\" in \"const uint8_t* ptr\". Some though required about\n// the base.io_reader.since method returning a mutable \"slice base.u8\".\n#if defined(__GNUC__)\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wcast-qual\"\n#endif\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__io__since(uint64_t mark, uint64_t index, const uint8_t* ptr) {\n if (index >= mark) {\n return wuffs_base__make_slice_u8(((uint8_t*)ptr) + mark,\n ((size_t)(index - mark)));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n#if defined(__GNUC__)\n#pragma GCC diagnostic pop\n#endif\n\n" +
"" +
"// --------\n\nstatic inline void //\nwuffs_base__io_reader__limit(const uint8_t** ptr_io2_r,\n const uint8_t* iop_r,\n uint64_t limit) {\n if (((uint64_t)(*ptr_io2_r - iop_r)) > limit) {\n *ptr_io2_r = iop_r + limit;\n }\n}\n\nstatic inline uint32_t //\nwuffs_base__io_reader__limited_copy_u32_to_slice(const uint8_t** ptr_iop_r,\n const uint8_t* io2_r,\n uint32_t length,\n wuffs_base__slice_u8 dst) {\n const uint8_t* iop_r = *ptr_iop_r;\n size_t n = dst.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(io2_r - iop_r))) {\n n = (size_t)(io2_r - iop_r);\n }\n if (n > 0) {\n memmove(dst.ptr, iop_r, n);\n *ptr_iop_r += n;\n }\n return (uint32_t)(n);\n}\n\n// wuffs_base__io_reader__match7 returns whether the io_reader's upcoming bytes\n// start with the given prefix (up to 7 bytes long). It is peek-like, not\n" +
"// read-like, in that there are no side-effects.\n//\n// The low 3 bits of a hold the prefix length, n.\n//\n// The high 56 bits of a hold the prefix itself, in little-endian order. The\n// first prefix byte is in bits 8..=15, the second prefix byte is in bits\n// 16..=23, etc. The high (8 * (7 - n)) bits are ignored.\n//\n// There are three possible return values:\n// - 0 means success.\n// - 1 means inconclusive, equivalent to \"$short read\".\n// - 2 means failure.\nstatic inline uint32_t //\nwuffs_base__io_reader__match7(const uint8_t* iop_r,\n const uint8_t* io2_r,\n wuffs_base__io_buffer* r,\n uint64_t a) {\n uint32_t n = a & 7;\n a >>= 8;\n if ((io2_r - iop_r) >= 8) {\n uint64_t x = wuffs_base__peek_u64le__no_bounds_check(iop_r);\n uint32_t shift = 8 * (8 - n);\n return ((a << shift) == (x << shift)) ? 0 : 2;\n }\n for (; n > 0; n--) {\n if (iop_r >= io2_r) {\n return (r && r->meta.closed) ? 2 : 1;\n } else if (*iop_" +
"r != ((uint8_t)(a))) {\n return 2;\n }\n iop_r++;\n a >>= 8;\n }\n return 0;\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_reader__set(wuffs_base__io_buffer* b,\n const uint8_t** ptr_iop_r,\n const uint8_t** ptr_io0_r,\n const uint8_t** ptr_io1_r,\n const uint8_t** ptr_io2_r,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = data.len;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_r = data.ptr;\n *ptr_io0_r = data.ptr;\n *ptr_io1_r = data.ptr;\n *ptr_io2_r = data.ptr + data.len;\n\n return b;\n}\n\n" +
"" +
"// --------\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_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" +
""
const BaseIOPublicH = "" +
"// ---------------- I/O\n//\n// See (/doc/note/io-input-output.md).\n\n// wuffs_base__io_buffer_meta is the metadata for a wuffs_base__io_buffer's\n// data.\ntypedef struct wuffs_base__io_buffer_meta__struct {\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n uint64_t pos; // Buffer position (relative to the start of stream).\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer_meta;\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus\n// additional metadata.\n//\n// A value with all fields zero is a valid, empty buffer.\ntypedef struct wuffs_base__io_buffer__struct {\n wuffs_base__slice_u8 data;\n wuffs_base__io_buffer_meta meta;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n inline void compact();\n inline size_t reader_length() const;\n inline uint8_t* reader_pointer() const;\n inline uint64_t reader_position() const;\n inline wuffs_base__slice_u8 reader_slice() const;\n inline size_t writer_length" +
"() const;\n inline uint8_t* writer_pointer() const;\n inline uint64_t writer_position() const;\n inline wuffs_base__slice_u8 writer_slice() const;\n\n // Deprecated: use reader_position.\n inline uint64_t reader_io_position() const;\n // Deprecated: use writer_position.\n inline uint64_t writer_io_position() const;\n#endif // __cplusplus\n\n} wuffs_base__io_buffer;\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__make_io_buffer(wuffs_base__slice_u8 data,\n wuffs_base__io_buffer_meta meta) {\n wuffs_base__io_buffer ret;\n ret.data = data;\n ret.meta = meta;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer_meta //\nwuffs_base__make_io_buffer_meta(size_t wi,\n size_t ri,\n uint64_t pos,\n bool closed) {\n wuffs_base__io_buffer_meta ret;\n ret.wi = wi;\n ret.ri = ri;\n ret.pos = pos;\n ret.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__ptr_u8__reader(uint8_" +
"t* ptr, size_t len, bool closed) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = ptr;\n ret.data.len = len;\n ret.meta.wi = len;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__ptr_u8__writer(uint8_t* ptr, size_t len) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = ptr;\n ret.data.len = len;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__slice_u8__reader(wuffs_base__slice_u8 s, bool closed) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data.len = s.len;\n ret.meta.wi = s.len;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__slice_u8__writer(wuffs_base__slice_u8 s) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data.len = s.len;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed =" +
" false;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__empty_io_buffer() {\n wuffs_base__io_buffer ret;\n ret.data.ptr = NULL;\n ret.data.len = 0;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer_meta //\nwuffs_base__empty_io_buffer_meta() {\n wuffs_base__io_buffer_meta ret;\n ret.wi = 0;\n ret.ri = 0;\n ret.pos = 0;\n ret.closed = false;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__io_buffer__is_valid(const wuffs_base__io_buffer* buf) {\n if (buf) {\n if (buf->data.ptr) {\n return (buf->meta.ri <= buf->meta.wi) && (buf->meta.wi <= buf->data.len);\n } else {\n return (buf->meta.ri == 0) && (buf->meta.wi == 0) && (buf->data.len == 0);\n }\n }\n return false;\n}\n\n// wuffs_base__io_buffer__compact moves any written but unread bytes to the\n// start of the buffer.\nstatic inline void //\nwuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {\n if (!buf || (buf->meta.ri == 0)) {\n " +
" return;\n }\n buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri);\n size_t n = buf->meta.wi - buf->meta.ri;\n if (n != 0) {\n memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n);\n }\n buf->meta.wi = n;\n buf->meta.ri = 0;\n}\n\n// Deprecated. Use wuffs_base__io_buffer__reader_position.\nstatic inline uint64_t //\nwuffs_base__io_buffer__reader_io_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline size_t //\nwuffs_base__io_buffer__reader_length(const wuffs_base__io_buffer* buf) {\n return buf ? buf->meta.wi - buf->meta.ri : 0;\n}\n\nstatic inline uint8_t* //\nwuffs_base__io_buffer__reader_pointer(const wuffs_base__io_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta.ri) : NULL;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__reader_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs" +
"_base__io_buffer__reader_slice(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__make_slice_u8(buf->data.ptr + buf->meta.ri,\n buf->meta.wi - buf->meta.ri)\n : wuffs_base__empty_slice_u8();\n}\n\n// Deprecated. Use wuffs_base__io_buffer__writer_position.\nstatic inline uint64_t //\nwuffs_base__io_buffer__writer_io_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\nstatic inline size_t //\nwuffs_base__io_buffer__writer_length(const wuffs_base__io_buffer* buf) {\n return buf ? buf->data.len - buf->meta.wi : 0;\n}\n\nstatic inline uint8_t* //\nwuffs_base__io_buffer__writer_pointer(const wuffs_base__io_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta.wi) : NULL;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__writer_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\nstatic inline wuffs_base__slice_u8 //\nw" +
"uffs_base__io_buffer__writer_slice(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__make_slice_u8(buf->data.ptr + buf->meta.wi,\n buf->data.len - buf->meta.wi)\n : wuffs_base__empty_slice_u8();\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__io_buffer::is_valid() const {\n return wuffs_base__io_buffer__is_valid(this);\n}\n\ninline void //\nwuffs_base__io_buffer::compact() {\n wuffs_base__io_buffer__compact(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::reader_io_position() const {\n return wuffs_base__io_buffer__reader_io_position(this);\n}\n\ninline size_t //\nwuffs_base__io_buffer::reader_length() const {\n return wuffs_base__io_buffer__reader_length(this);\n}\n\ninline uint8_t* //\nwuffs_base__io_buffer::reader_pointer() const {\n return wuffs_base__io_buffer__reader_pointer(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::reader_position() const {\n return wuffs_base__io_buffer__reader_position(this);\n}\n\ninline wuffs_base__slice_u8 //\nwu" +
"ffs_base__io_buffer::reader_slice() const {\n return wuffs_base__io_buffer__reader_slice(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::writer_io_position() const {\n return wuffs_base__io_buffer__writer_io_position(this);\n}\n\ninline size_t //\nwuffs_base__io_buffer::writer_length() const {\n return wuffs_base__io_buffer__writer_length(this);\n}\n\ninline uint8_t* //\nwuffs_base__io_buffer::writer_pointer() const {\n return wuffs_base__io_buffer__writer_pointer(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::writer_position() const {\n return wuffs_base__io_buffer__writer_position(this);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__io_buffer::writer_slice() const {\n return wuffs_base__io_buffer__writer_slice(this);\n}\n\n#endif // __cplusplus\n" +
""
const BaseRangePrivateH = "" +
"// ---------------- Ranges and Rects\n\nstatic inline uint32_t //\nwuffs_base__range_ii_u32__get_min_incl(const wuffs_base__range_ii_u32* r) {\n return r->min_incl;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ii_u32__get_max_incl(const wuffs_base__range_ii_u32* r) {\n return r->max_incl;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__get_min_incl(const wuffs_base__range_ie_u32* r) {\n return r->min_incl;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__get_max_excl(const wuffs_base__range_ie_u32* r) {\n return r->max_excl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ii_u64__get_min_incl(const wuffs_base__range_ii_u64* r) {\n return r->min_incl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ii_u64__get_max_incl(const wuffs_base__range_ii_u64* r) {\n return r->max_incl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ie_u64__get_min_incl(const wuffs_base__range_ie_u64* r) {\n return r->min_incl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ie_u64__get_max_excl(const wuffs_base__range_" +
"ie_u64* r) {\n return r->max_excl;\n}\n\n" +
"" +
"// ---------------- Ranges and Rects (Utility)\n\n#define wuffs_base__utility__empty_range_ii_u32 wuffs_base__empty_range_ii_u32\n#define wuffs_base__utility__empty_range_ie_u32 wuffs_base__empty_range_ie_u32\n#define wuffs_base__utility__empty_range_ii_u64 wuffs_base__empty_range_ii_u64\n#define wuffs_base__utility__empty_range_ie_u64 wuffs_base__empty_range_ie_u64\n#define wuffs_base__utility__empty_rect_ii_u32 wuffs_base__empty_rect_ii_u32\n#define wuffs_base__utility__empty_rect_ie_u32 wuffs_base__empty_rect_ie_u32\n#define wuffs_base__utility__make_range_ii_u32 wuffs_base__make_range_ii_u32\n#define wuffs_base__utility__make_range_ie_u32 wuffs_base__make_range_ie_u32\n#define wuffs_base__utility__make_range_ii_u64 wuffs_base__make_range_ii_u64\n#define wuffs_base__utility__make_range_ie_u64 wuffs_base__make_range_ie_u64\n#define wuffs_base__utility__make_rect_ii_u32 wuffs_base__make_rect_ii_u32\n#define wuffs_base__utility__make_rect_ie_u32 wuffs_base__make_rect_ie_u32\n" +
""
const BaseRangePublicH = "" +
"// ---------------- Ranges and Rects\n\n// See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md\n\ntypedef struct wuffs_base__range_ii_u32__struct {\n uint32_t min_incl;\n uint32_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ii_u32__struct s) const;\n inline wuffs_base__range_ii_u32__struct intersect(\n wuffs_base__range_ii_u32__struct s) const;\n inline wuffs_base__range_ii_u32__struct unite(\n wuffs_base__range_ii_u32__struct s) const;\n inline bool contains(uint32_t x) const;\n inline bool contains_range(wuffs_base__range_ii_u32__struct s) const;\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u32;\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__empty_range_ii_u32() {\n wuffs_base__range_ii_u32 ret;\n ret.min_incl = 0;\n ret.max_incl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__make_range_ii_u32(uint32_t min_incl, uint32_t max_incl) {\n wuffs_base__range_ii_u32 ret;\n ret.min_incl = min" +
"_incl;\n ret.max_incl = max_incl;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__is_empty(const wuffs_base__range_ii_u32* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__equals(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32__intersect(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32__unite(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii" +
"_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__max(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__contains(const wuffs_base__range_ii_u32* r,\n uint32_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__contains_range(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__equals(\n &s, wuffs_base__range_ii_u32__intersect(r, s));\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u32::is_empty() const {\n return wuffs_base__range_ii_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_" +
"ii_u32__equals(this, s);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_ii_u32__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::contains(uint32_t x) const {\n return wuffs_base__range_ii_u32__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::contains_range(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_ii_u32__contains_range(this, s);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__range_ie_u32__struct {\n uint32_t min_incl;\n uint32_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ie_u32__struct s) const;\n inline wuffs_base__range_ie_u32__struct intersect(\n wuffs_base__range_ie_u32__struct s) const;\n inline wuffs_base__range_ie_u32__struct unite(\n wuffs_base__range_ie_u32__struct s) const;\n inline bool contains(uint32_t x) const;\n inline bool contains_range(wuffs_base__range_ie_u32__struct s) const;\n inline uint32_t length() const;\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u32;\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__empty_range_ie_u32() {\n wuffs_base__range_ie_u32 ret;\n ret.min_incl = 0;\n ret.max_excl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__make_range_ie_u32(uint32_t min_incl, uint32_t max_excl) {\n wuffs_base__range_ie_u32 ret;\n ret.min_incl = min_incl;\n ret.max_excl = max_excl;\n return ret;\n}\n\nstatic inline bool " +
" //\nwuffs_base__range_ie_u32__is_empty(const wuffs_base__range_ie_u32* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__equals(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u32__is_empty(r) &&\n wuffs_base__range_ie_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__intersect(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__unite(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n if (wuffs_base__range_ie_u32__is_empty(r)) {\n return s" +
";\n }\n if (wuffs_base__range_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__contains(const wuffs_base__range_ie_u32* r,\n uint32_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__contains_range(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__equals(\n &s, wuffs_base__range_ie_u32__intersect(r, s));\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__length(const wuffs_base__range_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ie_u32::is_empty() const {\n return wuffs_base__range_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs" +
"_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__equals(this, s);\n}\n\ninline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32::intersect(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32::unite(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ie_u32::contains(uint32_t x) const {\n return wuffs_base__range_ie_u32__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ie_u32::contains_range(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__contains_range(this, s);\n}\n\ninline uint32_t //\nwuffs_base__range_ie_u32::length() const {\n return wuffs_base__range_ie_u32__length(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__range_ii_u64__struct {\n uint64_t min_incl;\n uint64_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ii_u64__struct s) const;\n inline wuffs_base__range_ii_u64__struct intersect(\n wuffs_base__range_ii_u64__struct s) const;\n inline wuffs_base__range_ii_u64__struct unite(\n wuffs_base__range_ii_u64__struct s) const;\n inline bool contains(uint64_t x) const;\n inline bool contains_range(wuffs_base__range_ii_u64__struct s) const;\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u64;\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__empty_range_ii_u64() {\n wuffs_base__range_ii_u64 ret;\n ret.min_incl = 0;\n ret.max_incl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__make_range_ii_u64(uint64_t min_incl, uint64_t max_incl) {\n wuffs_base__range_ii_u64 ret;\n ret.min_incl = min_incl;\n ret.max_incl = max_incl;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__is_e" +
"mpty(const wuffs_base__range_ii_u64* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__equals(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u64__is_empty(r) &&\n wuffs_base__range_ii_u64__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64__intersect(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64__unite(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n if (wuffs_base__range_ii_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u6" +
"4__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__max(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__contains(const wuffs_base__range_ii_u64* r,\n uint64_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__contains_range(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_ii_u64__equals(\n &s, wuffs_base__range_ii_u64__intersect(r, s));\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u64::is_empty() const {\n return wuffs_base__range_ii_u64__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__equals(this, s);\n}\n\ninline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64::intersect(wuff" +
"s_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64::unite(wuffs_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u64::contains(uint64_t x) const {\n return wuffs_base__range_ii_u64__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ii_u64::contains_range(wuffs_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__contains_range(this, s);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__range_ie_u64__struct {\n uint64_t min_incl;\n uint64_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ie_u64__struct s) const;\n inline wuffs_base__range_ie_u64__struct intersect(\n wuffs_base__range_ie_u64__struct s) const;\n inline wuffs_base__range_ie_u64__struct unite(\n wuffs_base__range_ie_u64__struct s) const;\n inline bool contains(uint64_t x) const;\n inline bool contains_range(wuffs_base__range_ie_u64__struct s) const;\n inline uint64_t length() const;\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u64;\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__empty_range_ie_u64() {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = 0;\n ret.max_excl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__make_range_ie_u64(uint64_t min_incl, uint64_t max_excl) {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = min_incl;\n ret.max_excl = max_excl;\n return ret;\n}\n\nstatic inline bool " +
" //\nwuffs_base__range_ie_u64__is_empty(const wuffs_base__range_ie_u64* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__equals(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u64__is_empty(r) &&\n wuffs_base__range_ie_u64__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64__intersect(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64__unite(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n if (wuffs_base__range_ie_u64__is_empty(r)) {\n return s" +
";\n }\n if (wuffs_base__range_ie_u64__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__contains(const wuffs_base__range_ie_u64* r,\n uint64_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__contains_range(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__equals(\n &s, wuffs_base__range_ie_u64__intersect(r, s));\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ie_u64__length(const wuffs_base__range_ie_u64* r) {\n return wuffs_base__u64__sat_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ie_u64::is_empty() const {\n return wuffs_base__range_ie_u64__is_empty(this);\n}\n\ninline bool //\nwuffs" +
"_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__equals(this, s);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64::intersect(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64::unite(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ie_u64::contains(uint64_t x) const {\n return wuffs_base__range_ie_u64__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ie_u64::contains_range(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__contains_range(this, s);\n}\n\ninline uint64_t //\nwuffs_base__range_ie_u64::length() const {\n return wuffs_base__range_ie_u64__length(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__rect_ii_u32__struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_incl_x;\n uint32_t max_incl_y;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__rect_ii_u32__struct s) const;\n inline wuffs_base__rect_ii_u32__struct intersect(\n wuffs_base__rect_ii_u32__struct s) const;\n inline wuffs_base__rect_ii_u32__struct unite(\n wuffs_base__rect_ii_u32__struct s) const;\n inline bool contains(uint32_t x, uint32_t y) const;\n inline bool contains_rect(wuffs_base__rect_ii_u32__struct s) const;\n#endif // __cplusplus\n\n} wuffs_base__rect_ii_u32;\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__empty_rect_ii_u32() {\n wuffs_base__rect_ii_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_incl_x = 0;\n ret.max_incl_y = 0;\n return ret;\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__make_rect_ii_u32(uint32_t min_incl_x,\n uint32_t min_incl_y,\n " +
"uint32_t max_incl_x,\n uint32_t max_incl_y) {\n wuffs_base__rect_ii_u32 ret;\n ret.min_incl_x = min_incl_x;\n ret.min_incl_y = min_incl_y;\n ret.max_incl_x = max_incl_x;\n ret.max_incl_y = max_incl_y;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__is_empty(const wuffs_base__rect_ii_u32* r) {\n return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__equals(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) ||\n (wuffs_base__rect_ii_u32__is_empty(r) &&\n wuffs_base__rect_ii_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32__intersect(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n wuffs_base__rect_ii_u32" +
" t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__min(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__min(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32__unite(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n if (wuffs_base__rect_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ii_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__max(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__max(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__contains(const wuffs_base__rect_ii_u32* r,\n " +
" uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) &&\n (y <= r->max_incl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__contains_rect(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__equals(\n &s, wuffs_base__rect_ii_u32__intersect(r, s));\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ii_u32::is_empty() const {\n return wuffs_base__rect_ii_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__equals(this, s);\n}\n\ninline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32::intersect(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32::unite(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__unite(this, s);" +
"\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) const {\n return wuffs_base__rect_ii_u32__contains(this, x, y);\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::contains_rect(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__contains_rect(this, s);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef struct wuffs_base__rect_ie_u32__struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_excl_x;\n uint32_t max_excl_y;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__rect_ie_u32__struct s) const;\n inline wuffs_base__rect_ie_u32__struct intersect(\n wuffs_base__rect_ie_u32__struct s) const;\n inline wuffs_base__rect_ie_u32__struct unite(\n wuffs_base__rect_ie_u32__struct s) const;\n inline bool contains(uint32_t x, uint32_t y) const;\n inline bool contains_rect(wuffs_base__rect_ie_u32__struct s) const;\n inline uint32_t width() const;\n inline uint32_t height() const;\n#endif // __cplusplus\n\n} wuffs_base__rect_ie_u32;\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__empty_rect_ie_u32() {\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__make_rect_ie_u32(uint32_t min_incl_x,\n " +
" uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = min_incl_x;\n ret.min_incl_y = min_incl_y;\n ret.max_excl_x = max_excl_x;\n ret.max_excl_y = max_excl_y;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__is_empty(const wuffs_base__rect_ie_u32* r) {\n return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__equals(const wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) ||\n (wuffs_base__rect_ie_u32__is_empty(r) &&\n wuffs_base__rect_ie_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__intersect(const wuffs_base__rect_ie_u32* r,\n " +
" wuffs_base__rect_ie_u32 s) {\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__min(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__min(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__unite(const wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n if (wuffs_base__rect_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__max(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__max(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__con" +
"tains(const wuffs_base__rect_ie_u32* r,\n uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) &&\n (y < r->max_excl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__contains_rect(const wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__equals(\n &s, wuffs_base__rect_ie_u32__intersect(r, s));\n}\n\nstatic inline uint32_t //\nwuffs_base__rect_ie_u32__width(const wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x);\n}\n\nstatic inline uint32_t //\nwuffs_base__rect_ie_u32__height(const wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ie_u32::is_empty() const {\n return wuffs_base__rect_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::equals(wuffs_bas" +
"e__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__equals(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__unite(this, s);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) const {\n return wuffs_base__rect_ie_u32__contains(this, x, y);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::contains_rect(wuffs_base__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__contains_rect(this, s);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::width() const {\n return wuffs_base__rect_ie_u32__width(this);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::height() const {\n return wuffs_base__rect_ie_u32__height(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// ---------------- More Information\n\n// wuffs_base__more_information holds additional fields, typically when a Wuffs\n// method returns a [note status](/doc/note/statuses.md).\n//\n// The flavor field follows the base38 namespace\n// convention](/doc/note/base38-and-fourcc.md). The other fields' semantics\n// depends on the flavor.\ntypedef struct wuffs_base__more_information__struct {\n uint32_t flavor;\n uint32_t w;\n uint64_t x;\n uint64_t y;\n uint64_t z;\n\n#ifdef __cplusplus\n inline void set(uint32_t flavor_arg,\n uint32_t w_arg,\n uint64_t x_arg,\n uint64_t y_arg,\n uint64_t z_arg);\n inline uint32_t io_redirect__fourcc() const;\n inline wuffs_base__range_ie_u64 io_redirect__range() const;\n inline uint64_t io_seek__position() const;\n inline uint32_t metadata__fourcc() const;\n inline wuffs_base__range_ie_u64 metadata__range() const;\n#endif // __cplusplus\n\n} wuffs_base__more_information;\n\n#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRE" +
"CT 1\n#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2\n#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3\n\nstatic inline wuffs_base__more_information //\nwuffs_base__empty_more_information() {\n wuffs_base__more_information ret;\n ret.flavor = 0;\n ret.w = 0;\n ret.x = 0;\n ret.y = 0;\n ret.z = 0;\n return ret;\n}\n\nstatic inline void //\nwuffs_base__more_information__set(wuffs_base__more_information* m,\n uint32_t flavor,\n uint32_t w,\n uint64_t x,\n uint64_t y,\n uint64_t z) {\n if (!m) {\n return;\n }\n m->flavor = flavor;\n m->w = w;\n m->x = x;\n m->y = y;\n m->z = z;\n}\n\nstatic inline uint32_t //\nwuffs_base__more_information__io_redirect__fourcc(\n const wuffs_base__more_information* m) {\n return m->w;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__more_information__io_redirect__range(\n const wuffs_base__more_informa" +
"tion* m) {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = m->y;\n ret.max_excl = m->z;\n return ret;\n}\n\nstatic inline uint64_t //\nwuffs_base__more_information__io_seek__position(\n const wuffs_base__more_information* m) {\n return m->x;\n}\n\nstatic inline uint32_t //\nwuffs_base__more_information__metadata__fourcc(\n const wuffs_base__more_information* m) {\n return m->w;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__more_information__metadata__range(\n const wuffs_base__more_information* m) {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = m->y;\n ret.max_excl = m->z;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__more_information::set(uint32_t flavor_arg,\n uint32_t w_arg,\n uint64_t x_arg,\n uint64_t y_arg,\n uint64_t z_arg) {\n wuffs_base__more_information__set(this, flavor_arg, w_arg, x_arg, y_arg,\n z_arg);" +
"\n}\n\ninline uint32_t //\nwuffs_base__more_information::io_redirect__fourcc() const {\n return wuffs_base__more_information__io_redirect__fourcc(this);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__more_information::io_redirect__range() const {\n return wuffs_base__more_information__io_redirect__range(this);\n}\n\ninline uint64_t //\nwuffs_base__more_information::io_seek__position() const {\n return wuffs_base__more_information__io_seek__position(this);\n}\n\ninline uint32_t //\nwuffs_base__more_information::metadata__fourcc() const {\n return wuffs_base__more_information__metadata__fourcc(this);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__more_information::metadata__range() const {\n return wuffs_base__more_information__metadata__range(this);\n}\n\n#endif // __cplusplus\n" +
""
const BaseStrConvPrivateH = "" +
"// ---------------- String Conversions\n\n" +
"" +
"// ---------------- Unicode and UTF-8\n" +
""
const BaseStrConvPublicH = "" +
"// ---------------- String Conversions\n\n// Options (bitwise or'ed together) for wuffs_base__parse_number_xxx\n// functions. The XXX options apply to both integer and floating point. The FXX\n// options apply only to floating point.\n\n#define WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES means to accept\n// inputs like \"00\", \"0644\" and \"00.7\". By default, they are rejected.\n#define WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES \\\n ((uint32_t)0x00000001)\n\n// WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES means to accept inputs like\n// \"1__2\" and \"_3.141_592\". By default, they are rejected.\n#define WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES ((uint32_t)0x00000002)\n\n// WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to accept\n// \"1,5\" and not \"1.5\" as one-and-a-half.\n//\n// If the caller wants to accept either, it is responsible for canonicalizing\n// the input before calling wuffs_base__parse_numb" +
"er_fxx. The caller also has\n// more context on e.g. exactly how to treat something like \"$1,234\".\n#define WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \\\n ((uint32_t)0x00000010)\n\n// WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN means to reject inputs that\n// would lead to infinite or Not-a-Number floating point values. By default,\n// they are accepted.\n//\n// This affects the literal \"inf\" as input, but also affects inputs like\n// \"1e999\" that would overflow double-precision floating point.\n#define WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN ((uint32_t)0x00000020)\n\n" +
"" +
"// --------\n\n// Options (bitwise or'ed together) for wuffs_base__render_number_xxx\n// functions. The XXX options apply to both integer and floating point. The FXX\n// options apply only to floating point.\n\n#define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT means to render to the right side\n// (higher indexes) of the destination slice, leaving any untouched bytes on\n// the left side (lower indexes). The default is vice versa: rendering on the\n// left with slack on the right.\n#define WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT ((uint32_t)0x00000100)\n\n// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN means to render the leading\n// \"+\" for non-negative numbers: \"+0\" and \"+12.3\" instead of \"0\" and \"12.3\".\n#define WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN ((uint32_t)0x00000200)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to render\n// one-and-a-half as \"1,5\" instead of \"1.5\".\n#define WUFFS_BASE__RENDER_NUMBER_F" +
"XX__DECIMAL_SEPARATOR_IS_A_COMMA \\\n ((uint32_t)0x00001000)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ETC means whether to never\n// (EXPONENT_ABSENT, equivalent to printf's \"%f\") or to always\n// (EXPONENT_PRESENT, equivalent to printf's \"%e\") render a floating point\n// number as \"1.23e+05\" instead of \"123000\".\n//\n// Having both bits set is the same has having neither bit set, where the\n// notation used depends on whether the exponent is sufficiently large: \"0.5\"\n// is preferred over \"5e-01\" but \"5e-09\" is preferred over \"0.000000005\".\n#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT ((uint32_t)0x00002000)\n#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT ((uint32_t)0x00004000)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION means to render the\n// smallest number of digits so that parsing the resultant string will recover\n// the same double-precision floating point number.\n//\n// For example, double-precision cannot distinguish between 0.3 and\n// 0.2999999999999999888977697537484345957636" +
"83319091796875, so when this bit\n// is set, rendering the latter will produce \"0.3\" but rendering\n// 0.3000000000000000444089209850062616169452667236328125 will produce\n// \"0.30000000000000004\".\n#define WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION \\\n ((uint32_t)0x00008000)\n\n" +
"" +
"// ---------------- IEEE 754 Floating Point\n\n// wuffs_base__ieee_754_bit_representation__etc converts between a double\n// precision numerical value and its IEEE 754 representations:\n// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.\n// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.\n// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.\n//\n// For example, it converts between:\n// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.\n// - +5.5 and 0x4580, 0x40B0_0000 or 0x4016_0000_0000_0000.\n// - -inf and 0xFC00, 0xFF80_0000 or 0xFFF0_0000_0000_0000.\n//\n// Converting from f64 to shorter formats (f16 or f32, represented in C as\n// uint16_t and uint32_t) may be lossy. Such functions have names that look\n// like etc_truncate, as converting finite numbers produce equal or smaller\n// (closer-to-zero) finite numbers. For example, 1048576.0 is a perfectly valid\n// f64 number, but converting it to a f16 (with truncation) produces 65504.0,\n// the" +
" largest finite f16 number. Truncating a f64-typed value d to f32 does\n// not always produce the same result as the C-style cast ((float)d), as\n// casting can convert from finite numbers to infinite ones.\n//\n// Converting infinities or NaNs produces infinities or NaNs and always report\n// no loss, even though there a multiple NaN representations so that round-\n// tripping a f64-typed NaN may produce a different 64 bits. Nonetheless, the\n// etc_truncate functions preserve a NaN's \"quiet vs signaling\" bit.\n//\n// See https://en.wikipedia.org/wiki/Double-precision_floating-point_format\n\ntypedef struct wuffs_base__lossy_value_u16__struct {\n uint16_t value;\n bool lossy;\n} wuffs_base__lossy_value_u16;\n\ntypedef struct wuffs_base__lossy_value_u32__struct {\n uint32_t value;\n bool lossy;\n} wuffs_base__lossy_value_u32;\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u16 //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u16_truncate(double f);\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u32 //\nwuffs_ba" +
"se__ieee_754_bit_representation__from_f64_to_u32_truncate(double f);\n\nstatic inline uint64_t //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u64(double f) {\n uint64_t u = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&u, &f, sizeof(uint64_t));\n }\n return u;\n}\n\nstatic inline double //\nwuffs_base__ieee_754_bit_representation__from_u16_to_f64(uint16_t u) {\n uint64_t v = ((uint64_t)(u & 0x8000)) << 48;\n\n do {\n uint64_t exp = (u >> 10) & 0x1F;\n uint64_t man = u & 0x3FF;\n if (exp == 0x1F) { // Infinity or NaN.\n exp = 2047;\n } else if (exp != 0) { // Normal.\n exp += 1008; // 1008 = 1023 - 15, the difference in biases.\n } else if (man != 0) { // Subnormal but non-zero.\n uint32_t clz = wuffs_base__count_leading_zeroes_u64(man);\n exp = 1062 - clz; // 1062 = 1008 + 64 - 10.\n man = 0x3FF & (man << (clz - 53));\n } else { // Zero.\n break;\n }\n v |= (exp << 52) | (man << 42);\n } while (0);\n\n double f = 0;\n if (sizeof(uint64_t) =" +
"= sizeof(double)) {\n memcpy(&f, &v, sizeof(uint64_t));\n }\n return f;\n}\n\nstatic inline double //\nwuffs_base__ieee_754_bit_representation__from_u32_to_f64(uint32_t u) {\n float f = 0;\n if (sizeof(uint32_t) == sizeof(float)) {\n memcpy(&f, &u, sizeof(uint32_t));\n }\n return (double)f;\n}\n\nstatic inline double //\nwuffs_base__ieee_754_bit_representation__from_u64_to_f64(uint64_t u) {\n double f = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&f, &u, sizeof(uint64_t));\n }\n return f;\n}\n\n" +
"" +
"// ---------------- Parsing and Rendering Numbers\n\n// wuffs_base__parse_number_f64 parses the floating point number in s. For\n// example, if s contains the bytes \"1.5\" then it will return the double 1.5.\n//\n// It returns an error if s does not contain a floating point number.\n//\n// It does not necessarily return an error if the conversion is lossy, e.g. if\n// s is \"0.3\", which double-precision floating point cannot represent exactly.\n//\n// Similarly, the returned value may be infinite (and no error returned) even\n// if s was not \"inf\", when the input is nominally finite but sufficiently\n// larger than DBL_MAX, about 1.8e+308.\n//\n// It is similar to the C standard library's strtod function, but:\n// - Errors are returned in-band (in a result type), not out-of-band (errno).\n// - It takes a slice (a pointer and length), not a NUL-terminated C string.\n// - It does not take an optional endptr argument. It does not allow a partial\n// parse: it returns an error unless all of s is consumed.\n// - It does not all" +
"ow whitespace, leading or otherwise.\n// - It does not allow hexadecimal floating point numbers.\n// - It is not affected by i18n / l10n settings such as environment variables.\n//\n// The options argument can change these, but by default, it:\n// - Allows \"inf\", \"+Infinity\" and \"-NAN\", case insensitive. Similarly,\n// without an explicit opt-out, it would successfully parse \"1e999\" as\n// infinity, even though it overflows double-precision floating point.\n// - Rejects underscores. With an explicit opt-in, \"_3.141_592\" would\n// successfully parse as an approximation to π.\n// - Rejects unnecessary leading zeroes: \"00\", \"0644\" and \"00.7\".\n// - Uses a dot '1.5' instead of a comma '1,5' for the decimal separator.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__FLOATCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //\nwuffs_base__parse_number_f64(wuffs_base__" +
"slice_u8 s, uint32_t options);\n\n// wuffs_base__parse_number_i64 parses the ASCII integer in s. For example, if\n// s contains the bytes \"-123\" then it will return the int64_t -123.\n//\n// It returns an error if s does not contain an integer or if the integer\n// within would overflow an int64_t.\n//\n// It is similar to wuffs_base__parse_number_u64 but it returns a signed\n// integer, not an unsigned integer. It also allows a leading '+' or '-'.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //\nwuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options);\n\n// wuffs_base__parse_number_u64 parses the ASCII integer in s. For example, if\n// s contains the bytes \"123\" then it will return the uint64_t 123.\n//\n// It returns an error if s does not contain an integer or if the integer\n// within would overflow a uin" +
"t64_t.\n//\n// It is similar to the C standard library's strtoull function, but:\n// - Errors are returned in-band (in a result type), not out-of-band (errno).\n// - It takes a slice (a pointer and length), not a NUL-terminated C string.\n// - It does not take an optional endptr argument. It does not allow a partial\n// parse: it returns an error unless all of s is consumed.\n// - It does not allow whitespace, leading or otherwise.\n// - It does not allow a leading '+' or '-'.\n// - It does not take a base argument (e.g. base 10 vs base 16). Instead, it\n// always accepts both decimal (e.g \"1234\", \"0d5678\") and hexadecimal (e.g.\n// \"0x9aBC\"). The caller is responsible for prior filtering of e.g. hex\n// numbers if they are unwanted. For example, Wuffs' JSON decoder will only\n// produce a wuffs_base__token for decimal numbers, not hexadecimal.\n// - It is not affected by i18n / l10n settings such as environment variables.\n//\n// The options argument can change these, but by default, it:\n// - Rejects " +
"underscores. With an explicit opt-in, \"__0D_1_002\" would\n// successfully parse as \"one thousand and two\". Underscores are still\n// rejected inside the optional 2-byte opening \"0d\" or \"0X\" that denotes\n// base-10 or base-16.\n// - Rejects unnecessary leading zeroes: \"00\" and \"0644\".\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //\nwuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options);\n\n" +
"" +
"// --------\n\n// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL is the string length of\n// \"-9223372036854775808\" and \"+9223372036854775807\", INT64_MIN and INT64_MAX.\n#define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20\n\n// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL is the string length of\n// \"+18446744073709551615\", UINT64_MAX.\n#define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21\n\n// wuffs_base__render_number_f64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// For those familiar with C's printf or Go's fmt.Printf functions:\n// - \"%e\" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT option.\n// - \"%f\" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT option.\n// - \"%g\" means neither or both bits are set.\n//\n// The precision argument controls the number of digits rendered, excluding the\n// exponent (the \"e+05\" in \"1.23e+05\"):\n// - for \"%e\" and \"%f\" it is the number of digits after t" +
"he decimal separator,\n// - for \"%g\" it is the number of significant digits (and trailing zeroes are\n// removed).\n//\n// A precision of 6 gives similar output to printf's defaults.\n//\n// A precision greater than 4095 is equivalent to 4095.\n//\n// The precision argument is ignored when the\n// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION option is set. This is\n// similar to Go's strconv.FormatFloat with a negative (i.e. non-sensical)\n// precision, but there is no corresponding feature in C's printf.\n//\n// Extreme values of x will be rendered as \"NaN\", \"Inf\" (or \"+Inf\" if the\n// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN option is set) or \"-Inf\".\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__FLOATCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_f64(wuffs_base__slice_u8 dst,\n double x,\n " +
" uint32_t precision,\n uint32_t options);\n\n// wuffs_base__render_number_i64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too short if its length is at least 20, also known as\n// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_i64(wuffs_base__slice_u8 dst,\n int64_t x,\n uint32_t options);\n\n// wuffs_base__render_number_u64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too sho" +
"rt if its length is at least 21, also known as\n// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_u64(wuffs_base__slice_u8 dst,\n uint64_t x,\n uint32_t options);\n\n" +
"" +
"// ---------------- Base-16\n\n// Options (bitwise or'ed together) for wuffs_base__base_16__xxx functions.\n\n#define WUFFS_BASE__BASE_16__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// wuffs_base__base_16__decode2 converts \"6A6b\" to \"jk\", where e.g. 'j' is\n// U+006A. There are 2 src bytes for every dst byte.\n//\n// It assumes that the src bytes are two hexadecimal digits (0-9, A-F, a-f),\n// repeated. It may write nonsense bytes if not, although it will not read or\n// write out of bounds.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_16__decode4 converts both \"\\\\x6A\\\\x6b\" and \"??6a??6B\" " +
"to\n// \"jk\", where e.g. 'j' is U+006A. There are 4 src bytes for every dst byte.\n//\n// It assumes that the src bytes are two ignored bytes and then two hexadecimal\n// digits (0-9, A-F, a-f), repeated. It may write nonsense bytes if not,\n// although it will not read or write out of bounds.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_16__encode2 converts \"jk\" to \"6A6B\", where e.g. 'j' is\n// U+006A. There are 2 dst bytes for every src byte.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV" +
" sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_16__encode4 converts \"jk\" to \"\\\\x6A\\\\x6B\", where e.g. 'j'\n// is U+006A. There are 4 dst bytes for every src byte.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n" +
"" +
"// ---------------- Base-64\n\n// Options (bitwise or'ed together) for wuffs_base__base_64__xxx functions.\n\n#define WUFFS_BASE__BASE_64__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING means that, when decoding base-64,\n// the input may (but does not need to) be padded with '=' bytes so that the\n// overall encoded length in bytes is a multiple of 4. A successful decoding\n// will return a num_src that includes those padding bytes.\n//\n// Excess padding (e.g. three final '='s) will be rejected as bad data.\n#define WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING ((uint32_t)0x00000001)\n\n// WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING means that, when encoding base-64,\n// the output will be padded with '=' bytes so that the overall encoded length\n// in bytes is a multiple of 4.\n#define WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING ((uint32_t)0x00000002)\n\n// WUFFS_BASE__BASE_64__URL_ALPHABET means that, for base-64, the URL-friendly\n// and file-name-friendly alphabet be used, as per RFC 4648 sect" +
"ion 5. When\n// this option bit is off, the standard alphabet from section 4 is used.\n#define WUFFS_BASE__BASE_64__URL_ALPHABET ((uint32_t)0x00000100)\n\n// wuffs_base__base_64__decode transforms base-64 encoded bytes from src to\n// arbitrary bytes in dst.\n//\n// It will not permit line breaks or other whitespace in src. Filtering those\n// out is the responsibility of the caller.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__decode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_64__encode transforms arbitrary bytes from src to base-64\n// encoded bytes in dst.\n//\n// For modular builds that divide the base module into sub-modules, using this" +
"\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__encode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n" +
"" +
"// ---------------- Unicode and UTF-8\n\n#define WUFFS_BASE__UNICODE_CODE_POINT__MIN_INCL 0x00000000\n#define WUFFS_BASE__UNICODE_CODE_POINT__MAX_INCL 0x0010FFFF\n\n#define WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER 0x0000FFFD\n\n#define WUFFS_BASE__UNICODE_SURROGATE__MIN_INCL 0x0000D800\n#define WUFFS_BASE__UNICODE_SURROGATE__MAX_INCL 0x0000DFFF\n\n#define WUFFS_BASE__ASCII__MIN_INCL 0x00\n#define WUFFS_BASE__ASCII__MAX_INCL 0x7F\n\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH__MIN_INCL 1\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL 4\n\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_1__CODE_POINT__MIN_INCL 0x00000000\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_1__CODE_POINT__MAX_INCL 0x0000007F\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_2__CODE_POINT__MIN_INCL 0x00000080\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_2__CODE_POINT__MAX_INCL 0x000007FF\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_3__CODE_POINT__MIN_INCL 0x00000800\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_3__CODE_POINT__MAX_INCL 0x0000FFFF\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_4__CODE_POINT_" +
"_MIN_INCL 0x00010000\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_4__CODE_POINT__MAX_INCL 0x0010FFFF\n\n" +
"" +
"// --------\n\n// wuffs_base__utf_8__next__output is the type returned by\n// wuffs_base__utf_8__next.\ntypedef struct wuffs_base__utf_8__next__output__struct {\n uint32_t code_point;\n uint32_t byte_length;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n#endif // __cplusplus\n\n} wuffs_base__utf_8__next__output;\n\nstatic inline wuffs_base__utf_8__next__output //\nwuffs_base__make_utf_8__next__output(uint32_t code_point,\n uint32_t byte_length) {\n wuffs_base__utf_8__next__output ret;\n ret.code_point = code_point;\n ret.byte_length = byte_length;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__utf_8__next__output__is_valid(\n const wuffs_base__utf_8__next__output* o) {\n if (o) {\n uint32_t cp = o->code_point;\n switch (o->byte_length) {\n case 1:\n return (cp <= 0x7F);\n case 2:\n return (0x080 <= cp) && (cp <= 0x7FF);\n case 3:\n // Avoid the 0xD800 ..= 0xDFFF surrogate range.\n return ((0x0800 <= cp) && (cp <= 0xD7FF)) ||\n " +
" ((0xE000 <= cp) && (cp <= 0xFFFF));\n case 4:\n return (0x00010000 <= cp) && (cp <= 0x0010FFFF);\n }\n }\n return false;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__utf_8__next__output::is_valid() const {\n return wuffs_base__utf_8__next__output__is_valid(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\n// wuffs_base__utf_8__encode writes the UTF-8 encoding of code_point to s and\n// returns the number of bytes written. If code_point is invalid, or if s is\n// shorter than the entire encoding, it returns 0 (and no bytes are written).\n//\n// s will never be too short if its length is at least 4, also known as\n// WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point);\n\n// wuffs_base__utf_8__next returns the next UTF-8 code point (and that code\n// point's byte length) at the start of the read-only slice (s_ptr, s_len).\n//\n// There are exactly two cases in which this function returns something where\n// wuffs_base__utf_8__next__output__is_valid is false:\n// - If s is empty then it returns {.code_point=0, .byte_len" +
"gth=0}.\n// - If s is non-empty and starts with invalid UTF-8 then it returns\n// {.code_point=WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, .byte_length=1}.\n//\n// Otherwise, it returns something where\n// wuffs_base__utf_8__next__output__is_valid is true.\n//\n// In any case, it always returns an output that satisfies both of:\n// - (output.code_point <= WUFFS_BASE__UNICODE_CODE_POINT__MAX_INCL).\n// - (output.byte_length <= s_len).\n//\n// If s is a sub-slice of a larger slice of valid UTF-8, but that sub-slice\n// boundary occurs in the middle of a multi-byte UTF-8 encoding of a single\n// code point, then this function may return something invalid. It is the\n// caller's responsibility to split on or otherwise manage UTF-8 boundaries.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //\nwuffs_base__utf_8__next(" +
"const uint8_t* s_ptr, size_t s_len);\n\n// wuffs_base__utf_8__next_from_end is like wuffs_base__utf_8__next except that\n// it looks at the end of (s_ptr, s_len) instead of the start.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //\nwuffs_base__utf_8__next_from_end(const uint8_t* s_ptr, size_t s_len);\n\n// wuffs_base__utf_8__longest_valid_prefix returns the largest n such that the\n// sub-slice s[..n] is valid UTF-8, where s is the read-only slice (s_ptr,\n// s_len).\n//\n// In particular, it returns s_len if and only if all of s is valid UTF-8.\n//\n// If s is a sub-slice of a larger slice of valid UTF-8, but that sub-slice\n// boundary occurs in the middle of a multi-byte UTF-8 encoding of a single\n// code point, then this function will return less than s_len. It is the\n// caller's responsibility to split on or " +
"otherwise manage UTF-8 boundaries.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len);\n\n// wuffs_base__ascii__longest_valid_prefix returns the largest n such that the\n// sub-slice s[..n] is valid ASCII, where s is the read-only slice (s_ptr,\n// s_len).\n//\n// In particular, it returns s_len if and only if all of s is valid ASCII.\n// Equivalently, when none of the bytes in s have the 0x80 high bit set.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__ascii__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len);\n" +
""
const BaseTokenPrivateH = "" +
"// ---------------- Tokens\n\n" +
"" +
"// ---------------- Tokens (Utility)\n" +
""
const BaseTokenPublicH = "" +
"// ---------------- Tokens\n\n// wuffs_base__token is an element of a byte stream's tokenization.\n//\n// See https://github.com/google/wuffs/blob/main/doc/note/tokens.md\ntypedef struct wuffs_base__token__struct {\n uint64_t repr;\n\n#ifdef __cplusplus\n inline int64_t value() const;\n inline int64_t value_extension() const;\n inline int64_t value_major() const;\n inline int64_t value_base_category() const;\n inline uint64_t value_minor() const;\n inline uint64_t value_base_detail() const;\n inline int64_t value_base_detail__sign_extended() const;\n inline bool continued() const;\n inline uint64_t length() const;\n#endif // __cplusplus\n\n} wuffs_base__token;\n\nstatic inline wuffs_base__token //\nwuffs_base__make_token(uint64_t repr) {\n wuffs_base__token ret;\n ret.repr = repr;\n return ret;\n}\n\n" +
"" +
"// --------\n\n#define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF\n\n#define WUFFS_BASE__TOKEN__VALUE__SHIFT 17\n#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17\n#define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42\n#define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17\n#define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38\n#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17\n#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16\n#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0\n\n#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46\n\n" +
"" +
"// --------\n\n#define WUFFS_BASE__TOKEN__VBC__FILLER 0\n#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1\n#define WUFFS_BASE__TOKEN__VBC__STRING 2\n#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3\n#define WUFFS_BASE__TOKEN__VBC__LITERAL 4\n#define WUFFS_BASE__TOKEN__VBC__NUMBER 5\n#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6\n#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7\n\n" +
"" +
"// --------\n\n#define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001\n#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002\n#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004\n\n// COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE.\n#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006\n\n" +
"" +
"// --------\n\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000\n\n" +
"" +
"// --------\n\n// DEFINITELY_FOO means that the destination bytes (and also the source bytes,\n// for 1_DST_1_SRC_COPY) are in the FOO format. Definitely means that the lack\n// of the bit means \"maybe FOO\". It does not necessarily mean \"not FOO\".\n//\n// CHAIN_ETC means that decoding the entire token chain forms a UTF-8 or ASCII\n// string, not just this current token. CHAIN_ETC_UTF_8 therefore distinguishes\n// Unicode (UTF-8) strings from byte strings. MUST means that the the token\n// producer (e.g. parser) must verify this. SHOULD means that the token\n// consumer (e.g. renderer) should verify this.\n//\n// When a CHAIN_ETC_UTF_8 bit is set, the parser must ensure that non-ASCII\n// code points (with multi-byte UTF-8 encodings) do not straddle token\n// boundaries. Checking UTF-8 validity can inspect each token separately.\n//\n// The lack of any particular bit is conservative: it is valid for all-ASCII\n// strings, in a single- or multi-token chain, to have none of these bits set.\n#define WUFFS_BASE__TOKEN__VBD__STRING_" +
"_DEFINITELY_UTF_8 0x00001\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004\n#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040\n\n// CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded)\n// produces multiples of D destination bytes. For example,\n// CONVERT_1_DST_4_SRC_BACKSLASH_X means a source like \"\\\\x23\\\\x67\\\\xAB\", where\n// 12 src bytes encode 3 dst bytes.\n//\n// Post-processing may further transform those D destination bytes (e.g. treat\n// \"\\\\xFF\" as the Unicode code point U+00FF instead of the byte 0xFF), but that\n// is out of scope of this VBD's semantics.\n//\n// When src is the empty string, multiple conversion algorithms are applicable\n// (so these bits are not necessarily mutually exclusive), all producing the\n// same empty dst string.\n#define WU" +
"FFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000\n\n" +
"" +
"// --------\n\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008\n\n" +
"" +
"// --------\n\n// For a source string of \"123\" or \"0x9A\", it is valid for a tokenizer to\n// return any combination of:\n// - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT.\n// - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED.\n// - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED.\n//\n// For a source string of \"+123\" or \"-0x9A\", only the first two are valid.\n//\n// For a source string of \"123.\", only the first one is valid.\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004\n\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF 0x00020\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN 0x00040\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN 0x00080\n\n// The number 300 might be represented as \"\\x01\\x2C\", \"\\x2C\\x01\\x00\\x00\" or\n// \"300\", which are big-en" +
"dian, little-endian or text. For binary formats, the\n// token length (after adjusting for FORMAT_IGNORE_ETC) discriminates\n// e.g. u16 little-endian vs u32 little-endian.\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400\n\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000\n\n" +
"" +
"// --------\n\n// wuffs_base__token__value returns the token's high 46 bits, sign-extended. A\n// negative value means an extended token, non-negative means a simple token.\nstatic inline int64_t //\nwuffs_base__token__value(const wuffs_base__token* t) {\n return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE__SHIFT;\n}\n\n// wuffs_base__token__value_extension returns a negative value if the token was\n// not an extended token.\nstatic inline int64_t //\nwuffs_base__token__value_extension(const wuffs_base__token* t) {\n return (~(int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT;\n}\n\n// wuffs_base__token__value_major returns a negative value if the token was not\n// a simple token.\nstatic inline int64_t //\nwuffs_base__token__value_major(const wuffs_base__token* t) {\n return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT;\n}\n\n// wuffs_base__token__value_base_category returns a negative value if the token\n// was not a simple token.\nstatic inline int64_t //\nwuffs_base__token__value_base_cat" +
"egory(const wuffs_base__token* t) {\n return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT;\n}\n\nstatic inline uint64_t //\nwuffs_base__token__value_minor(const wuffs_base__token* t) {\n return (t->repr >> WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) & 0x1FFFFFF;\n}\n\nstatic inline uint64_t //\nwuffs_base__token__value_base_detail(const wuffs_base__token* t) {\n return (t->repr >> WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT) & 0x1FFFFF;\n}\n\nstatic inline int64_t //\nwuffs_base__token__value_base_detail__sign_extended(\n const wuffs_base__token* t) {\n // The VBD is 21 bits in the middle of t->repr. Left shift the high (64 - 21\n // - ETC__SHIFT) bits off, then right shift (sign-extending) back down.\n uint64_t u = t->repr << (43 - WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT);\n return ((int64_t)u) >> 43;\n}\n\nstatic inline bool //\nwuffs_base__token__continued(const wuffs_base__token* t) {\n return t->repr & 0x10000;\n}\n\nstatic inline uint64_t //\nwuffs_base__token__length(const wuffs_base__token*" +
" t) {\n return (t->repr >> WUFFS_BASE__TOKEN__LENGTH__SHIFT) & 0xFFFF;\n}\n\n#ifdef __cplusplus\n\ninline int64_t //\nwuffs_base__token::value() const {\n return wuffs_base__token__value(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_extension() const {\n return wuffs_base__token__value_extension(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_major() const {\n return wuffs_base__token__value_major(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_base_category() const {\n return wuffs_base__token__value_base_category(this);\n}\n\ninline uint64_t //\nwuffs_base__token::value_minor() const {\n return wuffs_base__token__value_minor(this);\n}\n\ninline uint64_t //\nwuffs_base__token::value_base_detail() const {\n return wuffs_base__token__value_base_detail(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_base_detail__sign_extended() const {\n return wuffs_base__token__value_base_detail__sign_extended(this);\n}\n\ninline bool //\nwuffs_base__token::continued() const {\n return wuffs_base__token__continued" +
"(this);\n}\n\ninline uint64_t //\nwuffs_base__token::length() const {\n return wuffs_base__token__length(this);\n}\n\n#endif // __cplusplus\n\n" +
"" +
"// --------\n\ntypedef WUFFS_BASE__SLICE(wuffs_base__token) wuffs_base__slice_token;\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__make_slice_token(wuffs_base__token* ptr, size_t len) {\n wuffs_base__slice_token ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__empty_slice_token() {\n wuffs_base__slice_token ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__token_buffer_meta is the metadata for a\n// wuffs_base__token_buffer's data.\ntypedef struct wuffs_base__token_buffer_meta__struct {\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n uint64_t pos; // Position of the buffer start relative to the stream start.\n bool closed; // No further writes are expected.\n} wuffs_base__token_buffer_meta;\n\n// wuffs_base__token_buffer is a 1-dimensional buffer (a pointer and length)\n// plus additional metadata.\n//\n// A value with all fields zero is a valid, empty buffer.\ntypedef struct wuffs_base__token_buffer__struct {\n wuffs_base__slice_token data;\n wuffs_base__token_buffer_meta meta;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n inline void compact();\n inline uint64_t reader_length() const;\n inline wuffs_base__token* reader_pointer() const;\n inline wuffs_base__slice_token reader_slice() const;\n inline uint64_t reader_token_position() const;\n inline uint64_t writer_lengt" +
"h() const;\n inline uint64_t writer_token_position() const;\n inline wuffs_base__token* writer_pointer() const;\n inline wuffs_base__slice_token writer_slice() const;\n#endif // __cplusplus\n\n} wuffs_base__token_buffer;\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__make_token_buffer(wuffs_base__slice_token data,\n wuffs_base__token_buffer_meta meta) {\n wuffs_base__token_buffer ret;\n ret.data = data;\n ret.meta = meta;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer_meta //\nwuffs_base__make_token_buffer_meta(size_t wi,\n size_t ri,\n uint64_t pos,\n bool closed) {\n wuffs_base__token_buffer_meta ret;\n ret.wi = wi;\n ret.ri = ri;\n ret.pos = pos;\n ret.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__slice_token__reader(wuffs_base__slice_token s, bool closed) {\n wuffs_base__token_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data" +
".len = s.len;\n ret.meta.wi = s.len;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__slice_token__writer(wuffs_base__slice_token s) {\n wuffs_base__token_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data.len = s.len;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__empty_token_buffer() {\n wuffs_base__token_buffer ret;\n ret.data.ptr = NULL;\n ret.data.len = 0;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer_meta //\nwuffs_base__empty_token_buffer_meta() {\n wuffs_base__token_buffer_meta ret;\n ret.wi = 0;\n ret.ri = 0;\n ret.pos = 0;\n ret.closed = false;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__token_buffer__is_valid(const wuffs_base__token_buffer* buf) {\n if (buf) {\n if (buf->data.ptr) {\n return (buf->m" +
"eta.ri <= buf->meta.wi) && (buf->meta.wi <= buf->data.len);\n } else {\n return (buf->meta.ri == 0) && (buf->meta.wi == 0) && (buf->data.len == 0);\n }\n }\n return false;\n}\n\n// wuffs_base__token_buffer__compact moves any written but unread tokens to the\n// start of the buffer.\nstatic inline void //\nwuffs_base__token_buffer__compact(wuffs_base__token_buffer* buf) {\n if (!buf || (buf->meta.ri == 0)) {\n return;\n }\n buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri);\n size_t n = buf->meta.wi - buf->meta.ri;\n if (n != 0) {\n memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri,\n n * sizeof(wuffs_base__token));\n }\n buf->meta.wi = n;\n buf->meta.ri = 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__reader_length(const wuffs_base__token_buffer* buf) {\n return buf ? buf->meta.wi - buf->meta.ri : 0;\n}\n\nstatic inline wuffs_base__token* //\nwuffs_base__token_buffer__reader_pointer(const wuffs_base__token_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta" +
".ri) : NULL;\n}\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__token_buffer__reader_slice(const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__make_slice_token(buf->data.ptr + buf->meta.ri,\n buf->meta.wi - buf->meta.ri)\n : wuffs_base__empty_slice_token();\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__reader_token_position(\n const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__writer_length(const wuffs_base__token_buffer* buf) {\n return buf ? buf->data.len - buf->meta.wi : 0;\n}\n\nstatic inline wuffs_base__token* //\nwuffs_base__token_buffer__writer_pointer(const wuffs_base__token_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta.wi) : NULL;\n}\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__token_buffer__writer_slice(const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__make_slice_toke" +
"n(buf->data.ptr + buf->meta.wi,\n buf->data.len - buf->meta.wi)\n : wuffs_base__empty_slice_token();\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__writer_token_position(\n const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__token_buffer::is_valid() const {\n return wuffs_base__token_buffer__is_valid(this);\n}\n\ninline void //\nwuffs_base__token_buffer::compact() {\n wuffs_base__token_buffer__compact(this);\n}\n\ninline uint64_t //\nwuffs_base__token_buffer::reader_length() const {\n return wuffs_base__token_buffer__reader_length(this);\n}\n\ninline wuffs_base__token* //\nwuffs_base__token_buffer::reader_pointer() const {\n return wuffs_base__token_buffer__reader_pointer(this);\n}\n\ninline wuffs_base__slice_token //\nwuffs_base__token_buffer::reader_slice() const {\n return wuffs_base__token_buffer__reader_slice(this);\n}\n\ninline uint64_t //\nwuff" +
"s_base__token_buffer::reader_token_position() const {\n return wuffs_base__token_buffer__reader_token_position(this);\n}\n\ninline uint64_t //\nwuffs_base__token_buffer::writer_length() const {\n return wuffs_base__token_buffer__writer_length(this);\n}\n\ninline wuffs_base__token* //\nwuffs_base__token_buffer::writer_pointer() const {\n return wuffs_base__token_buffer__writer_pointer(this);\n}\n\ninline wuffs_base__slice_token //\nwuffs_base__token_buffer::writer_slice() const {\n return wuffs_base__token_buffer__writer_slice(this);\n}\n\ninline uint64_t //\nwuffs_base__token_buffer::writer_token_position() const {\n return wuffs_base__token_buffer__writer_token_position(this);\n}\n\n#endif // __cplusplus\n" +
""
const BaseFloatConvSubmoduleCodeC = "" +
"// ---------------- IEEE 754 Floating Point\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u16 //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u16_truncate(double f) {\n uint64_t u = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&u, &f, sizeof(uint64_t));\n }\n uint16_t neg = ((uint16_t)((u >> 63) << 15));\n u &= 0x7FFFFFFFFFFFFFFF;\n uint64_t exp = u >> 52;\n uint64_t man = u & 0x000FFFFFFFFFFFFF;\n\n if (exp == 0x7FF) {\n if (man == 0) { // Infinity.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | 0x7C00;\n ret.lossy = false;\n return ret;\n }\n // NaN. Shift the 52 mantissa bits to 10 mantissa bits, keeping the most\n // significant mantissa bit (quiet vs signaling NaNs). Also set the low 9\n // bits of ret.value so that the 10-bit mantissa is non-zero.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | 0x7DFF | ((uint16_t)(man >> 42));\n ret.lossy = false;\n return ret;\n\n } else if (exp > 0x40E) { // Truncate to the largest finite f16." +
"\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | 0x7BFF;\n ret.lossy = true;\n return ret;\n\n } else if (exp <= 0x3E6) { // Truncate to zero.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg;\n ret.lossy = (u != 0);\n return ret;\n\n } else if (exp <= 0x3F0) { // Normal f64, subnormal f16.\n // Convert from a 53-bit mantissa (after realizing the implicit bit) to a\n // 10-bit mantissa and then adjust for the exponent.\n man |= 0x0010000000000000;\n uint32_t shift = ((uint32_t)(1051 - exp)); // 1051 = 0x3F0 + 53 - 10.\n uint64_t shifted_man = man >> shift;\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | ((uint16_t)shifted_man);\n ret.lossy = (shifted_man << shift) != man;\n return ret;\n }\n\n // Normal f64, normal f16.\n\n // Re-bias from 1023 to 15 and shift above f16's 10 mantissa bits.\n exp = (exp - 1008) << 10; // 1008 = 1023 - 15 = 0x3FF - 0xF.\n\n // Convert from a 52-bit mantissa (excluding the implicit bit) to a 10-bit\n // mantissa (again excluding" +
" the implicit bit). We lose some information if\n // any of the bottom 42 bits are non-zero.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | ((uint16_t)exp) | ((uint16_t)(man >> 42));\n ret.lossy = (man << 22) != 0;\n return ret;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u32 //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {\n uint64_t u = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&u, &f, sizeof(uint64_t));\n }\n uint32_t neg = ((uint32_t)(u >> 63)) << 31;\n u &= 0x7FFFFFFFFFFFFFFF;\n uint64_t exp = u >> 52;\n uint64_t man = u & 0x000FFFFFFFFFFFFF;\n\n if (exp == 0x7FF) {\n if (man == 0) { // Infinity.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | 0x7F800000;\n ret.lossy = false;\n return ret;\n }\n // NaN. Shift the 52 mantissa bits to 23 mantissa bits, keeping the most\n // significant mantissa bit (quiet vs signaling NaNs). Also set the low 22\n // bits of ret.value so that the 23-bit mantissa is non-zero.\n " +
" wuffs_base__lossy_value_u32 ret;\n ret.value = neg | 0x7FBFFFFF | ((uint32_t)(man >> 29));\n ret.lossy = false;\n return ret;\n\n } else if (exp > 0x47E) { // Truncate to the largest finite f32.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | 0x7F7FFFFF;\n ret.lossy = true;\n return ret;\n\n } else if (exp <= 0x369) { // Truncate to zero.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg;\n ret.lossy = (u != 0);\n return ret;\n\n } else if (exp <= 0x380) { // Normal f64, subnormal f32.\n // Convert from a 53-bit mantissa (after realizing the implicit bit) to a\n // 23-bit mantissa and then adjust for the exponent.\n man |= 0x0010000000000000;\n uint32_t shift = ((uint32_t)(926 - exp)); // 926 = 0x380 + 53 - 23.\n uint64_t shifted_man = man >> shift;\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | ((uint32_t)shifted_man);\n ret.lossy = (shifted_man << shift) != man;\n return ret;\n }\n\n // Normal f64, normal f32.\n\n // Re-bias from 1023 to 127 and shi" +
"ft above f32's 23 mantissa bits.\n exp = (exp - 896) << 23; // 896 = 1023 - 127 = 0x3FF - 0x7F.\n\n // Convert from a 52-bit mantissa (excluding the implicit bit) to a 23-bit\n // mantissa (again excluding the implicit bit). We lose some information if\n // any of the bottom 29 bits are non-zero.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | ((uint32_t)exp) | ((uint32_t)(man >> 29));\n ret.lossy = (man << 35) != 0;\n return ret;\n}\n\n" +
"" +
"// --------\n\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800\n\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N\n// such that ((10 << N) < (1 << 64)).\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL 60\n\n// wuffs_base__private_implementation__high_prec_dec (abbreviated as HPD) is a\n// fixed precision floating point decimal number, augmented with ±infinity\n// values, but it cannot represent NaN (Not a Number).\n//\n// \"High precision\" means that the mantissa holds 800 decimal digits. 800 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.\n//\n// An HPD isn't for general purpose arithmetic, only for conversions to and\n// from IEEE 754 double-precision floating point, where the largest and\n// smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.\n// HPD exponents above +2047 mean infinity, below -2047 mean zero. The ±2047\n// bounds are further a" +
"way from zero than ±(324 + 800), where 800 and 2047 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n//\n// digits[.. num_digits] are the number's digits in big-endian order. The\n// uint8_t values are in the range [0 ..= 9], not ['0' ..= '9'], where e.g. '7'\n// is the ASCII value 0x37.\n//\n// decimal_point is the index (within digits) of the decimal point. It may be\n// negative or be larger than num_digits, in which case the explicit digits are\n// padded with implicit zeroes.\n//\n// For example, if num_digits is 3 and digits is \"\\x07\\x08\\x09\":\n// - A decimal_point of -2 means \".00789\"\n// - A decimal_point of -1 means \".0789\"\n// - A decimal_point of +0 means \".789\"\n// - A decimal_point of +1 means \"7.89\"\n// - A decimal_point of +2 means \"78.9\"\n// - A decimal_point of +3 means \"789.\"\n// - A decimal_point of +4 means \"7890.\"\n// - A decimal_point of +5 means \"78900.\"\n//\n// As above, a decimal_point higher than +2047" +
" means that the overall value is\n// infinity, lower than -2047 means zero.\n//\n// negative is a sign bit. An HPD can distinguish positive and negative zero.\n//\n// truncated is whether there are more than\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION digits, and at\n// least one of those extra digits are non-zero. The existence of long-tail\n// digits can affect rounding.\n//\n// The \"all fields are zero\" value is valid, and represents the number +0.\ntypedef struct wuffs_base__private_implementation__high_prec_dec__struct {\n uint32_t num_digits;\n int32_t decimal_point;\n bool negative;\n bool truncated;\n uint8_t digits[WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION];\n} wuffs_base__private_implementation__high_prec_dec;\n\n// wuffs_base__private_implementation__high_prec_dec__trim trims trailing\n// zeroes from the h->digits[.. h->num_digits] slice. They have no benefit,\n// since we explicitly track h->decimal_point.\n//\n// Preconditions:\n// - h is non-NULL.\nstatic inline void //\nwuffs_bas" +
"e__private_implementation__high_prec_dec__trim(\n wuffs_base__private_implementation__high_prec_dec* h) {\n while ((h->num_digits > 0) && (h->digits[h->num_digits - 1] == 0)) {\n h->num_digits--;\n }\n}\n\n// wuffs_base__private_implementation__high_prec_dec__assign sets h to\n// represent the number x.\n//\n// Preconditions:\n// - h is non-NULL.\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__assign(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint64_t x,\n bool negative) {\n uint32_t n = 0;\n\n // Set h->digits.\n if (x > 0) {\n // Calculate the digits, working right-to-left. After we determine n (how\n // many digits there are), copy from buf to h->digits.\n //\n // UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to\n // copy a constant number of bytes than a variable number (20 instead of\n // n). Make buf large enough (and start writing to it from the middle) so\n // that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)].\n" +
" uint8_t buf[40] = {0};\n uint8_t* ptr = &buf[20];\n do {\n uint64_t remaining = x / 10;\n x -= remaining * 10;\n ptr--;\n *ptr = (uint8_t)x;\n n++;\n x = remaining;\n } while (x > 0);\n memcpy(h->digits, ptr, 20);\n }\n\n // Set h's other fields.\n h->num_digits = n;\n h->decimal_point = (int32_t)n;\n h->negative = negative;\n h->truncated = false;\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic wuffs_base__status //\nwuffs_base__private_implementation__high_prec_dec__parse(\n wuffs_base__private_implementation__high_prec_dec* h,\n wuffs_base__slice_u8 s,\n uint32_t options) {\n if (!h) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n h->num_digits = 0;\n h->decimal_point = 0;\n h->negative = false;\n h->truncated = false;\n\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (;; p++) {\n if (p >= q) {\n return wuffs_base__make_status" +
"(wuffs_base__error__bad_argument);\n } else if (*p != '_') {\n break;\n }\n }\n }\n\n // Parse sign.\n do {\n if (*p == '+') {\n p++;\n } else if (*p == '-') {\n h->negative = true;\n p++;\n } else {\n break;\n }\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (;; p++) {\n if (p >= q) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n } else if (*p != '_') {\n break;\n }\n }\n }\n } while (0);\n\n // Parse digits, up to (and including) a '.', 'E' or 'e'. Examples for each\n // limb in this if-else chain:\n // - \"0.789\"\n // - \"1002.789\"\n // - \".789\"\n // - Other (invalid input).\n uint32_t nd = 0;\n int32_t dp = 0;\n bool no_digits_before_separator = false;\n if (('0' == *p) &&\n !(options &\n WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES)) {\n p++;\n for (;; p++) {\n if (p >= q) {\n goto after_all;\n } else if (*p ==\n (" +
"(options &\n WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n goto after_sep;\n } else if ((*p == 'E') || (*p == 'e')) {\n p++;\n goto after_exp;\n } else if ((*p != '_') ||\n !(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n }\n\n } else if (('0' <= *p) && (*p <= '9')) {\n if (*p == '0') {\n for (; (p < q) && (*p == '0'); p++) {\n }\n } else {\n h->digits[nd++] = (uint8_t)(*p - '0');\n dp = (int32_t)nd;\n p++;\n }\n\n for (;; p++) {\n if (p >= q) {\n goto after_all;\n } else if (('0' <= *p) && (*p <= '9')) {\n if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[nd++] = (uint8_t)(*p - '0');\n dp = (int32_t)nd;\n } else if ('0' != *p) {\n // Long-tail non-zeroes set t" +
"he truncated bit.\n h->truncated = true;\n }\n } else if (*p ==\n ((options &\n WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n goto after_sep;\n } else if ((*p == 'E') || (*p == 'e')) {\n p++;\n goto after_exp;\n } else if ((*p != '_') ||\n !(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n }\n\n } else if (*p == ((options &\n WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n no_digits_before_separator = true;\n\n } else {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\nafter_sep:\n for (;; p++) {\n if (p >= q) {\n goto after_all;\n } else if ('0' == *p) {\n if (nd == 0) {\n // Track leading " +
"zeroes implicitly.\n dp--;\n } else if (nd <\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[nd++] = (uint8_t)(*p - '0');\n }\n } else if (('0' < *p) && (*p <= '9')) {\n if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[nd++] = (uint8_t)(*p - '0');\n } else {\n // Long-tail non-zeroes set the truncated bit.\n h->truncated = true;\n }\n } else if ((*p == 'E') || (*p == 'e')) {\n p++;\n goto after_exp;\n } else if ((*p != '_') ||\n !(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n }\n\nafter_exp:\n do {\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (;; p++) {\n if (p >= q) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n } else if (*p != '_') {\n break;\n }\n }\n }\n\n int32_t ex" +
"p_sign = +1;\n if (*p == '+') {\n p++;\n } else if (*p == '-') {\n exp_sign = -1;\n p++;\n }\n\n int32_t exp = 0;\n const int32_t exp_large =\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE +\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n bool saw_exp_digits = false;\n for (; p < q; p++) {\n if ((*p == '_') &&\n (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n // No-op.\n } else if (('0' <= *p) && (*p <= '9')) {\n saw_exp_digits = true;\n if (exp < exp_large) {\n exp = (10 * exp) + ((int32_t)(*p - '0'));\n }\n } else {\n break;\n }\n }\n if (!saw_exp_digits) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n dp += exp_sign * exp;\n } while (0);\n\nafter_all:\n if (p != q) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n h->num_digits = nd;\n if (nd == 0) {\n if (no_digits_before_separator) {\n retu" +
"rn wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n h->decimal_point = 0;\n } else if (dp <\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n h->decimal_point =\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE - 1;\n } else if (dp >\n +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n h->decimal_point =\n +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE + 1;\n } else {\n h->decimal_point = dp;\n }\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n return wuffs_base__make_status(NULL);\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits\n// returns the number of additional decimal digits when left-shifting by shift.\n//\n// See below for preconditions.\nstatic uint32_t //\nwuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t shift) {\n // Masking with 0x3F should be unnecessary (assuming the preconditions) but\n // it's cheap and ensures that we don't overflow the\n // wuffs_base__private_implementation__hpd_left_shift array.\n shift &= 63;\n\n uint32_t x_a = wuffs_base__private_implementation__hpd_left_shift[shift];\n uint32_t x_b = wuffs_base__private_implementation__hpd_left_shift[shift + 1];\n uint32_t num_new_digits = x_a >> 11;\n uint32_t pow5_a = 0x7FF & x_a;\n uint32_t pow5_b = 0x7FF & x_b;\n\n const uint8_t* pow5 =\n &wuffs_base__private_implementation__powers_of_5[pow5_a];\n uint32_t i = 0;\n uint32_t n = pow5_b - pow5_a;\n for (; i < n; i++) {\n if (i >" +
"= h->num_digits) {\n return num_new_digits - 1;\n } else if (h->digits[i] == pow5[i]) {\n continue;\n } else if (h->digits[i] < pow5[i]) {\n return num_new_digits - 1;\n } else {\n return num_new_digits;\n }\n }\n return num_new_digits;\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns\n// the integral (non-fractional) part of h, provided that it is 18 or fewer\n// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:\n// - (1 << 53) is 9007199254740992, which has 16 decimal digits.\n// - (1 << 56) is 72057594037927936, which has 17 decimal digits.\n// - (1 << 59) is 576460752303423488, which has 18 decimal digits.\n// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.\n// and that IEEE 754 double precision has 52 mantissa bits.\n//\n// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.\n//\n// h's negative bit is ignored: rounding -8.6 returns 9.\n//\n// See below for preconditions.\nstatic uint64_t //\nwuffs_base__private_implementation__high_prec_dec__rounded_integer(\n wuffs_base__private_implementation__high_prec_dec* h) {\n if ((h->num_digits == 0) || (h->decimal_point < 0)) {\n return 0;\n } else if (h->decimal_point > 18) {\n return U" +
"INT64_MAX;\n }\n\n uint32_t dp = (uint32_t)(h->decimal_point);\n uint64_t n = 0;\n uint32_t i = 0;\n for (; i < dp; i++) {\n n = (10 * n) + ((i < h->num_digits) ? h->digits[i] : 0);\n }\n\n bool round_up = false;\n if (dp < h->num_digits) {\n round_up = h->digits[dp] >= 5;\n if ((h->digits[dp] == 5) && (dp + 1 == h->num_digits)) {\n // We are exactly halfway. If we're truncated, round up, otherwise round\n // to even.\n round_up = h->truncated || //\n ((dp > 0) && (1 & h->digits[dp - 1]));\n }\n }\n if (round_up) {\n n++;\n }\n\n return n;\n}\n\n// wuffs_base__private_implementation__high_prec_dec__small_xshift shifts h's\n// number (where 'x' is 'l' or 'r' for left or right) by a small shift value.\n//\n// Preconditions:\n// - h is non-NULL.\n// - h->decimal_point is \"not extreme\".\n// - shift is non-zero.\n// - shift is \"a small shift\".\n//\n// \"Not extreme\" means within\n// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n//\n// \"A small shift\" means not more than\n/" +
"/ WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.\n//\n// wuffs_base__private_implementation__high_prec_dec__rounded_integer and\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits\n// have the same preconditions.\n//\n// wuffs_base__private_implementation__high_prec_dec__lshift keeps the first\n// two preconditions but not the last two. Its shift argument is signed and\n// does not need to be \"small\": zero is a no-op, positive means left shift and\n// negative means right shift.\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__small_lshift(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t shift) {\n if (h->num_digits == 0) {\n return;\n }\n uint32_t num_new_digits =\n wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(\n h, shift);\n uint32_t rx = h->num_digits - 1; // Read index.\n uint32_t wx = h->num_digits - 1 + num_new_digits; // Write index.\n uint64_t n = 0;\n\n // Repeat: pick up " +
"a digit, put down a digit, right to left.\n while (((int32_t)rx) >= 0) {\n n += ((uint64_t)(h->digits[rx])) << shift;\n uint64_t quo = n / 10;\n uint64_t rem = n - (10 * quo);\n if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[wx] = (uint8_t)rem;\n } else if (rem > 0) {\n h->truncated = true;\n }\n n = quo;\n wx--;\n rx--;\n }\n\n // Put down leading digits, right to left.\n while (n > 0) {\n uint64_t quo = n / 10;\n uint64_t rem = n - (10 * quo);\n if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[wx] = (uint8_t)rem;\n } else if (rem > 0) {\n h->truncated = true;\n }\n n = quo;\n wx--;\n }\n\n // Finish.\n h->num_digits += num_new_digits;\n if (h->num_digits >\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->num_digits = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n }\n h->decimal_point += (int32_t)num_new_digits;\n wuffs_base__private_implementation__high_pre" +
"c_dec__trim(h);\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__small_rshift(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t shift) {\n uint32_t rx = 0; // Read index.\n uint32_t wx = 0; // Write index.\n uint64_t n = 0;\n\n // Pick up enough leading digits to cover the first shift.\n while ((n >> shift) == 0) {\n if (rx < h->num_digits) {\n // Read a digit.\n n = (10 * n) + h->digits[rx++];\n } else if (n == 0) {\n // h's number used to be zero and remains zero.\n return;\n } else {\n // Read sufficient implicit trailing zeroes.\n while ((n >> shift) == 0) {\n n = 10 * n;\n rx++;\n }\n break;\n }\n }\n h->decimal_point -= ((int32_t)(rx - 1));\n if (h->decimal_point <\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n // After the shift, h's number is effectively zero.\n h->num_digits = 0;\n h->decimal_point = 0;\n h->truncated = false;\n return;\n }\n\n // Repeat: pick up a digi" +
"t, put down a digit, left to right.\n uint64_t mask = (((uint64_t)(1)) << shift) - 1;\n while (rx < h->num_digits) {\n uint8_t new_digit = ((uint8_t)(n >> shift));\n n = (10 * (n & mask)) + h->digits[rx++];\n h->digits[wx++] = new_digit;\n }\n\n // Put down trailing digits, left to right.\n while (n > 0) {\n uint8_t new_digit = ((uint8_t)(n >> shift));\n n = 10 * (n & mask);\n if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[wx++] = new_digit;\n } else if (new_digit > 0) {\n h->truncated = true;\n }\n }\n\n // Finish.\n h->num_digits = wx;\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__lshift(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t shift) {\n if (shift > 0) {\n while (shift > +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n wuffs_base__private_implementation__high_prec_dec__small_lshift(\n h, WUFFS_BASE__PRIVATE_I" +
"MPLEMENTATION__HPD__SHIFT__MAX_INCL);\n shift -= WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n wuffs_base__private_implementation__high_prec_dec__small_lshift(\n h, ((uint32_t)(+shift)));\n } else if (shift < 0) {\n while (shift < -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n wuffs_base__private_implementation__high_prec_dec__small_rshift(\n h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);\n shift += WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n wuffs_base__private_implementation__high_prec_dec__small_rshift(\n h, ((uint32_t)(-shift)));\n }\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__round_etc rounds h's\n// number. For those functions that take an n argument, rounding produces at\n// most n digits (which is not necessarily at most n decimal places). Negative\n// n values are ignored, as well as any n greater than or equal to h's number\n// of digits. The etc__round_just_enough function implicitly chooses an n to\n// implement WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION.\n//\n// Preconditions:\n// - h is non-NULL.\n// - h->decimal_point is \"not extreme\".\n//\n// \"Not extreme\" means within\n// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__round_down(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t n) {\n if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n return;\n }\n h->num_digits = (uint32_t)(n);\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic void //\nwuffs_base__private_implementation__hi" +
"gh_prec_dec__round_up(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t n) {\n if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n return;\n }\n\n for (n--; n >= 0; n--) {\n if (h->digits[n] < 9) {\n h->digits[n]++;\n h->num_digits = (uint32_t)(n + 1);\n return;\n }\n }\n\n // The number is all 9s. Change to a single 1 and adjust the decimal point.\n h->digits[0] = 1;\n h->num_digits = 1;\n h->decimal_point++;\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__round_nearest(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t n) {\n if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n return;\n }\n bool up = h->digits[n] >= 5;\n if ((h->digits[n] == 5) && ((n + 1) == ((int32_t)(h->num_digits)))) {\n up = h->truncated || //\n ((n > 0) && ((h->digits[n - 1] & 1) != 0));\n }\n\n if (up) {\n wuffs_base__private_implementation__high_prec_dec__round_up(h, n);\n } else {\n wuffs_base__private_implementation__high_prec_dec__round_do" +
"wn(h, n);\n }\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__round_just_enough(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t exp2,\n uint64_t mantissa) {\n // The magic numbers 52 and 53 in this function are because IEEE 754 double\n // precision has 52 mantissa bits.\n //\n // Let f be the floating point number represented by exp2 and mantissa (and\n // also the number in h): the number (mantissa * (2 ** (exp2 - 52))).\n //\n // If f is zero or a small integer, we can return early.\n if ((mantissa == 0) ||\n ((exp2 < 53) && (h->decimal_point >= ((int32_t)(h->num_digits))))) {\n return;\n }\n\n // The smallest normal f has an exp2 of -1022 and a mantissa of (1 << 52).\n // Subnormal numbers have the same exp2 but a smaller mantissa.\n static const int32_t min_incl_normal_exp2 = -1022;\n static const uint64_t min_incl_normal_mantissa = 0x0010000000000000ul;\n\n // Compute lower and upper bounds such that any number between them (possibly\n // inclusive) wil" +
"l round to f. First, the lower bound. Our number f is:\n // ((mantissa + 0) * (2 ** ( exp2 - 52)))\n //\n // The next lowest floating point number is:\n // ((mantissa - 1) * (2 ** ( exp2 - 52)))\n // unless (mantissa - 1) drops the (1 << 52) bit and exp2 is not the\n // min_incl_normal_exp2. Either way, call it:\n // ((l_mantissa) * (2 ** (l_exp2 - 52)))\n //\n // The lower bound is halfway between them (noting that 52 became 53):\n // (((2 * l_mantissa) + 1) * (2 ** (l_exp2 - 53)))\n int32_t l_exp2 = exp2;\n uint64_t l_mantissa = mantissa - 1;\n if ((exp2 > min_incl_normal_exp2) && (mantissa <= min_incl_normal_mantissa)) {\n l_exp2 = exp2 - 1;\n l_mantissa = (2 * mantissa) - 1;\n }\n wuffs_base__private_implementation__high_prec_dec lower;\n wuffs_base__private_implementation__high_prec_dec__assign(\n &lower, (2 * l_mantissa) + 1, false);\n wuffs_base__private_implementation__high_prec_dec__lshift(&lower,\n " +
"l_exp2 - 53);\n\n // Next, the upper bound. Our number f is:\n // ((mantissa + 0) * (2 ** (exp2 - 52)))\n //\n // The next highest floating point number is:\n // ((mantissa + 1) * (2 ** (exp2 - 52)))\n //\n // The upper bound is halfway between them (noting that 52 became 53):\n // (((2 * mantissa) + 1) * (2 ** (exp2 - 53)))\n wuffs_base__private_implementation__high_prec_dec upper;\n wuffs_base__private_implementation__high_prec_dec__assign(\n &upper, (2 * mantissa) + 1, false);\n wuffs_base__private_implementation__high_prec_dec__lshift(&upper, exp2 - 53);\n\n // The lower and upper bounds are possible outputs only if the original\n // mantissa is even, so that IEEE round-to-even would round to the original\n // mantissa and not its neighbors.\n bool inclusive = (mantissa & 1) == 0;\n\n // As we walk the digits, we want to know whether rounding up would fall\n // within the upper bound. This is tracked by upper_delta:\n // - When -1, the digits of h and upper are the same so far.\n // -" +
" When +0, we saw a difference of 1 between h and upper on a previous\n // digit and subsequently only 9s for h and 0s for upper. Thus, rounding\n // up may fall outside of the bound if !inclusive.\n // - When +1, the difference is greater than 1 and we know that rounding up\n // falls within the bound.\n //\n // This is a state machine with three states. The numerical value for each\n // state (-1, +0 or +1) isn't important, other than their order.\n int upper_delta = -1;\n\n // We can now figure out the shortest number of digits required. Walk the\n // digits until h has distinguished itself from lower or upper.\n //\n // The zi and zd variables are indexes and digits, for z in l (lower), h (the\n // number) and u (upper).\n //\n // The lower, h and upper numbers may have their decimal points at different\n // places. In this case, upper is the longest, so we iterate ui starting from\n // 0 and iterate li and hi starting from either 0 or -1.\n int32_t ui = 0;\n for (;; ui++) {\n // Calculate hd, t" +
"he middle number's digit.\n int32_t hi = ui - upper.decimal_point + h->decimal_point;\n if (hi >= ((int32_t)(h->num_digits))) {\n break;\n }\n uint8_t hd = (((uint32_t)hi) < h->num_digits) ? h->digits[hi] : 0;\n\n // Calculate ld, the lower bound's digit.\n int32_t li = ui - upper.decimal_point + lower.decimal_point;\n uint8_t ld = (((uint32_t)li) < lower.num_digits) ? lower.digits[li] : 0;\n\n // We can round down (truncate) if lower has a different digit than h or if\n // lower is inclusive and is exactly the result of rounding down (i.e. we\n // have reached the final digit of lower).\n bool can_round_down =\n (ld != hd) || //\n (inclusive && ((li + 1) == ((int32_t)(lower.num_digits))));\n\n // Calculate ud, the upper bound's digit, and update upper_delta.\n uint8_t ud = (((uint32_t)ui) < upper.num_digits) ? upper.digits[ui] : 0;\n if (upper_delta < 0) {\n if ((hd + 1) < ud) {\n // For example:\n // h = 12345???\n // upper = 12347???\n " +
" upper_delta = +1;\n } else if (hd != ud) {\n // For example:\n // h = 12345???\n // upper = 12346???\n upper_delta = +0;\n }\n } else if (upper_delta == 0) {\n if ((hd != 9) || (ud != 0)) {\n // For example:\n // h = 1234598?\n // upper = 1234600?\n upper_delta = +1;\n }\n }\n\n // We can round up if upper has a different digit than h and either upper\n // is inclusive or upper is bigger than the result of rounding up.\n bool can_round_up =\n (upper_delta > 0) || //\n ((upper_delta == 0) && //\n (inclusive || ((ui + 1) < ((int32_t)(upper.num_digits)))));\n\n // If we can round either way, round to nearest. If we can round only one\n // way, do it. If we can't round, continue the loop.\n if (can_round_down) {\n if (can_round_up) {\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n h, hi + 1);\n return;\n } else {\n wuffs_base__private_implementat" +
"ion__high_prec_dec__round_down(h,\n hi + 1);\n return;\n }\n } else {\n if (can_round_up) {\n wuffs_base__private_implementation__high_prec_dec__round_up(h, hi + 1);\n return;\n }\n }\n }\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__private_implementation__parse_number_f64_eisel_lemire produces\n// the IEEE 754 double-precision value for an exact mantissa and base-10\n// exponent. For example:\n// - when parsing \"12345.678e+02\", man is 12345678 and exp10 is -1.\n// - when parsing \"-12\", man is 12 and exp10 is 0. Processing the leading\n// minus sign is the responsibility of the caller, not this function.\n//\n// On success, it returns a non-negative int64_t such that the low 63 bits hold\n// the 11-bit exponent and 52-bit mantissa.\n//\n// On failure, it returns a negative value.\n//\n// The algorithm is based on an original idea by Michael Eisel that was refined\n// by Daniel Lemire. See\n// https://lemire.me/blog/2020/03/10/fast-float-parsing-in-practice/\n// and\n// https://nigeltao.github.io/blog/2020/eisel-lemire.html\n//\n// Preconditions:\n// - man is non-zero.\n// - exp10 is in the range [-307 ..= 288], the same range of the\n// wuffs_base__private_implementation__powers_of_10 array.\n//\n// The exp10 range (and th" +
"e fact that man is in the range [1 ..= UINT64_MAX],\n// approximately [1 ..= 1.85e+19]) means that (man * (10 ** exp10)) is in the\n// range [1e-307 ..= 1.85e+307]. This is entirely within the range of normal\n// (neither subnormal nor non-finite) f64 values: DBL_MIN and DBL_MAX are\n// approximately 2.23e–308 and 1.80e+308.\nstatic int64_t //\nwuffs_base__private_implementation__parse_number_f64_eisel_lemire(\n uint64_t man,\n int32_t exp10) {\n // Look up the (possibly truncated) base-2 representation of (10 ** exp10).\n // The look-up table was constructed so that it is already normalized: the\n // table entry's mantissa's MSB (most significant bit) is on.\n const uint64_t* po10 =\n &wuffs_base__private_implementation__powers_of_10[exp10 + 307][0];\n\n // Normalize the man argument. The (man != 0) precondition means that a\n // non-zero bit exists.\n uint32_t clz = wuffs_base__count_leading_zeroes_u64(man);\n man <<= clz;\n\n // Calculate the return value's base-2 exponent. We might tweak it by ±1\n //" +
" later, but its initial value comes from a linear scaling of exp10,\n // converting from power-of-10 to power-of-2, and adjusting by clz.\n //\n // The magic constants are:\n // - 1087 = 1023 + 64. The 1023 is the f64 exponent bias. The 64 is because\n // the look-up table uses 64-bit mantissas.\n // - 217706 is such that the ratio 217706 / 65536 ≈ 3.321930 is close enough\n // (over the practical range of exp10) to log(10) / log(2) ≈ 3.321928.\n // - 65536 = 1<<16 is arbitrary but a power of 2, so division is a shift.\n //\n // Equality of the linearly-scaled value and the actual power-of-2, over the\n // range of exp10 arguments that this function accepts, is confirmed by\n // script/print-mpb-powers-of-10.go\n uint64_t ret_exp2 =\n ((uint64_t)(((217706 * exp10) >> 16) + 1087)) - ((uint64_t)clz);\n\n // Multiply the two mantissas. Normalization means that both mantissas are at\n // least (1<<63), so the 128-bit product must be at least (1<<126). The high\n // 64 bits of the product, x_hi, mu" +
"st therefore be at least (1<<62).\n //\n // As a consequence, x_hi has either 0 or 1 leading zeroes. Shifting x_hi\n // right by either 9 or 10 bits (depending on x_hi's MSB) will therefore\n // leave the top 10 MSBs (bits 54 ..= 63) off and the 11th MSB (bit 53) on.\n wuffs_base__multiply_u64__output x = wuffs_base__multiply_u64(man, po10[1]);\n uint64_t x_hi = x.hi;\n uint64_t x_lo = x.lo;\n\n // Before we shift right by at least 9 bits, recall that the look-up table\n // entry was possibly truncated. We have so far only calculated a lower bound\n // for the product (man * e), where e is (10 ** exp10). The upper bound would\n // add a further (man * 1) to the 128-bit product, which overflows the lower\n // 64-bit limb if ((x_lo + man) < man).\n //\n // If overflow occurs, that adds 1 to x_hi. Since we're about to shift right\n // by at least 9 bits, that carried 1 can be ignored unless the higher 64-bit\n // limb's low 9 bits are all on.\n //\n // For example, parsing \"9999999999999999999\" will take the if-t" +
"rue branch\n // here, since:\n // - x_hi = 0x4563918244F3FFFF\n // - x_lo = 0x8000000000000000\n // - man = 0x8AC7230489E7FFFF\n if (((x_hi & 0x1FF) == 0x1FF) && ((x_lo + man) < man)) {\n // Refine our calculation of (man * e). Before, our approximation of e used\n // a \"low resolution\" 64-bit mantissa. Now use a \"high resolution\" 128-bit\n // mantissa. We've already calculated x = (man * bits_0_to_63_incl_of_e).\n // Now calculate y = (man * bits_64_to_127_incl_of_e).\n wuffs_base__multiply_u64__output y = wuffs_base__multiply_u64(man, po10[0]);\n uint64_t y_hi = y.hi;\n uint64_t y_lo = y.lo;\n\n // Merge the 128-bit x and 128-bit y, which overlap by 64 bits, to\n // calculate the 192-bit product of the 64-bit man by the 128-bit e.\n // As we exit this if-block, we only care about the high 128 bits\n // (merged_hi and merged_lo) of that 192-bit product.\n //\n // For example, parsing \"1.234e-45\" will take the if-true branch here,\n // since:\n // - x_hi = 0x70B7E3696DB29FFF\n" +
" // - x_lo = 0xE040000000000000\n // - y_hi = 0x33718BBEAB0E0D7A\n // - y_lo = 0xA880000000000000\n uint64_t merged_hi = x_hi;\n uint64_t merged_lo = x_lo + y_hi;\n if (merged_lo < x_lo) {\n merged_hi++; // Carry the overflow bit.\n }\n\n // The \"high resolution\" approximation of e is still a lower bound. Once\n // again, see if the upper bound is large enough to produce a different\n // result. This time, if it does, give up instead of reaching for an even\n // more precise approximation to e.\n //\n // This three-part check is similar to the two-part check that guarded the\n // if block that we're now in, but it has an extra term for the middle 64\n // bits (checking that adding 1 to merged_lo would overflow).\n //\n // For example, parsing \"5.9604644775390625e-8\" will take the if-true\n // branch here, since:\n // - merged_hi = 0x7FFFFFFFFFFFFFFF\n // - merged_lo = 0xFFFFFFFFFFFFFFFF\n // - y_lo = 0x4DB3FFC120988200\n // - man = 0xD3C21BCEC" +
"CEDA100\n if (((merged_hi & 0x1FF) == 0x1FF) && ((merged_lo + 1) == 0) &&\n (y_lo + man < man)) {\n return -1;\n }\n\n // Replace the 128-bit x with merged.\n x_hi = merged_hi;\n x_lo = merged_lo;\n }\n\n // As mentioned above, shifting x_hi right by either 9 or 10 bits will leave\n // the top 10 MSBs (bits 54 ..= 63) off and the 11th MSB (bit 53) on. If the\n // MSB (before shifting) was on, adjust ret_exp2 for the larger shift.\n //\n // Having bit 53 on (and higher bits off) means that ret_mantissa is a 54-bit\n // number.\n uint64_t msb = x_hi >> 63;\n uint64_t ret_mantissa = x_hi >> (msb + 9);\n ret_exp2 -= 1 ^ msb;\n\n // IEEE 754 rounds to-nearest with ties rounded to-even. Rounding to-even can\n // be tricky. If we're half-way between two exactly representable numbers\n // (x's low 73 bits are zero and the next 2 bits that matter are \"01\"), give\n // up instead of trying to pick the winner.\n //\n // Technically, we could tighten the condition by changing \"73\" to \"73 or 74,\n // depen" +
"ding on msb\", but a flat \"73\" is simpler.\n //\n // For example, parsing \"1e+23\" will take the if-true branch here, since:\n // - x_hi = 0x54B40B1F852BDA00\n // - ret_mantissa = 0x002A5A058FC295ED\n if ((x_lo == 0) && ((x_hi & 0x1FF) == 0) && ((ret_mantissa & 3) == 1)) {\n return -1;\n }\n\n // If we're not halfway then it's rounding to-nearest. Starting with a 54-bit\n // number, carry the lowest bit (bit 0) up if it's on. Regardless of whether\n // it was on or off, shifting right by one then produces a 53-bit number. If\n // carrying up overflowed, shift again.\n ret_mantissa += ret_mantissa & 1;\n ret_mantissa >>= 1;\n // This if block is equivalent to (but benchmarks slightly faster than) the\n // following branchless form:\n // uint64_t overflow_adjustment = ret_mantissa >> 53;\n // ret_mantissa >>= overflow_adjustment;\n // ret_exp2 += overflow_adjustment;\n //\n // For example, parsing \"7.2057594037927933e+16\" will take the if-true\n // branch here, since:\n // - x_hi =" +
" 0x7FFFFFFFFFFFFE80\n // - ret_mantissa = 0x0020000000000000\n if ((ret_mantissa >> 53) > 0) {\n ret_mantissa >>= 1;\n ret_exp2++;\n }\n\n // Starting with a 53-bit number, IEEE 754 double-precision normal numbers\n // have an implicit mantissa bit. Mask that away and keep the low 52 bits.\n ret_mantissa &= 0x000FFFFFFFFFFFFF;\n\n // Pack the bits and return.\n return ((int64_t)(ret_mantissa | (ret_exp2 << 52)));\n}\n\n" +
"" +
"// --------\n\nstatic wuffs_base__result_f64 //\nwuffs_base__private_implementation__parse_number_f64_special(\n wuffs_base__slice_u8 s,\n uint32_t options) {\n do {\n if (options & WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN) {\n goto fail;\n }\n\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n for (; (p < q) && (*p == '_'); p++) {\n }\n if (p >= q) {\n goto fail;\n }\n\n // Parse sign.\n bool negative = false;\n do {\n if (*p == '+') {\n p++;\n } else if (*p == '-') {\n negative = true;\n p++;\n } else {\n break;\n }\n for (; (p < q) && (*p == '_'); p++) {\n }\n } while (0);\n if (p >= q) {\n goto fail;\n }\n\n bool nan = false;\n switch (p[0]) {\n case 'I':\n case 'i':\n if (((q - p) < 3) || //\n ((p[1] != 'N') && (p[1] != 'n')) || //\n ((p[2] != 'F') && (p[2] != 'f'))) {\n goto fail;\n }\n p += 3;\n\n if ((p >= q) || (*p == '_" +
"')) {\n break;\n } else if (((q - p) < 5) || //\n ((p[0] != 'I') && (p[0] != 'i')) || //\n ((p[1] != 'N') && (p[1] != 'n')) || //\n ((p[2] != 'I') && (p[2] != 'i')) || //\n ((p[3] != 'T') && (p[3] != 't')) || //\n ((p[4] != 'Y') && (p[4] != 'y'))) {\n goto fail;\n }\n p += 5;\n\n if ((p >= q) || (*p == '_')) {\n break;\n }\n goto fail;\n\n case 'N':\n case 'n':\n if (((q - p) < 3) || //\n ((p[1] != 'A') && (p[1] != 'a')) || //\n ((p[2] != 'N') && (p[2] != 'n'))) {\n goto fail;\n }\n p += 3;\n\n if ((p >= q) || (*p == '_')) {\n nan = true;\n break;\n }\n goto fail;\n\n default:\n goto fail;\n }\n\n // Finish.\n for (; (p < q) && (*p == '_'); p++) {\n }\n if (p != q) {\n goto fail;\n }\n wuffs_base__result_f64 ret;\n" +
" ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n (nan ? 0x7FFFFFFFFFFFFFFF : 0x7FF0000000000000) |\n (negative ? 0x8000000000000000 : 0));\n return ret;\n } while (0);\n\nfail:\n do {\n wuffs_base__result_f64 ret;\n ret.status.repr = wuffs_base__error__bad_argument;\n ret.value = 0;\n return ret;\n } while (0);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //\nwuffs_base__private_implementation__high_prec_dec__to_f64(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t options) {\n do {\n // powers converts decimal powers of 10 to binary powers of 2. For example,\n // (10000 >> 13) is 1. It stops before the elements exceed 60, also known\n // as WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.\n static const uint32_t num_powers = 19;\n static const uint8_t powers[19] = {\n 0, 3, 6, 9, 13, 16, 19, 23, 26, 29, //\n 33, 36, 39, 43, 46, 49, 53, 56, 59, //\n };\n\n // Handl" +
"e zero and obvious extremes. The largest and smallest positive\n // finite f64 values are approximately 1.8e+308 and 4.9e-324.\n if ((h->num_digits == 0) || (h->decimal_point < -326)) {\n goto zero;\n } else if (h->decimal_point > 310) {\n goto infinity;\n }\n\n // Try the fast Eisel-Lemire algorithm again. Calculating the (man, exp10)\n // pair from the high_prec_dec h is more correct but slower than the\n // approach taken in wuffs_base__parse_number_f64. The latter is optimized\n // for the common cases (e.g. assuming no underscores or a leading '+'\n // sign) rather than the full set of cases allowed by the Wuffs API.\n if (h->num_digits <= 19) {\n uint64_t man = 0;\n uint32_t i;\n for (i = 0; i < h->num_digits; i++) {\n man = (10 * man) + h->digits[i];\n }\n int32_t exp10 = h->decimal_point - ((int32_t)(h->num_digits));\n if ((man != 0) && (-307 <= exp10) && (exp10 <= 288)) {\n int64_t r =\n wuffs_base__private_implementation__parse" +
"_number_f64_eisel_lemire(\n man, exp10);\n if (r >= 0) {\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n ((uint64_t)r) | (((uint64_t)(h->negative)) << 63));\n return ret;\n }\n }\n }\n\n // When Eisel-Lemire fails, fall back to Simple Decimal Conversion. See\n // https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html\n //\n // Scale by powers of 2 until we're in the range [½ .. 1], which gives us\n // our exponent (in base-2). First we shift right, possibly a little too\n // far, ending with a value certainly below 1 and possibly below ½...\n const int32_t f64_bias = -1023;\n int32_t exp2 = 0;\n while (h->decimal_point > 0) {\n uint32_t n = (uint32_t)(+h->decimal_point);\n uint32_t shift =\n (n < num_powers)\n ? powers[n]\n : WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n\n " +
" wuffs_base__private_implementation__high_prec_dec__small_rshift(h, shift);\n if (h->decimal_point <\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n goto zero;\n }\n exp2 += (int32_t)shift;\n }\n // ...then we shift left, putting us in [½ .. 1].\n while (h->decimal_point <= 0) {\n uint32_t shift;\n if (h->decimal_point == 0) {\n if (h->digits[0] >= 5) {\n break;\n }\n shift = (h->digits[0] < 2) ? 2 : 1;\n } else {\n uint32_t n = (uint32_t)(-h->decimal_point);\n shift = (n < num_powers)\n ? powers[n]\n : WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n\n wuffs_base__private_implementation__high_prec_dec__small_lshift(h, shift);\n if (h->decimal_point >\n +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n goto infinity;\n }\n exp2 -= (int32_t)shift;\n }\n\n // We're in the range [½ .. 1] but f64 uses " +
"[1 .. 2].\n exp2--;\n\n // The minimum normal exponent is (f64_bias + 1).\n while ((f64_bias + 1) > exp2) {\n uint32_t n = (uint32_t)((f64_bias + 1) - exp2);\n if (n > WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n n = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n wuffs_base__private_implementation__high_prec_dec__small_rshift(h, n);\n exp2 += (int32_t)n;\n }\n\n // Check for overflow.\n if ((exp2 - f64_bias) >= 0x07FF) { // (1 << 11) - 1.\n goto infinity;\n }\n\n // Extract 53 bits for the mantissa (in base-2).\n wuffs_base__private_implementation__high_prec_dec__small_lshift(h, 53);\n uint64_t man2 =\n wuffs_base__private_implementation__high_prec_dec__rounded_integer(h);\n\n // Rounding might have added one bit. If so, shift and re-check overflow.\n if ((man2 >> 53) != 0) {\n man2 >>= 1;\n exp2++;\n if ((exp2 - f64_bias) >= 0x07FF) { // (1 << 11) - 1.\n goto infinity;\n }\n }\n\n // Handle su" +
"bnormal numbers.\n if ((man2 >> 52) == 0) {\n exp2 = f64_bias;\n }\n\n // Pack the bits and return.\n uint64_t exp2_bits =\n (uint64_t)((exp2 - f64_bias) & 0x07FF); // (1 << 11) - 1.\n uint64_t bits = (man2 & 0x000FFFFFFFFFFFFF) | // (1 << 52) - 1.\n (exp2_bits << 52) | //\n (h->negative ? 0x8000000000000000 : 0); // (1 << 63).\n\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);\n return ret;\n } while (0);\n\nzero:\n do {\n uint64_t bits = h->negative ? 0x8000000000000000 : 0;\n\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);\n return ret;\n } while (0);\n\ninfinity:\n do {\n if (options & WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN) {\n wuffs_base__result_f64 ret;\n ret.status.repr = wuffs_base__error__bad_argument" +
";\n ret.value = 0;\n return ret;\n }\n\n uint64_t bits = h->negative ? 0xFFF0000000000000 : 0x7FF0000000000000;\n\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);\n return ret;\n } while (0);\n}\n\nstatic inline bool //\nwuffs_base__private_implementation__is_decimal_digit(uint8_t c) {\n return ('0' <= c) && (c <= '9');\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //\nwuffs_base__parse_number_f64(wuffs_base__slice_u8 s, uint32_t options) {\n // In practice, almost all \"dd.ddddE±xxx\" numbers can be represented\n // losslessly by a uint64_t mantissa \"dddddd\" and an int32_t base-10\n // exponent, adjusting \"xxx\" for the position (if present) of the decimal\n // separator '.' or ','.\n //\n // This (u64 man, i32 exp10) data structure is superficially similar to the\n // \"Do It Yourself Floating Point\" type from Loitsch (†), but the exponent\n // here is base-10, not base-2.\n //\n // If s's number fits in " +
"a (man, exp10), parse that pair with the\n // Eisel-Lemire algorithm. If not, or if Eisel-Lemire fails, parsing s with\n // the fallback algorithm is slower but comprehensive.\n //\n // † \"Printing Floating-Point Numbers Quickly and Accurately with Integers\"\n // (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf).\n // Florian Loitsch is also the primary contributor to\n // https://github.com/google/double-conversion\n do {\n // Calculating that (man, exp10) pair needs to stay within s's bounds.\n // Provided that s isn't extremely long, work on a NUL-terminated copy of\n // s's contents. The NUL byte isn't a valid part of \"±dd.ddddE±xxx\".\n //\n // As the pointer p walks the contents, it's faster to repeatedly check \"is\n // *p a valid digit\" than \"is p within bounds and *p a valid digit\".\n if (s.len >= 256) {\n goto fallback;\n }\n uint8_t z[256];\n memcpy(&z[0], s.ptr, s.len);\n z[s.len] = 0;\n const uint8_t* p = &z[0];\n\n // Look for a leading minus " +
"sign. Technically, we could also look for an\n // optional plus sign, but the \"script/process-json-numbers.c with -p\"\n // benchmark is noticably slower if we do. It's optional and, in practice,\n // usually absent. Let the fallback catch it.\n bool negative = (*p == '-');\n if (negative) {\n p++;\n }\n\n // After walking \"dd.dddd\", comparing p later with p now will produce the\n // number of \"d\"s and \".\"s.\n const uint8_t* const start_of_digits_ptr = p;\n\n // Walk the \"d\"s before a '.', 'E', NUL byte, etc. If it starts with '0',\n // it must be a single '0'. If it starts with a non-zero decimal digit, it\n // can be a sequence of decimal digits.\n //\n // Update the man variable during the walk. It's OK if man overflows now.\n // We'll detect that later.\n uint64_t man;\n if (*p == '0') {\n man = 0;\n p++;\n if (wuffs_base__private_implementation__is_decimal_digit(*p)) {\n goto fallback;\n }\n } else if (wuffs_base__private_implementation__is_decim" +
"al_digit(*p)) {\n man = ((uint8_t)(*p - '0'));\n p++;\n for (; wuffs_base__private_implementation__is_decimal_digit(*p); p++) {\n man = (10 * man) + ((uint8_t)(*p - '0'));\n }\n } else {\n goto fallback;\n }\n\n // Walk the \"d\"s after the optional decimal separator ('.' or ','),\n // updating the man and exp10 variables.\n int32_t exp10 = 0;\n if (*p ==\n ((options & WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n const uint8_t* first_after_separator_ptr = p;\n if (!wuffs_base__private_implementation__is_decimal_digit(*p)) {\n goto fallback;\n }\n man = (10 * man) + ((uint8_t)(*p - '0'));\n p++;\n for (; wuffs_base__private_implementation__is_decimal_digit(*p); p++) {\n man = (10 * man) + ((uint8_t)(*p - '0'));\n }\n exp10 = ((int32_t)(first_after_separator_ptr - p));\n }\n\n // Count the number of digits:\n // - for an input of \"314159\", digit_count " +
"is 6.\n // - for an input of \"3.14159\", digit_count is 7.\n //\n // This is off-by-one if there is a decimal separator. That's OK for now.\n // We'll correct for that later. The \"script/process-json-numbers.c with\n // -p\" benchmark is noticably slower if we try to correct for that now.\n uint32_t digit_count = (uint32_t)(p - start_of_digits_ptr);\n\n // Update exp10 for the optional exponent, starting with 'E' or 'e'.\n if ((*p | 0x20) == 'e') {\n p++;\n int32_t exp_sign = +1;\n if (*p == '-') {\n p++;\n exp_sign = -1;\n } else if (*p == '+') {\n p++;\n }\n if (!wuffs_base__private_implementation__is_decimal_digit(*p)) {\n goto fallback;\n }\n int32_t exp_num = ((uint8_t)(*p - '0'));\n p++;\n // The rest of the exp_num walking has a peculiar control flow but, once\n // again, the \"script/process-json-numbers.c with -p\" benchmark is\n // sensitive to alternative formulations.\n if (wuffs_base__private_implementation__i" +
"s_decimal_digit(*p)) {\n exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));\n p++;\n }\n if (wuffs_base__private_implementation__is_decimal_digit(*p)) {\n exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));\n p++;\n }\n while (wuffs_base__private_implementation__is_decimal_digit(*p)) {\n if (exp_num > 0x1000000) {\n goto fallback;\n }\n exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));\n p++;\n }\n exp10 += exp_sign * exp_num;\n }\n\n // The Wuffs API is that the original slice has no trailing data. It also\n // allows underscores, which we don't catch here but the fallback should.\n if (p != &z[s.len]) {\n goto fallback;\n }\n\n // Check that the uint64_t typed man variable has not overflowed, based on\n // digit_count.\n //\n // For reference:\n // - (1 << 63) is 9223372036854775808, which has 19 decimal digits.\n // - (1 << 64) is 18446744073709551616, which has 20 decimal digits.\n // - 19 nines, " +
" 9999999999999999999, is 0x8AC7230489E7FFFF, which has 64\n // bits and 16 hexadecimal digits.\n // - 20 nines, 99999999999999999999, is 0x56BC75E2D630FFFFF, which has 67\n // bits and 17 hexadecimal digits.\n if (digit_count > 19) {\n // Even if we have more than 19 pseudo-digits, it's not yet definitely an\n // overflow. Recall that digit_count might be off-by-one (too large) if\n // there's a decimal separator. It will also over-report the number of\n // meaningful digits if the input looks something like \"0.000dddExxx\".\n //\n // We adjust by the number of leading '0's and '.'s and re-compare to 19.\n // Once again, technically, we could skip ','s too, but that perturbs the\n // \"script/process-json-numbers.c with -p\" benchmark.\n const uint8_t* q = start_of_digits_ptr;\n for (; (*q == '0') || (*q == '.'); q++) {\n }\n digit_count -= (uint32_t)(q - start_of_digits_ptr);\n if (digit_count > 19) {\n goto fallback;\n }\n }\n\n " +
" // The wuffs_base__private_implementation__parse_number_f64_eisel_lemire\n // preconditions include that exp10 is in the range [-307 ..= 288].\n if ((exp10 < -307) || (288 < exp10)) {\n goto fallback;\n }\n\n // If both man and (10 ** exp10) are exactly representable by a double, we\n // don't need to run the Eisel-Lemire algorithm.\n if ((-22 <= exp10) && (exp10 <= 22) && ((man >> 53) == 0)) {\n double d = (double)man;\n if (exp10 >= 0) {\n d *= wuffs_base__private_implementation__f64_powers_of_10[+exp10];\n } else {\n d /= wuffs_base__private_implementation__f64_powers_of_10[-exp10];\n }\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = negative ? -d : +d;\n return ret;\n }\n\n // The wuffs_base__private_implementation__parse_number_f64_eisel_lemire\n // preconditions include that man is non-zero. Parsing \"0\" should be caught\n // by the \"If both man and (10 ** exp10)\" above, but \"0e99\" might not.\n if (man == 0) {\n " +
" goto fallback;\n }\n\n // Our man and exp10 are in range. Run the Eisel-Lemire algorithm.\n int64_t r =\n wuffs_base__private_implementation__parse_number_f64_eisel_lemire(\n man, exp10);\n if (r < 0) {\n goto fallback;\n }\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n ((uint64_t)r) | (((uint64_t)negative) << 63));\n return ret;\n } while (0);\n\nfallback:\n do {\n wuffs_base__private_implementation__high_prec_dec h;\n wuffs_base__status status =\n wuffs_base__private_implementation__high_prec_dec__parse(&h, s,\n options);\n if (status.repr) {\n return wuffs_base__private_implementation__parse_number_f64_special(\n s, options);\n }\n return wuffs_base__private_implementation__high_prec_dec__to_f64(&h,\n options);\n } while (0);\n" +
"}\n\n" +
"" +
"// --------\n\nstatic inline size_t //\nwuffs_base__private_implementation__render_inf(wuffs_base__slice_u8 dst,\n bool neg,\n uint32_t options) {\n if (neg) {\n if (dst.len < 4) {\n return 0;\n }\n wuffs_base__poke_u32le__no_bounds_check(dst.ptr, 0x666E492D); // '-Inf'le.\n return 4;\n }\n\n if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n if (dst.len < 4) {\n return 0;\n }\n wuffs_base__poke_u32le__no_bounds_check(dst.ptr, 0x666E492B); // '+Inf'le.\n return 4;\n }\n\n if (dst.len < 3) {\n return 0;\n }\n wuffs_base__poke_u24le__no_bounds_check(dst.ptr, 0x666E49); // 'Inf'le.\n return 3;\n}\n\nstatic inline size_t //\nwuffs_base__private_implementation__render_nan(wuffs_base__slice_u8 dst) {\n if (dst.len < 3) {\n return 0;\n }\n wuffs_base__poke_u24le__no_bounds_check(dst.ptr, 0x4E614E); // 'NaN'le.\n return 3;\n}\n\nstatic size_t //\nwuffs_base__private_implementation__high_pre" +
"c_dec__render_exponent_absent(\n wuffs_base__slice_u8 dst,\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t precision,\n uint32_t options) {\n size_t n = (h->negative ||\n (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))\n ? 1\n : 0;\n if (h->decimal_point <= 0) {\n n += 1;\n } else {\n n += (size_t)(h->decimal_point);\n }\n if (precision > 0) {\n n += precision + 1; // +1 for the '.'.\n }\n\n // Don't modify dst if the formatted number won't fit.\n if (n > dst.len) {\n return 0;\n }\n\n // Align-left or align-right.\n uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n ? &dst.ptr[dst.len - n]\n : &dst.ptr[0];\n\n // Leading \"±\".\n if (h->negative) {\n *ptr++ = '-';\n } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n *ptr++ = '+';\n }\n\n // Integral digits.\n if (h->decimal_point <= 0) {\n *ptr++ = '0';\n } else {\n uint32_t m =\n " +
" wuffs_base__u32__min(h->num_digits, (uint32_t)(h->decimal_point));\n uint32_t i = 0;\n for (; i < m; i++) {\n *ptr++ = (uint8_t)('0' | h->digits[i]);\n }\n for (; i < (uint32_t)(h->decimal_point); i++) {\n *ptr++ = '0';\n }\n }\n\n // Separator and then fractional digits.\n if (precision > 0) {\n *ptr++ =\n (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.';\n uint32_t i = 0;\n for (; i < precision; i++) {\n uint32_t j = ((uint32_t)(h->decimal_point)) + i;\n *ptr++ = (uint8_t)('0' | ((j < h->num_digits) ? h->digits[j] : 0));\n }\n }\n\n return n;\n}\n\nstatic size_t //\nwuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n wuffs_base__slice_u8 dst,\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t precision,\n uint32_t options) {\n int32_t exp = 0;\n if (h->num_digits > 0) {\n exp = h->decimal_point - 1;\n }\n bool negative_exp = exp < 0;\n if (negative_exp) {\n " +
"exp = -exp;\n }\n\n size_t n = (h->negative ||\n (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))\n ? 4\n : 3; // Mininum 3 bytes: first digit and then \"e±\".\n if (precision > 0) {\n n += precision + 1; // +1 for the '.'.\n }\n n += (exp < 100) ? 2 : 3;\n\n // Don't modify dst if the formatted number won't fit.\n if (n > dst.len) {\n return 0;\n }\n\n // Align-left or align-right.\n uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n ? &dst.ptr[dst.len - n]\n : &dst.ptr[0];\n\n // Leading \"±\".\n if (h->negative) {\n *ptr++ = '-';\n } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n *ptr++ = '+';\n }\n\n // Integral digit.\n if (h->num_digits > 0) {\n *ptr++ = (uint8_t)('0' | h->digits[0]);\n } else {\n *ptr++ = '0';\n }\n\n // Separator and then fractional digits.\n if (precision > 0) {\n *ptr++ =\n (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATO" +
"R_IS_A_COMMA)\n ? ','\n : '.';\n uint32_t i = 1;\n uint32_t j = wuffs_base__u32__min(h->num_digits, precision + 1);\n for (; i < j; i++) {\n *ptr++ = (uint8_t)('0' | h->digits[i]);\n }\n for (; i <= precision; i++) {\n *ptr++ = '0';\n }\n }\n\n // Exponent: \"e±\" and then 2 or 3 digits.\n *ptr++ = 'e';\n *ptr++ = negative_exp ? '-' : '+';\n if (exp < 10) {\n *ptr++ = '0';\n *ptr++ = (uint8_t)('0' | exp);\n } else if (exp < 100) {\n *ptr++ = (uint8_t)('0' | (exp / 10));\n *ptr++ = (uint8_t)('0' | (exp % 10));\n } else {\n int32_t e = exp / 100;\n exp -= e * 100;\n *ptr++ = (uint8_t)('0' | e);\n *ptr++ = (uint8_t)('0' | (exp / 10));\n *ptr++ = (uint8_t)('0' | (exp % 10));\n }\n\n return n;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_f64(wuffs_base__slice_u8 dst,\n double x,\n uint32_t precision,\n uint32_t options) {\n // Decompose x (64 bits) into nega" +
"tivity (1 bit), base-2 exponent (11 bits\n // with a -1023 bias) and mantissa (52 bits).\n uint64_t bits = wuffs_base__ieee_754_bit_representation__from_f64_to_u64(x);\n bool neg = (bits >> 63) != 0;\n int32_t exp2 = ((int32_t)(bits >> 52)) & 0x7FF;\n uint64_t man = bits & 0x000FFFFFFFFFFFFFul;\n\n // Apply the exponent bias and set the implicit top bit of the mantissa,\n // unless x is subnormal. Also take care of Inf and NaN.\n if (exp2 == 0x7FF) {\n if (man != 0) {\n return wuffs_base__private_implementation__render_nan(dst);\n }\n return wuffs_base__private_implementation__render_inf(dst, neg, options);\n } else if (exp2 == 0) {\n exp2 = -1022;\n } else {\n exp2 -= 1023;\n man |= 0x0010000000000000ul;\n }\n\n // Ensure that precision isn't too large.\n if (precision > 4095) {\n precision = 4095;\n }\n\n // Convert from the (neg, exp2, man) tuple to an HPD.\n wuffs_base__private_implementation__high_prec_dec h;\n wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);\n if (" +
"h.num_digits > 0) {\n wuffs_base__private_implementation__high_prec_dec__lshift(\n &h, exp2 - 52); // 52 mantissa bits.\n }\n\n // Handle the \"%e\" and \"%f\" formats.\n switch (options & (WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |\n WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT)) {\n case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT: // The \"%\"f\" format.\n if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n &h, exp2, man);\n int32_t p = ((int32_t)(h.num_digits)) - h.decimal_point;\n precision = ((uint32_t)(wuffs_base__i32__max(0, p)));\n } else {\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n &h, ((int32_t)precision) + h.decimal_point);\n }\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(\n dst, &h, precision, options);\n\n case WUFFS_BASE__RENDER_NUMBER_FX" +
"X__EXPONENT_PRESENT: // The \"%e\" format.\n if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n &h, exp2, man);\n precision = (h.num_digits > 0) ? (h.num_digits - 1) : 0;\n } else {\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n &h, ((int32_t)precision) + 1);\n }\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n dst, &h, precision, options);\n }\n\n // We have the \"%g\" format and so precision means the number of significant\n // digits, not the number of digits after the decimal separator. Perform\n // rounding and determine whether to use \"%e\" or \"%f\".\n int32_t e_threshold = 0;\n if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n &h, exp2, man);\n precision = h.num_digits;\n e_threshold = 6;\n }" +
" else {\n if (precision == 0) {\n precision = 1;\n }\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n &h, ((int32_t)precision));\n e_threshold = ((int32_t)precision);\n int32_t nd = ((int32_t)(h.num_digits));\n if ((e_threshold > nd) && (nd >= h.decimal_point)) {\n e_threshold = nd;\n }\n }\n\n // Use the \"%e\" format if the exponent is large.\n int32_t e = h.decimal_point - 1;\n if ((e < -4) || (e_threshold <= e)) {\n uint32_t p = wuffs_base__u32__min(precision, h.num_digits);\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n dst, &h, (p > 0) ? (p - 1) : 0, options);\n }\n\n // Use the \"%f\" format otherwise.\n int32_t p = ((int32_t)precision);\n if (p > h.decimal_point) {\n p = ((int32_t)(h.num_digits));\n }\n precision = ((uint32_t)(wuffs_base__i32__max(0, p - h.decimal_point)));\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(\n dst, &h, precision, options);\n}\n" +
""
const BaseFloatConvSubmoduleDataC = "" +
"// ---------------- IEEE 754 Floating Point\n\n// The etc__hpd_left_shift and etc__powers_of_5 tables were printed by\n// script/print-hpd-left-shift.go. That script has an optional -comments flag,\n// whose output is not copied here, which prints further detail.\n//\n// These tables are used in\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits.\n\n// wuffs_base__private_implementation__hpd_left_shift[i] encodes the number of\n// new digits created after multiplying a positive integer by (1 << i): the\n// additional length in the decimal representation. For example, shifting \"234\"\n// by 3 (equivalent to multiplying by 8) will produce \"1872\". Going from a\n// 3-length string to a 4-length string means that 1 new digit was added (and\n// existing digits may have changed).\n//\n// Shifting by i can add either N or N-1 new digits, depending on whether the\n// original positive integer compares >= or < to the i'th power of 5 (as 10\n// equals 2 * 5). Comparison is lexicographic, not numerical.\n//\n// For " +
"example, shifting by 4 (i.e. multiplying by 16) can add 1 or 2 new\n// digits, depending on a lexicographic comparison to (5 ** 4), i.e. \"625\":\n// - (\"1\" << 4) is \"16\", which adds 1 new digit.\n// - (\"5678\" << 4) is \"90848\", which adds 1 new digit.\n// - (\"624\" << 4) is \"9984\", which adds 1 new digit.\n// - (\"62498\" << 4) is \"999968\", which adds 1 new digit.\n// - (\"625\" << 4) is \"10000\", which adds 2 new digits.\n// - (\"625001\" << 4) is \"10000016\", which adds 2 new digits.\n// - (\"7008\" << 4) is \"112128\", which adds 2 new digits.\n// - (\"99\" << 4) is \"1584\", which adds 2 new digits.\n//\n// Thus, when i is 4, N is 2 and (5 ** i) is \"625\". This etc__hpd_left_shift\n// array encodes this as:\n// - etc__hpd_left_shift[4] is 0x1006 = (2 << 11) | 0x0006.\n// - etc__hpd_left_shift[5] is 0x1009 = (? << 11) | 0x0009.\n// where the ? isn't relevant for i == 4.\n//\n// The high 5 bits of etc__hpd_left_shift[i] is N, the higher of the two\n// possible number of new digits. The low 1" +
"1 bits are an offset into the\n// etc__powers_of_5 array (of length 0x051C, so offsets fit in 11 bits). When i\n// is 4, its offset and the next one is 6 and 9, and etc__powers_of_5[6 .. 9]\n// is the string \"\\x06\\x02\\x05\", so the relevant power of 5 is \"625\".\n//\n// Thanks to Ken Thompson for the original idea.\nstatic const uint16_t wuffs_base__private_implementation__hpd_left_shift[65] = {\n 0x0000, 0x0800, 0x0801, 0x0803, 0x1006, 0x1009, 0x100D, 0x1812, 0x1817,\n 0x181D, 0x2024, 0x202B, 0x2033, 0x203C, 0x2846, 0x2850, 0x285B, 0x3067,\n 0x3073, 0x3080, 0x388E, 0x389C, 0x38AB, 0x38BB, 0x40CC, 0x40DD, 0x40EF,\n 0x4902, 0x4915, 0x4929, 0x513E, 0x5153, 0x5169, 0x5180, 0x5998, 0x59B0,\n 0x59C9, 0x61E3, 0x61FD, 0x6218, 0x6A34, 0x6A50, 0x6A6D, 0x6A8B, 0x72AA,\n 0x72C9, 0x72E9, 0x7B0A, 0x7B2B, 0x7B4D, 0x8370, 0x8393, 0x83B7, 0x83DC,\n 0x8C02, 0x8C28, 0x8C4F, 0x9477, 0x949F, 0x94C8, 0x9CF2, 0x051C, 0x051C,\n 0x051C, 0x051C,\n};\n\n// wuffs_base__private_implementation__powers_of_5 contains the powers of 5,\n" +
"// concatenated together: \"5\", \"25\", \"125\", \"625\", \"3125\", etc.\nstatic const uint8_t wuffs_base__private_implementation__powers_of_5[0x051C] = {\n 5, 2, 5, 1, 2, 5, 6, 2, 5, 3, 1, 2, 5, 1, 5, 6, 2, 5, 7, 8, 1, 2, 5, 3, 9,\n 0, 6, 2, 5, 1, 9, 5, 3, 1, 2, 5, 9, 7, 6, 5, 6, 2, 5, 4, 8, 8, 2, 8, 1, 2,\n 5, 2, 4, 4, 1, 4, 0, 6, 2, 5, 1, 2, 2, 0, 7, 0, 3, 1, 2, 5, 6, 1, 0, 3, 5,\n 1, 5, 6, 2, 5, 3, 0, 5, 1, 7, 5, 7, 8, 1, 2, 5, 1, 5, 2, 5, 8, 7, 8, 9, 0,\n 6, 2, 5, 7, 6, 2, 9, 3, 9, 4, 5, 3, 1, 2, 5, 3, 8, 1, 4, 6, 9, 7, 2, 6, 5,\n 6, 2, 5, 1, 9, 0, 7, 3, 4, 8, 6, 3, 2, 8, 1, 2, 5, 9, 5, 3, 6, 7, 4, 3, 1,\n 6, 4, 0, 6, 2, 5, 4, 7, 6, 8, 3, 7, 1, 5, 8, 2, 0, 3, 1, 2, 5, 2, 3, 8, 4,\n 1, 8, 5, 7, 9, 1, 0, 1, 5, 6, 2, 5, 1, 1, 9, 2, 0, 9, 2, 8, 9, 5, 5, 0, 7,\n 8, 1, 2, 5, 5, 9, 6, 0, 4, 6, 4, 4, 7, 7, 5, 3, 9, 0, 6, 2, 5, 2, 9, 8, 0,\n 2, 3, 2, 2, 3, 8, 7, 6, 9, 5, 3, 1, 2, 5, 1, 4, 9, 0, 1, 1, 6, 1, 1, 9, 3,\n 8, 4, 7, 6, 5, 6, 2, 5, 7, 4, 5, 0, 5, 8, 0, 5, 9, 6, 9, 2, 3, 8, 2, 8, 1,\n 2, 5, " +
"3, 7, 2, 5, 2, 9, 0, 2, 9, 8, 4, 6, 1, 9, 1, 4, 0, 6, 2, 5, 1, 8, 6,\n 2, 6, 4, 5, 1, 4, 9, 2, 3, 0, 9, 5, 7, 0, 3, 1, 2, 5, 9, 3, 1, 3, 2, 2, 5,\n 7, 4, 6, 1, 5, 4, 7, 8, 5, 1, 5, 6, 2, 5, 4, 6, 5, 6, 6, 1, 2, 8, 7, 3, 0,\n 7, 7, 3, 9, 2, 5, 7, 8, 1, 2, 5, 2, 3, 2, 8, 3, 0, 6, 4, 3, 6, 5, 3, 8, 6,\n 9, 6, 2, 8, 9, 0, 6, 2, 5, 1, 1, 6, 4, 1, 5, 3, 2, 1, 8, 2, 6, 9, 3, 4, 8,\n 1, 4, 4, 5, 3, 1, 2, 5, 5, 8, 2, 0, 7, 6, 6, 0, 9, 1, 3, 4, 6, 7, 4, 0, 7,\n 2, 2, 6, 5, 6, 2, 5, 2, 9, 1, 0, 3, 8, 3, 0, 4, 5, 6, 7, 3, 3, 7, 0, 3, 6,\n 1, 3, 2, 8, 1, 2, 5, 1, 4, 5, 5, 1, 9, 1, 5, 2, 2, 8, 3, 6, 6, 8, 5, 1, 8,\n 0, 6, 6, 4, 0, 6, 2, 5, 7, 2, 7, 5, 9, 5, 7, 6, 1, 4, 1, 8, 3, 4, 2, 5, 9,\n 0, 3, 3, 2, 0, 3, 1, 2, 5, 3, 6, 3, 7, 9, 7, 8, 8, 0, 7, 0, 9, 1, 7, 1, 2,\n 9, 5, 1, 6, 6, 0, 1, 5, 6, 2, 5, 1, 8, 1, 8, 9, 8, 9, 4, 0, 3, 5, 4, 5, 8,\n 5, 6, 4, 7, 5, 8, 3, 0, 0, 7, 8, 1, 2, 5, 9, 0, 9, 4, 9, 4, 7, 0, 1, 7, 7,\n 2, 9, 2, 8, 2, 3, 7, 9, 1, 5, 0, 3, 9, 0, 6, 2, 5, 4, 5, 4, 7, 4, 7, 3, 5,\n 0, " +
"8, 8, 6, 4, 6, 4, 1, 1, 8, 9, 5, 7, 5, 1, 9, 5, 3, 1, 2, 5, 2, 2, 7, 3,\n 7, 3, 6, 7, 5, 4, 4, 3, 2, 3, 2, 0, 5, 9, 4, 7, 8, 7, 5, 9, 7, 6, 5, 6, 2,\n 5, 1, 1, 3, 6, 8, 6, 8, 3, 7, 7, 2, 1, 6, 1, 6, 0, 2, 9, 7, 3, 9, 3, 7, 9,\n 8, 8, 2, 8, 1, 2, 5, 5, 6, 8, 4, 3, 4, 1, 8, 8, 6, 0, 8, 0, 8, 0, 1, 4, 8,\n 6, 9, 6, 8, 9, 9, 4, 1, 4, 0, 6, 2, 5, 2, 8, 4, 2, 1, 7, 0, 9, 4, 3, 0, 4,\n 0, 4, 0, 0, 7, 4, 3, 4, 8, 4, 4, 9, 7, 0, 7, 0, 3, 1, 2, 5, 1, 4, 2, 1, 0,\n 8, 5, 4, 7, 1, 5, 2, 0, 2, 0, 0, 3, 7, 1, 7, 4, 2, 2, 4, 8, 5, 3, 5, 1, 5,\n 6, 2, 5, 7, 1, 0, 5, 4, 2, 7, 3, 5, 7, 6, 0, 1, 0, 0, 1, 8, 5, 8, 7, 1, 1,\n 2, 4, 2, 6, 7, 5, 7, 8, 1, 2, 5, 3, 5, 5, 2, 7, 1, 3, 6, 7, 8, 8, 0, 0, 5,\n 0, 0, 9, 2, 9, 3, 5, 5, 6, 2, 1, 3, 3, 7, 8, 9, 0, 6, 2, 5, 1, 7, 7, 6, 3,\n 5, 6, 8, 3, 9, 4, 0, 0, 2, 5, 0, 4, 6, 4, 6, 7, 7, 8, 1, 0, 6, 6, 8, 9, 4,\n 5, 3, 1, 2, 5, 8, 8, 8, 1, 7, 8, 4, 1, 9, 7, 0, 0, 1, 2, 5, 2, 3, 2, 3, 3,\n 8, 9, 0, 5, 3, 3, 4, 4, 7, 2, 6, 5, 6, 2, 5, 4, 4, 4, 0, 8, 9, 2, 0, 9, 8,\n " +
"5, 0, 0, 6, 2, 6, 1, 6, 1, 6, 9, 4, 5, 2, 6, 6, 7, 2, 3, 6, 3, 2, 8, 1, 2,\n 5, 2, 2, 2, 0, 4, 4, 6, 0, 4, 9, 2, 5, 0, 3, 1, 3, 0, 8, 0, 8, 4, 7, 2, 6,\n 3, 3, 3, 6, 1, 8, 1, 6, 4, 0, 6, 2, 5, 1, 1, 1, 0, 2, 2, 3, 0, 2, 4, 6, 2,\n 5, 1, 5, 6, 5, 4, 0, 4, 2, 3, 6, 3, 1, 6, 6, 8, 0, 9, 0, 8, 2, 0, 3, 1, 2,\n 5, 5, 5, 5, 1, 1, 1, 5, 1, 2, 3, 1, 2, 5, 7, 8, 2, 7, 0, 2, 1, 1, 8, 1, 5,\n 8, 3, 4, 0, 4, 5, 4, 1, 0, 1, 5, 6, 2, 5, 2, 7, 7, 5, 5, 5, 7, 5, 6, 1, 5,\n 6, 2, 8, 9, 1, 3, 5, 1, 0, 5, 9, 0, 7, 9, 1, 7, 0, 2, 2, 7, 0, 5, 0, 7, 8,\n 1, 2, 5, 1, 3, 8, 7, 7, 7, 8, 7, 8, 0, 7, 8, 1, 4, 4, 5, 6, 7, 5, 5, 2, 9,\n 5, 3, 9, 5, 8, 5, 1, 1, 3, 5, 2, 5, 3, 9, 0, 6, 2, 5, 6, 9, 3, 8, 8, 9, 3,\n 9, 0, 3, 9, 0, 7, 2, 2, 8, 3, 7, 7, 6, 4, 7, 6, 9, 7, 9, 2, 5, 5, 6, 7, 6,\n 2, 6, 9, 5, 3, 1, 2, 5, 3, 4, 6, 9, 4, 4, 6, 9, 5, 1, 9, 5, 3, 6, 1, 4, 1,\n 8, 8, 8, 2, 3, 8, 4, 8, 9, 6, 2, 7, 8, 3, 8, 1, 3, 4, 7, 6, 5, 6, 2, 5, 1,\n 7, 3, 4, 7, 2, 3, 4, 7, 5, 9, 7, 6, 8, 0, 7, 0, 9, 4, 4, 1, 1, 9, 2, 4, 4,\n " +
" 8, 1, 3, 9, 1, 9, 0, 6, 7, 3, 8, 2, 8, 1, 2, 5, 8, 6, 7, 3, 6, 1, 7, 3, 7,\n 9, 8, 8, 4, 0, 3, 5, 4, 7, 2, 0, 5, 9, 6, 2, 2, 4, 0, 6, 9, 5, 9, 5, 3, 3,\n 6, 9, 1, 4, 0, 6, 2, 5,\n};\n\n" +
"" +
"// --------\n\n// wuffs_base__private_implementation__powers_of_10 contains truncated\n// approximations to the powers of 10, ranging from 1e-307 to 1e+288 inclusive,\n// as 596 pairs of uint64_t values (a 128-bit mantissa).\n//\n// There's also an implicit third column (implied by a linear formula involving\n// the base-10 exponent) that is the base-2 exponent, biased by a magic\n// constant. That constant (1214 or 0x04BE) equals 1023 + 191. 1023 is the bias\n// for IEEE 754 double-precision floating point. 191 is ((3 * 64) - 1) and\n// wuffs_base__private_implementation__parse_number_f64_eisel_lemire works with\n// multiples-of-64-bit mantissas.\n//\n// For example, the third row holds the approximation to 1e-305:\n// 0xE0B62E29_29ABA83C_331ACDAB_FE94DE87 * (2 ** (0x0049 - 0x04BE))\n//\n// Similarly, 1e+4 is approximated by:\n// 0x9C400000_00000000_00000000_00000000 * (2 ** (0x044C - 0x04BE))\n//\n// Similarly, 1e+68 is approximated by:\n// 0xED63A231_D4C4FB27_4CA7AAA8_63EE4BDD * (2 ** (0x0520 - 0x04BE))\n//\n// This table" +
" was generated by by script/print-mpb-powers-of-10.go\nstatic const uint64_t wuffs_base__private_implementation__powers_of_10[596][2] =\n {\n {0xA5D3B6D479F8E056, 0x8FD0C16206306BAB}, // 1e-307\n {0x8F48A4899877186C, 0xB3C4F1BA87BC8696}, // 1e-306\n {0x331ACDABFE94DE87, 0xE0B62E2929ABA83C}, // 1e-305\n {0x9FF0C08B7F1D0B14, 0x8C71DCD9BA0B4925}, // 1e-304\n {0x07ECF0AE5EE44DD9, 0xAF8E5410288E1B6F}, // 1e-303\n {0xC9E82CD9F69D6150, 0xDB71E91432B1A24A}, // 1e-302\n {0xBE311C083A225CD2, 0x892731AC9FAF056E}, // 1e-301\n {0x6DBD630A48AAF406, 0xAB70FE17C79AC6CA}, // 1e-300\n {0x092CBBCCDAD5B108, 0xD64D3D9DB981787D}, // 1e-299\n {0x25BBF56008C58EA5, 0x85F0468293F0EB4E}, // 1e-298\n {0xAF2AF2B80AF6F24E, 0xA76C582338ED2621}, // 1e-297\n {0x1AF5AF660DB4AEE1, 0xD1476E2C07286FAA}, // 1e-296\n {0x50D98D9FC890ED4D, 0x82CCA4DB847945CA}, // 1e-295\n {0xE50FF107BAB528A0, 0xA37FCE126597973C}, // 1e-294\n {0x1E53ED49A96272C8, " +
"0xCC5FC196FEFD7D0C}, // 1e-293\n {0x25E8E89C13BB0F7A, 0xFF77B1FCBEBCDC4F}, // 1e-292\n {0x77B191618C54E9AC, 0x9FAACF3DF73609B1}, // 1e-291\n {0xD59DF5B9EF6A2417, 0xC795830D75038C1D}, // 1e-290\n {0x4B0573286B44AD1D, 0xF97AE3D0D2446F25}, // 1e-289\n {0x4EE367F9430AEC32, 0x9BECCE62836AC577}, // 1e-288\n {0x229C41F793CDA73F, 0xC2E801FB244576D5}, // 1e-287\n {0x6B43527578C1110F, 0xF3A20279ED56D48A}, // 1e-286\n {0x830A13896B78AAA9, 0x9845418C345644D6}, // 1e-285\n {0x23CC986BC656D553, 0xBE5691EF416BD60C}, // 1e-284\n {0x2CBFBE86B7EC8AA8, 0xEDEC366B11C6CB8F}, // 1e-283\n {0x7BF7D71432F3D6A9, 0x94B3A202EB1C3F39}, // 1e-282\n {0xDAF5CCD93FB0CC53, 0xB9E08A83A5E34F07}, // 1e-281\n {0xD1B3400F8F9CFF68, 0xE858AD248F5C22C9}, // 1e-280\n {0x23100809B9C21FA1, 0x91376C36D99995BE}, // 1e-279\n {0xABD40A0C2832A78A, 0xB58547448FFFFB2D}, // 1e-278\n {0x16C90C8F323F516C, 0xE2E69915B3FFF9F9}, // 1e-277\n {0xAE3DA" +
"7D97F6792E3, 0x8DD01FAD907FFC3B}, // 1e-276\n {0x99CD11CFDF41779C, 0xB1442798F49FFB4A}, // 1e-275\n {0x40405643D711D583, 0xDD95317F31C7FA1D}, // 1e-274\n {0x482835EA666B2572, 0x8A7D3EEF7F1CFC52}, // 1e-273\n {0xDA3243650005EECF, 0xAD1C8EAB5EE43B66}, // 1e-272\n {0x90BED43E40076A82, 0xD863B256369D4A40}, // 1e-271\n {0x5A7744A6E804A291, 0x873E4F75E2224E68}, // 1e-270\n {0x711515D0A205CB36, 0xA90DE3535AAAE202}, // 1e-269\n {0x0D5A5B44CA873E03, 0xD3515C2831559A83}, // 1e-268\n {0xE858790AFE9486C2, 0x8412D9991ED58091}, // 1e-267\n {0x626E974DBE39A872, 0xA5178FFF668AE0B6}, // 1e-266\n {0xFB0A3D212DC8128F, 0xCE5D73FF402D98E3}, // 1e-265\n {0x7CE66634BC9D0B99, 0x80FA687F881C7F8E}, // 1e-264\n {0x1C1FFFC1EBC44E80, 0xA139029F6A239F72}, // 1e-263\n {0xA327FFB266B56220, 0xC987434744AC874E}, // 1e-262\n {0x4BF1FF9F0062BAA8, 0xFBE9141915D7A922}, // 1e-261\n {0x6F773FC3603DB4A9, 0x9D71AC8FADA6C9B5}, // 1e-260\n " +
" {0xCB550FB4384D21D3, 0xC4CE17B399107C22}, // 1e-259\n {0x7E2A53A146606A48, 0xF6019DA07F549B2B}, // 1e-258\n {0x2EDA7444CBFC426D, 0x99C102844F94E0FB}, // 1e-257\n {0xFA911155FEFB5308, 0xC0314325637A1939}, // 1e-256\n {0x793555AB7EBA27CA, 0xF03D93EEBC589F88}, // 1e-255\n {0x4BC1558B2F3458DE, 0x96267C7535B763B5}, // 1e-254\n {0x9EB1AAEDFB016F16, 0xBBB01B9283253CA2}, // 1e-253\n {0x465E15A979C1CADC, 0xEA9C227723EE8BCB}, // 1e-252\n {0x0BFACD89EC191EC9, 0x92A1958A7675175F}, // 1e-251\n {0xCEF980EC671F667B, 0xB749FAED14125D36}, // 1e-250\n {0x82B7E12780E7401A, 0xE51C79A85916F484}, // 1e-249\n {0xD1B2ECB8B0908810, 0x8F31CC0937AE58D2}, // 1e-248\n {0x861FA7E6DCB4AA15, 0xB2FE3F0B8599EF07}, // 1e-247\n {0x67A791E093E1D49A, 0xDFBDCECE67006AC9}, // 1e-246\n {0xE0C8BB2C5C6D24E0, 0x8BD6A141006042BD}, // 1e-245\n {0x58FAE9F773886E18, 0xAECC49914078536D}, // 1e-244\n {0xAF39A475506A899E, 0xDA7F5BF590966848}, " +
"// 1e-243\n {0x6D8406C952429603, 0x888F99797A5E012D}, // 1e-242\n {0xC8E5087BA6D33B83, 0xAAB37FD7D8F58178}, // 1e-241\n {0xFB1E4A9A90880A64, 0xD5605FCDCF32E1D6}, // 1e-240\n {0x5CF2EEA09A55067F, 0x855C3BE0A17FCD26}, // 1e-239\n {0xF42FAA48C0EA481E, 0xA6B34AD8C9DFC06F}, // 1e-238\n {0xF13B94DAF124DA26, 0xD0601D8EFC57B08B}, // 1e-237\n {0x76C53D08D6B70858, 0x823C12795DB6CE57}, // 1e-236\n {0x54768C4B0C64CA6E, 0xA2CB1717B52481ED}, // 1e-235\n {0xA9942F5DCF7DFD09, 0xCB7DDCDDA26DA268}, // 1e-234\n {0xD3F93B35435D7C4C, 0xFE5D54150B090B02}, // 1e-233\n {0xC47BC5014A1A6DAF, 0x9EFA548D26E5A6E1}, // 1e-232\n {0x359AB6419CA1091B, 0xC6B8E9B0709F109A}, // 1e-231\n {0xC30163D203C94B62, 0xF867241C8CC6D4C0}, // 1e-230\n {0x79E0DE63425DCF1D, 0x9B407691D7FC44F8}, // 1e-229\n {0x985915FC12F542E4, 0xC21094364DFB5636}, // 1e-228\n {0x3E6F5B7B17B2939D, 0xF294B943E17A2BC4}, // 1e-227\n {0xA705992CEECF9C42, 0x979CF3C" +
"A6CEC5B5A}, // 1e-226\n {0x50C6FF782A838353, 0xBD8430BD08277231}, // 1e-225\n {0xA4F8BF5635246428, 0xECE53CEC4A314EBD}, // 1e-224\n {0x871B7795E136BE99, 0x940F4613AE5ED136}, // 1e-223\n {0x28E2557B59846E3F, 0xB913179899F68584}, // 1e-222\n {0x331AEADA2FE589CF, 0xE757DD7EC07426E5}, // 1e-221\n {0x3FF0D2C85DEF7621, 0x9096EA6F3848984F}, // 1e-220\n {0x0FED077A756B53A9, 0xB4BCA50B065ABE63}, // 1e-219\n {0xD3E8495912C62894, 0xE1EBCE4DC7F16DFB}, // 1e-218\n {0x64712DD7ABBBD95C, 0x8D3360F09CF6E4BD}, // 1e-217\n {0xBD8D794D96AACFB3, 0xB080392CC4349DEC}, // 1e-216\n {0xECF0D7A0FC5583A0, 0xDCA04777F541C567}, // 1e-215\n {0xF41686C49DB57244, 0x89E42CAAF9491B60}, // 1e-214\n {0x311C2875C522CED5, 0xAC5D37D5B79B6239}, // 1e-213\n {0x7D633293366B828B, 0xD77485CB25823AC7}, // 1e-212\n {0xAE5DFF9C02033197, 0x86A8D39EF77164BC}, // 1e-211\n {0xD9F57F830283FDFC, 0xA8530886B54DBDEB}, // 1e-210\n {0xD072DF63C324FD" +
"7B, 0xD267CAA862A12D66}, // 1e-209\n {0x4247CB9E59F71E6D, 0x8380DEA93DA4BC60}, // 1e-208\n {0x52D9BE85F074E608, 0xA46116538D0DEB78}, // 1e-207\n {0x67902E276C921F8B, 0xCD795BE870516656}, // 1e-206\n {0x00BA1CD8A3DB53B6, 0x806BD9714632DFF6}, // 1e-205\n {0x80E8A40ECCD228A4, 0xA086CFCD97BF97F3}, // 1e-204\n {0x6122CD128006B2CD, 0xC8A883C0FDAF7DF0}, // 1e-203\n {0x796B805720085F81, 0xFAD2A4B13D1B5D6C}, // 1e-202\n {0xCBE3303674053BB0, 0x9CC3A6EEC6311A63}, // 1e-201\n {0xBEDBFC4411068A9C, 0xC3F490AA77BD60FC}, // 1e-200\n {0xEE92FB5515482D44, 0xF4F1B4D515ACB93B}, // 1e-199\n {0x751BDD152D4D1C4A, 0x991711052D8BF3C5}, // 1e-198\n {0xD262D45A78A0635D, 0xBF5CD54678EEF0B6}, // 1e-197\n {0x86FB897116C87C34, 0xEF340A98172AACE4}, // 1e-196\n {0xD45D35E6AE3D4DA0, 0x9580869F0E7AAC0E}, // 1e-195\n {0x8974836059CCA109, 0xBAE0A846D2195712}, // 1e-194\n {0x2BD1A438703FC94B, 0xE998D258869FACD7}, // 1e-193\n {0x7" +
"B6306A34627DDCF, 0x91FF83775423CC06}, // 1e-192\n {0x1A3BC84C17B1D542, 0xB67F6455292CBF08}, // 1e-191\n {0x20CABA5F1D9E4A93, 0xE41F3D6A7377EECA}, // 1e-190\n {0x547EB47B7282EE9C, 0x8E938662882AF53E}, // 1e-189\n {0xE99E619A4F23AA43, 0xB23867FB2A35B28D}, // 1e-188\n {0x6405FA00E2EC94D4, 0xDEC681F9F4C31F31}, // 1e-187\n {0xDE83BC408DD3DD04, 0x8B3C113C38F9F37E}, // 1e-186\n {0x9624AB50B148D445, 0xAE0B158B4738705E}, // 1e-185\n {0x3BADD624DD9B0957, 0xD98DDAEE19068C76}, // 1e-184\n {0xE54CA5D70A80E5D6, 0x87F8A8D4CFA417C9}, // 1e-183\n {0x5E9FCF4CCD211F4C, 0xA9F6D30A038D1DBC}, // 1e-182\n {0x7647C3200069671F, 0xD47487CC8470652B}, // 1e-181\n {0x29ECD9F40041E073, 0x84C8D4DFD2C63F3B}, // 1e-180\n {0xF468107100525890, 0xA5FB0A17C777CF09}, // 1e-179\n {0x7182148D4066EEB4, 0xCF79CC9DB955C2CC}, // 1e-178\n {0xC6F14CD848405530, 0x81AC1FE293D599BF}, // 1e-177\n {0xB8ADA00E5A506A7C, 0xA21727DB38CB002F}, // 1e-176" +
"\n {0xA6D90811F0E4851C, 0xCA9CF1D206FDC03B}, // 1e-175\n {0x908F4A166D1DA663, 0xFD442E4688BD304A}, // 1e-174\n {0x9A598E4E043287FE, 0x9E4A9CEC15763E2E}, // 1e-173\n {0x40EFF1E1853F29FD, 0xC5DD44271AD3CDBA}, // 1e-172\n {0xD12BEE59E68EF47C, 0xF7549530E188C128}, // 1e-171\n {0x82BB74F8301958CE, 0x9A94DD3E8CF578B9}, // 1e-170\n {0xE36A52363C1FAF01, 0xC13A148E3032D6E7}, // 1e-169\n {0xDC44E6C3CB279AC1, 0xF18899B1BC3F8CA1}, // 1e-168\n {0x29AB103A5EF8C0B9, 0x96F5600F15A7B7E5}, // 1e-167\n {0x7415D448F6B6F0E7, 0xBCB2B812DB11A5DE}, // 1e-166\n {0x111B495B3464AD21, 0xEBDF661791D60F56}, // 1e-165\n {0xCAB10DD900BEEC34, 0x936B9FCEBB25C995}, // 1e-164\n {0x3D5D514F40EEA742, 0xB84687C269EF3BFB}, // 1e-163\n {0x0CB4A5A3112A5112, 0xE65829B3046B0AFA}, // 1e-162\n {0x47F0E785EABA72AB, 0x8FF71A0FE2C2E6DC}, // 1e-161\n {0x59ED216765690F56, 0xB3F4E093DB73A093}, // 1e-160\n {0x306869C13EC3532C, 0xE0F218B8D25088B8" +
"}, // 1e-159\n {0x1E414218C73A13FB, 0x8C974F7383725573}, // 1e-158\n {0xE5D1929EF90898FA, 0xAFBD2350644EEACF}, // 1e-157\n {0xDF45F746B74ABF39, 0xDBAC6C247D62A583}, // 1e-156\n {0x6B8BBA8C328EB783, 0x894BC396CE5DA772}, // 1e-155\n {0x066EA92F3F326564, 0xAB9EB47C81F5114F}, // 1e-154\n {0xC80A537B0EFEFEBD, 0xD686619BA27255A2}, // 1e-153\n {0xBD06742CE95F5F36, 0x8613FD0145877585}, // 1e-152\n {0x2C48113823B73704, 0xA798FC4196E952E7}, // 1e-151\n {0xF75A15862CA504C5, 0xD17F3B51FCA3A7A0}, // 1e-150\n {0x9A984D73DBE722FB, 0x82EF85133DE648C4}, // 1e-149\n {0xC13E60D0D2E0EBBA, 0xA3AB66580D5FDAF5}, // 1e-148\n {0x318DF905079926A8, 0xCC963FEE10B7D1B3}, // 1e-147\n {0xFDF17746497F7052, 0xFFBBCFE994E5C61F}, // 1e-146\n {0xFEB6EA8BEDEFA633, 0x9FD561F1FD0F9BD3}, // 1e-145\n {0xFE64A52EE96B8FC0, 0xC7CABA6E7C5382C8}, // 1e-144\n {0x3DFDCE7AA3C673B0, 0xF9BD690A1B68637B}, // 1e-143\n {0x06BEA10CA65C084E, 0x9C1" +
"661A651213E2D}, // 1e-142\n {0x486E494FCFF30A62, 0xC31BFA0FE5698DB8}, // 1e-141\n {0x5A89DBA3C3EFCCFA, 0xF3E2F893DEC3F126}, // 1e-140\n {0xF89629465A75E01C, 0x986DDB5C6B3A76B7}, // 1e-139\n {0xF6BBB397F1135823, 0xBE89523386091465}, // 1e-138\n {0x746AA07DED582E2C, 0xEE2BA6C0678B597F}, // 1e-137\n {0xA8C2A44EB4571CDC, 0x94DB483840B717EF}, // 1e-136\n {0x92F34D62616CE413, 0xBA121A4650E4DDEB}, // 1e-135\n {0x77B020BAF9C81D17, 0xE896A0D7E51E1566}, // 1e-134\n {0x0ACE1474DC1D122E, 0x915E2486EF32CD60}, // 1e-133\n {0x0D819992132456BA, 0xB5B5ADA8AAFF80B8}, // 1e-132\n {0x10E1FFF697ED6C69, 0xE3231912D5BF60E6}, // 1e-131\n {0xCA8D3FFA1EF463C1, 0x8DF5EFABC5979C8F}, // 1e-130\n {0xBD308FF8A6B17CB2, 0xB1736B96B6FD83B3}, // 1e-129\n {0xAC7CB3F6D05DDBDE, 0xDDD0467C64BCE4A0}, // 1e-128\n {0x6BCDF07A423AA96B, 0x8AA22C0DBEF60EE4}, // 1e-127\n {0x86C16C98D2C953C6, 0xAD4AB7112EB3929D}, // 1e-126\n {0xE871C7BF07" +
"7BA8B7, 0xD89D64D57A607744}, // 1e-125\n {0x11471CD764AD4972, 0x87625F056C7C4A8B}, // 1e-124\n {0xD598E40D3DD89BCF, 0xA93AF6C6C79B5D2D}, // 1e-123\n {0x4AFF1D108D4EC2C3, 0xD389B47879823479}, // 1e-122\n {0xCEDF722A585139BA, 0x843610CB4BF160CB}, // 1e-121\n {0xC2974EB4EE658828, 0xA54394FE1EEDB8FE}, // 1e-120\n {0x733D226229FEEA32, 0xCE947A3DA6A9273E}, // 1e-119\n {0x0806357D5A3F525F, 0x811CCC668829B887}, // 1e-118\n {0xCA07C2DCB0CF26F7, 0xA163FF802A3426A8}, // 1e-117\n {0xFC89B393DD02F0B5, 0xC9BCFF6034C13052}, // 1e-116\n {0xBBAC2078D443ACE2, 0xFC2C3F3841F17C67}, // 1e-115\n {0xD54B944B84AA4C0D, 0x9D9BA7832936EDC0}, // 1e-114\n {0x0A9E795E65D4DF11, 0xC5029163F384A931}, // 1e-113\n {0x4D4617B5FF4A16D5, 0xF64335BCF065D37D}, // 1e-112\n {0x504BCED1BF8E4E45, 0x99EA0196163FA42E}, // 1e-111\n {0xE45EC2862F71E1D6, 0xC06481FB9BCF8D39}, // 1e-110\n {0x5D767327BB4E5A4C, 0xF07DA27A82C37088}, // 1e-109\n " +
"{0x3A6A07F8D510F86F, 0x964E858C91BA2655}, // 1e-108\n {0x890489F70A55368B, 0xBBE226EFB628AFEA}, // 1e-107\n {0x2B45AC74CCEA842E, 0xEADAB0ABA3B2DBE5}, // 1e-106\n {0x3B0B8BC90012929D, 0x92C8AE6B464FC96F}, // 1e-105\n {0x09CE6EBB40173744, 0xB77ADA0617E3BBCB}, // 1e-104\n {0xCC420A6A101D0515, 0xE55990879DDCAABD}, // 1e-103\n {0x9FA946824A12232D, 0x8F57FA54C2A9EAB6}, // 1e-102\n {0x47939822DC96ABF9, 0xB32DF8E9F3546564}, // 1e-101\n {0x59787E2B93BC56F7, 0xDFF9772470297EBD}, // 1e-100\n {0x57EB4EDB3C55B65A, 0x8BFBEA76C619EF36}, // 1e-99\n {0xEDE622920B6B23F1, 0xAEFAE51477A06B03}, // 1e-98\n {0xE95FAB368E45ECED, 0xDAB99E59958885C4}, // 1e-97\n {0x11DBCB0218EBB414, 0x88B402F7FD75539B}, // 1e-96\n {0xD652BDC29F26A119, 0xAAE103B5FCD2A881}, // 1e-95\n {0x4BE76D3346F0495F, 0xD59944A37C0752A2}, // 1e-94\n {0x6F70A4400C562DDB, 0x857FCAE62D8493A5}, // 1e-93\n {0xCB4CCD500F6BB952, 0xA6DFBD9FB8E5B88E}, // 1e-92\n " +
" {0x7E2000A41346A7A7, 0xD097AD07A71F26B2}, // 1e-91\n {0x8ED400668C0C28C8, 0x825ECC24C873782F}, // 1e-90\n {0x728900802F0F32FA, 0xA2F67F2DFA90563B}, // 1e-89\n {0x4F2B40A03AD2FFB9, 0xCBB41EF979346BCA}, // 1e-88\n {0xE2F610C84987BFA8, 0xFEA126B7D78186BC}, // 1e-87\n {0x0DD9CA7D2DF4D7C9, 0x9F24B832E6B0F436}, // 1e-86\n {0x91503D1C79720DBB, 0xC6EDE63FA05D3143}, // 1e-85\n {0x75A44C6397CE912A, 0xF8A95FCF88747D94}, // 1e-84\n {0xC986AFBE3EE11ABA, 0x9B69DBE1B548CE7C}, // 1e-83\n {0xFBE85BADCE996168, 0xC24452DA229B021B}, // 1e-82\n {0xFAE27299423FB9C3, 0xF2D56790AB41C2A2}, // 1e-81\n {0xDCCD879FC967D41A, 0x97C560BA6B0919A5}, // 1e-80\n {0x5400E987BBC1C920, 0xBDB6B8E905CB600F}, // 1e-79\n {0x290123E9AAB23B68, 0xED246723473E3813}, // 1e-78\n {0xF9A0B6720AAF6521, 0x9436C0760C86E30B}, // 1e-77\n {0xF808E40E8D5B3E69, 0xB94470938FA89BCE}, // 1e-76\n {0xB60B1D1230B20E04, 0xE7958CB87392C2C2}, // 1e-75\n " +
" {0xB1C6F22B5E6F48C2, 0x90BD77F3483BB9B9}, // 1e-74\n {0x1E38AEB6360B1AF3, 0xB4ECD5F01A4AA828}, // 1e-73\n {0x25C6DA63C38DE1B0, 0xE2280B6C20DD5232}, // 1e-72\n {0x579C487E5A38AD0E, 0x8D590723948A535F}, // 1e-71\n {0x2D835A9DF0C6D851, 0xB0AF48EC79ACE837}, // 1e-70\n {0xF8E431456CF88E65, 0xDCDB1B2798182244}, // 1e-69\n {0x1B8E9ECB641B58FF, 0x8A08F0F8BF0F156B}, // 1e-68\n {0xE272467E3D222F3F, 0xAC8B2D36EED2DAC5}, // 1e-67\n {0x5B0ED81DCC6ABB0F, 0xD7ADF884AA879177}, // 1e-66\n {0x98E947129FC2B4E9, 0x86CCBB52EA94BAEA}, // 1e-65\n {0x3F2398D747B36224, 0xA87FEA27A539E9A5}, // 1e-64\n {0x8EEC7F0D19A03AAD, 0xD29FE4B18E88640E}, // 1e-63\n {0x1953CF68300424AC, 0x83A3EEEEF9153E89}, // 1e-62\n {0x5FA8C3423C052DD7, 0xA48CEAAAB75A8E2B}, // 1e-61\n {0x3792F412CB06794D, 0xCDB02555653131B6}, // 1e-60\n {0xE2BBD88BBEE40BD0, 0x808E17555F3EBF11}, // 1e-59\n {0x5B6ACEAEAE9D0EC4, 0xA0B19D2AB70E6ED6}, // 1e-58\n {0x" +
"F245825A5A445275, 0xC8DE047564D20A8B}, // 1e-57\n {0xEED6E2F0F0D56712, 0xFB158592BE068D2E}, // 1e-56\n {0x55464DD69685606B, 0x9CED737BB6C4183D}, // 1e-55\n {0xAA97E14C3C26B886, 0xC428D05AA4751E4C}, // 1e-54\n {0xD53DD99F4B3066A8, 0xF53304714D9265DF}, // 1e-53\n {0xE546A8038EFE4029, 0x993FE2C6D07B7FAB}, // 1e-52\n {0xDE98520472BDD033, 0xBF8FDB78849A5F96}, // 1e-51\n {0x963E66858F6D4440, 0xEF73D256A5C0F77C}, // 1e-50\n {0xDDE7001379A44AA8, 0x95A8637627989AAD}, // 1e-49\n {0x5560C018580D5D52, 0xBB127C53B17EC159}, // 1e-48\n {0xAAB8F01E6E10B4A6, 0xE9D71B689DDE71AF}, // 1e-47\n {0xCAB3961304CA70E8, 0x9226712162AB070D}, // 1e-46\n {0x3D607B97C5FD0D22, 0xB6B00D69BB55C8D1}, // 1e-45\n {0x8CB89A7DB77C506A, 0xE45C10C42A2B3B05}, // 1e-44\n {0x77F3608E92ADB242, 0x8EB98A7A9A5B04E3}, // 1e-43\n {0x55F038B237591ED3, 0xB267ED1940F1C61C}, // 1e-42\n {0x6B6C46DEC52F6688, 0xDF01E85F912E37A3}, // 1e-41\n {0x2323" +
"AC4B3B3DA015, 0x8B61313BBABCE2C6}, // 1e-40\n {0xABEC975E0A0D081A, 0xAE397D8AA96C1B77}, // 1e-39\n {0x96E7BD358C904A21, 0xD9C7DCED53C72255}, // 1e-38\n {0x7E50D64177DA2E54, 0x881CEA14545C7575}, // 1e-37\n {0xDDE50BD1D5D0B9E9, 0xAA242499697392D2}, // 1e-36\n {0x955E4EC64B44E864, 0xD4AD2DBFC3D07787}, // 1e-35\n {0xBD5AF13BEF0B113E, 0x84EC3C97DA624AB4}, // 1e-34\n {0xECB1AD8AEACDD58E, 0xA6274BBDD0FADD61}, // 1e-33\n {0x67DE18EDA5814AF2, 0xCFB11EAD453994BA}, // 1e-32\n {0x80EACF948770CED7, 0x81CEB32C4B43FCF4}, // 1e-31\n {0xA1258379A94D028D, 0xA2425FF75E14FC31}, // 1e-30\n {0x096EE45813A04330, 0xCAD2F7F5359A3B3E}, // 1e-29\n {0x8BCA9D6E188853FC, 0xFD87B5F28300CA0D}, // 1e-28\n {0x775EA264CF55347D, 0x9E74D1B791E07E48}, // 1e-27\n {0x95364AFE032A819D, 0xC612062576589DDA}, // 1e-26\n {0x3A83DDBD83F52204, 0xF79687AED3EEC551}, // 1e-25\n {0xC4926A9672793542, 0x9ABE14CD44753B52}, // 1e-24\n {0x75B7053C" +
"0F178293, 0xC16D9A0095928A27}, // 1e-23\n {0x5324C68B12DD6338, 0xF1C90080BAF72CB1}, // 1e-22\n {0xD3F6FC16EBCA5E03, 0x971DA05074DA7BEE}, // 1e-21\n {0x88F4BB1CA6BCF584, 0xBCE5086492111AEA}, // 1e-20\n {0x2B31E9E3D06C32E5, 0xEC1E4A7DB69561A5}, // 1e-19\n {0x3AFF322E62439FCF, 0x9392EE8E921D5D07}, // 1e-18\n {0x09BEFEB9FAD487C2, 0xB877AA3236A4B449}, // 1e-17\n {0x4C2EBE687989A9B3, 0xE69594BEC44DE15B}, // 1e-16\n {0x0F9D37014BF60A10, 0x901D7CF73AB0ACD9}, // 1e-15\n {0x538484C19EF38C94, 0xB424DC35095CD80F}, // 1e-14\n {0x2865A5F206B06FB9, 0xE12E13424BB40E13}, // 1e-13\n {0xF93F87B7442E45D3, 0x8CBCCC096F5088CB}, // 1e-12\n {0xF78F69A51539D748, 0xAFEBFF0BCB24AAFE}, // 1e-11\n {0xB573440E5A884D1B, 0xDBE6FECEBDEDD5BE}, // 1e-10\n {0x31680A88F8953030, 0x89705F4136B4A597}, // 1e-9\n {0xFDC20D2B36BA7C3D, 0xABCC77118461CEFC}, // 1e-8\n {0x3D32907604691B4C, 0xD6BF94D5E57A42BC}, // 1e-7\n {0xA63F9A49C2C1B10" +
"F, 0x8637BD05AF6C69B5}, // 1e-6\n {0x0FCF80DC33721D53, 0xA7C5AC471B478423}, // 1e-5\n {0xD3C36113404EA4A8, 0xD1B71758E219652B}, // 1e-4\n {0x645A1CAC083126E9, 0x83126E978D4FDF3B}, // 1e-3\n {0x3D70A3D70A3D70A3, 0xA3D70A3D70A3D70A}, // 1e-2\n {0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC}, // 1e-1\n {0x0000000000000000, 0x8000000000000000}, // 1e0\n {0x0000000000000000, 0xA000000000000000}, // 1e1\n {0x0000000000000000, 0xC800000000000000}, // 1e2\n {0x0000000000000000, 0xFA00000000000000}, // 1e3\n {0x0000000000000000, 0x9C40000000000000}, // 1e4\n {0x0000000000000000, 0xC350000000000000}, // 1e5\n {0x0000000000000000, 0xF424000000000000}, // 1e6\n {0x0000000000000000, 0x9896800000000000}, // 1e7\n {0x0000000000000000, 0xBEBC200000000000}, // 1e8\n {0x0000000000000000, 0xEE6B280000000000}, // 1e9\n {0x0000000000000000, 0x9502F90000000000}, // 1e10\n {0x0000000000000000, 0xBA43B74000000000}, // 1e1" +
"1\n {0x0000000000000000, 0xE8D4A51000000000}, // 1e12\n {0x0000000000000000, 0x9184E72A00000000}, // 1e13\n {0x0000000000000000, 0xB5E620F480000000}, // 1e14\n {0x0000000000000000, 0xE35FA931A0000000}, // 1e15\n {0x0000000000000000, 0x8E1BC9BF04000000}, // 1e16\n {0x0000000000000000, 0xB1A2BC2EC5000000}, // 1e17\n {0x0000000000000000, 0xDE0B6B3A76400000}, // 1e18\n {0x0000000000000000, 0x8AC7230489E80000}, // 1e19\n {0x0000000000000000, 0xAD78EBC5AC620000}, // 1e20\n {0x0000000000000000, 0xD8D726B7177A8000}, // 1e21\n {0x0000000000000000, 0x878678326EAC9000}, // 1e22\n {0x0000000000000000, 0xA968163F0A57B400}, // 1e23\n {0x0000000000000000, 0xD3C21BCECCEDA100}, // 1e24\n {0x0000000000000000, 0x84595161401484A0}, // 1e25\n {0x0000000000000000, 0xA56FA5B99019A5C8}, // 1e26\n {0x0000000000000000, 0xCECB8F27F4200F3A}, // 1e27\n {0x4000000000000000, 0x813F3978F8940984}, // 1e28\n {0x50000000" +
"00000000, 0xA18F07D736B90BE5}, // 1e29\n {0xA400000000000000, 0xC9F2C9CD04674EDE}, // 1e30\n {0x4D00000000000000, 0xFC6F7C4045812296}, // 1e31\n {0xF020000000000000, 0x9DC5ADA82B70B59D}, // 1e32\n {0x6C28000000000000, 0xC5371912364CE305}, // 1e33\n {0xC732000000000000, 0xF684DF56C3E01BC6}, // 1e34\n {0x3C7F400000000000, 0x9A130B963A6C115C}, // 1e35\n {0x4B9F100000000000, 0xC097CE7BC90715B3}, // 1e36\n {0x1E86D40000000000, 0xF0BDC21ABB48DB20}, // 1e37\n {0x1314448000000000, 0x96769950B50D88F4}, // 1e38\n {0x17D955A000000000, 0xBC143FA4E250EB31}, // 1e39\n {0x5DCFAB0800000000, 0xEB194F8E1AE525FD}, // 1e40\n {0x5AA1CAE500000000, 0x92EFD1B8D0CF37BE}, // 1e41\n {0xF14A3D9E40000000, 0xB7ABC627050305AD}, // 1e42\n {0x6D9CCD05D0000000, 0xE596B7B0C643C719}, // 1e43\n {0xE4820023A2000000, 0x8F7E32CE7BEA5C6F}, // 1e44\n {0xDDA2802C8A800000, 0xB35DBF821AE4F38B}, // 1e45\n {0xD50B2037AD200000, 0xE0352F62A" +
"19E306E}, // 1e46\n {0x4526F422CC340000, 0x8C213D9DA502DE45}, // 1e47\n {0x9670B12B7F410000, 0xAF298D050E4395D6}, // 1e48\n {0x3C0CDD765F114000, 0xDAF3F04651D47B4C}, // 1e49\n {0xA5880A69FB6AC800, 0x88D8762BF324CD0F}, // 1e50\n {0x8EEA0D047A457A00, 0xAB0E93B6EFEE0053}, // 1e51\n {0x72A4904598D6D880, 0xD5D238A4ABE98068}, // 1e52\n {0x47A6DA2B7F864750, 0x85A36366EB71F041}, // 1e53\n {0x999090B65F67D924, 0xA70C3C40A64E6C51}, // 1e54\n {0xFFF4B4E3F741CF6D, 0xD0CF4B50CFE20765}, // 1e55\n {0xBFF8F10E7A8921A4, 0x82818F1281ED449F}, // 1e56\n {0xAFF72D52192B6A0D, 0xA321F2D7226895C7}, // 1e57\n {0x9BF4F8A69F764490, 0xCBEA6F8CEB02BB39}, // 1e58\n {0x02F236D04753D5B4, 0xFEE50B7025C36A08}, // 1e59\n {0x01D762422C946590, 0x9F4F2726179A2245}, // 1e60\n {0x424D3AD2B7B97EF5, 0xC722F0EF9D80AAD6}, // 1e61\n {0xD2E0898765A7DEB2, 0xF8EBAD2B84E0D58B}, // 1e62\n {0x63CC55F49F88EB2F, 0x9B934C3B330C8577}, // 1e63\n " +
" {0x3CBF6B71C76B25FB, 0xC2781F49FFCFA6D5}, // 1e64\n {0x8BEF464E3945EF7A, 0xF316271C7FC3908A}, // 1e65\n {0x97758BF0E3CBB5AC, 0x97EDD871CFDA3A56}, // 1e66\n {0x3D52EEED1CBEA317, 0xBDE94E8E43D0C8EC}, // 1e67\n {0x4CA7AAA863EE4BDD, 0xED63A231D4C4FB27}, // 1e68\n {0x8FE8CAA93E74EF6A, 0x945E455F24FB1CF8}, // 1e69\n {0xB3E2FD538E122B44, 0xB975D6B6EE39E436}, // 1e70\n {0x60DBBCA87196B616, 0xE7D34C64A9C85D44}, // 1e71\n {0xBC8955E946FE31CD, 0x90E40FBEEA1D3A4A}, // 1e72\n {0x6BABAB6398BDBE41, 0xB51D13AEA4A488DD}, // 1e73\n {0xC696963C7EED2DD1, 0xE264589A4DCDAB14}, // 1e74\n {0xFC1E1DE5CF543CA2, 0x8D7EB76070A08AEC}, // 1e75\n {0x3B25A55F43294BCB, 0xB0DE65388CC8ADA8}, // 1e76\n {0x49EF0EB713F39EBE, 0xDD15FE86AFFAD912}, // 1e77\n {0x6E3569326C784337, 0x8A2DBF142DFCC7AB}, // 1e78\n {0x49C2C37F07965404, 0xACB92ED9397BF996}, // 1e79\n {0xDC33745EC97BE906, 0xD7E77A8F87DAF7FB}, // 1e80\n {0x69A028BB3DED" +
"71A3, 0x86F0AC99B4E8DAFD}, // 1e81\n {0xC40832EA0D68CE0C, 0xA8ACD7C0222311BC}, // 1e82\n {0xF50A3FA490C30190, 0xD2D80DB02AABD62B}, // 1e83\n {0x792667C6DA79E0FA, 0x83C7088E1AAB65DB}, // 1e84\n {0x577001B891185938, 0xA4B8CAB1A1563F52}, // 1e85\n {0xED4C0226B55E6F86, 0xCDE6FD5E09ABCF26}, // 1e86\n {0x544F8158315B05B4, 0x80B05E5AC60B6178}, // 1e87\n {0x696361AE3DB1C721, 0xA0DC75F1778E39D6}, // 1e88\n {0x03BC3A19CD1E38E9, 0xC913936DD571C84C}, // 1e89\n {0x04AB48A04065C723, 0xFB5878494ACE3A5F}, // 1e90\n {0x62EB0D64283F9C76, 0x9D174B2DCEC0E47B}, // 1e91\n {0x3BA5D0BD324F8394, 0xC45D1DF942711D9A}, // 1e92\n {0xCA8F44EC7EE36479, 0xF5746577930D6500}, // 1e93\n {0x7E998B13CF4E1ECB, 0x9968BF6ABBE85F20}, // 1e94\n {0x9E3FEDD8C321A67E, 0xBFC2EF456AE276E8}, // 1e95\n {0xC5CFE94EF3EA101E, 0xEFB3AB16C59B14A2}, // 1e96\n {0xBBA1F1D158724A12, 0x95D04AEE3B80ECE5}, // 1e97\n {0x2A8A6E45AE8EDC97, 0xBB445DA9CA612" +
"81F}, // 1e98\n {0xF52D09D71A3293BD, 0xEA1575143CF97226}, // 1e99\n {0x593C2626705F9C56, 0x924D692CA61BE758}, // 1e100\n {0x6F8B2FB00C77836C, 0xB6E0C377CFA2E12E}, // 1e101\n {0x0B6DFB9C0F956447, 0xE498F455C38B997A}, // 1e102\n {0x4724BD4189BD5EAC, 0x8EDF98B59A373FEC}, // 1e103\n {0x58EDEC91EC2CB657, 0xB2977EE300C50FE7}, // 1e104\n {0x2F2967B66737E3ED, 0xDF3D5E9BC0F653E1}, // 1e105\n {0xBD79E0D20082EE74, 0x8B865B215899F46C}, // 1e106\n {0xECD8590680A3AA11, 0xAE67F1E9AEC07187}, // 1e107\n {0xE80E6F4820CC9495, 0xDA01EE641A708DE9}, // 1e108\n {0x3109058D147FDCDD, 0x884134FE908658B2}, // 1e109\n {0xBD4B46F0599FD415, 0xAA51823E34A7EEDE}, // 1e110\n {0x6C9E18AC7007C91A, 0xD4E5E2CDC1D1EA96}, // 1e111\n {0x03E2CF6BC604DDB0, 0x850FADC09923329E}, // 1e112\n {0x84DB8346B786151C, 0xA6539930BF6BFF45}, // 1e113\n {0xE612641865679A63, 0xCFE87F7CEF46FF16}, // 1e114\n {0x4FCB7E8F3F60C07E, 0x81F14FAE158C5F6E}, " +
" // 1e115\n {0xE3BE5E330F38F09D, 0xA26DA3999AEF7749}, // 1e116\n {0x5CADF5BFD3072CC5, 0xCB090C8001AB551C}, // 1e117\n {0x73D9732FC7C8F7F6, 0xFDCB4FA002162A63}, // 1e118\n {0x2867E7FDDCDD9AFA, 0x9E9F11C4014DDA7E}, // 1e119\n {0xB281E1FD541501B8, 0xC646D63501A1511D}, // 1e120\n {0x1F225A7CA91A4226, 0xF7D88BC24209A565}, // 1e121\n {0x3375788DE9B06958, 0x9AE757596946075F}, // 1e122\n {0x0052D6B1641C83AE, 0xC1A12D2FC3978937}, // 1e123\n {0xC0678C5DBD23A49A, 0xF209787BB47D6B84}, // 1e124\n {0xF840B7BA963646E0, 0x9745EB4D50CE6332}, // 1e125\n {0xB650E5A93BC3D898, 0xBD176620A501FBFF}, // 1e126\n {0xA3E51F138AB4CEBE, 0xEC5D3FA8CE427AFF}, // 1e127\n {0xC66F336C36B10137, 0x93BA47C980E98CDF}, // 1e128\n {0xB80B0047445D4184, 0xB8A8D9BBE123F017}, // 1e129\n {0xA60DC059157491E5, 0xE6D3102AD96CEC1D}, // 1e130\n {0x87C89837AD68DB2F, 0x9043EA1AC7E41392}, // 1e131\n {0x29BABE4598C311FB, 0xB454E4A179DD1877}, // " +
"1e132\n {0xF4296DD6FEF3D67A, 0xE16A1DC9D8545E94}, // 1e133\n {0x1899E4A65F58660C, 0x8CE2529E2734BB1D}, // 1e134\n {0x5EC05DCFF72E7F8F, 0xB01AE745B101E9E4}, // 1e135\n {0x76707543F4FA1F73, 0xDC21A1171D42645D}, // 1e136\n {0x6A06494A791C53A8, 0x899504AE72497EBA}, // 1e137\n {0x0487DB9D17636892, 0xABFA45DA0EDBDE69}, // 1e138\n {0x45A9D2845D3C42B6, 0xD6F8D7509292D603}, // 1e139\n {0x0B8A2392BA45A9B2, 0x865B86925B9BC5C2}, // 1e140\n {0x8E6CAC7768D7141E, 0xA7F26836F282B732}, // 1e141\n {0x3207D795430CD926, 0xD1EF0244AF2364FF}, // 1e142\n {0x7F44E6BD49E807B8, 0x8335616AED761F1F}, // 1e143\n {0x5F16206C9C6209A6, 0xA402B9C5A8D3A6E7}, // 1e144\n {0x36DBA887C37A8C0F, 0xCD036837130890A1}, // 1e145\n {0xC2494954DA2C9789, 0x802221226BE55A64}, // 1e146\n {0xF2DB9BAA10B7BD6C, 0xA02AA96B06DEB0FD}, // 1e147\n {0x6F92829494E5ACC7, 0xC83553C5C8965D3D}, // 1e148\n {0xCB772339BA1F17F9, 0xFA42A8B73ABBF48C}, // 1e14" +
"9\n {0xFF2A760414536EFB, 0x9C69A97284B578D7}, // 1e150\n {0xFEF5138519684ABA, 0xC38413CF25E2D70D}, // 1e151\n {0x7EB258665FC25D69, 0xF46518C2EF5B8CD1}, // 1e152\n {0xEF2F773FFBD97A61, 0x98BF2F79D5993802}, // 1e153\n {0xAAFB550FFACFD8FA, 0xBEEEFB584AFF8603}, // 1e154\n {0x95BA2A53F983CF38, 0xEEAABA2E5DBF6784}, // 1e155\n {0xDD945A747BF26183, 0x952AB45CFA97A0B2}, // 1e156\n {0x94F971119AEEF9E4, 0xBA756174393D88DF}, // 1e157\n {0x7A37CD5601AAB85D, 0xE912B9D1478CEB17}, // 1e158\n {0xAC62E055C10AB33A, 0x91ABB422CCB812EE}, // 1e159\n {0x577B986B314D6009, 0xB616A12B7FE617AA}, // 1e160\n {0xED5A7E85FDA0B80B, 0xE39C49765FDF9D94}, // 1e161\n {0x14588F13BE847307, 0x8E41ADE9FBEBC27D}, // 1e162\n {0x596EB2D8AE258FC8, 0xB1D219647AE6B31C}, // 1e163\n {0x6FCA5F8ED9AEF3BB, 0xDE469FBD99A05FE3}, // 1e164\n {0x25DE7BB9480D5854, 0x8AEC23D680043BEE}, // 1e165\n {0xAF561AA79A10AE6A, 0xADA72CCC20054AE9}, // 1e166\n " +
" {0x1B2BA1518094DA04, 0xD910F7FF28069DA4}, // 1e167\n {0x90FB44D2F05D0842, 0x87AA9AFF79042286}, // 1e168\n {0x353A1607AC744A53, 0xA99541BF57452B28}, // 1e169\n {0x42889B8997915CE8, 0xD3FA922F2D1675F2}, // 1e170\n {0x69956135FEBADA11, 0x847C9B5D7C2E09B7}, // 1e171\n {0x43FAB9837E699095, 0xA59BC234DB398C25}, // 1e172\n {0x94F967E45E03F4BB, 0xCF02B2C21207EF2E}, // 1e173\n {0x1D1BE0EEBAC278F5, 0x8161AFB94B44F57D}, // 1e174\n {0x6462D92A69731732, 0xA1BA1BA79E1632DC}, // 1e175\n {0x7D7B8F7503CFDCFE, 0xCA28A291859BBF93}, // 1e176\n {0x5CDA735244C3D43E, 0xFCB2CB35E702AF78}, // 1e177\n {0x3A0888136AFA64A7, 0x9DEFBF01B061ADAB}, // 1e178\n {0x088AAA1845B8FDD0, 0xC56BAEC21C7A1916}, // 1e179\n {0x8AAD549E57273D45, 0xF6C69A72A3989F5B}, // 1e180\n {0x36AC54E2F678864B, 0x9A3C2087A63F6399}, // 1e181\n {0x84576A1BB416A7DD, 0xC0CB28A98FCF3C7F}, // 1e182\n {0x656D44A2A11C51D5, 0xF0FDF2D3F3C30B9F}, // 1e183\n " +
" {0x9F644AE5A4B1B325, 0x969EB7C47859E743}, // 1e184\n {0x873D5D9F0DDE1FEE, 0xBC4665B596706114}, // 1e185\n {0xA90CB506D155A7EA, 0xEB57FF22FC0C7959}, // 1e186\n {0x09A7F12442D588F2, 0x9316FF75DD87CBD8}, // 1e187\n {0x0C11ED6D538AEB2F, 0xB7DCBF5354E9BECE}, // 1e188\n {0x8F1668C8A86DA5FA, 0xE5D3EF282A242E81}, // 1e189\n {0xF96E017D694487BC, 0x8FA475791A569D10}, // 1e190\n {0x37C981DCC395A9AC, 0xB38D92D760EC4455}, // 1e191\n {0x85BBE253F47B1417, 0xE070F78D3927556A}, // 1e192\n {0x93956D7478CCEC8E, 0x8C469AB843B89562}, // 1e193\n {0x387AC8D1970027B2, 0xAF58416654A6BABB}, // 1e194\n {0x06997B05FCC0319E, 0xDB2E51BFE9D0696A}, // 1e195\n {0x441FECE3BDF81F03, 0x88FCF317F22241E2}, // 1e196\n {0xD527E81CAD7626C3, 0xAB3C2FDDEEAAD25A}, // 1e197\n {0x8A71E223D8D3B074, 0xD60B3BD56A5586F1}, // 1e198\n {0xF6872D5667844E49, 0x85C7056562757456}, // 1e199\n {0xB428F8AC016561DB, 0xA738C6BEBB12D16C}, // 1e200\n {0" +
"xE13336D701BEBA52, 0xD106F86E69D785C7}, // 1e201\n {0xECC0024661173473, 0x82A45B450226B39C}, // 1e202\n {0x27F002D7F95D0190, 0xA34D721642B06084}, // 1e203\n {0x31EC038DF7B441F4, 0xCC20CE9BD35C78A5}, // 1e204\n {0x7E67047175A15271, 0xFF290242C83396CE}, // 1e205\n {0x0F0062C6E984D386, 0x9F79A169BD203E41}, // 1e206\n {0x52C07B78A3E60868, 0xC75809C42C684DD1}, // 1e207\n {0xA7709A56CCDF8A82, 0xF92E0C3537826145}, // 1e208\n {0x88A66076400BB691, 0x9BBCC7A142B17CCB}, // 1e209\n {0x6ACFF893D00EA435, 0xC2ABF989935DDBFE}, // 1e210\n {0x0583F6B8C4124D43, 0xF356F7EBF83552FE}, // 1e211\n {0xC3727A337A8B704A, 0x98165AF37B2153DE}, // 1e212\n {0x744F18C0592E4C5C, 0xBE1BF1B059E9A8D6}, // 1e213\n {0x1162DEF06F79DF73, 0xEDA2EE1C7064130C}, // 1e214\n {0x8ADDCB5645AC2BA8, 0x9485D4D1C63E8BE7}, // 1e215\n {0x6D953E2BD7173692, 0xB9A74A0637CE2EE1}, // 1e216\n {0xC8FA8DB6CCDD0437, 0xE8111C87C5C1BA99}, // 1e217\n {0x1D9" +
"C9892400A22A2, 0x910AB1D4DB9914A0}, // 1e218\n {0x2503BEB6D00CAB4B, 0xB54D5E4A127F59C8}, // 1e219\n {0x2E44AE64840FD61D, 0xE2A0B5DC971F303A}, // 1e220\n {0x5CEAECFED289E5D2, 0x8DA471A9DE737E24}, // 1e221\n {0x7425A83E872C5F47, 0xB10D8E1456105DAD}, // 1e222\n {0xD12F124E28F77719, 0xDD50F1996B947518}, // 1e223\n {0x82BD6B70D99AAA6F, 0x8A5296FFE33CC92F}, // 1e224\n {0x636CC64D1001550B, 0xACE73CBFDC0BFB7B}, // 1e225\n {0x3C47F7E05401AA4E, 0xD8210BEFD30EFA5A}, // 1e226\n {0x65ACFAEC34810A71, 0x8714A775E3E95C78}, // 1e227\n {0x7F1839A741A14D0D, 0xA8D9D1535CE3B396}, // 1e228\n {0x1EDE48111209A050, 0xD31045A8341CA07C}, // 1e229\n {0x934AED0AAB460432, 0x83EA2B892091E44D}, // 1e230\n {0xF81DA84D5617853F, 0xA4E4B66B68B65D60}, // 1e231\n {0x36251260AB9D668E, 0xCE1DE40642E3F4B9}, // 1e232\n {0xC1D72B7C6B426019, 0x80D2AE83E9CE78F3}, // 1e233\n {0xB24CF65B8612F81F, 0xA1075A24E4421730}, // 1e234\n {0xDEE033F" +
"26797B627, 0xC94930AE1D529CFC}, // 1e235\n {0x169840EF017DA3B1, 0xFB9B7CD9A4A7443C}, // 1e236\n {0x8E1F289560EE864E, 0x9D412E0806E88AA5}, // 1e237\n {0xF1A6F2BAB92A27E2, 0xC491798A08A2AD4E}, // 1e238\n {0xAE10AF696774B1DB, 0xF5B5D7EC8ACB58A2}, // 1e239\n {0xACCA6DA1E0A8EF29, 0x9991A6F3D6BF1765}, // 1e240\n {0x17FD090A58D32AF3, 0xBFF610B0CC6EDD3F}, // 1e241\n {0xDDFC4B4CEF07F5B0, 0xEFF394DCFF8A948E}, // 1e242\n {0x4ABDAF101564F98E, 0x95F83D0A1FB69CD9}, // 1e243\n {0x9D6D1AD41ABE37F1, 0xBB764C4CA7A4440F}, // 1e244\n {0x84C86189216DC5ED, 0xEA53DF5FD18D5513}, // 1e245\n {0x32FD3CF5B4E49BB4, 0x92746B9BE2F8552C}, // 1e246\n {0x3FBC8C33221DC2A1, 0xB7118682DBB66A77}, // 1e247\n {0x0FABAF3FEAA5334A, 0xE4D5E82392A40515}, // 1e248\n {0x29CB4D87F2A7400E, 0x8F05B1163BA6832D}, // 1e249\n {0x743E20E9EF511012, 0xB2C71D5BCA9023F8}, // 1e250\n {0x914DA9246B255416, 0xDF78E4B2BD342CF6}, // 1e251\n {0x1AD089B6C2F" +
"7548E, 0x8BAB8EEFB6409C1A}, // 1e252\n {0xA184AC2473B529B1, 0xAE9672ABA3D0C320}, // 1e253\n {0xC9E5D72D90A2741E, 0xDA3C0F568CC4F3E8}, // 1e254\n {0x7E2FA67C7A658892, 0x8865899617FB1871}, // 1e255\n {0xDDBB901B98FEEAB7, 0xAA7EEBFB9DF9DE8D}, // 1e256\n {0x552A74227F3EA565, 0xD51EA6FA85785631}, // 1e257\n {0xD53A88958F87275F, 0x8533285C936B35DE}, // 1e258\n {0x8A892ABAF368F137, 0xA67FF273B8460356}, // 1e259\n {0x2D2B7569B0432D85, 0xD01FEF10A657842C}, // 1e260\n {0x9C3B29620E29FC73, 0x8213F56A67F6B29B}, // 1e261\n {0x8349F3BA91B47B8F, 0xA298F2C501F45F42}, // 1e262\n {0x241C70A936219A73, 0xCB3F2F7642717713}, // 1e263\n {0xED238CD383AA0110, 0xFE0EFB53D30DD4D7}, // 1e264\n {0xF4363804324A40AA, 0x9EC95D1463E8A506}, // 1e265\n {0xB143C6053EDCD0D5, 0xC67BB4597CE2CE48}, // 1e266\n {0xDD94B7868E94050A, 0xF81AA16FDC1B81DA}, // 1e267\n {0xCA7CF2B4191C8326, 0x9B10A4E5E9913128}, // 1e268\n {0xFD1C2F611F63A3F" +
"0, 0xC1D4CE1F63F57D72}, // 1e269\n {0xBC633B39673C8CEC, 0xF24A01A73CF2DCCF}, // 1e270\n {0xD5BE0503E085D813, 0x976E41088617CA01}, // 1e271\n {0x4B2D8644D8A74E18, 0xBD49D14AA79DBC82}, // 1e272\n {0xDDF8E7D60ED1219E, 0xEC9C459D51852BA2}, // 1e273\n {0xCABB90E5C942B503, 0x93E1AB8252F33B45}, // 1e274\n {0x3D6A751F3B936243, 0xB8DA1662E7B00A17}, // 1e275\n {0x0CC512670A783AD4, 0xE7109BFBA19C0C9D}, // 1e276\n {0x27FB2B80668B24C5, 0x906A617D450187E2}, // 1e277\n {0xB1F9F660802DEDF6, 0xB484F9DC9641E9DA}, // 1e278\n {0x5E7873F8A0396973, 0xE1A63853BBD26451}, // 1e279\n {0xDB0B487B6423E1E8, 0x8D07E33455637EB2}, // 1e280\n {0x91CE1A9A3D2CDA62, 0xB049DC016ABC5E5F}, // 1e281\n {0x7641A140CC7810FB, 0xDC5C5301C56B75F7}, // 1e282\n {0xA9E904C87FCB0A9D, 0x89B9B3E11B6329BA}, // 1e283\n {0x546345FA9FBDCD44, 0xAC2820D9623BF429}, // 1e284\n {0xA97C177947AD4095, 0xD732290FBACAF133}, // 1e285\n {0x49ED8EABCCCC485D, 0" +
"x867F59A9D4BED6C0}, // 1e286\n {0x5C68F256BFFF5A74, 0xA81F301449EE8C70}, // 1e287\n {0x73832EEC6FFF3111, 0xD226FC195C6A2F8C}, // 1e288\n};\n\n// wuffs_base__private_implementation__f64_powers_of_10 holds powers of 10 that\n// can be exactly represented by a float64 (what C calls a double).\nstatic const double wuffs_base__private_implementation__f64_powers_of_10[23] = {\n 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,\n 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,\n};\n" +
""
const BaseIntConvSubmoduleC = "" +
"// ---------------- Integer\n\n// wuffs_base__parse_number__foo_digits entries are 0x00 for invalid digits,\n// and (0x80 | v) for valid digits, where v is the 4 bit value.\n\nstatic const uint8_t wuffs_base__parse_number__decimal_digits[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.\n 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.\n 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.\n 0x00, 0x00, 0x00, " +
"0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00," +
" // 0xB8 ..= 0xBF.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__parse_number__hexadecimal_digits[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.\n 0x00, " +
"0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.\n 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.\n 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.\n\n 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x40 ..= 0x47. 'A'-'F'.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.\n 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x60 ..= 0x67. 'a'-'f'.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.\n\n " +
" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB8 ..= 0xBF.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.\n 0x00, 0x00, 0x00, 0x00, 0x0" +
"0, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__private_implementation__encode_base16[16] = {\n 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, // 0x00 ..= 0x07.\n 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, // 0x08 ..= 0x0F.\n};\n\n" +
"" +
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //\nwuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n\n bool negative = false;\n if (p >= q) {\n goto fail_bad_argument;\n } else if (*p == '-') {\n p++;\n negative = true;\n } else if (*p == '+') {\n p++;\n }\n\n do {\n wuffs_base__result_u64 r = wuffs_base__parse_number_u64(\n wuffs_base__make_slice_u8(p, (size_t)(q - p)), options);\n if (r.status.repr != NULL) {\n wuffs_base__result_i64 ret;\n ret.status.repr = r.status.repr;\n ret.value = 0;\n return ret;\n } else if (negative) {\n if (r.value > 0x8000000000000000) {\n goto fail_out_of_bounds;\n }\n wuffs_base__result_i64 ret;\n ret.status.repr = NULL;\n ret.value = -(int64_t)(r.value);\n return ret;\n } else if (r.value > 0x7FFFFFFFFFFF" +
"FFFF) {\n goto fail_out_of_bounds;\n } else {\n wuffs_base__result_i64 ret;\n ret.status.repr = NULL;\n ret.value = +(int64_t)(r.value);\n return ret;\n }\n } while (0);\n\nfail_bad_argument:\n do {\n wuffs_base__result_i64 ret;\n ret.status.repr = wuffs_base__error__bad_argument;\n ret.value = 0;\n return ret;\n } while (0);\n\nfail_out_of_bounds:\n do {\n wuffs_base__result_i64 ret;\n ret.status.repr = wuffs_base__error__out_of_bounds;\n ret.value = 0;\n return ret;\n } while (0);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //\nwuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n\n if (p >= q) {\n goto fail_bad_argument;\n\n } else if (*p == '0') {\n p++;\n if (p >= q) {\n goto ok_zero;\n }\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n " +
"if (*p == '_') {\n p++;\n for (; p < q; p++) {\n if (*p != '_') {\n if (options &\n WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {\n goto decimal;\n }\n goto fail_bad_argument;\n }\n }\n goto ok_zero;\n }\n }\n\n if ((*p == 'x') || (*p == 'X')) {\n p++;\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n if (p < q) {\n goto hexadecimal;\n }\n\n } else if ((*p == 'd') || (*p == 'D')) {\n p++;\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n if (p < q) {\n goto decimal;\n }\n }\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {\n goto decimal;\n }\n goto fail_bad_argument;\n }\n\ndecimal:\n do {\n uint64_t v = wuffs_base__parse_number__decimal_digi" +
"ts[*p++];\n if (v == 0) {\n goto fail_bad_argument;\n }\n v &= 0x0F;\n\n // UINT64_MAX is 18446744073709551615, which is ((10 * max10) + max1).\n const uint64_t max10 = 1844674407370955161u;\n const uint8_t max1 = 5;\n\n for (; p < q; p++) {\n if ((*p == '_') &&\n (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n continue;\n }\n uint8_t digit = wuffs_base__parse_number__decimal_digits[*p];\n if (digit == 0) {\n goto fail_bad_argument;\n }\n digit &= 0x0F;\n if ((v > max10) || ((v == max10) && (digit > max1))) {\n goto fail_out_of_bounds;\n }\n v = (10 * v) + ((uint64_t)(digit));\n }\n\n wuffs_base__result_u64 ret;\n ret.status.repr = NULL;\n ret.value = v;\n return ret;\n } while (0);\n\nhexadecimal:\n do {\n uint64_t v = wuffs_base__parse_number__hexadecimal_digits[*p++];\n if (v == 0) {\n goto fail_bad_argument;\n }\n v &= 0x0F;\n\n for (; p < q; p++) {\n if ((*p == '_') &&\n (options" +
" & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n continue;\n }\n uint8_t digit = wuffs_base__parse_number__hexadecimal_digits[*p];\n if (digit == 0) {\n goto fail_bad_argument;\n }\n digit &= 0x0F;\n if ((v >> 60) != 0) {\n goto fail_out_of_bounds;\n }\n v = (v << 4) | ((uint64_t)(digit));\n }\n\n wuffs_base__result_u64 ret;\n ret.status.repr = NULL;\n ret.value = v;\n return ret;\n } while (0);\n\nok_zero:\n do {\n wuffs_base__result_u64 ret;\n ret.status.repr = NULL;\n ret.value = 0;\n return ret;\n } while (0);\n\nfail_bad_argument:\n do {\n wuffs_base__result_u64 ret;\n ret.status.repr = wuffs_base__error__bad_argument;\n ret.value = 0;\n return ret;\n } while (0);\n\nfail_out_of_bounds:\n do {\n wuffs_base__result_u64 ret;\n ret.status.repr = wuffs_base__error__out_of_bounds;\n ret.value = 0;\n return ret;\n } while (0);\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__render_number__first_hundred contains the decimal encodings of\n// the first one hundred numbers [0 ..= 99].\nstatic const uint8_t wuffs_base__render_number__first_hundred[200] = {\n '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', //\n '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', //\n '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', //\n '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', //\n '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', //\n '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', //\n '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', //\n '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', //\n '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', //\n '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', //\n '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', //\n '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', //\n '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', //\n '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', //\n '" +
"7', '0', '7', '1', '7', '2', '7', '3', '7', '4', //\n '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', //\n '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', //\n '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', //\n '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', //\n '9', '5', '9', '6', '9', '7', '9', '8', '9', '9', //\n};\n\nstatic size_t //\nwuffs_base__private_implementation__render_number_u64(wuffs_base__slice_u8 dst,\n uint64_t x,\n uint32_t options,\n bool neg) {\n uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];\n uint8_t* ptr = &buf[0] + sizeof(buf);\n\n while (x >= 100) {\n size_t index = ((size_t)((x % 100) * 2));\n x /= 100;\n uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];\n uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];\n ptr -= 2;\n ptr[0] = s0;\n ptr[1] = s1;\n }\n\n if " +
"(x < 10) {\n ptr -= 1;\n ptr[0] = (uint8_t)('0' + x);\n } else {\n size_t index = ((size_t)(x * 2));\n uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];\n uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];\n ptr -= 2;\n ptr[0] = s0;\n ptr[1] = s1;\n }\n\n if (neg) {\n ptr -= 1;\n ptr[0] = '-';\n } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n ptr -= 1;\n ptr[0] = '+';\n }\n\n size_t n = sizeof(buf) - ((size_t)(ptr - &buf[0]));\n if (n > dst.len) {\n return 0;\n }\n memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n ? (dst.len - n)\n : 0),\n ptr, n);\n return n;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_i64(wuffs_base__slice_u8 dst,\n int64_t x,\n uint32_t options) {\n uint64_t u = (uint64_t)x;\n bool neg = x < 0;\n if (neg) {\n u = 1 + ~u;\n }\n return wuffs_base__private_imp" +
"lementation__render_number_u64(dst, u, options,\n neg);\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_u64(wuffs_base__slice_u8 dst,\n uint64_t x,\n uint32_t options) {\n return wuffs_base__private_implementation__render_number_u64(dst, x, options,\n false);\n}\n\n" +
"" +
"// ---------------- Base-16\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t src_len2 = src.len / 2;\n size_t len;\n if (dst.len < src_len2) {\n len = dst.len;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src_len2;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else if (src.len & 1) {\n o.status.repr = wuffs_base__error__bad_data;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[0]] << 4) |\n (wuffs_base__parse_number__hexadecimal_digits[s[1]] & 0x0F));\n d += 1;\n s += 2;\n }\n\n o.num_dst = len;\n o.num_s" +
"rc = len * 2;\n return o;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t src_len4 = src.len / 4;\n size_t len = dst.len < src_len4 ? dst.len : src_len4;\n if (dst.len < src_len4) {\n len = dst.len;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src_len4;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else if (src.len & 1) {\n o.status.repr = wuffs_base__error__bad_data;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[2]] << 4) |\n (wuffs_base__parse_number__hexadecimal_digits[s[3]] & 0x0F));\n d += 1;\n " +
" s += 4;\n }\n\n o.num_dst = len;\n o.num_src = len * 4;\n return o;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t dst_len2 = dst.len / 2;\n size_t len;\n if (dst_len2 < src.len) {\n len = dst_len2;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src.len;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n uint8_t c = *s;\n d[0] = wuffs_base__private_implementation__encode_base16[c >> 4];\n d[1] = wuffs_base__private_implementation__encode_base16[c & 0x0F];\n d += 2;\n s += 1;\n }\n\n o.num_dst = len * 2;\n o.num_src = len;\n return o;\n}\n\nWUFFS_BA" +
"SE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t dst_len4 = dst.len / 4;\n size_t len;\n if (dst_len4 < src.len) {\n len = dst_len4;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src.len;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n uint8_t c = *s;\n d[0] = '\\\\';\n d[1] = 'x';\n d[2] = wuffs_base__private_implementation__encode_base16[c >> 4];\n d[3] = wuffs_base__private_implementation__encode_base16[c & 0x0F];\n d += 4;\n s += 1;\n }\n\n o.num_dst = len * 4;\n o.num_src = len;\n return o;\n}\n\n" +
"" +
"// ---------------- Base-64\n\n// The two base-64 alphabets, std and url, differ only in the last two codes.\n// - std: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\n// - url: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"\n\nstatic const uint8_t wuffs_base__base_64__decode_std[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x00 ..= 0x07.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x08 ..= 0x0F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x10 ..= 0x17.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x18 ..= 0x1F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x20 ..= 0x27.\n 0x80, 0x80, 0x80, 0x3E, 0x80, 0x80, 0x80, 0x3F, // 0x28 ..= 0x2F.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, // 0x30 ..= 0x37.\n 0x3C, 0x3D, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x38 ..= 0x3F.\n\n 0x80, 0x00, 0x01, 0x02," +
" 0x03, 0x04, 0x05, 0x06, // 0x40 ..= 0x47.\n 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, // 0x48 ..= 0x4F.\n 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, // 0x50 ..= 0x57.\n 0x17, 0x18, 0x19, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x58 ..= 0x5F.\n 0x80, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, // 0x60 ..= 0x67.\n 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, // 0x68 ..= 0x6F.\n 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, // 0x70 ..= 0x77.\n 0x31, 0x32, 0x33, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x78 ..= 0x7F.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x80 ..= 0x87.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x88 ..= 0x8F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x90 ..= 0x97.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x98 ..= 0x9F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA0 ..= 0xA7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA8 ..= 0xAF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // " +
"0xB0 ..= 0xB7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xB8 ..= 0xBF.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC0 ..= 0xC7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC8 ..= 0xCF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD0 ..= 0xD7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD8 ..= 0xDF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE0 ..= 0xE7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE8 ..= 0xEF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__base_64__decode_url[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x00 ..= 0x07.\n 0x80, 0x80, 0x80, 0x80, " +
"0x80, 0x80, 0x80, 0x80, // 0x08 ..= 0x0F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x10 ..= 0x17.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x18 ..= 0x1F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x20 ..= 0x27.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x3E, 0x80, 0x80, // 0x28 ..= 0x2F.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, // 0x30 ..= 0x37.\n 0x3C, 0x3D, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x38 ..= 0x3F.\n\n 0x80, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, // 0x40 ..= 0x47.\n 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, // 0x48 ..= 0x4F.\n 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, // 0x50 ..= 0x57.\n 0x17, 0x18, 0x19, 0x80, 0x80, 0x80, 0x80, 0x3F, // 0x58 ..= 0x5F.\n 0x80, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, // 0x60 ..= 0x67.\n 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, // 0x68 ..= 0x6F.\n 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, // 0x70 ..= 0x77.\n 0x31, 0x32, 0x33, 0x80, 0x80, 0x80, 0x80, 0x80, // 0" +
"x78 ..= 0x7F.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x80 ..= 0x87.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x88 ..= 0x8F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x90 ..= 0x97.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x98 ..= 0x9F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA0 ..= 0xA7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA8 ..= 0xAF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xB0 ..= 0xB7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xB8 ..= 0xBF.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC0 ..= 0xC7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC8 ..= 0xCF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD0 ..= 0xD7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD8 ..= 0xDF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE0 ..= 0xE7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE8 ..= 0xEF.\n 0x80, 0x80" +
", 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__base_64__encode_std[64] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, // 0x00 ..= 0x07.\n 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, // 0x08 ..= 0x0F.\n 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, // 0x10 ..= 0x17.\n 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, // 0x18 ..= 0x1F.\n 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, // 0x20 ..= 0x27.\n 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, // 0x28 ..= 0x2F.\n 0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33, // 0x30 ..= 0x37.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2B, 0x2F, // 0x38 ..= 0x3F.\n};\n\nstatic const uint8_t wuffs_base__base_64__encode_url[64" +
"] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, // 0x00 ..= 0x07.\n 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, // 0x08 ..= 0x0F.\n 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, // 0x10 ..= 0x17.\n 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, // 0x18 ..= 0x1F.\n 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, // 0x20 ..= 0x27.\n 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, // 0x28 ..= 0x2F.\n 0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33, // 0x30 ..= 0x37.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2D, 0x5F, // 0x38 ..= 0x3F.\n};\n\n" +
"" +
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__decode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n const uint8_t* alphabet = (options & WUFFS_BASE__BASE_64__URL_ALPHABET)\n ? wuffs_base__base_64__decode_url\n : wuffs_base__base_64__decode_std;\n wuffs_base__transform__output o;\n uint8_t* d_ptr = dst.ptr;\n size_t d_len = dst.len;\n const uint8_t* s_ptr = src.ptr;\n size_t s_len = src.len;\n bool pad = false;\n\n while (s_len >= 4) {\n uint32_t s = wuffs_base__peek_u32le__no_bounds_check(s_ptr);\n uint32_t s0 = alphabet[0xFF & (s >> 0)];\n uint32_t s1 = alphabet[0xFF & (s >> 8)];\n uint32_t s2 = alphabet[0xFF & (s >> 16)];\n uint32_t s3 = alphabet[0xFF & (s >> 24)];\n\n if (((s0 | s1 | s2 | s3) & 0xC0) != 0) {\n if (s_len > 4) {\n o.status.repr = wuffs_base_" +
"_error__bad_data;\n goto done;\n } else if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n goto done;\n } else if ((options & WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING) &&\n (s_ptr[3] == '=')) {\n pad = true;\n if (s_ptr[2] == '=') {\n goto src2;\n }\n goto src3;\n }\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n }\n\n if (d_len < 3) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n\n s_ptr += 4;\n s_len -= 4;\n s = (s0 << 18) | (s1 << 12) | (s2 << 6) | (s3 << 0);\n *d_ptr++ = (uint8_t)(s >> 16);\n *d_ptr++ = (uint8_t)(s >> 8);\n *d_ptr++ = (uint8_t)(s >> 0);\n d_len -= 3;\n }\n\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n goto done;\n }\n\n if (s_len == 0) {\n o.status.repr = NULL;\n goto done;\n } else if (s_len == 1) {\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n } else if (s" +
"_len == 2) {\n goto src2;\n }\n\nsrc3:\n do {\n uint32_t s = wuffs_base__peek_u24le__no_bounds_check(s_ptr);\n uint32_t s0 = alphabet[0xFF & (s >> 0)];\n uint32_t s1 = alphabet[0xFF & (s >> 8)];\n uint32_t s2 = alphabet[0xFF & (s >> 16)];\n if ((s0 & 0xC0) || (s1 & 0xC0) || (s2 & 0xC3)) {\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n }\n if (d_len < 2) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n s_ptr += pad ? 4 : 3;\n s = (s0 << 18) | (s1 << 12) | (s2 << 6);\n *d_ptr++ = (uint8_t)(s >> 16);\n *d_ptr++ = (uint8_t)(s >> 8);\n o.status.repr = NULL;\n goto done;\n } while (0);\n\nsrc2:\n do {\n uint32_t s = wuffs_base__peek_u16le__no_bounds_check(s_ptr);\n uint32_t s0 = alphabet[0xFF & (s >> 0)];\n uint32_t s1 = alphabet[0xFF & (s >> 8)];\n if ((s0 & 0xC0) || (s1 & 0xCF)) {\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n }\n if (d_len < 1) {\n o.status.repr = wuffs_base__suspension__sho" +
"rt_write;\n goto done;\n }\n s_ptr += pad ? 4 : 2;\n s = (s0 << 18) | (s1 << 12);\n *d_ptr++ = (uint8_t)(s >> 16);\n o.status.repr = NULL;\n goto done;\n } while (0);\n\ndone:\n o.num_dst = (size_t)(d_ptr - dst.ptr);\n o.num_src = (size_t)(s_ptr - src.ptr);\n return o;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__encode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n const uint8_t* alphabet = (options & WUFFS_BASE__BASE_64__URL_ALPHABET)\n ? wuffs_base__base_64__encode_url\n : wuffs_base__base_64__encode_std;\n wuffs_base__transform__output o;\n uint8_t* d_ptr = dst.ptr;\n size_t d_len = dst.len;\n const uint8_t* s_ptr = src.ptr;\n size_t s_len = src.len;\n\n do {\n while (s_len >= 3) {\n if (d_len < 4) {\n o.status.repr = wuffs_base__suspension__short_write;\n " +
" goto done;\n }\n uint32_t s = wuffs_base__peek_u24be__no_bounds_check(s_ptr);\n s_ptr += 3;\n s_len -= 3;\n *d_ptr++ = alphabet[0x3F & (s >> 18)];\n *d_ptr++ = alphabet[0x3F & (s >> 12)];\n *d_ptr++ = alphabet[0x3F & (s >> 6)];\n *d_ptr++ = alphabet[0x3F & (s >> 0)];\n d_len -= 4;\n }\n\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n goto done;\n }\n\n if (s_len == 2) {\n if (d_len <\n ((options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) ? 4 : 3)) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n uint32_t s = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(s_ptr)))\n << 8;\n s_ptr += 2;\n *d_ptr++ = alphabet[0x3F & (s >> 18)];\n *d_ptr++ = alphabet[0x3F & (s >> 12)];\n *d_ptr++ = alphabet[0x3F & (s >> 6)];\n if (options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) {\n *d_ptr++ = '=';\n }\n o.status.repr = NULL;\n " +
" goto done;\n\n } else if (s_len == 1) {\n if (d_len <\n ((options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) ? 4 : 2)) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n uint32_t s = ((uint32_t)(wuffs_base__peek_u8__no_bounds_check(s_ptr)))\n << 16;\n s_ptr += 1;\n *d_ptr++ = alphabet[0x3F & (s >> 18)];\n *d_ptr++ = alphabet[0x3F & (s >> 12)];\n if (options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) {\n *d_ptr++ = '=';\n *d_ptr++ = '=';\n }\n o.status.repr = NULL;\n goto done;\n\n } else {\n o.status.repr = NULL;\n goto done;\n }\n } while (0);\n\ndone:\n o.num_dst = (size_t)(d_ptr - dst.ptr);\n o.num_src = (size_t)(s_ptr - src.ptr);\n return o;\n}\n" +
""
const BaseMagicSubmoduleC = "" +
"// ---------------- Magic Numbers\n\nWUFFS_BASE__MAYBE_STATIC int32_t //\nwuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {\n // table holds the 'magic numbers' (which are actually variable length\n // strings). The strings may contain NUL bytes, so the \"const char* magic\"\n // value starts with the length-minus-1 of the 'magic number'.\n //\n // Keep it sorted by magic[1], then magic[0] descending and finally by\n // magic[2:]. When multiple entries match, the longest one wins.\n static struct {\n int32_t fourcc;\n const char* magic;\n } table[] = {\n {0x57424D50, \"\\x01\\x00\\x00\"}, // WBMP\n {0x424D5020, \"\\x01\\x42\\x4D\"}, // BMP\n {0x47494620, \"\\x03\\x47\\x49\\x46\\x38\"}, // GIF\n {0x54494646, \"\\x03\\x49\\x49\\x2A\\x00\"}, // TIFF (little-endian)\n {0x54494646, \"\\x03\\x4D\\x4D\\x00\\x2A\"}, // TIFF (big-endian)\n {0x52494646, \"\\x03\\x52\\x49\\x46\\x46\"}, // RIFF (see § below)\n {0x4E494520, \"\\x02\\x6E\\xC3\\xAF\"}, // NIE\n {0x504E4720, \"\\x03\\x89\\x50\\x" +
"4E\\x47\"}, // PNG\n {0x4A504547, \"\\x01\\xFF\\xD8\"}, // JPEG\n };\n static const size_t table_len = sizeof(table) / sizeof(table[0]);\n\n if (prefix.len == 0) {\n return -1;\n }\n uint8_t pre_first_byte = prefix.ptr[0];\n\n int32_t fourcc = 0;\n size_t i;\n for (i = 0; i < table_len; i++) {\n uint8_t mag_first_byte = ((uint8_t)(table[i].magic[1]));\n if (pre_first_byte < mag_first_byte) {\n break;\n } else if (pre_first_byte > mag_first_byte) {\n continue;\n }\n fourcc = table[i].fourcc;\n\n uint8_t mag_remaining_len = ((uint8_t)(table[i].magic[0]));\n if (mag_remaining_len == 0) {\n goto match;\n }\n\n const char* mag_remaining_ptr = table[i].magic + 2;\n uint8_t* pre_remaining_ptr = prefix.ptr + 1;\n size_t pre_remaining_len = prefix.len - 1;\n if (pre_remaining_len < mag_remaining_len) {\n if (!memcmp(pre_remaining_ptr, mag_remaining_ptr, pre_remaining_len)) {\n return -1;\n }\n } else {\n if (!memcmp(pre_remaining_ptr, mag_remaining_ptr, mag_" +
"remaining_len)) {\n goto match;\n }\n }\n }\n return 0;\n\nmatch:\n // Some FourCC values (see § above) are further specialized.\n if (fourcc == 0x52494646) { // 'RIFF'be\n if (prefix.len < 16) {\n return -1;\n }\n uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);\n if (x == 0x57454250) { // 'WEBP'be\n uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);\n if (y == 0x56503820) { // 'VP8 'be\n return 0x57503820; // 'WP8 'be\n } else if (y == 0x5650384C) { // 'VP8L'be\n return 0x5750384C; // 'WP8L'be\n }\n }\n }\n return fourcc;\n}\n" +
""
const BasePixConvSubmoduleC = "" +
"// ---------------- Pixel Swizzler\n\nstatic inline uint32_t //\nwuffs_base__swap_u32_argb_abgr(uint32_t u) {\n uint32_t o = u & 0xFF00FF00ul;\n uint32_t r = u & 0x00FF0000ul;\n uint32_t b = u & 0x000000FFul;\n return o | (r >> 16) | (b << 16);\n}\n\nstatic inline uint64_t //\nwuffs_base__swap_u64_argb_abgr(uint64_t u) {\n uint64_t o = u & 0xFFFF0000FFFF0000ull;\n uint64_t r = u & 0x0000FFFF00000000ull;\n uint64_t b = u & 0x000000000000FFFFull;\n return o | (r >> 32) | (b << 32);\n}\n\nstatic inline uint32_t //\nwuffs_base__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) {\n uint32_t a = ((uint32_t)(0xFF & (c >> 56)));\n uint32_t r = ((uint32_t)(0xFF & (c >> 40)));\n uint32_t g = ((uint32_t)(0xFF & (c >> 24)));\n uint32_t b = ((uint32_t)(0xFF & (c >> 8)));\n return (a << 24) | (b << 16) | (g << 8) | (r << 0);\n}\n\n" +
"" +
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //\nwuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y) {\n if (!pb || (x >= pb->pixcfg.private_impl.width) ||\n (y >= pb->pixcfg.private_impl.height)) {\n return 0;\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return 0;\n }\n\n size_t stride = pb->private_impl.planes[0].stride;\n const uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {\n uint8_t* palette = pb->private_impl" +
".planes[3].ptr;\n return wuffs_base__peek_u32le__no_bounds_check(palette +\n (4 * ((size_t)row[x])));\n }\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[x])));\n case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[(2 * x) + 1])));\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[(2 * x) + 0])));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {\n uint8_t* palette = pb->private_impl.planes[3].ptr;\n return wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(palette +\n (4 * ((size_t)row[x]))));\n }\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_ba" +
"se__peek_u16le__no_bounds_check(row + (2 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return 0xFF000000 |\n wuffs_base__peek_u24le__no_bounds_check(row + (3 * ((size_t)x)));\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n return wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n return wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u64le__no_bounds_check(row + (8 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return 0xFF000000 |\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__peek_u24le__no_bounds_check(row + (3 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n return wuffs" +
"_base__swap_u32_argb_abgr(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(row +\n (4 * ((size_t)x)))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n return wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n\n default:\n // TODO: support more formats.\n break;\n }\n\n return 0;\n}\n\n" +
"" +
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_at(\n wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n if ((x >= pb->pixcfg.private_impl.width) ||\n (y >= pb->pixcfg.private_impl.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n size_t stride = pb->private_impl.planes[0].stride;\n uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);\n break;\n" +
"\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n wuffs_base__poke_u8__no_bounds_check(\n row + ((size_t)x),\n wuffs_base__color_u32_argb_premul__as__color_u8_gray(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:\n wuffs_base__poke_u16le__no_bounds_check(\n row + (2 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u16_gray(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n wuffs_base__poke_u16be__no_bounds_check(\n row + (2 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u16_gray(color));\n break;\n\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 wuffs_base__poke_u8__no_bounds_check(\n row + ((size_t)x), wuffs_base__pixel_palette__closest_element(\n wuffs_base__pixel_buffer__p" +
"alette(pb),\n pb->pixcfg.private_impl.pixfmt, color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n wuffs_base__poke_u16le__no_bounds_check(\n row + (2 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__poke_u24le__no_bounds_check(row + (3 * ((size_t)x)), color);\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__poke_u32le__no_bounds_check(\n row + (4 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n wuffs_base__poke_u64le__no_bounds_check(\n row + (8 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul(\n color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n wuffs_base__poke_u24le__no_bounds_c" +
"heck(\n row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__poke_u32le__no_bounds_check(\n row + (4 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__swap_u32_argb_abgr(color)));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__poke_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n\n default:\n // TODO: support more formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n return wuffs_base__make_status(NULL);\n}\n\n" +
"" +
"// --------\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint16_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (2 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u16le__no_bounds_check(ptr, color);\n ptr += 2;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (2 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u16le__no_bounds_check(ptr, color);\n ptr += 2;\n " +
" }\n }\n}\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xxx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint32_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (3 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u24le__no_bounds_check(ptr, color);\n ptr += 3;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (3 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u24le__no_bounds_check(ptr, color);\n ptr += 3;\n " +
" }\n }\n}\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint32_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (4 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u32le__no_bounds_check(ptr, color);\n ptr += 4;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (4 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u32le__no_bounds_check(ptr, color);\n ptr += 4;\n " +
" }\n }\n}\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxxxxxx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint64_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (8 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u64le__no_bounds_check(ptr, color);\n ptr += 8;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (8 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u64le__no_bounds_check(ptr, color);\n ptr += 8;" +
"\n }\n }\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n } else if (wuffs_base__rect_ie_u32__is_empty(&rect)) {\n return wuffs_base__make_status(NULL);\n }\n wuffs_base__rect_ie_u32 bounds =\n wuffs_base__pixel_config__bounds(&pb->pixcfg);\n if (!wuffs_base__rect_ie_u32__contains_rect(&bounds, rect)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__pixel_buffer__set_color_u32_fill_r" +
"ect__xxxx(pb, rect, color);\n return wuffs_base__make_status(NULL);\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxx(pb, rect, color);\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n color));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxxxxxx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u64_argb_no" +
"npremul(\n color));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__swap_u32_argb_abgr(color)));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n pb, rect, wuffs_base__swap_u32_argb_abgr(color));\n return wuffs_base__make_status(NULL);\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint32_t x;\n for (x = rect.min_incl_x; x < rect.max_excl_x; x++) {\n wuffs_base__pixel_buffer__set_color_u32_at(pb, x, y, color);\n }\n }\n return wuffs_base__make_status(NULL);\n}\n\n" +
"" +
"// --------\n\nWUFFS_BASE__MAYBE_STATIC uint8_t //\nwuffs_base__pixel_palette__closest_element(\n wuffs_base__slice_u8 palette_slice,\n wuffs_base__pixel_format palette_format,\n wuffs_base__color_u32_argb_premul c) {\n size_t n = palette_slice.len / 4;\n if (n > (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n n = (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4);\n }\n size_t best_index = 0;\n uint64_t best_score = 0xFFFFFFFFFFFFFFFF;\n\n // Work in 16-bit color.\n uint32_t ca = 0x101 * (0xFF & (c >> 24));\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n switch (palette_format.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 bool nonpremul = palette_format.repr ==\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL;\n\n size_t i;\n" +
" for (i = 0; i < n; i++) {\n // Work in 16-bit color.\n uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0]));\n uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1]));\n uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2]));\n uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3]));\n\n // Convert to premultiplied alpha.\n if (nonpremul && (pa != 0xFFFF)) {\n pb = (pb * pa) / 0xFFFF;\n pg = (pg * pa) / 0xFFFF;\n pr = (pr * pa) / 0xFFFF;\n }\n\n // These deltas are conceptually int32_t (signed) but after squaring,\n // it's equivalent to work in uint32_t (unsigned).\n pb -= cb;\n pg -= cg;\n pr -= cr;\n pa -= ca;\n uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) +\n ((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa));\n if (best_score > score) {\n best_score = score;\n best_index = i;\n " +
"}\n }\n break;\n }\n }\n\n return (uint8_t)best_index;\n}\n\n" +
"" +
"// --------\n\nstatic inline uint32_t //\nwuffs_base__composite_nonpremul_nonpremul_u32_axxx(uint32_t dst_nonpremul,\n uint32_t src_nonpremul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));\n uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));\n\n // Convert dst from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = ((sr * sa) + (dr * ia)) / 0xF" +
"FFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert dst from premul to nonpremul.\n if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__composite_nonpremul_nonpremul_u64_axxx(uint64_t dst_nonpremul,\n uint64_t src_nonpremul) {\n // Extract components.\n uint64_t sa = 0xFFFF & (src_nonpremul >> 48);\n uint64_t sr = 0xFFFF & (src_nonpremul >> 32);\n uint64_t sg = 0xFFFF & (src_nonpremul >> 16);\n uint64_t sb = 0xFFFF & (src_nonpremul >> 0);\n uint64_t da = 0xFFFF & (dst_nonpremul >> 48);\n uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);\n uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);\n uint64_t db = 0xFFFF & (dst_nonpremul >> 0);\n\n // Convert ds" +
"t from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint64_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert dst from premul to nonpremul.\n if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Combine components.\n return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);\n}\n\nstatic inline uint32_t //\nwuffs_base__composite_nonpremul_premul_u32_axxx(uint32_t dst_nonpremul,\n uint32_t src_premul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)" +
");\n uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));\n\n // Convert dst from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert dst from premul to nonpremul.\n if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n" +
"\nstatic inline uint64_t //\nwuffs_base__composite_nonpremul_premul_u64_axxx(uint64_t dst_nonpremul,\n uint64_t src_premul) {\n // Extract components.\n uint64_t sa = 0xFFFF & (src_premul >> 48);\n uint64_t sr = 0xFFFF & (src_premul >> 32);\n uint64_t sg = 0xFFFF & (src_premul >> 16);\n uint64_t sb = 0xFFFF & (src_premul >> 0);\n uint64_t da = 0xFFFF & (dst_nonpremul >> 48);\n uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);\n uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);\n uint64_t db = 0xFFFF & (dst_nonpremul >> 0);\n\n // Convert dst from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint64_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert dst from premul to nonpremul.\n " +
" if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Combine components.\n return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);\n}\n\nstatic inline uint32_t //\nwuffs_base__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,\n uint32_t src_nonpremul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));\n uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n" +
" dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__composite_premul_nonpremul_u64_axxx(uint64_t dst_premul,\n uint64_t src_nonpremul) {\n // Extract components.\n uint64_t sa = 0xFFFF & (src_nonpremul >> 48);\n uint64_t sr = 0xFFFF & (src_nonpremul >> 32);\n uint64_t sg = 0xFFFF & (src_nonpremul >> 16);\n uint64_t sb = 0xFFFF & (src_nonpremul >> 0);\n uint64_t da = 0xFFFF & (dst_premul >> 48);\n uint64_t dr = 0xFFFF & (dst_premul >> 32);\n uint64_t dg = 0xFFFF & (dst_premul >> 16);\n uint64_t db = 0xFFFF & (dst_premul >> 0);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint64_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul)" +
".\n da = sa + ((da * ia) / 0xFFFF);\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Combine components.\n return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);\n}\n\nstatic inline uint32_t //\nwuffs_base__composite_premul_premul_u32_axxx(uint32_t dst_premul,\n uint32_t src_premul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));\n uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n da =" +
" sa + ((da * ia) / 0xFFFF);\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(uint8_t* dst_ptr,\n size_t dst_len,\n const uint8_t* src_ptr,\n size_t src_len,\n bool nonpremul) {\n size_t len = (dst_len < src_len ? dst_len : src_len) / 4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n--) {\n uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s);\n if (nonpremul) {\n argb =\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb);\n }\n uint32_t b5 = 0x1F & (argb >> (8 - 5));\n uint32_t g6 = 0x3F & (argb >> (16 - 6));\n uint32_t r5 = 0x1F & (argb >> (24 - 5));\n uint32_t alpha = argb & 0xFF000000;\n wuffs_base__poke_u32le__no_bounds_check(\n d, alpha | (r5 << 11) | (g6 << 5) | (b5 << 0));\n s += 4;\n " +
" d += 4;\n }\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgb_bgr(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 len = (dst_len < src_len ? dst_len : src_len) / 3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n--) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n d[0] = s2;\n d[1] = s1;\n d[2] = s0;\n s += 3;\n d += 3;\n }\n return len;\n}\n\n// ‼ WUFFS MULTI-FILE SECTION +x86_sse42\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\nWUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(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 len = (dst_len < src_len ? dst_len : src_len) / 4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n __m128i shuffle = _mm_set_epi8(+0x0F, +0x0C, +0x0D, +0x0E, //\n +0x0B, +0x08, +0x09, +0x0A, //\n +0x07, +0x04, +0x05, +0x06, //\n +0x03, +0x00, +0x01, +0x02);\n\n while (n >= 4) {\n __m128i x;\n x = _mm_lddqu_si128((const __m128i*)(const void*)s);\n x = _mm_shuffle_epi8(x, shuffle);\n _mm_storeu_si128((__m128i*)(void*)d, x);\n\n s += 4 * 4;\n d += 4 * 4;\n n -= 4;\n }\n\n while (n--) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s2;\n d[1" +
"] = s1;\n d[2] = s0;\n d[3] = s3;\n s += 4;\n d += 4;\n }\n return len;\n}\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n// ‼ WUFFS MULTI-FILE SECTION -x86_sse42\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx(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 len = (dst_len < src_len ? dst_len : src_len) / 4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n--) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s2;\n d[1] = s1;\n d[2] = s0;\n d[3] = s3;\n s += 4;\n d += 4;\n }\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_1_1(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 len = (dst_len < src_len) ? dst_len : src_len;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_2_2(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 if (len > 0) {\n " +
" memmove(dst_ptr, src_ptr, len * 2);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_3_3(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_len3 = dst_len / 3;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len3 < src_len3) ? dst_len3 : src_len3;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len * 3);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_4_4(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_len4 = dst_l" +
"en / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len * 4);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_8_8(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_len8 = src_len / 8;\n size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len * 8);\n }\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgr(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_len3 = src_len / 3;\n size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t b5 = s[0] >> 3;\n uint32_t g6 = s[1] >> 2;\n uint32_t r5 = s[2] >> 3;\n uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 3;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgrx(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_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t b5 = s[0] >> 3;\n uint32_t g6 = s[1] >> 2;\n uint32_t r5 = s[2] >> 3;\n uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const u" +
"int8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src(\n 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_len8 = src_len / 8;\n size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8" +
"_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))));\n\n s += 1 * 8;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n " +
" uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (n" +
"ew_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));\n uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));\n uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));\n uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));\n\n // Convert f" +
"rom 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_" +
"565);\n\n s += 1 * 8;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_premul__src(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_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));\n\n s += 1 * 4;\n d += 1 * 2;\n n" +
" -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;" +
"\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgb(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n s" +
"ize_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_len3 = src_len / 3;\n size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t r5 = s[0] >> 3;\n uint32_t g6 = s[1] >> 2;\n uint32_t b5 = s[2] >> 3;\n uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 3;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src(\n 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_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_l" +
"en4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))));\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color compon" +
"ents.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg " +
">> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_premul__src(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_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(" +
"\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb" +
"_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nst" +
"atic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__y(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 len = (dst_len2 < src_len) ? dst_len2 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t y5 = s[0] >> 3;\n uint32_t y6 = s[0] >> 2;\n uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__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 // TODO: unroll.\n\n while (n >= 1) {\n uint32_t y5 = s[0] >> 3;\n uint32_t y6 = s[0] >> 2;\n uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 2;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__index__src(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 if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len2 = dst_len / 2;\n size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n wuffs_base__poke_u16le__no_bounds_check(\n d + (1 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[1] * 4)));\n wuffs_base__poke_u16le__no_bounds_check(\n d + (2 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[2] * 4)));\n wuffs_base__poke_u16le" +
"__no_bounds_check(\n d + (3 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 2;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__index_bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len2 = dst_len / 2;\n size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: u" +
"nroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0)));\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__index_binary_alpha__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len2 = dst_len / 2;\n size_t len = (dst_len2 < src_len) ? dst_len2 : src_len" +
";\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)s0);\n }\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgr_565(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_len3 = dst_len / 3;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 2;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src(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_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 =\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src(\n 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_len3 = dst_len / 3;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 =\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 8;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_" +
"t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_le" +
"n,\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_len3 = dst_len / 3;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));\n uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));\n uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));\n uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia" +
")) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 8;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_premul__src(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_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\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 u" +
"int8_t s2 = s[2];\n d[0] = s0;\n d[1] = s1;\n d[2] = s2;\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_premul__src_over(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_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((" +
"uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src(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_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = sr" +
"c_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_premul__src(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_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\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 uint8_t s2 = s[2];\n d[0] = s2;\n d[1] = s1;\n d[2] = s0;\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_premul__src_over(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_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n /" +
"/ Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__composite_nonpremul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src(\n 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_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__color_u64__as__color_u32(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\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 d0 = wuffs_base__color_u32__as__color_u64(" +
"\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src(\n 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_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_premul__as__" +
"color_u32_argb_nonpremul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_nonpremul_premul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__composite_nonpremul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t ds" +
"t_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__composite_nonpremul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src(\n 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_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_le" +
"n4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u3" +
"2le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_nonpremul_premul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src(\n 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_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s0;\n d[1] = s0;\n d[2] = s1;\n d[3] = s1;\n d[4] = s2;\n d[5] = s2;\n d[6] = s3;\n d[7] = s3;\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_le" +
"n / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n siz" +
"e_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\n\n s += 1 * 8;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src(\n 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_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * " +
"4))));\n wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), wuffs_base__composite_nonpremul_premul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler" +
"__bgra_nonpremul_4x16le__index_bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\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 uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4)));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\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__bgra_nonpremu" +
"l_4x16le__rgba_nonpremul__src(\n 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_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s2;\n d[1] = s2;\n d[2] = s1;\n d[3] = s1;\n d[4] = s0;\n d[5] = s0;\n d[6] = s3;\n d[7] = s3;\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len" +
"4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 =\n wuffs_base__color_u32__as__color_u64(wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src(\n 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_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t " +
"s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));\n wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 =\n wuffs_base__color_u32__as__color_u64(wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le" +
"__no_bounds_check(s + (0 * 4))));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), wuffs_base__composite_nonpremul_premul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n 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_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src(\n 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_len4 =" +
" dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(s0));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bo" +
"unds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t d0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4" +
"),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_premul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_premul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__p" +
"ixel_swizzler__bgra_premul__index_bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src(\n " +
"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_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len " +
"= (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src(\n 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_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t" +
" s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t d0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__swap_u64_argb_abgr(\n wuffs_base__peek_u64le__no_bound" +
"s_check(s + (0 * 8)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_premul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_premul__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_premul_u32_axxx(d0," +
" s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__bgr(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_len4 = dst_len / 4;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(s + (0 * 3)));\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__bgr_565(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* d" +
"st_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))));\n\n s += 1 * 2;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const u" +
"int8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n// ‼ WUFFS MULTI-FILE SECTION +x86_sse42\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\nWUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__rgb__sse42(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_len4 = dst_len / 4;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n __m128i shuffle = _mm_set_epi8(+0x00, +0x09, +0x0A, +0x0B, //\n +0x00, +0x06, +0x07, +0x08, //\n +0x00, +0x03, +0x04, +0x05, //\n +0x00, +0x00, +0x01, +0x02);\n __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00);\n\n while (n >= 6) {\n __m128i x;\n x = _mm_lddqu_si128((const __m128i*)(const void*)s);\n x = _mm_shuffle_epi8(x, shuffle);\n x = _mm_or_si128(x, or_ff);\n _mm_storeu_si128((__m128i*)(void*)d, x);\n\n s += 4 * 3;\n d += 4 * 4;\n n -= 4;\n }\n\n whi" +
"le (n >= 1) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = 0xFF;\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n// ‼ WUFFS MULTI-FILE SECTION -x86_sse42\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__rgb(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_len4 = dst_len / 4;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;\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 b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = 0xF" +
"F;\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__rgbx(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_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = 0xFF;\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__bgr(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_len3 = src_len / 3;\n size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;\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 uint8_t s2 = s[2];\n d[0] = s0;\n d[1] = s0;\n d[2] = s1;\n d[3] = s1;\n d[4] = s2;\n d[5] = s2;\n d[6] = 0xFF;\n d[7] = 0xFF;\n\n s += 1 * 3;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__bgr_565(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 wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__color_u32__as__color_u64(\n wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));\n\n s += 1 * 2;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__bgrx(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_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\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 uint8_t s2 = s[2];\n d[0] = s0;\n d[1] = s0;\n d[2] = s1;\n d[3] = s1;\n d[4] = s2;\n d[5] = s2;\n d[6] = 0xFF;\n d[7] = 0xFF;\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__rgb(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_len3 = src_len / 3;\n size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;\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 uint8_t s2 = s[2];\n d[0] = s2;\n d[1] = s2;\n d[2] = s1;\n d[3] = s1;\n d[4] = s0;\n d[5] = s0;\n d[6] = 0xFF;\n d[7] = 0xFF;\n\n s += 1 * 3;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src(\n 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_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__color_u64__as__color_u32__swap_u32_argb_abgr(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__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 const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n" +
" size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\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 d0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__swap_u64_argb_abgr(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__rgbw__bgr_565(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_len4 = dst_len / 4;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));\n\n s += 1 * 2;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index__src(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 if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n // The comparison in the while condition is \">\", not \">=\", because with\n // \">=\", the last 4-byte store could write past the end of the dst slice.\n //\n // Each 4-byte store writes one too many bytes, but a subsequent store\n // will overwrite that with the correct byte. There is always" +
" another\n // store, whether a 4-byte store in this loop or a 1-byte store in the\n // next loop.\n while (n > loop_unroll_count) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (1 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[1] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (2 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[2] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (3 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n " +
" ((size_t)s[0] * 4));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index_bgra_nonpremul__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 =\n wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000;\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u24le__no_bou" +
"nds_check(\n d + (0 * 3), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index_binary_alpha__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n }\n uint32_t s1 = wuffs_base__peek_u32le__no_bound" +
"s_check(dst_palette_ptr +\n ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__poke_u24le__no_bounds_check(d + (1 * 3), s1);\n }\n uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__poke_u24le__no_bounds_check(d + (2 * 3), s2);\n }\n uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__poke_u24le__no_bounds_check(d + (3 * 3), s3);\n }\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n }\n\n" +
" s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__xxxx(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_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u24le__no_bounds_check(\n d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__y(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_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n d[0] = s0;\n d[1] = s0;\n d[2] = s0;\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__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_len3 = dst_len / 3;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len3 < src_len2)" +
" ? dst_len3 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n d[0] = s0;\n d[1] = s0;\n d[2] = s0;\n\n s += 1 * 2;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index__src(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 if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (1 * 4), wuffs_base__" +
"peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[1] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (2 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[2] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (3 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index_binary_alpha__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 const uint8_t* src_ptr,\n size_t src_len" +
") {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0);\n }\n uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__poke_u32le__no_bounds_check(d + (1 * 4), s1);\n }\n uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__poke_u32le" +
"__no_bounds_check(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__poke_u32le__no_bounds_check(d + (3 * 4), s3);\n }\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n// ‼ WUFFS MULTI-FILE SECTION +x86_sse42\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\nWUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y__sse42(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_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n __m128i shuffle = _mm_set_epi8(+0x03, +0x03, +0x03, +0x03, //\n +0x02, +0x02, +0x02, +0x02, //\n +0x01, +0x01, +0x01, +0x01, //\n +0x00, +0x00, +0x00, +0x00);\n __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00);\n\n while (n >= 4) {\n __m128i x;\n x = _mm_cvtsi32_si128((int)(wuffs_base__peek_u32le__no_bounds_check(s)));\n x = _mm_s" +
"huffle_epi8(x, shuffle);\n x = _mm_or_si128(x, or_ff);\n _mm_storeu_si128((__m128i*)(void*)d, x);\n\n s += 4 * 1;\n d += 4 * 4;\n n -= 4;\n }\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n// ‼ WUFFS MULTI-FILE SECTION -x86_sse42\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y(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_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : 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_u32le__no_bounds_ch" +
"eck(\n d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__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_len4 = dst_len / 4;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len4 < src_len2) ? dst_len4 : 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 wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 2;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
"" +
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxxxxxx__index__src(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 if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\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), wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4))));\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__index_binary_alpha__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 const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\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 uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), wuffs_base__color_u32__as__color_u64(s0));\n }\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(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 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\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__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 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_FORMA" +
"T__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 W" +
"UFFS_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_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__bgr" +
"a_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__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_b" +
"ase__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 (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__B" +
"GRA_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_b" +
"ase__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__b" +
"gra_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_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_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 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_OV" +
"ER:\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__P" +
"IXEL_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 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_ba" +
"se__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_ov" +
"er;\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 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" +
", blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n func = wuffs_base__pixel_swizzler__prepare__y_16be(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n func = wuffs_base__pixel_swizzler__prepare__bgr_565(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n func = wuffs_base__pixel_swizzler__prepare__bgr(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n func = wuffs_ba" +
"se__pixel_swizzler__prepare__bgra_nonpremul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n func = wuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n func = wuffs_base__pixel_swizzler__prepare__bgra_premul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n func = wuffs_base__pixel_swizzler__prepare__bgrx(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n func = wuffs_base__pixel_swizzler__prepare__rgb(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n func = wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n " +
" break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n func = wuffs_base__pixel_swizzler__prepare__rgba_premul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n }\n\n p->private_impl.func = func;\n p->private_impl.transparent_black_func = transparent_black_func;\n p->private_impl.dst_pixfmt_bytes_per_pixel = dst_pixfmt_bits_per_pixel / 8;\n p->private_impl.src_pixfmt_bytes_per_pixel = src_pixfmt_bits_per_pixel / 8;\n return wuffs_base__make_status(\n func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_option);\n}\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n uint32_t up_to_num_pixels,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r) {\n if (p && p->private_impl.func) {\n const uint8_t* iop_r = *ptr_iop_r;\n uint64_t src_len = wuffs_base__u64__min(\n ((uint64_t)up_to_num_pi" +
"xels) *\n ((uint64_t)p->private_impl.src_pixfmt_bytes_per_pixel),\n ((uint64_t)(io2_r - iop_r)));\n uint64_t n =\n (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr,\n dst_palette.len, iop_r, (size_t)src_len);\n *ptr_iop_r += n * p->private_impl.src_pixfmt_bytes_per_pixel;\n return n;\n }\n return 0;\n}\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r) {\n if (p && p->private_impl.func) {\n const uint8_t* iop_r = *ptr_iop_r;\n uint64_t src_len = ((uint64_t)(io2_r - iop_r));\n uint64_t n =\n (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr,\n dst_palette.len, iop_r, (size_t)src_len);\n *ptr_iop_r += n * p->private_impl.src_pixfmt_bytes_per_pixel;\n return n;\n }\n return 0;\n}\n\nWUF" +
"FS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (p && p->private_impl.func) {\n return (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr,\n dst_palette.len, src.ptr, src.len);\n }\n return 0;\n}\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n uint64_t num_pixels) {\n if (p && p->private_impl.transparent_black_func) {\n return (*p->private_impl.transparent_black_func)(\n dst.ptr, dst.len, dst_palette.ptr, dst_palette.len, num_pixels,\n p->private_impl.dst_pixfmt_bytes_per_pixel);\n }\n return 0;\n}\n" +
""
const BaseUTF8SubmoduleC = "" +
"// ---------------- Unicode and UTF-8\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point) {\n if (code_point <= 0x7F) {\n if (dst.len >= 1) {\n dst.ptr[0] = (uint8_t)(code_point);\n return 1;\n }\n\n } else if (code_point <= 0x07FF) {\n if (dst.len >= 2) {\n dst.ptr[0] = (uint8_t)(0xC0 | ((code_point >> 6)));\n dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));\n return 2;\n }\n\n } else if (code_point <= 0xFFFF) {\n if ((dst.len >= 3) && ((code_point < 0xD800) || (0xDFFF < code_point))) {\n dst.ptr[0] = (uint8_t)(0xE0 | ((code_point >> 12)));\n dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));\n dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));\n return 3;\n }\n\n } else if (code_point <= 0x10FFFF) {\n if (dst.len >= 4) {\n dst.ptr[0] = (uint8_t)(0xF0 | ((code_point >> 18)));\n dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 12) & 0x3F));\n dst.ptr[2] = (uint8_t)(0x80 |" +
" ((code_point >> 6) & 0x3F));\n dst.ptr[3] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));\n return 4;\n }\n }\n\n return 0;\n}\n\n// wuffs_base__utf_8__byte_length_minus_1 is the byte length (minus 1) of a\n// UTF-8 encoded code point, based on the encoding's initial byte.\n// - 0x00 is 1-byte UTF-8 (ASCII).\n// - 0x01 is the start of 2-byte UTF-8.\n// - 0x02 is the start of 3-byte UTF-8.\n// - 0x03 is the start of 4-byte UTF-8.\n// - 0x40 is a UTF-8 tail byte.\n// - 0x80 is invalid UTF-8.\n//\n// RFC 3629 (UTF-8) gives this grammar for valid UTF-8:\n// UTF8-1 = %x00-7F\n// UTF8-2 = %xC2-DF UTF8-tail\n// UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /\n// %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )\n// UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /\n// %xF4 %x80-8F 2( UTF8-tail )\n// UTF8-tail = %x80-BF\nstatic const uint8_t wuffs_base__utf_8__byte_length_minus_1[256] = {\n // 0 1 2 3 4 5 " +
" 6 7\n // 8 9 A B C D E F\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x30 ..= 0x37.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00" +
", 0x00, 0x00, // 0x68 ..= 0x6F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.\n\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x80 ..= 0x87.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x88 ..= 0x8F.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x90 ..= 0x97.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x98 ..= 0x9F.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA0 ..= 0xA7.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA8 ..= 0xAF.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB0 ..= 0xB7.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB8 ..= 0xBF.\n\n 0x80, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC0 ..= 0xC7.\n 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC8 ..= 0xCF.\n 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD0 ..= 0xD7.\n 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD8 ..= 0" +
"xDF.\n 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE0 ..= 0xE7.\n 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE8 ..= 0xEF.\n 0x03, 0x03, 0x03, 0x03, 0x03, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //\nwuffs_base__utf_8__next(const uint8_t* s_ptr, size_t s_len) {\n if (s_len == 0) {\n return wuffs_base__make_utf_8__next__output(0, 0);\n }\n uint32_t c = s_ptr[0];\n switch (wuffs_base__utf_8__byte_length_minus_1[c & 0xFF]) {\n case 0:\n return wuffs_base__make_utf_8__next__output(c, 1);\n\n case 1:\n if (s_len < 2) {\n break;\n }\n c = wuffs_base__peek_u16le__no_bounds_check(s_ptr);\n if ((c & 0xC000) != 0x8000) {\n break;\n }\n c = (0x0007C0 & (c << 6)) | (0x00003F & (c >> 8));\n return wuffs_base__make_utf_8__n" +
"ext__output(c, 2);\n\n case 2:\n if (s_len < 3) {\n break;\n }\n c = wuffs_base__peek_u24le__no_bounds_check(s_ptr);\n if ((c & 0xC0C000) != 0x808000) {\n break;\n }\n c = (0x00F000 & (c << 12)) | (0x000FC0 & (c >> 2)) |\n (0x00003F & (c >> 16));\n if ((c <= 0x07FF) || ((0xD800 <= c) && (c <= 0xDFFF))) {\n break;\n }\n return wuffs_base__make_utf_8__next__output(c, 3);\n\n case 3:\n if (s_len < 4) {\n break;\n }\n c = wuffs_base__peek_u32le__no_bounds_check(s_ptr);\n if ((c & 0xC0C0C000) != 0x80808000) {\n break;\n }\n c = (0x1C0000 & (c << 18)) | (0x03F000 & (c << 4)) |\n (0x000FC0 & (c >> 10)) | (0x00003F & (c >> 24));\n if ((c <= 0xFFFF) || (0x110000 <= c)) {\n break;\n }\n return wuffs_base__make_utf_8__next__output(c, 4);\n }\n\n return wuffs_base__make_utf_8__next__output(\n WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__out" +
"put //\nwuffs_base__utf_8__next_from_end(const uint8_t* s_ptr, size_t s_len) {\n if (s_len == 0) {\n return wuffs_base__make_utf_8__next__output(0, 0);\n }\n const uint8_t* ptr = &s_ptr[s_len - 1];\n if (*ptr < 0x80) {\n return wuffs_base__make_utf_8__next__output(*ptr, 1);\n\n } else if (*ptr < 0xC0) {\n const uint8_t* too_far = &s_ptr[(s_len > 4) ? (s_len - 4) : 0];\n uint32_t n = 1;\n while (ptr != too_far) {\n ptr--;\n n++;\n if (*ptr < 0x80) {\n break;\n } else if (*ptr < 0xC0) {\n continue;\n }\n wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(ptr, n);\n if (o.byte_length != n) {\n break;\n }\n return o;\n }\n }\n\n return wuffs_base__make_utf_8__next__output(\n WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len) {\n // TODO: possibly optimize the all-ASCII case (4 or 8 bytes at a time).\n //\n // TODO: possibly opti" +
"mize this by manually inlining the\n // wuffs_base__utf_8__next calls.\n size_t original_len = s_len;\n while (s_len > 0) {\n wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(s_ptr, s_len);\n if ((o.code_point > 0x7F) && (o.byte_length == 1)) {\n break;\n }\n s_ptr += o.byte_length;\n s_len -= o.byte_length;\n }\n return original_len - s_len;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__ascii__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len) {\n // TODO: possibly optimize this by checking 4 or 8 bytes at a time.\n const uint8_t* original_ptr = s_ptr;\n const uint8_t* p = s_ptr;\n const uint8_t* q = s_ptr + s_len;\n for (; (p != q) && ((*p & 0x80) == 0); p++) {\n }\n return (size_t)(p - original_ptr);\n}\n" +
""
const AuxBaseCc = "" +
"// ---------------- Auxiliary - Base\n\n// Auxiliary code is discussed at\n// https://github.com/google/wuffs/blob/main/doc/note/auxiliary-code.md\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__BASE)\n\nnamespace wuffs_aux {\n\nnamespace sync_io {\n\n" +
"" +
"// --------\n\nInput::~Input() {}\n\nIOBuffer* //\nInput::BringsItsOwnIOBuffer() {\n return nullptr;\n}\n\n" +
"" +
"// --------\n\nFileInput::FileInput(FILE* f) : m_f(f) {}\n\nstd::string //\nFileInput::CopyIn(IOBuffer* dst) {\n if (!m_f) {\n return \"wuffs_aux::sync_io::FileInput: nullptr file\";\n } else if (!dst) {\n return \"wuffs_aux::sync_io::FileInput: nullptr IOBuffer\";\n } else if (dst->meta.closed) {\n return \"wuffs_aux::sync_io::FileInput: end of file\";\n } else {\n dst->compact();\n size_t n = fread(dst->writer_pointer(), 1, dst->writer_length(), m_f);\n dst->meta.wi += n;\n dst->meta.closed = feof(m_f);\n if (ferror(m_f)) {\n return \"wuffs_aux::sync_io::FileInput: error reading file\";\n }\n }\n return \"\";\n}\n\n" +
"" +
"// --------\n\nMemoryInput::MemoryInput(const char* ptr, size_t len)\n : m_io(wuffs_base__ptr_u8__reader(\n static_cast<uint8_t*>(static_cast<void*>(const_cast<char*>(ptr))),\n len,\n true)) {}\n\nMemoryInput::MemoryInput(const uint8_t* ptr, size_t len)\n : m_io(wuffs_base__ptr_u8__reader(const_cast<uint8_t*>(ptr), len, true)) {}\n\nIOBuffer* //\nMemoryInput::BringsItsOwnIOBuffer() {\n return &m_io;\n}\n\nstd::string //\nMemoryInput::CopyIn(IOBuffer* dst) {\n if (!dst) {\n return \"wuffs_aux::sync_io::MemoryInput: nullptr IOBuffer\";\n } else if (dst->meta.closed) {\n return \"wuffs_aux::sync_io::MemoryInput: end of file\";\n } else if (wuffs_base__slice_u8__overlaps(dst->data, m_io.data)) {\n // Treat m_io's data as immutable, so don't compact dst or otherwise write\n // to it.\n return \"wuffs_aux::sync_io::MemoryInput: overlapping buffers\";\n } else {\n dst->compact();\n size_t nd = dst->writer_length();\n size_t ns = m_io.reader_length();\n size_t n = (nd < ns) ? nd : ns;\n " +
" memcpy(dst->writer_pointer(), m_io.reader_pointer(), n);\n m_io.meta.ri += n;\n dst->meta.wi += n;\n dst->meta.closed = m_io.reader_length() == 0;\n }\n return \"\";\n}\n\n" +
"" +
"// --------\n\n} // namespace sync_io\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__BASE)\n" +
""
const AuxBaseHh = "" +
"// ---------------- Auxiliary - Base\n\n// Auxiliary code is discussed at\n// https://github.com/google/wuffs/blob/main/doc/note/auxiliary-code.md\n\n#include <stdio.h>\n\n#include <string>\n\nnamespace wuffs_aux {\n\nusing IOBuffer = wuffs_base__io_buffer;\n\n// MemOwner represents ownership of some memory. Dynamically allocated memory\n// (e.g. from malloc or new) is typically paired with free or delete, invoked\n// when the std::unique_ptr is destroyed. Statically allocated memory might use\n// MemOwner(nullptr, &free), even if that statically allocated memory is not\n// nullptr, since calling free(nullptr) is a no-op.\nusing MemOwner = std::unique_ptr<void, decltype(&free)>;\n\nnamespace sync_io {\n\n" +
"" +
"// --------\n\nclass Input {\n public:\n virtual ~Input();\n\n virtual IOBuffer* BringsItsOwnIOBuffer();\n virtual std::string CopyIn(IOBuffer* dst) = 0;\n};\n\n" +
"" +
"// --------\n\n// FileInput is an Input that reads from a file source.\n//\n// It does not take responsibility for closing the file when done.\nclass FileInput : public Input {\n public:\n FileInput(FILE* f);\n\n virtual std::string CopyIn(IOBuffer* dst);\n\n private:\n FILE* m_f;\n\n // Delete the copy and assign constructors.\n FileInput(const FileInput&) = delete;\n FileInput& operator=(const FileInput&) = delete;\n};\n\n" +
"" +
"// --------\n\n// MemoryInput is an Input that reads from an in-memory source.\n//\n// It does not take responsibility for freeing the memory when done.\nclass MemoryInput : public Input {\n public:\n MemoryInput(const char* ptr, size_t len);\n MemoryInput(const uint8_t* ptr, size_t len);\n\n virtual IOBuffer* BringsItsOwnIOBuffer();\n virtual std::string CopyIn(IOBuffer* dst);\n\n private:\n IOBuffer m_io;\n\n // Delete the copy and assign constructors.\n MemoryInput(const MemoryInput&) = delete;\n MemoryInput& operator=(const MemoryInput&) = delete;\n};\n\n" +
"" +
"// --------\n\n} // namespace sync_io\n\n} // namespace wuffs_aux\n" +
""
const AuxCborCc = "" +
"// ---------------- Auxiliary - CBOR\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__CBOR)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeCborResult::DecodeCborResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nDecodeCborCallbacks::~DecodeCborCallbacks() {}\n\nvoid //\nDecodeCborCallbacks::Done(DecodeCborResult& result,\n sync_io::Input& input,\n IOBuffer& buffer) {}\n\nDecodeCborResult //\nDecodeCbor(DecodeCborCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks) {\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 CBOR decoder.\n wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();\n if (!dec) {\n ret_error_message = \"wuffs_aux::CborDecoder: out of memory\";\n goto done;\n }\n for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\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 int64_t extension_category = 0;\n uint64_t extension_detail = 0;\n\n // Valid token's VBCs range in 0 ..= 15. Values over that are for tokens\n // from outside of the base package, such as the CBOR package.\n constexpr int64_t EXT_CAT__CBOR_TAG = 16;\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n // 1. Get the next token.\n\n while (tok_buf.meta.ri >= tok_buf.meta.wi) {\n if (tok_status.repr == nullptr) {\n // No-op.\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 // Read from input to io_buf.\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::CborDecoder: internal error: bad cursor_index\";\n goto done;\n } else if (io_buf->meta.closed) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: 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::CborDecoder: 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\n if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: 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\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::CborDecoder: internal error: bad token indexes\";\n goto done;\n }\n uint8_t* token_ptr = io_buf->data.ptr + cursor_index;\n cursor_index += static_cast<size_t>(token_len);\n\n // 2. Process that token.\n\n uint64_t vbd = token.value_base_detail();\n\n if (extension_category != 0) {\n int64_t ext = token.value_extension();\n if ((ext >= 0) && !token.continued()) {\n extension_detail = (extension_detail\n << WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS) |\n static_cast<uint64_t>(ext);\n switch (extension_category) {\n case WUFFS_BASE__TOKEN__VBC__IN" +
"LINE_INTEGER_SIGNED:\n extension_category = 0;\n ret_error_message =\n callbacks.AppendI64(static_cast<int64_t>(extension_detail));\n goto parsed_a_value;\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED:\n extension_category = 0;\n ret_error_message = callbacks.AppendU64(extension_detail);\n goto parsed_a_value;\n case EXT_CAT__CBOR_TAG:\n extension_category = 0;\n ret_error_message = callbacks.AppendCborTag(extension_detail);\n if (!ret_error_message.empty()) {\n goto done;\n }\n continue;\n }\n }\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad extended token\";\n goto done;\n }\n\n switch (token.value_base_category()) {\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 =\n (vbd & WUFFS_BASE__T" +
"OKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8)\n ? callbacks.AppendTextString(std::move(str))\n : callbacks.AppendByteString(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 if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL) {\n ret_error_message = callbacks.AppendNull();\n } else if (vbd & WUFFS_BASE__TOKEN__VBD_" +
"_LITERAL__UNDEFINED) {\n ret_error_message = callbacks.AppendUndefined();\n } else {\n ret_error_message = callbacks.AppendBool(\n vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);\n }\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n const uint64_t cfp_fbbe_fifb =\n WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT |\n WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN |\n WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE;\n if ((vbd & cfp_fbbe_fifb) == cfp_fbbe_fifb) {\n double f;\n switch (token_len) {\n case 3:\n f = wuffs_base__ieee_754_bit_representation__from_u16_to_f64(\n wuffs_base__peek_u16be__no_bounds_check(token_ptr + 1));\n break;\n case 5:\n f = wuffs_base__ieee_754_bit_representation__from_u32_to_f64(\n wuffs_base__peek" +
"_u32be__no_bounds_check(token_ptr + 1));\n break;\n case 9:\n f = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n wuffs_base__peek_u64be__no_bounds_check(token_ptr + 1));\n break;\n default:\n goto fail;\n }\n ret_error_message = callbacks.AppendF64(f);\n goto parsed_a_value;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED: {\n if (token.continued()) {\n extension_category = WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED;\n extension_detail =\n static_cast<uint64_t>(token.value_base_detail__sign_extended());\n continue;\n }\n ret_error_message =\n callbacks.AppendI64(token.value_base_detail__sign_extended());\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED: {\n if (token.continu" +
"ed()) {\n extension_category =\n WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED;\n extension_detail = vbd;\n continue;\n }\n ret_error_message = callbacks.AppendU64(vbd);\n goto parsed_a_value;\n }\n }\n\n if (token.value_major() == WUFFS_CBOR__TOKEN_VALUE_MAJOR) {\n uint64_t value_minor = token.value_minor();\n if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__MINUS_1_MINUS_X) {\n if (token_len == 9) {\n ret_error_message = callbacks.AppendMinus1MinusX(\n wuffs_base__peek_u64be__no_bounds_check(token_ptr + 1));\n goto parsed_a_value;\n }\n } else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__SIMPLE_VALUE) {\n ret_error_message =\n callbacks.AppendCborSimpleValue(static_cast<uint8_t>(\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK));\n goto parsed_a_value;\n } else if (value_minor & WUFFS_CBOR__TOKE" +
"N_VALUE_MINOR__TAG) {\n if (token.continued()) {\n extension_category = EXT_CAT__CBOR_TAG;\n extension_detail =\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK;\n continue;\n }\n ret_error_message = callbacks.AppendCborTag(\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK);\n if (!ret_error_message.empty()) {\n goto done;\n }\n continue;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::CborDecoder: 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 DecodeCborResult 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} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n " +
"// defined(WUFFS_CONFIG__MODULE__AUX__CBOR)\n" +
""
const AuxCborHh = "" +
"// ---------------- Auxiliary - CBOR\n\nnamespace wuffs_aux {\n\nstruct DecodeCborResult {\n DecodeCborResult(std::string&& error_message0, uint64_t cursor_position0);\n\n std::string error_message;\n uint64_t cursor_position;\n};\n\nclass DecodeCborCallbacks {\n public:\n virtual ~DecodeCborCallbacks();\n\n // AppendXxx are called for leaf nodes: literals, numbers, strings, etc.\n\n virtual std::string AppendNull() = 0;\n virtual std::string AppendUndefined() = 0;\n virtual std::string AppendBool(bool val) = 0;\n virtual std::string AppendF64(double val) = 0;\n virtual std::string AppendI64(int64_t val) = 0;\n virtual std::string AppendU64(uint64_t val) = 0;\n virtual std::string AppendByteString(std::string&& val) = 0;\n virtual std::string AppendTextString(std::string&& val) = 0;\n virtual std::string AppendMinus1MinusX(uint64_t val) = 0;\n virtual std::string AppendCborSimpleValue(uint8_t val) = 0;\n virtual std::string AppendCborTag(uint64_t val) = 0;\n\n // Push and Pop are called for container nodes: CBOR arrays (" +
"lists) and CBOR\n // maps (dictionaries).\n //\n // The flags bits combine exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT\n // and exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT\n\n virtual std::string Push(uint32_t flags) = 0;\n virtual std::string Pop(uint32_t flags) = 0;\n\n // Done is always the last Callback method called by DecodeCbor, whether or\n // not parsing the input as CBOR encountered an error. Even when successful,\n // trailing data may remain in input and buffer.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeCbor may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op.\n virtual void //\n Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);\n}" +
";\n\n// DecodeCbor calls callbacks based on the CBOR-formatted data in input.\n//\n// On success, the returned error_message is empty and cursor_position counts\n// the number of bytes consumed. On failure, error_message is non-empty and\n// cursor_position is the location of the error. That error may be a content\n// error (invalid CBOR) or an input error (e.g. network failure).\nDecodeCborResult //\nDecodeCbor(DecodeCborCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());\n\n} // namespace wuffs_aux\n" +
""
const AuxImageCc = "" +
"// ---------------- Auxiliary - Image\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__IMAGE)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeImageResult::DecodeImageResult(MemOwner&& pixbuf_mem_owner0,\n wuffs_base__pixel_buffer pixbuf0,\n std::string&& error_message0)\n : pixbuf_mem_owner(std::move(pixbuf_mem_owner0)),\n pixbuf(pixbuf0),\n error_message(std::move(error_message0)) {}\n\nDecodeImageResult::DecodeImageResult(std::string&& error_message0)\n : pixbuf_mem_owner(nullptr, &free),\n pixbuf(wuffs_base__null_pixel_buffer()),\n error_message(std::move(error_message0)) {}\n\nDecodeImageCallbacks::~DecodeImageCallbacks() {}\n\nDecodeImageCallbacks::AllocPixbufResult::AllocPixbufResult(\n MemOwner&& mem_owner0,\n wuffs_base__pixel_buffer pixbuf0)\n : mem_owner(std::move(mem_owner0)), pixbuf(pixbuf0), error_message(\"\") {}\n\nDecodeImageCallbacks::AllocPixbufResult::AllocPixbufResult(\n std:" +
":string&& error_message0)\n : mem_owner(nullptr, &free),\n pixbuf(wuffs_base__null_pixel_buffer()),\n error_message(std::move(error_message0)) {}\n\nDecodeImageCallbacks::AllocWorkbufResult::AllocWorkbufResult(\n MemOwner&& mem_owner0,\n wuffs_base__slice_u8 workbuf0)\n : mem_owner(std::move(mem_owner0)), workbuf(workbuf0), error_message(\"\") {}\n\nDecodeImageCallbacks::AllocWorkbufResult::AllocWorkbufResult(\n std::string&& error_message0)\n : mem_owner(nullptr, &free),\n workbuf(wuffs_base__empty_slice_u8()),\n error_message(std::move(error_message0)) {}\n\nwuffs_base__image_decoder::unique_ptr //\nDecodeImageCallbacks::SelectDecoder(uint32_t fourcc,\n wuffs_base__slice_u8 prefix) {\n switch (fourcc) {\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP)\n case WUFFS_BASE__FOURCC__BMP:\n return wuffs_bmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE" +
"__GIF)\n case WUFFS_BASE__FOURCC__GIF:\n return wuffs_gif__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NIE)\n case WUFFS_BASE__FOURCC__NIE:\n return wuffs_nie__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG)\n case WUFFS_BASE__FOURCC__PNG: {\n auto dec = wuffs_png__decoder::alloc_as__wuffs_base__image_decoder();\n // Favor faster decodes over rejecting invalid checksums.\n dec->set_quirk_enabled(WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, true);\n return dec;\n }\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)\n case WUFFS_BASE__FOURCC__WBMP:\n return wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n }\n\n return wuffs_base__image_decoder::unique_ptr(nullptr, &free);\n}\n\nwuffs_base__pixel_format //\nDecodeImageCallbacks::SelectPixfmt(\n const wuffs_base__image_config&" +
" image_config) {\n return wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL);\n}\n\nDecodeImageCallbacks::AllocPixbufResult //\nDecodeImageCallbacks::AllocPixbuf(const wuffs_base__image_config& image_config,\n bool allow_uninitialized_memory) {\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w == 0) || (h == 0)) {\n return AllocPixbufResult(\"\");\n }\n uint64_t len = image_config.pixcfg.pixbuf_len();\n if ((len == 0) || (SIZE_MAX < len)) {\n return AllocPixbufResult(DecodeImage_UnsupportedPixelConfiguration);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);\n if (!ptr) {\n return AllocPixbufResult(DecodeImage_OutOfMemory);\n }\n wuffs_base__pixel_buffer pixbuf;\n wuffs_base__status status = pixbuf.set_from_slice(\n &image_config.pixcfg,\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len));\n if (!status.is_ok()) {\n free(ptr);\n return AllocPixbu" +
"fResult(status.message());\n }\n return AllocPixbufResult(MemOwner(ptr, &free), pixbuf);\n}\n\nDecodeImageCallbacks::AllocWorkbufResult //\nDecodeImageCallbacks::AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory) {\n uint64_t len = len_range.max_incl;\n if (len == 0) {\n return AllocWorkbufResult(\"\");\n } else if (SIZE_MAX < len) {\n return AllocWorkbufResult(DecodeImage_OutOfMemory);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);\n if (!ptr) {\n return AllocWorkbufResult(DecodeImage_OutOfMemory);\n }\n return AllocWorkbufResult(\n MemOwner(ptr, &free),\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len));\n}\n\nvoid //\nDecodeImageCallbacks::Done(\n DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder) {}\n\nconst char DecodeImage_BufferIsTooShort[] = //\n \"wuffs_aux::DecodeImage: buffer is too short" +
"\";\nconst char DecodeImage_MaxInclDimensionExceeded[] = //\n \"wuffs_aux::DecodeImage: max_incl_dimension exceeded\";\nconst char DecodeImage_OutOfMemory[] = //\n \"wuffs_aux::DecodeImage: out of memory\";\nconst char DecodeImage_UnexpectedEndOfFile[] = //\n \"wuffs_aux::DecodeImage: unexpected end of file\";\nconst char DecodeImage_UnsupportedImageFormat[] = //\n \"wuffs_aux::DecodeImage: unsupported image format\";\nconst char DecodeImage_UnsupportedPixelBlend[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel blend\";\nconst char DecodeImage_UnsupportedPixelConfiguration[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel configuration\";\nconst char DecodeImage_UnsupportedPixelFormat[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel format\";\n\n" +
"" +
"// --------\n\nnamespace {\n\nstd::string //\nDecodeImageAdvanceIOBuf(sync_io::Input& input,\n wuffs_base__io_buffer& io_buf,\n bool compactable,\n uint64_t min_excl_pos,\n uint64_t pos) {\n if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {\n // Redirects must go forward.\n return DecodeImage_UnsupportedImageFormat;\n }\n while (true) {\n uint64_t relative_pos = pos - io_buf.reader_position();\n if (relative_pos <= io_buf.reader_length()) {\n io_buf.meta.ri += (size_t)relative_pos;\n break;\n } else if (io_buf.meta.closed) {\n return DecodeImage_UnexpectedEndOfFile;\n }\n io_buf.meta.ri = io_buf.meta.wi;\n if (compactable) {\n io_buf.compact();\n }\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return error_message;\n }\n }\n return \"\";\n}\n\nDecodeImageResult //\nDecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,\n " +
" DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__io_buffer& io_buf,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\n // Check args.\n switch (pixel_blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelBlend);\n }\n\n wuffs_base__image_config image_config = wuffs_base__null_image_config();\n uint64_t start_pos = io_buf.reader_position();\n bool redirected = false;\n int32_t fourcc = 0;\nredirect:\n do {\n // Determine the image format.\n if (!redirected) {\n while (true) {\n fourcc = wuffs_base__magic_number_guess_fourcc(io_buf.reader_slice());\n if (fourcc > 0) {\n break;\n } else if ((fourcc == 0) && (io_buf.reader_length() >= 64)) {\n break;\n } else if (io_buf.meta.closed ||" +
" (io_buf.writer_length() == 0)) {\n fourcc = 0;\n break;\n }\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n } else {\n wuffs_base__io_buffer empty = wuffs_base__empty_io_buffer();\n wuffs_base__more_information minfo = wuffs_base__empty_more_information();\n wuffs_base__status tmm_status =\n image_decoder->tell_me_more(&empty, &minfo, &io_buf);\n if (tmm_status.repr != nullptr) {\n return DecodeImageResult(tmm_status.message());\n }\n if (minfo.flavor != WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n uint64_t pos = minfo.io_redirect__range().min_incl;\n std::string error_message = DecodeImageAdvanceIOBuf(\n input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);\n if (!error_message.empty()) {\n return" +
" DecodeImageResult(std::move(error_message));\n }\n fourcc = (int32_t)(minfo.io_redirect__fourcc());\n if (fourcc == 0) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n image_decoder.reset();\n }\n\n // Select the image decoder.\n image_decoder = callbacks.SelectDecoder(\n (uint32_t)fourcc,\n fourcc ? wuffs_base__empty_slice_u8() : io_buf.reader_slice());\n if (!image_decoder) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n\n // Decode the image config.\n while (true) {\n wuffs_base__status id_dic_status =\n image_decoder->decode_image_config(&image_config, &io_buf);\n if (id_dic_status.repr == nullptr) {\n break;\n } else if (id_dic_status.repr == wuffs_base__note__i_o_redirect) {\n if (redirected) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n redirected = true;\n goto redirect;\n } else if (id_dic_status.repr != wuffs_bas" +
"e__suspension__short_read) {\n return DecodeImageResult(id_dic_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n } while (false);\n\n // Select the pixel format.\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w > max_incl_dimension) || (h > max_incl_dimension)) {\n return DecodeImageResult(DecodeImage_MaxInclDimensionExceeded);\n }\n wuffs_base__pixel_format pixel_format = callbacks.SelectPixfmt(image_config);\n if (pixel_format.repr != image_config.pixcfg.pixel_format().repr) {\n switch (pixel_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT" +
"__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);\n }\n image_config.pixcfg.set(pixel_format.repr,\n WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);\n }\n\n // Allocate the pixel buffer.\n bool valid_background_color =\n wuffs_base__color_u32_argb_premul__is_valid(background_color);\n DecodeImageCallbacks::AllocPixbufResult alloc_pixbuf_result =\n callbacks.AllocPixbuf(image_config, valid_background_color);\n if (!alloc_pixbuf_result.error_message.empty()) {\n return DecodeImageResult(std::move(alloc_pixbuf_result.error_message));\n }\n wuffs_base__pixel_buffer pixel_buffer = alloc_pixbuf_result.pixbuf;\n if (valid_background_color) {\n wuffs_base__status pb_scufr_status = pixel_buffer.set_color_u32_fill_rect(\n pixel_buffer.pixcfg.bounds(), b" +
"ackground_color);\n if (pb_scufr_status.repr != nullptr) {\n return DecodeImageResult(pb_scufr_status.message());\n }\n }\n\n // Allocate the work buffer. Wuffs' decoders conventionally assume that this\n // can be uninitialized memory.\n wuffs_base__range_ii_u64 workbuf_len = image_decoder->workbuf_len();\n DecodeImageCallbacks::AllocWorkbufResult alloc_workbuf_result =\n callbacks.AllocWorkbuf(workbuf_len, true);\n if (!alloc_workbuf_result.error_message.empty()) {\n return DecodeImageResult(std::move(alloc_workbuf_result.error_message));\n } else if (alloc_workbuf_result.workbuf.len < workbuf_len.min_incl) {\n return DecodeImageResult(DecodeImage_BufferIsTooShort);\n }\n\n // Decode the frame config.\n wuffs_base__frame_config frame_config = wuffs_base__null_frame_config();\n while (true) {\n wuffs_base__status id_dfc_status =\n image_decoder->decode_frame_config(&frame_config, &io_buf);\n if (id_dfc_status.repr == nullptr) {\n break;\n } else if (id_dfc_status.repr != wuffs_b" +
"ase__suspension__short_read) {\n return DecodeImageResult(id_dfc_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n\n // Decode the frame (the pixels).\n //\n // From here on, always returns the pixel_buffer. If we get this far, we can\n // still display a partial image, even if we encounter an error.\n std::string message(\"\");\n if ((pixel_blend == WUFFS_BASE__PIXEL_BLEND__SRC_OVER) &&\n frame_config.overwrite_instead_of_blend()) {\n pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC;\n }\n while (true) {\n wuffs_base__status id_df_status =\n image_decoder->decode_frame(&pixel_buffer, &io_buf, pixel_blend,\n alloc_workbuf_result.workbuf, nullptr);\n if (id_df_status.repr == nullptr) {\n break;\n } else if (" +
"id_df_status.repr != wuffs_base__suspension__short_read) {\n message = id_df_status.message();\n break;\n } else if (io_buf.meta.closed) {\n message = DecodeImage_UnexpectedEndOfFile;\n break;\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n message = std::move(error_message);\n break;\n }\n }\n }\n return DecodeImageResult(std::move(alloc_pixbuf_result.mem_owner),\n pixel_buffer, std::move(message));\n}\n\n} // namespace\n\nDecodeImageResult //\nDecodeImage(DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\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 fallba" +
"ck_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[32768]);\n fallback_io_buf =\n wuffs_base__ptr_u8__writer(fallback_io_array.get(), 32768);\n io_buf = &fallback_io_buf;\n }\n\n wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);\n DecodeImageResult result =\n DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,\n background_color, max_incl_dimension);\n callbacks.Done(result, input, *io_buf, std::move(image_decoder));\n return result;\n}\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__IMAGE)\n" +
""
const AuxImageHh = "" +
"// ---------------- Auxiliary - Image\n\nnamespace wuffs_aux {\n\nstruct DecodeImageResult {\n DecodeImageResult(MemOwner&& pixbuf_mem_owner0,\n wuffs_base__pixel_buffer pixbuf0,\n std::string&& error_message0);\n DecodeImageResult(std::string&& error_message0);\n\n MemOwner pixbuf_mem_owner;\n wuffs_base__pixel_buffer pixbuf;\n std::string error_message;\n};\n\n// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always\n// called in this order:\n// 1. SelectDecoder\n// 2. SelectPixfmt\n// 3. AllocPixbuf\n// 4. AllocWorkbuf\n// 5. Done\n//\n// It may return early - the third callback might not be invoked if the second\n// one fails - but the final callback (Done) is always invoked.\nclass DecodeImageCallbacks {\n public:\n // AllocPixbufResult holds a memory allocation (the result of malloc or new,\n // a statically allocated pointer, etc), or an error message. The memory is\n // de-allocated when mem_owner goes out of scope and is destroyed.\n struct AllocPixbufResu" +
"lt {\n AllocPixbufResult(MemOwner&& mem_owner0, wuffs_base__pixel_buffer pixbuf0);\n AllocPixbufResult(std::string&& error_message0);\n\n MemOwner mem_owner;\n wuffs_base__pixel_buffer pixbuf;\n std::string error_message;\n };\n\n // AllocWorkbufResult holds a memory allocation (the result of malloc or new,\n // a statically allocated pointer, etc), or an error message. The memory is\n // de-allocated when mem_owner goes out of scope and is destroyed.\n struct AllocWorkbufResult {\n AllocWorkbufResult(MemOwner&& mem_owner0, wuffs_base__slice_u8 workbuf0);\n AllocWorkbufResult(std::string&& error_message0);\n\n MemOwner mem_owner;\n wuffs_base__slice_u8 workbuf;\n std::string error_message;\n };\n\n virtual ~DecodeImageCallbacks();\n\n // SelectDecoder returns the image decoder for the input data's file format.\n // Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat).\n //\n // Common formats will have a FourCC value in the range [1 ..= 0x7FFF_FFFF],\n // such as WUFFS_BASE__F" +
"OURCC__JPEG. A zero FourCC value means that the\n // caller is responsible for examining the opening bytes (a prefix) of the\n // input data. SelectDecoder implementations should not modify those bytes.\n //\n // SelectDecoder might be called more than once, since some image file\n // formats can wrap others. For example, a nominal BMP file can actually\n // contain a JPEG or a PNG.\n //\n // The default SelectDecoder accepts the FOURCC codes listed below. For\n // modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance\n // of the ETC file format is optional (for each value of ETC) and depends on\n // the corresponding module to be enabled at compile time (i.e. #define'ing\n // WUFFS_CONFIG__MODULE__ETC).\n // - WUFFS_BASE__FOURCC__BMP\n // - WUFFS_BASE__FOURCC__GIF\n // - WUFFS_BASE__FOURCC__NIE\n // - WUFFS_BASE__FOURCC__PNG\n // - WUFFS_BASE__FOURCC__WBMP\n virtual wuffs_base__image_decoder::unique_ptr //\n SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);\n\n // SelectPix" +
"fmt returns the destination pixel format for AllocPixbuf. It\n // should return wuffs_base__make_pixel_format(etc) called with one of:\n // - WUFFS_BASE__PIXEL_FORMAT__BGR_565\n // - WUFFS_BASE__PIXEL_FORMAT__BGR\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL\n // - WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL\n // - WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL\n // or return image_config.pixcfg.pixel_format(). The latter means to use the\n // image file's natural pixel format. For example, GIF images' natural pixel\n // format is an indexed one.\n //\n // Returning otherwise means failure (DecodeImage_UnsupportedPixelFormat).\n //\n // The default SelectPixfmt implementation returns\n // wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) which\n // is 4 bytes per pixel (8 bits per channel × 4 channels).\n virtual wuffs_base__pixel_format //\n SelectPixfmt(const wuffs_base__image_config& image_" +
"config);\n\n // AllocPixbuf allocates the pixel buffer.\n //\n // allow_uninitialized_memory will be true if a valid background_color was\n // passed to DecodeImage, since the pixel buffer's contents will be\n // overwritten with that color after AllocPixbuf returns.\n //\n // The default AllocPixbuf implementation allocates either uninitialized or\n // zeroed memory. Zeroed memory typically corresponds to filling with opaque\n // black or transparent black, depending on the pixel format.\n virtual AllocPixbufResult //\n AllocPixbuf(const wuffs_base__image_config& image_config,\n bool allow_uninitialized_memory);\n\n // AllocWorkbuf allocates the work buffer. The allocated buffer's length\n // should be at least len_range.min_incl, but larger allocations (up to\n // len_range.max_incl) may have better performance (by using more memory).\n //\n // The default AllocWorkbuf implementation allocates len_range.max_incl bytes\n // of either uninitialized or zeroed memory.\n virtual AllocWorkbufResult //" +
"\n AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory);\n\n // Done is always the last Callback method called by DecodeImage, whether or\n // not parsing the input encountered an error. Even when successful, trailing\n // data may remain in input and buffer.\n //\n // The image_decoder is the one returned by SelectDecoder (if SelectDecoder\n // was successful), or a no-op unique_ptr otherwise. Like any unique_ptr,\n // ownership moves to the Done implementation.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeImage may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op, other than running the\n // image_decoder unique_ptr destructor.\n virtual void //\n Done(DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder);\n};\n\nextern const char DecodeImage_BufferIsTooShort[];\nextern const char DecodeImag" +
"e_MaxInclDimensionExceeded[];\nextern const char DecodeImage_OutOfMemory[];\nextern const char DecodeImage_UnexpectedEndOfFile[];\nextern const char DecodeImage_UnsupportedImageFormat[];\nextern const char DecodeImage_UnsupportedPixelBlend[];\nextern const char DecodeImage_UnsupportedPixelConfiguration[];\nextern const char DecodeImage_UnsupportedPixelFormat[];\n\n// DecodeImage decodes the image data in input. A variety of image file formats\n// can be decoded, depending on what callbacks.SelectDecoder returns.\n//\n// For animated formats, only the first frame is returned, since the API is\n// simpler for synchronous I/O and having DecodeImage only return when\n// completely done, but rendering animation often involves handling other\n// events in between animation frames. To decode multiple frames of animated\n// images, or for asynchronous I/O (e.g. when decoding an image streamed over\n// the network), use Wuffs' lower level C API instead of its higher level,\n// simplified C++ API (the wuffs_aux API).\n//\n// The DecodeIm" +
"ageResult's fields depend on whether decoding succeeded:\n// - On total success, the error_message is empty and pixbuf.pixcfg.is_valid()\n// is true.\n// - On partial success (e.g. the input file was truncated but we are still\n// able to decode some of the pixels), error_message is non-empty but\n// pixbuf.pixcfg.is_valid() is still true. It is up to the caller whether to\n// accept or reject partial success.\n// - On failure, the error_message is non_empty and pixbuf.pixcfg.is_valid()\n// is false.\n//\n// The callbacks allocate the pixel buffer memory and work buffer memory. On\n// success, pixel buffer memory ownership is passed to the DecodeImage caller\n// as the returned pixbuf_mem_owner. Regardless of success or failure, the work\n// buffer memory is deleted.\n//\n// The pixel_blend (one of the constants listed below) determines how to\n// composite the decoded image over the pixel buffer's original pixels (as\n// returned by callbacks.AllocPixbuf):\n// - WUFFS_BASE__PIXEL_BLEND__SRC\n// - WUFFS_BASE" +
"__PIXEL_BLEND__SRC_OVER\n//\n// The background_color is used to fill the pixel buffer after\n// callbacks.AllocPixbuf returns, if it is valid in the\n// wuffs_base__color_u32_argb_premul__is_valid sense. The default value,\n// 0x0000_0001, is not valid since its Blue channel value (0x01) is greater\n// than its Alpha channel value (0x00). A valid background_color will typically\n// be overwritten when pixel_blend is WUFFS_BASE__PIXEL_BLEND__SRC, but might\n// still be visible on partial (not total) success or when pixel_blend is\n// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.\n//\n// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's\n// width or height is greater than max_incl_dimension.\nDecodeImageResult //\nDecodeImage(DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,\n wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.\n uint32_" +
"t max_incl_dimension = 1048575); // 0x000F_FFFF\n\n} // namespace wuffs_aux\n" +
""
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\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" +
"" +
"// --------\n\nstd::string //\nDecodeJson_WalkJsonPointerFragment(wuffs_base__token_buffer& tok_buf,\n wuffs_base__status& tok_status,\n wuffs_json__decoder::unique_ptr& dec,\n wuffs_base__io_buffer* io_buf,\n std::string& io_error_message,\n size_t& cursor_index,\n sync_io::Input& input,\n std::string& json_pointer_fragment) {\n std::string ret_error_message;\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 if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {\n continue;\n } else if ((vbc != WUFFS_BASE__TOKEN__VBC__STRUCTURE) ||\n !(vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH)) {\n return DecodeJson_NoMatch;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__ST" +
"RUCTURE__TO_LIST) {\n goto do_list;\n }\n goto do_dict;\n }\n\ndo_dict:\n // Alternate between these two things:\n // 1. Decode the next dict key (a string). If it matches the fragment, we're\n // done (success). If we've reached the dict's end (VBD__STRUCTURE__POP)\n // so that there was no next dict key, we're done (failure).\n // 2. Otherwise, skip the next dict value.\n while (true) {\n for (std::string str; 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 goto fail;\n }\n return DecodeJson_NoMatch;\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 } els" +
"e 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 break;\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 break;\n }\n\n default:\n goto fail;\n }\n\n if (token.continued()) {\n continue;\n }\n if (str == json_pointer_fragment) {\n " +
" return \"\";\n }\n goto skip_the_next_dict_value;\n }\n\n skip_the_next_dict_value:\n for (uint32_t skip_depth = 0; 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 if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n skip_depth--;\n }\n\n if (skip_depth == 0) {\n break;\n }\n } // skip_the_next_dict_value\n } // do_dict\n\ndo_list:\n do {\n wuffs_base__result_u64 result_u64 = wuffs_base__parse_number_u64(\n wuffs_base__make_slice_u8(\n static_cast<uint8_t*>(static_cast<void*>(\n const_cast<char*>(json_pointer_fragment.data()))),\n json_pointer_fragment.size()),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTI" +
"ONS);\n if (!result_u64.status.is_ok()) {\n return DecodeJson_NoMatch;\n }\n uint64_t remaining = result_u64.value;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n for (uint32_t skip_depth = 0; 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 if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n if (skip_depth == 0) {\n return DecodeJson_NoMatch;\n }\n skip_depth--;\n }\n\n if (skip_depth > 0) {\n continue;\n }\n remaining--;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n }\n } while (false); // do_list\n\ncheck_that_a_value_follows:\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 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" +
""
const AuxJsonHh = "" +
"// ---------------- Auxiliary - JSON\n\nnamespace wuffs_aux {\n\nstruct DecodeJsonResult {\n DecodeJsonResult(std::string&& error_message0, uint64_t cursor_position0);\n\n std::string error_message;\n uint64_t cursor_position;\n};\n\nclass DecodeJsonCallbacks {\n public:\n virtual ~DecodeJsonCallbacks();\n\n // AppendXxx are called for leaf nodes: literals, numbers and strings. For\n // strings, the Callbacks implementation is responsible for tracking map keys\n // versus other values.\n\n virtual std::string AppendNull() = 0;\n virtual std::string AppendBool(bool val) = 0;\n virtual std::string AppendF64(double val) = 0;\n virtual std::string AppendI64(int64_t val) = 0;\n virtual std::string AppendTextString(std::string&& val) = 0;\n\n // Push and Pop are called for container nodes: JSON arrays (lists) and JSON\n // objects (dictionaries).\n //\n // The flags bits combine exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST\n // - WUFFS_BASE__TOKEN__V" +
"BD__STRUCTURE__FROM_DICT\n // and exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT\n\n virtual std::string Push(uint32_t flags) = 0;\n virtual std::string Pop(uint32_t flags) = 0;\n\n // Done is always the last Callback method called by DecodeJson, whether or\n // not parsing the input as JSON encountered an error. Even when successful,\n // trailing data may remain in input and buffer. See \"Unintuitive JSON\n // Parsing\" (https://nullprogram.com/blog/2019/12/28/) which discusses JSON\n // parsing and when it stops.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeJson may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op.\n virtual void //\n Done(DecodeJsonResult& result, sync_io::Input& input, IOBuffer& buffer);\n};\n\nextern const char DecodeJson_BadJsonPointer[];\nextern const char DecodeJson_NoMatch[];\n\n//" +
" DecodeJson calls callbacks based on the JSON-formatted data in input.\n//\n// On success, the returned error_message is empty and cursor_position counts\n// the number of bytes consumed. On failure, error_message is non-empty and\n// cursor_position is the location of the error. That error may be a content\n// error (invalid JSON) or an input error (e.g. network failure).\n//\n// json_pointer is a query in the JSON Pointer (RFC 6901) syntax. The callbacks\n// run for the input's sub-node that matches the query. DecodeJson_NoMatch is\n// returned if no matching sub-node was found. The empty query matches the\n// input's root node, consistent with JSON Pointer semantics.\n//\n// The JSON Pointer implementation is greedy: duplicate keys are not rejected\n// but only the first match for each '/'-separated fragment is followed.\nDecodeJsonResult //\nDecodeJson(DecodeJsonCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),\n std::string json_po" +
"inter = std::string());\n\n} // namespace wuffs_aux\n" +
""
var AuxNonBaseCcFiles = []string{
AuxCborCc,
AuxImageCc,
AuxJsonCc,
}
var AuxNonBaseHhFiles = []string{
AuxCborHh,
AuxImageHh,
AuxJsonHh,
}
const BaseCopyright = "" +
"// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n" +
""
-193
View File
@@ -1,193 +0,0 @@
// Copyright 2017 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.
// +build ignore
package main
// gen.go converts "../base/*" to "data.go".
//
// Invoke it via "go generate".
import (
"bytes"
"fmt"
"go/format"
"io/ioutil"
"os"
"strings"
)
const columns = 1024
func main() {
if err := main1(); err != nil {
os.Stderr.WriteString(err.Error() + "\n")
os.Exit(1)
}
}
func main1() error {
out := &bytes.Buffer{}
out.WriteString("// Code generated by running \"go generate\". DO NOT EDIT.\n")
out.WriteString("\n")
out.WriteString("// Copyright 2017 The Wuffs Authors.\n")
out.WriteString("//\n")
out.WriteString("// Licensed under the Apache License, Version 2.0 (the \"License\");\n")
out.WriteString("// you may not use this file except in compliance with the License.\n")
out.WriteString("// You may obtain a copy of the License at\n")
out.WriteString("//\n")
out.WriteString("// https://www.apache.org/licenses/LICENSE-2.0\n")
out.WriteString("//\n")
out.WriteString("// Unless required by applicable law or agreed to in writing, software\n")
out.WriteString("// distributed under the License is distributed on an \"AS IS\" BASIS,\n")
out.WriteString("// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n")
out.WriteString("// See the License for the specific language governing permissions and\n")
out.WriteString("// limitations under the License.\n")
out.WriteString("\n")
out.WriteString("package data\n")
out.WriteString("\n")
if err := genData(out); err != nil {
return err
}
formatted, err := format.Source(out.Bytes())
if err != nil {
return err
}
return ioutil.WriteFile("data.go", formatted, 0644)
}
func genData(out *bytes.Buffer) error {
files := []struct {
filename, varname string
}{
{"../base/all-impl.c", "BaseAllImplC"},
{"../base/fundamental-private.h", "BaseFundamentalPrivateH"},
{"../base/fundamental-public.h", "BaseFundamentalPublicH"},
{"../base/memory-private.h", "BaseMemoryPrivateH"},
{"../base/memory-public.h", "BaseMemoryPublicH"},
{"../base/image-private.h", "BaseImagePrivateH"},
{"../base/image-public.h", "BaseImagePublicH"},
{"../base/io-private.h", "BaseIOPrivateH"},
{"../base/io-public.h", "BaseIOPublicH"},
{"../base/range-private.h", "BaseRangePrivateH"},
{"../base/range-public.h", "BaseRangePublicH"},
{"../base/strconv-private.h", "BaseStrConvPrivateH"},
{"../base/strconv-public.h", "BaseStrConvPublicH"},
{"../base/token-private.h", "BaseTokenPrivateH"},
{"../base/token-public.h", "BaseTokenPublicH"},
{"../base/floatconv-submodule-code.c", "BaseFloatConvSubmoduleCodeC"},
{"../base/floatconv-submodule-data.c", "BaseFloatConvSubmoduleDataC"},
{"../base/intconv-submodule.c", "BaseIntConvSubmoduleC"},
{"../base/magic-submodule.c", "BaseMagicSubmoduleC"},
{"../base/pixconv-submodule.c", "BasePixConvSubmoduleC"},
{"../base/utf8-submodule.c", "BaseUTF8SubmoduleC"},
{"../auxiliary/base.cc", "AuxBaseCc"},
{"../auxiliary/base.hh", "AuxBaseHh"},
{"../auxiliary/cbor.cc", "AuxCborCc"},
{"../auxiliary/cbor.hh", "AuxCborHh"},
{"../auxiliary/image.cc", "AuxImageCc"},
{"../auxiliary/image.hh", "AuxImageHh"},
{"../auxiliary/json.cc", "AuxJsonCc"},
{"../auxiliary/json.hh", "AuxJsonHh"},
}
prefixAfterEditing := []byte("// After editing this file,")
prefixCopyright := []byte("// Copyright ")
copyright := []byte(nil)
for _, f := range files {
in, err := ioutil.ReadFile(f.filename)
if err != nil {
return err
}
if !bytes.HasPrefix(in, prefixAfterEditing) {
return fmt.Errorf("%s's contents do not start with %q", f.filename, prefixAfterEditing)
}
if i := bytes.Index(in, []byte("\n\n")); i >= 0 {
in = in[i+2:]
}
if !bytes.HasPrefix(in, prefixCopyright) {
return fmt.Errorf("%s's contents do not start with %q", f.filename, prefixCopyright)
}
if i := bytes.Index(in, []byte("\n\n")); i >= 0 {
if len(copyright) == 0 {
// Take only one of the two trailing '\n's.
copyright = in[:i+1]
}
in = in[i+2:]
}
fmt.Fprintf(out, "const %s = \"\" +\n", f.varname)
writeStringConst(out, in)
out.WriteString("\"\"\n\n")
}
fmt.Fprintf(out, "var AuxNonBaseCcFiles = []string{\n")
for _, f := range files {
if strings.HasPrefix(f.varname, "Aux") &&
strings.HasSuffix(f.varname, "Cc") &&
(f.varname != "AuxBaseCc") {
fmt.Fprintf(out, "%s,\n", f.varname)
}
}
fmt.Fprintf(out, "}\n\n")
fmt.Fprintf(out, "var AuxNonBaseHhFiles = []string{\n")
for _, f := range files {
if strings.HasPrefix(f.varname, "Aux") &&
strings.HasSuffix(f.varname, "Hh") &&
(f.varname != "AuxBaseHh") {
fmt.Fprintf(out, "%s,\n", f.varname)
}
}
fmt.Fprintf(out, "}\n\n")
fmt.Fprintf(out, "const BaseCopyright = \"\" +\n")
writeStringConst(out, copyright)
out.WriteString("\"\"\n\n")
return nil
}
var dashDashDashDash = []byte("// ----")
func writeStringConst(out *bytes.Buffer, s []byte) {
for len(s) > 0 {
remaining := []byte(nil)
if i := bytes.Index(s[1:], dashDashDashDash); i >= 0 {
s, remaining = s[:i+1], s[i+1:]
}
for len(s) > 0 {
t := s
if len(t) > columns {
t = t[:columns]
}
s = s[len(t):]
fmt.Fprintf(out, "%q +\n", t)
}
s = remaining
if len(s) > 0 {
out.WriteString("\"\" +\n")
}
}
}
-21
View File
@@ -1,21 +0,0 @@
// Copyright 2020 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.
//go:generate go run gen.go
// Package data contains the files in the sibling "../base" and "../auxiliary"
// directories: the hand-written C and C++ code that is the 'runtime library'
// for Wuffs-transpiled-to-C. In this Go package, those files' contents are
// provided as string constants.
package data
+142
View File
@@ -0,0 +1,142 @@
// 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.
package cgen
import (
_ "embed"
"strings"
)
// EmbeddedString holds hand-written C/C++ code, exposed by this Go package by
// a "go:embed" directive.
type EmbeddedString string
// Trim removes the leading "Copyright etc" boilerplate.
func (e EmbeddedString) Trim() string {
s := string(e)
if strings.HasPrefix(s, "// Copyright ") {
if i := strings.Index(s, "\n\n"); i >= 0 {
s = s[i+2:]
}
}
return s
}
// ----
//go:embed base/all-impl.c
var embedBaseAllImplC EmbeddedString
// ----
//go:embed base/fundamental-private.h
var embedBaseFundamentalPrivateH EmbeddedString
//go:embed base/fundamental-public.h
var embedBaseFundamentalPublicH EmbeddedString
//go:embed base/memory-private.h
var embedBaseMemoryPrivateH EmbeddedString
//go:embed base/memory-public.h
var embedBaseMemoryPublicH EmbeddedString
//go:embed base/image-private.h
var embedBaseImagePrivateH EmbeddedString
//go:embed base/image-public.h
var embedBaseImagePublicH EmbeddedString
//go:embed base/io-private.h
var embedBaseIOPrivateH EmbeddedString
//go:embed base/io-public.h
var embedBaseIOPublicH EmbeddedString
//go:embed base/range-private.h
var embedBaseRangePrivateH EmbeddedString
//go:embed base/range-public.h
var embedBaseRangePublicH EmbeddedString
//go:embed base/strconv-private.h
var embedBaseStrConvPrivateH EmbeddedString
//go:embed base/strconv-public.h
var embedBaseStrConvPublicH EmbeddedString
//go:embed base/token-private.h
var embedBaseTokenPrivateH EmbeddedString
//go:embed base/token-public.h
var embedBaseTokenPublicH EmbeddedString
// ----
//go:embed base/floatconv-submodule-code.c
var embedBaseFloatConvSubmoduleCodeC EmbeddedString
//go:embed base/floatconv-submodule-data.c
var embedBaseFloatConvSubmoduleDataC EmbeddedString
//go:embed base/intconv-submodule.c
var embedBaseIntConvSubmoduleC EmbeddedString
//go:embed base/magic-submodule.c
var embedBaseMagicSubmoduleC EmbeddedString
//go:embed base/pixconv-submodule.c
var embedBasePixConvSubmoduleC EmbeddedString
//go:embed base/utf8-submodule.c
var embedBaseUTF8SubmoduleC EmbeddedString
// ----
//go:embed auxiliary/base.cc
var EmbeddedString_AuxBaseCc EmbeddedString
//go:embed auxiliary/base.hh
var EmbeddedString_AuxBaseHh EmbeddedString
//go:embed auxiliary/cbor.cc
var embedAuxCborCc EmbeddedString
//go:embed auxiliary/cbor.hh
var embedAuxCborHh EmbeddedString
//go:embed auxiliary/image.cc
var embedAuxImageCc EmbeddedString
//go:embed auxiliary/image.hh
var embedAuxImageHh EmbeddedString
//go:embed auxiliary/json.cc
var embedAuxJsonCc EmbeddedString
//go:embed auxiliary/json.hh
var embedAuxJsonHh EmbeddedString
var EmbeddedStrings_AuxNonBaseCcFiles = []EmbeddedString{
embedAuxCborCc,
embedAuxImageCc,
embedAuxJsonCc,
}
var EmbeddedStrings_AuxNonBaseHhFiles = []EmbeddedString{
embedAuxCborHh,
embedAuxImageHh,
embedAuxJsonHh,
}
+6 -1
View File
@@ -123,7 +123,12 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, sideEffectsOnly bool, depth u
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.printf(", sizeof (%s%s), WUFFS_VERSION, 0))", g.packagePrefix(qid), qid[1].Str(g.tm))
b.printf(",\nsizeof (%s%s), WUFFS_VERSION, ", g.packagePrefix(qid), qid[1].Str(g.tm))
if recv.IsThisDotFoo() != 0 {
b.writes("WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED))")
} else {
b.writes("0))")
}
return nil
}
+9 -6
View File
@@ -40,7 +40,7 @@ type funk struct {
derivedVars map[t.ID]struct{}
jumpTargets map[a.Loop]string
coroSuspPoint uint32
ioBinds uint32
ioManips uint32
tempW uint32
tempR uint32
usesEmptyIOBuffer bool
@@ -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")
}
}
@@ -501,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.
@@ -523,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
}
+8 -3
View File
@@ -185,8 +185,8 @@ loop:
return err
}
case a.KIOBind:
if err := h.doIOBind(r, o.AsIOBind(), depth); err != nil {
case a.KIOManip:
if err := h.doIOManip(r, o.AsIOManip(), depth); err != nil {
return err
}
@@ -324,13 +324,18 @@ func (h *livenessHelper) doExpr1(r livenesses, n *a.Expr, allToStrong bool, dept
return nil
}
func (h *livenessHelper) doIOBind(r livenesses, n *a.IOBind, depth uint32) error {
func (h *livenessHelper) doIOManip(r livenesses, n *a.IOManip, depth uint32) error {
if err := h.doExpr(r, n.IO()); err != nil {
return err
}
if err := h.doExpr(r, n.Arg1()); err != nil {
return err
}
if histPos := n.HistoryPosition(); histPos != nil {
if err := h.doExpr(r, n.HistoryPosition()); err != nil {
return err
}
}
return h.doBlock(r, n.Body(), depth)
}
+14 -9
View File
@@ -60,8 +60,8 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
return g.writeStatementAssign(b, n.Operator(), n.LHS(), n.RHS(), depth)
case a.KChoose:
return g.writeStatementChoose(b, n.AsChoose(), depth)
case a.KIOBind:
return g.writeStatementIOBind(b, n.AsIOBind(), depth)
case a.KIOManip:
return g.writeStatementIOManip(b, n.AsIOManip(), depth)
case a.KIf:
return g.writeStatementIf(b, n.AsIf(), depth)
case a.KIterate:
@@ -277,15 +277,15 @@ func cpuArchCNames(asserts []*a.Node) (caMacro string, caName string, caAttribut
caMacro, caName, caAttribute = "ARM_NEON", "arm_neon", ""
case t.IDX86SSE42:
caMacro, caName, caAttribute =
"X86_64", "x86_sse42",
"X86_FAMILY", "x86_sse42",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")"
case t.IDX86AVX2:
caMacro, caName, caAttribute =
"X86_64", "x86_avx2",
"X86_FAMILY", "x86_avx2",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2,avx2\")"
case t.IDX86BMI2:
caMacro, caName, caAttribute =
"X86_64", "x86_bmi2",
"X86_FAMILY", "x86_bmi2",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"bmi2\")"
}
}
@@ -293,12 +293,12 @@ func cpuArchCNames(asserts []*a.Node) (caMacro string, caName string, caAttribut
return caMacro, caName, caAttribute, nil
}
func (g *gen) writeStatementIOBind(b *buffer, n *a.IOBind, depth uint32) error {
if g.currFunk.ioBinds > maxIOBinds {
func (g *gen) writeStatementIOManip(b *buffer, n *a.IOManip, depth uint32) error {
if g.currFunk.ioManips > maxIOManips {
return fmt.Errorf("too many temporary variables required")
}
ioBindNum := g.currFunk.ioBinds
g.currFunk.ioBinds++
ioBindNum := g.currFunk.ioManips
g.currFunk.ioManips++
e := n.IO()
prefix := vPrefix
@@ -343,6 +343,10 @@ func (g *gen) writeStatementIOBind(b *buffer, n *a.IOBind, depth uint32) error {
if err := g.writeExpr(b, n.Arg1(), false, 0); err != nil {
return err
}
b.writes(",\n")
if err := g.writeExpr(b, n.HistoryPosition(), false, 0); err != nil {
return err
}
b.writes(");\n")
} else {
@@ -678,6 +682,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
+2 -2
View File
@@ -64,8 +64,8 @@ func (g *gen) needDerivedVar(name t.ID) bool {
}
}
case a.KIOBind:
if p.AsIOBind().IO().IsArgsDotFoo() == name {
case a.KIOManip:
if p.AsIOManip().IO().IsArgsDotFoo() == name {
return errNeedDerivedVar
}
}
+4 -4
View File
@@ -18,7 +18,7 @@ package testcut
import (
"bytes"
"io"
"io/ioutil"
"os"
"testing"
)
@@ -29,7 +29,7 @@ func calculateDecodedLen(b []byte,
if err != nil {
return 0, err
}
n, err := io.Copy(ioutil.Discard, r)
n, err := io.Copy(io.Discard, r)
if err != nil {
r.Close()
return 0, err
@@ -48,7 +48,7 @@ func Test(tt *testing.T,
filenames []string) {
for _, filename := range filenames {
full, err := ioutil.ReadFile("../../test/data/" + filename)
full, err := os.ReadFile("../../test/data/" + filename)
if err != nil {
tt.Errorf("f=%q: ReadFile: %v", filename, err)
continue
@@ -151,7 +151,7 @@ func Benchmark(b *testing.B,
trimSuffix int,
decodedLen int64) {
full, err := ioutil.ReadFile("../../test/data/" + filename)
full, err := os.ReadFile("../../test/data/" + filename)
if err != nil {
b.Fatalf("ReadFile: %v", err)
}
+28 -20
View File
@@ -46,7 +46,7 @@ const (
KField
KFile
KFunc
KIOBind
KIOManip
KIf
KIterate
KJump
@@ -78,7 +78,7 @@ var kindStrings = [...]string{
KField: "KField",
KFile: "KFile",
KFunc: "KFunc",
KIOBind: "KIOBind",
KIOManip: "KIOManip",
KIf: "KIf",
KIterate: "KIterate",
KJump: "KJump",
@@ -169,7 +169,7 @@ type Node struct {
// Field . . name Field
// File . . . File
// Func funcName receiverPkg receiverName Func
// IOBind . . . IOBind
// IOManip keyword . . IOManip
// If . . . If
// Iterate advance label length Iterate
// Jump keyword label . Jump
@@ -208,7 +208,7 @@ func (n *Node) AsExpr() *Expr { return (*Expr)(n) }
func (n *Node) AsField() *Field { return (*Field)(n) }
func (n *Node) AsFile() *File { return (*File)(n) }
func (n *Node) AsFunc() *Func { return (*Func)(n) }
func (n *Node) AsIOBind() *IOBind { return (*IOBind)(n) }
func (n *Node) AsIOManip() *IOManip { return (*IOManip)(n) }
func (n *Node) AsIf() *If { return (*If)(n) }
func (n *Node) AsIterate() *Iterate { return (*Iterate)(n) }
func (n *Node) AsJump() *Jump { return (*Jump)(n) }
@@ -386,10 +386,15 @@ func (n *Expr) SetMBounds(x interval.IntRange) { n.mBounds = x }
func (n *Expr) SetMType(x *TypeExpr) { n.mType = x }
func (n *Expr) IsArgsDotFoo() (foo t.ID) {
if n.id0 == t.IDDot {
if (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDArgs) {
return n.id2
}
if (n.id0 == t.IDDot) && (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDArgs) {
return n.id2
}
return 0
}
func (n *Expr) IsThisDotFoo() (foo t.ID) {
if (n.id0 == t.IDDot) && (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDThis) {
return n.id2
}
return 0
}
@@ -583,26 +588,29 @@ func NewField(flags Flags, name t.ID, xType *TypeExpr) *Field {
}
}
// IOBind is "io_bind (io:LHS, data:MHS) { List2 }" or "io_limit (io:LHS,
// limit:MHS) { List2 }":
// IOManip is "io_bind (io:LHS, data:MHS, history_position:RHS) { List2 }" or
// "io_limit (io:LHS, limit:MHS) { List2 }":
// - ID0: <IDIOBind|IDIOLimit>
// - LHS: <Expr>
// - MHS: <Expr>
// - RHS: <Expr>
// - List2: <Statement> body
type IOBind Node
type IOManip Node
func (n *IOBind) AsNode() *Node { return (*Node)(n) }
func (n *IOBind) Keyword() t.ID { return n.id0 }
func (n *IOBind) IO() *Expr { return n.lhs.AsExpr() }
func (n *IOBind) Arg1() *Expr { return n.mhs.AsExpr() }
func (n *IOBind) Body() []*Node { return n.list2 }
func (n *IOManip) AsNode() *Node { return (*Node)(n) }
func (n *IOManip) Keyword() t.ID { return n.id0 }
func (n *IOManip) IO() *Expr { return n.lhs.AsExpr() }
func (n *IOManip) Arg1() *Expr { return n.mhs.AsExpr() }
func (n *IOManip) HistoryPosition() *Expr { return n.rhs.AsExpr() }
func (n *IOManip) Body() []*Node { return n.list2 }
func NewIOBind(keyword t.ID, io *Expr, arg1 *Expr, body []*Node) *IOBind {
return &IOBind{
kind: KIOBind,
func NewIOManip(keyword t.ID, io *Expr, arg1 *Expr, historyPosition *Expr, body []*Node) *IOManip {
return &IOManip{
kind: KIOManip,
id0: keyword,
lhs: io.AsNode(),
mhs: arg1.AsNode(),
rhs: historyPosition.AsNode(),
list2: body,
}
}
@@ -1149,7 +1157,7 @@ func NewFile(filename string, topLevelDecls []*Node) *File {
// - Assert
// - Assign
// - Choose
// - IOBind
// - IOManip
// - If
// - Iterate
// - Jump
+30 -1
View File
@@ -28,13 +28,17 @@ import (
)
var FourCCs = [...][2]string{
{"BGCL", "Background Color"},
{"BMP ", "Bitmap"},
{"BRTL", "Brotli"},
{"BZ2 ", "Bzip2"},
{"CBOR", "Concise Binary Object Representation"},
{"CHRM", "Primary Chromaticities and White Point"},
{"CSS ", "Cascading Style Sheets"},
{"EPS ", "Encapsulated PostScript"},
{"EXIF", "Exchangeable Image File Format"},
{"FLAC", "Free Lossless Audio Codec"},
{"GAMA", "Gamma Correction"},
{"GIF ", "Graphics Interchange Format"},
{"GZ ", "GNU Zip"},
{"HEIF", "High Efficiency Image File"},
@@ -47,12 +51,18 @@ var FourCCs = [...][2]string{
{"JS ", "JavaScript"},
{"JSON", "JavaScript Object Notation"},
{"JWCC", "JSON With Commas and Comments"},
{"KVP ", "Key-Value Pair"},
{"KVPK", "Key-Value Pair (Key)"},
{"KVPV", "Key-Value Pair (Value)"},
{"LZ4 ", "Lempel–Ziv 4"},
{"MD ", "Markdown"},
{"MTIM", "Modification Time"},
{"MP3 ", "MPEG-1 Audio Layer III"},
{"NIE ", "Naive Image"},
{"OFS2", "Offset (2-Dimensional)"},
{"OTF ", "Open Type Format"},
{"PDF ", "Portable Document Format"},
{"PHYD", "Physical Dimensions"},
{"PNG ", "Portable Network Graphics"},
{"PNM ", "Portable Anymap"},
{"PS ", "PostScript"},
@@ -61,8 +71,10 @@ var FourCCs = [...][2]string{
{"RIFF", "Resource Interchange File Format"},
{"RIGL", "Riegeli Records"},
{"SNPY", "Snappy"},
{"SRGB", "Standard Red Green Blue (Rendering Intent)"},
{"SVG ", "Scalable Vector Graphics"},
{"TAR ", "Tape Archive"},
{"TEXT", "Text"},
{"TIFF", "Tagged Image File Format"},
{"TOML", "Tom's Obvious Minimal Language"},
{"WAVE", "Waveform"},
@@ -85,6 +97,20 @@ var Consts = [...]struct {
}{
// ----
{t.IDU8, "0", "ANIMATION_DISPOSAL__NONE"},
{t.IDU8, "1", "ANIMATION_DISPOSAL__RESTORE_BACKGROUND"},
{t.IDU8, "2", "ANIMATION_DISPOSAL__RESTORE_PREVIOUS"},
// ----
{t.IDU32, "1", "MORE_INFORMATION__FLAVOR__IO_REDIRECT"},
{t.IDU32, "2", "MORE_INFORMATION__FLAVOR__IO_SEEK"},
{t.IDU32, "3", "MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH"},
{t.IDU32, "4", "MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM"},
{t.IDU32, "5", "MORE_INFORMATION__FLAVOR__METADATA_PARSED"},
// ----
{t.IDU32, "0x02000008", "PIXEL_FORMAT__A"},
{t.IDU32, "0x20000008", "PIXEL_FORMAT__Y"},
@@ -528,6 +554,7 @@ var funcsOther = [...]string{
"io_writer.count_since(mark: u64) u64",
"io_writer.history_length() u64",
"io_writer.history_position() u64",
"io_writer.length() u64",
"io_writer.mark() u64",
"io_writer.position() u64",
@@ -939,7 +966,9 @@ var TableFuncs = []string{
"GENERIC T2.stride() u64",
"GENERIC T2.width() u64",
"GENERIC T2.row(y: u32) T1",
"GENERIC T2.row_u32(y: u32) T1",
"GENERIC T2.subtable(" +
"min_incl_x: u64, min_incl_y: u64, max_incl_x: u64, max_incl_y: u64) T2",
}
func ParseFuncs(tm *t.Map, ss []string, callback func(*a.Func) error) error {
+2 -2
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -24,7 +25,6 @@ import (
"bytes"
"fmt"
"go/format"
"io/ioutil"
"os"
"strings"
@@ -63,7 +63,7 @@ func main1() error {
if err != nil {
return err
}
return ioutil.WriteFile("data.go", formatted, 0644)
return os.WriteFile("data.go", formatted, 0644)
}
var (
+7 -2
View File
@@ -250,14 +250,19 @@ func (q *checker) bcheckStatement(n *a.Node) error {
case a.KChoose:
// No-op.
case a.KIOBind:
n := n.AsIOBind()
case a.KIOManip:
n := n.AsIOManip()
if _, err := q.bcheckExpr(n.IO(), 0); err != nil {
return err
}
if _, err := q.bcheckExpr(n.Arg1(), 0); err != nil {
return err
}
if histPos := n.HistoryPosition(); histPos != nil {
if _, err := q.bcheckExpr(histPos, 0); err != nil {
return err
}
}
if err := q.bcheckBlock(n.Body()); err != nil {
return err
}
+4
View File
@@ -135,6 +135,10 @@ func Check(tm *t.Map, files []*a.File, resolveUse func(usePath string) ([]byte,
}
xType := (*a.TypeExpr)(nil)
switch z.Type {
case t.IDU8:
xType = typeExprU8
case t.IDU16:
xType = typeExprU16
case t.IDU32:
xType = typeExprU32
case t.IDU64:
+3 -3
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -24,7 +25,6 @@ import (
"bytes"
"fmt"
"go/format"
"io/ioutil"
"os"
"sort"
"strings"
@@ -56,11 +56,11 @@ func main1() error {
if err != nil {
return err
}
return ioutil.WriteFile("data.go", formatted, 0644)
return os.WriteFile("data.go", formatted, 0644)
}
func loadReasons() ([]string, error) {
s, err := ioutil.ReadFile("axioms.md")
s, err := os.ReadFile("axioms.md")
if err != nil {
return nil, err
}
+12 -2
View File
@@ -149,8 +149,8 @@ func (q *checker) tcheckStatement(n *a.Node) error {
}
return nil
case a.KIOBind:
n := n.AsIOBind()
case a.KIOManip:
n := n.AsIOManip()
if err := q.tcheckExpr(n.IO(), 0); err != nil {
return err
}
@@ -171,6 +171,16 @@ func (q *checker) tcheckStatement(n *a.Node) error {
n.Keyword().Str(q.tm), n.Arg1().Str(q.tm), typ.Str(q.tm), arg1Typ.Str(q.tm))
}
if n.Keyword() == t.IDIOBind {
if err := q.tcheckExpr(n.HistoryPosition(), 0); err != nil {
return err
}
if typ := n.HistoryPosition().MType(); !typ.IsIdeal() && !typ.EqIgnoringRefinements(typeExprU64) {
return fmt.Errorf("check: %s expression %q, of type %q, does not have type %q",
n.Keyword().Str(q.tm), n.HistoryPosition().Str(q.tm), typ.Str(q.tm), typeExprU64.Str(q.tm))
}
}
for _, o := range n.Body() {
// TODO: prohibit jumps (breaks, continues), rets (returns, yields)
// and retry-calling ? methods while inside an io_bind body.
+4 -4
View File
@@ -17,7 +17,7 @@ package generate
import (
"flag"
"fmt"
"io/ioutil"
"io"
"os"
"path/filepath"
"strings"
@@ -98,7 +98,7 @@ func checkPackageName(s string) string {
func parseFiles(tm *t.Map, filenames []string) (files []*a.File, err error) {
if len(filenames) == 0 {
const filename = "stdin"
src, err := ioutil.ReadAll(os.Stdin)
src, err := io.ReadAll(os.Stdin)
if err != nil {
return nil, err
}
@@ -117,7 +117,7 @@ func parseFiles(tm *t.Map, filenames []string) (files []*a.File, err error) {
func ParseFiles(tm *t.Map, filenames []string, opts *parse.Options) (files []*a.File, err error) {
for _, filename := range filenames {
src, err := ioutil.ReadFile(filename)
src, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
@@ -139,5 +139,5 @@ func resolveUse(usePath string) ([]byte, error) {
if err != nil {
return nil, err
}
return ioutil.ReadFile(filepath.Join(wuffsRoot, "gen", "wuffs", filepath.FromSlash(usePath)))
return os.ReadFile(filepath.Join(wuffsRoot, "gen", "wuffs", filepath.FromSlash(usePath)))
}
+33 -19
View File
@@ -861,7 +861,7 @@ func (p *parser) parseStatement1() (*a.Node, error) {
return a.NewChoose(name, args).AsNode(), nil
case t.IDIOBind, t.IDIOLimit:
return p.parseIOBindNode()
return p.parseIOManipNode()
case t.IDIf:
o, err := p.parseIf()
@@ -1050,7 +1050,7 @@ func (p *parser) parseAsserts() ([]*a.Node, error) {
return asserts, nil
}
func (p *parser) parseIOBindNode() (*a.Node, error) {
func (p *parser) parseIOManipNode() (*a.Node, error) {
keyword := p.peek1()
p.src = p.src[1:]
@@ -1123,6 +1123,36 @@ func (p *parser) parseIOBindNode() (*a.Node, error) {
io.Str(p.tm), p.filename, p.line())
}
histPos := (*a.Expr)(nil)
if keyword == t.IDIOBind {
if x := p.peek1(); x != t.IDComma {
got := p.tm.ByID(x)
return nil, fmt.Errorf(`parse: expected ",", got %q at %s:%d`, got, p.filename, p.line())
}
p.src = p.src[1:]
if x := p.peek1(); x != t.IDHistoryPosition {
got := p.tm.ByID(x)
return nil, fmt.Errorf(`parse: expected "history_position", got %q at %s:%d`, got, p.filename, p.line())
}
p.src = p.src[1:]
if x := p.peek1(); x != t.IDColon {
got := p.tm.ByID(x)
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
}
p.src = p.src[1:]
histPos, err = p.parseExpr()
if err != nil {
return nil, err
}
if histPos.Effect() != 0 {
return nil, fmt.Errorf(`parse: argument %q is not effect-free at %s:%d`,
io.Str(p.tm), p.filename, p.line())
}
}
if x := p.peek1(); x != t.IDCloseParen {
got := p.tm.ByID(x)
return nil, fmt.Errorf(`parse: expected ")", got %q at %s:%d`, got, p.filename, p.line())
@@ -1134,7 +1164,7 @@ func (p *parser) parseIOBindNode() (*a.Node, error) {
return nil, err
}
return a.NewIOBind(keyword, io, arg1, body).AsNode(), nil
return a.NewIOManip(keyword, io, arg1, histPos, body).AsNode(), nil
}
func (p *parser) parseIf() (*a.If, error) {
@@ -1354,22 +1384,6 @@ func (p *parser) parseArgNode() (*a.Node, error) {
return a.NewArg(name, value).AsNode(), nil
}
func (p *parser) parseIOBindExprNode() (*a.Node, error) {
e, err := p.parseExpr()
if err != nil {
return nil, err
}
switch e.Operator() {
case 0:
return e.AsNode(), nil
case t.IDDot:
if lhs := e.LHS().AsExpr(); lhs.Operator() == 0 && lhs.Ident() == t.IDArgs {
return e.AsNode(), nil
}
}
return nil, fmt.Errorf(`parse: expected "args.something", got %q at %s:%d`, e.Str(p.tm), p.filename, p.line())
}
func (p *parser) parseVarNode() (*a.Node, error) {
id, err := p.parseIdent()
if err != nil {
+38 -32
View File
@@ -490,19 +490,20 @@ const (
IDDecodeFrameOptions = ID(0x158)
IDCanUndoByte = ID(0x160)
IDCountSince = ID(0x161)
IDHistoryLength = ID(0x162)
IDIsClosed = ID(0x163)
IDMark = ID(0x164)
IDMatch15 = ID(0x165)
IDMatch31 = ID(0x166)
IDMatch7 = ID(0x167)
IDPosition = ID(0x168)
IDSince = ID(0x169)
IDSkip = ID(0x16A)
IDSkipU32 = ID(0x16B)
IDSkipU32Fast = ID(0x16C)
IDCanUndoByte = ID(0x160)
IDCountSince = ID(0x161)
IDHistoryLength = ID(0x162)
IDHistoryPosition = ID(0x163)
IDIsClosed = ID(0x164)
IDMark = ID(0x165)
IDMatch15 = ID(0x166)
IDMatch31 = ID(0x167)
IDMatch7 = ID(0x168)
IDPosition = ID(0x169)
IDSince = ID(0x16A)
IDSkip = ID(0x16B)
IDSkipU32 = ID(0x16C)
IDSkipU32Fast = ID(0x16D)
IDCopyFromSlice = ID(0x170)
IDLimitedCopyU32FromHistory = ID(0x171)
@@ -667,12 +668,14 @@ const (
IDIO = ID(0x242)
IDLimit = ID(0x243)
IDPrefix = ID(0x244)
IDRow = ID(0x245)
IDRowU32 = ID(0x245)
IDStride = ID(0x246)
IDSuffix = ID(0x247)
IDUintptrLow12Bits = ID(0x248)
IDValidUTF8Length = ID(0x249)
IDWidth = ID(0x24A)
IDSubslice = ID(0x247)
IDSubtable = ID(0x248)
IDSuffix = ID(0x249)
IDUintptrLow12Bits = ID(0x24A)
IDValidUTF8Length = ID(0x24B)
IDWidth = ID(0x24C)
IDLimitedSwizzleU32InterleavedFromReader = ID(0x280)
IDSwizzleInterleavedFromReader = ID(0x281)
@@ -917,19 +920,20 @@ var builtInsByID = [nBuiltInIDs]string{
IDDecodeFrameOptions: "decode_frame_options",
IDCanUndoByte: "can_undo_byte",
IDCountSince: "count_since",
IDHistoryLength: "history_length",
IDIsClosed: "is_closed",
IDMark: "mark",
IDMatch15: "match15",
IDMatch31: "match31",
IDMatch7: "match7",
IDPosition: "position",
IDSince: "since",
IDSkip: "skip",
IDSkipU32: "skip_u32",
IDSkipU32Fast: "skip_u32_fast",
IDCanUndoByte: "can_undo_byte",
IDCountSince: "count_since",
IDHistoryLength: "history_length",
IDHistoryPosition: "history_position",
IDIsClosed: "is_closed",
IDMark: "mark",
IDMatch15: "match15",
IDMatch31: "match31",
IDMatch7: "match7",
IDPosition: "position",
IDSince: "since",
IDSkip: "skip",
IDSkipU32: "skip_u32",
IDSkipU32Fast: "skip_u32_fast",
IDCopyFromSlice: "copy_from_slice",
IDLimitedCopyU32FromHistory: "limited_copy_u32_from_history",
@@ -1090,8 +1094,10 @@ var builtInsByID = [nBuiltInIDs]string{
IDIO: "io",
IDLimit: "limit",
IDPrefix: "prefix",
IDRow: "row",
IDRowU32: "row_u32",
IDStride: "stride",
IDSubslice: "subslice",
IDSubtable: "subtable",
IDSuffix: "suffix",
IDUintptrLow12Bits: "uintptr_low_12_bits",
IDValidUTF8Length: "valid_utf_8_length",
+2 -2
View File
@@ -14,6 +14,7 @@
// ----------------
//go:build ignore
// +build ignore
package main
@@ -24,7 +25,6 @@ import (
"flag"
"fmt"
"io"
"io/ioutil"
"net/http"
"os"
"sort"
@@ -151,7 +151,7 @@ func main1() error {
fmt.Fprintf(w, "// %4d entries have %2d%s probes\n", x, i, plus)
}
return ioutil.WriteFile("data.go", w.Bytes(), 0644)
return os.WriteFile("data.go", w.Bytes(), 0644)
}
func build() error {
+2 -2
View File
@@ -16,7 +16,7 @@ package cgolz4
import (
"bytes"
"io/ioutil"
"io"
"strings"
"testing"
)
@@ -74,7 +74,7 @@ func TestRoundTrip(tt *testing.T) {
// Uncompress.
{
r.Reset(strings.NewReader(compressed), nil)
gotBytes, err := ioutil.ReadAll(r)
gotBytes, err := io.ReadAll(r)
if err != nil {
r.Close()
tt.Fatalf("i=%d: ReadAll: %v", i, err)
+1
View File
@@ -14,6 +14,7 @@
// ----------------
//go:build !cgo
// +build !cgo
package cgolz4
+4 -4
View File
@@ -18,7 +18,7 @@ import (
"bytes"
"compress/zlib"
"io"
"io/ioutil"
"os"
"strings"
"testing"
)
@@ -57,7 +57,7 @@ func testReadAll(tt *testing.T, r resetReadCloser, src io.Reader, dict []byte, w
tt.Fatalf("Reset: %v", err)
}
got, err := ioutil.ReadAll(r)
got, err := io.ReadAll(r)
if err != nil {
tt.Fatalf("ReadAll: %v", err)
}
@@ -87,7 +87,7 @@ func benchmarkReader(b *testing.B, r resetReadCloser) {
}
src := bytes.NewReader(nil)
srcBytes, err := ioutil.ReadFile("../../test/data/pi.txt.zlib")
srcBytes, err := os.ReadFile("../../test/data/pi.txt.zlib")
if err != nil {
b.Fatalf("ReadFile: %v", err)
}
@@ -100,7 +100,7 @@ func benchmarkReader(b *testing.B, r resetReadCloser) {
b.Fatalf("Reset: %v", err)
}
if n, err := io.Copy(ioutil.Discard, r); err != nil {
if n, err := io.Copy(io.Discard, r); err != nil {
b.Fatalf("Copy: %v", err)
} else if n != 100003 {
b.Fatalf("Copy: got %d, want %d", n, 100003)
+1
View File
@@ -14,6 +14,7 @@
// ----------------
//go:build !cgo
// +build !cgo
package cgozlib
+3 -3
View File
@@ -16,7 +16,7 @@ package cgozstd
import (
"bytes"
"io/ioutil"
"io"
"strings"
"testing"
)
@@ -87,7 +87,7 @@ func TestRoundTrip(tt *testing.T) {
r.Close()
tt.Fatalf("i=%d: Reset: %v", i, err)
}
gotBytes, err := ioutil.ReadAll(r)
gotBytes, err := io.ReadAll(r)
if err != nil {
r.Close()
tt.Fatalf("i=%d: ReadAll: %v", i, err)
@@ -149,7 +149,7 @@ func TestDictionary(tt *testing.T) {
r.Close()
tt.Fatalf("%s: Reset: %v", name, err)
}
gotBytes, err := ioutil.ReadAll(r)
gotBytes, err := io.ReadAll(r)
if err != nil {
r.Close()
tt.Fatalf("%s: ReadAll: %v", name, err)
+1
View File
@@ -14,6 +14,7 @@
// ----------------
//go:build !cgo
// +build !cgo
package cgozstd
+3 -4
View File
@@ -18,7 +18,6 @@ import (
"bytes"
"compress/flate"
"io"
"io/ioutil"
"testing"
"github.com/google/wuffs/internal/testcut"
@@ -26,8 +25,8 @@ import (
func TestCut(tt *testing.T) {
testcut.Test(tt, SmallestValidMaxEncodedLen, Cut, newReader, []string{
"artificial/deflate-backref-crosses-blocks.deflate",
"artificial/deflate-distance-32768.deflate",
"artificial-deflate/backref-crosses-blocks.deflate",
"artificial-deflate/distance-32768.deflate",
"romeo.txt.deflate",
"romeo.txt.fixed-huff.deflate",
})
@@ -43,7 +42,7 @@ func newReader(r io.Reader) (io.ReadCloser, error) {
}
func decodeFlate(src []byte) string {
dst, err := ioutil.ReadAll(flate.NewReader(bytes.NewReader(src)))
dst, err := io.ReadAll(flate.NewReader(bytes.NewReader(src)))
if err != nil {
return err.Error()
}
+3 -4
View File
@@ -20,7 +20,6 @@ import (
"fmt"
"hash/crc32"
"io"
"io/ioutil"
"math/rand"
"os"
"strings"
@@ -165,7 +164,7 @@ func TestWriterILAStartMemTempFile(tt *testing.T) {
}
func TestWriterILAStartRealTempFile(tt *testing.T) {
f, err := ioutil.TempFile("", "rac_test")
f, err := os.CreateTemp("", "rac_test")
if err != nil {
tt.Fatalf("TempFile: %v", err)
}
@@ -560,7 +559,7 @@ func TestReaderEmpty(tt *testing.T) {
CompressedSize: int64(len(encoded)),
}
defer r.Close()
got, err := ioutil.ReadAll(r)
got, err := io.ReadAll(r)
if err != nil {
tt.Fatalf("ReadAll: %v", err)
}
@@ -587,7 +586,7 @@ func TestReaderZeroes(tt *testing.T) {
CompressedSize: int64(len(encoded)),
}
defer r.Close()
got, err := ioutil.ReadAll(r)
got, err := io.ReadAll(r)
if err != nil {
tt.Fatalf("ReadAll: %v", err)
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build cgo
// +build cgo
package raczlib
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build !cgo
// +build !cgo
package raczlib
+2 -2
View File
@@ -18,7 +18,7 @@ import (
"bytes"
"compress/zlib"
"fmt"
"io/ioutil"
"io"
"log"
"strings"
@@ -83,7 +83,7 @@ func ExampleCut() {
if err != nil {
log.Fatalf("NewReader: %v", err)
}
uncompressed, err := ioutil.ReadAll(r)
uncompressed, err := io.ReadAll(r)
if err != nil {
log.Fatalf("ReadAll: %v", err)
}
+4068 -724
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.
@@ -40,13 +54,14 @@
#include <stdlib.h>
#include <string.h>
// Note that Clang also defines __GNUC__.
#ifdef __cplusplus
#if (__cplusplus >= 201103L) || defined(_MSC_VER)
#include <memory>
#define WUFFS_BASE__HAVE_EQ_DELETE
#define WUFFS_BASE__HAVE_UNIQUE_PTR
#elif defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#elif defined(__GNUC__) || defined(__clang__)
#warning "Wuffs' C++ code expects -std=c++11 or later"
#endif
@@ -74,7 +89,7 @@ extern "C" {
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 0
#define WUFFS_VERSION_PATCH 0
#define WUFFS_VERSION_PRE_RELEASE_LABEL "work.in.progress"
#define WUFFS_VERSION_PRE_RELEASE_LABEL "unsupported.snapshot"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0
#define WUFFS_VERSION_STRING "0.0.0+0.00000000"
@@ -117,15 +132,18 @@ extern "C" {
// POPCNT. This is checked at runtime via cpuid, not at compile time.
//
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
#if defined(__x86_64__) && !defined(__native_client__)
#if defined(__i386__) || defined(__x86_64__)
#if !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__) && !defined(__native_client__)
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#endif // !defined(__native_client__)
#endif // defined(__i386__) || defined(__x86_64__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_X64)
#if defined(_M_IX86) || defined(_M_X64)
#if defined(__AVX__) || defined(__clang__)
// We need <intrin.h> for the __cpuid function.
@@ -139,7 +157,8 @@ extern "C" {
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL
#define WUFFS_BASE__CPU_ARCH__X86_64
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#else // defined(__AVX__) || defined(__clang__)
@@ -149,19 +168,22 @@ extern "C" {
// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time
// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#pragma message("Wuffs with MSVC+X64 needs /arch:AVX for best performance")
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
#endif // defined(__AVX__) || defined(__clang__)
#endif // defined(_M_X64)
#endif // defined(_M_IX86) || defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
// --------
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
// static storage. The motivation is discussed in the "ALLOW STATIC
// IMPLEMENTATION" section of
// Define WUFFS_CONFIG__STATIC_FUNCTIONS (combined with WUFFS_IMPLEMENTATION)
// to make all of Wuffs' functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)
#define WUFFS_BASE__MAYBE_STATIC static
@@ -191,7 +213,7 @@ wuffs_base__cpu_arch__have_arm_neon() {
static inline bool //
wuffs_base__cpu_arch__have_x86_avx2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
@@ -231,13 +253,13 @@ wuffs_base__cpu_arch__have_x86_avx2() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_bmi2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
@@ -261,13 +283,13 @@ wuffs_base__cpu_arch__have_x86_bmi2() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_sse42() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
@@ -293,7 +315,7 @@ wuffs_base__cpu_arch__have_x86_sse42() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
@@ -308,8 +330,9 @@ wuffs_base__cpu_arch__have_x86_sse42() {
#endif
#endif
// Clang also defines "__GNUC__".
#if defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__) || defined(__clang__)
#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))
#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))
#else
@@ -537,7 +560,20 @@ typedef struct wuffs_base__transform__output__struct {
// --------
// FourCC constants.
// FourCC constants. Four Character Codes are literally four ASCII characters
// (sometimes padded with ' ' spaces) that pack neatly into a signed or
// unsigned 32-bit integer. ASCII letters are conventionally upper case.
//
// They are often used to identify video codecs (e.g. "H265") and pixel formats
// (e.g. "YV12"). Wuffs uses them for that but also generally for naming
// various things: compression formats (e.g. "BZ2 "), image metadata (e.g.
// "EXIF"), file formats (e.g. "HTML"), etc.
//
// Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to
// preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320.
// Background Color.
#define WUFFS_BASE__FOURCC__BGCL 0x4247434C
// Bitmap.
#define WUFFS_BASE__FOURCC__BMP 0x424D5020
@@ -551,15 +587,24 @@ typedef struct wuffs_base__transform__output__struct {
// Concise Binary Object Representation.
#define WUFFS_BASE__FOURCC__CBOR 0x43424F52
// Primary Chromaticities and White Point.
#define WUFFS_BASE__FOURCC__CHRM 0x4348524D
// Cascading Style Sheets.
#define WUFFS_BASE__FOURCC__CSS 0x43535320
// Encapsulated PostScript.
#define WUFFS_BASE__FOURCC__EPS 0x45505320
// Exchangeable Image File Format.
#define WUFFS_BASE__FOURCC__EXIF 0x45584946
// Free Lossless Audio Codec.
#define WUFFS_BASE__FOURCC__FLAC 0x464C4143
// Gamma Correction.
#define WUFFS_BASE__FOURCC__GAMA 0x47414D41
// Graphics Interchange Format.
#define WUFFS_BASE__FOURCC__GIF 0x47494620
@@ -596,24 +641,42 @@ typedef struct wuffs_base__transform__output__struct {
// JSON With Commas and Comments.
#define WUFFS_BASE__FOURCC__JWCC 0x4A574343
// Key-Value Pair.
#define WUFFS_BASE__FOURCC__KVP 0x4B565020
// Key-Value Pair (Key).
#define WUFFS_BASE__FOURCC__KVPK 0x4B56504B
// Key-Value Pair (Value).
#define WUFFS_BASE__FOURCC__KVPV 0x4B565056
// Lempel–Ziv 4.
#define WUFFS_BASE__FOURCC__LZ4 0x4C5A3420
// Markdown.
#define WUFFS_BASE__FOURCC__MD 0x4D442020
// Modification Time.
#define WUFFS_BASE__FOURCC__MTIM 0x4D54494D
// MPEG-1 Audio Layer III.
#define WUFFS_BASE__FOURCC__MP3 0x4D503320
// Naive Image.
#define WUFFS_BASE__FOURCC__NIE 0x4E494520
// Offset (2-Dimensional).
#define WUFFS_BASE__FOURCC__OFS2 0x4F465332
// Open Type Format.
#define WUFFS_BASE__FOURCC__OTF 0x4F544620
// Portable Document Format.
#define WUFFS_BASE__FOURCC__PDF 0x50444620
// Physical Dimensions.
#define WUFFS_BASE__FOURCC__PHYD 0x50485944
// Portable Network Graphics.
#define WUFFS_BASE__FOURCC__PNG 0x504E4720
@@ -638,12 +701,18 @@ typedef struct wuffs_base__transform__output__struct {
// Snappy.
#define WUFFS_BASE__FOURCC__SNPY 0x534E5059
// Standard Red Green Blue (Rendering Intent).
#define WUFFS_BASE__FOURCC__SRGB 0x53524742
// Scalable Vector Graphics.
#define WUFFS_BASE__FOURCC__SVG 0x53564720
// Tape Archive.
#define WUFFS_BASE__FOURCC__TAR 0x54415220
// Text.
#define WUFFS_BASE__FOURCC__TEXT 0x54455854
// Tagged Image File Format.
#define WUFFS_BASE__FOURCC__TIFF 0x54494646
@@ -792,6 +861,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/
//
@@ -892,7 +1011,9 @@ wuffs_base__multiply_u64(uint64_t x, uint64_t y) {
// --------
#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
static inline uint32_t //
wuffs_base__count_leading_zeroes_u64(uint64_t u) {
@@ -936,7 +1057,7 @@ wuffs_base__count_leading_zeroes_u64(uint64_t u) {
return n;
}
#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
#endif // (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
// --------
@@ -1500,6 +1621,25 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
return wuffs_base__make_slice_u8(NULL, 0);
}
// wuffs_base__table_u8__subtable_ij returns t[ix:jx, iy:jy].
//
// It returns an empty table if i or j is out of bounds.
static inline wuffs_base__table_u8 //
wuffs_base__table_u8__subtable_ij(wuffs_base__table_u8 t,
uint64_t ix,
uint64_t iy,
uint64_t jx,
uint64_t jy) {
if ((ix <= jx) && (jx <= SIZE_MAX) && (jx <= t.width) && //
(iy <= jy) && (jy <= SIZE_MAX) && (jy <= t.height)) {
return wuffs_base__make_table_u8(t.ptr + ix + (iy * t.stride), //
((size_t)(jx - ix)), //
((size_t)(jy - iy)), //
t.stride); //
}
return wuffs_base__make_table_u8(NULL, 0, 0, 0);
}
// wuffs_base__table__flattened_length returns the number of elements covered
// by the 1-dimensional span that backs a 2-dimensional table. This counts the
// elements inside the table and, when width != stride, the elements outside
@@ -2382,14 +2522,24 @@ typedef struct wuffs_base__more_information__struct {
inline wuffs_base__range_ie_u64 io_redirect__range() const;
inline uint64_t io_seek__position() const;
inline uint32_t metadata__fourcc() const;
// Deprecated: use metadata_raw_passthrough__range.
inline wuffs_base__range_ie_u64 metadata__range() const;
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
inline int32_t metadata_parsed__chrm(uint32_t component) const;
inline uint32_t metadata_parsed__gama() const;
inline uint32_t metadata_parsed__srgb() const;
#endif // __cplusplus
} wuffs_base__more_information;
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT 1
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2
// Deprecated: use
// WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH.
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH 3
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM 4
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED 5
static inline wuffs_base__more_information //
wuffs_base__empty_more_information() {
@@ -2446,6 +2596,8 @@ wuffs_base__more_information__metadata__fourcc(
return m->w;
}
// Deprecated: use
// wuffs_base__more_information__metadata_raw_passthrough__range.
static inline wuffs_base__range_ie_u64 //
wuffs_base__more_information__metadata__range(
const wuffs_base__more_information* m) {
@@ -2455,6 +2607,103 @@ wuffs_base__more_information__metadata__range(
return ret;
}
static inline wuffs_base__range_ie_u64 //
wuffs_base__more_information__metadata_raw_passthrough__range(
const wuffs_base__more_information* m) {
wuffs_base__range_ie_u64 ret;
ret.min_incl = m->y;
ret.max_excl = m->z;
return ret;
}
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_X 0
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_Y 1
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_X 2
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_Y 3
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_X 4
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_Y 5
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_X 6
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_Y 7
// wuffs_base__more_information__metadata_parsed__chrm returns chromaticity
// values (scaled by 100000) like the PNG "cHRM" chunk. For example, the sRGB
// color space corresponds to:
// - ETC__CHRM__WHITE_X 31270
// - ETC__CHRM__WHITE_Y 32900
// - ETC__CHRM__RED_X 64000
// - ETC__CHRM__RED_Y 33000
// - ETC__CHRM__GREEN_X 30000
// - ETC__CHRM__GREEN_Y 60000
// - ETC__CHRM__BLUE_X 15000
// - ETC__CHRM__BLUE_Y 6000
//
// See
// https://ciechanow.ski/color-spaces/#chromaticity-and-white-point-coordinates
static inline int32_t //
wuffs_base__more_information__metadata_parsed__chrm(
const wuffs_base__more_information* m,
uint32_t component) {
// After the flavor and the w field (holding a FourCC), a
// wuffs_base__more_information holds 24 bytes of data in three uint64_t
// typed fields (x, y and z). We pack the eight chromaticity values (wx, wy,
// rx, ..., by), basically int24_t values, into 24 bytes like this:
// - LSB MSB
// - x: wx wx wx wy wy wy rx rx
// - y: rx ry ry ry gx gx gx gy
// - z: gy gy bx bx bx by by by
uint32_t u = 0;
switch (component & 7) {
case 0:
u = ((uint32_t)(m->x >> 0));
break;
case 1:
u = ((uint32_t)(m->x >> 24));
break;
case 2:
u = ((uint32_t)((m->x >> 48) | (m->y << 16)));
break;
case 3:
u = ((uint32_t)(m->y >> 8));
break;
case 4:
u = ((uint32_t)(m->y >> 32));
break;
case 5:
u = ((uint32_t)((m->y >> 56) | (m->z << 8)));
break;
case 6:
u = ((uint32_t)(m->z >> 16));
break;
case 7:
u = ((uint32_t)(m->z >> 40));
break;
}
// The left-right shifts sign-extend from 24-bit to 32-bit integers.
return ((int32_t)(u << 8)) >> 8;
}
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
static inline uint32_t //
wuffs_base__more_information__metadata_parsed__gama(
const wuffs_base__more_information* m) {
return ((uint32_t)(m->x));
}
#define WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL 0
#define WUFFS_BASE__SRGB_RENDERING_INTENT__RELATIVE_COLORIMETRIC 1
#define WUFFS_BASE__SRGB_RENDERING_INTENT__SATURATION 2
#define WUFFS_BASE__SRGB_RENDERING_INTENT__ABSOLUTE_COLORIMETRIC 3
// wuffs_base__more_information__metadata_parsed__srgb returns the sRGB
// rendering intent like the PNG "sRGB" chunk.
static inline uint32_t //
wuffs_base__more_information__metadata_parsed__srgb(
const wuffs_base__more_information* m) {
return m->x & 3;
}
#ifdef __cplusplus
inline void //
@@ -2492,6 +2741,26 @@ wuffs_base__more_information::metadata__range() const {
return wuffs_base__more_information__metadata__range(this);
}
inline wuffs_base__range_ie_u64 //
wuffs_base__more_information::metadata_raw_passthrough__range() const {
return wuffs_base__more_information__metadata_raw_passthrough__range(this);
}
inline int32_t //
wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__gama() const {
return wuffs_base__more_information__metadata_parsed__gama(this);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__srgb() const {
return wuffs_base__more_information__metadata_parsed__srgb(this);
}
#endif // __cplusplus
// ---------------- I/O
@@ -4998,9 +5267,9 @@ wuffs_base__pixel_swizzler::swizzle_interleaved_from_slice(
// wuffs_base__ieee_754_bit_representation__etc converts between a double
// precision numerical value and its IEEE 754 representations:
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
//
// For example, it converts between:
// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.
@@ -7039,6 +7308,7 @@ struct wuffs_deflate__decoder__struct {
uint32_t f_bits;
uint32_t f_n_bits;
uint64_t f_transformed_history_count;
uint32_t f_history_index;
uint32_t f_n_huffs_bits[2];
bool f_end_of_block;
@@ -7611,8 +7881,8 @@ struct wuffs_gif__decoder__struct {
bool f_previous_lzw_decode_ended_abruptly;
bool f_has_global_palette;
uint8_t f_interlace;
bool f_seen_num_loops;
uint32_t f_num_loops;
bool f_seen_num_animation_loops_value;
uint32_t f_num_animation_loops_value;
uint32_t f_background_color_u32_argb_premul;
uint32_t f_black_color_u32_argb_premul;
bool f_gc_has_transparent_index;
@@ -8890,17 +9160,22 @@ struct wuffs_zlib__decoder__struct {
// ---------------- Status Codes
extern const char wuffs_png__error__bad_animation_sequence_number[];
extern const char wuffs_png__error__bad_checksum[];
extern const char wuffs_png__error__bad_chunk[];
extern const char wuffs_png__error__bad_filter[];
extern const char wuffs_png__error__bad_header[];
extern const char wuffs_png__error__bad_text_chunk_not_latin_1[];
extern const char wuffs_png__error__missing_palette[];
extern const char wuffs_png__error__unsupported_png_compression_method[];
extern const char wuffs_png__error__unsupported_png_file[];
// ---------------- Public Consts
#define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0
#define WUFFS_PNG__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 8
// ---------------- Struct Declarations
typedef struct wuffs_png__decoder__struct wuffs_png__decoder;
@@ -9050,22 +9325,66 @@ struct wuffs_png__decoder__struct {
uint32_t f_height;
uint64_t f_pass_bytes_per_row;
uint64_t f_workbuf_wi;
uint64_t f_workbuf_hist_pos_base;
uint64_t f_overall_workbuf_length;
uint64_t f_pass_workbuf_length;
uint8_t f_call_sequence;
bool f_report_metadata_chrm;
bool f_report_metadata_gama;
bool f_report_metadata_iccp;
bool f_report_metadata_kvp;
bool f_report_metadata_srgb;
bool f_ignore_checksum;
uint8_t f_depth;
uint8_t f_color_type;
uint8_t f_filter_distance;
uint8_t f_interlace_pass;
bool f_seen_actl;
bool f_seen_chrm;
bool f_seen_fctl;
bool f_seen_gama;
bool f_seen_iccp;
bool f_seen_idat;
bool f_seen_plte;
bool f_seen_srgb;
bool f_seen_trns;
uint32_t f_dst_pixfmt;
uint32_t f_src_pixfmt;
bool f_metadata_is_zlib_compressed;
bool f_zlib_is_dirty;
uint32_t f_chunk_type;
uint8_t f_chunk_type_array[4];
uint64_t f_chunk_length;
uint32_t f_chunk_length;
uint64_t f_remap_transparency;
uint32_t f_dst_pixfmt;
uint32_t f_src_pixfmt;
uint32_t f_num_animation_frames_value;
uint32_t f_num_animation_loops_value;
uint32_t f_num_decoded_frame_configs_value;
uint32_t f_num_decoded_frames_value;
uint32_t f_frame_rect_x0;
uint32_t f_frame_rect_y0;
uint32_t f_frame_rect_x1;
uint32_t f_frame_rect_y1;
uint32_t f_first_rect_x0;
uint32_t f_first_rect_y0;
uint32_t f_first_rect_x1;
uint32_t f_first_rect_y1;
uint64_t f_frame_config_io_position;
uint64_t f_first_config_io_position;
uint64_t f_frame_duration;
uint64_t f_first_duration;
uint8_t f_frame_disposal;
uint8_t f_first_disposal;
bool f_frame_overwrite_instead_of_blend;
bool f_first_overwrite_instead_of_blend;
uint32_t f_next_animation_seq_num;
uint32_t f_metadata_flavor;
uint32_t f_metadata_fourcc;
uint64_t f_metadata_x;
uint64_t f_metadata_y;
uint64_t f_metadata_z;
uint32_t f_ztxt_ri;
uint32_t f_ztxt_wi;
uint64_t f_ztxt_hist_pos;
wuffs_base__pixel_swizzler f_swizzler;
wuffs_base__empty_struct (*choosy_filter_1)(
@@ -9082,11 +9401,19 @@ struct wuffs_png__decoder__struct {
uint32_t p_decode_image_config[1];
uint32_t p_decode_ihdr[1];
uint32_t p_decode_other_chunk[1];
uint32_t p_decode_actl[1];
uint32_t p_decode_chrm[1];
uint32_t p_decode_fctl[1];
uint32_t p_decode_gama[1];
uint32_t p_decode_iccp[1];
uint32_t p_decode_plte[1];
uint32_t p_decode_srgb[1];
uint32_t p_decode_trns[1];
uint32_t p_decode_frame_config[1];
uint32_t p_skip_frame[1];
uint32_t p_decode_frame[1];
uint32_t p_decode_pass[1];
uint32_t p_tell_me_more[1];
wuffs_base__status (*choosy_filter_and_swizzle)(
wuffs_png__decoder* self,
wuffs_base__pixel_buffer* a_dst,
@@ -9109,19 +9436,47 @@ struct wuffs_png__decoder__struct {
struct {
uint64_t scratch;
} s_decode_other_chunk[1];
struct {
uint64_t scratch;
} s_decode_actl[1];
struct {
uint64_t scratch;
} s_decode_chrm[1];
struct {
uint32_t v_x0;
uint32_t v_x1;
uint32_t v_y1;
uint64_t scratch;
} s_decode_fctl[1];
struct {
uint64_t scratch;
} s_decode_gama[1];
struct {
uint32_t v_num_entries;
uint32_t v_i;
uint64_t scratch;
} s_decode_plte[1];
struct {
uint32_t v_num_entries;
uint32_t v_i;
uint32_t v_n;
uint64_t scratch;
} s_decode_trns[1];
struct {
uint32_t v_checksum_have;
uint64_t scratch;
} s_decode_frame_config[1];
struct {
uint64_t scratch;
} s_skip_frame[1];
struct {
uint64_t scratch;
} s_decode_frame[1];
struct {
uint64_t scratch;
} s_decode_pass[1];
struct {
wuffs_base__status v_zlib_status;
uint64_t scratch;
} s_tell_me_more[1];
} private_data;
#ifdef __cplusplus
@@ -9618,6 +9973,63 @@ namespace sync_io {
// --------
// DynIOBuffer is an IOBuffer that is backed by a dynamically sized byte array.
// It owns that backing array and will free it in its destructor.
//
// The array size can be explicitly extended (by calling the grow method) but,
// unlike a C++ std::vector, there is no implicit extension (e.g. by calling
// std::vector::insert) and its maximum size is capped by the max_incl
// constructor argument.
//
// It contains an IOBuffer-typed field whose reader side provides access to
// previously written bytes and whose writer side provides access to the
// allocated but not-yet-written-to slack space. For Go programmers, this slack
// space is roughly analogous to the s[len(s):cap(s)] space of a slice s.
class DynIOBuffer {
public:
enum GrowResult {
OK = 0,
FailedMaxInclExceeded = 1,
FailedOutOfMemory = 2,
};
// m_buf holds the dynamically sized byte array and its read/write indexes:
// - m_buf.meta.wi is roughly analogous to a Go slice's length.
// - m_buf.data.len is roughly analogous to a Go slice's capacity. It is
// also equal to the m_buf.data.ptr malloc/realloc size.
//
// Users should not modify the m_buf.data.ptr or m_buf.data.len fields (as
// they are conceptually private to this class), but they can modify the
// bytes referenced by that pointer-length pair (e.g. compactions).
IOBuffer m_buf;
// m_max_incl is an inclusive upper bound on the backing array size.
const uint64_t m_max_incl;
// Constructor and destructor.
explicit DynIOBuffer(uint64_t max_incl);
~DynIOBuffer();
// Drop frees the byte array and resets m_buf. The DynIOBuffer can still be
// used after a drop call. It just restarts from zero.
void drop();
// grow ensures that the byte array size is at least min_incl and at most
// max_incl. It returns FailedMaxInclExceeded if that would require
// allocating more than max_incl bytes, including the case where (min_incl >
// max_incl). It returns FailedOutOfMemory if memory allocation failed.
GrowResult grow(uint64_t min_incl);
private:
// Delete the copy and assign constructors.
DynIOBuffer(const DynIOBuffer&) = delete;
DynIOBuffer& operator=(const DynIOBuffer&) = delete;
static uint64_t round_up(uint64_t min_incl, uint64_t max_incl);
};
// --------
class Input {
public:
virtual ~Input();
@@ -9728,6 +10140,26 @@ class DecodeCborCallbacks {
Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);
};
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
struct DecodeCborArgQuirks {
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeCborArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
@@ -9737,7 +10169,7 @@ class DecodeCborCallbacks {
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());
DecodeCborArgQuirks quirks = DecodeCborArgQuirks::DefaultValue());
} // namespace wuffs_aux
@@ -9759,10 +10191,11 @@ struct DecodeImageResult {
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
// called in this order:
// 1. SelectDecoder
// 2. SelectPixfmt
// 3. AllocPixbuf
// 4. AllocWorkbuf
// 5. Done
// 2. HandleMetadata
// 3. SelectPixfmt
// 4. AllocPixbuf
// 5. AllocWorkbuf
// 6. Done
//
// It may return early - the third callback might not be invoked if the second
// one fails - but the final callback (Done) is always invoked.
@@ -9819,6 +10252,22 @@ class DecodeImageCallbacks {
virtual wuffs_base__image_decoder::unique_ptr //
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
// HandleMetadata acknowledges image metadata. minfo.flavor will be one of:
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED
// If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those
// bytes should not be retained beyond the the HandleMetadata call.
//
// minfo.metadata__fourcc() will typically match one of the
// DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM |
// REPORT_METADATA_GAMA) was passed to DecodeImage then the metadata FourCC
// will be either WUFFS_BASE__FOURCC__CHRM or WUFFS_BASE__FOURCC__GAMA.
//
// It returns an error message, or an empty string on success.
virtual std::string //
HandleMetadata(const wuffs_base__more_information& minfo,
wuffs_base__slice_u8 raw);
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
// should return wuffs_base__make_pixel_format(etc) called with one of:
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
@@ -9885,13 +10334,116 @@ class DecodeImageCallbacks {
extern const char DecodeImage_BufferIsTooShort[];
extern const char DecodeImage_MaxInclDimensionExceeded[];
extern const char DecodeImage_MaxInclMetadataLengthExceeded[];
extern const char DecodeImage_OutOfMemory[];
extern const char DecodeImage_UnexpectedEndOfFile[];
extern const char DecodeImage_UnsupportedImageFormat[];
extern const char DecodeImage_UnsupportedMetadata[];
extern const char DecodeImage_UnsupportedPixelBlend[];
extern const char DecodeImage_UnsupportedPixelConfiguration[];
extern const char DecodeImage_UnsupportedPixelFormat[];
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeImageArgQuirks wraps an optional argument to DecodeImage.
struct DecodeImageArgQuirks {
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeImageArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeImageArgFlags wraps an optional argument to DecodeImage.
struct DecodeImageArgFlags {
explicit DecodeImageArgFlags(uint64_t repr0);
// DefaultValue returns 0.
static DecodeImageArgFlags DefaultValue();
// TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, GAMA,
// ICCP, KVP, SRGB and XMP.
// Background Color.
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
// Primary Chromaticities and White Point.
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
// Exchangeable Image File Format.
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
// Gamma Correction.
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
// International Color Consortium Profile.
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
// Key-Value Pair.
//
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
// HandleMetadata callback, the raw argument contains UTF-8 strings.
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
// Modification Time.
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
// Offset (2-Dimensional).
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
// Physical Dimensions.
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
// Standard Red Green Blue (Rendering Intent).
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
// Extensible Metadata Platform.
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
uint64_t repr;
};
// DecodeImageArgPixelBlend wraps an optional argument to DecodeImage.
struct DecodeImageArgPixelBlend {
explicit DecodeImageArgPixelBlend(wuffs_base__pixel_blend repr0);
// DefaultValue returns WUFFS_BASE__PIXEL_BLEND__SRC.
static DecodeImageArgPixelBlend DefaultValue();
wuffs_base__pixel_blend repr;
};
// DecodeImageArgBackgroundColor wraps an optional argument to DecodeImage.
struct DecodeImageArgBackgroundColor {
explicit DecodeImageArgBackgroundColor(
wuffs_base__color_u32_argb_premul repr0);
// DefaultValue returns 1, an invalid wuffs_base__color_u32_argb_premul.
static DecodeImageArgBackgroundColor DefaultValue();
wuffs_base__color_u32_argb_premul repr;
};
// DecodeImageArgMaxInclDimension wraps an optional argument to DecodeImage.
struct DecodeImageArgMaxInclDimension {
explicit DecodeImageArgMaxInclDimension(uint32_t repr0);
// DefaultValue returns 1048575 = 0x000F_FFFF, more than 1 million pixels.
static DecodeImageArgMaxInclDimension DefaultValue();
uint32_t repr;
};
// DecodeImageArgMaxInclMetadataLength wraps an optional argument to
// DecodeImage.
struct DecodeImageArgMaxInclMetadataLength {
explicit DecodeImageArgMaxInclMetadataLength(uint64_t repr0);
// DefaultValue returns 16777215 = 0x00FF_FFFF, one less than 16 MiB.
static DecodeImageArgMaxInclMetadataLength DefaultValue();
uint64_t repr;
};
// DecodeImage decodes the image data in input. A variety of image file formats
// can be decoded, depending on what callbacks.SelectDecoder returns.
//
@@ -9934,13 +10486,21 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.
//
// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's
// width or height is greater than max_incl_dimension.
// width or height is greater than max_incl_dimension or if any opted-in (via
// flags bits) metadata is longer than max_incl_metadata_length.
DecodeImageResult //
DecodeImage(DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
DecodeImageArgQuirks quirks = DecodeImageArgQuirks::DefaultValue(),
DecodeImageArgFlags flags = DecodeImageArgFlags::DefaultValue(),
DecodeImageArgPixelBlend pixel_blend =
DecodeImageArgPixelBlend::DefaultValue(),
DecodeImageArgBackgroundColor background_color =
DecodeImageArgBackgroundColor::DefaultValue(),
DecodeImageArgMaxInclDimension max_incl_dimension =
DecodeImageArgMaxInclDimension::DefaultValue(),
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length =
DecodeImageArgMaxInclMetadataLength::DefaultValue());
} // namespace wuffs_aux
@@ -10001,6 +10561,36 @@ class DecodeJsonCallbacks {
extern const char DecodeJson_BadJsonPointer[];
extern const char DecodeJson_NoMatch[];
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
struct DecodeJsonArgQuirks {
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeJsonArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
struct DecodeJsonArgJsonPointer {
explicit DecodeJsonArgJsonPointer(std::string repr0);
// DefaultValue returns an empty string.
static DecodeJsonArgJsonPointer DefaultValue();
std::string repr;
};
// DecodeJson calls callbacks based on the JSON-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
@@ -10018,8 +10608,9 @@ extern const char DecodeJson_NoMatch[];
DecodeJsonResult //
DecodeJson(DecodeJsonCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),
std::string json_pointer = std::string());
DecodeJsonArgQuirks quirks = DecodeJsonArgQuirks::DefaultValue(),
DecodeJsonArgJsonPointer json_pointer =
DecodeJsonArgJsonPointer::DefaultValue());
} // namespace wuffs_aux
@@ -10047,26 +10638,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) \
@@ -10079,8 +10660,9 @@ extern "C" {
goto suspend; \
case n:;
// Clang also defines "__GNUC__".
#if defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__) || defined(__clang__)
#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))
#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))
#else
@@ -10238,7 +10820,7 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
// --------
static inline wuffs_base__slice_u8 //
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
wuffs_base__table_u8__row_u32(wuffs_base__table_u8 t, uint32_t y) {
if (y < t.height) {
return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);
}
@@ -10409,11 +10991,12 @@ wuffs_base__io_reader__set(wuffs_base__io_buffer* b,
const uint8_t** ptr_io0_r,
const uint8_t** ptr_io1_r,
const uint8_t** ptr_io2_r,
wuffs_base__slice_u8 data) {
wuffs_base__slice_u8 data,
uint64_t history_position) {
b->data = data;
b->meta.wi = data.len;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.pos = history_position;
b->meta.closed = false;
*ptr_iop_r = data.ptr;
@@ -10647,11 +11230,12 @@ wuffs_base__io_writer__set(wuffs_base__io_buffer* b,
uint8_t** ptr_io0_w,
uint8_t** ptr_io1_w,
uint8_t** ptr_io2_w,
wuffs_base__slice_u8 data) {
wuffs_base__slice_u8 data,
uint64_t history_position) {
b->data = data;
b->meta.wi = 0;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.pos = history_position;
b->meta.closed = false;
*ptr_iop_w = data.ptr;
@@ -12304,14 +12888,14 @@ wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {
// padded with implicit zeroes.
//
// For example, if num_digits is 3 and digits is "\x07\x08\x09":
// - A decimal_point of -2 means ".00789"
// - A decimal_point of -1 means ".0789"
// - A decimal_point of +0 means ".789"
// - A decimal_point of +1 means "7.89"
// - A decimal_point of +2 means "78.9"
// - A decimal_point of +3 means "789."
// - A decimal_point of +4 means "7890."
// - A decimal_point of +5 means "78900."
// - A decimal_point of -2 means ".00789"
// - A decimal_point of -1 means ".0789"
// - A decimal_point of +0 means ".789"
// - A decimal_point of +1 means "7.89"
// - A decimal_point of +2 means "78.9"
// - A decimal_point of +3 means "789."
// - A decimal_point of +4 means "7890."
// - A decimal_point of +5 means "78900."
//
// As above, a decimal_point higher than +2047 means that the overall value is
// infinity, lower than -2047 means zero.
@@ -12656,10 +13240,10 @@ wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns
// the integral (non-fractional) part of h, provided that it is 18 or fewer
// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
// and that IEEE 754 double precision has 52 mantissa bits.
//
// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.
@@ -14216,13 +14800,18 @@ wuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {
ret.value = 0;
return ret;
} else if (negative) {
if (r.value > 0x8000000000000000) {
goto fail_out_of_bounds;
if (r.value < 0x8000000000000000) {
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = -(int64_t)(r.value);
return ret;
} else if (r.value == 0x8000000000000000) {
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = INT64_MIN;
return ret;
}
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = -(int64_t)(r.value);
return ret;
goto fail_out_of_bounds;
} else if (r.value > 0x7FFFFFFFFFFFFFFF) {
goto fail_out_of_bounds;
} else {
@@ -14987,19 +15576,22 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
//
// Keep it sorted by magic[1], then magic[0] descending and finally by
// magic[2:]. When multiple entries match, the longest one wins.
//
// The fourcc field might be negated, in which case there's further
// specialization (see § below).
static struct {
int32_t fourcc;
const char* magic;
} table[] = {
{0x57424D50, "\x01\x00\x00"}, // WBMP
{0x424D5020, "\x01\x42\x4D"}, // BMP
{0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
{0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
{0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
{0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF (see § below)
{0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
{0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
{0x4A504547, "\x01\xFF\xD8"}, // JPEG
{-0x30302020, "\x01\x00\x00"}, // '00 'be
{+0x424D5020, "\x01\x42\x4D"}, // BMP
{+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
{+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
{+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
{-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF
{+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
{+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
{+0x4A504547, "\x01\xFF\xD8"}, // JPEG
};
static const size_t table_len = sizeof(table) / sizeof(table[0]);
@@ -15040,19 +15632,38 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
return 0;
match:
// Some FourCC values (see § above) are further specialized.
if (fourcc == 0x52494646) { // 'RIFF'be
if (prefix.len < 16) {
return -1;
}
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
if (x == 0x57454250) { // 'WEBP'be
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
if (y == 0x56503820) { // 'VP8 'be
return 0x57503820; // 'WP8 'be
} else if (y == 0x5650384C) { // 'VP8L'be
return 0x5750384C; // 'WP8L'be
// Negative FourCC values (see § above) are further specialized.
if (fourcc < 0) {
fourcc = -fourcc;
if (fourcc == 0x52494646) { // 'RIFF'be
if (prefix.len < 16) {
return -1;
}
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
if (x == 0x57454250) { // 'WEBP'be
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
if (y == 0x56503820) { // 'VP8 'be
return 0x57503820; // 'WP8 'be
} else if (y == 0x5650384C) { // 'VP8L'be
return 0x5750384C; // 'WP8L'be
}
}
} else if (fourcc == 0x30302020) { // '00 'be
// Binary data starting with multiple 0x00 NUL bytes is quite common.
if (prefix.len < 4) {
return -1;
} else if ((prefix.ptr[2] != 0x00) &&
((prefix.ptr[2] >= 0x80) || (prefix.ptr[3] != 0x00))) {
// Roughly speaking, this could be a non-degenerate (non-0-width and
// non-0-height) WBMP image.
return 0x57424D50; // 'WBMP'be
} else if (((prefix.ptr[2] == 0x01) || (prefix.ptr[2] == 0x02)) &&
(prefix.ptr[3] == 0x00)) {
return 0x49434F20; // 'ICO 'be
}
return 0;
}
}
return fourcc;
@@ -15863,7 +16474,7 @@ wuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
@@ -15907,7 +16518,7 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
}
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -18186,7 +18797,7 @@ wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
@@ -18239,7 +18850,7 @@ wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -18898,7 +19509,7 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
@@ -18945,7 +19556,7 @@ wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -19233,7 +19844,7 @@ wuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__xxxx__y__sse42;
}
@@ -19271,7 +19882,6 @@ wuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,
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:
@@ -19617,7 +20227,7 @@ wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
}
@@ -19692,7 +20302,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -19873,7 +20483,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_premul(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -19941,7 +20551,7 @@ wuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
}
@@ -19992,7 +20602,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -20103,7 +20713,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_premul(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -20586,12 +21196,12 @@ wuffs_adler32__hasher__up_arm_neon(
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_x86_sse42(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ---------------- VTables
@@ -20707,7 +21317,7 @@ wuffs_adler32__hasher__update_u32(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_adler32__hasher__up_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_adler32__hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -20899,7 +21509,7 @@ wuffs_adler32__hasher__up_arm_neon(
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func adler32.hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_x86_sse42(
@@ -20985,7 +21595,7 @@ wuffs_adler32__hasher__up_x86_sse42(
self->private_impl.f_state = (((v_s2 & 65535) << 16) | (v_s1 & 65535));
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32)
@@ -21316,7 +21926,7 @@ wuffs_bmp__decoder__decode_image_config(
goto exit;
}
self->private_impl.f_padding -= 14;
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))));
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))));
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
uint32_t t_2;
@@ -22065,7 +22675,7 @@ wuffs_bmp__decoder__decode_image_config(
} else if (self->private_impl.f_bits_per_pixel == 32) {
self->private_impl.f_pad_per_row = 0;
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if (a_dst != NULL) {
v_dst_pixfmt = 2164295816;
if ((self->private_impl.f_channel_num_bits[0] > 8) ||
@@ -22085,7 +22695,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;
@@ -22164,7 +22773,7 @@ wuffs_bmp__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
@@ -22194,7 +22803,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;
@@ -22382,7 +22990,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;
@@ -22471,7 +23078,7 @@ wuffs_bmp__decoder__swizzle_none(
goto label__outer__continue;
}
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -22496,7 +23103,6 @@ wuffs_bmp__decoder__swizzle_none(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22557,7 +23163,7 @@ wuffs_bmp__decoder__swizzle_rle(
v_rle_state = self->private_impl.f_rle_state;
label__outer__continue:;
while (true) {
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
}
@@ -22717,7 +23323,7 @@ wuffs_bmp__decoder__swizzle_rle(
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
}
@@ -22749,7 +23355,7 @@ wuffs_bmp__decoder__swizzle_rle(
}
label__outer__break:;
while (self->private_impl.f_dst_y < self->private_impl.f_height) {
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
}
@@ -22759,7 +23365,6 @@ wuffs_bmp__decoder__swizzle_rle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22880,7 +23485,7 @@ wuffs_bmp__decoder__swizzle_bitfields(
v_p0 += 1;
}
label__0__break:;
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -22900,7 +23505,6 @@ wuffs_bmp__decoder__swizzle_bitfields(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22963,7 +23567,7 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
goto label__loop__break;
}
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -23069,7 +23673,6 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -24155,7 +24758,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;
@@ -24773,19 +25375,19 @@ 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)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_sse42(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ---------------- VTables
@@ -24899,10 +25501,10 @@ 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)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -25092,7 +25694,7 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func crc32.ieee_hasher.up_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
@@ -25205,13 +25807,13 @@ wuffs_crc32__ieee_hasher__up_x86_avx2(
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc32.ieee_hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_sse42(
@@ -25324,7 +25926,7 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC32)
@@ -25449,13 +26051,13 @@ wuffs_deflate__decoder__init_huff(
uint32_t a_n_codes1,
uint32_t a_base_symbol);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast32(
@@ -25685,7 +26287,7 @@ wuffs_deflate__decoder__transform_io(
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
self->private_impl.choosy_decode_huffman_fast64 = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
#endif
self->private_impl.choosy_decode_huffman_fast64);
@@ -25711,12 +26313,12 @@ wuffs_deflate__decoder__transform_io(
}
goto ok;
}
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_transformed_history_count, wuffs_base__io__count_since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst))));
wuffs_deflate__decoder__add_history(self, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst));
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -25874,7 +26476,6 @@ wuffs_deflate__decoder__decode_blocks(
}
}
goto ok;
ok:
self->private_impl.p_decode_blocks[0] = 0;
goto exit;
@@ -25994,7 +26595,6 @@ wuffs_deflate__decoder__decode_uncompressed(
}
}
goto ok;
ok:
self->private_impl.p_decode_uncompressed[0] = 0;
goto exit;
@@ -26580,7 +27180,7 @@ wuffs_deflate__decoder__init_huff(
// ‼ WUFFS MULTI-FILE SECTION +x86_bmi2
// -------- func deflate.decoder.decode_huffman_bmi2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_bmi2(
@@ -26601,6 +27201,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint32_t v_hdist_adjustment = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -26634,6 +27235,11 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
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);
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
goto exit;
}
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
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)));
@@ -26724,6 +27330,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
v_hlen = v_length;
v_length = 0;
}
v_hdist += v_hdist_adjustment;
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -26784,7 +27391,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
return status;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
// -------- func deflate.decoder.decode_huffman_fast32
@@ -26808,6 +27415,7 @@ wuffs_deflate__decoder__decode_huffman_fast32(
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint32_t v_hdist_adjustment = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -26841,6 +27449,11 @@ wuffs_deflate__decoder__decode_huffman_fast32(
v_n_bits = self->private_impl.f_n_bits;
v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
goto exit;
}
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
label__loop__continue:;
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 12)) {
if (v_n_bits < 15) {
@@ -26983,6 +27596,7 @@ wuffs_deflate__decoder__decode_huffman_fast32(
v_hlen = v_length;
v_length = 0;
}
v_hdist += v_hdist_adjustment;
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -27066,6 +27680,7 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint32_t v_hdist_adjustment = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -27099,6 +27714,11 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
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);
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
goto exit;
}
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
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)));
@@ -27189,6 +27809,7 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
v_hlen = v_length;
v_length = 0;
}
v_hdist += v_hdist_adjustment;
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -27523,6 +28144,7 @@ wuffs_deflate__decoder__decode_huffman_slow(
v_hlen = v_length;
v_length = 0;
}
v_hdist += ((uint32_t)((((uint64_t)(self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0))) & 4294967295)));
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -27585,7 +28207,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_huffman_slow[0] = 0;
goto exit;
@@ -27857,7 +28478,6 @@ wuffs_lzw__decoder__transform_io(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -28101,7 +28721,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;
@@ -28591,7 +29210,7 @@ wuffs_gif__decoder__tell_me_more(
while (true) {
label__0__continue:;
while (true) {
if (wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
if (wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
if (a_minfo != NULL) {
wuffs_base__more_information__set(a_minfo,
2,
@@ -28630,13 +29249,13 @@ wuffs_gif__decoder__tell_me_more(
} else {
iop_a_src += 1;
}
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
if (a_minfo != NULL) {
wuffs_base__more_information__set(a_minfo,
3,
self->private_impl.f_metadata_fourcc,
0,
wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))),
wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))),
self->private_impl.f_metadata_io_position);
}
status = wuffs_base__make_status(wuffs_base__suspension__even_more_information);
@@ -28657,7 +29276,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;
@@ -28693,8 +29311,8 @@ wuffs_gif__decoder__num_animation_loops(
return 0;
}
if (self->private_impl.f_seen_num_loops) {
return self->private_impl.f_num_loops;
if (self->private_impl.f_seen_num_animation_loops_value) {
return self->private_impl.f_num_animation_loops_value;
}
return 1;
}
@@ -28925,7 +29543,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;
@@ -29164,9 +29781,9 @@ wuffs_gif__decoder__decode_up_to_id_part1(
if ( ! self->private_impl.f_restarted) {
if (self->private_impl.f_call_sequence != 2) {
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
}
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
} else {
@@ -29591,7 +30208,6 @@ wuffs_gif__decoder__decode_extension(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_extension[0] = 0;
goto exit;
@@ -29660,7 +30276,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;
@@ -29844,22 +30459,22 @@ wuffs_gif__decoder__decode_ae(
*scratch |= ((uint64_t)(num_bits_4)) << 56;
}
}
self->private_impl.f_num_loops = t_4;
self->private_impl.f_num_animation_loops_value = t_4;
}
self->private_impl.f_seen_num_loops = true;
if ((0 < self->private_impl.f_num_loops) && (self->private_impl.f_num_loops <= 65535)) {
self->private_impl.f_num_loops += 1;
self->private_impl.f_seen_num_animation_loops_value = true;
if ((0 < self->private_impl.f_num_animation_loops_value) && (self->private_impl.f_num_animation_loops_value <= 65535)) {
self->private_impl.f_num_animation_loops_value += 1;
}
} else if (self->private_impl.f_ignore_metadata) {
} else if (v_is_iccp && self->private_impl.f_report_metadata_iccp) {
self->private_impl.f_metadata_fourcc = 1229144912;
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
} else if (v_is_xmp && self->private_impl.f_report_metadata_xmp) {
self->private_impl.f_metadata_fourcc = 1481461792;
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
@@ -29879,7 +30494,6 @@ wuffs_gif__decoder__decode_ae(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_ae[0] = 0;
goto exit;
@@ -30331,7 +30945,8 @@ wuffs_gif__decoder__decode_id_part1(
goto ok;
}
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw, sizeof (wuffs_lzw__decoder), WUFFS_VERSION, 0));
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw,
sizeof (wuffs_lzw__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -30349,7 +30964,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;
@@ -30485,7 +31099,8 @@ wuffs_gif__decoder__decode_id_part2(
wuffs_base__slice_u8__subslice_ij(wuffs_base__make_slice_u8(self->private_data.f_compressed,
4096),
self->private_impl.f_compressed_ri,
self->private_impl.f_compressed_wi));
self->private_impl.f_compressed_wi),
0);
v_mark = ((uint64_t)(iop_v_r - io0_v_r));
{
u_r.meta.ri = ((size_t)(iop_v_r - u_r.data.ptr));
@@ -30556,7 +31171,6 @@ wuffs_gif__decoder__decode_id_part2(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_id_part2[0] = 0;
goto exit;
@@ -30618,7 +31232,7 @@ wuffs_gif__decoder__copy_to_image_buffer(
}
return wuffs_base__make_status(wuffs_base__error__too_much_data);
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, 0);
} else if (v_width_in_bytes < ((uint64_t)(v_dst.len))) {
@@ -30644,12 +31258,12 @@ wuffs_gif__decoder__copy_to_image_buffer(
goto label__0__continue;
}
if ((self->private_impl.f_num_decoded_frames_value == 0) && ! self->private_impl.f_gc_has_transparent_index && (self->private_impl.f_interlace > 1)) {
v_replicate_src = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_replicate_src = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
v_replicate_y0 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, 1);
v_replicate_y1 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, ((uint32_t)(WUFFS_GIF__INTERLACE_COUNT[self->private_impl.f_interlace])));
v_replicate_y1 = wuffs_base__u32__min(v_replicate_y1, self->private_impl.f_frame_rect_y1);
while (v_replicate_y0 < v_replicate_y1) {
v_replicate_dst = wuffs_base__table_u8__row(v_tab, v_replicate_y0);
v_replicate_dst = wuffs_base__table_u8__row_u32(v_tab, v_replicate_y0);
wuffs_base__slice_u8__copy_from_slice(v_replicate_dst, v_replicate_src);
v_replicate_y0 += 1;
}
@@ -31166,7 +31780,6 @@ wuffs_gzip__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -32623,7 +33236,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;
@@ -32925,7 +33537,6 @@ wuffs_json__decoder__decode_leading(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_decode_leading[0] = 0;
goto exit;
@@ -33067,16 +33678,19 @@ wuffs_json__decoder__decode_comment(
}
while (true) {
if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
if (v_length > 0) {
if (a_src && a_src->meta.closed) {
*iop_a_dst++ = wuffs_base__make_token(
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
self->private_impl.f_comment_type = 2;
status = wuffs_base__make_status(NULL);
goto ok;
} else if (v_length > 0) {
*iop_a_dst++ = wuffs_base__make_token(
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
(((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
}
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_json__error__bad_input);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
v_length = 0;
@@ -33084,10 +33698,9 @@ wuffs_json__decoder__decode_comment(
}
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
if (v_c == 10) {
iop_a_src += 1;
*iop_a_dst++ = wuffs_base__make_token(
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
(((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
self->private_impl.f_comment_type = 2;
status = wuffs_base__make_status(NULL);
goto ok;
@@ -33106,7 +33719,6 @@ wuffs_json__decoder__decode_comment(
}
}
goto ok;
ok:
self->private_impl.p_decode_comment[0] = 0;
goto exit;
@@ -33267,7 +33879,6 @@ wuffs_json__decoder__decode_inf_nan(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_inf_nan[0] = 0;
goto exit;
@@ -33413,7 +34024,6 @@ wuffs_json__decoder__decode_trailer(
}
label__outer__break:;
goto ok;
ok:
self->private_impl.p_decode_trailer[0] = 0;
goto exit;
@@ -33858,7 +34468,7 @@ wuffs_nie__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (16 != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (16 != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
@@ -33888,7 +34498,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;
@@ -33997,7 +34606,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;
@@ -34063,7 +34671,7 @@ wuffs_nie__decoder__swizzle(
goto label__0__break;
}
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -34087,7 +34695,6 @@ wuffs_nie__decoder__swizzle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -34687,7 +35294,6 @@ wuffs_zlib__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -34720,17 +35326,25 @@ wuffs_zlib__decoder__transform_io(
// ---------------- Status Codes Implementations
const char wuffs_png__error__bad_animation_sequence_number[] = "#png: bad animation sequence number";
const char wuffs_png__error__bad_checksum[] = "#png: bad checksum";
const char wuffs_png__error__bad_chunk[] = "#png: bad chunk";
const char wuffs_png__error__bad_filter[] = "#png: bad filter";
const char wuffs_png__error__bad_header[] = "#png: bad header";
const char wuffs_png__error__bad_text_chunk_not_latin_1[] = "#png: bad text chunk (not Latin-1)";
const char wuffs_png__error__missing_palette[] = "#png: missing palette";
const char wuffs_png__error__unsupported_png_compression_method[] = "#png: unsupported PNG compression method";
const char wuffs_png__error__unsupported_png_file[] = "#png: unsupported PNG file";
const char wuffs_png__error__internal_error_inconsistent_i_o[] = "#png: internal error: inconsistent I/O";
const char wuffs_png__error__internal_error_inconsistent_chunk_type[] = "#png: internal error: inconsistent chunk type";
const char wuffs_png__error__internal_error_inconsistent_frame_bounds[] = "#png: internal error: inconsistent frame bounds";
const char wuffs_png__error__internal_error_inconsistent_workbuf_length[] = "#png: internal error: inconsistent workbuf length";
const char wuffs_png__error__internal_error_zlib_decoder_did_not_exhaust_its_input[] = "#png: internal error: zlib decoder did not exhaust its input";
// ---------------- Private Consts
#define WUFFS_PNG__ANCILLARY_BIT 32
static const uint8_t
WUFFS_PNG__INTERLACING[8][6] WUFFS_BASE__POTENTIALLY_UNUSED = {
{
@@ -34767,6 +35381,42 @@ WUFFS_PNG__NUM_CHANNELS[8] WUFFS_BASE__POTENTIALLY_UNUSED = {
1, 0, 3, 1, 2, 0, 4, 0,
};
static const uint16_t
WUFFS_PNG__LATIN_1[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87,
88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 41410, 41666, 41922, 42178, 42434, 42690, 42946,
43202, 43458, 43714, 43970, 44226, 44482, 44738, 44994,
45250, 45506, 45762, 46018, 46274, 46530, 46786, 47042,
47298, 47554, 47810, 48066, 48322, 48578, 48834, 49090,
32963, 33219, 33475, 33731, 33987, 34243, 34499, 34755,
35011, 35267, 35523, 35779, 36035, 36291, 36547, 36803,
37059, 37315, 37571, 37827, 38083, 38339, 38595, 38851,
39107, 39363, 39619, 39875, 40131, 40387, 40643, 40899,
41155, 41411, 41667, 41923, 42179, 42435, 42691, 42947,
43203, 43459, 43715, 43971, 44227, 44483, 44739, 44995,
45251, 45507, 45763, 46019, 46275, 46531, 46787, 47043,
47299, 47555, 47811, 48067, 48323, 48579, 48835, 49091,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -34876,36 +35526,36 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__status
wuffs_png__decoder__decode_ihdr(
@@ -34930,16 +35580,51 @@ wuffs_png__decoder__decode_other_chunk(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_actl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_chrm(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_fctl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_gama(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_iccp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_plte(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_srgb(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_trns(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__skip_frame(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_pass(
wuffs_png__decoder* self,
@@ -36113,7 +36798,7 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_1_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
@@ -36153,13 +36838,13 @@ wuffs_png__decoder__filter_1_distance_4_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_3_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
@@ -36258,13 +36943,13 @@ wuffs_png__decoder__filter_3_distance_4_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_4_distance_3_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
@@ -36384,13 +37069,13 @@ wuffs_png__decoder__filter_4_distance_3_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_4_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
@@ -36488,7 +37173,7 @@ wuffs_png__decoder__filter_4_distance_4_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// -------- func png.decoder.set_quirk_enabled
@@ -36564,172 +37249,210 @@ wuffs_png__decoder__decode_image_config(
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 0) {
if (self->private_impl.f_call_sequence == 2) {
if (self->private_impl.f_metadata_fourcc != 0) {
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
}
} else if (self->private_impl.f_call_sequence != 0) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 56) {
t_0 = ((uint64_t)(*scratch));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_magic = t_0;
}
if (v_magic != 727905341920923785) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 56) {
t_1 = ((uint64_t)(*scratch));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_magic = t_1;
}
if (v_magic != 5927942488114331648) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 72;
self->private_impl.f_chunk_type_array[2] = 68;
self->private_impl.f_chunk_type_array[3] = 82;
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
} else {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__0__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
label__0__break:;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_checksum_want = t_3;
}
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
}
while (true) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
uint64_t t_4;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
if (num_bits_4 == 24) {
t_4 = ((uint64_t)(*scratch >> 32));
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 56) {
t_0 = ((uint64_t)(*scratch));
break;
}
num_bits_4 += 8;
*scratch |= ((uint64_t)(num_bits_4));
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
self->private_impl.f_chunk_length = t_4;
v_magic = t_0;
}
if (v_magic != 727905341920923785) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 56) {
t_1 = ((uint64_t)(*scratch));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_magic = t_1;
}
if (v_magic != 5927942488114331648) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 72;
self->private_impl.f_chunk_type_array[2] = 68;
self->private_impl.f_chunk_type_array[3] = 82;
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__0__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
label__0__break:;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_checksum_want = t_3;
}
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
}
}
while (true) {
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
}
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
if (self->private_impl.f_chunk_type == 1413563465) {
if ( ! self->private_impl.f_seen_actl || self->private_impl.f_seen_fctl) {
goto label__1__break;
}
self->private_impl.f_seen_idat = true;
} else if (self->private_impl.f_chunk_type == 1413571686) {
if (self->private_impl.f_seen_idat && self->private_impl.f_seen_fctl) {
goto label__1__break;
}
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
iop_a_src += 8;
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_4 = wuffs_png__decoder__decode_other_chunk(self, a_src);
v_status = t_4;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__2__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
}
label__2__break:;
if (self->private_impl.f_metadata_fourcc != 0) {
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
uint32_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_5 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
@@ -36740,83 +37463,21 @@ wuffs_png__decoder__decode_image_config(
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_5;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 24) {
t_5 = ((uint32_t)(*scratch));
t_5 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5)) << 56;
*scratch |= ((uint64_t)(num_bits_5));
}
}
self->private_impl.f_chunk_type = t_5;
v_checksum_want = t_5;
}
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type == 1413563465) || (self->private_impl.f_chunk_type == 1163152464))) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
if (self->private_impl.f_chunk_type == 1413563465) {
goto label__1__break;
}
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_6 = wuffs_png__decoder__decode_other_chunk(self, a_src);
v_status = t_6;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__2__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(12);
}
label__2__break:;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
uint32_t t_7;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_7 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
if (num_bits_7 == 24) {
t_7 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_7 += 8;
*scratch |= ((uint64_t)(num_bits_7));
}
}
v_checksum_want = t_7;
}
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464) && (v_checksum_have != v_checksum_want)) {
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0) && (v_checksum_have != v_checksum_want)) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
}
@@ -36826,7 +37487,8 @@ wuffs_png__decoder__decode_image_config(
status = wuffs_base__make_status(wuffs_png__error__missing_palette);
goto exit;
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_first_config_io_position = self->private_impl.f_frame_config_io_position;
if (a_dst != NULL) {
wuffs_base__image_config__set(
a_dst,
@@ -36834,12 +37496,21 @@ wuffs_png__decoder__decode_image_config(
0,
self->private_impl.f_width,
self->private_impl.f_height,
self->private_impl.f_frame_config_io_position,
self->private_impl.f_first_config_io_position,
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns));
}
if ( ! self->private_impl.f_seen_actl) {
self->private_impl.f_num_animation_frames_value = 1;
self->private_impl.f_first_rect_x0 = 0;
self->private_impl.f_first_rect_y0 = 0;
self->private_impl.f_first_rect_x1 = self->private_impl.f_width;
self->private_impl.f_first_rect_y1 = self->private_impl.f_height;
self->private_impl.f_first_duration = 0;
self->private_impl.f_first_disposal = 0;
self->private_impl.f_first_overwrite_instead_of_blend = false;
}
self->private_impl.f_call_sequence = 3;
goto ok;
ok:
self->private_impl.p_decode_image_config[0] = 0;
goto exit;
@@ -37001,7 +37672,7 @@ wuffs_png__decoder__decode_ihdr(
v_a8 = t_4;
}
if (v_a8 != 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
{
@@ -37039,7 +37710,7 @@ wuffs_png__decoder__decode_ihdr(
self->private_impl.f_filter_distance = 0;
wuffs_png__decoder__assign_filter_distance(self);
if (self->private_impl.f_filter_distance == 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
self->private_impl.f_overall_workbuf_length = (((uint64_t)(self->private_impl.f_height)) * (1 + wuffs_png__decoder__calculate_bytes_per_row(self, self->private_impl.f_width)));
@@ -37070,7 +37741,9 @@ static wuffs_base__empty_struct
wuffs_png__decoder__assign_filter_distance(
wuffs_png__decoder* self) {
if (self->private_impl.f_depth < 8) {
if (self->private_impl.f_color_type == 0) {
if ((self->private_impl.f_depth != 1) && (self->private_impl.f_depth != 2) && (self->private_impl.f_depth != 4)) {
return wuffs_base__make_empty_struct();
} else if (self->private_impl.f_color_type == 0) {
self->private_impl.f_dst_pixfmt = 536870920;
self->private_impl.f_src_pixfmt = 536870920;
} else if (self->private_impl.f_color_type == 3) {
@@ -37173,7 +37846,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_3_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_3_x86_sse42 :
#endif
&wuffs_png__decoder__filter_4_distance_3_fallback);
@@ -37182,7 +37855,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_1_distance_4_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_1_distance_4_x86_sse42 :
#endif
&wuffs_png__decoder__filter_1_distance_4_fallback);
@@ -37190,7 +37863,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_3_distance_4_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_3_distance_4_x86_sse42 :
#endif
&wuffs_png__decoder__filter_3_distance_4_fallback);
@@ -37198,7 +37871,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_4_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_4_x86_sse42 :
#endif
&wuffs_png__decoder__filter_4_distance_4_fallback);
@@ -37246,6 +37919,121 @@ wuffs_png__decoder__decode_other_chunk(
goto suspend;
}
self->private_impl.f_seen_plte = true;
} else if ((self->private_impl.f_chunk_type & 32) == 0) {
if (self->private_impl.f_chunk_type != 1413563465) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
} else if (self->private_impl.f_chunk_type == 1280598881) {
if (self->private_impl.f_seen_actl) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_png__decoder__decode_actl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_actl = true;
} else if (self->private_impl.f_chunk_type == 1297238115) {
if (self->private_impl.f_report_metadata_chrm) {
if (self->private_impl.f_seen_chrm) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_png__decoder__decode_chrm(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_chrm = true;
}
} else if (self->private_impl.f_chunk_type == 1280598886) {
if (self->private_impl.f_seen_fctl) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_png__decoder__decode_fctl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_fctl = true;
} else if (self->private_impl.f_chunk_type == 1095582055) {
if (self->private_impl.f_report_metadata_gama) {
if (self->private_impl.f_seen_gama) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_png__decoder__decode_gama(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_gama = true;
}
} else if (self->private_impl.f_chunk_type == 1346585449) {
if (self->private_impl.f_report_metadata_iccp) {
if (self->private_impl.f_seen_iccp) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_png__decoder__decode_iccp(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_iccp = true;
}
} else if (self->private_impl.f_chunk_type == 1111970419) {
if (self->private_impl.f_report_metadata_srgb) {
if (self->private_impl.f_seen_srgb) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_png__decoder__decode_srgb(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_srgb = true;
}
} else if (self->private_impl.f_chunk_type == 1397641844) {
if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3) || ((self->private_impl.f_color_type == 3) && ! self->private_impl.f_seen_plte)) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
@@ -37254,7 +38042,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_png__decoder__decode_trns(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -37263,9 +38051,18 @@ wuffs_png__decoder__decode_other_chunk(
goto suspend;
}
self->private_impl.f_seen_trns = true;
} else {
} else if ((self->private_impl.f_chunk_type == 1951945833) || (self->private_impl.f_chunk_type == 1951942004) || (self->private_impl.f_chunk_type == 1951945850)) {
if (self->private_impl.f_report_metadata_kvp) {
self->private_impl.f_metadata_flavor = 4;
self->private_impl.f_metadata_fourcc = 1263947851;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
}
}
if (self->private_impl.f_metadata_fourcc == 0) {
self->private_data.s_decode_other_chunk[0].scratch = self->private_impl.f_chunk_length;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
if (self->private_data.s_decode_other_chunk[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_other_chunk[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
@@ -37294,6 +38091,923 @@ wuffs_png__decoder__decode_other_chunk(
return status;
}
// -------- func png.decoder.decode_actl
static wuffs_base__status
wuffs_png__decoder__decode_actl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_actl[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 8) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
} else if (self->private_impl.f_interlace_pass > 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_actl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
self->private_impl.f_num_animation_frames_value = t_0;
}
if (self->private_impl.f_num_animation_frames_value == 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_actl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
self->private_impl.f_num_animation_loops_value = t_1;
}
goto ok;
ok:
self->private_impl.p_decode_actl[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_actl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_chrm
static wuffs_base__status
wuffs_png__decoder__decode_chrm(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_u = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_chrm[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 32) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
self->private_impl.f_metadata_flavor = 5;
self->private_impl.f_metadata_fourcc = 1128813133;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_u = t_0;
}
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 0);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
v_u = t_1;
}
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 24);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint64_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
if (num_bits_2 == 24) {
t_2 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_2 += 8;
*scratch |= ((uint64_t)(num_bits_2));
}
}
v_u = t_2;
}
self->private_impl.f_metadata_x |= ((uint64_t)((16777215 & v_u) << 48));
self->private_impl.f_metadata_y |= ((16777215 & v_u) >> 16);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
uint64_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_u = t_3;
}
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 8);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
uint64_t t_4;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
if (num_bits_4 == 24) {
t_4 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_4 += 8;
*scratch |= ((uint64_t)(num_bits_4));
}
}
v_u = t_4;
}
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 32);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
uint64_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_5 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 24) {
t_5 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5));
}
}
v_u = t_5;
}
self->private_impl.f_metadata_y |= ((uint64_t)((16777215 & v_u) << 56));
self->private_impl.f_metadata_z |= ((16777215 & v_u) >> 8);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
uint64_t t_6;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_6 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
if (num_bits_6 == 24) {
t_6 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_6 += 8;
*scratch |= ((uint64_t)(num_bits_6));
}
}
v_u = t_6;
}
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 16);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
uint64_t t_7;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_7 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
if (num_bits_7 == 24) {
t_7 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_7 += 8;
*scratch |= ((uint64_t)(num_bits_7));
}
}
v_u = t_7;
}
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 40);
goto ok;
ok:
self->private_impl.p_decode_chrm[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_chrm[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_fctl
static wuffs_base__status
wuffs_png__decoder__decode_fctl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_x0 = 0;
uint32_t v_y0 = 0;
uint32_t v_x1 = 0;
uint32_t v_y1 = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_fctl[0];
if (coro_susp_point) {
v_x0 = self->private_data.s_decode_fctl[0].v_x0;
v_x1 = self->private_data.s_decode_fctl[0].v_x1;
v_y1 = self->private_data.s_decode_fctl[0].v_y1;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 26) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_x0 = t_0;
}
if (v_x0 != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
v_x1 = t_1;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
if (num_bits_2 == 24) {
t_2 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_2 += 8;
*scratch |= ((uint64_t)(num_bits_2));
}
}
v_y1 = t_2;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_x0 = t_3;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
uint32_t t_4;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_4 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
if (num_bits_4 == 24) {
t_4 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_4 += 8;
*scratch |= ((uint64_t)(num_bits_4));
}
}
v_y0 = t_4;
}
v_x1 += v_x0;
v_y1 += v_y0;
if ((v_x0 >= v_x1) ||
(v_x0 > self->private_impl.f_width) ||
(v_x1 > self->private_impl.f_width) ||
(v_y0 >= v_y1) ||
(v_y0 > self->private_impl.f_height) ||
(v_y1 > self->private_impl.f_height)) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_frame_rect_x0 = v_x0;
self->private_impl.f_frame_rect_y0 = v_y0;
self->private_impl.f_frame_rect_x1 = v_x1;
self->private_impl.f_frame_rect_y1 = v_y1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
uint32_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
t_5 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 8) {
t_5 = ((uint32_t)(*scratch >> 48));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5));
}
}
v_x0 = t_5;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
uint32_t t_6;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
t_6 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
if (num_bits_6 == 8) {
t_6 = ((uint32_t)(*scratch >> 48));
break;
}
num_bits_6 += 8;
*scratch |= ((uint64_t)(num_bits_6));
}
}
v_x1 = t_6;
}
if (v_x1 <= 0) {
self->private_impl.f_frame_duration = (((uint64_t)(v_x0)) * 7056000);
} else {
self->private_impl.f_frame_duration = ((((uint64_t)(v_x0)) * 705600000) / ((uint64_t)(v_x1)));
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_7 = *iop_a_src++;
v_x0 = t_7;
}
if (v_x0 == 0) {
self->private_impl.f_frame_disposal = 0;
} else if (v_x0 == 1) {
self->private_impl.f_frame_disposal = 1;
} else if (v_x0 == 2) {
self->private_impl.f_frame_disposal = 2;
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_8 = *iop_a_src++;
v_x0 = t_8;
}
if (v_x0 == 0) {
self->private_impl.f_frame_overwrite_instead_of_blend = true;
} else if (v_x0 == 1) {
self->private_impl.f_frame_overwrite_instead_of_blend = false;
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
self->private_impl.f_first_rect_x0 = self->private_impl.f_frame_rect_x0;
self->private_impl.f_first_rect_y0 = self->private_impl.f_frame_rect_y0;
self->private_impl.f_first_rect_x1 = self->private_impl.f_frame_rect_x1;
self->private_impl.f_first_rect_y1 = self->private_impl.f_frame_rect_y1;
self->private_impl.f_first_duration = self->private_impl.f_frame_duration;
self->private_impl.f_first_disposal = self->private_impl.f_frame_disposal;
self->private_impl.f_first_overwrite_instead_of_blend = self->private_impl.f_frame_overwrite_instead_of_blend;
}
goto ok;
ok:
self->private_impl.p_decode_fctl[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_fctl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_fctl[0].v_x0 = v_x0;
self->private_data.s_decode_fctl[0].v_x1 = v_x1;
self->private_data.s_decode_fctl[0].v_y1 = v_y1;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_gama
static wuffs_base__status
wuffs_png__decoder__decode_gama(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_gama[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 4) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
self->private_impl.f_metadata_flavor = 5;
self->private_impl.f_metadata_fourcc = 1195461953;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_gama[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_gama[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
self->private_impl.f_metadata_x = t_0;
}
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
goto ok;
ok:
self->private_impl.p_decode_gama[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_gama[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_iccp
static wuffs_base__status
wuffs_png__decoder__decode_iccp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_iccp[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_c = t_0;
}
if (v_c == 0) {
goto label__0__break;
}
}
label__0__break:;
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
v_c = t_1;
}
if (v_c != 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
self->private_impl.f_metadata_is_zlib_compressed = true;
self->private_impl.f_metadata_flavor = 4;
self->private_impl.f_metadata_fourcc = 1229144912;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
goto ok;
ok:
self->private_impl.p_decode_iccp[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_iccp[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_plte
static wuffs_base__status
@@ -37330,6 +39044,7 @@ wuffs_png__decoder__decode_plte(
goto exit;
}
v_num_entries = (((uint32_t)(self->private_impl.f_chunk_length)) / 3);
self->private_impl.f_chunk_length = 0;
while (v_i < v_num_entries) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
@@ -37396,6 +39111,67 @@ wuffs_png__decoder__decode_plte(
return status;
}
// -------- func png.decoder.decode_srgb
static wuffs_base__status
wuffs_png__decoder__decode_srgb(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_srgb[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 1) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
self->private_impl.f_metadata_flavor = 5;
self->private_impl.f_metadata_fourcc = 1397901122;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t t_0 = *iop_a_src++;
self->private_impl.f_metadata_x = t_0;
}
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
goto ok;
ok:
self->private_impl.p_decode_srgb[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_srgb[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_trns
static wuffs_base__status
@@ -37404,8 +39180,9 @@ wuffs_png__decoder__decode_trns(
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_num_entries = 0;
uint32_t v_i = 0;
uint32_t v_n = 0;
uint64_t v_u = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -37420,42 +39197,143 @@ wuffs_png__decoder__decode_trns(
uint32_t coro_susp_point = self->private_impl.p_decode_trns[0];
if (coro_susp_point) {
v_num_entries = self->private_data.s_decode_trns[0].v_num_entries;
v_i = self->private_data.s_decode_trns[0].v_i;
v_n = self->private_data.s_decode_trns[0].v_n;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length > 256) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
v_num_entries = ((uint32_t)(self->private_impl.f_chunk_length));
while (v_i < v_num_entries) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_0;
}
v_i += 1;
}
if (self->private_impl.f_color_type == 3) {
self->private_impl.f_dst_pixfmt = 2164523016;
self->private_impl.f_src_pixfmt = 2164523016;
} else {
if (self->private_impl.f_color_type == 0) {
self->private_impl.choosy_filter_and_swizzle = (
&wuffs_png__decoder__filter_and_swizzle_tricky);
if (self->private_impl.f_color_type == 0) {
self->private_impl.f_dst_pixfmt = 2164295816;
self->private_impl.f_src_pixfmt = 2164308923;
} else if (self->private_impl.f_color_type == 2) {
if (self->private_impl.f_depth <= 8) {
self->private_impl.f_dst_pixfmt = 2164295816;
self->private_impl.f_src_pixfmt = 2164295816;
} else {
self->private_impl.f_dst_pixfmt = 2164308923;
self->private_impl.f_src_pixfmt = 2164308923;
}
if (self->private_impl.f_chunk_length != 2) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
t_0 = ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2;
} else {
self->private_data.s_decode_trns[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 8) {
t_0 = ((uint64_t)(*scratch >> 48));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_u = t_0;
}
if (self->private_impl.f_depth <= 1) {
self->private_impl.f_remap_transparency = (((v_u & 1) * 16777215) | 4278190080);
} else if (self->private_impl.f_depth <= 2) {
self->private_impl.f_remap_transparency = (((v_u & 3) * 5592405) | 4278190080);
} else if (self->private_impl.f_depth <= 4) {
self->private_impl.f_remap_transparency = (((v_u & 15) * 1118481) | 4278190080);
} else if (self->private_impl.f_depth <= 8) {
self->private_impl.f_remap_transparency = (((v_u & 255) * 65793) | 4278190080);
} else {
self->private_impl.f_remap_transparency = ((v_u * 4295032833) | 18446462598732840960u);
}
} else if (self->private_impl.f_color_type == 2) {
self->private_impl.choosy_filter_and_swizzle = (
&wuffs_png__decoder__filter_and_swizzle_tricky);
if (self->private_impl.f_depth <= 8) {
self->private_impl.f_dst_pixfmt = 2164295816;
self->private_impl.f_src_pixfmt = 2164295816;
} else {
self->private_impl.f_dst_pixfmt = 2164308923;
self->private_impl.f_src_pixfmt = 2164308923;
}
if (self->private_impl.f_chunk_length != 6) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 6)) {
t_1 = ((uint64_t)(wuffs_base__peek_u48be__no_bounds_check(iop_a_src)));
iop_a_src += 6;
} else {
self->private_data.s_decode_trns[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 40) {
t_1 = ((uint64_t)(*scratch >> 16));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
v_u = t_1;
}
if (self->private_impl.f_depth <= 8) {
self->private_impl.f_remap_transparency = ((255 & (v_u >> 0)) |
(65280 & (v_u >> 8)) |
(16711680 & (v_u >> 16)) |
4278190080);
} else {
self->private_impl.f_remap_transparency = (v_u | 18446462598732840960u);
}
} else if (self->private_impl.f_color_type == 3) {
self->private_impl.f_dst_pixfmt = 2164523016;
self->private_impl.f_src_pixfmt = 2164523016;
if (self->private_impl.f_chunk_length > 256) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
v_n = ((uint32_t)(self->private_impl.f_chunk_length));
self->private_impl.f_chunk_length = 0;
while (v_i < v_n) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_2;
}
v_i += 1;
}
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
goto ok;
@@ -37467,8 +39345,8 @@ wuffs_png__decoder__decode_trns(
goto suspend;
suspend:
self->private_impl.p_decode_trns[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_trns[0].v_num_entries = v_num_entries;
self->private_data.s_decode_trns[0].v_i = v_i;
self->private_data.s_decode_trns[0].v_n = v_n;
goto exit;
exit:
@@ -37522,7 +39400,10 @@ wuffs_png__decoder__decode_frame_config(
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence < 3) {
if (self->private_impl.f_call_sequence == 255) {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else if (self->private_impl.f_call_sequence < 3) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
@@ -37535,37 +39416,155 @@ wuffs_png__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
} else if (self->private_impl.f_call_sequence == 4) {
self->private_impl.f_call_sequence = 255;
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_png__decoder__skip_frame(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (self->private_impl.f_call_sequence == 255) {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
}
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
self->private_impl.f_frame_rect_x0 = self->private_impl.f_first_rect_x0;
self->private_impl.f_frame_rect_y0 = self->private_impl.f_first_rect_y0;
self->private_impl.f_frame_rect_x1 = self->private_impl.f_first_rect_x1;
self->private_impl.f_frame_rect_y1 = self->private_impl.f_first_rect_y1;
self->private_impl.f_frame_config_io_position = self->private_impl.f_first_config_io_position;
self->private_impl.f_frame_duration = self->private_impl.f_first_duration;
self->private_impl.f_frame_disposal = self->private_impl.f_first_disposal;
self->private_impl.f_frame_overwrite_instead_of_blend = self->private_impl.f_first_overwrite_instead_of_blend;
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
while (true) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_frame_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
self->private_impl.f_chunk_length = t_0;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_frame_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
self->private_impl.f_chunk_type = t_1;
}
if (self->private_impl.f_chunk_type == 1413571686) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
} else if (self->private_impl.f_chunk_type == 1280598886) {
self->private_impl.f_frame_config_io_position = ((uint64_t)(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) - 8));
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_png__decoder__decode_fctl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_data.s_decode_frame_config[0].scratch = 4;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
goto label__0__break;
}
self->private_data.s_decode_frame_config[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
self->private_impl.f_chunk_length = 0;
}
label__0__break:;
}
if (a_dst != NULL) {
wuffs_base__frame_config__set(
a_dst,
wuffs_base__utility__make_rect_ie_u32(
0,
0,
self->private_impl.f_width,
self->private_impl.f_height),
((wuffs_base__flicks)(0)),
0,
self->private_impl.f_frame_rect_x0,
self->private_impl.f_frame_rect_y0,
self->private_impl.f_frame_rect_x1,
self->private_impl.f_frame_rect_y1),
((wuffs_base__flicks)(self->private_impl.f_frame_duration)),
((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value)),
self->private_impl.f_frame_config_io_position,
0,
false,
false,
self->private_impl.f_frame_disposal,
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns),
self->private_impl.f_frame_overwrite_instead_of_blend,
0);
}
wuffs_base__u32__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;
@@ -37588,6 +39587,162 @@ wuffs_png__decoder__decode_frame_config(
return status;
}
// -------- func png.decoder.skip_frame
static wuffs_base__status
wuffs_png__decoder__skip_frame(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_seq_num = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_skip_frame[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
self->private_impl.f_chunk_type_array[0] = 0;
self->private_impl.f_chunk_type_array[1] = 0;
self->private_impl.f_chunk_type_array[2] = 0;
self->private_impl.f_chunk_type_array[3] = 0;
label__0__continue:;
while (true) {
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
if (self->private_impl.f_chunk_type == 1413563465) {
if (self->private_impl.f_chunk_type_array[0] == 102) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 68;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
} else if (self->private_impl.f_chunk_type == 1413571686) {
if (self->private_impl.f_chunk_type_array[0] == 73) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_type_array[0] = 102;
self->private_impl.f_chunk_type_array[1] = 100;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
if (self->private_impl.f_chunk_length < 4) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 4;
iop_a_src += 8;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_skip_frame[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_skip_frame[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_seq_num = t_0;
}
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_skip_frame[0].scratch;
self->private_impl.f_chunk_length = 0;
goto label__0__continue;
} else if (self->private_impl.f_chunk_type_array[0] != 0) {
goto label__0__break;
} else if (self->private_impl.f_chunk_type == 1280598886) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_skip_frame[0].scratch;
self->private_impl.f_chunk_length = 0;
}
label__0__break:;
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
self->private_impl.f_call_sequence = 5;
} else {
self->private_impl.f_call_sequence = 255;
}
ok:
self->private_impl.p_skip_frame[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_skip_frame[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_frame
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
@@ -37619,25 +39774,138 @@ wuffs_png__decoder__decode_frame(
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_seq_num = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t v_pass_width = 0;
uint32_t v_pass_height = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_frame[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence < 4) {
if (self->private_impl.f_call_sequence == 255) {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else if (self->private_impl.f_call_sequence != 4) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_png__decoder__decode_frame_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 4) {
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
while (true) {
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
}
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
if (self->private_impl.f_chunk_type == 1413563465) {
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 68;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
iop_a_src += 8;
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
goto label__0__break;
} else if (self->private_impl.f_chunk_type == 1413571686) {
self->private_impl.f_chunk_type_array[0] = 102;
self->private_impl.f_chunk_type_array[1] = 100;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
if (self->private_impl.f_chunk_length < 4) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 4;
iop_a_src += 8;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_frame[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_frame[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_seq_num = t_0;
}
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
goto label__0__break;
} else if (self->private_impl.f_chunk_type == 1280598886) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_data.s_decode_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (self->private_data.s_decode_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_decode_frame[0].scratch;
self->private_impl.f_chunk_length = 0;
}
label__0__break:;
if (self->private_impl.f_zlib_is_dirty) {
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
if (self->private_impl.f_ignore_checksum) {
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
}
}
self->private_impl.f_zlib_is_dirty = true;
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
wuffs_base__pixel_buffer__pixel_format(a_dst),
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
@@ -37654,14 +39922,26 @@ wuffs_png__decoder__decode_frame(
}
goto ok;
}
self->private_impl.f_workbuf_hist_pos_base = 0;
while (true) {
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
if (self->private_impl.f_chunk_type_array[0] == 73) {
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
} else {
v_pass_width = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_x1 - self->private_impl.f_frame_rect_x0)));
v_pass_height = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_y1 - self->private_impl.f_frame_rect_y0)));
}
if ((v_pass_width > 0) && (v_pass_height > 0)) {
self->private_impl.f_pass_bytes_per_row = wuffs_png__decoder__calculate_bytes_per_row(self, v_pass_width);
self->private_impl.f_pass_workbuf_length = (((uint64_t)(v_pass_height)) * (1 + self->private_impl.f_pass_bytes_per_row));
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_png__decoder__decode_pass(self, a_src, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
@@ -37676,9 +39956,10 @@ wuffs_png__decoder__decode_frame(
}
goto ok;
}
self->private_impl.f_workbuf_hist_pos_base += self->private_impl.f_pass_workbuf_length;
}
if ((self->private_impl.f_interlace_pass == 0) || (self->private_impl.f_interlace_pass >= 7)) {
goto label__0__break;
goto label__1__break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
@@ -37689,10 +39970,14 @@ wuffs_png__decoder__decode_frame(
#pragma GCC diagnostic pop
#endif
}
label__0__break:;
self->private_impl.f_call_sequence = 255;
label__1__break:;
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
self->private_impl.f_call_sequence = 5;
} else {
self->private_impl.f_call_sequence = 255;
}
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -37705,6 +39990,10 @@ wuffs_png__decoder__decode_frame(
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
@@ -37731,6 +40020,7 @@ wuffs_png__decoder__decode_pass(
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
uint32_t v_checksum_have = 0;
uint32_t v_checksum_want = 0;
uint32_t v_seq_num = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -37744,9 +40034,6 @@ wuffs_png__decoder__decode_pass(
}
uint32_t coro_susp_point = self->private_impl.p_decode_pass[0];
if (coro_susp_point) {
v_checksum_have = self->private_data.s_decode_pass[0].v_checksum_have;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -37771,11 +40058,12 @@ wuffs_png__decoder__decode_pass(
&io2_v_w,
wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_workbuf_wi,
self->private_impl.f_pass_workbuf_length));
self->private_impl.f_pass_workbuf_length),
((uint64_t)(self->private_impl.f_workbuf_hist_pos_base + self->private_impl.f_workbuf_wi)));
{
const uint8_t *o_1_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
self->private_impl.f_chunk_length);
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
@@ -37796,7 +40084,7 @@ wuffs_png__decoder__decode_pass(
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
wuffs_base__u64__sat_sub_indirect(&self->private_impl.f_chunk_length, wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))));
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_workbuf_wi, wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w))));
io2_a_src = o_1_io2_a_src;
if (a_src) {
@@ -37810,41 +40098,41 @@ wuffs_png__decoder__decode_pass(
io2_v_w = o_0_io2_v_w;
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
if ( ! self->private_impl.f_ignore_checksum) {
if (self->private_impl.f_chunk_length > 0) {
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
goto exit;
}
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
if (self->private_impl.f_chunk_length > 0) {
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
v_checksum_want = t_1;
}
v_checksum_want = t_1;
}
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
if (v_checksum_have != v_checksum_want) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
@@ -37896,7 +40184,7 @@ wuffs_png__decoder__decode_pass(
}
v_checksum_want = t_2;
}
if ( ! self->private_impl.f_ignore_checksum) {
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
if (v_checksum_have != v_checksum_want) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
@@ -37905,9 +40193,9 @@ wuffs_png__decoder__decode_pass(
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint64_t t_3;
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
@@ -37923,7 +40211,7 @@ wuffs_png__decoder__decode_pass(
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint64_t)(*scratch >> 32));
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
@@ -37961,17 +40249,59 @@ wuffs_png__decoder__decode_pass(
}
self->private_impl.f_chunk_type = t_4;
}
if (self->private_impl.f_chunk_type != 1413563465) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 68;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
if (self->private_impl.f_chunk_type_array[0] == 73) {
if (self->private_impl.f_chunk_type != 1413563465) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
} else {
if ((self->private_impl.f_chunk_type != 1413571686) || (self->private_impl.f_chunk_length < 4)) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 4;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
uint32_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 24) {
t_5 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5));
}
}
v_seq_num = t_5;
}
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
}
goto label__0__continue;
} else if (((uint64_t)(io2_a_src - iop_a_src)) > 0) {
@@ -37979,7 +40309,7 @@ wuffs_png__decoder__decode_pass(
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
}
label__0__break:;
if (self->private_impl.f_workbuf_wi != self->private_impl.f_pass_workbuf_length) {
@@ -37991,7 +40321,6 @@ wuffs_png__decoder__decode_pass(
}
}
goto ok;
ok:
self->private_impl.p_decode_pass[0] = 0;
goto exit;
@@ -38000,7 +40329,6 @@ wuffs_png__decoder__decode_pass(
goto suspend;
suspend:
self->private_impl.p_decode_pass[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_pass[0].v_checksum_have = v_checksum_have;
goto exit;
exit:
@@ -38025,10 +40353,10 @@ wuffs_png__decoder__frame_dirty_rect(
}
return wuffs_base__utility__make_rect_ie_u32(
0,
0,
self->private_impl.f_width,
self->private_impl.f_height);
self->private_impl.f_frame_rect_x0,
self->private_impl.f_frame_rect_y0,
self->private_impl.f_frame_rect_x1,
self->private_impl.f_frame_rect_y1);
}
// -------- func png.decoder.num_animation_loops
@@ -38044,7 +40372,7 @@ wuffs_png__decoder__num_animation_loops(
return 0;
}
return 0;
return self->private_impl.f_num_animation_loops_value;
}
// -------- func png.decoder.num_decoded_frame_configs
@@ -38060,10 +40388,7 @@ wuffs_png__decoder__num_decoded_frame_configs(
return 0;
}
if (self->private_impl.f_call_sequence > 3) {
return 1;
}
return 0;
return ((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value));
}
// -------- func png.decoder.num_decoded_frames
@@ -38079,10 +40404,7 @@ wuffs_png__decoder__num_decoded_frames(
return 0;
}
if (self->private_impl.f_call_sequence > 4) {
return 1;
}
return 0;
return ((uint64_t)(self->private_impl.f_num_decoded_frames_value));
}
// -------- func png.decoder.restart_frame
@@ -38104,8 +40426,7 @@ wuffs_png__decoder__restart_frame(
if (self->private_impl.f_call_sequence < 3) {
return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
}
if (a_index != 0) {
} else if ((a_index >= ((uint64_t)(self->private_impl.f_num_animation_frames_value))) || ((a_index == 0) && (a_io_position != self->private_impl.f_first_config_io_position))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
self->private_impl.f_call_sequence = 3;
@@ -38113,6 +40434,8 @@ wuffs_png__decoder__restart_frame(
self->private_impl.f_interlace_pass = 1;
}
self->private_impl.f_frame_config_io_position = a_io_position;
self->private_impl.f_num_decoded_frame_configs_value = ((uint32_t)((a_index & 4294967295)));
self->private_impl.f_num_decoded_frames_value = self->private_impl.f_num_decoded_frame_configs_value;
return wuffs_base__make_status(NULL);
}
@@ -38123,6 +40446,24 @@ wuffs_png__decoder__set_report_metadata(
wuffs_png__decoder* self,
uint32_t a_fourcc,
bool a_report) {
if (!self) {
return wuffs_base__make_empty_struct();
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_empty_struct();
}
if (a_fourcc == 1128813133) {
self->private_impl.f_report_metadata_chrm = a_report;
} else if (a_fourcc == 1195461953) {
self->private_impl.f_report_metadata_gama = a_report;
} else if (a_fourcc == 1229144912) {
self->private_impl.f_report_metadata_iccp = a_report;
} else if (a_fourcc == 1263947808) {
self->private_impl.f_report_metadata_kvp = a_report;
} else if (a_fourcc == 1397901122) {
self->private_impl.f_report_metadata_srgb = a_report;
}
return wuffs_base__make_empty_struct();
}
@@ -38155,13 +40496,471 @@ wuffs_png__decoder__tell_me_more(
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
goto exit;
uint8_t v_c = 0;
uint16_t v_c2 = 0;
wuffs_base__io_buffer u_w = wuffs_base__empty_io_buffer();
wuffs_base__io_buffer* v_w = &u_w;
uint8_t* iop_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io0_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io1_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io2_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint64_t v_num_written = 0;
uint64_t v_w_mark = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
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;
}
uint32_t coro_susp_point = self->private_impl.p_tell_me_more[0];
if (coro_susp_point) {
v_zlib_status = self->private_data.s_tell_me_more[0].v_zlib_status;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 1) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
if (self->private_impl.f_metadata_fourcc == 0) {
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
goto exit;
}
if (self->private_impl.f_metadata_is_zlib_compressed) {
if (self->private_impl.f_zlib_is_dirty) {
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
if (self->private_impl.f_ignore_checksum) {
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
}
}
self->private_impl.f_zlib_is_dirty = true;
self->private_impl.f_ztxt_hist_pos = 0;
}
label__loop__continue:;
while (true) {
if (a_minfo != NULL) {
wuffs_base__more_information__set(a_minfo,
self->private_impl.f_metadata_flavor,
self->private_impl.f_metadata_fourcc,
self->private_impl.f_metadata_x,
self->private_impl.f_metadata_y,
self->private_impl.f_metadata_z);
}
if (self->private_impl.f_metadata_flavor != 4) {
goto label__loop__break;
}
if (self->private_impl.f_metadata_is_zlib_compressed) {
if (self->private_impl.f_chunk_type == 1346585449) {
{
const uint8_t *o_0_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
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));
}
wuffs_base__status t_0 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
v_zlib_status = t_0;
if (a_dst) {
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
}
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
self->private_impl.f_metadata_is_zlib_compressed = false;
goto label__loop__break;
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
status = v_zlib_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
status = v_zlib_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
} else if (self->private_impl.f_chunk_type == 1951945833) {
{
const uint8_t *o_1_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
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));
}
wuffs_base__status t_1 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
v_zlib_status = t_1;
if (a_dst) {
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
}
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
io2_a_src = o_1_io2_a_src;
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
self->private_impl.f_metadata_is_zlib_compressed = false;
goto label__loop__break;
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
status = v_zlib_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
status = v_zlib_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
} else if (self->private_impl.f_chunk_type == 1951945850) {
if (self->private_impl.f_ztxt_ri == self->private_impl.f_ztxt_wi) {
{
wuffs_base__io_buffer* o_2_v_w = v_w;
uint8_t *o_2_iop_v_w = iop_v_w;
uint8_t *o_2_io0_v_w = io0_v_w;
uint8_t *o_2_io1_v_w = io1_v_w;
uint8_t *o_2_io2_v_w = io2_v_w;
v_w = wuffs_base__io_writer__set(
&u_w,
&iop_v_w,
&io0_v_w,
&io1_v_w,
&io2_v_w,
wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024),
self->private_impl.f_ztxt_hist_pos);
{
const uint8_t *o_3_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
v_w_mark = ((uint64_t)(iop_v_w - io0_v_w));
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
u_w.meta.wi = ((size_t)(iop_v_w - u_w.data.ptr));
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, v_w, a_src, wuffs_base__utility__empty_slice_u8());
v_zlib_status = t_2;
iop_v_w = u_w.data.ptr + u_w.meta.wi;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
v_num_written = wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w)));
io2_a_src = o_3_io2_a_src;
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
v_w = o_2_v_w;
iop_v_w = o_2_iop_v_w;
io0_v_w = o_2_io0_v_w;
io1_v_w = o_2_io1_v_w;
io2_v_w = o_2_io2_v_w;
}
if (v_num_written > 1024) {
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_i_o);
goto exit;
}
self->private_impl.f_ztxt_ri = 0;
self->private_impl.f_ztxt_wi = ((uint32_t)(v_num_written));
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_ztxt_hist_pos, v_num_written);
}
while (self->private_impl.f_ztxt_ri < self->private_impl.f_ztxt_wi) {
v_c2 = WUFFS_PNG__LATIN_1[self->private_data.f_dst_palette[self->private_impl.f_ztxt_ri]];
if (v_c2 == 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
goto exit;
} else if (v_c2 <= 127) {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_ztxt_ri += 1;
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
} else {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_ztxt_ri += 1;
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
}
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
self->private_impl.f_metadata_is_zlib_compressed = false;
goto label__loop__break;
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
status = v_zlib_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if (v_zlib_status.repr != wuffs_base__suspension__short_write) {
status = v_zlib_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
} else {
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_chunk_type);
goto exit;
}
} else if ((self->private_impl.f_chunk_type == 1951945833) && (self->private_impl.f_metadata_fourcc == 1263947862)) {
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
goto label__loop__break;
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
goto label__loop__continue;
} else if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
goto label__loop__continue;
}
self->private_impl.f_chunk_length -= 1;
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1;
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_c), iop_a_dst += 1);
}
} else {
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
if (self->private_impl.f_metadata_fourcc == 1263947851) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
goto label__loop__break;
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
goto label__loop__continue;
}
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
if (v_c == 0) {
self->private_impl.f_chunk_length -= 1;
iop_a_src += 1;
goto label__loop__break;
}
v_c2 = WUFFS_PNG__LATIN_1[v_c];
if (v_c2 == 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
goto exit;
} else if (v_c2 <= 127) {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_chunk_length -= 1;
iop_a_src += 1;
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
} else {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_chunk_length -= 1;
iop_a_src += 1;
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
}
}
}
}
label__loop__break:;
if (self->private_impl.f_metadata_fourcc == 1263947851) {
self->private_impl.f_metadata_fourcc = 1263947862;
if (self->private_impl.f_chunk_type == 1951945833) {
if (self->private_impl.f_chunk_length <= 1) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 2;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
v_c = t_3;
}
if (v_c == 0) {
self->private_impl.f_metadata_is_zlib_compressed = false;
} else if (v_c == 1) {
self->private_impl.f_metadata_is_zlib_compressed = true;
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
v_c = t_4;
}
if ((v_c != 0) && self->private_impl.f_metadata_is_zlib_compressed) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
self->private_impl.f_metadata_fourcc -= 2;
while (self->private_impl.f_metadata_fourcc != 1263947862) {
self->private_impl.f_metadata_fourcc += 1;
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_5 = *iop_a_src++;
v_c = t_5;
}
if (v_c == 0) {
goto label__0__break;
}
}
label__0__break:;
}
} else if (self->private_impl.f_chunk_type == 1951945850) {
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_6 = *iop_a_src++;
v_c = t_6;
}
if (v_c != 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
self->private_impl.f_metadata_is_zlib_compressed = true;
}
} else {
if (self->private_impl.f_chunk_length != 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_data.s_tell_me_more[0].scratch = 4;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
if (self->private_data.s_tell_me_more[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_tell_me_more[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_tell_me_more[0].scratch;
self->private_impl.f_metadata_flavor = 0;
self->private_impl.f_metadata_fourcc = 0;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
}
self->private_impl.f_call_sequence = 2;
status = wuffs_base__make_status(NULL);
goto ok;
ok:
self->private_impl.p_tell_me_more[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_tell_me_more[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 4 : 0;
self->private_data.s_tell_me_more[0].v_zlib_status = v_zlib_status;
goto ok;
ok:
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));
}
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
@@ -38202,7 +41001,8 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0;
uint64_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_bytes_per_row = 0;
uint64_t v_dst_bytes_per_row0 = 0;
uint64_t v_dst_bytes_per_row1 = 0;
wuffs_base__slice_u8 v_dst_palette = {0};
wuffs_base__table_u8 v_tab = {0};
uint32_t v_y = 0;
@@ -38217,14 +41017,33 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
v_dst_bytes_per_row0 = (((uint64_t)(self->private_impl.f_frame_rect_x0)) * v_dst_bytes_per_pixel);
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
while (v_y < self->private_impl.f_height) {
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
if (v_dst_bytes_per_row1 < ((uint64_t)(v_tab.width))) {
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
0,
0,
v_dst_bytes_per_row1,
((uint64_t)(v_tab.height)));
}
if (v_dst_bytes_per_row0 < ((uint64_t)(v_tab.width))) {
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
v_dst_bytes_per_row0,
0,
((uint64_t)(v_tab.width)),
((uint64_t)(v_tab.height)));
} else {
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
0,
0,
0,
0);
}
v_y = self->private_impl.f_frame_rect_y0;
while (v_y < self->private_impl.f_frame_rect_y1) {
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
if (1 > ((uint64_t)(a_workbuf.len))) {
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
}
@@ -38264,7 +41083,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0;
uint64_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_bytes_per_row = 0;
uint64_t v_dst_bytes_per_row1 = 0;
wuffs_base__slice_u8 v_dst_palette = {0};
wuffs_base__table_u8 v_tab = {0};
uint64_t v_src_bytes_per_pixel = 0;
@@ -38288,26 +41107,22 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
v_src_bytes_per_pixel = 1;
if (self->private_impl.f_depth >= 8) {
v_src_bytes_per_pixel = (((uint64_t)(WUFFS_PNG__NUM_CHANNELS[self->private_impl.f_color_type])) * ((uint64_t)((self->private_impl.f_depth >> 3))));
}
v_bits_unpacked[0] = 255;
v_bits_unpacked[1] = 255;
v_bits_unpacked[2] = 255;
v_bits_unpacked[3] = 255;
v_bits_unpacked[4] = 255;
v_bits_unpacked[5] = 255;
v_bits_unpacked[6] = 255;
v_bits_unpacked[7] = 255;
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
while (v_y < self->private_impl.f_height) {
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
if (self->private_impl.f_chunk_type_array[0] == 73) {
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
} else {
v_y = self->private_impl.f_frame_rect_y0;
}
while (v_y < self->private_impl.f_frame_rect_y1) {
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
if (v_dst_bytes_per_row1 < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row1);
}
if (1 > ((uint64_t)(a_workbuf.len))) {
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
@@ -38332,9 +41147,13 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
return wuffs_base__make_status(wuffs_png__error__bad_filter);
}
v_s = v_curr_row;
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
if (self->private_impl.f_chunk_type_array[0] == 73) {
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
} else {
v_x = self->private_impl.f_frame_rect_x0;
}
if (self->private_impl.f_depth == 8) {
while (v_x < self->private_impl.f_width) {
while (v_x < self->private_impl.f_frame_rect_x1) {
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
if (v_i <= ((uint64_t)(v_dst.len))) {
if (self->private_impl.f_color_type == 4) {
@@ -38346,6 +41165,44 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
}
} else if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
if (self->private_impl.f_color_type == 0) {
if (1 <= ((uint64_t)(v_s.len))) {
v_bits_unpacked[0] = v_s.ptr[0];
v_bits_unpacked[1] = v_s.ptr[0];
v_bits_unpacked[2] = v_s.ptr[0];
v_bits_unpacked[3] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 1);
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
(((uint32_t)(v_bits_unpacked[1])) << 8) |
(((uint32_t)(v_bits_unpacked[2])) << 16) |
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
}
} else {
if (3 <= ((uint64_t)(v_s.len))) {
v_bits_unpacked[0] = v_s.ptr[2];
v_bits_unpacked[1] = v_s.ptr[1];
v_bits_unpacked[2] = v_s.ptr[0];
v_bits_unpacked[3] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 3);
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
(((uint32_t)(v_bits_unpacked[1])) << 8) |
(((uint32_t)(v_bits_unpacked[2])) << 16) |
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
}
}
} else if (v_src_bytes_per_pixel <= ((uint64_t)(v_s.len))) {
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__slice_u8__subslice_j(v_s, v_src_bytes_per_pixel));
v_s = wuffs_base__slice_u8__subslice_i(v_s, v_src_bytes_per_pixel);
@@ -38360,7 +41217,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
}
v_shift = ((8 - self->private_impl.f_depth) & 7);
v_packs_remaining = 0;
while (v_x < self->private_impl.f_width) {
while (v_x < self->private_impl.f_frame_rect_x1) {
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
if (v_i <= ((uint64_t)(v_dst.len))) {
if ((v_packs_remaining == 0) && (1 <= ((uint64_t)(v_s.len)))) {
@@ -38371,12 +41228,28 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_bits_unpacked[0] = ((uint8_t)((v_bits_packed >> v_shift) * v_multiplier));
v_bits_packed = ((uint8_t)(v_bits_packed << self->private_impl.f_depth));
v_packs_remaining = ((uint8_t)(v_packs_remaining - 1));
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
v_bits_unpacked[1] = v_bits_unpacked[0];
v_bits_unpacked[2] = v_bits_unpacked[0];
v_bits_unpacked[3] = 255;
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
(((uint32_t)(v_bits_unpacked[1])) << 8) |
(((uint32_t)(v_bits_unpacked[2])) << 16) |
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
} else {
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
}
}
v_x += (((uint32_t)(1)) << WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]);
}
} else {
while (v_x < self->private_impl.f_width) {
while (v_x < self->private_impl.f_frame_rect_x1) {
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
if (v_i <= ((uint64_t)(v_dst.len))) {
if (self->private_impl.f_color_type == 0) {
@@ -38387,7 +41260,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_bits_unpacked[3] = v_s.ptr[0];
v_bits_unpacked[4] = v_s.ptr[1];
v_bits_unpacked[5] = v_s.ptr[0];
v_bits_unpacked[6] = 255;
v_bits_unpacked[7] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
(((uint64_t)(v_bits_unpacked[1])) << 8) |
(((uint64_t)(v_bits_unpacked[2])) << 16) |
(((uint64_t)(v_bits_unpacked[3])) << 24) |
(((uint64_t)(v_bits_unpacked[4])) << 32) |
(((uint64_t)(v_bits_unpacked[5])) << 40) |
(((uint64_t)(v_bits_unpacked[6])) << 48) |
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
v_bits_unpacked[4] = 0;
v_bits_unpacked[5] = 0;
v_bits_unpacked[6] = 0;
v_bits_unpacked[7] = 0;
}
}
} else if (self->private_impl.f_color_type == 2) {
if (6 <= ((uint64_t)(v_s.len))) {
@@ -38397,7 +41289,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_bits_unpacked[3] = v_s.ptr[2];
v_bits_unpacked[4] = v_s.ptr[1];
v_bits_unpacked[5] = v_s.ptr[0];
v_bits_unpacked[6] = 255;
v_bits_unpacked[7] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 6);
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
(((uint64_t)(v_bits_unpacked[1])) << 8) |
(((uint64_t)(v_bits_unpacked[2])) << 16) |
(((uint64_t)(v_bits_unpacked[3])) << 24) |
(((uint64_t)(v_bits_unpacked[4])) << 32) |
(((uint64_t)(v_bits_unpacked[5])) << 40) |
(((uint64_t)(v_bits_unpacked[6])) << 48) |
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
v_bits_unpacked[4] = 0;
v_bits_unpacked[5] = 0;
v_bits_unpacked[6] = 0;
v_bits_unpacked[7] = 0;
}
}
} else if (self->private_impl.f_color_type == 4) {
if (4 <= ((uint64_t)(v_s.len))) {
@@ -38671,7 +41582,7 @@ wuffs_wbmp__decoder__decode_image_config(
}
v_i += 1;
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if (a_dst != NULL) {
wuffs_base__image_config__set(
a_dst,
@@ -38765,7 +41676,7 @@ wuffs_wbmp__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
@@ -38795,7 +41706,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;
@@ -38926,7 +41836,7 @@ wuffs_wbmp__decoder__decode_frame(
if (self->private_impl.f_width > 0) {
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
while (v_dst_y < self->private_impl.f_height) {
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
v_dst_x = 0;
while (v_dst_x < self->private_impl.f_width) {
if ((v_dst_x & 7) == 0) {
@@ -38934,7 +41844,7 @@ wuffs_wbmp__decoder__decode_frame(
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
v_dst_x_in_bytes = (((uint64_t)(v_dst_x)) * v_dst_bytes_per_pixel);
if (v_dst_x_in_bytes <= ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_dst_x_in_bytes);
@@ -38960,7 +41870,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;
@@ -39175,6 +42084,71 @@ namespace sync_io {
// --------
DynIOBuffer::DynIOBuffer(uint64_t max_incl)
: m_buf(wuffs_base__empty_io_buffer()), m_max_incl(max_incl) {}
DynIOBuffer::~DynIOBuffer() {
if (m_buf.data.ptr) {
free(m_buf.data.ptr);
}
}
void //
DynIOBuffer::drop() {
if (m_buf.data.ptr) {
free(m_buf.data.ptr);
}
m_buf = wuffs_base__empty_io_buffer();
}
DynIOBuffer::GrowResult //
DynIOBuffer::grow(uint64_t min_incl) {
uint64_t n = round_up(min_incl, m_max_incl);
if (n == 0) {
return ((min_incl == 0) && (m_max_incl == 0))
? DynIOBuffer::GrowResult::OK
: DynIOBuffer::GrowResult::FailedMaxInclExceeded;
} else if (n > m_buf.data.len) {
uint8_t* ptr = static_cast<uint8_t*>(realloc(m_buf.data.ptr, n));
if (!ptr) {
return DynIOBuffer::GrowResult::FailedOutOfMemory;
}
m_buf.data.ptr = ptr;
m_buf.data.len = n;
}
return DynIOBuffer::GrowResult::OK;
}
// round_up rounds min_incl up, returning the smallest value x satisfying
// (min_incl <= x) and (x <= max_incl) and some other constraints. It returns 0
// if there is no such x.
//
// When max_incl <= 4096, the other constraints are:
// - (x == max_incl)
//
// When max_incl > 4096, the other constraints are:
// - (x == max_incl) or (x is a power of 2)
// - (x >= 4096)
uint64_t //
DynIOBuffer::round_up(uint64_t min_incl, uint64_t max_incl) {
if (min_incl > max_incl) {
return 0;
}
uint64_t n = 4096;
if (n >= max_incl) {
return max_incl;
}
while (n < min_incl) {
if (n >= (max_incl / 2)) {
return max_incl;
}
n *= 2;
}
return n;
}
// --------
Input::~Input() {}
IOBuffer* //
@@ -39249,6 +42223,164 @@ MemoryInput::CopyIn(IOBuffer* dst) {
} // namespace sync_io
namespace private_impl {
struct ErrorMessages {
const char* max_incl_metadata_length_exceeded;
const char* out_of_memory;
const char* unexpected_end_of_file;
const char* unsupported_metadata;
const char* unsupported_negative_advance;
// If adding new "const char*" typed fields to this struct, either add them
// after existing fields or, if re-ordering fields, make sure that you update
// all of the "const private_impl::ErrorMessages FooBarErrorMessages" values
// in all of the sibling *.cc files.
static inline const char* resolve(const char* s) {
return s ? s : "wuffs_aux::private_impl: unknown error";
};
};
std::string //
AdvanceIOBufferTo(const ErrorMessages& error_messages,
sync_io::Input& input,
IOBuffer& io_buf,
uint64_t absolute_position) {
if (absolute_position < io_buf.reader_position()) {
return error_messages.resolve(error_messages.unsupported_negative_advance);
}
while (true) {
uint64_t relative_position = absolute_position - io_buf.reader_position();
if (relative_position <= io_buf.reader_length()) {
io_buf.meta.ri += (size_t)relative_position;
break;
} else if (io_buf.meta.closed) {
return error_messages.resolve(error_messages.unexpected_end_of_file);
}
io_buf.meta.ri = io_buf.meta.wi;
if (!input.BringsItsOwnIOBuffer()) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
return "";
}
std::string //
HandleMetadata(
const ErrorMessages& error_messages,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
sync_io::DynIOBuffer& raw,
wuffs_base__status (*tell_me_more_func)(void*,
wuffs_base__io_buffer*,
wuffs_base__more_information*,
wuffs_base__io_buffer*),
void* tell_me_more_receiver,
std::string (*handle_metadata_func)(void*,
const wuffs_base__more_information*,
wuffs_base__slice_u8),
void* handle_metadata_receiver) {
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
// Reset raw but keep its backing array (the raw.m_buf.data slice).
raw.m_buf.meta = wuffs_base__empty_io_buffer_meta();
while (true) {
minfo = wuffs_base__empty_more_information();
wuffs_base__status status = (*tell_me_more_func)(
tell_me_more_receiver, &raw.m_buf, &minfo, &io_buf);
switch (minfo.flavor) {
case 0:
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM:
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED:
break;
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH: {
wuffs_base__range_ie_u64 r = minfo.metadata_raw_passthrough__range();
if (r.is_empty()) {
break;
}
uint64_t num_to_copy = r.length();
if (num_to_copy > (raw.m_max_incl - raw.m_buf.meta.wi)) {
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
} else if (num_to_copy > (raw.m_buf.data.len - raw.m_buf.meta.wi)) {
switch (raw.grow(num_to_copy + raw.m_buf.meta.wi)) {
case sync_io::DynIOBuffer::GrowResult::OK:
break;
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
return error_messages.resolve(error_messages.out_of_memory);
}
}
if (io_buf.reader_position() > r.min_incl) {
return error_messages.resolve(error_messages.unsupported_metadata);
} else {
std::string error_message =
AdvanceIOBufferTo(error_messages, input, io_buf, r.min_incl);
if (!error_message.empty()) {
return error_message;
}
}
while (true) {
uint64_t n =
wuffs_base__u64__min(num_to_copy, io_buf.reader_length());
memcpy(raw.m_buf.writer_pointer(), io_buf.reader_pointer(), n);
raw.m_buf.meta.wi += n;
io_buf.meta.ri += n;
num_to_copy -= n;
if (num_to_copy == 0) {
break;
} else if (io_buf.meta.closed) {
return error_messages.resolve(
error_messages.unexpected_end_of_file);
} else if (!input.BringsItsOwnIOBuffer()) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
break;
}
default:
return error_messages.resolve(error_messages.unsupported_metadata);
}
if (status.repr == nullptr) {
break;
} else if (status.repr != wuffs_base__suspension__even_more_information) {
if (status.repr != wuffs_base__suspension__short_write) {
return status.message();
}
switch (raw.grow(wuffs_base__u64__sat_add(raw.m_buf.data.len, 1))) {
case sync_io::DynIOBuffer::GrowResult::OK:
break;
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
return error_messages.resolve(error_messages.out_of_memory);
}
}
}
return (*handle_metadata_func)(handle_metadata_receiver, &minfo,
raw.m_buf.reader_slice());
}
} // namespace private_impl
} // namespace wuffs_aux
#endif // !defined(WUFFS_CONFIG__MODULES) ||
@@ -39274,10 +42406,21 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeCborArgQuirks //
DecodeCborArgQuirks::DefaultValue() {
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks) {
DecodeCborArgQuirks quirks) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
@@ -39297,11 +42440,11 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
// Prepare the low-level CBOR decoder.
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
if (!dec) {
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
goto done;
}
for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
for (size_t i = 0; i < quirks.repr.len; i++) {
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
}
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
@@ -39312,7 +42455,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
// Prepare other state.
uint32_t depth = 0;
int32_t depth = 0;
std::string str;
int64_t extension_category = 0;
uint64_t extension_detail = 0;
@@ -39339,17 +42482,17 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
goto done;
} else if (cursor_index != io_buf->meta.ri) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
"wuffs_aux::DecodeCbor: internal error: bad cursor_index";
goto done;
} else if (io_buf->meta.closed) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
"wuffs_aux::DecodeCbor: 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::CborDecoder: internal error: io_buf is full";
"wuffs_aux::DecodeCbor: internal error: io_buf is full";
goto done;
}
cursor_index = io_buf->meta.ri;
@@ -39361,11 +42504,19 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
"wuffs_aux::DecodeCbor: 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);
if ((tok_buf.meta.ri > tok_buf.meta.wi) ||
(tok_buf.meta.wi > tok_buf.data.len) ||
(io_buf->meta.ri > io_buf->meta.wi) ||
(io_buf->meta.wi > io_buf->data.len)) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad buffer indexes";
goto done;
}
}
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
@@ -39373,7 +42524,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
if ((io_buf->meta.ri < cursor_index) ||
((io_buf->meta.ri - cursor_index) < token_len)) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad token indexes";
"wuffs_aux::DecodeCbor: internal error: bad token indexes";
goto done;
}
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
@@ -39409,7 +42560,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
}
}
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad extended token";
"wuffs_aux::DecodeCbor: internal error: bad extended token";
goto done;
}
@@ -39424,10 +42575,20 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
goto done;
}
depth++;
if (depth > WUFFS_CBOR__DECODER_DEPTH_MAX_INCL) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad depth";
goto done;
}
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
if (depth < 0) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad depth";
goto done;
}
goto parsed_a_value;
}
@@ -39564,7 +42725,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
fail:
ret_error_message =
"wuffs_aux::CborDecoder: internal error: unexpected token";
"wuffs_aux::DecodeCbor: internal error: unexpected token";
goto done;
parsed_a_value:
@@ -39668,6 +42829,12 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
}
std::string //
DecodeImageCallbacks::HandleMetadata(const wuffs_base__more_information& minfo,
wuffs_base__slice_u8 raw) {
return "";
}
wuffs_base__pixel_format //
DecodeImageCallbacks::SelectPixfmt(
const wuffs_base__image_config& image_config) {
@@ -39732,12 +42899,16 @@ const char DecodeImage_BufferIsTooShort[] = //
"wuffs_aux::DecodeImage: buffer is too short";
const char DecodeImage_MaxInclDimensionExceeded[] = //
"wuffs_aux::DecodeImage: max_incl_dimension exceeded";
const char DecodeImage_MaxInclMetadataLengthExceeded[] = //
"wuffs_aux::DecodeImage: max_incl_metadata_length exceeded";
const char DecodeImage_OutOfMemory[] = //
"wuffs_aux::DecodeImage: out of memory";
const char DecodeImage_UnexpectedEndOfFile[] = //
"wuffs_aux::DecodeImage: unexpected end of file";
const char DecodeImage_UnsupportedImageFormat[] = //
"wuffs_aux::DecodeImage: unsupported image format";
const char DecodeImage_UnsupportedMetadata[] = //
"wuffs_aux::DecodeImage: unsupported metadata";
const char DecodeImage_UnsupportedPixelBlend[] = //
"wuffs_aux::DecodeImage: unsupported pixel blend";
const char DecodeImage_UnsupportedPixelConfiguration[] = //
@@ -39745,38 +42916,105 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
const char DecodeImage_UnsupportedPixelFormat[] = //
"wuffs_aux::DecodeImage: unsupported pixel format";
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeImageArgQuirks //
DecodeImageArgQuirks::DefaultValue() {
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
DecodeImageArgFlags //
DecodeImageArgFlags::DefaultValue() {
return DecodeImageArgFlags(0);
}
DecodeImageArgPixelBlend::DecodeImageArgPixelBlend(
wuffs_base__pixel_blend repr0)
: repr(repr0) {}
DecodeImageArgPixelBlend //
DecodeImageArgPixelBlend::DefaultValue() {
return DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC);
}
DecodeImageArgBackgroundColor::DecodeImageArgBackgroundColor(
wuffs_base__color_u32_argb_premul repr0)
: repr(repr0) {}
DecodeImageArgBackgroundColor //
DecodeImageArgBackgroundColor::DefaultValue() {
return DecodeImageArgBackgroundColor(1);
}
DecodeImageArgMaxInclDimension::DecodeImageArgMaxInclDimension(uint32_t repr0)
: repr(repr0) {}
DecodeImageArgMaxInclDimension //
DecodeImageArgMaxInclDimension::DefaultValue() {
return DecodeImageArgMaxInclDimension(1048575);
}
DecodeImageArgMaxInclMetadataLength::DecodeImageArgMaxInclMetadataLength(
uint64_t repr0)
: repr(repr0) {}
DecodeImageArgMaxInclMetadataLength //
DecodeImageArgMaxInclMetadataLength::DefaultValue() {
return DecodeImageArgMaxInclMetadataLength(16777215);
}
// --------
namespace {
const private_impl::ErrorMessages DecodeImageErrorMessages = {
DecodeImage_MaxInclMetadataLengthExceeded, //
DecodeImage_OutOfMemory, //
DecodeImage_UnexpectedEndOfFile, //
DecodeImage_UnsupportedMetadata, //
DecodeImage_UnsupportedImageFormat, //
};
std::string //
DecodeImageAdvanceIOBuf(sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
bool compactable,
uint64_t min_excl_pos,
uint64_t pos) {
if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {
// Redirects must go forward.
return DecodeImage_UnsupportedImageFormat;
}
while (true) {
uint64_t relative_pos = pos - io_buf.reader_position();
if (relative_pos <= io_buf.reader_length()) {
io_buf.meta.ri += (size_t)relative_pos;
break;
} else if (io_buf.meta.closed) {
return DecodeImage_UnexpectedEndOfFile;
}
io_buf.meta.ri = io_buf.meta.wi;
if (compactable) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
return "";
DecodeImageAdvanceIOBufferTo(sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
uint64_t absolute_position) {
return private_impl::AdvanceIOBufferTo(DecodeImageErrorMessages, input,
io_buf, absolute_position);
}
wuffs_base__status //
DIHM0(void* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src) {
return wuffs_base__image_decoder__tell_me_more(
static_cast<wuffs_base__image_decoder*>(self), a_dst, a_minfo, a_src);
}
std::string //
DIHM1(void* self,
const wuffs_base__more_information* minfo,
wuffs_base__slice_u8 raw) {
return static_cast<DecodeImageCallbacks*>(self)->HandleMetadata(*minfo, raw);
}
std::string //
DecodeImageHandleMetadata(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
sync_io::DynIOBuffer& raw_metadata_buf) {
return private_impl::HandleMetadata(DecodeImageErrorMessages, input, io_buf,
raw_metadata_buf, DIHM0,
static_cast<void*>(image_decoder.get()),
DIHM1, static_cast<void*>(&callbacks));
}
DecodeImageResult //
@@ -39784,9 +43022,12 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
wuffs_base__slice_u32 quirks,
uint64_t flags,
wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color,
uint32_t max_incl_dimension) {
uint32_t max_incl_dimension,
uint64_t max_incl_metadata_length) {
// Check args.
switch (pixel_blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -39797,6 +43038,7 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
}
wuffs_base__image_config image_config = wuffs_base__null_image_config();
sync_io::DynIOBuffer raw_metadata_buf(max_incl_metadata_length);
uint64_t start_pos = io_buf.reader_position();
bool redirected = false;
int32_t fourcc = 0;
@@ -39831,8 +43073,12 @@ redirect:
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
uint64_t pos = minfo.io_redirect__range().min_incl;
std::string error_message = DecodeImageAdvanceIOBuf(
input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);
if (pos <= start_pos) {
// Redirects must go forward.
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
std::string error_message =
DecodeImageAdvanceIOBufferTo(input, io_buf, pos);
if (!error_message.empty()) {
return DecodeImageResult(std::move(error_message));
}
@@ -39851,6 +43097,33 @@ redirect:
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
// Apply quirks.
for (size_t i = 0; i < quirks.len; i++) {
image_decoder->set_quirk_enabled(quirks.ptr[i], true);
}
// Apply flags.
if (flags != 0) {
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_GAMA) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__GAMA, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_ICCP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_KVP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__KVP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_SRGB) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__SRGB, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_XMP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__XMP, true);
}
}
// Decode the image config.
while (true) {
wuffs_base__status id_dic_status =
@@ -39863,6 +43136,12 @@ redirect:
}
redirected = true;
goto redirect;
} else if (id_dic_status.repr == wuffs_base__note__metadata_reported) {
std::string error_message = DecodeImageHandleMetadata(
image_decoder, callbacks, input, io_buf, raw_metadata_buf);
if (!error_message.empty()) {
return DecodeImageResult(std::move(error_message));
}
} else if (id_dic_status.repr != wuffs_base__suspension__short_read) {
return DecodeImageResult(id_dic_status.message());
} else if (io_buf.meta.closed) {
@@ -39875,6 +43154,7 @@ redirect:
}
}
} while (false);
raw_metadata_buf.drop();
// Select the pixel format.
uint32_t w = image_config.pixcfg.width();
@@ -39985,9 +43265,12 @@ redirect:
DecodeImageResult //
DecodeImage(DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color,
uint32_t max_incl_dimension) {
DecodeImageArgQuirks quirks,
DecodeImageArgFlags flags,
DecodeImageArgPixelBlend pixel_blend,
DecodeImageArgBackgroundColor background_color,
DecodeImageArgMaxInclDimension max_incl_dimension,
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length) {
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
@@ -40000,8 +43283,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
DecodeImageResult result =
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
background_color, max_incl_dimension);
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
flags.repr, pixel_blend.repr, background_color.repr,
max_incl_dimension.repr, max_incl_metadata_length.repr);
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
return result;
}
@@ -40031,60 +43315,84 @@ DecodeJsonCallbacks::Done(DecodeJsonResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
const char DecodeJson_BadJsonPointer[] =
const char DecodeJson_BadJsonPointer[] = //
"wuffs_aux::DecodeJson: bad JSON Pointer";
const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
const char DecodeJson_NoMatch[] = //
"wuffs_aux::DecodeJson: no match";
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeJsonArgQuirks //
DecodeJsonArgQuirks::DefaultValue() {
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
: repr(repr0) {}
DecodeJsonArgJsonPointer //
DecodeJsonArgJsonPointer::DefaultValue() {
return DecodeJsonArgJsonPointer(std::string());
}
// --------
#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()); \
if ((tok_buf.meta.ri > tok_buf.meta.wi) || \
(tok_buf.meta.wi > tok_buf.data.len) || \
(io_buf->meta.ri > io_buf->meta.wi) || \
(io_buf->meta.wi > io_buf->data.len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \
goto done; \
} \
} \
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)
// --------
@@ -40092,7 +43400,8 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
namespace {
// DecodeJson_SplitJsonPointer returns ("bar", 8) for ("/foo/bar/b~1z/qux", 5,
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax or i is
// out of bounds.
//
// The string returned is unescaped. If calling it again, this time with i=8,
// the "b~1z" substring would be returned as "b/z".
@@ -40101,6 +43410,9 @@ DecodeJson_SplitJsonPointer(std::string& s,
size_t i,
bool allow_tilde_n_tilde_r_tilde_t) {
std::string fragment;
if (i > s.size()) {
return std::make_pair(std::string(), 0);
}
while (i < s.size()) {
char c = s[i];
if (c == '/') {
@@ -40307,8 +43619,8 @@ check_that_a_value_follows:
continue;
}
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that
// we're only peeking at the next token.
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so
// that we're only peeking at the next token.
tok_buf.meta.ri--;
cursor_index -= static_cast<size_t>(token_len);
@@ -40332,8 +43644,8 @@ done:
DecodeJsonResult //
DecodeJson(DecodeJsonCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks,
std::string json_pointer) {
DecodeJsonArgQuirks quirks,
DecodeJsonArgJsonPointer json_pointer) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
@@ -40355,11 +43667,15 @@ 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++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
if (quirks.ptr[i] ==
for (size_t i = 0; i < quirks.repr.len; i++) {
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
if (quirks.repr.ptr[i] ==
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
allow_tilde_n_tilde_r_tilde_t = true;
}
@@ -40370,21 +43686,22 @@ 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;
int32_t depth = 0;
std::string str;
// Walk the (optional) JSON Pointer.
for (size_t i = 0; i < json_pointer.size();) {
if (json_pointer[i] != '/') {
for (size_t i = 0; i < json_pointer.repr.size();) {
if (json_pointer.repr[i] != '/') {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
}
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);
json_pointer.repr, i + 1, allow_tilde_n_tilde_r_tilde_t);
i = split.second;
if (i == 0) {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
@@ -40416,10 +43733,20 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done;
}
depth++;
if (depth > WUFFS_JSON__DECODER_DEPTH_MAX_INCL) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad depth";
goto done;
}
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
if (depth < 0) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad depth";
goto done;
}
goto parsed_a_value;
}
@@ -40519,7 +43846,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.repr.empty())) {
goto done;
}
}
@@ -40546,6 +43888,8 @@ done:
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#endif
#endif // WUFFS_INCLUDE_GUARD
+4072 -728
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.
@@ -40,13 +54,14 @@
#include <stdlib.h>
#include <string.h>
// Note that Clang also defines __GNUC__.
#ifdef __cplusplus
#if (__cplusplus >= 201103L) || defined(_MSC_VER)
#include <memory>
#define WUFFS_BASE__HAVE_EQ_DELETE
#define WUFFS_BASE__HAVE_UNIQUE_PTR
#elif defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#elif defined(__GNUC__) || defined(__clang__)
#warning "Wuffs' C++ code expects -std=c++11 or later"
#endif
@@ -70,15 +85,15 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// 91857f4c4b827a2dcac7982ef03db1767ef72e23 committed on 2021-06-24.
// 161e4730d8b446a72d6152b8343da8543e7518bf committed on 2021-11-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.2"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3048
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20210624
#define WUFFS_VERSION_STRING "0.3.0-beta.2+3048.20210624"
#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.11"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3198
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20211118
#define WUFFS_VERSION_STRING "0.3.0-beta.11+3198.20211118"
// ---------------- Configuration
@@ -118,15 +133,18 @@ extern "C" {
// POPCNT. This is checked at runtime via cpuid, not at compile time.
//
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
#if defined(__x86_64__) && !defined(__native_client__)
#if defined(__i386__) || defined(__x86_64__)
#if !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__) && !defined(__native_client__)
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#endif // !defined(__native_client__)
#endif // defined(__i386__) || defined(__x86_64__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_X64)
#if defined(_M_IX86) || defined(_M_X64)
#if defined(__AVX__) || defined(__clang__)
// We need <intrin.h> for the __cpuid function.
@@ -140,7 +158,8 @@ extern "C" {
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL
#define WUFFS_BASE__CPU_ARCH__X86_64
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#else // defined(__AVX__) || defined(__clang__)
@@ -150,19 +169,22 @@ extern "C" {
// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time
// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#pragma message("Wuffs with MSVC+X64 needs /arch:AVX for best performance")
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
#endif // defined(__AVX__) || defined(__clang__)
#endif // defined(_M_X64)
#endif // defined(_M_IX86) || defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
// --------
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
// static storage. The motivation is discussed in the "ALLOW STATIC
// IMPLEMENTATION" section of
// Define WUFFS_CONFIG__STATIC_FUNCTIONS (combined with WUFFS_IMPLEMENTATION)
// to make all of Wuffs' functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)
#define WUFFS_BASE__MAYBE_STATIC static
@@ -192,7 +214,7 @@ wuffs_base__cpu_arch__have_arm_neon() {
static inline bool //
wuffs_base__cpu_arch__have_x86_avx2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
@@ -232,13 +254,13 @@ wuffs_base__cpu_arch__have_x86_avx2() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_bmi2() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
@@ -262,13 +284,13 @@ wuffs_base__cpu_arch__have_x86_bmi2() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
static inline bool //
wuffs_base__cpu_arch__have_x86_sse42() {
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
@@ -294,7 +316,7 @@ wuffs_base__cpu_arch__have_x86_sse42() {
#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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
return false;
}
@@ -309,8 +331,9 @@ wuffs_base__cpu_arch__have_x86_sse42() {
#endif
#endif
// Clang also defines "__GNUC__".
#if defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__) || defined(__clang__)
#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))
#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))
#else
@@ -538,7 +561,20 @@ typedef struct wuffs_base__transform__output__struct {
// --------
// FourCC constants.
// FourCC constants. Four Character Codes are literally four ASCII characters
// (sometimes padded with ' ' spaces) that pack neatly into a signed or
// unsigned 32-bit integer. ASCII letters are conventionally upper case.
//
// They are often used to identify video codecs (e.g. "H265") and pixel formats
// (e.g. "YV12"). Wuffs uses them for that but also generally for naming
// various things: compression formats (e.g. "BZ2 "), image metadata (e.g.
// "EXIF"), file formats (e.g. "HTML"), etc.
//
// Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to
// preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320.
// Background Color.
#define WUFFS_BASE__FOURCC__BGCL 0x4247434C
// Bitmap.
#define WUFFS_BASE__FOURCC__BMP 0x424D5020
@@ -552,15 +588,24 @@ typedef struct wuffs_base__transform__output__struct {
// Concise Binary Object Representation.
#define WUFFS_BASE__FOURCC__CBOR 0x43424F52
// Primary Chromaticities and White Point.
#define WUFFS_BASE__FOURCC__CHRM 0x4348524D
// Cascading Style Sheets.
#define WUFFS_BASE__FOURCC__CSS 0x43535320
// Encapsulated PostScript.
#define WUFFS_BASE__FOURCC__EPS 0x45505320
// Exchangeable Image File Format.
#define WUFFS_BASE__FOURCC__EXIF 0x45584946
// Free Lossless Audio Codec.
#define WUFFS_BASE__FOURCC__FLAC 0x464C4143
// Gamma Correction.
#define WUFFS_BASE__FOURCC__GAMA 0x47414D41
// Graphics Interchange Format.
#define WUFFS_BASE__FOURCC__GIF 0x47494620
@@ -597,24 +642,42 @@ typedef struct wuffs_base__transform__output__struct {
// JSON With Commas and Comments.
#define WUFFS_BASE__FOURCC__JWCC 0x4A574343
// Key-Value Pair.
#define WUFFS_BASE__FOURCC__KVP 0x4B565020
// Key-Value Pair (Key).
#define WUFFS_BASE__FOURCC__KVPK 0x4B56504B
// Key-Value Pair (Value).
#define WUFFS_BASE__FOURCC__KVPV 0x4B565056
// Lempel–Ziv 4.
#define WUFFS_BASE__FOURCC__LZ4 0x4C5A3420
// Markdown.
#define WUFFS_BASE__FOURCC__MD 0x4D442020
// Modification Time.
#define WUFFS_BASE__FOURCC__MTIM 0x4D54494D
// MPEG-1 Audio Layer III.
#define WUFFS_BASE__FOURCC__MP3 0x4D503320
// Naive Image.
#define WUFFS_BASE__FOURCC__NIE 0x4E494520
// Offset (2-Dimensional).
#define WUFFS_BASE__FOURCC__OFS2 0x4F465332
// Open Type Format.
#define WUFFS_BASE__FOURCC__OTF 0x4F544620
// Portable Document Format.
#define WUFFS_BASE__FOURCC__PDF 0x50444620
// Physical Dimensions.
#define WUFFS_BASE__FOURCC__PHYD 0x50485944
// Portable Network Graphics.
#define WUFFS_BASE__FOURCC__PNG 0x504E4720
@@ -639,12 +702,18 @@ typedef struct wuffs_base__transform__output__struct {
// Snappy.
#define WUFFS_BASE__FOURCC__SNPY 0x534E5059
// Standard Red Green Blue (Rendering Intent).
#define WUFFS_BASE__FOURCC__SRGB 0x53524742
// Scalable Vector Graphics.
#define WUFFS_BASE__FOURCC__SVG 0x53564720
// Tape Archive.
#define WUFFS_BASE__FOURCC__TAR 0x54415220
// Text.
#define WUFFS_BASE__FOURCC__TEXT 0x54455854
// Tagged Image File Format.
#define WUFFS_BASE__FOURCC__TIFF 0x54494646
@@ -793,6 +862,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/
//
@@ -893,7 +1012,9 @@ wuffs_base__multiply_u64(uint64_t x, uint64_t y) {
// --------
#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
static inline uint32_t //
wuffs_base__count_leading_zeroes_u64(uint64_t u) {
@@ -937,7 +1058,7 @@ wuffs_base__count_leading_zeroes_u64(uint64_t u) {
return n;
}
#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
#endif // (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
// --------
@@ -1501,6 +1622,25 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
return wuffs_base__make_slice_u8(NULL, 0);
}
// wuffs_base__table_u8__subtable_ij returns t[ix:jx, iy:jy].
//
// It returns an empty table if i or j is out of bounds.
static inline wuffs_base__table_u8 //
wuffs_base__table_u8__subtable_ij(wuffs_base__table_u8 t,
uint64_t ix,
uint64_t iy,
uint64_t jx,
uint64_t jy) {
if ((ix <= jx) && (jx <= SIZE_MAX) && (jx <= t.width) && //
(iy <= jy) && (jy <= SIZE_MAX) && (jy <= t.height)) {
return wuffs_base__make_table_u8(t.ptr + ix + (iy * t.stride), //
((size_t)(jx - ix)), //
((size_t)(jy - iy)), //
t.stride); //
}
return wuffs_base__make_table_u8(NULL, 0, 0, 0);
}
// wuffs_base__table__flattened_length returns the number of elements covered
// by the 1-dimensional span that backs a 2-dimensional table. This counts the
// elements inside the table and, when width != stride, the elements outside
@@ -2383,14 +2523,24 @@ typedef struct wuffs_base__more_information__struct {
inline wuffs_base__range_ie_u64 io_redirect__range() const;
inline uint64_t io_seek__position() const;
inline uint32_t metadata__fourcc() const;
// Deprecated: use metadata_raw_passthrough__range.
inline wuffs_base__range_ie_u64 metadata__range() const;
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
inline int32_t metadata_parsed__chrm(uint32_t component) const;
inline uint32_t metadata_parsed__gama() const;
inline uint32_t metadata_parsed__srgb() const;
#endif // __cplusplus
} wuffs_base__more_information;
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT 1
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2
// Deprecated: use
// WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH.
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH 3
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM 4
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED 5
static inline wuffs_base__more_information //
wuffs_base__empty_more_information() {
@@ -2447,6 +2597,8 @@ wuffs_base__more_information__metadata__fourcc(
return m->w;
}
// Deprecated: use
// wuffs_base__more_information__metadata_raw_passthrough__range.
static inline wuffs_base__range_ie_u64 //
wuffs_base__more_information__metadata__range(
const wuffs_base__more_information* m) {
@@ -2456,6 +2608,103 @@ wuffs_base__more_information__metadata__range(
return ret;
}
static inline wuffs_base__range_ie_u64 //
wuffs_base__more_information__metadata_raw_passthrough__range(
const wuffs_base__more_information* m) {
wuffs_base__range_ie_u64 ret;
ret.min_incl = m->y;
ret.max_excl = m->z;
return ret;
}
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_X 0
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_Y 1
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_X 2
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_Y 3
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_X 4
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_Y 5
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_X 6
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_Y 7
// wuffs_base__more_information__metadata_parsed__chrm returns chromaticity
// values (scaled by 100000) like the PNG "cHRM" chunk. For example, the sRGB
// color space corresponds to:
// - ETC__CHRM__WHITE_X 31270
// - ETC__CHRM__WHITE_Y 32900
// - ETC__CHRM__RED_X 64000
// - ETC__CHRM__RED_Y 33000
// - ETC__CHRM__GREEN_X 30000
// - ETC__CHRM__GREEN_Y 60000
// - ETC__CHRM__BLUE_X 15000
// - ETC__CHRM__BLUE_Y 6000
//
// See
// https://ciechanow.ski/color-spaces/#chromaticity-and-white-point-coordinates
static inline int32_t //
wuffs_base__more_information__metadata_parsed__chrm(
const wuffs_base__more_information* m,
uint32_t component) {
// After the flavor and the w field (holding a FourCC), a
// wuffs_base__more_information holds 24 bytes of data in three uint64_t
// typed fields (x, y and z). We pack the eight chromaticity values (wx, wy,
// rx, ..., by), basically int24_t values, into 24 bytes like this:
// - LSB MSB
// - x: wx wx wx wy wy wy rx rx
// - y: rx ry ry ry gx gx gx gy
// - z: gy gy bx bx bx by by by
uint32_t u = 0;
switch (component & 7) {
case 0:
u = ((uint32_t)(m->x >> 0));
break;
case 1:
u = ((uint32_t)(m->x >> 24));
break;
case 2:
u = ((uint32_t)((m->x >> 48) | (m->y << 16)));
break;
case 3:
u = ((uint32_t)(m->y >> 8));
break;
case 4:
u = ((uint32_t)(m->y >> 32));
break;
case 5:
u = ((uint32_t)((m->y >> 56) | (m->z << 8)));
break;
case 6:
u = ((uint32_t)(m->z >> 16));
break;
case 7:
u = ((uint32_t)(m->z >> 40));
break;
}
// The left-right shifts sign-extend from 24-bit to 32-bit integers.
return ((int32_t)(u << 8)) >> 8;
}
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
static inline uint32_t //
wuffs_base__more_information__metadata_parsed__gama(
const wuffs_base__more_information* m) {
return ((uint32_t)(m->x));
}
#define WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL 0
#define WUFFS_BASE__SRGB_RENDERING_INTENT__RELATIVE_COLORIMETRIC 1
#define WUFFS_BASE__SRGB_RENDERING_INTENT__SATURATION 2
#define WUFFS_BASE__SRGB_RENDERING_INTENT__ABSOLUTE_COLORIMETRIC 3
// wuffs_base__more_information__metadata_parsed__srgb returns the sRGB
// rendering intent like the PNG "sRGB" chunk.
static inline uint32_t //
wuffs_base__more_information__metadata_parsed__srgb(
const wuffs_base__more_information* m) {
return m->x & 3;
}
#ifdef __cplusplus
inline void //
@@ -2493,6 +2742,26 @@ wuffs_base__more_information::metadata__range() const {
return wuffs_base__more_information__metadata__range(this);
}
inline wuffs_base__range_ie_u64 //
wuffs_base__more_information::metadata_raw_passthrough__range() const {
return wuffs_base__more_information__metadata_raw_passthrough__range(this);
}
inline int32_t //
wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__gama() const {
return wuffs_base__more_information__metadata_parsed__gama(this);
}
inline uint32_t //
wuffs_base__more_information::metadata_parsed__srgb() const {
return wuffs_base__more_information__metadata_parsed__srgb(this);
}
#endif // __cplusplus
// ---------------- I/O
@@ -4999,9 +5268,9 @@ wuffs_base__pixel_swizzler::swizzle_interleaved_from_slice(
// wuffs_base__ieee_754_bit_representation__etc converts between a double
// precision numerical value and its IEEE 754 representations:
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
//
// For example, it converts between:
// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.
@@ -7040,6 +7309,7 @@ struct wuffs_deflate__decoder__struct {
uint32_t f_bits;
uint32_t f_n_bits;
uint64_t f_transformed_history_count;
uint32_t f_history_index;
uint32_t f_n_huffs_bits[2];
bool f_end_of_block;
@@ -7612,8 +7882,8 @@ struct wuffs_gif__decoder__struct {
bool f_previous_lzw_decode_ended_abruptly;
bool f_has_global_palette;
uint8_t f_interlace;
bool f_seen_num_loops;
uint32_t f_num_loops;
bool f_seen_num_animation_loops_value;
uint32_t f_num_animation_loops_value;
uint32_t f_background_color_u32_argb_premul;
uint32_t f_black_color_u32_argb_premul;
bool f_gc_has_transparent_index;
@@ -8891,17 +9161,22 @@ struct wuffs_zlib__decoder__struct {
// ---------------- Status Codes
extern const char wuffs_png__error__bad_animation_sequence_number[];
extern const char wuffs_png__error__bad_checksum[];
extern const char wuffs_png__error__bad_chunk[];
extern const char wuffs_png__error__bad_filter[];
extern const char wuffs_png__error__bad_header[];
extern const char wuffs_png__error__bad_text_chunk_not_latin_1[];
extern const char wuffs_png__error__missing_palette[];
extern const char wuffs_png__error__unsupported_png_compression_method[];
extern const char wuffs_png__error__unsupported_png_file[];
// ---------------- Public Consts
#define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0
#define WUFFS_PNG__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 8
// ---------------- Struct Declarations
typedef struct wuffs_png__decoder__struct wuffs_png__decoder;
@@ -9051,22 +9326,66 @@ struct wuffs_png__decoder__struct {
uint32_t f_height;
uint64_t f_pass_bytes_per_row;
uint64_t f_workbuf_wi;
uint64_t f_workbuf_hist_pos_base;
uint64_t f_overall_workbuf_length;
uint64_t f_pass_workbuf_length;
uint8_t f_call_sequence;
bool f_report_metadata_chrm;
bool f_report_metadata_gama;
bool f_report_metadata_iccp;
bool f_report_metadata_kvp;
bool f_report_metadata_srgb;
bool f_ignore_checksum;
uint8_t f_depth;
uint8_t f_color_type;
uint8_t f_filter_distance;
uint8_t f_interlace_pass;
bool f_seen_actl;
bool f_seen_chrm;
bool f_seen_fctl;
bool f_seen_gama;
bool f_seen_iccp;
bool f_seen_idat;
bool f_seen_plte;
bool f_seen_srgb;
bool f_seen_trns;
uint32_t f_dst_pixfmt;
uint32_t f_src_pixfmt;
bool f_metadata_is_zlib_compressed;
bool f_zlib_is_dirty;
uint32_t f_chunk_type;
uint8_t f_chunk_type_array[4];
uint64_t f_chunk_length;
uint32_t f_chunk_length;
uint64_t f_remap_transparency;
uint32_t f_dst_pixfmt;
uint32_t f_src_pixfmt;
uint32_t f_num_animation_frames_value;
uint32_t f_num_animation_loops_value;
uint32_t f_num_decoded_frame_configs_value;
uint32_t f_num_decoded_frames_value;
uint32_t f_frame_rect_x0;
uint32_t f_frame_rect_y0;
uint32_t f_frame_rect_x1;
uint32_t f_frame_rect_y1;
uint32_t f_first_rect_x0;
uint32_t f_first_rect_y0;
uint32_t f_first_rect_x1;
uint32_t f_first_rect_y1;
uint64_t f_frame_config_io_position;
uint64_t f_first_config_io_position;
uint64_t f_frame_duration;
uint64_t f_first_duration;
uint8_t f_frame_disposal;
uint8_t f_first_disposal;
bool f_frame_overwrite_instead_of_blend;
bool f_first_overwrite_instead_of_blend;
uint32_t f_next_animation_seq_num;
uint32_t f_metadata_flavor;
uint32_t f_metadata_fourcc;
uint64_t f_metadata_x;
uint64_t f_metadata_y;
uint64_t f_metadata_z;
uint32_t f_ztxt_ri;
uint32_t f_ztxt_wi;
uint64_t f_ztxt_hist_pos;
wuffs_base__pixel_swizzler f_swizzler;
wuffs_base__empty_struct (*choosy_filter_1)(
@@ -9083,11 +9402,19 @@ struct wuffs_png__decoder__struct {
uint32_t p_decode_image_config[1];
uint32_t p_decode_ihdr[1];
uint32_t p_decode_other_chunk[1];
uint32_t p_decode_actl[1];
uint32_t p_decode_chrm[1];
uint32_t p_decode_fctl[1];
uint32_t p_decode_gama[1];
uint32_t p_decode_iccp[1];
uint32_t p_decode_plte[1];
uint32_t p_decode_srgb[1];
uint32_t p_decode_trns[1];
uint32_t p_decode_frame_config[1];
uint32_t p_skip_frame[1];
uint32_t p_decode_frame[1];
uint32_t p_decode_pass[1];
uint32_t p_tell_me_more[1];
wuffs_base__status (*choosy_filter_and_swizzle)(
wuffs_png__decoder* self,
wuffs_base__pixel_buffer* a_dst,
@@ -9110,19 +9437,47 @@ struct wuffs_png__decoder__struct {
struct {
uint64_t scratch;
} s_decode_other_chunk[1];
struct {
uint64_t scratch;
} s_decode_actl[1];
struct {
uint64_t scratch;
} s_decode_chrm[1];
struct {
uint32_t v_x0;
uint32_t v_x1;
uint32_t v_y1;
uint64_t scratch;
} s_decode_fctl[1];
struct {
uint64_t scratch;
} s_decode_gama[1];
struct {
uint32_t v_num_entries;
uint32_t v_i;
uint64_t scratch;
} s_decode_plte[1];
struct {
uint32_t v_num_entries;
uint32_t v_i;
uint32_t v_n;
uint64_t scratch;
} s_decode_trns[1];
struct {
uint32_t v_checksum_have;
uint64_t scratch;
} s_decode_frame_config[1];
struct {
uint64_t scratch;
} s_skip_frame[1];
struct {
uint64_t scratch;
} s_decode_frame[1];
struct {
uint64_t scratch;
} s_decode_pass[1];
struct {
wuffs_base__status v_zlib_status;
uint64_t scratch;
} s_tell_me_more[1];
} private_data;
#ifdef __cplusplus
@@ -9619,6 +9974,63 @@ namespace sync_io {
// --------
// DynIOBuffer is an IOBuffer that is backed by a dynamically sized byte array.
// It owns that backing array and will free it in its destructor.
//
// The array size can be explicitly extended (by calling the grow method) but,
// unlike a C++ std::vector, there is no implicit extension (e.g. by calling
// std::vector::insert) and its maximum size is capped by the max_incl
// constructor argument.
//
// It contains an IOBuffer-typed field whose reader side provides access to
// previously written bytes and whose writer side provides access to the
// allocated but not-yet-written-to slack space. For Go programmers, this slack
// space is roughly analogous to the s[len(s):cap(s)] space of a slice s.
class DynIOBuffer {
public:
enum GrowResult {
OK = 0,
FailedMaxInclExceeded = 1,
FailedOutOfMemory = 2,
};
// m_buf holds the dynamically sized byte array and its read/write indexes:
// - m_buf.meta.wi is roughly analogous to a Go slice's length.
// - m_buf.data.len is roughly analogous to a Go slice's capacity. It is
// also equal to the m_buf.data.ptr malloc/realloc size.
//
// Users should not modify the m_buf.data.ptr or m_buf.data.len fields (as
// they are conceptually private to this class), but they can modify the
// bytes referenced by that pointer-length pair (e.g. compactions).
IOBuffer m_buf;
// m_max_incl is an inclusive upper bound on the backing array size.
const uint64_t m_max_incl;
// Constructor and destructor.
explicit DynIOBuffer(uint64_t max_incl);
~DynIOBuffer();
// Drop frees the byte array and resets m_buf. The DynIOBuffer can still be
// used after a drop call. It just restarts from zero.
void drop();
// grow ensures that the byte array size is at least min_incl and at most
// max_incl. It returns FailedMaxInclExceeded if that would require
// allocating more than max_incl bytes, including the case where (min_incl >
// max_incl). It returns FailedOutOfMemory if memory allocation failed.
GrowResult grow(uint64_t min_incl);
private:
// Delete the copy and assign constructors.
DynIOBuffer(const DynIOBuffer&) = delete;
DynIOBuffer& operator=(const DynIOBuffer&) = delete;
static uint64_t round_up(uint64_t min_incl, uint64_t max_incl);
};
// --------
class Input {
public:
virtual ~Input();
@@ -9729,6 +10141,26 @@ class DecodeCborCallbacks {
Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);
};
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
struct DecodeCborArgQuirks {
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeCborArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
@@ -9738,7 +10170,7 @@ class DecodeCborCallbacks {
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());
DecodeCborArgQuirks quirks = DecodeCborArgQuirks::DefaultValue());
} // namespace wuffs_aux
@@ -9760,10 +10192,11 @@ struct DecodeImageResult {
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
// called in this order:
// 1. SelectDecoder
// 2. SelectPixfmt
// 3. AllocPixbuf
// 4. AllocWorkbuf
// 5. Done
// 2. HandleMetadata
// 3. SelectPixfmt
// 4. AllocPixbuf
// 5. AllocWorkbuf
// 6. Done
//
// It may return early - the third callback might not be invoked if the second
// one fails - but the final callback (Done) is always invoked.
@@ -9820,6 +10253,22 @@ class DecodeImageCallbacks {
virtual wuffs_base__image_decoder::unique_ptr //
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
// HandleMetadata acknowledges image metadata. minfo.flavor will be one of:
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED
// If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those
// bytes should not be retained beyond the the HandleMetadata call.
//
// minfo.metadata__fourcc() will typically match one of the
// DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM |
// REPORT_METADATA_GAMA) was passed to DecodeImage then the metadata FourCC
// will be either WUFFS_BASE__FOURCC__CHRM or WUFFS_BASE__FOURCC__GAMA.
//
// It returns an error message, or an empty string on success.
virtual std::string //
HandleMetadata(const wuffs_base__more_information& minfo,
wuffs_base__slice_u8 raw);
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
// should return wuffs_base__make_pixel_format(etc) called with one of:
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
@@ -9886,13 +10335,116 @@ class DecodeImageCallbacks {
extern const char DecodeImage_BufferIsTooShort[];
extern const char DecodeImage_MaxInclDimensionExceeded[];
extern const char DecodeImage_MaxInclMetadataLengthExceeded[];
extern const char DecodeImage_OutOfMemory[];
extern const char DecodeImage_UnexpectedEndOfFile[];
extern const char DecodeImage_UnsupportedImageFormat[];
extern const char DecodeImage_UnsupportedMetadata[];
extern const char DecodeImage_UnsupportedPixelBlend[];
extern const char DecodeImage_UnsupportedPixelConfiguration[];
extern const char DecodeImage_UnsupportedPixelFormat[];
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeImageArgQuirks wraps an optional argument to DecodeImage.
struct DecodeImageArgQuirks {
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeImageArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeImageArgFlags wraps an optional argument to DecodeImage.
struct DecodeImageArgFlags {
explicit DecodeImageArgFlags(uint64_t repr0);
// DefaultValue returns 0.
static DecodeImageArgFlags DefaultValue();
// TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, GAMA,
// ICCP, KVP, SRGB and XMP.
// Background Color.
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
// Primary Chromaticities and White Point.
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
// Exchangeable Image File Format.
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
// Gamma Correction.
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
// International Color Consortium Profile.
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
// Key-Value Pair.
//
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
// HandleMetadata callback, the raw argument contains UTF-8 strings.
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
// Modification Time.
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
// Offset (2-Dimensional).
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
// Physical Dimensions.
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
// Standard Red Green Blue (Rendering Intent).
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
// Extensible Metadata Platform.
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
uint64_t repr;
};
// DecodeImageArgPixelBlend wraps an optional argument to DecodeImage.
struct DecodeImageArgPixelBlend {
explicit DecodeImageArgPixelBlend(wuffs_base__pixel_blend repr0);
// DefaultValue returns WUFFS_BASE__PIXEL_BLEND__SRC.
static DecodeImageArgPixelBlend DefaultValue();
wuffs_base__pixel_blend repr;
};
// DecodeImageArgBackgroundColor wraps an optional argument to DecodeImage.
struct DecodeImageArgBackgroundColor {
explicit DecodeImageArgBackgroundColor(
wuffs_base__color_u32_argb_premul repr0);
// DefaultValue returns 1, an invalid wuffs_base__color_u32_argb_premul.
static DecodeImageArgBackgroundColor DefaultValue();
wuffs_base__color_u32_argb_premul repr;
};
// DecodeImageArgMaxInclDimension wraps an optional argument to DecodeImage.
struct DecodeImageArgMaxInclDimension {
explicit DecodeImageArgMaxInclDimension(uint32_t repr0);
// DefaultValue returns 1048575 = 0x000F_FFFF, more than 1 million pixels.
static DecodeImageArgMaxInclDimension DefaultValue();
uint32_t repr;
};
// DecodeImageArgMaxInclMetadataLength wraps an optional argument to
// DecodeImage.
struct DecodeImageArgMaxInclMetadataLength {
explicit DecodeImageArgMaxInclMetadataLength(uint64_t repr0);
// DefaultValue returns 16777215 = 0x00FF_FFFF, one less than 16 MiB.
static DecodeImageArgMaxInclMetadataLength DefaultValue();
uint64_t repr;
};
// DecodeImage decodes the image data in input. A variety of image file formats
// can be decoded, depending on what callbacks.SelectDecoder returns.
//
@@ -9935,13 +10487,21 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.
//
// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's
// width or height is greater than max_incl_dimension.
// width or height is greater than max_incl_dimension or if any opted-in (via
// flags bits) metadata is longer than max_incl_metadata_length.
DecodeImageResult //
DecodeImage(DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
DecodeImageArgQuirks quirks = DecodeImageArgQuirks::DefaultValue(),
DecodeImageArgFlags flags = DecodeImageArgFlags::DefaultValue(),
DecodeImageArgPixelBlend pixel_blend =
DecodeImageArgPixelBlend::DefaultValue(),
DecodeImageArgBackgroundColor background_color =
DecodeImageArgBackgroundColor::DefaultValue(),
DecodeImageArgMaxInclDimension max_incl_dimension =
DecodeImageArgMaxInclDimension::DefaultValue(),
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length =
DecodeImageArgMaxInclMetadataLength::DefaultValue());
} // namespace wuffs_aux
@@ -10002,6 +10562,36 @@ class DecodeJsonCallbacks {
extern const char DecodeJson_BadJsonPointer[];
extern const char DecodeJson_NoMatch[];
// The FooArgBar types add structure to Foo's optional arguments. They wrap
// inner representations for several reasons:
// - It provides a home for the DefaultValue static method, for Foo callers
// that want to override some but not all optional arguments.
// - It provides the "Bar" name at Foo call sites, which can help self-
// document Foo calls with many arguemnts.
// - It provides some type safety against accidentally transposing or omitting
// adjacent fundamentally-numeric-typed optional arguments.
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
struct DecodeJsonArgQuirks {
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0);
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len);
// DefaultValue returns an empty slice.
static DecodeJsonArgQuirks DefaultValue();
wuffs_base__slice_u32 repr;
};
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
struct DecodeJsonArgJsonPointer {
explicit DecodeJsonArgJsonPointer(std::string repr0);
// DefaultValue returns an empty string.
static DecodeJsonArgJsonPointer DefaultValue();
std::string repr;
};
// DecodeJson calls callbacks based on the JSON-formatted data in input.
//
// On success, the returned error_message is empty and cursor_position counts
@@ -10019,8 +10609,9 @@ extern const char DecodeJson_NoMatch[];
DecodeJsonResult //
DecodeJson(DecodeJsonCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),
std::string json_pointer = std::string());
DecodeJsonArgQuirks quirks = DecodeJsonArgQuirks::DefaultValue(),
DecodeJsonArgJsonPointer json_pointer =
DecodeJsonArgJsonPointer::DefaultValue());
} // namespace wuffs_aux
@@ -10048,26 +10639,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) \
@@ -10080,8 +10661,9 @@ extern "C" {
goto suspend; \
case n:;
// Clang also defines "__GNUC__".
#if defined(__GNUC__)
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
#if defined(__GNUC__) || defined(__clang__)
#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))
#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))
#else
@@ -10239,7 +10821,7 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
// --------
static inline wuffs_base__slice_u8 //
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
wuffs_base__table_u8__row_u32(wuffs_base__table_u8 t, uint32_t y) {
if (y < t.height) {
return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);
}
@@ -10410,11 +10992,12 @@ wuffs_base__io_reader__set(wuffs_base__io_buffer* b,
const uint8_t** ptr_io0_r,
const uint8_t** ptr_io1_r,
const uint8_t** ptr_io2_r,
wuffs_base__slice_u8 data) {
wuffs_base__slice_u8 data,
uint64_t history_position) {
b->data = data;
b->meta.wi = data.len;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.pos = history_position;
b->meta.closed = false;
*ptr_iop_r = data.ptr;
@@ -10648,11 +11231,12 @@ wuffs_base__io_writer__set(wuffs_base__io_buffer* b,
uint8_t** ptr_io0_w,
uint8_t** ptr_io1_w,
uint8_t** ptr_io2_w,
wuffs_base__slice_u8 data) {
wuffs_base__slice_u8 data,
uint64_t history_position) {
b->data = data;
b->meta.wi = 0;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.pos = history_position;
b->meta.closed = false;
*ptr_iop_w = data.ptr;
@@ -12305,14 +12889,14 @@ wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {
// padded with implicit zeroes.
//
// For example, if num_digits is 3 and digits is "\x07\x08\x09":
// - A decimal_point of -2 means ".00789"
// - A decimal_point of -1 means ".0789"
// - A decimal_point of +0 means ".789"
// - A decimal_point of +1 means "7.89"
// - A decimal_point of +2 means "78.9"
// - A decimal_point of +3 means "789."
// - A decimal_point of +4 means "7890."
// - A decimal_point of +5 means "78900."
// - A decimal_point of -2 means ".00789"
// - A decimal_point of -1 means ".0789"
// - A decimal_point of +0 means ".789"
// - A decimal_point of +1 means "7.89"
// - A decimal_point of +2 means "78.9"
// - A decimal_point of +3 means "789."
// - A decimal_point of +4 means "7890."
// - A decimal_point of +5 means "78900."
//
// As above, a decimal_point higher than +2047 means that the overall value is
// infinity, lower than -2047 means zero.
@@ -12657,10 +13241,10 @@ wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns
// the integral (non-fractional) part of h, provided that it is 18 or fewer
// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
// and that IEEE 754 double precision has 52 mantissa bits.
//
// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.
@@ -14217,13 +14801,18 @@ wuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {
ret.value = 0;
return ret;
} else if (negative) {
if (r.value > 0x8000000000000000) {
goto fail_out_of_bounds;
if (r.value < 0x8000000000000000) {
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = -(int64_t)(r.value);
return ret;
} else if (r.value == 0x8000000000000000) {
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = INT64_MIN;
return ret;
}
wuffs_base__result_i64 ret;
ret.status.repr = NULL;
ret.value = -(int64_t)(r.value);
return ret;
goto fail_out_of_bounds;
} else if (r.value > 0x7FFFFFFFFFFFFFFF) {
goto fail_out_of_bounds;
} else {
@@ -14988,19 +15577,22 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
//
// Keep it sorted by magic[1], then magic[0] descending and finally by
// magic[2:]. When multiple entries match, the longest one wins.
//
// The fourcc field might be negated, in which case there's further
// specialization (see § below).
static struct {
int32_t fourcc;
const char* magic;
} table[] = {
{0x57424D50, "\x01\x00\x00"}, // WBMP
{0x424D5020, "\x01\x42\x4D"}, // BMP
{0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
{0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
{0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
{0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF (see § below)
{0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
{0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
{0x4A504547, "\x01\xFF\xD8"}, // JPEG
{-0x30302020, "\x01\x00\x00"}, // '00 'be
{+0x424D5020, "\x01\x42\x4D"}, // BMP
{+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
{+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
{+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
{-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF
{+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
{+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
{+0x4A504547, "\x01\xFF\xD8"}, // JPEG
};
static const size_t table_len = sizeof(table) / sizeof(table[0]);
@@ -15041,19 +15633,38 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
return 0;
match:
// Some FourCC values (see § above) are further specialized.
if (fourcc == 0x52494646) { // 'RIFF'be
if (prefix.len < 16) {
return -1;
}
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
if (x == 0x57454250) { // 'WEBP'be
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
if (y == 0x56503820) { // 'VP8 'be
return 0x57503820; // 'WP8 'be
} else if (y == 0x5650384C) { // 'VP8L'be
return 0x5750384C; // 'WP8L'be
// Negative FourCC values (see § above) are further specialized.
if (fourcc < 0) {
fourcc = -fourcc;
if (fourcc == 0x52494646) { // 'RIFF'be
if (prefix.len < 16) {
return -1;
}
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
if (x == 0x57454250) { // 'WEBP'be
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
if (y == 0x56503820) { // 'VP8 'be
return 0x57503820; // 'WP8 'be
} else if (y == 0x5650384C) { // 'VP8L'be
return 0x5750384C; // 'WP8L'be
}
}
} else if (fourcc == 0x30302020) { // '00 'be
// Binary data starting with multiple 0x00 NUL bytes is quite common.
if (prefix.len < 4) {
return -1;
} else if ((prefix.ptr[2] != 0x00) &&
((prefix.ptr[2] >= 0x80) || (prefix.ptr[3] != 0x00))) {
// Roughly speaking, this could be a non-degenerate (non-0-width and
// non-0-height) WBMP image.
return 0x57424D50; // 'WBMP'be
} else if (((prefix.ptr[2] == 0x01) || (prefix.ptr[2] == 0x02)) &&
(prefix.ptr[3] == 0x00)) {
return 0x49434F20; // 'ICO 'be
}
return 0;
}
}
return fourcc;
@@ -15864,7 +16475,7 @@ wuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
@@ -15908,7 +16519,7 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
}
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -18187,7 +18798,7 @@ wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
@@ -18240,7 +18851,7 @@ wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -18899,7 +19510,7 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
@@ -18946,7 +19557,7 @@ wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -19234,7 +19845,7 @@ wuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__xxxx__y__sse42;
}
@@ -19272,7 +19883,6 @@ wuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,
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:
@@ -19618,7 +20228,7 @@ wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
}
@@ -19693,7 +20303,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -19874,7 +20484,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_premul(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -19942,7 +20552,7 @@ wuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
}
@@ -19993,7 +20603,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -20104,7 +20714,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_premul(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
@@ -20587,12 +21197,12 @@ wuffs_adler32__hasher__up_arm_neon(
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_x86_sse42(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ---------------- VTables
@@ -20708,7 +21318,7 @@ wuffs_adler32__hasher__update_u32(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_adler32__hasher__up_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_adler32__hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -20900,7 +21510,7 @@ wuffs_adler32__hasher__up_arm_neon(
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func adler32.hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_x86_sse42(
@@ -20986,7 +21596,7 @@ wuffs_adler32__hasher__up_x86_sse42(
self->private_impl.f_state = (((v_s2 & 65535) << 16) | (v_s1 & 65535));
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32)
@@ -21317,7 +21927,7 @@ wuffs_bmp__decoder__decode_image_config(
goto exit;
}
self->private_impl.f_padding -= 14;
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))));
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))));
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
uint32_t t_2;
@@ -22066,7 +22676,7 @@ wuffs_bmp__decoder__decode_image_config(
} else if (self->private_impl.f_bits_per_pixel == 32) {
self->private_impl.f_pad_per_row = 0;
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if (a_dst != NULL) {
v_dst_pixfmt = 2164295816;
if ((self->private_impl.f_channel_num_bits[0] > 8) ||
@@ -22086,7 +22696,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;
@@ -22165,7 +22774,7 @@ wuffs_bmp__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
@@ -22195,7 +22804,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;
@@ -22383,7 +22991,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;
@@ -22472,7 +23079,7 @@ wuffs_bmp__decoder__swizzle_none(
goto label__outer__continue;
}
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -22497,7 +23104,6 @@ wuffs_bmp__decoder__swizzle_none(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22558,7 +23164,7 @@ wuffs_bmp__decoder__swizzle_rle(
v_rle_state = self->private_impl.f_rle_state;
label__outer__continue:;
while (true) {
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
}
@@ -22718,7 +23324,7 @@ wuffs_bmp__decoder__swizzle_rle(
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
}
@@ -22750,7 +23356,7 @@ wuffs_bmp__decoder__swizzle_rle(
}
label__outer__break:;
while (self->private_impl.f_dst_y < self->private_impl.f_height) {
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
}
@@ -22760,7 +23366,6 @@ wuffs_bmp__decoder__swizzle_rle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22881,7 +23486,7 @@ wuffs_bmp__decoder__swizzle_bitfields(
v_p0 += 1;
}
label__0__break:;
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -22901,7 +23506,6 @@ wuffs_bmp__decoder__swizzle_bitfields(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -22964,7 +23568,7 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
goto label__loop__break;
}
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -23070,7 +23674,6 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -24156,7 +24759,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;
@@ -24774,19 +25376,19 @@ 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)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_sse42(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ---------------- VTables
@@ -24900,10 +25502,10 @@ 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)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -25093,7 +25695,7 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func crc32.ieee_hasher.up_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
@@ -25206,13 +25808,13 @@ wuffs_crc32__ieee_hasher__up_x86_avx2(
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc32.ieee_hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_sse42(
@@ -25325,7 +25927,7 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
self->private_impl.f_state = (4294967295 ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC32)
@@ -25450,13 +26052,13 @@ wuffs_deflate__decoder__init_huff(
uint32_t a_n_codes1,
uint32_t a_base_symbol);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
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)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_fast32(
@@ -25686,7 +26288,7 @@ wuffs_deflate__decoder__transform_io(
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
self->private_impl.choosy_decode_huffman_fast64 = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
#endif
self->private_impl.choosy_decode_huffman_fast64);
@@ -25712,12 +26314,12 @@ wuffs_deflate__decoder__transform_io(
}
goto ok;
}
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_transformed_history_count, wuffs_base__io__count_since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst))));
wuffs_deflate__decoder__add_history(self, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst));
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -25875,7 +26477,6 @@ wuffs_deflate__decoder__decode_blocks(
}
}
goto ok;
ok:
self->private_impl.p_decode_blocks[0] = 0;
goto exit;
@@ -25995,7 +26596,6 @@ wuffs_deflate__decoder__decode_uncompressed(
}
}
goto ok;
ok:
self->private_impl.p_decode_uncompressed[0] = 0;
goto exit;
@@ -26581,7 +27181,7 @@ wuffs_deflate__decoder__init_huff(
// ‼ WUFFS MULTI-FILE SECTION +x86_bmi2
// -------- func deflate.decoder.decode_huffman_bmi2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
static wuffs_base__status
wuffs_deflate__decoder__decode_huffman_bmi2(
@@ -26602,6 +27202,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint32_t v_hdist_adjustment = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -26635,6 +27236,11 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
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);
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
goto exit;
}
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
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)));
@@ -26725,6 +27331,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
v_hlen = v_length;
v_length = 0;
}
v_hdist += v_hdist_adjustment;
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -26785,7 +27392,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
return status;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
// -------- func deflate.decoder.decode_huffman_fast32
@@ -26809,6 +27416,7 @@ wuffs_deflate__decoder__decode_huffman_fast32(
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint32_t v_hdist_adjustment = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -26842,6 +27450,11 @@ wuffs_deflate__decoder__decode_huffman_fast32(
v_n_bits = self->private_impl.f_n_bits;
v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
goto exit;
}
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
label__loop__continue:;
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 12)) {
if (v_n_bits < 15) {
@@ -26984,6 +27597,7 @@ wuffs_deflate__decoder__decode_huffman_fast32(
v_hlen = v_length;
v_length = 0;
}
v_hdist += v_hdist_adjustment;
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -27067,6 +27681,7 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
uint32_t v_dist_minus_1 = 0;
uint32_t v_hlen = 0;
uint32_t v_hdist = 0;
uint32_t v_hdist_adjustment = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -27100,6 +27715,11 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
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);
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
goto exit;
}
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
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)));
@@ -27190,6 +27810,7 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
v_hlen = v_length;
v_length = 0;
}
v_hdist += v_hdist_adjustment;
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -27524,6 +28145,7 @@ wuffs_deflate__decoder__decode_huffman_slow(
v_hlen = v_length;
v_length = 0;
}
v_hdist += ((uint32_t)((((uint64_t)(self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0))) & 4294967295)));
if (self->private_impl.f_history_index < v_hdist) {
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
goto exit;
@@ -27586,7 +28208,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_huffman_slow[0] = 0;
goto exit;
@@ -27858,7 +28479,6 @@ wuffs_lzw__decoder__transform_io(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -28102,7 +28722,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;
@@ -28592,7 +29211,7 @@ wuffs_gif__decoder__tell_me_more(
while (true) {
label__0__continue:;
while (true) {
if (wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
if (wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
if (a_minfo != NULL) {
wuffs_base__more_information__set(a_minfo,
2,
@@ -28631,13 +29250,13 @@ wuffs_gif__decoder__tell_me_more(
} else {
iop_a_src += 1;
}
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
if (a_minfo != NULL) {
wuffs_base__more_information__set(a_minfo,
3,
self->private_impl.f_metadata_fourcc,
0,
wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))),
wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))),
self->private_impl.f_metadata_io_position);
}
status = wuffs_base__make_status(wuffs_base__suspension__even_more_information);
@@ -28658,7 +29277,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;
@@ -28694,8 +29312,8 @@ wuffs_gif__decoder__num_animation_loops(
return 0;
}
if (self->private_impl.f_seen_num_loops) {
return self->private_impl.f_num_loops;
if (self->private_impl.f_seen_num_animation_loops_value) {
return self->private_impl.f_num_animation_loops_value;
}
return 1;
}
@@ -28926,7 +29544,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;
@@ -29165,9 +29782,9 @@ wuffs_gif__decoder__decode_up_to_id_part1(
if ( ! self->private_impl.f_restarted) {
if (self->private_impl.f_call_sequence != 2) {
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
}
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
} else {
@@ -29592,7 +30209,6 @@ wuffs_gif__decoder__decode_extension(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_extension[0] = 0;
goto exit;
@@ -29661,7 +30277,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;
@@ -29845,22 +30460,22 @@ wuffs_gif__decoder__decode_ae(
*scratch |= ((uint64_t)(num_bits_4)) << 56;
}
}
self->private_impl.f_num_loops = t_4;
self->private_impl.f_num_animation_loops_value = t_4;
}
self->private_impl.f_seen_num_loops = true;
if ((0 < self->private_impl.f_num_loops) && (self->private_impl.f_num_loops <= 65535)) {
self->private_impl.f_num_loops += 1;
self->private_impl.f_seen_num_animation_loops_value = true;
if ((0 < self->private_impl.f_num_animation_loops_value) && (self->private_impl.f_num_animation_loops_value <= 65535)) {
self->private_impl.f_num_animation_loops_value += 1;
}
} else if (self->private_impl.f_ignore_metadata) {
} else if (v_is_iccp && self->private_impl.f_report_metadata_iccp) {
self->private_impl.f_metadata_fourcc = 1229144912;
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
} else if (v_is_xmp && self->private_impl.f_report_metadata_xmp) {
self->private_impl.f_metadata_fourcc = 1481461792;
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
@@ -29880,7 +30495,6 @@ wuffs_gif__decoder__decode_ae(
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_ae[0] = 0;
goto exit;
@@ -30332,7 +30946,8 @@ wuffs_gif__decoder__decode_id_part1(
goto ok;
}
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw, sizeof (wuffs_lzw__decoder), WUFFS_VERSION, 0));
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw,
sizeof (wuffs_lzw__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -30350,7 +30965,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;
@@ -30486,7 +31100,8 @@ wuffs_gif__decoder__decode_id_part2(
wuffs_base__slice_u8__subslice_ij(wuffs_base__make_slice_u8(self->private_data.f_compressed,
4096),
self->private_impl.f_compressed_ri,
self->private_impl.f_compressed_wi));
self->private_impl.f_compressed_wi),
0);
v_mark = ((uint64_t)(iop_v_r - io0_v_r));
{
u_r.meta.ri = ((size_t)(iop_v_r - u_r.data.ptr));
@@ -30557,7 +31172,6 @@ wuffs_gif__decoder__decode_id_part2(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_id_part2[0] = 0;
goto exit;
@@ -30619,7 +31233,7 @@ wuffs_gif__decoder__copy_to_image_buffer(
}
return wuffs_base__make_status(wuffs_base__error__too_much_data);
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, 0);
} else if (v_width_in_bytes < ((uint64_t)(v_dst.len))) {
@@ -30645,12 +31259,12 @@ wuffs_gif__decoder__copy_to_image_buffer(
goto label__0__continue;
}
if ((self->private_impl.f_num_decoded_frames_value == 0) && ! self->private_impl.f_gc_has_transparent_index && (self->private_impl.f_interlace > 1)) {
v_replicate_src = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_replicate_src = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
v_replicate_y0 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, 1);
v_replicate_y1 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, ((uint32_t)(WUFFS_GIF__INTERLACE_COUNT[self->private_impl.f_interlace])));
v_replicate_y1 = wuffs_base__u32__min(v_replicate_y1, self->private_impl.f_frame_rect_y1);
while (v_replicate_y0 < v_replicate_y1) {
v_replicate_dst = wuffs_base__table_u8__row(v_tab, v_replicate_y0);
v_replicate_dst = wuffs_base__table_u8__row_u32(v_tab, v_replicate_y0);
wuffs_base__slice_u8__copy_from_slice(v_replicate_dst, v_replicate_src);
v_replicate_y0 += 1;
}
@@ -31167,7 +31781,6 @@ wuffs_gzip__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -32624,7 +33237,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;
@@ -32926,7 +33538,6 @@ wuffs_json__decoder__decode_leading(
}
label__0__break:;
goto ok;
ok:
self->private_impl.p_decode_leading[0] = 0;
goto exit;
@@ -33068,16 +33679,19 @@ wuffs_json__decoder__decode_comment(
}
while (true) {
if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
if (v_length > 0) {
if (a_src && a_src->meta.closed) {
*iop_a_dst++ = wuffs_base__make_token(
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
self->private_impl.f_comment_type = 2;
status = wuffs_base__make_status(NULL);
goto ok;
} else if (v_length > 0) {
*iop_a_dst++ = wuffs_base__make_token(
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
(((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
}
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_json__error__bad_input);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
v_length = 0;
@@ -33085,10 +33699,9 @@ wuffs_json__decoder__decode_comment(
}
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
if (v_c == 10) {
iop_a_src += 1;
*iop_a_dst++ = wuffs_base__make_token(
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
(((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
self->private_impl.f_comment_type = 2;
status = wuffs_base__make_status(NULL);
goto ok;
@@ -33107,7 +33720,6 @@ wuffs_json__decoder__decode_comment(
}
}
goto ok;
ok:
self->private_impl.p_decode_comment[0] = 0;
goto exit;
@@ -33268,7 +33880,6 @@ wuffs_json__decoder__decode_inf_nan(
goto exit;
}
goto ok;
ok:
self->private_impl.p_decode_inf_nan[0] = 0;
goto exit;
@@ -33414,7 +34025,6 @@ wuffs_json__decoder__decode_trailer(
}
label__outer__break:;
goto ok;
ok:
self->private_impl.p_decode_trailer[0] = 0;
goto exit;
@@ -33859,7 +34469,7 @@ wuffs_nie__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (16 != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (16 != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
@@ -33889,7 +34499,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;
@@ -33998,7 +34607,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;
@@ -34064,7 +34672,7 @@ wuffs_nie__decoder__swizzle(
goto label__0__break;
}
}
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
@@ -34088,7 +34696,6 @@ wuffs_nie__decoder__swizzle(
status = wuffs_base__make_status(NULL);
goto ok;
goto ok;
ok:
goto exit;
exit:
@@ -34688,7 +35295,6 @@ wuffs_zlib__decoder__transform_io(
goto exit;
}
goto ok;
ok:
self->private_impl.p_transform_io[0] = 0;
goto exit;
@@ -34721,17 +35327,25 @@ wuffs_zlib__decoder__transform_io(
// ---------------- Status Codes Implementations
const char wuffs_png__error__bad_animation_sequence_number[] = "#png: bad animation sequence number";
const char wuffs_png__error__bad_checksum[] = "#png: bad checksum";
const char wuffs_png__error__bad_chunk[] = "#png: bad chunk";
const char wuffs_png__error__bad_filter[] = "#png: bad filter";
const char wuffs_png__error__bad_header[] = "#png: bad header";
const char wuffs_png__error__bad_text_chunk_not_latin_1[] = "#png: bad text chunk (not Latin-1)";
const char wuffs_png__error__missing_palette[] = "#png: missing palette";
const char wuffs_png__error__unsupported_png_compression_method[] = "#png: unsupported PNG compression method";
const char wuffs_png__error__unsupported_png_file[] = "#png: unsupported PNG file";
const char wuffs_png__error__internal_error_inconsistent_i_o[] = "#png: internal error: inconsistent I/O";
const char wuffs_png__error__internal_error_inconsistent_chunk_type[] = "#png: internal error: inconsistent chunk type";
const char wuffs_png__error__internal_error_inconsistent_frame_bounds[] = "#png: internal error: inconsistent frame bounds";
const char wuffs_png__error__internal_error_inconsistent_workbuf_length[] = "#png: internal error: inconsistent workbuf length";
const char wuffs_png__error__internal_error_zlib_decoder_did_not_exhaust_its_input[] = "#png: internal error: zlib decoder did not exhaust its input";
// ---------------- Private Consts
#define WUFFS_PNG__ANCILLARY_BIT 32
static const uint8_t
WUFFS_PNG__INTERLACING[8][6] WUFFS_BASE__POTENTIALLY_UNUSED = {
{
@@ -34768,6 +35382,42 @@ WUFFS_PNG__NUM_CHANNELS[8] WUFFS_BASE__POTENTIALLY_UNUSED = {
1, 0, 3, 1, 2, 0, 4, 0,
};
static const uint16_t
WUFFS_PNG__LATIN_1[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87,
88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 41410, 41666, 41922, 42178, 42434, 42690, 42946,
43202, 43458, 43714, 43970, 44226, 44482, 44738, 44994,
45250, 45506, 45762, 46018, 46274, 46530, 46786, 47042,
47298, 47554, 47810, 48066, 48322, 48578, 48834, 49090,
32963, 33219, 33475, 33731, 33987, 34243, 34499, 34755,
35011, 35267, 35523, 35779, 36035, 36291, 36547, 36803,
37059, 37315, 37571, 37827, 38083, 38339, 38595, 38851,
39107, 39363, 39619, 39875, 40131, 40387, 40643, 40899,
41155, 41411, 41667, 41923, 42179, 42435, 42691, 42947,
43203, 43459, 43715, 43971, 44227, 44483, 44739, 44995,
45251, 45507, 45763, 46019, 46275, 46531, 46787, 47043,
47299, 47555, 47811, 48067, 48323, 48579, 48835, 49091,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -34877,36 +35527,36 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
static wuffs_base__status
wuffs_png__decoder__decode_ihdr(
@@ -34931,16 +35581,51 @@ wuffs_png__decoder__decode_other_chunk(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_actl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_chrm(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_fctl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_gama(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_iccp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_plte(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_srgb(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_trns(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__skip_frame(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src);
static wuffs_base__status
wuffs_png__decoder__decode_pass(
wuffs_png__decoder* self,
@@ -36114,7 +36799,7 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_1_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
@@ -36154,13 +36839,13 @@ wuffs_png__decoder__filter_1_distance_4_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_3_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
@@ -36259,13 +36944,13 @@ wuffs_png__decoder__filter_3_distance_4_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_4_distance_3_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
@@ -36385,13 +37070,13 @@ wuffs_png__decoder__filter_4_distance_3_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_4_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
@@ -36489,7 +37174,7 @@ wuffs_png__decoder__filter_4_distance_4_x86_sse42(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// -------- func png.decoder.set_quirk_enabled
@@ -36565,172 +37250,210 @@ wuffs_png__decoder__decode_image_config(
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 0) {
if (self->private_impl.f_call_sequence == 2) {
if (self->private_impl.f_metadata_fourcc != 0) {
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
}
} else if (self->private_impl.f_call_sequence != 0) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 56) {
t_0 = ((uint64_t)(*scratch));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_magic = t_0;
}
if (v_magic != 727905341920923785) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 56) {
t_1 = ((uint64_t)(*scratch));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_magic = t_1;
}
if (v_magic != 5927942488114331648) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 72;
self->private_impl.f_chunk_type_array[2] = 68;
self->private_impl.f_chunk_type_array[3] = 82;
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
} else {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__0__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
label__0__break:;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_checksum_want = t_3;
}
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
}
while (true) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
uint64_t t_4;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
if (num_bits_4 == 24) {
t_4 = ((uint64_t)(*scratch >> 32));
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 56) {
t_0 = ((uint64_t)(*scratch));
break;
}
num_bits_4 += 8;
*scratch |= ((uint64_t)(num_bits_4));
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
self->private_impl.f_chunk_length = t_4;
v_magic = t_0;
}
if (v_magic != 727905341920923785) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
iop_a_src += 8;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 56) {
t_1 = ((uint64_t)(*scratch));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_magic = t_1;
}
if (v_magic != 5927942488114331648) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 72;
self->private_impl.f_chunk_type_array[2] = 68;
self->private_impl.f_chunk_type_array[3] = 82;
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__0__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
label__0__break:;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_checksum_want = t_3;
}
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
}
}
while (true) {
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
}
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
if (self->private_impl.f_chunk_type == 1413563465) {
if ( ! self->private_impl.f_seen_actl || self->private_impl.f_seen_fctl) {
goto label__1__break;
}
self->private_impl.f_seen_idat = true;
} else if (self->private_impl.f_chunk_type == 1413571686) {
if (self->private_impl.f_seen_idat && self->private_impl.f_seen_fctl) {
goto label__1__break;
}
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
iop_a_src += 8;
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_4 = wuffs_png__decoder__decode_other_chunk(self, a_src);
v_status = t_4;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__2__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
}
label__2__break:;
if (self->private_impl.f_metadata_fourcc != 0) {
self->private_impl.f_call_sequence = 1;
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
goto ok;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
uint32_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_5 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
@@ -36741,83 +37464,21 @@ wuffs_png__decoder__decode_image_config(
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_5;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 24) {
t_5 = ((uint32_t)(*scratch));
t_5 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5)) << 56;
*scratch |= ((uint64_t)(num_bits_5));
}
}
self->private_impl.f_chunk_type = t_5;
v_checksum_want = t_5;
}
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type == 1413563465) || (self->private_impl.f_chunk_type == 1163152464))) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
if (self->private_impl.f_chunk_type == 1413563465) {
goto label__1__break;
}
while (true) {
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_6 = wuffs_png__decoder__decode_other_chunk(self, a_src);
v_status = t_6;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
if (wuffs_base__status__is_ok(&v_status)) {
goto label__2__break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(12);
}
label__2__break:;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
uint32_t t_7;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_7 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_image_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
if (num_bits_7 == 24) {
t_7 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_7 += 8;
*scratch |= ((uint64_t)(num_bits_7));
}
}
v_checksum_want = t_7;
}
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464) && (v_checksum_have != v_checksum_want)) {
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0) && (v_checksum_have != v_checksum_want)) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
}
@@ -36827,7 +37488,8 @@ wuffs_png__decoder__decode_image_config(
status = wuffs_base__make_status(wuffs_png__error__missing_palette);
goto exit;
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_first_config_io_position = self->private_impl.f_frame_config_io_position;
if (a_dst != NULL) {
wuffs_base__image_config__set(
a_dst,
@@ -36835,12 +37497,21 @@ wuffs_png__decoder__decode_image_config(
0,
self->private_impl.f_width,
self->private_impl.f_height,
self->private_impl.f_frame_config_io_position,
self->private_impl.f_first_config_io_position,
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns));
}
if ( ! self->private_impl.f_seen_actl) {
self->private_impl.f_num_animation_frames_value = 1;
self->private_impl.f_first_rect_x0 = 0;
self->private_impl.f_first_rect_y0 = 0;
self->private_impl.f_first_rect_x1 = self->private_impl.f_width;
self->private_impl.f_first_rect_y1 = self->private_impl.f_height;
self->private_impl.f_first_duration = 0;
self->private_impl.f_first_disposal = 0;
self->private_impl.f_first_overwrite_instead_of_blend = false;
}
self->private_impl.f_call_sequence = 3;
goto ok;
ok:
self->private_impl.p_decode_image_config[0] = 0;
goto exit;
@@ -37002,7 +37673,7 @@ wuffs_png__decoder__decode_ihdr(
v_a8 = t_4;
}
if (v_a8 != 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_header);
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
{
@@ -37040,7 +37711,7 @@ wuffs_png__decoder__decode_ihdr(
self->private_impl.f_filter_distance = 0;
wuffs_png__decoder__assign_filter_distance(self);
if (self->private_impl.f_filter_distance == 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
status = wuffs_base__make_status(wuffs_png__error__bad_header);
goto exit;
}
self->private_impl.f_overall_workbuf_length = (((uint64_t)(self->private_impl.f_height)) * (1 + wuffs_png__decoder__calculate_bytes_per_row(self, self->private_impl.f_width)));
@@ -37071,7 +37742,9 @@ static wuffs_base__empty_struct
wuffs_png__decoder__assign_filter_distance(
wuffs_png__decoder* self) {
if (self->private_impl.f_depth < 8) {
if (self->private_impl.f_color_type == 0) {
if ((self->private_impl.f_depth != 1) && (self->private_impl.f_depth != 2) && (self->private_impl.f_depth != 4)) {
return wuffs_base__make_empty_struct();
} else if (self->private_impl.f_color_type == 0) {
self->private_impl.f_dst_pixfmt = 536870920;
self->private_impl.f_src_pixfmt = 536870920;
} else if (self->private_impl.f_color_type == 3) {
@@ -37174,7 +37847,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_3_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_3_x86_sse42 :
#endif
&wuffs_png__decoder__filter_4_distance_3_fallback);
@@ -37183,7 +37856,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_1_distance_4_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_1_distance_4_x86_sse42 :
#endif
&wuffs_png__decoder__filter_1_distance_4_fallback);
@@ -37191,7 +37864,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_3_distance_4_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_3_distance_4_x86_sse42 :
#endif
&wuffs_png__decoder__filter_3_distance_4_fallback);
@@ -37199,7 +37872,7 @@ wuffs_png__decoder__choose_filter_implementations(
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_4_arm_neon :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_4_x86_sse42 :
#endif
&wuffs_png__decoder__filter_4_distance_4_fallback);
@@ -37247,6 +37920,121 @@ wuffs_png__decoder__decode_other_chunk(
goto suspend;
}
self->private_impl.f_seen_plte = true;
} else if ((self->private_impl.f_chunk_type & 32) == 0) {
if (self->private_impl.f_chunk_type != 1413563465) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
} else if (self->private_impl.f_chunk_type == 1280598881) {
if (self->private_impl.f_seen_actl) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_png__decoder__decode_actl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_actl = true;
} else if (self->private_impl.f_chunk_type == 1297238115) {
if (self->private_impl.f_report_metadata_chrm) {
if (self->private_impl.f_seen_chrm) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_png__decoder__decode_chrm(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_chrm = true;
}
} else if (self->private_impl.f_chunk_type == 1280598886) {
if (self->private_impl.f_seen_fctl) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_png__decoder__decode_fctl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_fctl = true;
} else if (self->private_impl.f_chunk_type == 1095582055) {
if (self->private_impl.f_report_metadata_gama) {
if (self->private_impl.f_seen_gama) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_png__decoder__decode_gama(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_gama = true;
}
} else if (self->private_impl.f_chunk_type == 1346585449) {
if (self->private_impl.f_report_metadata_iccp) {
if (self->private_impl.f_seen_iccp) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_png__decoder__decode_iccp(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_iccp = true;
}
} else if (self->private_impl.f_chunk_type == 1111970419) {
if (self->private_impl.f_report_metadata_srgb) {
if (self->private_impl.f_seen_srgb) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_png__decoder__decode_srgb(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_seen_srgb = true;
}
} else if (self->private_impl.f_chunk_type == 1397641844) {
if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3) || ((self->private_impl.f_color_type == 3) && ! self->private_impl.f_seen_plte)) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
@@ -37255,7 +38043,7 @@ wuffs_png__decoder__decode_other_chunk(
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_png__decoder__decode_trns(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -37264,9 +38052,18 @@ wuffs_png__decoder__decode_other_chunk(
goto suspend;
}
self->private_impl.f_seen_trns = true;
} else {
} else if ((self->private_impl.f_chunk_type == 1951945833) || (self->private_impl.f_chunk_type == 1951942004) || (self->private_impl.f_chunk_type == 1951945850)) {
if (self->private_impl.f_report_metadata_kvp) {
self->private_impl.f_metadata_flavor = 4;
self->private_impl.f_metadata_fourcc = 1263947851;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
}
}
if (self->private_impl.f_metadata_fourcc == 0) {
self->private_data.s_decode_other_chunk[0].scratch = self->private_impl.f_chunk_length;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
if (self->private_data.s_decode_other_chunk[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_other_chunk[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
@@ -37295,6 +38092,923 @@ wuffs_png__decoder__decode_other_chunk(
return status;
}
// -------- func png.decoder.decode_actl
static wuffs_base__status
wuffs_png__decoder__decode_actl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_actl[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 8) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
} else if (self->private_impl.f_interlace_pass > 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_actl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
self->private_impl.f_num_animation_frames_value = t_0;
}
if (self->private_impl.f_num_animation_frames_value == 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_actl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
self->private_impl.f_num_animation_loops_value = t_1;
}
goto ok;
ok:
self->private_impl.p_decode_actl[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_actl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_chrm
static wuffs_base__status
wuffs_png__decoder__decode_chrm(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_u = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_chrm[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 32) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
self->private_impl.f_metadata_flavor = 5;
self->private_impl.f_metadata_fourcc = 1128813133;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_u = t_0;
}
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 0);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
v_u = t_1;
}
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 24);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint64_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
if (num_bits_2 == 24) {
t_2 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_2 += 8;
*scratch |= ((uint64_t)(num_bits_2));
}
}
v_u = t_2;
}
self->private_impl.f_metadata_x |= ((uint64_t)((16777215 & v_u) << 48));
self->private_impl.f_metadata_y |= ((16777215 & v_u) >> 16);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
uint64_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_u = t_3;
}
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 8);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
uint64_t t_4;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
if (num_bits_4 == 24) {
t_4 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_4 += 8;
*scratch |= ((uint64_t)(num_bits_4));
}
}
v_u = t_4;
}
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 32);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
uint64_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_5 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 24) {
t_5 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5));
}
}
v_u = t_5;
}
self->private_impl.f_metadata_y |= ((uint64_t)((16777215 & v_u) << 56));
self->private_impl.f_metadata_z |= ((16777215 & v_u) >> 8);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
uint64_t t_6;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_6 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
if (num_bits_6 == 24) {
t_6 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_6 += 8;
*scratch |= ((uint64_t)(num_bits_6));
}
}
v_u = t_6;
}
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 16);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
uint64_t t_7;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_7 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_chrm[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
if (num_bits_7 == 24) {
t_7 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_7 += 8;
*scratch |= ((uint64_t)(num_bits_7));
}
}
v_u = t_7;
}
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 40);
goto ok;
ok:
self->private_impl.p_decode_chrm[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_chrm[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_fctl
static wuffs_base__status
wuffs_png__decoder__decode_fctl(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_x0 = 0;
uint32_t v_y0 = 0;
uint32_t v_x1 = 0;
uint32_t v_y1 = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_fctl[0];
if (coro_susp_point) {
v_x0 = self->private_data.s_decode_fctl[0].v_x0;
v_x1 = self->private_data.s_decode_fctl[0].v_x1;
v_y1 = self->private_data.s_decode_fctl[0].v_y1;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 26) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_x0 = t_0;
}
if (v_x0 != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
v_x1 = t_1;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
if (num_bits_2 == 24) {
t_2 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_2 += 8;
*scratch |= ((uint64_t)(num_bits_2));
}
}
v_y1 = t_2;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
*scratch |= ((uint64_t)(num_bits_3));
}
}
v_x0 = t_3;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
uint32_t t_4;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_4 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
if (num_bits_4 == 24) {
t_4 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_4 += 8;
*scratch |= ((uint64_t)(num_bits_4));
}
}
v_y0 = t_4;
}
v_x1 += v_x0;
v_y1 += v_y0;
if ((v_x0 >= v_x1) ||
(v_x0 > self->private_impl.f_width) ||
(v_x1 > self->private_impl.f_width) ||
(v_y0 >= v_y1) ||
(v_y0 > self->private_impl.f_height) ||
(v_y1 > self->private_impl.f_height)) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_frame_rect_x0 = v_x0;
self->private_impl.f_frame_rect_y0 = v_y0;
self->private_impl.f_frame_rect_x1 = v_x1;
self->private_impl.f_frame_rect_y1 = v_y1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
uint32_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
t_5 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 8) {
t_5 = ((uint32_t)(*scratch >> 48));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5));
}
}
v_x0 = t_5;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
uint32_t t_6;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
t_6 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2;
} else {
self->private_data.s_decode_fctl[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
if (num_bits_6 == 8) {
t_6 = ((uint32_t)(*scratch >> 48));
break;
}
num_bits_6 += 8;
*scratch |= ((uint64_t)(num_bits_6));
}
}
v_x1 = t_6;
}
if (v_x1 <= 0) {
self->private_impl.f_frame_duration = (((uint64_t)(v_x0)) * 7056000);
} else {
self->private_impl.f_frame_duration = ((((uint64_t)(v_x0)) * 705600000) / ((uint64_t)(v_x1)));
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_7 = *iop_a_src++;
v_x0 = t_7;
}
if (v_x0 == 0) {
self->private_impl.f_frame_disposal = 0;
} else if (v_x0 == 1) {
self->private_impl.f_frame_disposal = 1;
} else if (v_x0 == 2) {
self->private_impl.f_frame_disposal = 2;
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_8 = *iop_a_src++;
v_x0 = t_8;
}
if (v_x0 == 0) {
self->private_impl.f_frame_overwrite_instead_of_blend = true;
} else if (v_x0 == 1) {
self->private_impl.f_frame_overwrite_instead_of_blend = false;
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
self->private_impl.f_first_rect_x0 = self->private_impl.f_frame_rect_x0;
self->private_impl.f_first_rect_y0 = self->private_impl.f_frame_rect_y0;
self->private_impl.f_first_rect_x1 = self->private_impl.f_frame_rect_x1;
self->private_impl.f_first_rect_y1 = self->private_impl.f_frame_rect_y1;
self->private_impl.f_first_duration = self->private_impl.f_frame_duration;
self->private_impl.f_first_disposal = self->private_impl.f_frame_disposal;
self->private_impl.f_first_overwrite_instead_of_blend = self->private_impl.f_frame_overwrite_instead_of_blend;
}
goto ok;
ok:
self->private_impl.p_decode_fctl[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_fctl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_fctl[0].v_x0 = v_x0;
self->private_data.s_decode_fctl[0].v_x1 = v_x1;
self->private_data.s_decode_fctl[0].v_y1 = v_y1;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_gama
static wuffs_base__status
wuffs_png__decoder__decode_gama(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_gama[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 4) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
self->private_impl.f_metadata_flavor = 5;
self->private_impl.f_metadata_fourcc = 1195461953;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
iop_a_src += 4;
} else {
self->private_data.s_decode_gama[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_gama[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint64_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
self->private_impl.f_metadata_x = t_0;
}
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
goto ok;
ok:
self->private_impl.p_decode_gama[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_gama[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_iccp
static wuffs_base__status
wuffs_png__decoder__decode_iccp(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_iccp[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
v_c = t_0;
}
if (v_c == 0) {
goto label__0__break;
}
}
label__0__break:;
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_1 = *iop_a_src++;
v_c = t_1;
}
if (v_c != 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
self->private_impl.f_metadata_is_zlib_compressed = true;
self->private_impl.f_metadata_flavor = 4;
self->private_impl.f_metadata_fourcc = 1229144912;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
goto ok;
ok:
self->private_impl.p_decode_iccp[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_iccp[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_plte
static wuffs_base__status
@@ -37331,6 +39045,7 @@ wuffs_png__decoder__decode_plte(
goto exit;
}
v_num_entries = (((uint32_t)(self->private_impl.f_chunk_length)) / 3);
self->private_impl.f_chunk_length = 0;
while (v_i < v_num_entries) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
@@ -37397,6 +39112,67 @@ wuffs_png__decoder__decode_plte(
return status;
}
// -------- func png.decoder.decode_srgb
static wuffs_base__status
wuffs_png__decoder__decode_srgb(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_srgb[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length != 1) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
self->private_impl.f_metadata_flavor = 5;
self->private_impl.f_metadata_fourcc = 1397901122;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t t_0 = *iop_a_src++;
self->private_impl.f_metadata_x = t_0;
}
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
goto ok;
ok:
self->private_impl.p_decode_srgb[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_srgb[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_trns
static wuffs_base__status
@@ -37405,8 +39181,9 @@ wuffs_png__decoder__decode_trns(
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_num_entries = 0;
uint32_t v_i = 0;
uint32_t v_n = 0;
uint64_t v_u = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -37421,42 +39198,143 @@ wuffs_png__decoder__decode_trns(
uint32_t coro_susp_point = self->private_impl.p_decode_trns[0];
if (coro_susp_point) {
v_num_entries = self->private_data.s_decode_trns[0].v_num_entries;
v_i = self->private_data.s_decode_trns[0].v_i;
v_n = self->private_data.s_decode_trns[0].v_n;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_chunk_length > 256) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
v_num_entries = ((uint32_t)(self->private_impl.f_chunk_length));
while (v_i < v_num_entries) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_0 = *iop_a_src++;
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_0;
}
v_i += 1;
}
if (self->private_impl.f_color_type == 3) {
self->private_impl.f_dst_pixfmt = 2164523016;
self->private_impl.f_src_pixfmt = 2164523016;
} else {
if (self->private_impl.f_color_type == 0) {
self->private_impl.choosy_filter_and_swizzle = (
&wuffs_png__decoder__filter_and_swizzle_tricky);
if (self->private_impl.f_color_type == 0) {
self->private_impl.f_dst_pixfmt = 2164295816;
self->private_impl.f_src_pixfmt = 2164308923;
} else if (self->private_impl.f_color_type == 2) {
if (self->private_impl.f_depth <= 8) {
self->private_impl.f_dst_pixfmt = 2164295816;
self->private_impl.f_src_pixfmt = 2164295816;
} else {
self->private_impl.f_dst_pixfmt = 2164308923;
self->private_impl.f_src_pixfmt = 2164308923;
}
if (self->private_impl.f_chunk_length != 2) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint64_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
t_0 = ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2;
} else {
self->private_data.s_decode_trns[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 8) {
t_0 = ((uint64_t)(*scratch >> 48));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_u = t_0;
}
if (self->private_impl.f_depth <= 1) {
self->private_impl.f_remap_transparency = (((v_u & 1) * 16777215) | 4278190080);
} else if (self->private_impl.f_depth <= 2) {
self->private_impl.f_remap_transparency = (((v_u & 3) * 5592405) | 4278190080);
} else if (self->private_impl.f_depth <= 4) {
self->private_impl.f_remap_transparency = (((v_u & 15) * 1118481) | 4278190080);
} else if (self->private_impl.f_depth <= 8) {
self->private_impl.f_remap_transparency = (((v_u & 255) * 65793) | 4278190080);
} else {
self->private_impl.f_remap_transparency = ((v_u * 4295032833) | 18446462598732840960u);
}
} else if (self->private_impl.f_color_type == 2) {
self->private_impl.choosy_filter_and_swizzle = (
&wuffs_png__decoder__filter_and_swizzle_tricky);
if (self->private_impl.f_depth <= 8) {
self->private_impl.f_dst_pixfmt = 2164295816;
self->private_impl.f_src_pixfmt = 2164295816;
} else {
self->private_impl.f_dst_pixfmt = 2164308923;
self->private_impl.f_src_pixfmt = 2164308923;
}
if (self->private_impl.f_chunk_length != 6) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length = 0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint64_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 6)) {
t_1 = ((uint64_t)(wuffs_base__peek_u48be__no_bounds_check(iop_a_src)));
iop_a_src += 6;
} else {
self->private_data.s_decode_trns[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 40) {
t_1 = ((uint64_t)(*scratch >> 16));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
}
v_u = t_1;
}
if (self->private_impl.f_depth <= 8) {
self->private_impl.f_remap_transparency = ((255 & (v_u >> 0)) |
(65280 & (v_u >> 8)) |
(16711680 & (v_u >> 16)) |
4278190080);
} else {
self->private_impl.f_remap_transparency = (v_u | 18446462598732840960u);
}
} else if (self->private_impl.f_color_type == 3) {
self->private_impl.f_dst_pixfmt = 2164523016;
self->private_impl.f_src_pixfmt = 2164523016;
if (self->private_impl.f_chunk_length > 256) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
v_n = ((uint32_t)(self->private_impl.f_chunk_length));
self->private_impl.f_chunk_length = 0;
while (v_i < v_n) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_2 = *iop_a_src++;
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_2;
}
v_i += 1;
}
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
goto ok;
@@ -37468,8 +39346,8 @@ wuffs_png__decoder__decode_trns(
goto suspend;
suspend:
self->private_impl.p_decode_trns[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_trns[0].v_num_entries = v_num_entries;
self->private_data.s_decode_trns[0].v_i = v_i;
self->private_data.s_decode_trns[0].v_n = v_n;
goto exit;
exit:
@@ -37523,7 +39401,10 @@ wuffs_png__decoder__decode_frame_config(
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence < 3) {
if (self->private_impl.f_call_sequence == 255) {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else if (self->private_impl.f_call_sequence < 3) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
@@ -37536,37 +39417,155 @@ wuffs_png__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
} else if (self->private_impl.f_call_sequence == 4) {
self->private_impl.f_call_sequence = 255;
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_png__decoder__skip_frame(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (self->private_impl.f_call_sequence == 255) {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
}
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
self->private_impl.f_frame_rect_x0 = self->private_impl.f_first_rect_x0;
self->private_impl.f_frame_rect_y0 = self->private_impl.f_first_rect_y0;
self->private_impl.f_frame_rect_x1 = self->private_impl.f_first_rect_x1;
self->private_impl.f_frame_rect_y1 = self->private_impl.f_first_rect_y1;
self->private_impl.f_frame_config_io_position = self->private_impl.f_first_config_io_position;
self->private_impl.f_frame_duration = self->private_impl.f_first_duration;
self->private_impl.f_frame_disposal = self->private_impl.f_first_disposal;
self->private_impl.f_frame_overwrite_instead_of_blend = self->private_impl.f_first_overwrite_instead_of_blend;
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
while (true) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_frame_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
self->private_impl.f_chunk_length = t_0;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_frame_config[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
self->private_impl.f_chunk_type = t_1;
}
if (self->private_impl.f_chunk_type == 1413571686) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
} else if (self->private_impl.f_chunk_type == 1280598886) {
self->private_impl.f_frame_config_io_position = ((uint64_t)(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) - 8));
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_png__decoder__decode_fctl(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_data.s_decode_frame_config[0].scratch = 4;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
goto label__0__break;
}
self->private_data.s_decode_frame_config[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
self->private_impl.f_chunk_length = 0;
}
label__0__break:;
}
if (a_dst != NULL) {
wuffs_base__frame_config__set(
a_dst,
wuffs_base__utility__make_rect_ie_u32(
0,
0,
self->private_impl.f_width,
self->private_impl.f_height),
((wuffs_base__flicks)(0)),
0,
self->private_impl.f_frame_rect_x0,
self->private_impl.f_frame_rect_y0,
self->private_impl.f_frame_rect_x1,
self->private_impl.f_frame_rect_y1),
((wuffs_base__flicks)(self->private_impl.f_frame_duration)),
((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value)),
self->private_impl.f_frame_config_io_position,
0,
false,
false,
self->private_impl.f_frame_disposal,
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns),
self->private_impl.f_frame_overwrite_instead_of_blend,
0);
}
wuffs_base__u32__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;
@@ -37589,6 +39588,162 @@ wuffs_png__decoder__decode_frame_config(
return status;
}
// -------- func png.decoder.skip_frame
static wuffs_base__status
wuffs_png__decoder__skip_frame(
wuffs_png__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_seq_num = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_skip_frame[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
self->private_impl.f_chunk_type_array[0] = 0;
self->private_impl.f_chunk_type_array[1] = 0;
self->private_impl.f_chunk_type_array[2] = 0;
self->private_impl.f_chunk_type_array[3] = 0;
label__0__continue:;
while (true) {
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
if (self->private_impl.f_chunk_type == 1413563465) {
if (self->private_impl.f_chunk_type_array[0] == 102) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 68;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
} else if (self->private_impl.f_chunk_type == 1413571686) {
if (self->private_impl.f_chunk_type_array[0] == 73) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_type_array[0] = 102;
self->private_impl.f_chunk_type_array[1] = 100;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
if (self->private_impl.f_chunk_length < 4) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 4;
iop_a_src += 8;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_skip_frame[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_skip_frame[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_seq_num = t_0;
}
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_skip_frame[0].scratch;
self->private_impl.f_chunk_length = 0;
goto label__0__continue;
} else if (self->private_impl.f_chunk_type_array[0] != 0) {
goto label__0__break;
} else if (self->private_impl.f_chunk_type == 1280598886) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_skip_frame[0].scratch;
self->private_impl.f_chunk_length = 0;
}
label__0__break:;
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
self->private_impl.f_call_sequence = 5;
} else {
self->private_impl.f_call_sequence = 255;
}
ok:
self->private_impl.p_skip_frame[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_skip_frame[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func png.decoder.decode_frame
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
@@ -37620,25 +39775,138 @@ wuffs_png__decoder__decode_frame(
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_seq_num = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t v_pass_width = 0;
uint32_t v_pass_height = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_frame[0];
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence < 4) {
if (self->private_impl.f_call_sequence == 255) {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else if (self->private_impl.f_call_sequence != 4) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_png__decoder__decode_frame_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 4) {
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
while (true) {
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
if (a_src && a_src->meta.closed) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
}
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
if (self->private_impl.f_chunk_type == 1413563465) {
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 68;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
iop_a_src += 8;
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
goto label__0__break;
} else if (self->private_impl.f_chunk_type == 1413571686) {
self->private_impl.f_chunk_type_array[0] = 102;
self->private_impl.f_chunk_type_array[1] = 100;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
if (self->private_impl.f_chunk_length < 4) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 4;
iop_a_src += 8;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_frame[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_frame[0].scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_0 += 8;
*scratch |= ((uint64_t)(num_bits_0));
}
}
v_seq_num = t_0;
}
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
goto label__0__break;
} else if (self->private_impl.f_chunk_type == 1280598886) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_data.s_decode_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
if (self->private_data.s_decode_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_decode_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_decode_frame[0].scratch;
self->private_impl.f_chunk_length = 0;
}
label__0__break:;
if (self->private_impl.f_zlib_is_dirty) {
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
if (self->private_impl.f_ignore_checksum) {
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
}
}
self->private_impl.f_zlib_is_dirty = true;
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
wuffs_base__pixel_buffer__pixel_format(a_dst),
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
@@ -37655,14 +39923,26 @@ wuffs_png__decoder__decode_frame(
}
goto ok;
}
self->private_impl.f_workbuf_hist_pos_base = 0;
while (true) {
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
if (self->private_impl.f_chunk_type_array[0] == 73) {
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
} else {
v_pass_width = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_x1 - self->private_impl.f_frame_rect_x0)));
v_pass_height = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_y1 - self->private_impl.f_frame_rect_y0)));
}
if ((v_pass_width > 0) && (v_pass_height > 0)) {
self->private_impl.f_pass_bytes_per_row = wuffs_png__decoder__calculate_bytes_per_row(self, v_pass_width);
self->private_impl.f_pass_workbuf_length = (((uint64_t)(v_pass_height)) * (1 + self->private_impl.f_pass_bytes_per_row));
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_png__decoder__decode_pass(self, a_src, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
@@ -37677,9 +39957,10 @@ wuffs_png__decoder__decode_frame(
}
goto ok;
}
self->private_impl.f_workbuf_hist_pos_base += self->private_impl.f_pass_workbuf_length;
}
if ((self->private_impl.f_interlace_pass == 0) || (self->private_impl.f_interlace_pass >= 7)) {
goto label__0__break;
goto label__1__break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
@@ -37690,10 +39971,14 @@ wuffs_png__decoder__decode_frame(
#pragma GCC diagnostic pop
#endif
}
label__0__break:;
self->private_impl.f_call_sequence = 255;
label__1__break:;
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
self->private_impl.f_call_sequence = 5;
} else {
self->private_impl.f_call_sequence = 255;
}
goto ok;
ok:
self->private_impl.p_decode_frame[0] = 0;
goto exit;
@@ -37706,6 +39991,10 @@ wuffs_png__decoder__decode_frame(
goto exit;
exit:
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
@@ -37732,6 +40021,7 @@ wuffs_png__decoder__decode_pass(
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
uint32_t v_checksum_have = 0;
uint32_t v_checksum_want = 0;
uint32_t v_seq_num = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -37745,9 +40035,6 @@ wuffs_png__decoder__decode_pass(
}
uint32_t coro_susp_point = self->private_impl.p_decode_pass[0];
if (coro_susp_point) {
v_checksum_have = self->private_data.s_decode_pass[0].v_checksum_have;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -37772,11 +40059,12 @@ wuffs_png__decoder__decode_pass(
&io2_v_w,
wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_workbuf_wi,
self->private_impl.f_pass_workbuf_length));
self->private_impl.f_pass_workbuf_length),
((uint64_t)(self->private_impl.f_workbuf_hist_pos_base + self->private_impl.f_workbuf_wi)));
{
const uint8_t *o_1_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
self->private_impl.f_chunk_length);
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
@@ -37797,7 +40085,7 @@ wuffs_png__decoder__decode_pass(
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
}
wuffs_base__u64__sat_sub_indirect(&self->private_impl.f_chunk_length, wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))));
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_workbuf_wi, wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w))));
io2_a_src = o_1_io2_a_src;
if (a_src) {
@@ -37811,41 +40099,41 @@ wuffs_png__decoder__decode_pass(
io2_v_w = o_0_io2_v_w;
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
if ( ! self->private_impl.f_ignore_checksum) {
if (self->private_impl.f_chunk_length > 0) {
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
goto exit;
}
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
if (self->private_impl.f_chunk_length > 0) {
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_1 += 8;
*scratch |= ((uint64_t)(num_bits_1));
}
v_checksum_want = t_1;
}
v_checksum_want = t_1;
}
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
if (v_checksum_have != v_checksum_want) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
goto exit;
@@ -37897,7 +40185,7 @@ wuffs_png__decoder__decode_pass(
}
v_checksum_want = t_2;
}
if ( ! self->private_impl.f_ignore_checksum) {
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
if (v_checksum_have != v_checksum_want) {
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
@@ -37906,9 +40194,9 @@ wuffs_png__decoder__decode_pass(
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint64_t t_3;
uint32_t t_3;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
@@ -37924,7 +40212,7 @@ wuffs_png__decoder__decode_pass(
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
if (num_bits_3 == 24) {
t_3 = ((uint64_t)(*scratch >> 32));
t_3 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_3 += 8;
@@ -37962,17 +40250,59 @@ wuffs_png__decoder__decode_pass(
}
self->private_impl.f_chunk_type = t_4;
}
if (self->private_impl.f_chunk_type != 1413563465) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
self->private_impl.f_chunk_type_array[0] = 73;
self->private_impl.f_chunk_type_array[1] = 68;
self->private_impl.f_chunk_type_array[2] = 65;
self->private_impl.f_chunk_type_array[3] = 84;
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
if (self->private_impl.f_chunk_type_array[0] == 73) {
if (self->private_impl.f_chunk_type != 1413563465) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
if ( ! self->private_impl.f_ignore_checksum) {
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
}
} else {
if ((self->private_impl.f_chunk_type != 1413571686) || (self->private_impl.f_chunk_length < 4)) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 4;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
uint32_t t_5;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_decode_pass[0].scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
*scratch >>= 8;
*scratch <<= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
if (num_bits_5 == 24) {
t_5 = ((uint32_t)(*scratch >> 32));
break;
}
num_bits_5 += 8;
*scratch |= ((uint64_t)(num_bits_5));
}
}
v_seq_num = t_5;
}
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
goto exit;
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
goto exit;
}
self->private_impl.f_next_animation_seq_num += 1;
}
goto label__0__continue;
} else if (((uint64_t)(io2_a_src - iop_a_src)) > 0) {
@@ -37980,7 +40310,7 @@ wuffs_png__decoder__decode_pass(
goto exit;
}
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
}
label__0__break:;
if (self->private_impl.f_workbuf_wi != self->private_impl.f_pass_workbuf_length) {
@@ -37992,7 +40322,6 @@ wuffs_png__decoder__decode_pass(
}
}
goto ok;
ok:
self->private_impl.p_decode_pass[0] = 0;
goto exit;
@@ -38001,7 +40330,6 @@ wuffs_png__decoder__decode_pass(
goto suspend;
suspend:
self->private_impl.p_decode_pass[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_pass[0].v_checksum_have = v_checksum_have;
goto exit;
exit:
@@ -38026,10 +40354,10 @@ wuffs_png__decoder__frame_dirty_rect(
}
return wuffs_base__utility__make_rect_ie_u32(
0,
0,
self->private_impl.f_width,
self->private_impl.f_height);
self->private_impl.f_frame_rect_x0,
self->private_impl.f_frame_rect_y0,
self->private_impl.f_frame_rect_x1,
self->private_impl.f_frame_rect_y1);
}
// -------- func png.decoder.num_animation_loops
@@ -38045,7 +40373,7 @@ wuffs_png__decoder__num_animation_loops(
return 0;
}
return 0;
return self->private_impl.f_num_animation_loops_value;
}
// -------- func png.decoder.num_decoded_frame_configs
@@ -38061,10 +40389,7 @@ wuffs_png__decoder__num_decoded_frame_configs(
return 0;
}
if (self->private_impl.f_call_sequence > 3) {
return 1;
}
return 0;
return ((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value));
}
// -------- func png.decoder.num_decoded_frames
@@ -38080,10 +40405,7 @@ wuffs_png__decoder__num_decoded_frames(
return 0;
}
if (self->private_impl.f_call_sequence > 4) {
return 1;
}
return 0;
return ((uint64_t)(self->private_impl.f_num_decoded_frames_value));
}
// -------- func png.decoder.restart_frame
@@ -38105,8 +40427,7 @@ wuffs_png__decoder__restart_frame(
if (self->private_impl.f_call_sequence < 3) {
return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
}
if (a_index != 0) {
} else if ((a_index >= ((uint64_t)(self->private_impl.f_num_animation_frames_value))) || ((a_index == 0) && (a_io_position != self->private_impl.f_first_config_io_position))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
self->private_impl.f_call_sequence = 3;
@@ -38114,6 +40435,8 @@ wuffs_png__decoder__restart_frame(
self->private_impl.f_interlace_pass = 1;
}
self->private_impl.f_frame_config_io_position = a_io_position;
self->private_impl.f_num_decoded_frame_configs_value = ((uint32_t)((a_index & 4294967295)));
self->private_impl.f_num_decoded_frames_value = self->private_impl.f_num_decoded_frame_configs_value;
return wuffs_base__make_status(NULL);
}
@@ -38124,6 +40447,24 @@ wuffs_png__decoder__set_report_metadata(
wuffs_png__decoder* self,
uint32_t a_fourcc,
bool a_report) {
if (!self) {
return wuffs_base__make_empty_struct();
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_empty_struct();
}
if (a_fourcc == 1128813133) {
self->private_impl.f_report_metadata_chrm = a_report;
} else if (a_fourcc == 1195461953) {
self->private_impl.f_report_metadata_gama = a_report;
} else if (a_fourcc == 1229144912) {
self->private_impl.f_report_metadata_iccp = a_report;
} else if (a_fourcc == 1263947808) {
self->private_impl.f_report_metadata_kvp = a_report;
} else if (a_fourcc == 1397901122) {
self->private_impl.f_report_metadata_srgb = a_report;
}
return wuffs_base__make_empty_struct();
}
@@ -38156,13 +40497,471 @@ wuffs_png__decoder__tell_me_more(
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
goto exit;
uint8_t v_c = 0;
uint16_t v_c2 = 0;
wuffs_base__io_buffer u_w = wuffs_base__empty_io_buffer();
wuffs_base__io_buffer* v_w = &u_w;
uint8_t* iop_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io0_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io1_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io2_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint64_t v_num_written = 0;
uint64_t v_w_mark = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
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;
}
uint32_t coro_susp_point = self->private_impl.p_tell_me_more[0];
if (coro_susp_point) {
v_zlib_status = self->private_data.s_tell_me_more[0].v_zlib_status;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 1) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
if (self->private_impl.f_metadata_fourcc == 0) {
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
goto exit;
}
if (self->private_impl.f_metadata_is_zlib_compressed) {
if (self->private_impl.f_zlib_is_dirty) {
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
if (self->private_impl.f_ignore_checksum) {
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
}
}
self->private_impl.f_zlib_is_dirty = true;
self->private_impl.f_ztxt_hist_pos = 0;
}
label__loop__continue:;
while (true) {
if (a_minfo != NULL) {
wuffs_base__more_information__set(a_minfo,
self->private_impl.f_metadata_flavor,
self->private_impl.f_metadata_fourcc,
self->private_impl.f_metadata_x,
self->private_impl.f_metadata_y,
self->private_impl.f_metadata_z);
}
if (self->private_impl.f_metadata_flavor != 4) {
goto label__loop__break;
}
if (self->private_impl.f_metadata_is_zlib_compressed) {
if (self->private_impl.f_chunk_type == 1346585449) {
{
const uint8_t *o_0_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
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));
}
wuffs_base__status t_0 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
v_zlib_status = t_0;
if (a_dst) {
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
}
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
self->private_impl.f_metadata_is_zlib_compressed = false;
goto label__loop__break;
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
status = v_zlib_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
status = v_zlib_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
} else if (self->private_impl.f_chunk_type == 1951945833) {
{
const uint8_t *o_1_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
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));
}
wuffs_base__status t_1 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
v_zlib_status = t_1;
if (a_dst) {
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
}
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
io2_a_src = o_1_io2_a_src;
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
self->private_impl.f_metadata_is_zlib_compressed = false;
goto label__loop__break;
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
status = v_zlib_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
status = v_zlib_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
} else if (self->private_impl.f_chunk_type == 1951945850) {
if (self->private_impl.f_ztxt_ri == self->private_impl.f_ztxt_wi) {
{
wuffs_base__io_buffer* o_2_v_w = v_w;
uint8_t *o_2_iop_v_w = iop_v_w;
uint8_t *o_2_io0_v_w = io0_v_w;
uint8_t *o_2_io1_v_w = io1_v_w;
uint8_t *o_2_io2_v_w = io2_v_w;
v_w = wuffs_base__io_writer__set(
&u_w,
&iop_v_w,
&io0_v_w,
&io1_v_w,
&io2_v_w,
wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024),
self->private_impl.f_ztxt_hist_pos);
{
const uint8_t *o_3_io2_a_src = io2_a_src;
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_chunk_length)));
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
v_w_mark = ((uint64_t)(iop_v_w - io0_v_w));
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
u_w.meta.wi = ((size_t)(iop_v_w - u_w.data.ptr));
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, v_w, a_src, wuffs_base__utility__empty_slice_u8());
v_zlib_status = t_2;
iop_v_w = u_w.data.ptr + u_w.meta.wi;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
v_num_written = wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w)));
io2_a_src = o_3_io2_a_src;
if (a_src) {
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
v_w = o_2_v_w;
iop_v_w = o_2_iop_v_w;
io0_v_w = o_2_io0_v_w;
io1_v_w = o_2_io1_v_w;
io2_v_w = o_2_io2_v_w;
}
if (v_num_written > 1024) {
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_i_o);
goto exit;
}
self->private_impl.f_ztxt_ri = 0;
self->private_impl.f_ztxt_wi = ((uint32_t)(v_num_written));
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_ztxt_hist_pos, v_num_written);
}
while (self->private_impl.f_ztxt_ri < self->private_impl.f_ztxt_wi) {
v_c2 = WUFFS_PNG__LATIN_1[self->private_data.f_dst_palette[self->private_impl.f_ztxt_ri]];
if (v_c2 == 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
goto exit;
} else if (v_c2 <= 127) {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_ztxt_ri += 1;
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
} else {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_ztxt_ri += 1;
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
}
}
if (wuffs_base__status__is_ok(&v_zlib_status)) {
self->private_impl.f_metadata_is_zlib_compressed = false;
goto label__loop__break;
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
status = v_zlib_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if (v_zlib_status.repr != wuffs_base__suspension__short_write) {
status = v_zlib_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
} else {
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_chunk_type);
goto exit;
}
} else if ((self->private_impl.f_chunk_type == 1951945833) && (self->private_impl.f_metadata_fourcc == 1263947862)) {
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
goto label__loop__break;
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
goto label__loop__continue;
} else if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
goto label__loop__continue;
}
self->private_impl.f_chunk_length -= 1;
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1;
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_c), iop_a_dst += 1);
}
} else {
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
if (self->private_impl.f_metadata_fourcc == 1263947851) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
goto label__loop__break;
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
goto label__loop__continue;
}
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
if (v_c == 0) {
self->private_impl.f_chunk_length -= 1;
iop_a_src += 1;
goto label__loop__break;
}
v_c2 = WUFFS_PNG__LATIN_1[v_c];
if (v_c2 == 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
goto exit;
} else if (v_c2 <= 127) {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_chunk_length -= 1;
iop_a_src += 1;
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
} else {
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
v_c2 = 0;
goto label__loop__continue;
}
self->private_impl.f_chunk_length -= 1;
iop_a_src += 1;
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
}
}
}
}
label__loop__break:;
if (self->private_impl.f_metadata_fourcc == 1263947851) {
self->private_impl.f_metadata_fourcc = 1263947862;
if (self->private_impl.f_chunk_type == 1951945833) {
if (self->private_impl.f_chunk_length <= 1) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 2;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_3 = *iop_a_src++;
v_c = t_3;
}
if (v_c == 0) {
self->private_impl.f_metadata_is_zlib_compressed = false;
} else if (v_c == 1) {
self->private_impl.f_metadata_is_zlib_compressed = true;
} else {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_4 = *iop_a_src++;
v_c = t_4;
}
if ((v_c != 0) && self->private_impl.f_metadata_is_zlib_compressed) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
self->private_impl.f_metadata_fourcc -= 2;
while (self->private_impl.f_metadata_fourcc != 1263947862) {
self->private_impl.f_metadata_fourcc += 1;
while (true) {
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_5 = *iop_a_src++;
v_c = t_5;
}
if (v_c == 0) {
goto label__0__break;
}
}
label__0__break:;
}
} else if (self->private_impl.f_chunk_type == 1951945850) {
if (self->private_impl.f_chunk_length <= 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_impl.f_chunk_length -= 1;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint8_t t_6 = *iop_a_src++;
v_c = t_6;
}
if (v_c != 0) {
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
goto exit;
}
self->private_impl.f_metadata_is_zlib_compressed = true;
}
} else {
if (self->private_impl.f_chunk_length != 0) {
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
goto exit;
}
self->private_data.s_tell_me_more[0].scratch = 4;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
if (self->private_data.s_tell_me_more[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_tell_me_more[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src += self->private_data.s_tell_me_more[0].scratch;
self->private_impl.f_metadata_flavor = 0;
self->private_impl.f_metadata_fourcc = 0;
self->private_impl.f_metadata_x = 0;
self->private_impl.f_metadata_y = 0;
self->private_impl.f_metadata_z = 0;
}
self->private_impl.f_call_sequence = 2;
status = wuffs_base__make_status(NULL);
goto ok;
ok:
self->private_impl.p_tell_me_more[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_tell_me_more[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 4 : 0;
self->private_data.s_tell_me_more[0].v_zlib_status = v_zlib_status;
goto ok;
ok:
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));
}
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
@@ -38203,7 +41002,8 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0;
uint64_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_bytes_per_row = 0;
uint64_t v_dst_bytes_per_row0 = 0;
uint64_t v_dst_bytes_per_row1 = 0;
wuffs_base__slice_u8 v_dst_palette = {0};
wuffs_base__table_u8 v_tab = {0};
uint32_t v_y = 0;
@@ -38218,14 +41018,33 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
v_dst_bytes_per_row0 = (((uint64_t)(self->private_impl.f_frame_rect_x0)) * v_dst_bytes_per_pixel);
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
while (v_y < self->private_impl.f_height) {
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
}
if (v_dst_bytes_per_row1 < ((uint64_t)(v_tab.width))) {
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
0,
0,
v_dst_bytes_per_row1,
((uint64_t)(v_tab.height)));
}
if (v_dst_bytes_per_row0 < ((uint64_t)(v_tab.width))) {
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
v_dst_bytes_per_row0,
0,
((uint64_t)(v_tab.width)),
((uint64_t)(v_tab.height)));
} else {
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
0,
0,
0,
0);
}
v_y = self->private_impl.f_frame_rect_y0;
while (v_y < self->private_impl.f_frame_rect_y1) {
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
if (1 > ((uint64_t)(a_workbuf.len))) {
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
}
@@ -38265,7 +41084,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0;
uint64_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_bytes_per_row = 0;
uint64_t v_dst_bytes_per_row1 = 0;
wuffs_base__slice_u8 v_dst_palette = {0};
wuffs_base__table_u8 v_tab = {0};
uint64_t v_src_bytes_per_pixel = 0;
@@ -38289,26 +41108,22 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
v_src_bytes_per_pixel = 1;
if (self->private_impl.f_depth >= 8) {
v_src_bytes_per_pixel = (((uint64_t)(WUFFS_PNG__NUM_CHANNELS[self->private_impl.f_color_type])) * ((uint64_t)((self->private_impl.f_depth >> 3))));
}
v_bits_unpacked[0] = 255;
v_bits_unpacked[1] = 255;
v_bits_unpacked[2] = 255;
v_bits_unpacked[3] = 255;
v_bits_unpacked[4] = 255;
v_bits_unpacked[5] = 255;
v_bits_unpacked[6] = 255;
v_bits_unpacked[7] = 255;
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
while (v_y < self->private_impl.f_height) {
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
if (self->private_impl.f_chunk_type_array[0] == 73) {
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
} else {
v_y = self->private_impl.f_frame_rect_y0;
}
while (v_y < self->private_impl.f_frame_rect_y1) {
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
if (v_dst_bytes_per_row1 < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row1);
}
if (1 > ((uint64_t)(a_workbuf.len))) {
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
@@ -38333,9 +41148,13 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
return wuffs_base__make_status(wuffs_png__error__bad_filter);
}
v_s = v_curr_row;
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
if (self->private_impl.f_chunk_type_array[0] == 73) {
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
} else {
v_x = self->private_impl.f_frame_rect_x0;
}
if (self->private_impl.f_depth == 8) {
while (v_x < self->private_impl.f_width) {
while (v_x < self->private_impl.f_frame_rect_x1) {
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
if (v_i <= ((uint64_t)(v_dst.len))) {
if (self->private_impl.f_color_type == 4) {
@@ -38347,6 +41166,44 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
}
} else if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
if (self->private_impl.f_color_type == 0) {
if (1 <= ((uint64_t)(v_s.len))) {
v_bits_unpacked[0] = v_s.ptr[0];
v_bits_unpacked[1] = v_s.ptr[0];
v_bits_unpacked[2] = v_s.ptr[0];
v_bits_unpacked[3] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 1);
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
(((uint32_t)(v_bits_unpacked[1])) << 8) |
(((uint32_t)(v_bits_unpacked[2])) << 16) |
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
}
} else {
if (3 <= ((uint64_t)(v_s.len))) {
v_bits_unpacked[0] = v_s.ptr[2];
v_bits_unpacked[1] = v_s.ptr[1];
v_bits_unpacked[2] = v_s.ptr[0];
v_bits_unpacked[3] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 3);
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
(((uint32_t)(v_bits_unpacked[1])) << 8) |
(((uint32_t)(v_bits_unpacked[2])) << 16) |
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
}
}
} else if (v_src_bytes_per_pixel <= ((uint64_t)(v_s.len))) {
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__slice_u8__subslice_j(v_s, v_src_bytes_per_pixel));
v_s = wuffs_base__slice_u8__subslice_i(v_s, v_src_bytes_per_pixel);
@@ -38361,7 +41218,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
}
v_shift = ((8 - self->private_impl.f_depth) & 7);
v_packs_remaining = 0;
while (v_x < self->private_impl.f_width) {
while (v_x < self->private_impl.f_frame_rect_x1) {
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
if (v_i <= ((uint64_t)(v_dst.len))) {
if ((v_packs_remaining == 0) && (1 <= ((uint64_t)(v_s.len)))) {
@@ -38372,12 +41229,28 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_bits_unpacked[0] = ((uint8_t)((v_bits_packed >> v_shift) * v_multiplier));
v_bits_packed = ((uint8_t)(v_bits_packed << self->private_impl.f_depth));
v_packs_remaining = ((uint8_t)(v_packs_remaining - 1));
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
v_bits_unpacked[1] = v_bits_unpacked[0];
v_bits_unpacked[2] = v_bits_unpacked[0];
v_bits_unpacked[3] = 255;
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
(((uint32_t)(v_bits_unpacked[1])) << 8) |
(((uint32_t)(v_bits_unpacked[2])) << 16) |
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
} else {
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
}
}
v_x += (((uint32_t)(1)) << WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]);
}
} else {
while (v_x < self->private_impl.f_width) {
while (v_x < self->private_impl.f_frame_rect_x1) {
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
if (v_i <= ((uint64_t)(v_dst.len))) {
if (self->private_impl.f_color_type == 0) {
@@ -38388,7 +41261,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_bits_unpacked[3] = v_s.ptr[0];
v_bits_unpacked[4] = v_s.ptr[1];
v_bits_unpacked[5] = v_s.ptr[0];
v_bits_unpacked[6] = 255;
v_bits_unpacked[7] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
(((uint64_t)(v_bits_unpacked[1])) << 8) |
(((uint64_t)(v_bits_unpacked[2])) << 16) |
(((uint64_t)(v_bits_unpacked[3])) << 24) |
(((uint64_t)(v_bits_unpacked[4])) << 32) |
(((uint64_t)(v_bits_unpacked[5])) << 40) |
(((uint64_t)(v_bits_unpacked[6])) << 48) |
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
v_bits_unpacked[4] = 0;
v_bits_unpacked[5] = 0;
v_bits_unpacked[6] = 0;
v_bits_unpacked[7] = 0;
}
}
} else if (self->private_impl.f_color_type == 2) {
if (6 <= ((uint64_t)(v_s.len))) {
@@ -38398,7 +41290,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
v_bits_unpacked[3] = v_s.ptr[2];
v_bits_unpacked[4] = v_s.ptr[1];
v_bits_unpacked[5] = v_s.ptr[0];
v_bits_unpacked[6] = 255;
v_bits_unpacked[7] = 255;
v_s = wuffs_base__slice_u8__subslice_i(v_s, 6);
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
(((uint64_t)(v_bits_unpacked[1])) << 8) |
(((uint64_t)(v_bits_unpacked[2])) << 16) |
(((uint64_t)(v_bits_unpacked[3])) << 24) |
(((uint64_t)(v_bits_unpacked[4])) << 32) |
(((uint64_t)(v_bits_unpacked[5])) << 40) |
(((uint64_t)(v_bits_unpacked[6])) << 48) |
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
v_bits_unpacked[0] = 0;
v_bits_unpacked[1] = 0;
v_bits_unpacked[2] = 0;
v_bits_unpacked[3] = 0;
v_bits_unpacked[4] = 0;
v_bits_unpacked[5] = 0;
v_bits_unpacked[6] = 0;
v_bits_unpacked[7] = 0;
}
}
} else if (self->private_impl.f_color_type == 4) {
if (4 <= ((uint64_t)(v_s.len))) {
@@ -38672,7 +41583,7 @@ wuffs_wbmp__decoder__decode_image_config(
}
v_i += 1;
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if (a_dst != NULL) {
wuffs_base__image_config__set(
a_dst,
@@ -38766,7 +41677,7 @@ wuffs_wbmp__decoder__decode_frame_config(
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 3) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
@@ -38796,7 +41707,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;
@@ -38927,7 +41837,7 @@ wuffs_wbmp__decoder__decode_frame(
if (self->private_impl.f_width > 0) {
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
while (v_dst_y < self->private_impl.f_height) {
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
v_dst_x = 0;
while (v_dst_x < self->private_impl.f_width) {
if ((v_dst_x & 7) == 0) {
@@ -38935,7 +41845,7 @@ wuffs_wbmp__decoder__decode_frame(
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
v_dst_x_in_bytes = (((uint64_t)(v_dst_x)) * v_dst_bytes_per_pixel);
if (v_dst_x_in_bytes <= ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_dst_x_in_bytes);
@@ -38961,7 +41871,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;
@@ -39176,6 +42085,71 @@ namespace sync_io {
// --------
DynIOBuffer::DynIOBuffer(uint64_t max_incl)
: m_buf(wuffs_base__empty_io_buffer()), m_max_incl(max_incl) {}
DynIOBuffer::~DynIOBuffer() {
if (m_buf.data.ptr) {
free(m_buf.data.ptr);
}
}
void //
DynIOBuffer::drop() {
if (m_buf.data.ptr) {
free(m_buf.data.ptr);
}
m_buf = wuffs_base__empty_io_buffer();
}
DynIOBuffer::GrowResult //
DynIOBuffer::grow(uint64_t min_incl) {
uint64_t n = round_up(min_incl, m_max_incl);
if (n == 0) {
return ((min_incl == 0) && (m_max_incl == 0))
? DynIOBuffer::GrowResult::OK
: DynIOBuffer::GrowResult::FailedMaxInclExceeded;
} else if (n > m_buf.data.len) {
uint8_t* ptr = static_cast<uint8_t*>(realloc(m_buf.data.ptr, n));
if (!ptr) {
return DynIOBuffer::GrowResult::FailedOutOfMemory;
}
m_buf.data.ptr = ptr;
m_buf.data.len = n;
}
return DynIOBuffer::GrowResult::OK;
}
// round_up rounds min_incl up, returning the smallest value x satisfying
// (min_incl <= x) and (x <= max_incl) and some other constraints. It returns 0
// if there is no such x.
//
// When max_incl <= 4096, the other constraints are:
// - (x == max_incl)
//
// When max_incl > 4096, the other constraints are:
// - (x == max_incl) or (x is a power of 2)
// - (x >= 4096)
uint64_t //
DynIOBuffer::round_up(uint64_t min_incl, uint64_t max_incl) {
if (min_incl > max_incl) {
return 0;
}
uint64_t n = 4096;
if (n >= max_incl) {
return max_incl;
}
while (n < min_incl) {
if (n >= (max_incl / 2)) {
return max_incl;
}
n *= 2;
}
return n;
}
// --------
Input::~Input() {}
IOBuffer* //
@@ -39250,6 +42224,164 @@ MemoryInput::CopyIn(IOBuffer* dst) {
} // namespace sync_io
namespace private_impl {
struct ErrorMessages {
const char* max_incl_metadata_length_exceeded;
const char* out_of_memory;
const char* unexpected_end_of_file;
const char* unsupported_metadata;
const char* unsupported_negative_advance;
// If adding new "const char*" typed fields to this struct, either add them
// after existing fields or, if re-ordering fields, make sure that you update
// all of the "const private_impl::ErrorMessages FooBarErrorMessages" values
// in all of the sibling *.cc files.
static inline const char* resolve(const char* s) {
return s ? s : "wuffs_aux::private_impl: unknown error";
};
};
std::string //
AdvanceIOBufferTo(const ErrorMessages& error_messages,
sync_io::Input& input,
IOBuffer& io_buf,
uint64_t absolute_position) {
if (absolute_position < io_buf.reader_position()) {
return error_messages.resolve(error_messages.unsupported_negative_advance);
}
while (true) {
uint64_t relative_position = absolute_position - io_buf.reader_position();
if (relative_position <= io_buf.reader_length()) {
io_buf.meta.ri += (size_t)relative_position;
break;
} else if (io_buf.meta.closed) {
return error_messages.resolve(error_messages.unexpected_end_of_file);
}
io_buf.meta.ri = io_buf.meta.wi;
if (!input.BringsItsOwnIOBuffer()) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
return "";
}
std::string //
HandleMetadata(
const ErrorMessages& error_messages,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
sync_io::DynIOBuffer& raw,
wuffs_base__status (*tell_me_more_func)(void*,
wuffs_base__io_buffer*,
wuffs_base__more_information*,
wuffs_base__io_buffer*),
void* tell_me_more_receiver,
std::string (*handle_metadata_func)(void*,
const wuffs_base__more_information*,
wuffs_base__slice_u8),
void* handle_metadata_receiver) {
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
// Reset raw but keep its backing array (the raw.m_buf.data slice).
raw.m_buf.meta = wuffs_base__empty_io_buffer_meta();
while (true) {
minfo = wuffs_base__empty_more_information();
wuffs_base__status status = (*tell_me_more_func)(
tell_me_more_receiver, &raw.m_buf, &minfo, &io_buf);
switch (minfo.flavor) {
case 0:
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM:
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED:
break;
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH: {
wuffs_base__range_ie_u64 r = minfo.metadata_raw_passthrough__range();
if (r.is_empty()) {
break;
}
uint64_t num_to_copy = r.length();
if (num_to_copy > (raw.m_max_incl - raw.m_buf.meta.wi)) {
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
} else if (num_to_copy > (raw.m_buf.data.len - raw.m_buf.meta.wi)) {
switch (raw.grow(num_to_copy + raw.m_buf.meta.wi)) {
case sync_io::DynIOBuffer::GrowResult::OK:
break;
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
return error_messages.resolve(error_messages.out_of_memory);
}
}
if (io_buf.reader_position() > r.min_incl) {
return error_messages.resolve(error_messages.unsupported_metadata);
} else {
std::string error_message =
AdvanceIOBufferTo(error_messages, input, io_buf, r.min_incl);
if (!error_message.empty()) {
return error_message;
}
}
while (true) {
uint64_t n =
wuffs_base__u64__min(num_to_copy, io_buf.reader_length());
memcpy(raw.m_buf.writer_pointer(), io_buf.reader_pointer(), n);
raw.m_buf.meta.wi += n;
io_buf.meta.ri += n;
num_to_copy -= n;
if (num_to_copy == 0) {
break;
} else if (io_buf.meta.closed) {
return error_messages.resolve(
error_messages.unexpected_end_of_file);
} else if (!input.BringsItsOwnIOBuffer()) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
break;
}
default:
return error_messages.resolve(error_messages.unsupported_metadata);
}
if (status.repr == nullptr) {
break;
} else if (status.repr != wuffs_base__suspension__even_more_information) {
if (status.repr != wuffs_base__suspension__short_write) {
return status.message();
}
switch (raw.grow(wuffs_base__u64__sat_add(raw.m_buf.data.len, 1))) {
case sync_io::DynIOBuffer::GrowResult::OK:
break;
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
return error_messages.resolve(
error_messages.max_incl_metadata_length_exceeded);
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
return error_messages.resolve(error_messages.out_of_memory);
}
}
}
return (*handle_metadata_func)(handle_metadata_receiver, &minfo,
raw.m_buf.reader_slice());
}
} // namespace private_impl
} // namespace wuffs_aux
#endif // !defined(WUFFS_CONFIG__MODULES) ||
@@ -39275,10 +42407,21 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeCborArgQuirks //
DecodeCborArgQuirks::DefaultValue() {
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeCborResult //
DecodeCbor(DecodeCborCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks) {
DecodeCborArgQuirks quirks) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
@@ -39298,11 +42441,11 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
// Prepare the low-level CBOR decoder.
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
if (!dec) {
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
goto done;
}
for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
for (size_t i = 0; i < quirks.repr.len; i++) {
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
}
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
@@ -39313,7 +42456,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
// Prepare other state.
uint32_t depth = 0;
int32_t depth = 0;
std::string str;
int64_t extension_category = 0;
uint64_t extension_detail = 0;
@@ -39340,17 +42483,17 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
goto done;
} else if (cursor_index != io_buf->meta.ri) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
"wuffs_aux::DecodeCbor: internal error: bad cursor_index";
goto done;
} else if (io_buf->meta.closed) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
"wuffs_aux::DecodeCbor: 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::CborDecoder: internal error: io_buf is full";
"wuffs_aux::DecodeCbor: internal error: io_buf is full";
goto done;
}
cursor_index = io_buf->meta.ri;
@@ -39362,11 +42505,19 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
"wuffs_aux::DecodeCbor: 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);
if ((tok_buf.meta.ri > tok_buf.meta.wi) ||
(tok_buf.meta.wi > tok_buf.data.len) ||
(io_buf->meta.ri > io_buf->meta.wi) ||
(io_buf->meta.wi > io_buf->data.len)) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad buffer indexes";
goto done;
}
}
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
@@ -39374,7 +42525,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
if ((io_buf->meta.ri < cursor_index) ||
((io_buf->meta.ri - cursor_index) < token_len)) {
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad token indexes";
"wuffs_aux::DecodeCbor: internal error: bad token indexes";
goto done;
}
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
@@ -39410,7 +42561,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
}
}
ret_error_message =
"wuffs_aux::CborDecoder: internal error: bad extended token";
"wuffs_aux::DecodeCbor: internal error: bad extended token";
goto done;
}
@@ -39425,10 +42576,20 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
goto done;
}
depth++;
if (depth > WUFFS_CBOR__DECODER_DEPTH_MAX_INCL) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad depth";
goto done;
}
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
if (depth < 0) {
ret_error_message =
"wuffs_aux::DecodeCbor: internal error: bad depth";
goto done;
}
goto parsed_a_value;
}
@@ -39565,7 +42726,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
fail:
ret_error_message =
"wuffs_aux::CborDecoder: internal error: unexpected token";
"wuffs_aux::DecodeCbor: internal error: unexpected token";
goto done;
parsed_a_value:
@@ -39669,6 +42830,12 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
}
std::string //
DecodeImageCallbacks::HandleMetadata(const wuffs_base__more_information& minfo,
wuffs_base__slice_u8 raw) {
return "";
}
wuffs_base__pixel_format //
DecodeImageCallbacks::SelectPixfmt(
const wuffs_base__image_config& image_config) {
@@ -39733,12 +42900,16 @@ const char DecodeImage_BufferIsTooShort[] = //
"wuffs_aux::DecodeImage: buffer is too short";
const char DecodeImage_MaxInclDimensionExceeded[] = //
"wuffs_aux::DecodeImage: max_incl_dimension exceeded";
const char DecodeImage_MaxInclMetadataLengthExceeded[] = //
"wuffs_aux::DecodeImage: max_incl_metadata_length exceeded";
const char DecodeImage_OutOfMemory[] = //
"wuffs_aux::DecodeImage: out of memory";
const char DecodeImage_UnexpectedEndOfFile[] = //
"wuffs_aux::DecodeImage: unexpected end of file";
const char DecodeImage_UnsupportedImageFormat[] = //
"wuffs_aux::DecodeImage: unsupported image format";
const char DecodeImage_UnsupportedMetadata[] = //
"wuffs_aux::DecodeImage: unsupported metadata";
const char DecodeImage_UnsupportedPixelBlend[] = //
"wuffs_aux::DecodeImage: unsupported pixel blend";
const char DecodeImage_UnsupportedPixelConfiguration[] = //
@@ -39746,38 +42917,105 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
const char DecodeImage_UnsupportedPixelFormat[] = //
"wuffs_aux::DecodeImage: unsupported pixel format";
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeImageArgQuirks //
DecodeImageArgQuirks::DefaultValue() {
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
DecodeImageArgFlags //
DecodeImageArgFlags::DefaultValue() {
return DecodeImageArgFlags(0);
}
DecodeImageArgPixelBlend::DecodeImageArgPixelBlend(
wuffs_base__pixel_blend repr0)
: repr(repr0) {}
DecodeImageArgPixelBlend //
DecodeImageArgPixelBlend::DefaultValue() {
return DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC);
}
DecodeImageArgBackgroundColor::DecodeImageArgBackgroundColor(
wuffs_base__color_u32_argb_premul repr0)
: repr(repr0) {}
DecodeImageArgBackgroundColor //
DecodeImageArgBackgroundColor::DefaultValue() {
return DecodeImageArgBackgroundColor(1);
}
DecodeImageArgMaxInclDimension::DecodeImageArgMaxInclDimension(uint32_t repr0)
: repr(repr0) {}
DecodeImageArgMaxInclDimension //
DecodeImageArgMaxInclDimension::DefaultValue() {
return DecodeImageArgMaxInclDimension(1048575);
}
DecodeImageArgMaxInclMetadataLength::DecodeImageArgMaxInclMetadataLength(
uint64_t repr0)
: repr(repr0) {}
DecodeImageArgMaxInclMetadataLength //
DecodeImageArgMaxInclMetadataLength::DefaultValue() {
return DecodeImageArgMaxInclMetadataLength(16777215);
}
// --------
namespace {
const private_impl::ErrorMessages DecodeImageErrorMessages = {
DecodeImage_MaxInclMetadataLengthExceeded, //
DecodeImage_OutOfMemory, //
DecodeImage_UnexpectedEndOfFile, //
DecodeImage_UnsupportedMetadata, //
DecodeImage_UnsupportedImageFormat, //
};
std::string //
DecodeImageAdvanceIOBuf(sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
bool compactable,
uint64_t min_excl_pos,
uint64_t pos) {
if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {
// Redirects must go forward.
return DecodeImage_UnsupportedImageFormat;
}
while (true) {
uint64_t relative_pos = pos - io_buf.reader_position();
if (relative_pos <= io_buf.reader_length()) {
io_buf.meta.ri += (size_t)relative_pos;
break;
} else if (io_buf.meta.closed) {
return DecodeImage_UnexpectedEndOfFile;
}
io_buf.meta.ri = io_buf.meta.wi;
if (compactable) {
io_buf.compact();
}
std::string error_message = input.CopyIn(&io_buf);
if (!error_message.empty()) {
return error_message;
}
}
return "";
DecodeImageAdvanceIOBufferTo(sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
uint64_t absolute_position) {
return private_impl::AdvanceIOBufferTo(DecodeImageErrorMessages, input,
io_buf, absolute_position);
}
wuffs_base__status //
DIHM0(void* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src) {
return wuffs_base__image_decoder__tell_me_more(
static_cast<wuffs_base__image_decoder*>(self), a_dst, a_minfo, a_src);
}
std::string //
DIHM1(void* self,
const wuffs_base__more_information* minfo,
wuffs_base__slice_u8 raw) {
return static_cast<DecodeImageCallbacks*>(self)->HandleMetadata(*minfo, raw);
}
std::string //
DecodeImageHandleMetadata(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
sync_io::DynIOBuffer& raw_metadata_buf) {
return private_impl::HandleMetadata(DecodeImageErrorMessages, input, io_buf,
raw_metadata_buf, DIHM0,
static_cast<void*>(image_decoder.get()),
DIHM1, static_cast<void*>(&callbacks));
}
DecodeImageResult //
@@ -39785,9 +43023,12 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__io_buffer& io_buf,
wuffs_base__slice_u32 quirks,
uint64_t flags,
wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color,
uint32_t max_incl_dimension) {
uint32_t max_incl_dimension,
uint64_t max_incl_metadata_length) {
// Check args.
switch (pixel_blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -39798,6 +43039,7 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
}
wuffs_base__image_config image_config = wuffs_base__null_image_config();
sync_io::DynIOBuffer raw_metadata_buf(max_incl_metadata_length);
uint64_t start_pos = io_buf.reader_position();
bool redirected = false;
int32_t fourcc = 0;
@@ -39832,8 +43074,12 @@ redirect:
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
uint64_t pos = minfo.io_redirect__range().min_incl;
std::string error_message = DecodeImageAdvanceIOBuf(
input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);
if (pos <= start_pos) {
// Redirects must go forward.
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
std::string error_message =
DecodeImageAdvanceIOBufferTo(input, io_buf, pos);
if (!error_message.empty()) {
return DecodeImageResult(std::move(error_message));
}
@@ -39852,6 +43098,33 @@ redirect:
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
}
// Apply quirks.
for (size_t i = 0; i < quirks.len; i++) {
image_decoder->set_quirk_enabled(quirks.ptr[i], true);
}
// Apply flags.
if (flags != 0) {
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_GAMA) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__GAMA, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_ICCP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_KVP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__KVP, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_SRGB) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__SRGB, true);
}
if (flags & DecodeImageArgFlags::REPORT_METADATA_XMP) {
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__XMP, true);
}
}
// Decode the image config.
while (true) {
wuffs_base__status id_dic_status =
@@ -39864,6 +43137,12 @@ redirect:
}
redirected = true;
goto redirect;
} else if (id_dic_status.repr == wuffs_base__note__metadata_reported) {
std::string error_message = DecodeImageHandleMetadata(
image_decoder, callbacks, input, io_buf, raw_metadata_buf);
if (!error_message.empty()) {
return DecodeImageResult(std::move(error_message));
}
} else if (id_dic_status.repr != wuffs_base__suspension__short_read) {
return DecodeImageResult(id_dic_status.message());
} else if (io_buf.meta.closed) {
@@ -39876,6 +43155,7 @@ redirect:
}
}
} while (false);
raw_metadata_buf.drop();
// Select the pixel format.
uint32_t w = image_config.pixcfg.width();
@@ -39986,9 +43266,12 @@ redirect:
DecodeImageResult //
DecodeImage(DecodeImageCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color,
uint32_t max_incl_dimension) {
DecodeImageArgQuirks quirks,
DecodeImageArgFlags flags,
DecodeImageArgPixelBlend pixel_blend,
DecodeImageArgBackgroundColor background_color,
DecodeImageArgMaxInclDimension max_incl_dimension,
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length) {
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
@@ -40001,8 +43284,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
DecodeImageResult result =
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
background_color, max_incl_dimension);
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
flags.repr, pixel_blend.repr, background_color.repr,
max_incl_dimension.repr, max_incl_metadata_length.repr);
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
return result;
}
@@ -40032,60 +43316,84 @@ DecodeJsonCallbacks::Done(DecodeJsonResult& result,
sync_io::Input& input,
IOBuffer& buffer) {}
const char DecodeJson_BadJsonPointer[] =
const char DecodeJson_BadJsonPointer[] = //
"wuffs_aux::DecodeJson: bad JSON Pointer";
const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
const char DecodeJson_NoMatch[] = //
"wuffs_aux::DecodeJson: no match";
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0)
: repr(repr0) {}
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeJsonArgQuirks //
DecodeJsonArgQuirks::DefaultValue() {
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32());
}
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
: repr(repr0) {}
DecodeJsonArgJsonPointer //
DecodeJsonArgJsonPointer::DefaultValue() {
return DecodeJsonArgJsonPointer(std::string());
}
// --------
#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()); \
if ((tok_buf.meta.ri > tok_buf.meta.wi) || \
(tok_buf.meta.wi > tok_buf.data.len) || \
(io_buf->meta.ri > io_buf->meta.wi) || \
(io_buf->meta.wi > io_buf->data.len)) { \
ret_error_message = \
"wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \
goto done; \
} \
} \
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)
// --------
@@ -40093,7 +43401,8 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
namespace {
// DecodeJson_SplitJsonPointer returns ("bar", 8) for ("/foo/bar/b~1z/qux", 5,
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax or i is
// out of bounds.
//
// The string returned is unescaped. If calling it again, this time with i=8,
// the "b~1z" substring would be returned as "b/z".
@@ -40102,6 +43411,9 @@ DecodeJson_SplitJsonPointer(std::string& s,
size_t i,
bool allow_tilde_n_tilde_r_tilde_t) {
std::string fragment;
if (i > s.size()) {
return std::make_pair(std::string(), 0);
}
while (i < s.size()) {
char c = s[i];
if (c == '/') {
@@ -40308,8 +43620,8 @@ check_that_a_value_follows:
continue;
}
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that
// we're only peeking at the next token.
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so
// that we're only peeking at the next token.
tok_buf.meta.ri--;
cursor_index -= static_cast<size_t>(token_len);
@@ -40333,8 +43645,8 @@ done:
DecodeJsonResult //
DecodeJson(DecodeJsonCallbacks& callbacks,
sync_io::Input& input,
wuffs_base__slice_u32 quirks,
std::string json_pointer) {
DecodeJsonArgQuirks quirks,
DecodeJsonArgJsonPointer json_pointer) {
// Prepare the wuffs_base__io_buffer and the resultant error_message.
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
@@ -40356,11 +43668,15 @@ 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++) {
dec->set_quirk_enabled(quirks.ptr[i], true);
if (quirks.ptr[i] ==
for (size_t i = 0; i < quirks.repr.len; i++) {
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
if (quirks.repr.ptr[i] ==
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
allow_tilde_n_tilde_r_tilde_t = true;
}
@@ -40371,21 +43687,22 @@ 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;
int32_t depth = 0;
std::string str;
// Walk the (optional) JSON Pointer.
for (size_t i = 0; i < json_pointer.size();) {
if (json_pointer[i] != '/') {
for (size_t i = 0; i < json_pointer.repr.size();) {
if (json_pointer.repr[i] != '/') {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
}
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);
json_pointer.repr, i + 1, allow_tilde_n_tilde_r_tilde_t);
i = split.second;
if (i == 0) {
ret_error_message = DecodeJson_BadJsonPointer;
goto done;
@@ -40417,10 +43734,20 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done;
}
depth++;
if (depth > WUFFS_JSON__DECODER_DEPTH_MAX_INCL) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad depth";
goto done;
}
continue;
}
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
depth--;
if (depth < 0) {
ret_error_message =
"wuffs_aux::DecodeJson: internal error: bad depth";
goto done;
}
goto parsed_a_value;
}
@@ -40520,7 +43847,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.repr.empty())) {
goto done;
}
}
@@ -40547,6 +43889,8 @@ done:
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#endif
#endif // WUFFS_INCLUDE_GUARD
+1 -2
View File
@@ -175,9 +175,8 @@ main(int argc, char** argv) {
// https://play.golang.org/p/IU2T58P00C
const uint32_t expected_hash_of_1mib_of_zeroes = 0x00f00001UL;
int i;
int num_bad = 0;
for (i = 0; i < num_reps; i++) {
for (int i = 0; i < num_reps; i++) {
uint32_t actual_hash = calculate_hash(g_buffer, BUFFER_SIZE);
if (!g_flags.no_check && (actual_hash != expected_hash_of_1mib_of_zeroes)) {
num_bad++;
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+12 -4
View File
@@ -68,6 +68,16 @@
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// If building this program in an environment that doesn't easily accommodate
// relative includes, you can use the script/inline-c-relative-includes.go
// program to generate a stand-alone C file.
@@ -320,8 +330,7 @@ decode(bool frag_dst, bool frag_idat) {
struct timeval bench_start_tv;
gettimeofday(&bench_start_tv, NULL);
int i;
for (i = 0; i < reps; i++) {
for (int i = 0; i < reps; i++) {
const char* msg = decode_once(frag_dst, frag_idat);
if (msg) {
return msg;
@@ -389,8 +398,7 @@ main(int argc, char** argv) {
"it, first\n"
"# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");
int i;
for (i = 0; i < 5; i++) {
for (int i = 0; i < 5; i++) {
msg = decode(true, true);
if (msg) {
return fail(msg);
+3 -3
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -29,7 +30,6 @@ import (
"compress/flate"
"fmt"
"io"
"io/ioutil"
"os"
"runtime"
"time"
@@ -62,7 +62,7 @@ var testCases = []testCase{{
}}
func mustLoad(filename string) []byte {
src, err := ioutil.ReadFile("../../" + filename)
src, err := os.ReadFile("../../" + filename)
if err != nil {
panic(err.Error())
}
@@ -117,6 +117,6 @@ func main1() error {
func decode(src []byte) (numBytes uint64, retErr error) {
r := flate.NewReader(bytes.NewReader(src))
defer r.Close()
n, err := io.Copy(ioutil.Discard, r)
n, err := io.Copy(io.Discard, r)
return uint64(n), err
}
+2 -2
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -30,7 +31,6 @@ import (
"image"
"image/draw"
"image/gif"
"io/ioutil"
"os"
"runtime"
"strings"
@@ -87,7 +87,7 @@ var testCases = []testCase{{
}}
func mustLoad(filename string) []byte {
src, err := ioutil.ReadFile("../../" + filename)
src, err := os.ReadFile("../../" + filename)
if err != nil {
panic(err.Error())
}
+2 -2
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -30,7 +31,6 @@ import (
"image"
"image/draw"
"image/png"
"io/ioutil"
"os"
"runtime"
"strings"
@@ -71,7 +71,7 @@ var testCases = []testCase{{
}}
func mustLoad(filename string) []byte {
src, err := ioutil.ReadFile("../../" + filename)
src, err := os.ReadFile("../../" + filename)
if err != nil {
panic(err.Error())
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+4 -3
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -33,7 +34,7 @@ import (
"crypto/sha256"
"flag"
"fmt"
"io/ioutil"
"io"
"log"
"math/rand"
"net/http"
@@ -484,7 +485,7 @@ func (w worker) work1(u *url.URL, followHTML bool) (e entry, links []*url.URL, f
if _, err := os.Stat(filename); os.IsNotExist(err) {
log.Printf("worker #%03d: writing %q", w, urlString)
os.MkdirAll(filepath.Dir(filename), 0755)
if err := ioutil.WriteFile(filename, data, 0644); err != nil {
if err := os.WriteFile(filename, data, 0644); err != nil {
log.Println(err)
return entry{}, nil, true
}
@@ -508,7 +509,7 @@ func fetch(urlString string) (statusCode uint32, body []byte, retErr error) {
}
defer res.Body.Close()
body, err = ioutil.ReadAll(res.Body)
body, err = io.ReadAll(res.Body)
if err != nil {
return 0, nil, err
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+4 -3
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -35,7 +36,7 @@ import (
"bytes"
"flag"
"fmt"
"io/ioutil"
"io"
"os"
)
@@ -112,7 +113,7 @@ func emit() error {
}
filename := fmt.Sprintf("cbor-rfc-7049-examples/%02d.cbor", fileNumber)
fileNumber++
err := ioutil.WriteFile(filename, contents, 0644)
err := os.WriteFile(filename, contents, 0644)
contents = nil
return err
}
@@ -128,7 +129,7 @@ func readExampleTable() ([]byte, error) {
appendixA := []byte("Appendix A. Examples\n\n")
ruler := []byte("+------------------------------+------------------------------------+\n")
src, err := ioutil.ReadAll(os.Stdin)
src, err := io.ReadAll(os.Stdin)
if err != nil {
return nil, err
}
+7 -6
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -33,7 +34,7 @@ import (
"flag"
"fmt"
"hash/adler32"
"io/ioutil"
"io"
"os"
"strings"
)
@@ -71,7 +72,7 @@ func main1() error {
}
func decode(filename string) error {
src, err := ioutil.ReadFile(filename)
src, err := os.ReadFile(filename)
if err != nil {
return err
}
@@ -130,7 +131,7 @@ func doWriteDeflate(deflateCompressed []byte, uncompressed []byte, filename stri
filename = filename[:len(filename)-3]
}
filename += ".deflate"
if err := ioutil.WriteFile(filename, deflateCompressed, 0666); err != nil {
if err := os.WriteFile(filename, deflateCompressed, 0666); err != nil {
return err
}
fmt.Printf("wrote %s\n", filename)
@@ -170,7 +171,7 @@ func doWriteZlib(deflateCompressed []byte, uncompressed []byte, filename string)
filename = filename[:len(filename)-3]
}
filename += ".zlib"
if err := ioutil.WriteFile(filename, asZlib, 0666); err != nil {
if err := os.WriteFile(filename, asZlib, 0666); err != nil {
return err
}
fmt.Printf("wrote %s\n", filename)
@@ -192,7 +193,7 @@ func readString(src []byte, i int) (int, error) {
func checkDeflate(x []byte) ([]byte, error) {
rc := flate.NewReader(bytes.NewReader(x))
defer rc.Close()
x, err := ioutil.ReadAll(rc)
x, err := io.ReadAll(rc)
if err != nil {
return nil, fmt.Errorf("data is not valid deflate: %v", err)
}
@@ -205,7 +206,7 @@ func checkZlib(x []byte) ([]byte, error) {
return nil, fmt.Errorf("data is not valid zlib: %v", err)
}
defer rc.Close()
x, err = ioutil.ReadAll(rc)
x, err = io.ReadAll(rc)
if err != nil {
return nil, fmt.Errorf("data is not valid zlib: %v", err)
}
+5 -4
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -36,7 +37,7 @@ import (
"compress/lzw"
"flag"
"fmt"
"io/ioutil"
"io"
"os"
"path/filepath"
)
@@ -90,7 +91,7 @@ func main1() error {
filename = fmt.Sprintf("%s-frame-%03d", filename, argIndex)
}
filename += ".indexes.giflzw"
if err := ioutil.WriteFile(filename, frame, 0644); err != nil {
if err := os.WriteFile(filename, frame, 0644); err != nil {
return err
}
}
@@ -116,7 +117,7 @@ func main1() error {
}
func extractLZWFrames(filename string) (ret [][]byte, err error) {
src, err := ioutil.ReadFile(filename)
src, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
@@ -237,7 +238,7 @@ func checkLZW(data []byte) error {
}
rc := lzw.NewReader(bytes.NewReader(data[1:]), lzw.LSB, int(data[0]))
defer rc.Close()
_, err := ioutil.ReadAll(rc)
_, err := io.ReadAll(rc)
if err != nil {
return fmt.Errorf("block data is not valid LZW: %v", err)
}
+192
View File
@@ -0,0 +1,192 @@
// 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.
//go:build ignore
// +build ignore
package main
// extract-nia-frames.go extracts the individual frames from a NIA animation,
// writing them out as NIE images.
//
// Usage: go run extract-nia-frames.go foo.nia bar/baz.nia
//
// This will write new files:
// - foo.000000.nie
// - foo.000001.nie
// - foo.000002.nie
// - foo.000003.nie
// - etc
// - bar/baz.000000.nie
// - bar/baz.000001.nie
// - etc
import (
"bufio"
"errors"
"flag"
"fmt"
"io"
"os"
"path/filepath"
)
var (
dryRun = flag.Bool("dry-run", false, "just print metadata; don't write NIE files")
)
func main() {
if err := main1(); err != nil {
os.Stderr.WriteString(err.Error() + "\n")
os.Exit(1)
}
}
func main1() error {
flag.Parse()
for _, a := range flag.Args() {
if err := extract(a); err != nil {
return err
}
}
return nil
}
func extract(srcFilename string) error {
fmt.Printf("Extract %s\n", srcFilename)
f, err := os.Open(srcFilename)
if err != nil {
return err
}
defer f.Close()
r := bufio.NewReader(f)
dstFilenamePrefix := srcFilename[:len(srcFilename)-len(filepath.Ext(srcFilename))]
buf := [16]byte{}
if _, err := io.ReadFull(r, buf[:16]); err != nil {
return err
}
depth8 := buf[7] == '8'
width := u32le(buf[8:])
height := u32le(buf[12:])
padded := !depth8 && ((width & 1) != 0) && ((height & 1) != 0)
if (u32le(buf[:]) != 0x41AF_C36E) || // 0x41AF_C36E is 'nïA'le.
(buf[4] != 0xFF) ||
(buf[5] != 'b') ||
((buf[6] != 'n') && (buf[6] != 'p')) ||
((buf[7] != '4') && (buf[7] != '8')) ||
(width >= 0x8000_0000) ||
(height >= 0x8000_0000) {
return errors.New("bad NIA header")
}
fmt.Printf(" Config v1-b%c%c\n", buf[6], buf[7])
fmt.Printf(" Width %d\n", width)
fmt.Printf(" Height %d\n", height)
nieSize := calculateNIESize(depth8, width, height)
if nieSize < 0 {
return errors.New("unsupported NIA (image dimensions are too large)")
}
prevCDD := uint64(0)
for frameIndex := uint64(0); ; frameIndex++ {
if _, err := io.ReadFull(r, buf[:8]); err != nil {
return err
}
cdd := u64le(buf[:])
if (cdd >> 32) == 0x8000_0000 {
fmt.Printf(" LoopCount %d\n", uint32(cdd))
break
} else if ((cdd >> 32) > 0x8000_0000) || (cdd < prevCDD) {
return errors.New("bad CDD (Cumulative Display Duration)")
}
fmt.Printf(" CDD %16d flicks = %8g seconds; delta = %8g seconds\n",
cdd,
float64(cdd)/705_600000,
float64(cdd-prevCDD)/705_600000,
)
prevCDD = cdd
dstFilename := fmt.Sprintf("%s.%06d.nie", dstFilenamePrefix, frameIndex)
if err := extract1(dstFilename, r, int64(nieSize)); err != nil {
return err
}
if padded {
if _, err := io.ReadFull(r, buf[:4]); err != nil {
return err
} else if u32le(buf[:]) != 0 {
return errors.New("bad padding")
}
}
}
return nil
}
func calculateNIESize(depth8 bool, width uint32, height uint32) int64 {
const maxInt64 = (1 << 63) - 1
const maxUint64 = (1 << 64) - 1
n := uint64(width) * uint64(height) * 4
if depth8 {
if n > (maxUint64 / 2) {
return -1
}
n *= 2
}
if n > (maxInt64 - 16) {
return -1
}
return int64(n + 16)
}
func extract1(dstFilename string, r *bufio.Reader, nieSize int64) error {
if *dryRun {
fmt.Printf(" DryRun %s\n", dstFilename)
_, err := io.CopyN(io.Discard, r, nieSize)
return err
}
fmt.Printf(" Write %s\n", dstFilename)
f, err := os.Create(dstFilename)
if err != nil {
return err
}
_, err1 := io.CopyN(f, r, nieSize)
err2 := f.Close()
if err1 != nil {
return err1
}
return err2
}
func u32le(b []byte) uint32 {
return (uint32(b[0]) << 0) |
(uint32(b[1]) << 8) |
(uint32(b[2]) << 16) |
(uint32(b[3]) << 24)
}
func u64le(b []byte) uint64 {
return (uint64(b[0]) << 0) |
(uint64(b[1]) << 8) |
(uint64(b[2]) << 16) |
(uint64(b[3]) << 24) |
(uint64(b[4]) << 32) |
(uint64(b[5]) << 40) |
(uint64(b[6]) << 48) |
(uint64(b[7]) << 56)
}
+3 -3
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -29,7 +30,6 @@ import (
"image"
"image/gif"
"image/png"
"io/ioutil"
"os"
"path/filepath"
)
@@ -60,12 +60,12 @@ func main1() error {
}
}
if bPalette != nil {
if err := ioutil.WriteFile(baseFilename+".palette", bPalette, 0644); err != nil {
if err := os.WriteFile(baseFilename+".palette", bPalette, 0644); err != nil {
return err
}
}
if bIndexes != nil {
if err := ioutil.WriteFile(baseFilename+".indexes", bIndexes, 0644); err != nil {
if err := os.WriteFile(baseFilename+".indexes", bIndexes, 0644); err != nil {
return err
}
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+112 -2
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -25,8 +26,10 @@ package main
import (
"bytes"
"compress/lzw"
"compress/zlib"
"fmt"
"io/ioutil"
"hash/crc32"
"io"
"os"
"strconv"
"strings"
@@ -54,7 +57,7 @@ func main() {
}
func main1() error {
stdin, err := ioutil.ReadAll(os.Stdin)
stdin, err := io.ReadAll(os.Stdin)
if err != nil {
return err
}
@@ -137,6 +140,10 @@ func appendU16LE(b []byte, u uint16) []byte {
return append(b, uint8(u), uint8(u>>8))
}
func appendU32BE(b []byte, u uint32) []byte {
return append(b, uint8(u>>24), uint8(u>>16), uint8(u>>8), uint8(u))
}
func log2(u uint32) (i int32) {
for i, pow := uint32(0), uint32(1); i < 32; i, pow = i+1, pow<<1 {
if u == pow {
@@ -1219,3 +1226,106 @@ func stateGifFramePalette(line string) (stateFunc, error) {
return nil, fmt.Errorf("bad stateGifFramePalette command: %q", line)
}
// ----
func init() {
formats["png"] = statePng
}
var pngGlobals struct {
scratch [4]byte
animSeqNum uint32
chunkData bytes.Buffer
chunkType string
zlibWriter *zlib.Writer
}
func statePng(line string) (stateFunc, error) {
g := &pngGlobals
switch {
case line == "":
return statePng, nil
case line == "magic":
out = append(out, "\x89PNG\x0D\x0A\x1A\x0A"...)
return statePng, nil
case (len(line) == 6) && (line[4] == ' ') && (line[5] == '{'):
g.chunkData.Reset()
g.chunkType = line[:4]
return statePngChunk, nil
}
return nil, fmt.Errorf("bad statePng command: %q", line)
}
func statePngChunk(line string) (stateFunc, error) {
g := &pngGlobals
if line == "}" {
if n := g.chunkData.Len(); n > 0xFFFF_FFFF {
return nil, fmt.Errorf("chunkData is too long")
}
out = appendU32BE(out, uint32(g.chunkData.Len()))
n := len(out)
out = append(out, g.chunkType...)
out = append(out, g.chunkData.Bytes()...)
out = appendU32BE(out, crc32.ChecksumIEEE(out[n:]))
return statePng, nil
}
switch {
case line == "animSeqNum++":
g.chunkData.Write(appendU32BE(g.scratch[:0], g.animSeqNum))
g.animSeqNum++
return statePngChunk, nil
case line == "raw {":
return statePngRaw, nil
case line == "zlib {":
g.zlibWriter = zlib.NewWriter(&g.chunkData)
return statePngZlib, nil
}
return nil, fmt.Errorf("bad statePngChunk command: %q", line)
}
func statePngRaw(line string) (stateFunc, error) {
g := &pngGlobals
if line == "}" {
return statePngChunk, nil
}
for s := line; s != ""; {
if x, remaining, ok := parseHex(s); ok {
g.chunkData.WriteByte(byte(x))
s = remaining
} else {
return nil, fmt.Errorf("bad statePngRaw command: %q", line)
}
}
return statePngRaw, nil
}
func statePngZlib(line string) (stateFunc, error) {
g := &pngGlobals
if line == "}" {
if err := g.zlibWriter.Close(); err != nil {
return nil, fmt.Errorf("statePngZlib: %w", err)
}
return statePngChunk, nil
}
for s := line; s != ""; {
if x, remaining, ok := parseHex(s); ok {
g.scratch[0] = byte(x)
g.zlibWriter.Write(g.scratch[:1])
s = remaining
} else {
return nil, fmt.Errorf("bad statePngZlib command: %q", line)
}
}
return statePngZlib, nil
}
+181
View File
@@ -0,0 +1,181 @@
// 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.
//go:build ignore
// +build ignore
package main
// make-red-blue-gradient.go makes a simple PNG image with optional color
// correction chunks.
//
// Usage: go run make-red-blue-gradient.go > foo.png
import (
"bytes"
"compress/zlib"
"errors"
"flag"
"hash/crc32"
"image"
"image/color"
"image/png"
"math"
"os"
"path/filepath"
"strings"
)
var (
checkerboard = flag.Bool("checkerboard", false, "Create a checkerboard pattern instead")
gama = flag.Float64("gama", 0, "Gamma correction value (e.g. 2.2)")
iccp = flag.String("iccp", "", "ICC filename (e.g. foo/bar.icc)")
)
func main() {
if err := main1(); err != nil {
os.Stderr.WriteString(err.Error() + "\n")
os.Exit(1)
}
}
func main1() error {
flag.Parse()
// Make a checkerboard or red-blue gradient.
src := image.Image(nil)
if *checkerboard {
// With -gama=1.0 (or -gama=2.2), the two halves of this image should
// have roughly equal (or un-equal) brightness.
m := image.NewGray(image.Rect(0, 0, 256, 256))
for y := 0; y < 256; y++ {
for x := 0; x < 256; x++ {
if x < 128 {
m.SetGray(x, y, color.Gray{0x80})
} else if ((x ^ y) & 1) == 1 {
m.SetGray(x, y, color.Gray{0xFF})
} else {
m.SetGray(x, y, color.Gray{0x00})
}
}
}
src = m
} else {
m := image.NewRGBA(image.Rect(0, 0, 256, 256))
for y := 0; y < 256; y++ {
for x := 0; x < 256; x++ {
m.SetRGBA(x, y, color.RGBA{
R: uint8(x),
G: 0x00,
B: uint8(y),
A: 0xFF,
})
}
}
src = m
}
// Encode to PNG.
buf := &bytes.Buffer{}
png.Encode(buf, src)
original := buf.Bytes()
// Split the encoding into a magic+IHDR prefix and an IDAT+IEND suffix. The
// starting magic number is 8 bytes long. The IHDR chunk is 25 bytes long.
prefix, suffix := original[:33], original[33:]
out := []byte(nil)
out = append(out, prefix...)
// Insert the optional chunks between the prefix and suffix.
if *gama > 0 {
g := uint32(math.Round(100000 / *gama))
out = appendPNGChunk(out, "gAMA",
byte(g>>24),
byte(g>>16),
byte(g>>8),
byte(g>>0),
)
}
if *iccp != "" {
raw, err := os.ReadFile(*iccp)
if err != nil {
return err
}
name, err := iccpName(*iccp)
if err != nil {
return err
}
data := &bytes.Buffer{}
data.WriteString(name)
data.WriteByte(0x00) // The name is NUL terminated.
data.WriteByte(0x00) // 0x00 means zlib compression.
w := zlib.NewWriter(data)
w.Write(raw)
w.Close()
out = appendPNGChunk(out, "iCCP", data.Bytes()...)
}
// Append the suffix and write to stdout.
out = append(out, suffix...)
_, err := os.Stdout.Write(out)
return err
}
func appendPNGChunk(b []byte, name string, chunk ...byte) []byte {
n := uint32(len(chunk))
b = append(b,
byte(n>>24),
byte(n>>16),
byte(n>>8),
byte(n>>0),
)
b = append(b, name...)
b = append(b, chunk...)
hasher := crc32.NewIEEE()
hasher.Write([]byte(name))
hasher.Write(chunk)
c := hasher.Sum32()
return append(b,
byte(c>>24),
byte(c>>16),
byte(c>>8),
byte(c>>0),
)
}
// iccpName determines a "bar" iCCP profile name (that satisifes the PNG
// specification re the iCCP chunk) based on the "foo/bar.icc" filename.
func iccpName(filename string) (string, error) {
s := filepath.Base(filename)
if i := strings.IndexByte(s, '.'); i >= 0 {
s = s[:i]
}
s = strings.TrimSpace(s)
if strings.Index(s, " ") >= 0 {
return "", errors.New("ICCP name cannot contain consecutive spaces")
} else if (len(s) < 1) || (79 < len(s)) {
return "", errors.New("ICCP name has invalid length.")
}
for i := 0; i < len(s); i++ {
if (s[i] < ' ') || ('~' < s[i]) {
// Strictly speaking, the PNG specification allows the iCCP name to
// be printable Latin-1, not just printable ASCII, but printable
// ASCII is easier and avoids any later Latin-1 vs UTF-8 ambiguity.
return "", errors.New("ICCP name is not printable ASCII")
}
}
return s, nil
}
+11 -1
View File
@@ -37,6 +37,16 @@
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -261,7 +271,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;
+4 -4
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
// Deprecated: unused as of commit 695a6815 "Remove gif.config_decoder".
@@ -110,7 +111,6 @@ import (
"bytes"
"flag"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"runtime"
@@ -166,7 +166,7 @@ func main1() error {
sort.Strings(sortedFilenames)
for _, filename := range sortedFilenames {
contents := globalTargets[filename]
if x, err := ioutil.ReadFile(filename); (err == nil) && bytes.Equal(x, contents) {
if x, err := os.ReadFile(filename); (err == nil) && bytes.Equal(x, contents) {
fmt.Printf("gen unchanged: %s\n", filename)
continue
@@ -240,7 +240,7 @@ type filter struct {
}
func do(filename string) error {
src, err := ioutil.ReadFile(filename)
src, err := os.ReadFile(filename)
if err != nil {
return err
}
@@ -395,7 +395,7 @@ func wuffsfmt(src []byte) []byte {
const chmodSupported = runtime.GOOS != "windows"
func writeFile(filename string, b []byte) error {
f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename))
f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))
if err != nil {
return err
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+11 -2
View File
@@ -73,6 +73,16 @@
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
@@ -302,8 +312,7 @@ main1(int argc, char** argv) {
WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE,
0,
};
uint32_t i;
for (i = 0; quirks[i]; i++) {
for (uint32_t i = 0; quirks[i]; i++) {
wuffs_base__token_decoder__set_quirk_enabled(g_dec, quirks[i], true);
}
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+3 -3
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -37,13 +38,12 @@ import (
"flag"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"sort"
"strings"
"gopkg.in/russross/blackfriday.v2"
"github.com/russross/blackfriday/v2"
)
var skiphttp = flag.Bool("skiphttp", false, `skip "http:" or "https:" links`)
@@ -105,7 +105,7 @@ func main1() error {
}
func visit(r *renderer, filename string) error {
src, err := ioutil.ReadFile(filename)
src, err := os.ReadFile(filename)
if err != nil {
return err
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+74
View File
@@ -0,0 +1,74 @@
#!/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 script prints the CRC-32 checksum of the decoded pixels (in the NIA
# format, see doc/spec/nie-spec.md) of every image given as a command line
# argument: if a file then itself, if a directory then the files under it. It
# skips any non-image file found (non-image meaning not decodable by Wuffs'
# standard library).
#
# It is not perfect. It can have false positives and false negatives.
# Nonetheless, running it regularly (compiled against the in-development
# release/c/wuffs-unsupported-snapshot.c) can help detect regressions.
#
# "False positive" means that a non-image file can produce a non-zero checksum.
# Any file (containing binary data) starting with two '\x00' NUL bytes can
# sometimes be mistaken for a WBMP-formatted image file.
#
# "False negative" means that an image file that produces an all-zero checksum
# will be skipped.
if [ ! -e wuffs-root-directory.txt ]; then
echo "$0 should be run from the Wuffs root directory."
exit 1
elif [ ! -e gen/bin/example-convert-to-nia ]; then
echo "Run \"./build-example.sh example/convert-to-nia\" first."
exit 1
elif [ ! -e gen/bin/example-crc32 ]; then
echo "Run \"./build-example.sh example/crc32\" first."
exit 1
fi
sources=$@
if [ $# -eq 0 ]; then
sources=test/data
fi
# ----
handle() {
local c=$(gen/bin/example-convert-to-nia <$1 2>/dev/null | gen/bin/example-crc32)
if [ "$c" != "00000000" ]; then
echo $c $1
fi
}
# ----
echo "# Generated by script/print-nia-checksums.sh"
for f in $sources; do
if [ -f $f ]; then
handle $f
elif [ -d $f ]; then
for g in `find $f -type f | sort`; do
handle $g
done
else
echo "Could not open $f"
exit 1
fi
done
+57
View File
@@ -0,0 +1,57 @@
// 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.
//go:build ignore
// +build ignore
package main
// print-png-latin-1.go prints the UTF-8 encoding of the std/png Latin-1 table.
//
// Usage: go run print-png-latin-1.go
import (
"fmt"
"os"
)
func main() {
if err := main1(); err != nil {
os.Stderr.WriteString(err.Error() + "\n")
os.Exit(1)
}
}
func main1() error {
// The PNG spec (https://www.w3.org/TR/PNG/) says "*printable* [emphasis
// added] Latin-1 characters and spaces (only character codes 32-126 and
// 161-255 decimal are allowed)".
//
// See also https://www.w3.org/TR/2003/REC-PNG-20031110/iso_8859-1.txt
for r := rune(0); r <= 0xFF; r++ {
if (r < 32) || ((126 < r) && (r < 161)) {
fmt.Printf(" 0x0000,")
} else if r < 128 {
fmt.Printf(" 0x%04X,", r)
} else {
s := fmt.Sprintf("%c", r)
fmt.Printf(" 0x%02X%02X,", s[1], s[0]) // UTF-8 as little-endian uint16.
}
if r%8 == 7 {
fmt.Println()
}
}
return nil
}
+5
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -125,6 +126,10 @@ var f64TestCases = []float64{
6.022141e23,
6.0221408e23,
6.02214076e23,
// Some "parse to float64" implementations find this one tricky.
// https://github.com/serde-rs/json/issues/707
122.416294033786585,
}
var u64TestCases = []uint64{
+10
View File
@@ -52,6 +52,16 @@
// compiling it.
#define WUFFS_IMPLEMENTATION
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
+2 -2
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
@@ -25,7 +26,6 @@ import (
"bytes"
"fmt"
"io"
"io/ioutil"
"math/rand"
"os"
@@ -41,7 +41,7 @@ func main() {
}
func main1() error {
input, err := ioutil.ReadAll(os.Stdin)
input, err := io.ReadAll(os.Stdin)
if err != nil {
return err
}
+1
View File
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build ignore
// +build ignore
package main
+7 -7
View File
@@ -530,7 +530,7 @@ pri func decoder.swizzle_none!(dst: ptr base.pixel_buffer, src: base.io_reader)
}
}
dst = tab.row(y: this.dst_y)
dst = tab.row_u32(y: this.dst_y)
if dst_bytes_per_row < dst.length() {
dst = dst[.. dst_bytes_per_row]
}
@@ -597,7 +597,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
rle_state = this.rle_state
while.outer true {
row = tab.row(y: this.dst_y)
row = tab.row_u32(y: this.dst_y)
if dst_bytes_per_row < row.length() {
row = row[.. dst_bytes_per_row]
}
@@ -771,7 +771,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
if this.dst_y >= this.height {
return "#bad RLE compression"
}
row = tab.row(y: this.dst_y)
row = tab.row_u32(y: this.dst_y)
if dst_bytes_per_row < row.length() {
row = row[.. dst_bytes_per_row]
}
@@ -801,7 +801,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
} endwhile.outer
while this.dst_y < this.height {
row = tab.row(y: this.dst_y)
row = tab.row_u32(y: this.dst_y)
if dst_bytes_per_row < row.length() {
row = row[.. dst_bytes_per_row]
}
@@ -921,7 +921,7 @@ pri func decoder.swizzle_bitfields!(dst: ptr base.pixel_buffer, src: base.io_rea
} endwhile
// -------- END convert to PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE.
dst = tab.row(y: this.dst_y)
dst = tab.row_u32(y: this.dst_y)
if dst_bytes_per_row < dst.length() {
dst = dst[.. dst_bytes_per_row]
}
@@ -983,7 +983,7 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
}
}
dst = tab.row(y: this.dst_y)
dst = tab.row_u32(y: this.dst_y)
if dst_bytes_per_row < dst.length() {
dst = dst[.. dst_bytes_per_row]
}
@@ -1151,7 +1151,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
}
if args.minfo <> nullptr {
args.minfo.set!(
flavor: 1, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT
flavor: base.MORE_INFORMATION__FLAVOR__IO_REDIRECT,
w: this.io_redirect_fourcc,
x: 0,
y: this.io_redirect_pos,
+9
View File
@@ -70,6 +70,14 @@ pub struct decoder? implements base.io_transformer(
bits : base.u32,
n_bits : base.u32,
// transformed_history_count is the number of bytes written to the history
// ringbuffer due to calling transform_io. It excludes any pre-history
// written by explicit calls to add_history. It also excludes any bytes
// decoded from the final transform_io call (the one that doesn't suspend)
// as there is no further need for tracking history (for resolving back-
// references) once the decoding completes.
transformed_history_count : base.u64,
// history_index indexes the history array, defined below.
history_index : base.u32,
@@ -211,6 +219,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
if not status.is_suspension() {
return status
}
this.transformed_history_count ~sat+= args.dst.count_since(mark: mark)
// TODO: should "since" be "since!", as the return value lets you
// modify the state of args.dst, so future mutations (via the slice)
// can change the veracity of any args.dst assertions?
+7
View File
@@ -35,6 +35,7 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
var dist_minus_1 : base.u32[..= 0x7FFF]
var hlen : base.u32[..= 0x7FFF]
var hdist : base.u32
var hdist_adjustment : base.u32
if (this.n_bits >= 8) or ((this.bits >> (this.n_bits & 7)) <> 0) {
return "#internal error: inconsistent n_bits"
@@ -46,6 +47,11 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
lmask = ((1 as base.u64) << this.n_huffs_bits[0]) - 1
dmask = ((1 as base.u64) << this.n_huffs_bits[1]) - 1
if this.transformed_history_count < args.dst.history_position() {
return base."#bad I/O position"
}
hdist_adjustment = ((this.transformed_history_count - args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
// 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
@@ -209,6 +215,7 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
hlen = length
length = 0
}
hdist ~mod+= hdist_adjustment
if this.history_index < hdist {
return "#bad distance"
}
+7
View File
@@ -32,6 +32,7 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
var dist_minus_1 : base.u32[..= 0x7FFF]
var hlen : base.u32[..= 0x7FFF]
var hdist : base.u32
var hdist_adjustment : base.u32
if (this.n_bits >= 8) or ((this.bits >> (this.n_bits & 7)) <> 0) {
return "#internal error: inconsistent n_bits"
@@ -43,6 +44,11 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
lmask = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
dmask = ((1 as base.u32) << this.n_huffs_bits[1]) - 1
if this.transformed_history_count < args.dst.history_position() {
return base."#bad I/O position"
}
hdist_adjustment = ((this.transformed_history_count - args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
// Check up front, on each iteration, that we have enough buffer space to
// both read (12 bytes) and write (266 bytes) as much as we need to. Doing
// this check once (per iteration), up front, removes the need to check
@@ -314,6 +320,7 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
hlen = length
length = 0
}
hdist ~mod+= hdist_adjustment
if this.history_index < hdist {
return "#bad distance"
}
+7
View File
@@ -34,6 +34,7 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
var dist_minus_1 : base.u32[..= 0x7FFF]
var hlen : base.u32[..= 0x7FFF]
var hdist : base.u32
var hdist_adjustment : base.u32
if (this.n_bits >= 8) or ((this.bits >> (this.n_bits & 7)) <> 0) {
return "#internal error: inconsistent n_bits"
@@ -45,6 +46,11 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
lmask = ((1 as base.u64) << this.n_huffs_bits[0]) - 1
dmask = ((1 as base.u64) << this.n_huffs_bits[1]) - 1
if this.transformed_history_count < args.dst.history_position() {
return base."#bad I/O position"
}
hdist_adjustment = ((this.transformed_history_count - args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
// 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
@@ -208,6 +214,7 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
hlen = length
length = 0
}
hdist ~mod+= hdist_adjustment
if this.history_index < hdist {
return "#bad distance"
}
+1
View File
@@ -217,6 +217,7 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
hlen = length
length = 0
}
hdist ~mod+= ((this.transformed_history_count ~mod- args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
if this.history_index < hdist {
return "#bad distance"
}
+22 -26
View File
@@ -12,8 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// --------
pub struct decoder? implements base.image_decoder(
width : base.u32,
height : base.u32,
@@ -40,7 +38,7 @@ pub struct decoder? implements base.image_decoder(
// - 0x00 -> 0x04: via DFC with implicit DIC
// - 0x00 -> 0x05: via DF with implicit DIC and DFC
//
// - 0x01 -> 0x02: via AMC
// - 0x01 -> 0x02: via TMM
//
// - 0x02 -> 0x01: via DIC (metadata reported)
// - 0x02 -> 0x03: via DIC (metadata not reported)
@@ -57,11 +55,11 @@ pub struct decoder? implements base.image_decoder(
// - ???? -> 0x05: via RF for ???? > 0x00
//
// Where:
// - AMC is ack_metadata_chunk
// - DF is decode_frame, implicit means skip_frame
// - DFC is decode_frame_config, implicit means nullptr args.dst
// - DIC is decode_image_config, implicit means nullptr args.dst
// - RF is restart_frame
// - TMM is tell_me_more
call_sequence : base.u8,
ignore_metadata : base.bool,
@@ -84,8 +82,8 @@ pub struct decoder? implements base.image_decoder(
// Absent an ANIMEXTS1.0 or NETSCAPE2.0 extension, the implicit number of
// animation loops is 1.
seen_num_loops : base.bool,
num_loops : base.u32,
seen_num_animation_loops_value : base.bool,
num_animation_loops_value : base.u32,
background_color_u32_argb_premul : base.u32,
black_color_u32_argb_premul : base.u32,
@@ -96,7 +94,8 @@ pub struct decoder? implements base.image_decoder(
// There are 7_056000 flicks per centisecond.
gc_duration : base.u64[..= 0xFFFF * 7_056000],
frame_config_io_position : base.u64,
frame_config_io_position : base.u64,
num_decoded_frame_configs_value : base.u64,
num_decoded_frames_value : base.u64,
@@ -205,7 +204,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
if args.src.position() <> this.metadata_io_position {
if args.minfo <> nullptr {
args.minfo.set!(
flavor: 2, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK
flavor: base.MORE_INFORMATION__FLAVOR__IO_SEEK,
w: 0,
x: this.metadata_io_position,
y: 0,
@@ -250,7 +249,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
if args.minfo <> nullptr {
args.minfo.set!(
flavor: 3, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA
flavor: base.MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH,
w: this.metadata_fourcc,
x: 0,
y: args.src.position(),
@@ -262,7 +261,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
if args.minfo <> nullptr {
args.minfo.set!(
flavor: 3, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA
flavor: base.MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH,
w: this.metadata_fourcc,
x: 0,
y: this.metadata_io_position,
@@ -275,8 +274,8 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
}
pub func decoder.num_animation_loops() base.u32 {
if this.seen_num_loops {
return this.num_loops
if this.seen_num_animation_loops_value {
return this.num_animation_loops_value
}
return 1
}
@@ -662,8 +661,8 @@ pri func decoder.decode_ae?(src: base.io_reader) {
args.src.skip_u32?(n: 2)
break.goto_done
}
this.num_loops = args.src.read_u16le_as_u32?()
this.seen_num_loops = true
this.num_animation_loops_value = args.src.read_u16le_as_u32?()
this.seen_num_animation_loops_value = true
// A loop count of N, in the wire format, actually means "repeat N
// times after the first play", if N is positive. A zero N means to
@@ -675,8 +674,8 @@ pri func decoder.decode_ae?(src: base.io_reader) {
//
// Thus, we increment N if it is positive. The comparison against
// 0xFFFF will never fail, but is necessary for the overflow checker.
if (0 < this.num_loops) and (this.num_loops <= 0xFFFF) {
this.num_loops += 1
if (0 < this.num_animation_loops_value) and (this.num_animation_loops_value <= 0xFFFF) {
this.num_animation_loops_value += 1
}
} else if this.ignore_metadata {
@@ -721,16 +720,13 @@ pri func decoder.decode_gc?(src: base.io_reader) {
// in the range [4 ..= 7] are "to be defined". In practice, some encoders also
// use 4 for "restore previous". See
// https://cs.chromium.org/chromium/src/third_party/blink/renderer/platform/image-decoders/gif/gif_image_reader.cc?rcl=5161173c43324da2b13e1aa45bbe69901daa1279&l=625
//
// TODO: named constants instead of assigning 1 for
// WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND, etc.
flags = (flags >> 2) & 0x07
if flags == 2 {
this.gc_disposal = 1 // 1 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND
this.gc_disposal = base.ANIMATION_DISPOSAL__RESTORE_BACKGROUND
} else if (flags == 3) or (flags == 4) {
this.gc_disposal = 2 // 2 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS
this.gc_disposal = base.ANIMATION_DISPOSAL__RESTORE_PREVIOUS
} else {
this.gc_disposal = 0
this.gc_disposal = base.ANIMATION_DISPOSAL__NONE
}
// There are 7_056000 flicks per centisecond.
@@ -929,7 +925,7 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade
if (this.compressed_ri > this.compressed_wi) or (this.compressed_wi > 4096) {
return "#internal error: inconsistent ri/wi"
}
io_bind (io: r, data: this.compressed[this.compressed_ri .. this.compressed_wi]) {
io_bind (io: r, data: this.compressed[this.compressed_ri .. this.compressed_wi], history_position: 0) {
mark = r.mark()
lzw_status =? this.lzw.transform_io?(
dst: this.util.empty_io_writer(), src: r, workbuf: this.util.empty_slice_u8())
@@ -1015,7 +1011,7 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: slice bas
// First, copy from src to that part of the frame rect that is inside
// args.pb's bounds (clipped to the image bounds).
dst = tab.row(y: this.dst_y)
dst = tab.row_u32(y: this.dst_y)
if this.dst_y >= this.height {
dst = dst[.. 0]
} else if width_in_bytes < dst.length() {
@@ -1057,13 +1053,13 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: slice bas
(not this.gc_has_transparent_index) and
(this.interlace > 1) {
replicate_src = tab.row(y: this.dst_y)
replicate_src = tab.row_u32(y: this.dst_y)
replicate_y0 = this.dst_y ~sat+ 1
replicate_y1 = this.dst_y ~sat+ (INTERLACE_COUNT[this.interlace] as base.u32)
replicate_y1 = replicate_y1.min(a: this.frame_rect_y1)
while replicate_y0 < replicate_y1 {
assert replicate_y0 < 0xFFFF_FFFF via "a < b: a < c; c <= b"(c: replicate_y1)
replicate_dst = tab.row(y: replicate_y0)
replicate_dst = tab.row_u32(y: replicate_y0)
replicate_dst.copy_from_slice!(s: replicate_src)
replicate_y0 += 1
} endwhile
+11 -6
View File
@@ -1530,7 +1530,16 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
pre args.dst.length() > 0,
{
if args.src.length() <= 0 {
if length > 0 {
if args.src.is_closed() {
args.dst.write_simple_token_fast!(
value_major: 0,
value_minor: (base.TOKEN__VBC__FILLER << 21) |
base.TOKEN__VBD__FILLER__COMMENT_LINE,
continued: 0,
length: length)
this.comment_type = 2
return ok
} else if length > 0 {
args.dst.write_simple_token_fast!(
value_major: 0,
value_minor: (base.TOKEN__VBC__FILLER << 21) |
@@ -1538,9 +1547,6 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
continued: 1,
length: length)
}
if args.src.is_closed() {
return "#bad input"
}
yield? base."$short read"
length = 0
continue.comment_line
@@ -1548,13 +1554,12 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
c = args.src.peek_u8()
if c == '\n' {
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
args.dst.write_simple_token_fast!(
value_major: 0,
value_minor: (base.TOKEN__VBC__FILLER << 21) |
base.TOKEN__VBD__FILLER__COMMENT_LINE,
continued: 0,
length: length + 1)
length: length)
this.comment_type = 2
return ok
}
+7 -5
View File
@@ -109,15 +109,17 @@ pub const QUIRK_ALLOW_COMMENT_BLOCK : base.u32 = 0x4909_9400 | 0x0B
// When this quirk is enabled, "// C/C++ style line comments\n" are accepted
// anywhere whitespace would be. See also QUIRK_ALLOW_TRAILING_FILLER.
//
// A line comment may not omit the ending "\n", even if there is no input
// afterwards (i.e. the prospective line comment ends with the end-of-file).
// Line comments are terminated by a '\n' byte. '\r' bytes are irrelevant. When
// combined with QUIRK_ALLOW_TRAILING_FILLER, a line comment at the end of the
// file may omit the final '\n' byte.
//
// They produce WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE tokens. The token
// chain's source bytes includes the starting "//" and the ending "\n".
// chain's source bytes includes the starting "//" but always excludes the
// ending "\n", regardless of whether it met the end of the file instead.
//
// Even if the line comments are on consecutive lines, each line comment is a
// separate token chain. There may be whitespace tokens between one line
// comment's ending "\n" and the next one's starting "//".
// separate token chain. Between them is at least one "\n" and maybe other
// whitespace, which are not part of a line comment token chain.
//
// To avoid ambiguity (as comments can contain new lines), this quirk cannot be
// combined with QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF.
+1 -1
View File
@@ -211,7 +211,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
}
}
dst = tab.row(y: this.dst_y)
dst = tab.row_u32(y: this.dst_y)
if dst_bytes_per_row < dst.length() {
dst = dst[.. dst_bytes_per_row]
}
+142
View File
@@ -0,0 +1,142 @@
// Copyright 2020 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.
pub status "#bad animation sequence number"
pub status "#bad checksum"
pub status "#bad chunk"
pub status "#bad filter"
pub status "#bad header"
pub status "#bad text chunk (not Latin-1)"
pub status "#missing palette"
pub status "#unsupported PNG compression method"
pub status "#unsupported PNG file"
pri status "#internal error: inconsistent I/O"
pri status "#internal error: inconsistent chunk type"
pri status "#internal error: inconsistent frame bounds"
pri status "#internal error: inconsistent workbuf length"
pri status "#internal error: zlib decoder did not exhaust its input"
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
// DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL is the minimum length of the src
// wuffs_base__io_buffer passed to the decoder.
pub const DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL : base.u64 = 8
// ANCILLARY_BIT is the upper/lower case bit on the chunk type's first byte (in
// little-endian order).
pri const ANCILLARY_BIT : base.u32 = 0x0000_0020
// INTERLACING holds the Adam7 interlacing pattern, involving 7 passes:
// 1 6 4 6 2 6 4 6
// 7 7 7 7 7 7 7 7
// 5 6 5 6 5 6 5 6
// 7 7 7 7 7 7 7 7
// 3 6 4 6 3 6 4 6
// 7 7 7 7 7 7 7 7
// 5 6 5 6 5 6 5 6
// 7 7 7 7 7 7 7 7
//
// The six elements of each inner array are:
// 0: log2(x_stride)
// 1: x_stride - x_offset - 1
// 2: x_offset
// 3: log2(y_stride)
// 4: y_stride - y_offset - 1
// 5: y_offset
pri const INTERLACING : array[8] array[6] base.u8[..= 7] = [
[0, 0, 0, 0, 0, 0], // non-interlaced; xy_stride=1, xy_offset=0
[3, 7, 0, 3, 7, 0], // interlace_pass == 1
[3, 3, 4, 3, 7, 0], // interlace_pass == 2
[2, 3, 0, 3, 3, 4], // interlace_pass == 3
[2, 1, 2, 2, 3, 0], // interlace_pass == 4
[1, 1, 0, 2, 1, 2], // interlace_pass == 5
[1, 0, 1, 1, 1, 0], // interlace_pass == 6
[0, 0, 0, 1, 0, 1], // interlace_pass == 7
]
// LOW_BIT_DEPTH_MULTIPLIERS holds multipliers that convert D-bit values into
// 8-bit values, for depth D.
pri const LOW_BIT_DEPTH_MULTIPLIERS : array[8] base.u8 = [
0,
0b1111_1111, // depth == 1
0b0101_0101, // depth == 2
0,
0b0001_0001, // depth == 4
0,
0,
0,
]
// LOW_BIT_DEPTH_NUM_PACKS holds the number of smaller-than-1-byte units that
// are packed into each byte.
pri const LOW_BIT_DEPTH_NUM_PACKS : array[8] base.u8 = [
0,
8, // depth == 1
4, // depth == 2
0,
2, // depth == 4
0,
0,
0,
]
// NUM_CHANNELS holds the number of channels for each valid color type.
pri const NUM_CHANNELS : array[8] base.u8[..= 4] = [
1, // color_type == 0: Y
0,
3, // color_type == 2: RGB
1, // color_type == 3: indexed
2, // color_type == 4: YA
0,
4, // color_type == 6: RGBA
0,
]
// LATIN_1 converts from printable Latin-1 (ISO/IEC 8859-1) to UTF-8 (encoded
// as little-endian u16). It was created by script/print-png-latin-1.go.
pri const LATIN_1 : array[256] base.u16 = [
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0xA1C2, 0xA2C2, 0xA3C2, 0xA4C2, 0xA5C2, 0xA6C2, 0xA7C2,
0xA8C2, 0xA9C2, 0xAAC2, 0xABC2, 0xACC2, 0xADC2, 0xAEC2, 0xAFC2,
0xB0C2, 0xB1C2, 0xB2C2, 0xB3C2, 0xB4C2, 0xB5C2, 0xB6C2, 0xB7C2,
0xB8C2, 0xB9C2, 0xBAC2, 0xBBC2, 0xBCC2, 0xBDC2, 0xBEC2, 0xBFC2,
0x80C3, 0x81C3, 0x82C3, 0x83C3, 0x84C3, 0x85C3, 0x86C3, 0x87C3,
0x88C3, 0x89C3, 0x8AC3, 0x8BC3, 0x8CC3, 0x8DC3, 0x8EC3, 0x8FC3,
0x90C3, 0x91C3, 0x92C3, 0x93C3, 0x94C3, 0x95C3, 0x96C3, 0x97C3,
0x98C3, 0x99C3, 0x9AC3, 0x9BC3, 0x9CC3, 0x9DC3, 0x9EC3, 0x9FC3,
0xA0C3, 0xA1C3, 0xA2C3, 0xA3C3, 0xA4C3, 0xA5C3, 0xA6C3, 0xA7C3,
0xA8C3, 0xA9C3, 0xAAC3, 0xABC3, 0xACC3, 0xADC3, 0xAEC3, 0xAFC3,
0xB0C3, 0xB1C3, 0xB2C3, 0xB3C3, 0xB4C3, 0xB5C3, 0xB6C3, 0xB7C3,
0xB8C3, 0xB9C3, 0xBAC3, 0xBBC3, 0xBCC3, 0xBDC3, 0xBEC3, 0xBFC3,
]
+1061 -222
View File
@@ -15,18 +15,6 @@
use "std/crc32"
use "std/zlib"
pub status "#bad checksum"
pub status "#bad chunk"
pub status "#bad filter"
pub status "#bad header"
pub status "#missing palette"
pub status "#unsupported PNG file"
pri status "#internal error: inconsistent workbuf length"
pri status "#internal error: zlib decoder did not exhaust its input"
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
pub struct decoder? implements base.image_decoder(
// The 0x00FF_FFFF limit is arbitrary (the PNG spec says 0x7FFF_FFFF) but
// it means that (width * height * bytes_per_pixel) doesn't overflow.
@@ -37,36 +25,61 @@ pub struct decoder? implements base.image_decoder(
pass_bytes_per_row : base.u64[..= 0x07FF_FFF8],
workbuf_wi : base.u64,
workbuf_hist_pos_base : base.u64,
overall_workbuf_length : base.u64[..= 0x0007_FFFF_F100_0007],
pass_workbuf_length : base.u64[..= 0x0007_FFFF_F100_0007],
// Call sequence states:
// - 0x00: initial state.
// - 0x01: metadata reported; image config decode is in progress.
// - 0x02: metadata finished; image config decode is in progress.
// - 0x03: image config decoded.
// - 0x04: frame config decoded.
// - 0xFF: end-of-data, usually after (the non-animated) frame decoded.
// - 0x05: frame decoded.
// - 0xFF: end-of-data, after the final frame decoded.
//
// State transitions:
//
// - 0x00 -> 0x03: via DIC
// - 0x00 -> 0x01: via DIC (metadata reported)
// - 0x00 -> 0x03: via DIC (metadata not reported)
// - 0x00 -> 0x04: via DFC with implicit DIC
// - 0x00 -> 0x05: via DF with implicit DIC and DFC
// - 0x00 -> 0xFF: via DF with implicit DIC and DFC
//
// - 0x01 -> 0x02: via TMM
//
// - 0x02 -> 0x01: via DIC (metadata reported)
// - 0x02 -> 0x03: via DIC (metadata not reported)
//
// - 0x03 -> 0x04: via DFC
// - 0x03 -> 0x05: via DF with implicit DFC
// - 0x03 -> 0xFF: via DF with implicit DFC
//
// - 0x04 -> 0xFF: via DFC
// - 0x04 -> 0x04: via DFC with implicit DF
// - 0x04 -> 0x05: via DF
// - 0x04 -> 0xFF: via DFC with implicit DF
// - 0x04 -> 0xFF: via DF
//
// - 0x05 -> 0x04: via DFC
// - 0x05 -> 0x05: via DF with implicit DFC
// - 0x05 -> 0xFF: via DF with implicit DFC
//
// - ???? -> 0x03: via RF for ???? > 0x00
//
// Where:
// - DF is decode_frame
// - DF is decode_frame, implicit means skip_frame
// - DFC is decode_frame_config, implicit means nullptr args.dst
// - DIC is decode_image_config, implicit means nullptr args.dst
// - RF is restart_frame
// - TMM is tell_me_more
call_sequence : base.u8,
report_metadata_chrm : base.bool,
report_metadata_gama : base.bool,
report_metadata_iccp : base.bool,
report_metadata_kvp : base.bool,
report_metadata_srgb : base.bool,
ignore_checksum : base.bool,
depth : base.u8[..= 16],
@@ -74,17 +87,93 @@ pub struct decoder? implements base.image_decoder(
filter_distance : base.u8[..= 8],
interlace_pass : base.u8[..= 7],
seen_actl : base.bool,
seen_chrm : base.bool,
seen_fctl : base.bool,
seen_gama : base.bool,
seen_iccp : base.bool,
seen_idat : base.bool,
seen_plte : base.bool,
seen_srgb : base.bool,
seen_trns : base.bool,
metadata_is_zlib_compressed : base.bool,
zlib_is_dirty : base.bool,
chunk_type : base.u32,
chunk_type_array : array[4] base.u8,
chunk_length : base.u32,
// remap_transparency, if non-zero, is the 32-bit or 64-bit (depending on
// this.depth) argb_nonpremul color that is nominally opaque but remapped
// to transparent black.
//
// "Remapped" is an unofficial term. This is where the IHDR color type is 0
// (Y) or 2 (RGB) but there's also a tRNS chunk.
//
// PNG transparency that isn't "remapped" is color type 3 (indexed) with
// tRNS, color type 4 (YA) or color type 6 (RGBA).
remap_transparency : base.u64,
dst_pixfmt : base.u32,
src_pixfmt : base.u32,
chunk_type : base.u32,
chunk_type_array : array[4] base.u8,
chunk_length : base.u64,
num_animation_frames_value : base.u32,
num_animation_loops_value : base.u32,
num_decoded_frame_configs_value : base.u32,
num_decoded_frames_value : base.u32,
frame_config_io_position : base.u64,
// The frame_etc fields correspond to the base.frame_config argument passed
// to decode_frame_config. For animated APNG, these are explicitly given in
// the file's fcTL chunks. For still PNG, these are implicitly given in the
// file's IHDR chunk.
//
// Either way, decode_image_config has to read all the way to the start of
// the first IDAT / fdAT chunk (e.g. to see if there's a PLTE chunk). While
// later frame's restart io_positions are located just before fcTL chunks,
// the first frame's restart io_position is located just before the IDAT /
// fdAT chunk, so we also have to cache the first frame's configuration as
// we cannot re-read the first fcTL. Hence, there are first_etc fields for
// every frame_etc field.
//
// For the etc_duration fields, there are 705_600000 flicks per second and
// the maximum frame duration is 65535 seconds.
//
// The fields are ordered to minimize alignment wastage.
frame_rect_x0 : base.u32[..= 0x00FF_FFFF],
frame_rect_y0 : base.u32[..= 0x00FF_FFFF],
frame_rect_x1 : base.u32[..= 0x00FF_FFFF],
frame_rect_y1 : base.u32[..= 0x00FF_FFFF],
first_rect_x0 : base.u32[..= 0x00FF_FFFF],
first_rect_y0 : base.u32[..= 0x00FF_FFFF],
first_rect_x1 : base.u32[..= 0x00FF_FFFF],
first_rect_y1 : base.u32[..= 0x00FF_FFFF],
frame_config_io_position : base.u64,
first_config_io_position : base.u64,
frame_duration : base.u64[..= 0x2A0E_6FF1_6600],
first_duration : base.u64[..= 0x2A0E_6FF1_6600],
frame_disposal : base.u8,
first_disposal : base.u8,
frame_overwrite_instead_of_blend : base.bool,
first_overwrite_instead_of_blend : base.bool,
next_animation_seq_num : base.u32,
metadata_flavor : base.u32,
metadata_fourcc : base.u32,
metadata_x : base.u64,
metadata_y : base.u64,
metadata_z : base.u64,
// ztxt_ri and ztxt_wi are read and write indexes into the dst_palette
// buffer, re-purposed as a zlib uncompression buffer for zTXt chunks. The
// upper bound, 1024, is the same as the dst_palette length.
ztxt_ri : base.u32[..= 1024],
ztxt_wi : base.u32[..= 1024],
// ztxt_hist_pos is the history position: how many uncompressed bytes have
// been generated.
ztxt_hist_pos : base.u64,
swizzler : base.pixel_swizzler,
util : base.utility,
@@ -92,6 +181,10 @@ pub struct decoder? implements base.image_decoder(
crc32 : crc32.ieee_hasher,
zlib : zlib.decoder,
// dst_palette and src_palette are used by the swizzler, during
// decode_frame. src_palette is initialized by processing the PLTE chunk.
// dst_palette is also re-purposed as a zlib uncompression buffer for zTXt
// chunks, during decode_image_config.
dst_palette : array[4 * 256] base.u8,
src_palette : array[4 * 256] base.u8,
)
@@ -110,44 +203,49 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
var checksum_want : base.u32
var status : base.status
if this.call_sequence <> 0 {
if this.call_sequence == 2 {
if this.metadata_fourcc <> 0 {
this.call_sequence = 1
return base."@metadata reported"
}
} else if this.call_sequence <> 0 {
return base."#bad call sequence"
}
magic = args.src.read_u64le?()
if magic <> '\x89PNG\x0D\x0A\x1A\x0A'le {
return "#bad header"
}
magic = args.src.read_u64le?()
if magic <> '\x00\x00\x00\x0DIHDR'le {
return "#bad header"
}
this.crc32.reset!()
this.chunk_type_array[0] = 'I'
this.chunk_type_array[1] = 'H'
this.chunk_type_array[2] = 'D'
this.chunk_type_array[3] = 'R'
this.crc32.update_u32!(x: this.chunk_type_array[..])
while true {
mark = args.src.mark()
status =? this.decode_ihdr?(src: args.src)
if not this.ignore_checksum {
checksum_have = this.crc32.update_u32!(x: args.src.since(mark: mark))
} else {
magic = args.src.read_u64le?()
if magic <> '\x89PNG\x0D\x0A\x1A\x0A'le {
return "#bad header"
}
if status.is_ok() {
break
magic = args.src.read_u64le?()
if magic <> '\x00\x00\x00\x0DIHDR'le {
return "#bad header"
}
yield? status
} endwhile
this.chunk_type_array[0] = 'I'
this.chunk_type_array[1] = 'H'
this.chunk_type_array[2] = 'D'
this.chunk_type_array[3] = 'R'
this.crc32.reset!()
this.crc32.update_u32!(x: this.chunk_type_array[..])
// Verify CRC-32 checksum.
checksum_want = args.src.read_u32be?()
if (not this.ignore_checksum) and (checksum_have <> checksum_want) {
return "#bad checksum"
while true {
mark = args.src.mark()
status =? this.decode_ihdr?(src: args.src)
if not this.ignore_checksum {
checksum_have = this.crc32.update_u32!(x: args.src.since(mark: mark))
}
if status.is_ok() {
break
}
yield? status
} endwhile
// Verify CRC-32 checksum.
checksum_want = args.src.read_u32be?()
if (not this.ignore_checksum) and (checksum_have <> checksum_want) {
return "#bad checksum"
}
}
// Read up until an IDAT chunk.
// Read up until an IDAT or fdAT chunk.
//
// By default, libpng "warns and discards" when seeing ancillary chunk
// checksum failures (as opposed to critical chunk checksum failures) but
@@ -160,26 +258,43 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
// IDAT chunk breaks the loop. The only other possible critical chunk is a
// PLTE chunk. We verify PLTE checksums here but ignore other checksums.
while true {
this.chunk_length = args.src.read_u32be_as_u64?()
this.chunk_type = args.src.read_u32le?()
if (not this.ignore_checksum) and
((this.chunk_type == 'IDAT'le) or (this.chunk_type == 'PLTE'le)) {
this.crc32.reset!()
while args.src.length() < 8,
post args.src.length() >= 8,
{
if args.src.is_closed() {
return "#bad chunk"
}
yield? base."$short read"
} endwhile
this.chunk_length = args.src.peek_u32be()
this.chunk_type = (args.src.peek_u64le() >> 32) as base.u32
if this.chunk_type == 'IDAT'le {
if (not this.seen_actl) or this.seen_fctl {
break
}
this.seen_idat = true
} else if this.chunk_type == 'fdAT'le {
if this.seen_idat and this.seen_fctl {
break
}
return "#bad chunk"
}
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
if (not this.ignore_checksum) and ((this.chunk_type & ANCILLARY_BIT) == 0) {
this.chunk_type_array[0] = ((this.chunk_type >> 0) & 0xFF) as base.u8
this.chunk_type_array[1] = ((this.chunk_type >> 8) & 0xFF) as base.u8
this.chunk_type_array[2] = ((this.chunk_type >> 16) & 0xFF) as base.u8
this.chunk_type_array[3] = ((this.chunk_type >> 24) & 0xFF) as base.u8
this.crc32.reset!()
this.crc32.update_u32!(x: this.chunk_type_array[..])
}
if this.chunk_type == 'IDAT'le {
break
}
while true {
mark = args.src.mark()
status =? this.decode_other_chunk?(src: args.src)
if (not this.ignore_checksum) and (this.chunk_type == 'PLTE'le) {
if (not this.ignore_checksum) and ((this.chunk_type & ANCILLARY_BIT) == 0) {
checksum_have = this.crc32.update_u32!(x: args.src.since(mark: mark))
}
if status.is_ok() {
@@ -187,12 +302,19 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
}
yield? status
} endwhile
// If we have metadata, delay reading (skipping) the ancillary chunk's
// CRC-32 checksum until the end of tell_me_more.
if this.metadata_fourcc <> 0 {
this.call_sequence = 1
return base."@metadata reported"
}
checksum_want = args.src.read_u32be?()
if (not this.ignore_checksum) and (this.chunk_type == 'PLTE'le) and
if (not this.ignore_checksum) and ((this.chunk_type & ANCILLARY_BIT) == 0) and
(checksum_have <> checksum_want) {
return "#bad checksum"
}
} endwhile
if (this.color_type == 3) and (not this.seen_plte) {
@@ -200,6 +322,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
}
this.frame_config_io_position = args.src.position()
this.first_config_io_position = this.frame_config_io_position
if args.dst <> nullptr {
args.dst.set!(
@@ -207,10 +330,23 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
pixsub: 0,
width: this.width,
height: this.height,
first_frame_io_position: this.frame_config_io_position,
first_frame_io_position: this.first_config_io_position,
first_frame_is_opaque: (this.color_type <= 3) and (not this.seen_trns))
}
// For still (non-animated) PNGs, the first and only frame's configuration
// is implied by the IHDR chunk instead of an explicit fcTL chunk.
if not this.seen_actl {
this.num_animation_frames_value = 1
this.first_rect_x0 = 0
this.first_rect_y0 = 0
this.first_rect_x1 = this.width
this.first_rect_y1 = this.height
this.first_duration = 0
this.first_disposal = base.ANIMATION_DISPOSAL__NONE
this.first_overwrite_instead_of_blend = false
}
this.call_sequence = 3
}
@@ -251,7 +387,7 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
// Compression.
a8 = args.src.read_u8?()
if a8 <> 0 {
return "#bad header"
return "#unsupported PNG compression method"
}
// Filter.
@@ -275,7 +411,7 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
this.filter_distance = 0
this.assign_filter_distance!()
if this.filter_distance == 0 {
return "#unsupported PNG file"
return "#bad header"
}
this.overall_workbuf_length = (this.height as base.u64) *
(1 + this.calculate_bytes_per_row(width: this.width))
@@ -284,7 +420,9 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
pri func decoder.assign_filter_distance!() {
if this.depth < 8 {
if this.color_type == 0 {
if (this.depth <> 1) and (this.depth <> 2) and (this.depth <> 4) {
return nothing
} else if this.color_type == 0 {
this.dst_pixfmt = base.PIXEL_FORMAT__Y
this.src_pixfmt = base.PIXEL_FORMAT__Y
} else if this.color_type == 3 {
@@ -402,6 +540,62 @@ pri func decoder.decode_other_chunk?(src: base.io_reader) {
}
this.decode_plte?(src: args.src)
this.seen_plte = true
} else if (this.chunk_type & ANCILLARY_BIT) == 0 {
if this.chunk_type <> 'IDAT'le {
return "#bad chunk"
}
} else if this.chunk_type == 'acTL'le {
if this.seen_actl {
return "#bad chunk"
}
this.decode_actl?(src: args.src)
this.seen_actl = true
} else if this.chunk_type == 'cHRM'le {
if this.report_metadata_chrm {
if this.seen_chrm {
return "#bad chunk"
}
this.decode_chrm?(src: args.src)
this.seen_chrm = true
}
} else if this.chunk_type == 'fcTL'le {
if this.seen_fctl {
return "#bad chunk"
}
this.decode_fctl?(src: args.src)
this.seen_fctl = true
} else if this.chunk_type == 'gAMA'le {
if this.report_metadata_gama {
if this.seen_gama {
return "#bad chunk"
}
this.decode_gama?(src: args.src)
this.seen_gama = true
}
} else if this.chunk_type == 'iCCP'le {
if this.report_metadata_iccp {
if this.seen_iccp {
return "#bad chunk"
}
this.decode_iccp?(src: args.src)
this.seen_iccp = true
}
} else if this.chunk_type == 'sRGB'le {
if this.report_metadata_srgb {
if this.seen_srgb {
return "#bad chunk"
}
this.decode_srgb?(src: args.src)
this.seen_srgb = true
}
} else if this.chunk_type == 'tRNS'le {
if this.seen_trns or (this.color_type > 3) or
((this.color_type == 3) and (not this.seen_plte)) {
@@ -409,9 +603,200 @@ pri func decoder.decode_other_chunk?(src: base.io_reader) {
}
this.decode_trns?(src: args.src)
this.seen_trns = true
} else {
args.src.skip?(n: this.chunk_length)
} else if (this.chunk_type == 'iTXt'le) or
(this.chunk_type == 'tEXt'le) or
(this.chunk_type == 'zTXt'le) {
if this.report_metadata_kvp {
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM
this.metadata_fourcc = 'KVPK'be
this.metadata_x = 0
this.metadata_y = 0
this.metadata_z = 0
}
}
if this.metadata_fourcc == 0 {
args.src.skip_u32?(n: this.chunk_length)
}
}
pri func decoder.decode_actl?(src: base.io_reader) {
if this.chunk_length <> 8 {
return "#bad chunk"
} else if this.interlace_pass > 0 {
// https://wiki.mozilla.org/APNG_Specification doesn't say whether the
// interlace pattern starts at the image or frame top-left corner. We
// avoid the question by returning "unsupported" for now.
return "#unsupported PNG file"
}
this.chunk_length = 0
this.num_animation_frames_value = args.src.read_u32be?()
if this.num_animation_frames_value == 0 {
return "#bad chunk"
}
this.num_animation_loops_value = args.src.read_u32be?()
}
pri func decoder.decode_chrm?(src: base.io_reader) {
var u : base.u64
if this.chunk_length <> 32 {
return "#bad chunk"
}
this.chunk_length = 0
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_PARSED
this.metadata_fourcc = 'CHRM'be
this.metadata_x = 0
this.metadata_y = 0
this.metadata_z = 0
// See the wuffs_base__more_information__metadata_parsed__chrm comments for
// how we pack the eight chromaticity values into three u64 fields. This
// admittedly truncates chromaticity values from 32 to 24 bits, but in
// practice they only range between 0 and 100000 (which is 0x01_86A0).
u = args.src.read_u32be_as_u64?()
this.metadata_x |= (0xFF_FFFF & u) << 0
u = args.src.read_u32be_as_u64?()
this.metadata_x |= (0xFF_FFFF & u) << 24
u = args.src.read_u32be_as_u64?()
this.metadata_x |= (0xFF_FFFF & u) ~mod<< 48
this.metadata_y |= (0xFF_FFFF & u) >> 16
u = args.src.read_u32be_as_u64?()
this.metadata_y |= (0xFF_FFFF & u) << 8
u = args.src.read_u32be_as_u64?()
this.metadata_y |= (0xFF_FFFF & u) << 32
u = args.src.read_u32be_as_u64?()
this.metadata_y |= (0xFF_FFFF & u) ~mod<< 56
this.metadata_z |= (0xFF_FFFF & u) >> 8
u = args.src.read_u32be_as_u64?()
this.metadata_z |= (0xFF_FFFF & u) << 16
u = args.src.read_u32be_as_u64?()
this.metadata_z |= (0xFF_FFFF & u) << 40
}
pri func decoder.decode_fctl?(src: base.io_reader) {
var x0 : base.u32
var y0 : base.u32
var x1 : base.u32
var y1 : base.u32
if this.chunk_length <> 26 {
return "#bad chunk"
}
this.chunk_length = 0
x0 = args.src.read_u32be?()
if x0 <> this.next_animation_seq_num {
return "#bad animation sequence number"
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
return "#unsupported PNG file"
}
this.next_animation_seq_num += 1
x1 = args.src.read_u32be?()
y1 = args.src.read_u32be?()
x0 = args.src.read_u32be?()
y0 = args.src.read_u32be?()
x1 ~mod+= x0
y1 ~mod+= y0
if (x0 >= x1) or (x0 > this.width) or (x1 > this.width) or
(y0 >= y1) or (y0 > this.height) or (y1 > this.height) {
return "#bad chunk"
}
assert x1 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: this.width)
assert y1 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: this.height)
assert x0 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: x1)
assert y0 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: y1)
this.frame_rect_x0 = x0
this.frame_rect_y0 = y0
this.frame_rect_x1 = x1
this.frame_rect_y1 = y1
// There are 705_600000 flicks per second. A nominally zero denominator
// means to use 100 instead (the units are centiseconds, the same as GIF).
x0 = args.src.read_u16be_as_u32?()
x1 = args.src.read_u16be_as_u32?()
if x1 <= 0 {
this.frame_duration = (x0 as base.u64) * 7_056000
} else {
this.frame_duration = ((x0 as base.u64) * 705_600000) / (x1 as base.u64)
}
x0 = args.src.read_u8_as_u32?()
if x0 == 0 {
this.frame_disposal = base.ANIMATION_DISPOSAL__NONE
} else if x0 == 1 {
this.frame_disposal = base.ANIMATION_DISPOSAL__RESTORE_BACKGROUND
} else if x0 == 2 {
this.frame_disposal = base.ANIMATION_DISPOSAL__RESTORE_PREVIOUS
} else {
return "#bad chunk"
}
x0 = args.src.read_u8_as_u32?()
if x0 == 0 {
this.frame_overwrite_instead_of_blend = true
} else if x0 == 1 {
this.frame_overwrite_instead_of_blend = false
} else {
return "#bad chunk"
}
if this.num_decoded_frame_configs_value == 0 {
this.first_rect_x0 = this.frame_rect_x0
this.first_rect_y0 = this.frame_rect_y0
this.first_rect_x1 = this.frame_rect_x1
this.first_rect_y1 = this.frame_rect_y1
this.first_duration = this.frame_duration
this.first_disposal = this.frame_disposal
this.first_overwrite_instead_of_blend = this.frame_overwrite_instead_of_blend
}
}
pri func decoder.decode_gama?(src: base.io_reader) {
if this.chunk_length <> 4 {
return "#bad chunk"
}
this.chunk_length = 0
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_PARSED
this.metadata_fourcc = 'GAMA'be
this.metadata_x = args.src.read_u32be_as_u64?()
this.metadata_y = 0
this.metadata_z = 0
}
pri func decoder.decode_iccp?(src: base.io_reader) {
var c : base.u8
// Skip the NUL-terminated color profile name.
while true {
if this.chunk_length <= 0 {
return "#bad chunk"
}
this.chunk_length -= 1
c = args.src.read_u8?()
if c == 0 {
break
}
} endwhile
// Compression method.
if this.chunk_length <= 0 {
return "#bad chunk"
}
this.chunk_length -= 1
c = args.src.read_u8?()
if c <> 0 {
return "#unsupported PNG compression method"
}
this.metadata_is_zlib_compressed = true
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM
this.metadata_fourcc = 'ICCP'be
this.metadata_x = 0
this.metadata_y = 0
this.metadata_z = 0
}
pri func decoder.decode_plte?(src: base.io_reader) {
@@ -423,6 +808,7 @@ pri func decoder.decode_plte?(src: base.io_reader) {
return "#bad chunk"
}
num_entries = (this.chunk_length as base.u32) / 3
this.chunk_length = 0
while i < num_entries {
assert i < 256 via "a < b: a < c; c <= b"(c: num_entries)
@@ -447,82 +833,304 @@ pri func decoder.decode_plte?(src: base.io_reader) {
} endwhile
}
pri func decoder.decode_trns?(src: base.io_reader) {
var num_entries : base.u32[..= 256]
var i : base.u32
if this.chunk_length > 256 {
pri func decoder.decode_srgb?(src: base.io_reader) {
if this.chunk_length <> 1 {
return "#bad chunk"
}
num_entries = this.chunk_length as base.u32
this.chunk_length = 0
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_PARSED
this.metadata_fourcc = 'SRGB'be
this.metadata_x = args.src.read_u8_as_u64?()
this.metadata_y = 0
this.metadata_z = 0
}
while i < num_entries {
assert i < 256 via "a < b: a < c; c <= b"(c: num_entries)
this.src_palette[(4 * i) + 3] = args.src.read_u8?()
i += 1
} endwhile
pri func decoder.decode_trns?(src: base.io_reader) {
var i : base.u32
var n : base.u32[..= 256]
var u : base.u64
if this.color_type == 3 {
this.dst_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
this.src_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
} else {
if this.color_type == 0 {
choose filter_and_swizzle = [filter_and_swizzle_tricky]
if this.color_type == 0 {
// TODO: PIXEL_FORMAT__YA_NONPREMUL
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
} else if this.color_type == 2 {
if this.depth <= 8 {
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
} else {
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
}
if this.chunk_length <> 2 {
return "#bad chunk"
}
this.chunk_length = 0
u = args.src.read_u16be_as_u64?()
if this.depth <= 1 {
this.remap_transparency = ((u & 0x01) * 0xFF_FFFF) | 0xFF00_0000
} else if this.depth <= 2 {
this.remap_transparency = ((u & 0x03) * 0x55_5555) | 0xFF00_0000
} else if this.depth <= 4 {
this.remap_transparency = ((u & 0x0F) * 0x11_1111) | 0xFF00_0000
} else if this.depth <= 8 {
this.remap_transparency = ((u & 0xFF) * 0x01_0101) | 0xFF00_0000
} else {
this.remap_transparency = (u * 0x0001_0001_0001) | 0xFFFF_0000_0000_0000
}
} else if this.color_type == 2 {
choose filter_and_swizzle = [filter_and_swizzle_tricky]
if this.depth <= 8 {
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
} else {
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
}
if this.chunk_length <> 6 {
return "#bad chunk"
}
this.chunk_length = 0
u = args.src.read_u48be_as_u64?()
if this.depth <= 8 {
this.remap_transparency =
(0x0000_00FF & (u >> 0)) |
(0x0000_FF00 & (u >> 8)) |
(0x00FF_0000 & (u >> 16)) |
0xFF00_0000
} else {
this.remap_transparency = u | 0xFFFF_0000_0000_0000
}
} else if this.color_type == 3 {
this.dst_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
this.src_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
if this.chunk_length > 256 {
return "#bad chunk"
}
n = this.chunk_length as base.u32
this.chunk_length = 0
while i < n {
assert i < 256 via "a < b: a < c; c <= b"(c: n)
this.src_palette[(4 * i) + 3] = args.src.read_u8?()
i += 1
} endwhile
} else {
return "#bad chunk"
}
}
pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
if this.call_sequence < 3 {
if this.call_sequence == 0xFF {
return base."@end of data"
} else if this.call_sequence < 3 {
this.decode_image_config?(dst: nullptr, src: args.src)
} else if this.call_sequence == 3 {
if this.frame_config_io_position <> args.src.position() {
return base."#bad restart"
}
} else if this.call_sequence == 4 {
this.call_sequence = 0xFF
return base."@end of data"
this.skip_frame?(src: args.src)
if this.call_sequence == 0xFF {
return base."@end of data"
}
}
if this.num_decoded_frame_configs_value == 0 {
this.frame_rect_x0 = this.first_rect_x0
this.frame_rect_y0 = this.first_rect_y0
this.frame_rect_x1 = this.first_rect_x1
this.frame_rect_y1 = this.first_rect_y1
this.frame_config_io_position = this.first_config_io_position
this.frame_duration = this.first_duration
this.frame_disposal = this.first_disposal
this.frame_overwrite_instead_of_blend = this.first_overwrite_instead_of_blend
} else {
return base."@end of data"
// Decode the next fcTL chunk.
while true {
this.chunk_length = args.src.read_u32be?()
this.chunk_type = args.src.read_u32le?()
if this.chunk_type == 'fdAT'le {
return "#bad chunk"
} else if this.chunk_type == 'fcTL'le {
this.frame_config_io_position = args.src.position() ~mod- 8
this.decode_fctl?(src: args.src)
args.src.skip?(n: 4) // Skip the checksum.
break
}
args.src.skip?(n: (this.chunk_length as base.u64) + 4) // +4 for the checksum.
this.chunk_length = 0
} endwhile
}
if args.dst <> nullptr {
args.dst.set!(bounds: this.util.make_rect_ie_u32(
min_incl_x: 0,
min_incl_y: 0,
max_excl_x: this.width,
max_excl_y: this.height),
duration: 0,
index: 0,
min_incl_x: this.frame_rect_x0,
min_incl_y: this.frame_rect_y0,
max_excl_x: this.frame_rect_x1,
max_excl_y: this.frame_rect_y1),
duration: this.frame_duration,
index: this.num_decoded_frame_configs_value as base.u64,
io_position: this.frame_config_io_position,
disposal: 0,
opaque_within_bounds: false,
overwrite_instead_of_blend: false,
disposal: this.frame_disposal,
opaque_within_bounds: (this.color_type <= 3) and (not this.seen_trns),
overwrite_instead_of_blend: this.frame_overwrite_instead_of_blend,
background_color: 0x0000_0000)
}
this.num_decoded_frame_configs_value ~sat+= 1
this.call_sequence = 4
}
pri func decoder.skip_frame?(src: base.io_reader) {
var seq_num : base.u32
this.chunk_type_array[0] = 0
this.chunk_type_array[1] = 0
this.chunk_type_array[2] = 0
this.chunk_type_array[3] = 0
while true {
while args.src.length() < 8,
post args.src.length() >= 8,
{
if args.src.is_closed() {
return "#bad chunk"
}
yield? base."$short read"
} endwhile
this.chunk_length = args.src.peek_u32be()
this.chunk_type = (args.src.peek_u64le() >> 32) as base.u32
if this.chunk_type == 'IDAT'le {
if this.chunk_type_array[0] == 'f' {
return "#bad chunk"
}
this.chunk_type_array[0] = 'I'
this.chunk_type_array[1] = 'D'
this.chunk_type_array[2] = 'A'
this.chunk_type_array[3] = 'T'
} else if this.chunk_type == 'fdAT'le {
if this.chunk_type_array[0] == 'I' {
return "#bad chunk"
}
this.chunk_type_array[0] = 'f'
this.chunk_type_array[1] = 'd'
this.chunk_type_array[2] = 'A'
this.chunk_type_array[3] = 'T'
if this.chunk_length < 4 {
return "#bad chunk"
}
this.chunk_length -= 4
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
seq_num = args.src.read_u32be?()
if seq_num <> this.next_animation_seq_num {
return "#bad animation sequence number"
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
return "#unsupported PNG file"
}
this.next_animation_seq_num += 1
args.src.skip?(n: (this.chunk_length as base.u64) + 4) // +4 for the checksum.
this.chunk_length = 0
continue
} else if this.chunk_type_array[0] <> 0 {
break
} else if this.chunk_type == 'fcTL'le {
return "#bad chunk"
}
// +12 for chunk length, chunk type and checksum.
args.src.skip?(n: (this.chunk_length as base.u64) + 12)
this.chunk_length = 0
} endwhile
this.num_decoded_frames_value ~sat+= 1
if this.num_decoded_frames_value < this.num_animation_frames_value {
this.call_sequence = 5
} else {
this.call_sequence = 0xFF
}
}
pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
var seq_num : base.u32
var status : base.status
var pass_width : base.u32[..= 0x00FF_FFFF]
var pass_height : base.u32[..= 0x00FF_FFFF]
if this.call_sequence < 4 {
this.decode_frame_config?(dst: nullptr, src: args.src)
} else if this.call_sequence == 4 {
// No-op.
} else {
if this.call_sequence == 0xFF {
return base."@end of data"
} else if this.call_sequence <> 4 {
this.decode_frame_config?(dst: nullptr, src: args.src)
}
while true {
while args.src.length() < 8,
post args.src.length() >= 8,
{
if args.src.is_closed() {
return "#bad chunk"
}
yield? base."$short read"
} endwhile
this.chunk_length = args.src.peek_u32be()
this.chunk_type = (args.src.peek_u64le() >> 32) as base.u32
if this.chunk_type == 'IDAT'le {
this.chunk_type_array[0] = 'I'
this.chunk_type_array[1] = 'D'
this.chunk_type_array[2] = 'A'
this.chunk_type_array[3] = 'T'
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
if not this.ignore_checksum {
this.crc32.reset!()
this.crc32.update_u32!(x: this.chunk_type_array[..])
}
break
} else if this.chunk_type == 'fdAT'le {
this.chunk_type_array[0] = 'f'
this.chunk_type_array[1] = 'd'
this.chunk_type_array[2] = 'A'
this.chunk_type_array[3] = 'T'
if this.chunk_length < 4 {
return "#bad chunk"
}
this.chunk_length -= 4
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
seq_num = args.src.read_u32be?()
if seq_num <> this.next_animation_seq_num {
return "#bad animation sequence number"
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
return "#unsupported PNG file"
}
this.next_animation_seq_num += 1
break
} else if this.chunk_type == 'fcTL'le {
return "#bad chunk"
}
// +12 for chunk length, chunk type and checksum.
args.src.skip?(n: (this.chunk_length as base.u64) + 12)
this.chunk_length = 0
} endwhile
if this.zlib_is_dirty {
this.zlib.reset!()
if this.ignore_checksum {
this.zlib.set_quirk_enabled!(quirk: base.QUIRK_IGNORE_CHECKSUM, enabled: true)
}
}
this.zlib_is_dirty = true
status = this.swizzler.prepare!(
dst_pixfmt: args.dst.pixel_format(),
dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]),
@@ -533,13 +1141,19 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return status
}
this.workbuf_hist_pos_base = 0
while true {
pass_width = 0x00FF_FFFF &
(((INTERLACING[this.interlace_pass][1] as base.u32) + this.width) >>
INTERLACING[this.interlace_pass][0])
pass_height = 0x00FF_FFFF &
(((INTERLACING[this.interlace_pass][4] as base.u32) + this.height) >>
INTERLACING[this.interlace_pass][3])
if (this.chunk_type_array[0] == 'I') {
pass_width = 0x00FF_FFFF &
(((INTERLACING[this.interlace_pass][1] as base.u32) + this.width) >>
INTERLACING[this.interlace_pass][0])
pass_height = 0x00FF_FFFF &
(((INTERLACING[this.interlace_pass][4] as base.u32) + this.height) >>
INTERLACING[this.interlace_pass][3])
} else {
pass_width = 0x00FF_FFFF & (this.frame_rect_x1 ~mod- this.frame_rect_x0)
pass_height = 0x00FF_FFFF & (this.frame_rect_y1 ~mod- this.frame_rect_y0)
}
if (pass_width > 0) and (pass_height > 0) {
this.pass_bytes_per_row = this.calculate_bytes_per_row(width: pass_width)
@@ -549,6 +1163,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
if not status.is_ok() {
return status
}
this.workbuf_hist_pos_base ~mod+= this.pass_workbuf_length
}
if (this.interlace_pass == 0) or (this.interlace_pass >= 7) {
@@ -557,7 +1172,12 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
this.interlace_pass += 1
} endwhile
this.call_sequence = 0xFF
this.num_decoded_frames_value ~sat+= 1
if this.num_decoded_frames_value < this.num_animation_frames_value {
this.call_sequence = 5
} else {
this.call_sequence = 0xFF
}
}
pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
@@ -567,6 +1187,7 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
var zlib_status : base.status
var checksum_have : base.u32
var checksum_want : base.u32
var seq_num : base.u32
this.workbuf_wi = 0
while true {
@@ -574,8 +1195,8 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
this.pass_workbuf_length > args.workbuf.length()) {
return base."#bad workbuf length"
}
io_bind (io: w, data: args.workbuf[this.workbuf_wi .. this.pass_workbuf_length]) {
io_limit (io: args.src, limit: this.chunk_length) {
io_bind (io: w, data: args.workbuf[this.workbuf_wi .. this.pass_workbuf_length], history_position: this.workbuf_hist_pos_base ~mod+ this.workbuf_wi) {
io_limit (io: args.src, limit: (this.chunk_length as base.u64)) {
w_mark = w.mark()
r_mark = args.src.mark()
zlib_status =? this.zlib.transform_io?(
@@ -583,20 +1204,20 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
if not this.ignore_checksum {
this.crc32.update_u32!(x: args.src.since(mark: r_mark))
}
this.chunk_length ~sat-= args.src.count_since(mark: r_mark)
this.chunk_length ~sat-= (args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
this.workbuf_wi ~sat+= w.count_since(mark: w_mark)
}
}
if zlib_status.is_ok() {
if this.chunk_length > 0 {
// TODO: should this really be a fatal error?
return base."#too much data"
}
checksum_want = args.src.read_u32be?()
// Verify the final IDAT chunk's CRC-32 checksum.
if not this.ignore_checksum {
if this.chunk_length > 0 {
// TODO: should this really be a fatal error?
return base."#too much data"
}
if (not this.ignore_checksum) and (this.chunk_type_array[0] == 'I') {
checksum_have = this.crc32.update_u32!(x: this.util.empty_slice_u8())
checksum_want = args.src.read_u32be?()
if checksum_have <> checksum_want {
return "#bad checksum"
}
@@ -612,28 +1233,37 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
} else if this.chunk_length == 0 {
// Verify the non-final IDAT chunk's CRC-32 checksum.
checksum_want = args.src.read_u32be?()
if not this.ignore_checksum {
if (not this.ignore_checksum) and (this.chunk_type_array[0] == 'I') {
checksum_have = this.crc32.update_u32!(x: this.util.empty_slice_u8())
if checksum_have <> checksum_want {
return "#bad checksum"
}
}
// The next chunk should be another IDAT.
this.chunk_length = args.src.read_u32be_as_u64?()
// The next chunk should be another IDAT or fdAT.
this.chunk_length = args.src.read_u32be?()
this.chunk_type = args.src.read_u32le?()
if this.chunk_type <> 'IDAT'le {
return "#bad chunk"
}
// The 'IDAT'be is part of the next CRC-32 checksum's input.
if not this.ignore_checksum {
this.crc32.reset!()
this.chunk_type_array[0] = 'I'
this.chunk_type_array[1] = 'D'
this.chunk_type_array[2] = 'A'
this.chunk_type_array[3] = 'T'
this.crc32.update_u32!(x: this.chunk_type_array[..])
if (this.chunk_type_array[0] == 'I') {
if this.chunk_type <> 'IDAT'le {
return "#bad chunk"
}
// The IDAT is part of the next CRC-32 checksum's input.
if not this.ignore_checksum {
this.crc32.reset!()
this.crc32.update_u32!(x: this.chunk_type_array[..])
}
} else {
if (this.chunk_type <> 'fdAT'le) or (this.chunk_length < 4) {
return "#bad chunk"
}
this.chunk_length -= 4
seq_num = args.src.read_u32be?()
if seq_num <> this.next_animation_seq_num {
return "#bad animation sequence number"
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
return "#unsupported PNG file"
}
this.next_animation_seq_num += 1
}
continue
} else if args.src.length() > 0 {
@@ -656,35 +1286,29 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
pub func decoder.frame_dirty_rect() base.rect_ie_u32 {
return this.util.make_rect_ie_u32(
min_incl_x: 0,
min_incl_y: 0,
max_excl_x: this.width,
max_excl_y: this.height)
min_incl_x: this.frame_rect_x0,
min_incl_y: this.frame_rect_y0,
max_excl_x: this.frame_rect_x1,
max_excl_y: this.frame_rect_y1)
}
pub func decoder.num_animation_loops() base.u32 {
return 0
return this.num_animation_loops_value
}
pub func decoder.num_decoded_frame_configs() base.u64 {
if this.call_sequence > 3 {
return 1
}
return 0
return this.num_decoded_frame_configs_value as base.u64
}
pub func decoder.num_decoded_frames() base.u64 {
if this.call_sequence > 4 {
return 1
}
return 0
return this.num_decoded_frames_value as base.u64
}
pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
if this.call_sequence < 3 {
return base."#bad call sequence"
}
if args.index <> 0 {
} else if (args.index >= (this.num_animation_frames_value as base.u64)) or
((args.index == 0) and (args.io_position <> this.first_config_io_position)) {
return base."#bad argument"
}
this.call_sequence = 3
@@ -692,15 +1316,296 @@ pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.sta
this.interlace_pass = 1
}
this.frame_config_io_position = args.io_position
this.num_decoded_frame_configs_value = (args.index & 0xFFFF_FFFF) as base.u32
this.num_decoded_frames_value = this.num_decoded_frame_configs_value
return ok
}
pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
// TODO.
if args.fourcc == 'CHRM'be {
this.report_metadata_chrm = args.report
} else if args.fourcc == 'GAMA'be {
this.report_metadata_gama = args.report
} else if args.fourcc == 'ICCP'be {
this.report_metadata_iccp = args.report
} else if args.fourcc == 'KVP 'be {
this.report_metadata_kvp = args.report
} else if args.fourcc == 'SRGB'be {
this.report_metadata_srgb = args.report
}
}
pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
return base."#no more information"
var c : base.u8
var c2 : base.u16
var w : base.io_writer
var num_written : base.u64
var w_mark : base.u64
var r_mark : base.u64
var zlib_status : base.status
if this.call_sequence <> 1 {
return base."#bad call sequence"
}
if this.metadata_fourcc == 0 {
return base."#no more information"
}
if this.metadata_is_zlib_compressed {
if this.zlib_is_dirty {
this.zlib.reset!()
if this.ignore_checksum {
this.zlib.set_quirk_enabled!(quirk: base.QUIRK_IGNORE_CHECKSUM, enabled: true)
}
}
this.zlib_is_dirty = true
this.ztxt_hist_pos = 0
}
while.loop true {
if args.minfo <> nullptr {
args.minfo.set!(
flavor: this.metadata_flavor,
w: this.metadata_fourcc,
x: this.metadata_x,
y: this.metadata_y,
z: this.metadata_z)
}
if this.metadata_flavor <> base.MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM {
break.loop
}
if this.metadata_is_zlib_compressed {
if this.chunk_type == 'iCCP'le {
io_limit (io: args.src, limit: this.chunk_length as base.u64) {
r_mark = args.src.mark()
zlib_status =? this.zlib.transform_io?(
dst: args.dst, src: args.src, workbuf: this.util.empty_slice_u8())
this.chunk_length ~sat-=
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
}
if zlib_status.is_ok() {
this.metadata_is_zlib_compressed = false
break.loop
} else if not zlib_status.is_suspension() {
return zlib_status
}
yield? zlib_status
} else if this.chunk_type == 'iTXt'le {
// TODO: verify uncompressed data is UTF-8.
io_limit (io: args.src, limit: this.chunk_length as base.u64) {
r_mark = args.src.mark()
zlib_status =? this.zlib.transform_io?(
dst: args.dst, src: args.src, workbuf: this.util.empty_slice_u8())
this.chunk_length ~sat-=
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
}
if zlib_status.is_ok() {
this.metadata_is_zlib_compressed = false
break.loop
} else if not zlib_status.is_suspension() {
return zlib_status
}
yield? zlib_status
} else if this.chunk_type == 'zTXt'le {
// Fill this.dst_palette, zlib-uncompressing producing Latin-1.
if this.ztxt_ri == this.ztxt_wi {
io_bind (io: w, data: this.dst_palette[..], history_position: this.ztxt_hist_pos) {
io_limit (io: args.src, limit: this.chunk_length as base.u64) {
w_mark = w.mark()
r_mark = args.src.mark()
zlib_status =? this.zlib.transform_io?(
dst: w, src: args.src, workbuf: this.util.empty_slice_u8())
this.chunk_length ~sat-=
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
num_written = w.count_since(mark: w_mark)
}
}
if num_written > 1024 {
return "#internal error: inconsistent I/O"
}
this.ztxt_ri = 0
this.ztxt_wi = num_written as base.u32
this.ztxt_hist_pos ~sat+= num_written
}
// Drain this.dst_palette, converting from Latin-1 to UTF-8.
while this.ztxt_ri < this.ztxt_wi {
assert this.ztxt_ri < 1024 via "a < b: a < c; c <= b"(c: this.ztxt_wi)
c2 = LATIN_1[this.dst_palette[this.ztxt_ri]]
if c2 == 0 {
return "#bad text chunk (not Latin-1)"
} else if c2 <= 0x7F {
if args.dst.length() <= 0 {
yield? base."$short write"
c2 = 0
continue.loop
}
this.ztxt_ri += 1
args.dst.write_u8_fast!(a: c2 as base.u8)
} else {
if args.dst.length() <= 1 {
yield? base."$short write"
c2 = 0
continue.loop
}
this.ztxt_ri += 1
args.dst.write_u16le_fast!(a: c2)
}
} endwhile
if zlib_status.is_ok() {
this.metadata_is_zlib_compressed = false
break.loop
} else if not zlib_status.is_suspension() {
return zlib_status
} else if zlib_status <> base."$short write" {
yield? zlib_status
}
} else {
return "#internal error: inconsistent chunk type"
}
} else if (this.chunk_type == 'iTXt'le) and (this.metadata_fourcc == 'KVPV'be) {
// iTXt value is UTF-8.
//
// TODO: verify data is UTF-8.
while true {
if this.chunk_length <= 0 {
break.loop
} else if args.src.length() <= 0 {
yield? base."$short read"
continue.loop
} else if args.dst.length() <= 0 {
yield? base."$short write"
continue.loop
}
this.chunk_length -= 1
c = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
args.dst.write_u8_fast!(a: c)
} endwhile
} else {
// Other uncompressed keys and values are Latin-1.
while true {
if this.chunk_length <= 0 {
// Keys are NUL-terminated but values are not.
if this.metadata_fourcc == 'KVPK'be {
return "#bad chunk"
}
break.loop
} else if args.src.length() <= 0 {
yield? base."$short read"
continue.loop
}
c = args.src.peek_u8()
if c == 0 {
this.chunk_length -= 1
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
break.loop
}
c2 = LATIN_1[c]
if c2 == 0 {
return "#bad text chunk (not Latin-1)"
} else if c2 <= 0x7F {
if args.dst.length() <= 0 {
yield? base."$short write"
c2 = 0
continue.loop
}
this.chunk_length -= 1
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
args.dst.write_u8_fast!(a: c2 as base.u8)
} else {
if args.dst.length() <= 1 {
yield? base."$short write"
c2 = 0
continue.loop
}
this.chunk_length -= 1
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
args.dst.write_u16le_fast!(a: c2)
}
} endwhile
}
} endwhile.loop
// Key-value pairs come in... pairs.
if this.metadata_fourcc == 'KVPK'be {
this.metadata_fourcc = 'KVPV'be
if this.chunk_type == 'iTXt'le {
// Compression flag, compression method.
if this.chunk_length <= 1 {
return "#bad chunk"
}
this.chunk_length -= 2
c = args.src.read_u8?()
if c == 0 {
this.metadata_is_zlib_compressed = false
} else if c == 1 {
this.metadata_is_zlib_compressed = true
} else {
return "#bad chunk"
}
c = args.src.read_u8?()
if (c <> 0) and this.metadata_is_zlib_compressed {
return "#unsupported PNG compression method"
}
// Skip the language tag and translated keyword: two iterations
// looking for a NUL terminator.
this.metadata_fourcc ~mod-= 2
while this.metadata_fourcc <> 'KVPV'be {
this.metadata_fourcc ~mod+= 1
while true {
if this.chunk_length <= 0 {
return "#bad chunk"
}
this.chunk_length -= 1
c = args.src.read_u8?()
if c == 0 {
break
}
} endwhile
} endwhile
} else if this.chunk_type == 'zTXt'le {
// Compression method.
if this.chunk_length <= 0 {
return "#bad chunk"
}
this.chunk_length -= 1
c = args.src.read_u8?()
if c <> 0 {
return "#unsupported PNG compression method"
}
this.metadata_is_zlib_compressed = true
}
} else {
if this.chunk_length <> 0 {
return "#bad chunk"
}
// Skip the ancillary chunk's CRC-32 checksum.
args.src.skip?(n: 4)
this.metadata_flavor = 0
this.metadata_fourcc = 0
this.metadata_x = 0
this.metadata_y = 0
this.metadata_z = 0
}
this.call_sequence = 2
return ok
}
pub func decoder.workbuf_len() base.range_ii_u64 {
@@ -708,69 +1613,3 @@ pub func decoder.workbuf_len() base.range_ii_u64 {
min_incl: this.overall_workbuf_length,
max_incl: this.overall_workbuf_length)
}
// INTERLACING holds the Adam7 interlacing pattern, involving 7 passes:
// 1 6 4 6 2 6 4 6
// 7 7 7 7 7 7 7 7
// 5 6 5 6 5 6 5 6
// 7 7 7 7 7 7 7 7
// 3 6 4 6 3 6 4 6
// 7 7 7 7 7 7 7 7
// 5 6 5 6 5 6 5 6
// 7 7 7 7 7 7 7 7
//
// The six elements of each inner array are:
// 0: log2(x_stride)
// 1: x_stride - x_offset - 1
// 2: x_offset
// 3: log2(y_stride)
// 4: y_stride - y_offset - 1
// 5: y_offset
pri const INTERLACING : array[8] array[6] base.u8[..= 8] = [
[0, 0, 0, 0, 0, 0], // non-interlaced; xy_stride=1, xy_offset=0
[3, 7, 0, 3, 7, 0], // interlace_pass == 1
[3, 3, 4, 3, 7, 0], // interlace_pass == 2
[2, 3, 0, 3, 3, 4], // interlace_pass == 3
[2, 1, 2, 2, 3, 0], // interlace_pass == 4
[1, 1, 0, 2, 1, 2], // interlace_pass == 5
[1, 0, 1, 1, 1, 0], // interlace_pass == 6
[0, 0, 0, 1, 0, 1], // interlace_pass == 7
]
// LOW_BIT_DEPTH_MULTIPLIERS holds multipliers that convert D-bit values into
// 8-bit values, for depth D.
pri const LOW_BIT_DEPTH_MULTIPLIERS : array[8] base.u8 = [
0,
0b1111_1111, // depth == 1
0b0101_0101, // depth == 2
0,
0b0001_0001, // depth == 4
0,
0,
0,
]
// LOW_BIT_DEPTH_NUM_PACKS holds the number of smaller-than-1-byte units that
// are packed into each byte.
pri const LOW_BIT_DEPTH_NUM_PACKS : array[8] base.u8 = [
0,
8, // depth == 1
4, // depth == 2
0,
2, // depth == 4
0,
0,
0,
]
// NUM_CHANNELS holds the number of channels for each valid color type.
pri const NUM_CHANNELS : array[8] base.u8[..= 4] = [
1, // color_type == 0: Y
0,
3, // color_type == 2: RGB
1, // color_type == 3: indexed
2, // color_type == 4: YA
0,
4, // color_type == 6: RGBA
0,
]
@@ -18,7 +18,8 @@ pri func decoder.filter_and_swizzle!(dst: ptr base.pixel_buffer, workbuf: slice
var dst_pixfmt : base.pixel_format
var dst_bits_per_pixel : base.u32[..= 256]
var dst_bytes_per_pixel : base.u64[..= 32]
var dst_bytes_per_row : base.u64
var dst_bytes_per_row0 : base.u64
var dst_bytes_per_row1 : base.u64
var dst_palette : slice base.u8
var tab : table base.u8
@@ -36,16 +37,37 @@ pri func decoder.filter_and_swizzle!(dst: ptr base.pixel_buffer, workbuf: slice
return base."#unsupported option"
}
dst_bytes_per_pixel = (dst_bits_per_pixel / 8) as base.u64
dst_bytes_per_row = (this.width as base.u64) * dst_bytes_per_pixel
dst_bytes_per_row0 = (this.frame_rect_x0 as base.u64) * dst_bytes_per_pixel
dst_bytes_per_row1 = (this.frame_rect_x1 as base.u64) * dst_bytes_per_pixel
dst_palette = args.dst.palette_or_else(fallback: this.dst_palette[..])
tab = args.dst.plane(p: 0)
while y < this.height {
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.height)
dst = tab.row(y: y)
if dst_bytes_per_row < dst.length() {
dst = dst[.. dst_bytes_per_row]
}
if dst_bytes_per_row1 < tab.width() {
tab = tab.subtable(
min_incl_x: 0,
min_incl_y: 0,
max_incl_x: dst_bytes_per_row1,
max_incl_y: tab.height())
}
if dst_bytes_per_row0 < tab.width() {
tab = tab.subtable(
min_incl_x: dst_bytes_per_row0,
min_incl_y: 0,
max_incl_x: tab.width(),
max_incl_y: tab.height())
} else {
tab = tab.subtable(
min_incl_x: 0,
min_incl_y: 0,
max_incl_x: 0,
max_incl_y: 0)
}
y = this.frame_rect_y0
while y < this.frame_rect_y1 {
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_y1)
dst = tab.row_u32(y: y)
if 1 > args.workbuf.length() {
return "#internal error: inconsistent workbuf length"
+139 -28
View File
@@ -16,7 +16,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
var dst_pixfmt : base.pixel_format
var dst_bits_per_pixel : base.u32[..= 256]
var dst_bytes_per_pixel : base.u64[..= 32]
var dst_bytes_per_row : base.u64
var dst_bytes_per_row1 : base.u64
var dst_palette : slice base.u8
var tab : table base.u8
@@ -45,7 +45,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
return base."#unsupported option"
}
dst_bytes_per_pixel = (dst_bits_per_pixel / 8) as base.u64
dst_bytes_per_row = (this.width as base.u64) * dst_bytes_per_pixel
dst_bytes_per_row1 = (this.frame_rect_x1 as base.u64) * dst_bytes_per_pixel
dst_palette = args.dst.palette_or_else(fallback: this.dst_palette[..])
tab = args.dst.plane(p: 0)
@@ -55,21 +55,16 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
((this.depth >> 3) as base.u64)
}
bits_unpacked[0] = 0xFF
bits_unpacked[1] = 0xFF
bits_unpacked[2] = 0xFF
bits_unpacked[3] = 0xFF
bits_unpacked[4] = 0xFF
bits_unpacked[5] = 0xFF
bits_unpacked[6] = 0xFF
bits_unpacked[7] = 0xFF
y = INTERLACING[this.interlace_pass][5] as base.u32
while y < this.height {
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.height)
dst = tab.row(y: y)
if dst_bytes_per_row < dst.length() {
dst = dst[.. dst_bytes_per_row]
if (this.chunk_type_array[0] == 'I') {
y = INTERLACING[this.interlace_pass][5] as base.u32
} else {
y = this.frame_rect_y0
}
while y < this.frame_rect_y1 {
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_y1)
dst = tab.row_u32(y: y)
if dst_bytes_per_row1 < dst.length() {
dst = dst[.. dst_bytes_per_row1]
}
if 1 > args.workbuf.length() {
@@ -98,12 +93,16 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
}
s = curr_row
x = INTERLACING[this.interlace_pass][2] as base.u32
if (this.chunk_type_array[0] == 'I') {
x = INTERLACING[this.interlace_pass][2] as base.u32
} else {
x = this.frame_rect_x0
}
if this.depth == 8 {
while x < this.width,
while x < this.frame_rect_x1,
inv y < 0x00FF_FFFF,
{
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.width)
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
i = (x as base.u64) * dst_bytes_per_pixel
if i <= dst.length() {
if this.color_type == 4 {
@@ -118,6 +117,54 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
dst_palette: dst_palette,
src: bits_unpacked[.. 4])
}
} else if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) <> 0 {
if this.color_type == 0 {
if 1 <= s.length() {
bits_unpacked[0] = s[0]
bits_unpacked[1] = s[0]
bits_unpacked[2] = s[0]
bits_unpacked[3] = 0xFF
s = s[1 ..]
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
((bits_unpacked[0] as base.u32) << 0) |
((bits_unpacked[1] as base.u32) << 8) |
((bits_unpacked[2] as base.u32) << 16) |
((bits_unpacked[3] as base.u32) << 24)) {
bits_unpacked[0] = 0
bits_unpacked[1] = 0
bits_unpacked[2] = 0
bits_unpacked[3] = 0
}
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst[i ..],
dst_palette: dst_palette,
src: bits_unpacked[.. 4])
}
} else {
if 3 <= s.length() {
bits_unpacked[0] = s[2]
bits_unpacked[1] = s[1]
bits_unpacked[2] = s[0]
bits_unpacked[3] = 0xFF
s = s[3 ..]
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
((bits_unpacked[0] as base.u32) << 0) |
((bits_unpacked[1] as base.u32) << 8) |
((bits_unpacked[2] as base.u32) << 16) |
((bits_unpacked[3] as base.u32) << 24)) {
bits_unpacked[0] = 0
bits_unpacked[1] = 0
bits_unpacked[2] = 0
bits_unpacked[3] = 0
}
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst[i ..],
dst_palette: dst_palette,
src: bits_unpacked[.. 4])
}
}
} else if src_bytes_per_pixel <= s.length() {
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst[i ..],
@@ -137,11 +184,11 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
shift = (8 - this.depth) & 7
packs_remaining = 0
while x < this.width,
while x < this.frame_rect_x1,
inv y < 0x00FF_FFFF,
inv this.depth < 8,
{
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.width)
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
i = (x as base.u64) * dst_bytes_per_pixel
if i <= dst.length() {
if (packs_remaining == 0) and (1 <= s.length()) {
@@ -153,19 +200,40 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
bits_packed = bits_packed ~mod<< this.depth
packs_remaining = packs_remaining ~mod- 1
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst[i ..],
dst_palette: dst_palette,
src: bits_unpacked[.. 1])
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) <> 0 {
bits_unpacked[1] = bits_unpacked[0]
bits_unpacked[2] = bits_unpacked[0]
bits_unpacked[3] = 0xFF
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
((bits_unpacked[0] as base.u32) << 0) |
((bits_unpacked[1] as base.u32) << 8) |
((bits_unpacked[2] as base.u32) << 16) |
((bits_unpacked[3] as base.u32) << 24)) {
bits_unpacked[0] = 0
bits_unpacked[1] = 0
bits_unpacked[2] = 0
bits_unpacked[3] = 0
}
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst[i ..],
dst_palette: dst_palette,
src: bits_unpacked[.. 4])
} else {
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst[i ..],
dst_palette: dst_palette,
src: bits_unpacked[.. 1])
}
}
x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
} endwhile
} else {
while x < this.width,
while x < this.frame_rect_x1,
inv y < 0x00FF_FFFF,
{
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.width)
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
i = (x as base.u64) * dst_bytes_per_pixel
if i <= dst.length() {
if this.color_type == 0 {
@@ -176,8 +244,29 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
bits_unpacked[3] = s[0]
bits_unpacked[4] = s[1]
bits_unpacked[5] = s[0]
bits_unpacked[6] = 0xFF
bits_unpacked[7] = 0xFF
s = s[2 ..]
if this.remap_transparency == (
((bits_unpacked[0] as base.u64) << 0) |
((bits_unpacked[1] as base.u64) << 8) |
((bits_unpacked[2] as base.u64) << 16) |
((bits_unpacked[3] as base.u64) << 24) |
((bits_unpacked[4] as base.u64) << 32) |
((bits_unpacked[5] as base.u64) << 40) |
((bits_unpacked[6] as base.u64) << 48) |
((bits_unpacked[7] as base.u64) << 56)) {
bits_unpacked[0] = 0
bits_unpacked[1] = 0
bits_unpacked[2] = 0
bits_unpacked[3] = 0
bits_unpacked[4] = 0
bits_unpacked[5] = 0
bits_unpacked[6] = 0
bits_unpacked[7] = 0
}
}
} else if this.color_type == 2 {
if 6 <= s.length() {
bits_unpacked[0] = s[5]
@@ -186,8 +275,29 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
bits_unpacked[3] = s[2]
bits_unpacked[4] = s[1]
bits_unpacked[5] = s[0]
bits_unpacked[6] = 0xFF
bits_unpacked[7] = 0xFF
s = s[6 ..]
if this.remap_transparency == (
((bits_unpacked[0] as base.u64) << 0) |
((bits_unpacked[1] as base.u64) << 8) |
((bits_unpacked[2] as base.u64) << 16) |
((bits_unpacked[3] as base.u64) << 24) |
((bits_unpacked[4] as base.u64) << 32) |
((bits_unpacked[5] as base.u64) << 40) |
((bits_unpacked[6] as base.u64) << 48) |
((bits_unpacked[7] as base.u64) << 56)) {
bits_unpacked[0] = 0
bits_unpacked[1] = 0
bits_unpacked[2] = 0
bits_unpacked[3] = 0
bits_unpacked[4] = 0
bits_unpacked[5] = 0
bits_unpacked[6] = 0
bits_unpacked[7] = 0
}
}
} else if this.color_type == 4 {
if 4 <= s.length() {
bits_unpacked[0] = s[1]
@@ -200,6 +310,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
bits_unpacked[7] = s[2]
s = s[4 ..]
}
} else {
if 8 <= s.length() {
bits_unpacked[0] = s[5]
+2 -2
View File
@@ -196,7 +196,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
tab = args.dst.plane(p: 0)
while dst_y < this.height {
assert dst_y < 0xFFFF_FFFF via "a < b: a < c; c <= b"(c: this.height)
dst = tab.row(y: dst_y)
dst = tab.row_u32(y: dst_y)
dst_x = 0
while dst_x < this.width,
@@ -212,7 +212,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
{
yield? base."$short read"
tab = args.dst.plane(p: 0)
dst = tab.row(y: dst_y)
dst = tab.row_u32(y: dst_y)
dst_x_in_bytes = (dst_x as base.u64) * dst_bytes_per_pixel
if dst_x_in_bytes <= dst.length() {
dst = dst[dst_x_in_bytes ..]
+1 -2
View File
@@ -62,8 +62,7 @@ mimic_gif_decode(uint64_t* n_bytes_out,
goto cleanup1;
}
int i;
for (i = 0; i < f->ImageCount; i++) {
for (int i = 0; i < f->ImageCount; i++) {
// Copy the pixel data from the GifFileType* f to the dst buffer, since the
// former is free'd at the end of this function.
//
+2 -4
View File
@@ -64,8 +64,7 @@ mimic_png_decode(uint64_t* n_bytes_out,
spng_ctx* ctx = spng_ctx_new(0);
size_t i;
for (i = 0; i < quirks_len; i++) {
for (size_t i = 0; i < quirks_len; i++) {
uint32_t q = quirks_ptr[i];
if (q == WUFFS_BASE__QUIRK_IGNORE_CHECKSUM) {
spng_set_crc_action(ctx, SPNG_CRC_USE, SPNG_CRC_USE);
@@ -358,8 +357,7 @@ mimic_png_decode(uint64_t* n_bytes_out,
goto cleanup0;
}
size_t i;
for (i = 0; i < quirks_len; i++) {
for (size_t i = 0; i < quirks_len; i++) {
uint32_t q = quirks_ptr[i];
if (q == WUFFS_BASE__QUIRK_IGNORE_CHECKSUM) {
// TODO: configure libpng to ignore Adler-32 and CRC-32 checksums.
+4 -7
View File
@@ -131,15 +131,13 @@ test_wuffs_adler32_golden() {
},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, test_cases[tc].filename));
int j;
for (j = 0; j < 2; j++) {
for (int j = 0; j < 2; j++) {
wuffs_adler32__hasher checksum;
CHECK_STATUS("initialize",
wuffs_adler32__hasher__initialize(
@@ -164,7 +162,7 @@ test_wuffs_adler32_golden() {
} while (num_bytes < src.meta.wi);
if (have != test_cases[tc].want) {
RETURN_FAIL("tc=%d, j=%d, filename=\"%s\": have 0x%08" PRIX32
RETURN_FAIL("tc=%zu, j=%d, filename=\"%s\": have 0x%08" PRIX32
", want 0x%08" PRIX32 "\n",
tc, j, test_cases[tc].filename, have, test_cases[tc].want);
}
@@ -208,8 +206,7 @@ test_wuffs_adler32_pi() {
0xBEAA13C1, 0xD29C13F2, 0xE6C51429, 0xFB1E1459,
};
int i;
for (i = 0; i < 100; i++) {
for (int i = 0; i < 100; i++) {
wuffs_adler32__hasher checksum;
CHECK_STATUS("initialize",
wuffs_adler32__hasher__initialize(
+4 -6
View File
@@ -117,8 +117,7 @@ test_wuffs_cbor_decode_invalid() {
"\xFE",
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__token tok_array[256];
wuffs_base__token_buffer tok_buf =
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
@@ -138,7 +137,7 @@ test_wuffs_cbor_decode_invalid() {
wuffs_base__status status = wuffs_cbor__decoder__decode_tokens(
&dec, &tok_buf, &io_buf, g_work_slice_u8);
if (!wuffs_base__status__is_error(&status)) {
RETURN_FAIL("tc=%d: have \"%s\", want an error", tc, status.repr);
RETURN_FAIL("tc=%zu: have \"%s\", want an error", tc, status.repr);
}
}
return NULL;
@@ -159,8 +158,7 @@ test_wuffs_cbor_decode_valid() {
"\xD0\xBF\xFF",
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__token tok_array[256];
wuffs_base__token_buffer tok_buf =
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
@@ -180,7 +178,7 @@ test_wuffs_cbor_decode_valid() {
wuffs_base__status status = wuffs_cbor__decoder__decode_tokens(
&dec, &tok_buf, &io_buf, g_work_slice_u8);
if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("tc=%d: have \"%s\", want no error", tc, status.repr);
RETURN_FAIL("tc=%zu: have \"%s\", want no error", tc, status.repr);
}
}
return NULL;
+4 -7
View File
@@ -131,15 +131,13 @@ test_wuffs_crc32_ieee_golden() {
},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, test_cases[tc].filename));
int j;
for (j = 0; j < 2; j++) {
for (int j = 0; j < 2; j++) {
wuffs_crc32__ieee_hasher checksum;
CHECK_STATUS("initialize",
wuffs_crc32__ieee_hasher__initialize(
@@ -164,7 +162,7 @@ test_wuffs_crc32_ieee_golden() {
} while (num_bytes < src.meta.wi);
if (have != test_cases[tc].want) {
RETURN_FAIL("tc=%d, j=%d, filename=\"%s\": have 0x%08" PRIX32
RETURN_FAIL("tc=%zu, j=%d, filename=\"%s\": have 0x%08" PRIX32
", want 0x%08" PRIX32,
tc, j, test_cases[tc].filename, have, test_cases[tc].want);
}
@@ -206,8 +204,7 @@ do_test_xxxxx_crc32_ieee_pi(bool mimic) {
0x4D9D54B7, 0xD69454CC, 0xF8BB504D, 0xFC4E595C,
};
int i;
for (i = 0; i < 100; i++) {
for (int i = 0; i < 100; i++) {
uint32_t have;
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
.ptr = (uint8_t*)(digits),
+30 -36
View File
@@ -74,55 +74,55 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
// go run script/extract-flate-offsets.go test/data/*.gz
golden_test g_deflate_256_bytes_gt = {
.want_filename = "test/data/artificial/256.bytes",
.src_filename = "test/data/artificial/256.bytes.gz",
.want_filename = "test/data/256.bytes",
.src_filename = "test/data/256.bytes.gz",
.src_offset0 = 20,
.src_offset1 = 281,
};
golden_test g_deflate_deflate_backref_crosses_blocks_gt = {
.want_filename =
"test/data/artificial/"
"deflate-backref-crosses-blocks.deflate.decompressed",
"test/data/artificial-deflate/"
"backref-crosses-blocks.deflate.decompressed",
.src_filename =
"test/data/artificial/"
"deflate-backref-crosses-blocks.deflate",
"test/data/artificial-deflate/"
"backref-crosses-blocks.deflate",
};
golden_test g_deflate_deflate_degenerate_huffman_unused_gt = {
.want_filename =
"test/data/artificial/"
"deflate-degenerate-huffman-unused.deflate.decompressed",
"test/data/artificial-deflate/"
"degenerate-huffman-unused.deflate.decompressed",
.src_filename =
"test/data/artificial/"
"deflate-degenerate-huffman-unused.deflate",
"test/data/artificial-deflate/"
"degenerate-huffman-unused.deflate",
};
golden_test g_deflate_deflate_distance_32768_gt = {
.want_filename =
"test/data/artificial/"
"deflate-distance-32768.deflate.decompressed",
"test/data/artificial-deflate/"
"distance-32768.deflate.decompressed",
.src_filename =
"test/data/artificial/"
"deflate-distance-32768.deflate",
"test/data/artificial-deflate/"
"distance-32768.deflate",
};
golden_test g_deflate_deflate_distance_code_31_gt = {
.want_filename =
"test/data/artificial/"
"qdeflate-distance-code-31.deflate.decompressed",
"test/data/artificial-deflate/"
"qdistance-code-31.deflate.decompressed",
.src_filename =
"test/data/artificial/"
"deflate-distance-code-31.deflate",
"test/data/artificial-deflate/"
"distance-code-31.deflate",
};
golden_test g_deflate_deflate_huffman_primlen_9_gt = {
.want_filename =
"test/data/artificial/"
"deflate-huffman-primlen-9.deflate.decompressed",
"test/data/artificial-deflate/"
"huffman-primlen-9.deflate.decompressed",
.src_filename =
"test/data/artificial/"
"deflate-huffman-primlen-9.deflate",
"test/data/artificial-deflate/"
"huffman-primlen-9.deflate",
};
golden_test g_deflate_midsummer_gt = {
@@ -269,8 +269,7 @@ test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
CHECK_STATUS("transform_io", wuffs_deflate__decoder__transform_io(
&dec, &have, &src, g_work_slice_u8));
int i;
for (i = 0; i < 2; i++) {
for (int i = 0; i < 2; i++) {
// Find the first unused (i.e. zero) entry in the i'th huffs table.
int have = WUFFS_DEFLATE__HUFFS_TABLE_SIZE;
while ((have > 0) && (dec.private_data.f_huffs[i][have - 1] == 0)) {
@@ -354,8 +353,7 @@ test_wuffs_deflate_decode_split_src() {
CHECK_STRING(read_file(&src, gt->src_filename));
CHECK_STRING(read_file(&want, gt->want_filename));
int i;
for (i = 1; i < 32; i++) {
for (int i = 1; i < 32; i++) {
size_t split = gt->src_offset0 + i;
if (split >= gt->src_offset1) {
RETURN_FAIL("i=%d: split was not an interior split", i);
@@ -468,8 +466,7 @@ test_wuffs_deflate_history_full() {
CHECK_STRING(read_file(&want, gt->want_filename));
const int full_history_size = 0x8000;
int i;
for (i = -2; i <= +2; i++) {
for (int i = -2; i <= +2; i++) {
wuffs_deflate__decoder dec;
CHECK_STATUS("initialize",
wuffs_deflate__decoder__initialize(
@@ -531,8 +528,7 @@ test_wuffs_deflate_history_partial() {
0x8000, 0x8001, 0x9234, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
};
int i;
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(starting_history_indexes); i++) {
for (int i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(starting_history_indexes); i++) {
uint32_t starting_history_index = starting_history_indexes[i];
// The flate_pi_gt golden test file decodes to the digits of pi.
@@ -564,8 +560,7 @@ test_wuffs_deflate_history_partial() {
have_history_index, (int)(want_full), want_history_index);
}
int j;
for (j = -2; j < (int)(fragment_length) + 2; j++) {
for (int j = -2; j < (int)(fragment_length) + 2; j++) {
uint32_t index = (starting_history_index + j) & 0x7FFF;
uint8_t have = dec.private_data.f_history[index];
uint8_t want = (0 <= j && j < fragment_length) ? fragment[j] : 0;
@@ -633,7 +628,6 @@ test_wuffs_deflate_table_redirect() {
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
memset(&(dec.private_data.f_huffs), 0, sizeof(dec.private_data.f_huffs));
int i;
int n = 0;
dec.private_data.f_code_lengths[n++] = 1;
dec.private_data.f_code_lengths[n++] = 2;
@@ -644,7 +638,7 @@ test_wuffs_deflate_table_redirect() {
dec.private_data.f_code_lengths[n++] = 7;
dec.private_data.f_code_lengths[n++] = 9;
dec.private_data.f_code_lengths[n++] = 10;
for (i = 0; i < 19; i++) {
for (int i = 0; i < 19; i++) {
dec.private_data.f_code_lengths[n++] = 12;
}
dec.private_data.f_code_lengths[n++] = 13;
@@ -658,7 +652,7 @@ test_wuffs_deflate_table_redirect() {
// should be zero outside of those tables.
const int n_f_huffs = sizeof(dec.private_data.f_huffs[0]) /
sizeof(dec.private_data.f_huffs[0][0]);
for (i = 0; i < n_f_huffs; i++) {
for (int i = 0; i < n_f_huffs; i++) {
bool have = dec.private_data.f_huffs[0][i] == 0;
bool want = i >= (1 << 9) + (1 << 3) + (1 << 3) + (1 << 4);
if (have != want) {
@@ -696,7 +690,7 @@ test_wuffs_deflate_table_redirect() {
0x80000801, 0x80000903, 0x80000801, 0x80000B03,
0x80000801, 0x80000A03, 0x80000801, 0x80000C03,
};
for (i = 0; i < 8; i++) {
for (int i = 0; i < 8; i++) {
have = dec.private_data.f_huffs[0][0x0200 + i];
want = wants[i];
if (have != want) {
+65 -81
View File
@@ -355,8 +355,7 @@ do_test_wuffs_gif_decode(const char* filename,
}
if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__BGR) {
size_t i;
for (i = 0; i < ind_want.meta.wi; i++) {
for (size_t i = 0; i < ind_want.meta.wi; i++) {
uint8_t index = ind_want.data.ptr[i];
expanded_want.data.ptr[3 * i + 0] = pal_want_array[4 * index + 0];
expanded_want.data.ptr[3 * i + 1] = pal_want_array[4 * index + 1];
@@ -364,8 +363,7 @@ do_test_wuffs_gif_decode(const char* filename,
}
expanded_want.meta.wi = 3 * ind_want.meta.wi;
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__BGR_565) {
size_t i;
for (i = 0; i < ind_want.meta.wi; i++) {
for (size_t i = 0; i < ind_want.meta.wi; i++) {
uint8_t index = ind_want.data.ptr[i];
uint32_t b5 = pal_want_array[4 * index + 0] >> 3;
uint32_t g6 = pal_want_array[4 * index + 1] >> 2;
@@ -376,8 +374,7 @@ do_test_wuffs_gif_decode(const char* filename,
}
expanded_want.meta.wi = 2 * ind_want.meta.wi;
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL) {
size_t i;
for (i = 0; i < ind_want.meta.wi; i++) {
for (size_t i = 0; i < ind_want.meta.wi; i++) {
uint8_t index = ind_want.data.ptr[i];
expanded_want.data.ptr[4 * i + 0] = pal_want_array[4 * index + 0];
expanded_want.data.ptr[4 * i + 1] = pal_want_array[4 * index + 1];
@@ -386,8 +383,7 @@ do_test_wuffs_gif_decode(const char* filename,
}
expanded_want.meta.wi = 4 * ind_want.meta.wi;
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__RGB) {
size_t i;
for (i = 0; i < ind_want.meta.wi; i++) {
for (size_t i = 0; i < ind_want.meta.wi; i++) {
uint8_t index = ind_want.data.ptr[i];
expanded_want.data.ptr[3 * i + 0] = pal_want_array[4 * index + 2];
expanded_want.data.ptr[3 * i + 1] = pal_want_array[4 * index + 1];
@@ -395,8 +391,7 @@ do_test_wuffs_gif_decode(const char* filename,
}
expanded_want.meta.wi = 3 * ind_want.meta.wi;
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL) {
size_t i;
for (i = 0; i < ind_want.meta.wi; i++) {
for (size_t i = 0; i < ind_want.meta.wi; i++) {
uint8_t index = ind_want.data.ptr[i];
expanded_want.data.ptr[4 * i + 0] = pal_want_array[4 * index + 2];
expanded_want.data.ptr[4 * i + 1] = pal_want_array[4 * index + 1];
@@ -580,8 +575,7 @@ do_test_wuffs_gif_decode_animated(
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg, g_pixel_slice_u8));
uint32_t i;
for (i = 0; i < want_num_frames; i++) {
for (uint32_t i = 0; i < want_num_frames; i++) {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__status status =
wuffs_gif__decoder__decode_frame_config(&dec, &fc, &src);
@@ -618,7 +612,7 @@ do_test_wuffs_gif_decode_animated(
// There should be no more frames, no matter how many times we call
// decode_frame.
for (i = 0; i < 3; i++) {
for (uint32_t i = 0; i < 3; i++) {
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
if (status.repr != wuffs_base__note__end_of_data) {
@@ -685,8 +679,7 @@ test_wuffs_gif_decode_delay_num_frames_decoded() {
}
src.meta.wi--;
int q;
for (q = 0; q < 2; q++) {
for (int q = 0; q < 2; q++) {
src.meta.ri = 0;
wuffs_gif__decoder dec;
@@ -721,9 +714,8 @@ test_wuffs_gif_decode_empty_palette() {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, "test/data/artificial/gif-empty-palette.gif"));
int q;
for (q = 0; q < 2; q++) {
CHECK_STRING(read_file(&src, "test/data/artificial-gif/empty-palette.gif"));
for (int q = 0; q < 2; q++) {
src.meta.ri = 0;
wuffs_gif__decoder dec;
@@ -748,8 +740,7 @@ test_wuffs_gif_decode_empty_palette() {
RETURN_FAIL("q=%d: set_from_slice: \"%s\"", q, status.repr);
}
int i;
for (i = 0; i < 2; i++) {
for (int i = 0; i < 2; i++) {
status = wuffs_gif__decoder__decode_frame(
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
if ((q == 1) && (i == 1)) {
@@ -789,9 +780,8 @@ test_wuffs_gif_decode_background_color() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-background-color.gif"));
int q;
for (q = 0; q < 2; q++) {
read_file(&src, "test/data/artificial-gif/background-color.gif"));
for (int q = 0; q < 2; q++) {
src.meta.ri = 0;
wuffs_gif__decoder dec;
@@ -828,9 +818,8 @@ test_wuffs_gif_decode_first_frame_is_opaque() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-frame-out-of-bounds.gif"));
int q;
for (q = 0; q < 2; q++) {
read_file(&src, "test/data/artificial-gif/frame-out-of-bounds.gif"));
for (int q = 0; q < 2; q++) {
src.meta.ri = 0;
wuffs_gif__decoder dec;
@@ -866,9 +855,8 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-frame-out-of-bounds.gif"));
int q;
for (q = 0; q < 2; q++) {
read_file(&src, "test/data/artificial-gif/frame-out-of-bounds.gif"));
for (int q = 0; q < 2; q++) {
src.meta.ri = 0;
wuffs_gif__decoder dec;
@@ -888,7 +876,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
// The nominal width and height for the overall image is 2×2, but its first
// frame extends those bounds to 4×2. See
// test/data/artificial/gif-frame-out-of-bounds.gif.make-artificial.txt for
// test/data/artificial-gif/frame-out-of-bounds.gif.make-artificial.txt for
// more discussion.
const uint32_t width = q ? 2 : 4;
@@ -914,7 +902,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
RETURN_FAIL("q=%d: set_from_slice: \"%s\"", q, status.repr);
}
// See test/data/artificial/gif-frame-out-of-bounds.gif.make-artificial.txt
// See test/data/artificial-gif/frame-out-of-bounds.gif.make-artificial.txt
// for the want_frame_config_bounds and want_pixel_indexes source.
wuffs_base__rect_ie_u32 want_frame_config_bounds[4] = {
@@ -931,8 +919,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
q ? "...." : "..45..89",
};
uint32_t i;
for (i = 0; true; i++) {
for (uint32_t i = 0; true; i++) {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
{
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, &src);
@@ -964,14 +951,13 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
{
wuffs_base__table_u8 p = wuffs_base__pixel_buffer__plane(&pb, 0);
uint32_t y, x;
for (y = 0; y < 5; y++) {
for (x = 0; x < 5; x++) {
for (uint32_t y = 0; y < 5; y++) {
for (uint32_t x = 0; x < 5; x++) {
p.ptr[(y * p.stride) + x] = 0xEE;
}
}
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
p.ptr[(y * p.stride) + x] = 0;
}
}
@@ -984,8 +970,8 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
status.repr);
}
for (y = 0; y < 5; y++) {
for (x = 0; x < 5; x++) {
for (uint32_t y = 0; y < 5; y++) {
for (uint32_t x = 0; x < 5; x++) {
if ((x < width) && (y < height)) {
continue;
}
@@ -1009,8 +995,8 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
}
char have[(width * height) + 1];
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
uint8_t index = 0x0F & p.ptr[(y * p.stride) + x];
have[(y * width) + x] = index ? ('0' + index) : '.';
}
@@ -1036,9 +1022,8 @@ test_wuffs_gif_decode_zero_width_frame() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-zero-width-frame.gif"));
int q;
for (q = 0; q < 3; q++) {
read_file(&src, "test/data/artificial-gif/zero-width-frame.gif"));
for (int q = 0; q < 3; q++) {
src.meta.ri = 0;
wuffs_gif__decoder dec;
@@ -1274,8 +1259,8 @@ do_test_wuffs_gif_decode_metadata(bool full) {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, full ? "test/data/artificial/gif-metadata-full.gif"
: "test/data/artificial/gif-metadata-empty.gif"));
read_file(&src, full ? "test/data/artificial-gif/metadata-full.gif"
: "test/data/artificial-gif/metadata-empty.gif"));
int iccp;
for (iccp = 0; iccp < 2; iccp++) {
@@ -1327,12 +1312,14 @@ do_test_wuffs_gif_decode_metadata(bool full) {
if (wuffs_base__status__is_error(&status)) {
RETURN_FAIL("tell_me_more (iccp=%d, xmp=%d): \"%s\"", iccp, xmp,
status.repr);
} else if (minfo.flavor !=
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA) {
RETURN_FAIL("tell_me_more (iccp=%d, xmp=%d): flavor: have %" PRIu32
", want %" PRIu32,
iccp, xmp, minfo.flavor,
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA);
} else if (
minfo.flavor !=
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH) {
RETURN_FAIL(
"tell_me_more (iccp=%d, xmp=%d): flavor: have %" PRIu32
", want %" PRIu32,
iccp, xmp, minfo.flavor,
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH);
}
have_fourcc = wuffs_base__more_information__metadata__fourcc(&minfo);
@@ -1480,7 +1467,7 @@ test_wuffs_gif_decode_multiple_graphic_controls() {
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(
&src, "test/data/artificial/gif-multiple-graphic-controls.gif"));
&src, "test/data/artificial-gif/multiple-graphic-controls.gif"));
wuffs_gif__decoder dec;
CHECK_STATUS("initialize",
@@ -1507,7 +1494,7 @@ test_wuffs_gif_decode_multiple_loop_counts() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-multiple-loop-counts.gif"));
read_file(&src, "test/data/artificial-gif/multiple-loop-counts.gif"));
wuffs_gif__decoder dec;
CHECK_STATUS("initialize",
@@ -1518,29 +1505,27 @@ test_wuffs_gif_decode_multiple_loop_counts() {
CHECK_STATUS("decode_image_config",
wuffs_gif__decoder__decode_image_config(&dec, &ic, &src));
// See test/data/artificial/gif-multiple-loop-counts.gif.make-artificial.txt
// See test/data/artificial-gif/multiple-loop-counts.gif.make-artificial.txt
// for the want_num_animation_loops source. Note that the GIF wire format's
// loop counts are the number of animation loops *after* the first play
// through, and Wuffs' are the number *including* the first play through.
uint32_t want_num_animation_loops[4] = {1, 1, 51, 31};
uint32_t i;
for (i = 0; true; i++) {
{
wuffs_base__status status =
wuffs_gif__decoder__decode_frame_config(&dec, NULL, &src);
if (i == WUFFS_TESTLIB_ARRAY_SIZE(want_num_animation_loops)) {
if (status.repr != wuffs_base__note__end_of_data) {
RETURN_FAIL("decode_frame_config #%" PRIu32
": have \"%s\", want \"%s\"",
i, status.repr, wuffs_base__note__end_of_data);
}
break;
}
if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": \"%s\"", i, status.repr);
uint32_t i = 0;
while (true) {
wuffs_base__status status =
wuffs_gif__decoder__decode_frame_config(&dec, NULL, &src);
if (i == WUFFS_TESTLIB_ARRAY_SIZE(want_num_animation_loops)) {
if (status.repr != wuffs_base__note__end_of_data) {
RETURN_FAIL("decode_frame_config #%" PRIu32
": have \"%s\", want \"%s\"",
i, status.repr, wuffs_base__note__end_of_data);
}
break;
}
if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": \"%s\"", i, status.repr);
}
uint32_t have = wuffs_gif__decoder__num_animation_loops(&dec);
@@ -1550,6 +1535,7 @@ test_wuffs_gif_decode_multiple_loop_counts() {
", want %" PRIu32,
i, have, want);
}
i++;
}
uint32_t have = wuffs_gif__decoder__num_animation_loops(&dec);
@@ -1587,7 +1573,7 @@ test_wuffs_gif_decode_pixel_data_none() {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, "test/data/artificial/gif-pixel-data-none.gif"));
CHECK_STRING(read_file(&src, "test/data/artificial-gif/pixel-data-none.gif"));
return do_test_wuffs_gif_decode_expecting(
src, 0, wuffs_base__error__not_enough_data, true);
@@ -1600,7 +1586,7 @@ test_wuffs_gif_decode_pixel_data_not_enough() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-pixel-data-not-enough.gif"));
read_file(&src, "test/data/artificial-gif/pixel-data-not-enough.gif"));
return do_test_wuffs_gif_decode_expecting(
src, 0, wuffs_base__error__not_enough_data, false);
@@ -1613,7 +1599,7 @@ test_wuffs_gif_decode_pixel_data_too_much_sans_quirk() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-pixel-data-too-much.gif"));
read_file(&src, "test/data/artificial-gif/pixel-data-too-much.gif"));
return do_test_wuffs_gif_decode_expecting(
src, 0, wuffs_base__error__too_much_data, false);
@@ -1626,7 +1612,7 @@ test_wuffs_gif_decode_pixel_data_too_much_with_quirk() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-pixel-data-too-much.gif"));
read_file(&src, "test/data/artificial-gif/pixel-data-too-much.gif"));
return do_test_wuffs_gif_decode_expecting(
src, WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, NULL, false);
@@ -1815,8 +1801,7 @@ do_test_wuffs_gif_io_position(bool chunked) {
wuffs_base__frame_config fcs[4];
uint32_t width_wants[4] = {64, 37, 49, 49};
uint64_t pos_wants[4] = {781, 2126, 2187, 2542};
int i;
for (i = 0; i < 4; i++) {
for (int i = 0; i < 4; i++) {
fcs[i] = ((wuffs_base__frame_config){});
wuffs_base__status status =
wuffs_gif__decoder__decode_frame_config(&dec, &fcs[i], &src);
@@ -1878,7 +1863,7 @@ do_test_wuffs_gif_io_position(bool chunked) {
return NULL;
}
for (i = 0; i < 4; i++) {
for (int i = 0; i < 4; i++) {
src.meta.ri = pos_wants[i];
status = wuffs_gif__decoder__restart_frame(
@@ -1887,8 +1872,7 @@ do_test_wuffs_gif_io_position(bool chunked) {
RETURN_FAIL("restart_frame #%d: \"%s\"", i, status.repr);
}
int j;
for (j = i; j < 4; j++) {
for (int j = i; j < 4; j++) {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, &src);
if (!wuffs_base__status__is_ok(&status)) {
@@ -1939,7 +1923,7 @@ test_wuffs_gif_small_frame_interlaced() {
.data = g_src_slice_u8,
});
CHECK_STRING(
read_file(&src, "test/data/artificial/gif-small-frame-interlaced.gif"));
read_file(&src, "test/data/artificial-gif/small-frame-interlaced.gif"));
wuffs_gif__decoder dec;
CHECK_STATUS("initialize",
+61 -2
View File
@@ -160,8 +160,7 @@ do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
// or isn't zero.
int i;
for (i = 0; i < 2; i++) {
for (int i = 0; i < 2; i++) {
uint64_t rlimit = UINT64_MAX;
const char* want_z = NULL;
if (i == 0) {
@@ -216,6 +215,65 @@ test_wuffs_gzip_checksum_verify_good() {
return do_test_wuffs_gzip_checksum(false, 0);
}
const char* //
test_wuffs_gzip_decode_infrequent_compaction() {
CHECK_FOCUS(__func__);
wuffs_gzip__decoder dec;
CHECK_STATUS("initialize",
wuffs_gzip__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){
.data = g_have_slice_u8,
});
// src_bytes holds the first 50 Fibonacci numbers, gzipped using Python's
// gzip module.
uint8_t src_bytes[183] = {
0x1F, 0x8B, 0x08, 0x00, 0x07, 0x22, 0x16, 0x61, 0x02, 0xFF, 0x15, 0x8F,
0xC1, 0x11, 0x00, 0x31, 0x08, 0x02, 0xFF, 0x54, 0x23, 0x6A, 0x44, 0xFB,
0x6F, 0xEC, 0xB8, 0xC9, 0xCB, 0x59, 0x09, 0x6B, 0x80, 0x7E, 0x89, 0xC2,
0xC3, 0x82, 0x85, 0x24, 0xAA, 0xF1, 0x3C, 0x1D, 0xD8, 0x8D, 0xAC, 0x42,
0x49, 0x18, 0x06, 0x6E, 0x05, 0xBE, 0x13, 0xF2, 0x6D, 0xA3, 0xB9, 0xC4,
0x68, 0x1E, 0x18, 0xD7, 0x03, 0x4A, 0xF4, 0x57, 0x3B, 0x4F, 0xE8, 0xA9,
0x59, 0xE8, 0x45, 0x9A, 0x26, 0xEB, 0x0A, 0xBC, 0x71, 0x02, 0x45, 0xAD,
0xD7, 0x1E, 0x3B, 0xF3, 0xB0, 0x95, 0xD1, 0xE1, 0xDE, 0x9E, 0x9C, 0x73,
0xB9, 0xB6, 0xE2, 0x50, 0x2F, 0xFB, 0x69, 0xF1, 0x14, 0xB9, 0x2E, 0xBD,
0x4C, 0xF5, 0x5F, 0xD4, 0x57, 0x61, 0x88, 0x6C, 0x9A, 0x53, 0xA8, 0x8B,
0x5D, 0x3A, 0x3A, 0xE5, 0xC8, 0xAD, 0x35, 0xC2, 0xCA, 0xC6, 0xDE, 0x9E,
0xF7, 0x36, 0xD8, 0x96, 0x1A, 0x9D, 0x0B, 0x6F, 0xD0, 0x66, 0xD7, 0x5D,
0x82, 0x4C, 0x62, 0xE5, 0xF3, 0xE8, 0xFA, 0x0B, 0x8B, 0x59, 0x64, 0x6B,
0x8A, 0xF4, 0x84, 0x3C, 0xD9, 0xFC, 0x85, 0x0A, 0xBD, 0xA1, 0x67, 0x3F,
0x0D, 0x24, 0xAD, 0xDA, 0xD2, 0x87, 0x0F, 0x12, 0x69, 0x4A, 0xA8, 0x3B,
0x01, 0x00, 0x00,
};
wuffs_base__io_buffer src =
wuffs_base__ptr_u8__reader(src_bytes, sizeof src_bytes, true);
// Decode 5 source bytes at a time. Compact every 15 source bytes.
for (size_t i = 0; i < src.data.len; i += 5) {
src.meta.wi = i;
wuffs_base__status status =
wuffs_gzip__decoder__transform_io(&dec, &dst, &src, g_work_slice_u8);
if (status.repr != wuffs_base__suspension__short_read) {
RETURN_FAIL("i=%zu: have \"%s\", want \"%s\"", i, status.repr,
wuffs_base__suspension__short_read);
}
if (i % 15 == 0) {
dst.meta.ri = dst.meta.wi;
wuffs_base__io_buffer__compact(&dst);
}
}
src.meta.wi = src.data.len;
src.meta.closed = true;
CHECK_STATUS("final transform_io", wuffs_gzip__decoder__transform_io(
&dec, &dst, &src, g_work_slice_u8));
return NULL;
}
const char* //
test_wuffs_gzip_decode_midsummer() {
CHECK_FOCUS(__func__);
@@ -299,6 +357,7 @@ proc g_tests[] = {
test_wuffs_gzip_checksum_verify_bad0,
test_wuffs_gzip_checksum_verify_bad7,
test_wuffs_gzip_checksum_verify_good,
test_wuffs_gzip_decode_infrequent_compaction,
test_wuffs_gzip_decode_interface,
test_wuffs_gzip_decode_midsummer,
test_wuffs_gzip_decode_pi,
+130 -158
View File
@@ -86,8 +86,7 @@ test_wuffs_core_count_leading_zeroes_u64() {
{.num = 0xFFFFFFFFFFFFFFFF, .want = 0},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
uint32_t have = wuffs_base__count_leading_zeroes_u64(test_cases[tc].num);
if (have != test_cases[tc].want) {
RETURN_FAIL("0x%" PRIX64 ": have %" PRIu32 ", want %" PRIu32,
@@ -122,8 +121,7 @@ test_wuffs_core_multiply_u64() {
.want_lo = 0x89B3DE09506618CF},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__multiply_u64__output have =
wuffs_base__multiply_u64(test_cases[tc].x, test_cases[tc].y);
if ((have.hi != test_cases[tc].want_hi) ||
@@ -343,8 +341,7 @@ test_wuffs_strconv_hpd_rounded_integer() {
{.want = UINT64_MAX, .str = "1234567890123456789"},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__private_implementation__high_prec_dec hpd;
CHECK_STATUS("hpd__parse",
wuffs_base__private_implementation__high_prec_dec__parse(
@@ -389,8 +386,7 @@ test_wuffs_strconv_hpd_shift() {
.want = "+314159000000000000000000000."},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__private_implementation__high_prec_dec hpd;
CHECK_STATUS("hpd__parse",
wuffs_base__private_implementation__high_prec_dec__parse(
@@ -499,8 +495,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
double have_f64 = wuffs_base__ieee_754_bit_representation__from_u16_to_f64(
test_cases[tc].u16_bits);
double want_f64 = test_cases[tc].want_f64;
@@ -508,7 +503,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
bool equal = ((have_f64 == want_f64) ||
((have_f64 != have_f64) && (want_f64 != want_f64)));
if (!equal) {
RETURN_FAIL("tc=%d: to_f64: have %g, want %g", tc, have_f64, want_f64);
RETURN_FAIL("tc=%zu: to_f64: have %g, want %g", tc, have_f64, want_f64);
}
uint64_t have_u64 =
@@ -516,7 +511,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
uint64_t want_u64 = test_cases[tc].want_u64;
// There's more than one representation of NaN.
if ((have_u64 != want_u64) && (want_u64 != nan_u64)) {
RETURN_FAIL("tc=%d: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
RETURN_FAIL("tc=%zu: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
tc, have_u64, want_u64);
}
@@ -530,13 +525,13 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
want_u64 ^ ((uint64_t)noise)));
if (lv.value != test_cases[tc].u16_bits) {
RETURN_FAIL("tc=%d: noise=%d: to_u16 value: have 0x%04" PRIX16
RETURN_FAIL("tc=%zu: noise=%d: to_u16 value: have 0x%04" PRIX16
", want 0x%04" PRIX16,
tc, noise, lv.value, test_cases[tc].u16_bits);
}
int want_lossy = (want_f64 == want_f64) ? noise : 0;
if (((int)lv.lossy) != want_lossy) {
RETURN_FAIL("tc=%d: noise=%d: to_u16 lossy: have %d, want %d", tc,
RETURN_FAIL("tc=%zu: noise=%d: to_u16 lossy: have %d, want %d", tc,
noise, ((int)(lv.lossy)), want_lossy);
}
}
@@ -621,8 +616,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
double have_f64 = wuffs_base__ieee_754_bit_representation__from_u32_to_f64(
test_cases[tc].u32_bits);
double want_f64 = test_cases[tc].want_f64;
@@ -630,7 +624,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
bool equal = ((have_f64 == want_f64) ||
((have_f64 != have_f64) && (want_f64 != want_f64)));
if (!equal) {
RETURN_FAIL("tc=%d: to_f64: have %g, want %g", tc, have_f64, want_f64);
RETURN_FAIL("tc=%zu: to_f64: have %g, want %g", tc, have_f64, want_f64);
}
uint64_t have_u64 =
@@ -638,7 +632,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
uint64_t want_u64 = test_cases[tc].want_u64;
// There's more than one representation of NaN.
if ((have_u64 != want_u64) && (want_u64 != nan_u64)) {
RETURN_FAIL("tc=%d: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
RETURN_FAIL("tc=%zu: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
tc, have_u64, want_u64);
}
@@ -652,13 +646,13 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
want_u64 ^ ((uint64_t)noise)));
if (lv.value != test_cases[tc].u32_bits) {
RETURN_FAIL("tc=%d: noise=%d: to_u32 value: have 0x%08" PRIX32
RETURN_FAIL("tc=%zu: noise=%d: to_u32 value: have 0x%08" PRIX32
", want 0x%08" PRIX32,
tc, noise, lv.value, test_cases[tc].u32_bits);
}
int want_lossy = (want_f64 == want_f64) ? noise : 0;
if (((int)lv.lossy) != want_lossy) {
RETURN_FAIL("tc=%d: noise=%d: to_u32 lossy: have %d, want %d", tc,
RETURN_FAIL("tc=%zu: noise=%d: to_u32 lossy: have %d, want %d", tc,
noise, ((int)(lv.lossy)), want_lossy);
}
}
@@ -749,8 +743,7 @@ test_wuffs_strconv_base_64() {
"Zm9vYmFy", //
};
size_t tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(wants); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(wants); tc++) {
const bool src_closed = true;
wuffs_base__transform__output e = wuffs_base__base_64__encode(
@@ -828,8 +821,7 @@ test_wuffs_strconv_parse_number_f64_options() {
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES.
{
int o;
for (o = 0; o < 2; o++) {
for (int o = 0; o < 2; o++) {
const char* str = "001.25";
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
wuffs_base__make_slice_u8((void*)str, strlen(str)),
@@ -859,8 +851,7 @@ test_wuffs_strconv_parse_number_f64_options() {
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES.
{
int o;
for (o = 0; o < 2; o++) {
for (int o = 0; o < 2; o++) {
const char* str = "_1.2__5";
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
wuffs_base__make_slice_u8((void*)str, strlen(str)),
@@ -889,8 +880,7 @@ test_wuffs_strconv_parse_number_f64_options() {
// Test WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA.
{
int o;
for (o = 0; o < 2; o++) {
for (int o = 0; o < 2; o++) {
const char* str = "1,75";
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
wuffs_base__make_slice_u8((void*)str, strlen(str)),
@@ -920,8 +910,7 @@ test_wuffs_strconv_parse_number_f64_options() {
// Test WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN.
{
int o;
for (o = 0; o < 4; o++) {
for (int o = 0; o < 4; o++) {
const char* str = (o & 2) ? "1e999" : "nan";
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
wuffs_base__make_slice_u8((void*)str, strlen(str)),
@@ -1008,6 +997,9 @@ test_wuffs_strconv_parse_number_f64_regular() {
{.want = 0x4038000000000000, .str = "2.4E1"},
{.want = 0x4038000000000000, .str = "24"},
{.want = 0x4038000000000000, .str = "2400_00000_00000.00000_e-_1_2"},
{.want = 0x405E9AA48FBB2888, .str = "122.416294033786585"},
{.want = 0x405E9AA48FBB2888, .str = "122.41629403378658"},
{.want = 0x405E9AA48FBB2889, .str = "122.4162940337866"},
{.want = 0x40FE240C9FCB0C02, .str = "123456.789012"},
{.want = 0x41E0246690000001,
.str = "2.16656806400000023841857910156251e9"},
@@ -1082,8 +1074,7 @@ test_wuffs_strconv_parse_number_f64_regular() {
{.want = fail, .str = "nun"},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
wuffs_base__make_slice_u8((void*)test_cases[tc].str,
strlen(test_cases[tc].str)),
@@ -1135,8 +1126,7 @@ test_wuffs_strconv_parse_number_i64() {
{.want = fail, .str = "9223372036854775808"}, // 1 << 63.
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__result_i64 r = wuffs_base__parse_number_i64(
wuffs_base__make_slice_u8((void*)test_cases[tc].str,
strlen(test_cases[tc].str)),
@@ -1222,8 +1212,7 @@ test_wuffs_strconv_parse_number_u64() {
{.want = fail, .str = "x"},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
wuffs_base__make_slice_u8((void*)test_cases[tc].str,
strlen(test_cases[tc].str)),
@@ -1237,8 +1226,7 @@ test_wuffs_strconv_parse_number_u64() {
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES.
{
int o;
for (o = 0; o < 2; o++) {
for (int o = 0; o < 2; o++) {
const char* str = "007";
wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
wuffs_base__make_slice_u8((void*)str, strlen(str)),
@@ -1266,8 +1254,7 @@ test_wuffs_strconv_parse_number_u64() {
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES.
{
int o;
for (o = 0; o < 2; o++) {
for (int o = 0; o < 2; o++) {
const char* str = "56_7__8";
wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
wuffs_base__make_slice_u8((void*)str, strlen(str)),
@@ -1709,6 +1696,15 @@ test_wuffs_strconv_render_number_f64() {
.want_3f = "24.000",
.want_4g = "24",
},
{
.x = 0x405E9AA48FBB2888,
.want__e = "1.2241629403378658e+02",
.want__f = "122.41629403378658",
.want_0g = "1e+02",
.want_2e = "1.22e+02",
.want_3f = "122.416",
.want_4g = "122.4",
},
{
.x = 0x40FE240C9FCB0C02,
.want__e = "1.23456789012e+05",
@@ -2123,12 +2119,10 @@ test_wuffs_strconv_render_number_f64() {
},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
double f64 = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
test_cases[tc].x);
int o;
for (o = 0; o < 6; o++) {
for (int o = 0; o < 6; o++) {
uint32_t precision = 0;
uint32_t options = 0;
const char* want = NULL;
@@ -2177,8 +2171,7 @@ test_wuffs_strconv_render_number_f64() {
// Test WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA.
{
int o;
for (o = 0; o < 2; o++) {
for (int o = 0; o < 2; o++) {
uint8_t dst[8] = {0};
const double f64 = 1.75;
const uint32_t precision = 2;
@@ -2251,8 +2244,7 @@ test_wuffs_strconv_render_number_i64() {
return "g_have_slice_u8.len is too short";
}
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
size_t n = wuffs_base__render_number_i64(
g_have_slice_u8, test_cases[tc].x,
WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
@@ -2306,8 +2298,7 @@ test_wuffs_strconv_render_number_u64() {
return "g_have_slice_u8.len is too short";
}
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
size_t n = wuffs_base__render_number_u64(
g_have_slice_u8, test_cases[tc].x,
WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
@@ -2454,8 +2445,7 @@ test_wuffs_strconv_utf_8_next() {
{.want0 = 0x0100FFFD, .want1 = 0x0100FFFD, .str = "\xED\xBF\xBF"},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__slice_u8 s = wuffs_base__make_slice_u8(
(void*)test_cases[tc].str, strlen(test_cases[tc].str));
// Override "The <NUL> byte" with "\x00".
@@ -2578,8 +2568,7 @@ test_wuffs_json_decode_interface() {
wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
uint32_t i;
for (i = 0; quirks[i]; i++) {
for (size_t i = 0; quirks[i]; i++) {
wuffs_json__decoder__set_quirk_enabled(&dec, quirks[i], true);
}
CHECK_STRING(do_test__wuffs_base__token_decoder(
@@ -2626,8 +2615,7 @@ const char* //
test_wuffs_json_decode_end_of_data() {
CHECK_FOCUS(__func__);
int i;
for (i = 0; i < 2; i++) {
for (int i = 0; i < 2; i++) {
uint8_t* src_ptr = (uint8_t*)("123null89");
size_t src_len = i ? 3 : 9;
@@ -2719,11 +2707,10 @@ test_wuffs_json_decode_long_numbers() {
wuffs_json__decoder dec;
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
size_t suffix_length = strlen(test_cases[tc].suffix);
if ((suffix_length + 1) > (119 - 102)) { // +1 for the terminal NUL.
RETURN_FAIL("tc=%d: src_array is too short", tc);
RETURN_FAIL("tc=%zu: src_array is too short", tc);
}
bool ends_with_space = (suffix_length > 0) &&
(test_cases[tc].suffix[suffix_length - 1] == ' ');
@@ -2764,7 +2751,7 @@ test_wuffs_json_decode_long_numbers() {
}
if (total_length != src.meta.ri) {
RETURN_FAIL(
"tc=%d, nines_length=%zu, closed=%d: total_length: have %zu, "
"tc=%zu, nines_length=%zu, closed=%d: total_length: have %zu, "
"want %zu",
tc, nines_length, closed, total_length, src.meta.ri);
}
@@ -2780,7 +2767,7 @@ test_wuffs_json_decode_long_numbers() {
if (have != want) {
RETURN_FAIL(
"tc=%d, nines_length=%zu, closed=%d: have \"%s\", want \"%s\"",
"tc=%zu, nines_length=%zu, closed=%d: have \"%s\", want \"%s\"",
tc, nines_length, closed, have, want);
}
}
@@ -2849,8 +2836,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
wuffs_json__decoder dec;
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
size_t n = strlen(test_cases[tc]);
size_t num_preceding = 0;
while (num_preceding < n) {
@@ -2862,7 +2848,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
}
num_preceding += x.byte_length;
if (num_preceding > n) {
RETURN_FAIL("tc=%d: utf_8__next overflow", tc);
RETURN_FAIL("tc=%zu: utf_8__next overflow", tc);
}
}
@@ -2910,7 +2896,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
have += wuffs_base__token__length(t);
} else {
RETURN_FAIL(
"tc=%d, prefix=%zu, suffix=%zu, closed=%d: unexpected token",
"tc=%zu, prefix=%zu, suffix=%zu, closed=%d: unexpected token",
tc, prefix, suffix, closed);
}
}
@@ -2920,7 +2906,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
}
if (have != want) {
RETURN_FAIL(
"tc=%d, prefix=%zu, suffix=%zu, closed=%d: have %zu, want %zu",
"tc=%zu, prefix=%zu, suffix=%zu, closed=%d: have %zu, want %zu",
tc, prefix, suffix, closed, have, want);
}
}
@@ -2987,10 +2973,8 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() {
},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
int q;
for (q = 0; q < 2; q++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (int q = 0; q < 2; q++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3013,7 +2997,7 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() {
want_status_repr = wuffs_json__error__bad_c0_control_code;
}
if (have_status_repr != want_status_repr) {
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
q, have_status_repr, want_status_repr);
}
if (want_status_repr != NULL) {
@@ -3031,7 +3015,7 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() {
}
}
if (have != test_cases[tc].want) {
RETURN_FAIL("tc=%d, q=%d: Unicode code point: have U+%04" PRIX32
RETURN_FAIL("tc=%zu, q=%d: Unicode code point: have U+%04" PRIX32
", want U+%04" PRIX32,
tc, q, have, test_cases[tc].want);
}
@@ -3072,8 +3056,7 @@ test_wuffs_json_decode_quirk_allow_backslash_x() {
.str = "\"a\\x\""},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3090,7 +3073,7 @@ test_wuffs_json_decode_quirk_allow_backslash_x() {
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
.repr;
if (have_status_repr != test_cases[tc].want_status_repr) {
RETURN_FAIL("tc=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
RETURN_FAIL("tc=%zu: decode_tokens: have \"%s\", want \"%s\"", tc,
have_status_repr, test_cases[tc].want_status_repr);
}
@@ -3118,7 +3101,7 @@ test_wuffs_json_decode_quirk_allow_backslash_x() {
}
uint64_t want = test_cases[tc].want_code_points;
if (have != want) {
RETURN_FAIL("tc=%d: have U+%08" PRIX64 ", want U+%08" PRIX64, tc, have,
RETURN_FAIL("tc=%zu: have U+%08" PRIX64 ", want U+%08" PRIX64, tc, have,
want);
}
}
@@ -3144,10 +3127,8 @@ test_wuffs_json_decode_quirk_allow_extra_comma() {
{.want = "--", .str = "{,}"},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
int q;
for (q = 0; q < 2; q++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (int q = 0; q < 2; q++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3165,7 +3146,7 @@ test_wuffs_json_decode_quirk_allow_extra_comma() {
const char* want =
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
if (have != want) {
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
q, have, want);
}
@@ -3174,17 +3155,17 @@ test_wuffs_json_decode_quirk_allow_extra_comma() {
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
}
if (total_length != src.meta.ri) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.meta.ri);
}
if (test_cases[tc].want[q] == 'X') {
if (total_length != src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.data.len);
}
} else if (test_cases[tc].want[q] == '+') {
if (total_length >= src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
total_length, src.data.len);
}
}
@@ -3219,10 +3200,8 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() {
{.want = "--", .str = "∞"},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
int q;
for (q = 0; q < 2; q++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (int q = 0; q < 2; q++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3240,7 +3219,7 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() {
const char* want =
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
if (have != want) {
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
q, have, want);
}
@@ -3249,17 +3228,17 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() {
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
}
if (total_length != src.meta.ri) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.meta.ri);
}
if (test_cases[tc].want[q] == 'X') {
if (total_length != src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.data.len);
}
} else if (test_cases[tc].want[q] == '+') {
if (total_length >= src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
total_length, src.data.len);
}
}
@@ -3288,10 +3267,8 @@ test_wuffs_json_decode_quirk_allow_comment_etc() {
{.want = "----", .str = "[4/5]"}, // Lone slash.
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
int q;
for (q = 0; q < 4; q++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (int q = 0; q < 4; q++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3311,7 +3288,7 @@ test_wuffs_json_decode_quirk_allow_comment_etc() {
const char* want =
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
if (have != want) {
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
q, have, want);
}
@@ -3320,17 +3297,17 @@ test_wuffs_json_decode_quirk_allow_comment_etc() {
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
}
if (total_length != src.meta.ri) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.meta.ri);
}
if (test_cases[tc].want[q] == 'X') {
if (total_length != src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.data.len);
}
} else if (test_cases[tc].want[q] == '+') {
if (total_length >= src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
total_length, src.data.len);
}
}
@@ -3365,10 +3342,8 @@ test_wuffs_json_decode_quirk_allow_leading_etc() {
{.want = "----", .str = "\xEFtrue"},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
int q;
for (q = 0; q < 4; q++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (int q = 0; q < 4; q++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3388,7 +3363,7 @@ test_wuffs_json_decode_quirk_allow_leading_etc() {
const char* want =
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
if (have != want) {
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
q, have, want);
}
@@ -3397,17 +3372,17 @@ test_wuffs_json_decode_quirk_allow_leading_etc() {
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
}
if (total_length != src.meta.ri) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.meta.ri);
}
if (test_cases[tc].want[q] == 'X') {
if (total_length != src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.data.len);
}
} else if (test_cases[tc].want[q] == '+') {
if (total_length >= src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
total_length, src.data.len);
}
}
@@ -3427,6 +3402,14 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
// - '4' means that there is non-filler after eof-or-'\n'
// - '5' means that there is non-filler before eof-or-'\n'
//
// The second and third bytes are digits such that the overall string starts
// with a three digit number, which is parsed as the top-level JSON value and
// everything afterwards is trailer.
//
// That three digit number modulo 100 also acts as a 'line number' (matching
// the tc loop variable), starting counting from zero, so that the 6th test
// case, tc == 5, is the line starting with "something hundred and five".
//
// WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER (together with
// WUFFS_JSON__QUIRK_ALLOW_COMMENT_ETC) should decode the '1's, '2's and '3's
// completely and the '4's and '5's up to but excluding the non-filler.
@@ -3443,17 +3426,17 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
"306 /*foo*/ \n", //
"307 /*foo*/ \n\n", //
"308/*bar\nbaz*/\n\n", //
"309 // qux\n\n", //
"310 /*c0*/ /*c1*/\n\n", //
"311 /*c0*/ \n\n // c2 \n\n", //
"412 \n9", //
"513 9", //
"309 // qux", //
"310 // qux\n", //
"311 // qux\n\n", //
"312 /*c0*/ /*c1*/\n\n", //
"313 /*c0*/ \n\n // c2 \n\n", //
"414 \n9", //
"515 9", //
};
int tc;
// Test ALLOW_ETC.
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
void* tc_ptr = (void*)(test_cases[tc]);
size_t tc_len = strlen(test_cases[tc]);
char code = test_cases[tc][0];
@@ -3477,8 +3460,8 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
.repr;
if (have_repr != NULL) {
RETURN_FAIL("tc=%d, ALLOW_ETC: decode_tokens: have \"%s\", want NULL", tc,
have_repr);
RETURN_FAIL("tc=%zu, ALLOW_ETC: decode_tokens: have \"%s\", want NULL",
tc, have_repr);
}
size_t have_total_length = 0;
@@ -3488,16 +3471,16 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
}
size_t want_total_length = tc_len - ((code >= '4') ? 1 : 0);
if (have_total_length != src.meta.ri) {
RETURN_FAIL("tc=%d, ALLOW_ETC: total_length: have %zu, want %zu", tc,
RETURN_FAIL("tc=%zu, ALLOW_ETC: total_length: have %zu, want %zu", tc,
have_total_length, src.meta.ri);
} else if (have_total_length != want_total_length) {
RETURN_FAIL("tc=%d, ALLOW_ETC: total_length: have %zu, want %zu", tc,
RETURN_FAIL("tc=%zu, ALLOW_ETC: total_length: have %zu, want %zu", tc,
have_total_length, want_total_length);
}
}
// Test EXPECT_ETC.
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
void* tc_ptr = (void*)(test_cases[tc]);
size_t tc_len = strlen(test_cases[tc]);
char code = test_cases[tc][0];
@@ -3519,7 +3502,7 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
const char* want_repr =
((code == '3') || (code == '5')) ? wuffs_json__error__bad_input : NULL;
if (have_repr != want_repr) {
RETURN_FAIL("tc=%d, EXPECT_ETC: decode_tokens: have \"%s\", want \"%s\"",
RETURN_FAIL("tc=%zu, EXPECT_ETC: decode_tokens: have \"%s\", want \"%s\"",
tc, have_repr, want_repr);
} else if (have_repr != NULL) {
continue;
@@ -3532,10 +3515,10 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
}
size_t want_total_length = tc_len - ((code == '1') ? 0 : 1);
if (have_total_length != src.meta.ri) {
RETURN_FAIL("tc=%d, EXPECT_ETC: total_length: have %zu, want %zu", tc,
RETURN_FAIL("tc=%zu, EXPECT_ETC: total_length: have %zu, want %zu", tc,
have_total_length, src.meta.ri);
} else if (have_total_length != want_total_length) {
RETURN_FAIL("tc=%d, EXPECT_ETC: total_length: have %zu, want %zu", tc,
RETURN_FAIL("tc=%zu, EXPECT_ETC: total_length: have %zu, want %zu", tc,
have_total_length, want_total_length);
}
}
@@ -3572,10 +3555,8 @@ test_wuffs_json_decode_quirk_allow_trailing_filler() {
{.want = "XXX", .str = "0"}, //
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
int q;
for (q = 0; q < 3; q++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (int q = 0; q < 3; q++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3595,7 +3576,7 @@ test_wuffs_json_decode_quirk_allow_trailing_filler() {
const char* want =
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
if (have != want) {
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
q, have, want);
}
@@ -3604,17 +3585,17 @@ test_wuffs_json_decode_quirk_allow_trailing_filler() {
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
}
if (total_length != src.meta.ri) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.meta.ri);
}
if (test_cases[tc].want[q] == 'X') {
if (total_length != src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
total_length, src.data.len);
}
} else if (test_cases[tc].want[q] == '+') {
if (total_length >= src.data.len) {
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
total_length, src.data.len);
}
}
@@ -3672,8 +3653,7 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() {
{.want = "a\xF0\x90\x80\x80?z", .str = "\"a\\uD800\\uDC00\\uDFFFz\""},
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_json__decoder dec;
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3707,7 +3687,7 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() {
n = 1;
}
if ((have.data.len - have.meta.wi) < n) {
RETURN_FAIL("tc=%d: token too long", tc);
RETURN_FAIL("tc=%zu: token too long", tc);
}
memcpy(&have.data.ptr[have.meta.wi], &u[0], n);
have.meta.wi += n;
@@ -3718,35 +3698,35 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() {
} else if (vbd &
WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {
if ((have.data.len - have.meta.wi) < token_length) {
RETURN_FAIL("tc=%d: token too long", tc);
RETURN_FAIL("tc=%zu: token too long", tc);
}
memcpy(&have.data.ptr[have.meta.wi], &test_cases[tc].str[src_index],
token_length);
have.meta.wi += token_length;
} else {
RETURN_FAIL("tc=%d: unexpected string-token conversion", tc);
RETURN_FAIL("tc=%zu: unexpected string-token conversion", tc);
}
} else {
RETURN_FAIL("tc=%d: unexpected token", tc);
RETURN_FAIL("tc=%zu: unexpected token", tc);
}
src_index += token_length;
}
if (src_index != src.meta.ri) {
RETURN_FAIL("tc=%d: src_index: have %" PRIu64 ", want %zu", tc, src_index,
src.meta.ri);
RETURN_FAIL("tc=%zu: src_index: have %" PRIu64 ", want %zu", tc,
src_index, src.meta.ri);
}
if (have.meta.wi >= have.data.len) {
RETURN_FAIL("tc=%d: too many have bytes", tc);
RETURN_FAIL("tc=%zu: too many have bytes", tc);
}
have.data.ptr[have.meta.wi] = '\x00';
size_t len = strlen(test_cases[tc].want);
if ((len != have.meta.wi) ||
(memcmp(have.data.ptr, test_cases[tc].want, len) != 0)) {
RETURN_FAIL("tc=%d: have \"%s\", want \"%s\"", tc, have.data.ptr,
RETURN_FAIL("tc=%zu: have \"%s\", want \"%s\"", tc, have.data.ptr,
test_cases[tc].want);
}
}
@@ -3807,8 +3787,7 @@ test_wuffs_json_decode_unicode4_escapes() {
};
wuffs_json__decoder dec;
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
CHECK_STATUS("initialize",
wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -3822,8 +3801,7 @@ test_wuffs_json_decode_unicode4_escapes() {
uint32_t have = fail;
uint64_t total_length = 0;
size_t i;
for (i = tok.meta.ri; i < tok.meta.wi; i++) {
for (size_t i = tok.meta.ri; i < tok.meta.wi; i++) {
wuffs_base__token* t = &tok.data.ptr[i];
total_length =
wuffs_base__u64__sat_add(total_length, wuffs_base__token__length(t));
@@ -3885,8 +3863,7 @@ test_wuffs_json_decode_src_io_buffer_length() {
wuffs_json__decoder dec;
int i;
for (i = WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL - 2;
for (int i = WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL - 2;
i <= WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL + 2; i++) {
if (i < 0) {
RETURN_FAIL("invalid test case: i=%d", i);
@@ -3997,8 +3974,7 @@ test_wuffs_json_decode_string() {
};
wuffs_json__decoder dec;
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
CHECK_STATUS("initialize",
wuffs_json__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
@@ -4012,8 +3988,7 @@ test_wuffs_json_decode_string() {
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8);
uint64_t total_length = 0;
size_t i;
for (i = tok.meta.ri; i < tok.meta.wi; i++) {
for (size_t i = tok.meta.ri; i < tok.meta.wi; i++) {
wuffs_base__token* t = &tok.data.ptr[i];
total_length =
wuffs_base__u64__sat_add(total_length, wuffs_base__token__length(t));
@@ -4049,9 +4024,8 @@ do_bench_wuffs_strconv_parse_number_f64(const char* str,
wuffs_base__slice_u8 s = wuffs_base__make_slice_u8((void*)str, strlen(str));
bench_start();
uint64_t i;
uint64_t iters = iters_unscaled * g_flags.iterscale;
for (i = 0; i < iters; i++) {
for (uint64_t i = 0; i < iters; i++) {
CHECK_STATUS("", wuffs_base__parse_number_f64(
s, WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS)
.status);
@@ -4092,11 +4066,9 @@ const char* //
do_bench_wuffs_strconv_render_number_f64(wuffs_base__slice_u64 test_cases,
uint64_t iters_unscaled) {
bench_start();
uint64_t i;
uint64_t iters = iters_unscaled * g_flags.iterscale;
for (i = 0; i < iters; i++) {
size_t tc;
for (tc = 0; tc < test_cases.len; tc++) {
for (uint64_t i = 0; i < iters; i++) {
for (size_t tc = 0; tc < test_cases.len; tc++) {
size_t n = wuffs_base__render_number_f64(
g_have_slice_u8,
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
+3 -6
View File
@@ -225,8 +225,7 @@ test_wuffs_lzw_decode_output_bad() {
// (0x41, 0x42, 0x43) then a bad 8-bit code 0xFF. Decoding should produce 3
// bytes and consume 4 bytes.
src.meta.wi = 20;
int i;
for (i = 0; i < src.meta.wi; i++) {
for (int i = 0; i < src.meta.wi; i++) {
src.data.ptr[i] = 0;
}
src.data.ptr[0] = 0x41;
@@ -271,8 +270,7 @@ test_wuffs_lzw_decode_output_empty() {
// Set up src to be 20 bytes long, starting with the 9-bit end code 0x101.
// Decoding should produce 0 bytes and consume 2 bytes.
src.meta.wi = 20;
int i;
for (i = 0; i < src.meta.wi; i++) {
for (int i = 0; i < src.meta.wi; i++) {
src.data.ptr[i] = 0;
}
src.data.ptr[0] = 0x01;
@@ -405,9 +403,8 @@ do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
bench_start();
uint64_t n_bytes = 0;
uint64_t i;
uint64_t iters = iters_unscaled * g_flags.iterscale;
for (i = 0; i < iters; i++) {
for (uint64_t i = 0; i < iters; i++) {
have.meta.wi = 0;
src.meta.ri = 1; // Skip the literal width.
wuffs_lzw__decoder dec;
+425 -32
View File
@@ -118,8 +118,7 @@ do_test_xxxxx_png_decode_bad_crc32_checksum_critical(
#endif
};
int tc;
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
@@ -132,7 +131,7 @@ do_test_xxxxx_png_decode_bad_crc32_checksum_critical(
wuffs_base__make_pixel_format(
WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, &src)) {
RETURN_FAIL("tc=%d (filename=\"%s\"): bad checksum not rejected", tc,
RETURN_FAIL("tc=%zu (filename=\"%s\"): bad checksum not rejected", tc,
test_cases[tc]);
}
}
@@ -149,6 +148,10 @@ do_wuffs_png_swizzle(uint32_t width,
CHECK_STATUS("initialize", wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
dec.private_impl.f_frame_rect_x0 = 0;
dec.private_impl.f_frame_rect_y0 = 0;
dec.private_impl.f_frame_rect_x1 = width;
dec.private_impl.f_frame_rect_y1 = height;
dec.private_impl.f_width = width;
dec.private_impl.f_height = height;
dec.private_impl.f_pass_bytes_per_row = width;
@@ -315,16 +318,14 @@ apply_png_encode_filters(wuffs_base__slice_u8 dst_rows,
(((width + 1) * height) != src_rows.len)) {
return "apply_png_encode_filters: unexpected rows.len";
}
size_t y;
uint8_t* src_prev = NULL;
for (y = 0; y < height; y++) {
for (size_t y = 0; y < height; y++) {
uint8_t filter = src_rows.ptr[(width + 1) * y];
dst_rows.ptr[(width + 1) * y] = filter;
uint8_t* dst_curr = &dst_rows.ptr[((width + 1) * y) + 1];
uint8_t* src_curr = &src_rows.ptr[((width + 1) * y) + 1];
size_t x;
for (x = 0; x < width; x++) {
for (size_t x = 0; x < width; x++) {
int32_t fa = 0;
int32_t fb = 0;
int32_t fc = 0;
@@ -449,26 +450,420 @@ test_wuffs_png_decode_filters_round_trip() {
const char* //
test_wuffs_png_decode_frame_config() {
CHECK_FOCUS(__func__);
static const uint64_t hibiscus_regular_want_areas[] = {
312 * 442,
};
static const uint64_t hibiscus_regular_want_io_ps[] = {
0x0021,
};
static const uint64_t animated_red_blue_want_areas[] = {
64 * 48,
37 * 9,
49 * 40,
37 * 9,
};
static const uint64_t animated_red_blue_want_io_ps[] = {
0x006D,
0x044A,
0x04D1,
0x0720,
};
struct {
const char* filename;
uint64_t want_count;
const uint64_t* want_areas;
const uint64_t* want_io_ps;
} test_cases[] = {
{
.filename = "test/data/hibiscus.regular.png",
.want_count = WUFFS_TESTLIB_ARRAY_SIZE(hibiscus_regular_want_areas),
.want_areas = hibiscus_regular_want_areas,
.want_io_ps = hibiscus_regular_want_io_ps,
},
{
.filename = "test/data/animated-red-blue.apng",
.want_count = WUFFS_TESTLIB_ARRAY_SIZE(animated_red_blue_want_areas),
.want_areas = animated_red_blue_want_areas,
.want_io_ps = animated_red_blue_want_io_ps,
},
};
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
wuffs_png__decoder dec;
CHECK_STATUS("initialize",
wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, test_cases[tc].filename));
uint64_t have_count = 0;
while (true) {
wuffs_base__status status =
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src);
if (status.repr == wuffs_base__note__end_of_data) {
break;
} else if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("decode_frame_config tc=%zu #%" PRIu64 ": %s", tc,
have_count, status.repr);
}
if (have_count < test_cases[tc].want_count) {
uint64_t have_area = ((uint64_t)wuffs_base__frame_config__width(&fc)) *
((uint64_t)wuffs_base__frame_config__height(&fc));
if (have_area != test_cases[tc].want_areas[have_count]) {
RETURN_FAIL(
"area tc=%zu #%" PRIu64 ": have %" PRIu64 ", want %" PRIu64, tc,
have_count, have_area, test_cases[tc].want_areas[have_count]);
}
uint64_t have_io_p = wuffs_base__frame_config__io_position(&fc);
if (have_io_p != test_cases[tc].want_io_ps[have_count]) {
RETURN_FAIL("io_position tc=%zu #%" PRIu64 ": have %" PRIu64
", want %" PRIu64,
tc, have_count, have_io_p,
test_cases[tc].want_io_ps[have_count]);
}
}
have_count++;
}
if (have_count != test_cases[tc].want_count) {
RETURN_FAIL("count tc=%zu: have %" PRIu64 ", want %" PRIu64, tc,
have_count, test_cases[tc].want_count);
}
}
return NULL;
}
const char* //
test_wuffs_png_decode_metadata_chrm_gama_srgb() {
CHECK_FOCUS(__func__);
wuffs_png__decoder dec;
for (int q = 0; q < 4; q++) {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, "test/data/bricks-dither.png"));
wuffs_base__image_config ic = ((wuffs_base__image_config){});
CHECK_STATUS("initialize",
wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
uint32_t want_fourcc = 0;
uint32_t want[8] = {0};
uint32_t have[8] = {0};
if (q == 1) {
want_fourcc = WUFFS_BASE__FOURCC__CHRM;
want[0] = 31270;
want[1] = 32900;
want[2] = 64000;
want[3] = 33000;
want[4] = 30000;
want[5] = 60000;
want[6] = 15000;
want[7] = 6000;
} else if (q == 2) {
want_fourcc = WUFFS_BASE__FOURCC__GAMA;
want[0] = 45455;
} else if (q == 3) {
want_fourcc = WUFFS_BASE__FOURCC__SRGB;
want[0] = WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL;
have[0] = 123;
}
wuffs_png__decoder__set_report_metadata(&dec, want_fourcc, true);
while (true) {
wuffs_base__status status =
wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
if (wuffs_base__status__is_ok(&status)) {
break;
} else if (status.repr != wuffs_base__note__metadata_reported) {
RETURN_FAIL("decode_image_config (q=%d): have \"%s\", want \"%s\"", q,
status.repr, wuffs_base__note__metadata_reported);
}
wuffs_base__io_buffer empty = wuffs_base__empty_io_buffer();
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
status = wuffs_png__decoder__tell_me_more(&dec, &empty, &minfo, &src);
if (wuffs_base__status__is_error(&status)) {
RETURN_FAIL("tell_me_more (q=%d): \"%s\"", q, status.repr);
} else if (minfo.flavor !=
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED) {
RETURN_FAIL("tell_me_more (q=%d): flavor: have %" PRIu32
", want %" PRIu32,
q, minfo.flavor,
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED);
}
uint32_t have_fourcc =
wuffs_base__more_information__metadata__fourcc(&minfo);
if (have_fourcc != want_fourcc) {
RETURN_FAIL("tell_me_more (q=%d): fourcc: have 0x%08" PRIX32
", want 0x%08" PRIX32,
q, have_fourcc, want_fourcc);
} else if (have_fourcc == WUFFS_BASE__FOURCC__CHRM) {
for (int i = 0; i < 8; i++) {
have[i] = ((uint32_t)(
wuffs_base__more_information__metadata_parsed__chrm(&minfo, i)));
}
} else if (have_fourcc == WUFFS_BASE__FOURCC__GAMA) {
have[0] = wuffs_base__more_information__metadata_parsed__gama(&minfo);
} else if (have_fourcc == WUFFS_BASE__FOURCC__SRGB) {
have[0] = wuffs_base__more_information__metadata_parsed__srgb(&minfo);
}
}
for (int i = 0; i < 8; i++) {
if (have[i] != want[i]) {
RETURN_FAIL("(q=%d, i=%d): have %" PRIu32 ", want %" PRIu32, q, i,
have[i], want[i]);
}
}
}
return NULL;
}
const char* //
test_wuffs_png_decode_metadata_iccp() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
.data = g_have_slice_u8,
});
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = g_want_slice_u8,
});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&want, "test/data/DCI-P3-D65.icc"));
CHECK_STRING(read_file(
&src, "test/data/red-blue-gradient.dcip3d65-no-chrm-no-gama.png"));
bool seen_iccp = false;
wuffs_png__decoder dec;
CHECK_STATUS("initialize",
wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_png__decoder__set_report_metadata(&dec, WUFFS_BASE__FOURCC__ICCP, true);
wuffs_base__image_config ic = ((wuffs_base__image_config){});
while (true) {
wuffs_base__status status =
wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
if (wuffs_base__status__is_ok(&status)) {
break;
} else if (status.repr != wuffs_base__note__metadata_reported) {
RETURN_FAIL("decode_image_config: have \"%s\", want \"%s\"", status.repr,
wuffs_base__note__metadata_reported);
}
{
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
wuffs_base__status status =
wuffs_png__decoder__tell_me_more(&dec, &have, &minfo, &src);
if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("tell_me_more: \"%s\"", status.repr);
} else if (minfo.flavor !=
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM) {
RETURN_FAIL(
"tell_me_more: flavor: have %" PRIu32 ", want %" PRIu32,
minfo.flavor,
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM);
} else if (wuffs_base__more_information__metadata__fourcc(&minfo) !=
WUFFS_BASE__FOURCC__ICCP) {
RETURN_FAIL("tell_me_more: fourcc: have %" PRIX32 ", want %" PRIX32,
wuffs_base__more_information__metadata__fourcc(&minfo),
WUFFS_BASE__FOURCC__ICCP);
}
CHECK_STRING(check_io_buffers_equal("", &have, &want));
seen_iccp = true;
}
}
if (!seen_iccp) {
RETURN_FAIL("seen_iccp: have %d, want %d", seen_iccp, true);
}
{
// 423 = 0x1A7 is just before the "????IDAT" bytes.
uint64_t have = wuffs_base__image_config__first_frame_io_position(&ic);
uint64_t want = 423;
if (have != want) {
RETURN_FAIL("first_frame_io_position: have %" PRIu64 ", want %" PRIu64,
have, want);
}
}
{
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__status status =
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src);
if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("decode_frame_config: %s", status.repr);
}
uint32_t have = wuffs_base__frame_config__width(&fc);
uint32_t want = 256;
if (have != want) {
RETURN_FAIL("decode_frame_config: width: have %" PRIu32 ", want %" PRIu32,
have, want);
}
}
return NULL;
}
const char* //
test_wuffs_png_decode_metadata_kvp() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, "test/data/artificial-png/key-value-pairs.png"));
const char* wants[] = {
"Key", //
"English", //
"Clé", //
"Français", //
"zlïbK", //
"zlïbV", //
"U-Key", //
"U-значение", //
"Z-Këy", //
"Z-значение", //
};
wuffs_png__decoder dec;
CHECK_STATUS("initialize",
wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_png__decoder__set_report_metadata(&dec, WUFFS_BASE__FOURCC__KVP, true);
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
size_t i = 0;
for (;; i++) {
wuffs_base__status status =
wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
if (wuffs_base__status__is_ok(&status)) {
break;
} else if (status.repr != wuffs_base__note__metadata_reported) {
RETURN_FAIL("decode_image_config i=%zu: %s", i, status.repr);
}
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
.data = g_have_slice_u8,
});
status = wuffs_png__decoder__tell_me_more(&dec, &have, &minfo, &src);
if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("tell_me_more i=%zu: \"%s\"", i, status.repr);
} else if (minfo.flavor !=
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM) {
RETURN_FAIL("tell_me_more i=%zu: flavor: have %" PRIu32 ", want %" PRIu32,
i, minfo.flavor,
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM);
}
uint32_t have_fourcc =
wuffs_base__more_information__metadata__fourcc(&minfo);
uint32_t want_fourcc =
(i & 1) ? WUFFS_BASE__FOURCC__KVPV : WUFFS_BASE__FOURCC__KVPK;
if (have_fourcc != want_fourcc) {
RETURN_FAIL("tell_me_more i=%zu: fourcc: have %" PRIX32 ", want %" PRIX32,
i, have_fourcc, want_fourcc);
}
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = g_want_slice_u8,
});
if (i < WUFFS_TESTLIB_ARRAY_SIZE(wants)) {
size_t n = strlen(wants[i]);
if (n < want.data.len) {
memcpy(want.data.ptr, wants[i], n);
want.meta.wi = n;
}
}
CHECK_STRING(check_io_buffers_equal("", &have, &want));
}
if (i != WUFFS_TESTLIB_ARRAY_SIZE(wants)) {
RETURN_FAIL("i: have %zu, want %zu", i, WUFFS_TESTLIB_ARRAY_SIZE(wants));
}
return NULL;
}
const char* //
test_wuffs_png_decode_restart_frame() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, "test/data/pjw-thumbnail.png"));
wuffs_png__decoder dec;
CHECK_STATUS("initialize",
wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, "test/data/hibiscus.regular.png"));
CHECK_STATUS("decode_frame_config #0",
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src));
wuffs_base__status status =
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src);
if (status.repr != wuffs_base__note__end_of_data) {
RETURN_FAIL("decode_frame_config #1: have \"%s\", want \"%s\"", status.repr,
wuffs_base__note__end_of_data);
wuffs_base__image_config ic = ((wuffs_base__image_config){});
CHECK_STATUS("decode_image_config",
wuffs_png__decoder__decode_image_config(&dec, &ic, &src));
// 51 = 0x33 is just before the "????IDAT" bytes.
uint64_t ffio = wuffs_base__image_config__first_frame_io_position(&ic);
if (ffio != 51) {
RETURN_FAIL("first_frame_io_position: have %" PRIu64 ", want 51", ffio);
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg, g_pixel_slice_u8));
for (int i = 0; i < 2; i++) {
if (i > 0) {
CHECK_STATUS("restart_frame",
wuffs_png__decoder__restart_frame(&dec, 0, 51));
if (51 <= src.meta.wi) {
src.meta.ri = 51;
}
}
uint64_t rpos = wuffs_base__io_buffer__reader_position(&src);
if (rpos != 51) {
RETURN_FAIL("reader_position (before) #%d: have %" PRIu64 ", want 51", i,
rpos);
}
wuffs_base__status status = wuffs_png__decoder__decode_frame(
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
if (!wuffs_base__status__is_ok(&status)) {
RETURN_FAIL("decode_frame #%d: %s", i, status.repr);
}
// 196 = 0xC4 is just before the "????IEND" bytes.
rpos = wuffs_base__io_buffer__reader_position(&src);
if (rpos != 196) {
RETURN_FAIL("reader_position (after) #%d: have %" PRIu64 ", want 196", i,
rpos);
}
}
return NULL;
}
@@ -564,10 +959,6 @@ test_mimic_png_decode_bad_crc32_checksum_critical() {
const char* //
bench_wuffs_png_decode_image_19k_8bpp() {
CHECK_FOCUS(__func__);
// libpng automatically applies the "gAMA" chunk (with no matching "sRGB"
// chunk) but Wuffs does not. To make the comparison more like-for-like,
// especially in emitting identical BGRA pixels, patch the source file by
// replacing the "gAMA" with the nonsense "hAMA". ASCII 'g' is 0x67.
return do_bench_image_decode(
&wuffs_png_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__Y), NULL, 0,
@@ -635,8 +1026,7 @@ do_bench_wuffs_png_decode_filter(uint8_t filter,
return "source data is too short";
}
uint32_t y;
for (y = 0; y < height; y++) {
for (uint32_t y = 0; y < height; y++) {
workbuf.data.ptr[(1 + bytes_per_row) * y] = filter;
}
@@ -651,6 +1041,10 @@ do_bench_wuffs_png_decode_filter(uint8_t filter,
CHECK_STATUS("initialize", wuffs_png__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
dec.private_impl.f_frame_rect_x0 = 0;
dec.private_impl.f_frame_rect_y0 = 0;
dec.private_impl.f_frame_rect_x1 = width;
dec.private_impl.f_frame_rect_y1 = height;
dec.private_impl.f_width = width;
dec.private_impl.f_height = height;
dec.private_impl.f_pass_bytes_per_row = bytes_per_row;
@@ -676,9 +1070,8 @@ do_bench_wuffs_png_decode_filter(uint8_t filter,
bench_start();
uint64_t n_bytes = 0;
uint64_t i;
uint64_t iters = iters_unscaled * g_flags.iterscale;
for (i = 0; i < iters; i++) {
for (uint64_t i = 0; i < iters; i++) {
CHECK_STATUS(
"filter_and_swizzle",
wuffs_png__decoder__filter_and_swizzle(
@@ -744,10 +1137,6 @@ bench_wuffs_png_decode_filt_4_dist_4() {
const char* //
bench_mimic_png_decode_image_19k_8bpp() {
CHECK_FOCUS(__func__);
// libpng automatically applies the "gAMA" chunk (with no matching "sRGB"
// chunk) but Wuffs does not. To make the comparison more like-for-like,
// especially in emitting identical BGRA pixels, patch the source file by
// replacing the "gAMA" with the nonsense "hAMA". ASCII 'g' is 0x67.
return do_bench_image_decode(
&mimic_png_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__Y), NULL, 0,
@@ -811,6 +1200,10 @@ proc g_tests[] = {
test_wuffs_png_decode_filters_round_trip,
test_wuffs_png_decode_frame_config,
test_wuffs_png_decode_interface,
test_wuffs_png_decode_metadata_chrm_gama_srgb,
test_wuffs_png_decode_metadata_iccp,
test_wuffs_png_decode_metadata_kvp,
test_wuffs_png_decode_restart_frame,
#ifdef WUFFS_MIMIC
+17 -28
View File
@@ -75,8 +75,7 @@ fill_palette_with_grays(wuffs_base__pixel_buffer* pb) {
if (palette.len != 1024) {
return;
}
int i;
for (i = 0; i < 256; i++) {
for (int i = 0; i < 256; i++) {
palette.ptr[(4 * i) + 0] = i;
palette.ptr[(4 * i) + 1] = i;
palette.ptr[(4 * i) + 2] = i;
@@ -90,8 +89,7 @@ fill_palette_with_nrgba_transparent_yellows(wuffs_base__pixel_buffer* pb) {
if (palette.len != 1024) {
return;
}
int i;
for (i = 0; i < 256; i++) {
for (int i = 0; i < 256; i++) {
palette.ptr[(4 * i) + 0] = 0x00;
palette.ptr[(4 * i) + 1] = 0x99;
palette.ptr[(4 * i) + 2] = 0xCC;
@@ -161,8 +159,7 @@ test_wuffs_pixel_buffer_fill_rect() {
},
};
int d;
for (d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
for (size_t d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
// Allocate the dst_pixbuf.
wuffs_base__pixel_config dst_pixcfg = ((wuffs_base__pixel_config){});
wuffs_base__pixel_config__set(&dst_pixcfg, dsts[d].pixfmt_repr,
@@ -173,13 +170,10 @@ test_wuffs_pixel_buffer_fill_rect() {
wuffs_base__pixel_buffer__set_from_slice(
&dst_pixbuf, &dst_pixcfg, g_have_slice_u8));
int orientation;
for (orientation = 0; orientation < 2; orientation++) {
for (int orientation = 0; orientation < 2; orientation++) {
// Reset to transparent black (or its closest approximation).
uint32_t y;
for (y = 0; y < height; y++) {
uint32_t x;
for (x = 0; x < width; x++) {
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
CHECK_STATUS(
"set_color_u32_at",
wuffs_base__pixel_buffer__set_color_u32_at(&dst_pixbuf, x, y, 0));
@@ -204,7 +198,7 @@ test_wuffs_pixel_buffer_fill_rect() {
wuffs_base__pixel_buffer__color_u32_at(&dst_pixbuf, width / 2,
height / 2);
if (colors_differ(have_dst_pixel, want_dst_pixel, 0)) {
RETURN_FAIL("d=%d, orientation=%d: dst_pixel: have 0x%08" PRIX32
RETURN_FAIL("d=%zu, orientation=%d: dst_pixel: have 0x%08" PRIX32
", want 0x%08" PRIX32,
d, orientation, have_dst_pixel, want_dst_pixel);
}
@@ -324,8 +318,7 @@ test_wuffs_pixel_swizzler_swizzle() {
WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
};
int s;
for (s = 0; s < WUFFS_TESTLIB_ARRAY_SIZE(srcs); s++) {
for (size_t s = 0; s < WUFFS_TESTLIB_ARRAY_SIZE(srcs); s++) {
// Allocate the src_pixbuf.
wuffs_base__pixel_config src_pixcfg = ((wuffs_base__pixel_config){});
wuffs_base__pixel_config__set(&src_pixcfg, srcs[s].pixfmt_repr,
@@ -350,12 +343,11 @@ test_wuffs_pixel_swizzler_swizzle() {
wuffs_base__pixel_buffer__color_u32_at(&src_pixbuf, width / 2,
height / 2);
if (have_src_pixel != srcs[s].color) {
RETURN_FAIL("s=%d: src_pixel: have 0x%08" PRIX32 ", want 0x%08" PRIX32, s,
have_src_pixel, srcs[s].color);
RETURN_FAIL("s=%zu: src_pixel: have 0x%08" PRIX32 ", want 0x%08" PRIX32,
s, have_src_pixel, srcs[s].color);
}
int d;
for (d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
for (size_t d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
// Allocate the dst_pixbuf.
wuffs_base__pixel_config dst_pixcfg = ((wuffs_base__pixel_config){});
wuffs_base__pixel_config__set(&dst_pixcfg, dsts[d].pixfmt_repr,
@@ -378,8 +370,7 @@ test_wuffs_pixel_swizzler_swizzle() {
WUFFS_TESTLIB_ARRAY_SIZE(fallback_palette_array));
}
int b;
for (b = 0; b < WUFFS_TESTLIB_ARRAY_SIZE(blends); b++) {
for (size_t b = 0; b < WUFFS_TESTLIB_ARRAY_SIZE(blends); b++) {
// Set the middle dst pixel.
CHECK_STATUS("set_color_u32_at",
wuffs_base__pixel_buffer__set_color_u32_at(
@@ -394,10 +385,10 @@ test_wuffs_pixel_swizzler_swizzle() {
wuffs_base__pixel_buffer__palette(&src_pixbuf), blends[b]));
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(
&swizzler,
wuffs_base__table_u8__row(
wuffs_base__table_u8__row_u32(
wuffs_base__pixel_buffer__plane(&dst_pixbuf, 0), height / 2),
dst_palette,
wuffs_base__table_u8__row(
wuffs_base__table_u8__row_u32(
wuffs_base__pixel_buffer__plane(&src_pixbuf, 0), height / 2));
// Check the middle dst pixel.
@@ -420,7 +411,7 @@ test_wuffs_pixel_swizzler_swizzle() {
wuffs_base__pixel_buffer__color_u32_at(&dst_pixbuf, width / 2,
height / 2);
if (colors_differ(have_dst_pixel, want_dst_pixel, tolerance)) {
RETURN_FAIL("s=%d, d=%d, b=%d: dst_pixel: have 0x%08" PRIX32
RETURN_FAIL("s=%zu, d=%zu, b=%zu: dst_pixel: have 0x%08" PRIX32
", want 0x%08" PRIX32 ", per-channel tolerance=%" PRId32,
s, d, b, have_dst_pixel, want_dst_pixel, tolerance);
}
@@ -559,11 +550,9 @@ do_bench_wuffs_pixel_swizzler(uint32_t dst_pixfmt_repr,
bench_start();
uint64_t n_bytes = 0;
uint64_t i;
uint64_t iters = iters_unscaled * g_flags.iterscale;
for (i = 0; i < iters; i++) {
uint32_t y;
for (y = 0; y < height; y++) {
for (uint64_t i = 0; i < iters; i++) {
for (uint32_t y = 0; y < height; y++) {
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(
&swizzler,
wuffs_base__make_slice_u8(
+2 -4
View File
@@ -170,8 +170,7 @@ do_test_wuffs_zlib_checksum(bool ignore_checksum, uint32_t bad_checksum) {
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
// or isn't zero.
int i;
for (i = 0; i < 2; i++) {
for (int i = 0; i < 2; i++) {
uint64_t rlimit = UINT64_MAX;
const char* want_z = NULL;
if (i == 0) {
@@ -255,8 +254,7 @@ test_wuffs_zlib_decode_sheep() {
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
int i;
for (i = 0; i < 3; i++) {
for (int i = 0; i < 3; i++) {
wuffs_base__status status =
wuffs_zlib__decoder__transform_io(&dec, &have, &src, g_work_slice_u8);
+17 -30
View File
@@ -369,8 +369,7 @@ chdir_to_the_wuffs_root_directory() {
// Chdir to the Wuffs root directory, assuming that we're starting from
// somewhere in the Wuffs repository, so we can find the root directory by
// running chdir("..") a number of times.
int n;
for (n = 0; n < 64; n++) {
for (int n = 0; n < 64; n++) {
if (access("wuffs-root-directory.txt", F_OK) == 0) {
return NULL;
}
@@ -426,11 +425,9 @@ test_main(int argc, char** argv, proc* tests, proc* benches) {
"# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");
}
int i;
for (i = 0; i < reps; i++) {
for (int i = 0; i < reps; i++) {
g_bench_warm_up = i == 0;
proc* p;
for (p = procs; *p; p++) {
for (proc* p = procs; *p; p++) {
g_proc_func_name = "unknown_func_name";
g_fail_msg[0] = 0;
g_in_focus = false;
@@ -562,12 +559,10 @@ copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst,
}
size_t bytes_per_pixel = bits_per_pixel / 8;
uint32_t p;
for (p = 0; p < 1; p++) {
for (uint32_t p = 0; p < 1; p++) {
wuffs_base__table_u8 tab = wuffs_base__pixel_buffer__plane(src, p);
uint32_t y;
for (y = r.min_incl_y; y < r.max_excl_y; y++) {
wuffs_base__slice_u8 row = wuffs_base__table_u8__row(tab, y);
for (uint32_t y = r.min_incl_y; y < r.max_excl_y; y++) {
wuffs_base__slice_u8 row = wuffs_base__table_u8__row_u32(tab, y);
if ((r.min_incl_x >= r.max_excl_x) ||
(r.max_excl_x > (row.len / bytes_per_pixel))) {
break;
@@ -671,7 +666,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);
@@ -748,8 +743,7 @@ hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
return msg;
}
size_t base = i - (i & 15);
int j;
for (j = -3 * 16; j <= +3 * 16; j += 16) {
for (int j = -3 * 16; j <= +3 * 16; j += 16) {
if ((j < 0) && (base < (size_t)(-j))) {
continue;
}
@@ -759,8 +753,7 @@ hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
}
size_t n = buf->meta.wi - b;
INCR_FAIL(msg, " %06zx:", b);
size_t k;
for (k = 0; k < 16; k++) {
for (size_t k = 0; k < 16; k++) {
if (k % 2 == 0) {
INCR_FAIL(msg, " ");
}
@@ -771,7 +764,7 @@ hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
}
}
INCR_FAIL(msg, " ");
for (k = 0; k < 16; k++) {
for (size_t k = 0; k < 16; k++) {
char c = ' ';
if (k < n) {
c = buf->data.ptr[b + k];
@@ -797,12 +790,10 @@ check_io_buffers_equal(const char* prefix,
RETURN_FAIL("%sio_buffers_equal: NULL argument", prefix);
}
char* msg = g_fail_msg;
size_t i;
size_t i = 0;
size_t n = have->meta.wi < want->meta.wi ? have->meta.wi : want->meta.wi;
for (i = 0; i < n; i++) {
if (have->data.ptr[i] != want->data.ptr[i]) {
break;
}
while ((i < n) && (have->data.ptr[i] == want->data.ptr[i])) {
i++;
}
if (have->meta.wi != want->meta.wi) {
INCR_FAIL(msg, "%sio_buffers_equal: wi: have %zu, want %zu.\n", prefix,
@@ -893,8 +884,7 @@ proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
bench_start();
}
uint64_t n_bytes = 0;
uint64_t i;
for (i = 0; i < iters; i++) {
for (uint64_t i = 0; i < iters; i++) {
have.meta.wi = 0;
src.meta.ri = gt->src_offset0;
const char* status =
@@ -979,8 +969,7 @@ proc_token_decoder(const char* (*codec_func)(wuffs_base__token_buffer*,
bench_start();
}
uint64_t n_bytes = 0;
uint64_t i;
for (i = 0; i < iters; i++) {
for (uint64_t i = 0; i < iters; i++) {
have.meta.wi = 0;
src.meta.ri = gt->src_offset0;
const char* status =
@@ -1067,8 +1056,7 @@ do_run__wuffs_base__image_decoder(wuffs_base__image_decoder* b,
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
size_t i;
for (i = 0; i < quirks_len; i++) {
for (size_t i = 0; i < quirks_len; i++) {
wuffs_base__image_decoder__set_quirk_enabled(b, quirks_ptr[i], true);
}
@@ -1145,9 +1133,8 @@ do_bench_image_decode(
bench_start();
uint64_t n_bytes = 0;
uint64_t i;
uint64_t iters = iters_unscaled * g_flags.iterscale;
for (i = 0; i < iters; i++) {
for (uint64_t i = 0; i < iters; i++) {
src.meta.ri = src_ri;
CHECK_STRING((*decode_func)(&n_bytes, NULL, wuffs_initialize_flags, pixfmt,
quirks_ptr, quirks_len, &src));
File renamed without changes.
File renamed without changes.
File renamed without changes.
Binary file not shown.
Binary file not shown.
+23 -6
View File
@@ -6,21 +6,27 @@ files were generated by `script/extract-palette-indexes.go`. The `*.tokens`
files were generated by `script/print-json-token-debug-format.c`.
The `*.jpeg` files are usually the canonical versions of the test/data images,
and other versions (`*.bmp`, `*.gif`, `*.png`, `*.tiff`) were generated by
and other versions (`*.bmp`, `*.gif`, `*.png` etc) were usually generated by
ImageMagick's `convert` command line tool. The `*.wbmp` versions were generated
by the `script/convert-png-to-wbmp.go` command line tool. The `*.webp` versions
were generated by the cwebp command line tool.
were generated by the cwebp command line tool. The `*.no-ancillary.png` files
were generated by the `script/strip-png-ancillary-chunks.go` command line tool.
The `*.apng` files were generated by `gif2apng`. Those with finite animation
loop counts were manually patched to correct for a `gif2apng` bug.
https://bugs.chromium.org/p/chromium/issues/detail?id=592735 argues that GIF
and APNG/WEBP have different semantics but `gif2apng` does not cater for that.
---
The artificial directory holds artificially generated test data, often to
The `artificial-*` directories hold artificially generated test data, often to
explicitly test corner cases of various file formats. The files there usually
come in families whose names have a common prefix, such as three files
`foo.bar`, `foo.bar.qux`, `foo.bar.commentary.txt` all prefixed by `foo.bar`.
The file whose name is that prefix is usually the canonical (typically
hand-crafted) file, and the other files are then derived from that. Outside of
the artificial directory, the other files in this directory are typically real
world examples of various file formats, or deriviations of them.
the `artificial-*` directories, the other files in this directory are typically
real world examples of various file formats, or deriviations of them.
---
@@ -28,10 +34,17 @@ The non-ascii directory holds trivial UTF-8 (but not ASCII) text files.
---
`DCI-P3-D65.icc` comes from
[color.org](https://www.color.org/chardata/rgb/DCIP3.xalter).
`DCI-P3-D65.icc.zlib` is a zlib-compresion of that, created by Go's standard
library.
`archive.*` archives a subset of other files in this directory.
`animated-red-blue.gif` is an original animation by Nigel Tao
<nigeltao@golang.org>.
<nigeltao@golang.org>. `animated-red-blue.nia` and `animated-red-blue.*.nie`
were then generated by `example/convert-to-nia` and
`script/extract-nia-frames.go`.
`australian-abc-local-stations.json` was crawled from
[data.gov.au](http://data.gov.au/geoserver/abc-local-stations/wfs?request=GetFeature&typeName=ckan_d534c0e9_a9bf_487b_ac8f_b7877a09d162&outputFormat=json).
@@ -43,6 +56,8 @@ The non-ascii directory holds trivial UTF-8 (but not ASCII) text files.
`cbor-rfc-7049-examples.*.json` files were then generated by
`example/cbor-to-json`.
`checkerboard.*.png` was generated by `script/make-red-blue-gradient.go`.
`crude-flag.*` is an original animation by Nigel Tao
<nigeltao@golang.org>. See the `lib/nie` documentation.
@@ -109,6 +124,8 @@ which is in the public domain.
`pjw-thumbnail.*` are various encodings of an image derived from an iconic,
original photo of Peter J. Weinberger by Rob Pike <r@golang.org>.
`red-blue-gradient.*.png` was generated by `script/make-red-blue-gradient.go`.
`rfc-6901-json-pointer.json` is the example JSON document given in the [RFC
6901 "JavaScript Object Notation (JSON)
Pointer"](https://tools.ietf.org/rfc/rfc6901.txt) specification.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 2.0 KiB

Binary file not shown.
@@ -1,5 +1,5 @@
Running deflate-backref-crosses-blocks.deflate through script/print-bits.go and
adding commentary:
Running backref-crosses-blocks.deflate through script/print-bits.go and adding
commentary:
offset xoffset ASCII hex binary
000000 0x0000 . 0x00 0b_...._.000 Uncompressed block, non-final
@@ -1,5 +1,5 @@
Running deflate-degenerate-huffman-unused.deflate through script/print-bits.go
and adding commentary:
Running degenerate-huffman-unused.deflate through script/print-bits.go and
adding commentary:
offset xoffset ASCII hex binary
000000 0x0000 . 0x05 0b_...._.101 Dynamic Huffman block, final
@@ -1,4 +1,4 @@
Running deflate-distance-32768.deflate through script/print-bits.go and adding
Running distance-32768.deflate through script/print-bits.go and adding
commentary:
offset xoffset ASCII hex binary
@@ -1,5 +1,5 @@
Running deflate-distance-code-31.deflate through script/print-bits.go and
adding commentary:
Running distance-code-31.deflate through script/print-bits.go and adding
commentary:
offset xoffset ASCII hex binary
000000 0x0000 . 0x03 0b_...._.011 Fixed Huffman block, final
@@ -1,5 +1,5 @@
Running deflate-huffman-primlen-9.deflate through script/print-bits.go and
adding commentary:
Running huffman-primlen-9.deflate through script/print-bits.go and adding
commentary:
offset xoffset ASCII hex binary
000000 0x0000 . 0xED 0b_...._.101 Dynamic Huffman block, final
File renamed without changes.

Before

Width:  |  Height:  |  Size: 90 B

After

Width:  |  Height:  |  Size: 90 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 54 B

After

Width:  |  Height:  |  Size: 54 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 132 B

After

Width:  |  Height:  |  Size: 132 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 90 B

After

Width:  |  Height:  |  Size: 90 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 110 B

After

Width:  |  Height:  |  Size: 110 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 56 B

After

Width:  |  Height:  |  Size: 56 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 139 B

After

Width:  |  Height:  |  Size: 139 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 26 B

After

Width:  |  Height:  |  Size: 26 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 40 B

After

Width:  |  Height:  |  Size: 40 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 40 B

After

Width:  |  Height:  |  Size: 40 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 41 B

After

Width:  |  Height:  |  Size: 41 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 40 B

After

Width:  |  Height:  |  Size: 40 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 165 B

After

Width:  |  Height:  |  Size: 165 B

File renamed without changes.

Before

Width:  |  Height:  |  Size: 40 B

After

Width:  |  Height:  |  Size: 40 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 270 B

@@ -0,0 +1,87 @@
# Feed this file to script/make-artificial.go
# This APNG image has its first fcTL chunk after the IDAT chunks, so that the
# IDAT data (the "default image") is not displayed. See
# https://wiki.mozilla.org/APNG_Specification
make png
magic
IHDR {
raw {
# Width, height.
0x00 0x00 0x00 0x03
0x00 0x00 0x00 0x02
# Depth, color, compression, filter, interlace.
0x08 0x02 0x00 0x00 0x00
}
}
acTL {
raw {
# Frame count.
0x00 0x00 0x00 0x02
# Loop count.
0x00 0x00 0x00 0x00
}
}
IDAT {
zlib {
# 3x2 RGB pixels (with filter bytes), shades of red.
0x00 0x20 0x00 0x00 0x50 0x00 0x00 0x80 0x00 0x00
0x00 0x40 0x00 0x00 0xA0 0x00 0x00 0xFF 0x00 0x00
}
}
fcTL {
animSeqNum++
raw {
# Width, height, left, top.
0x00 0x00 0x00 0x03
0x00 0x00 0x00 0x02
0x00 0x00 0x00 0x00
0x00 0x00 0x00 0x00
# Duration (1/1 second).
0x00 0x01 0x00 0x01
# Disposal, blend.
0x00 0x00
}
}
fdAT {
animSeqNum++
zlib {
# 3x2 RGB pixels (with filter bytes), shades of cyan.
0x00 0x00 0x20 0x20 0x00 0x50 0x50 0x00 0x80 0x80
0x00 0x00 0x40 0x40 0x00 0xA0 0xA0 0x00 0xFF 0xFF
}
}
fcTL {
animSeqNum++
raw {
# Width, height, left, top.
0x00 0x00 0x00 0x01
0x00 0x00 0x00 0x02
0x00 0x00 0x00 0x02
0x00 0x00 0x00 0x00
# Duration (1/1 second).
0x00 0x01 0x00 0x01
# Disposal, blend.
0x00 0x00
}
}
fdAT {
animSeqNum++
zlib {
# 1x2 RGB pixels (with filter bytes), shades of gray.
0x00 0x80 0x80 0x80
0x00 0xFF 0xFF 0xFF
}
}
IEND {
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 272 B

@@ -0,0 +1,99 @@
# Feed this file to script/make-artificial.go
make png
magic
IHDR {
raw {
# Width, height.
0x00 0x00 0x00 0x01
0x00 0x00 0x00 0x01
# Depth, color, compression, filter, interlace.
0x08 0x00 0x00 0x00 0x00
}
}
# Basic key-value pair.
tEXt {
raw {
# "Key\x00".
0x4B 0x65 0x79 0x00
# "English".
0x45 0x6E 0x67 0x6C 0x69 0x73 0x68
}
}
# Latin-1 (not UTF-8) uncompressed key-value pair.
tEXt {
raw {
# asLatin1("Clé\x00").
0x43 0x6C 0xE9 0x00
# asLatin1("Français").
0x46 0x72 0x61 0x6E 0xE7 0x61 0x69 0x73
}
}
# Latin-1 (not UTF-8) zlib-compressed key-value pair.
zTXt {
raw {
# asLatin1("zlïbK\x00").
0x7A 0x6C 0xEF 0x62 0x4B 0x00
# Compression method.
0x00
}
zlib {
# asLatin1("zlïbV").
0x7A 0x6C 0xEF 0x62 0x56
}
}
# UTF-8 uncompressed key-value pair.
iTXt {
raw {
# "U-Key\x00".
0x55 0x2D 0x4B 0x65 0x79 0x00
# Compression flag, compression method.
0x00 0x00
# Language tag: "ru\x00".
0x72 0x75 0x00
# Translated key: "U-ключ\x00".
0x55 0x2D 0xD0 0xBA 0xD0 0xBB 0xD1 0x8E
0xD1 0x87 0x00
# "U-значение".
0x55 0x2D 0xD0 0xB7 0xD0 0xBD 0xD0 0xB0
0xD1 0x87 0xD0 0xB5 0xD0 0xBD 0xD0 0xB8
0xD0 0xB5
}
}
# Latin-1 / UTF-8 zlib-compressed key-value pair.
iTXt {
raw {
# asLatin1("Z-Këy\x00").
0x5A 0x2D 0x4B 0xEB 0x79 0x00
# Compression flag, compression method.
0x01 0x00
# Language tag: "ru\x00".
0x72 0x75 0x00
# Translated key: "Z-ключ\x00".
0x5A 0x2D 0xD0 0xBA 0xD0 0xBB 0xD1 0x8E
0xD1 0x87 0x00
}
zlib {
# "Z-значение".
0x5A 0x2D 0xD0 0xB7 0xD0 0xBD 0xD0 0xB0
0xD1 0x87 0xD0 0xB5 0xD0 0xBD 0xD0 0xB8
0xD0 0xB5
}
}
IDAT {
zlib {
# 1x1 gray pixels (with filter bytes).
0x00 0x80
}
}
IEND {
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 14 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 441 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 441 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 4.2 KiB

Binary file not shown.
Binary file not shown.

After

Width:  |  Height:  |  Size: 9.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.1 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 779 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 779 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 779 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 763 B

+75
View File
@@ -0,0 +1,75 @@
# Generated by script/print-nia-checksums.sh
d3bb0beb test/data/DCI-P3-D65.icc
646e081a test/data/animated-red-blue.000000.nie
181c6916 test/data/animated-red-blue.000001.nie
e651a889 test/data/animated-red-blue.000002.nie
14a5b4b0 test/data/animated-red-blue.000003.nie
76e40058 test/data/animated-red-blue.apng
76e40058 test/data/animated-red-blue.gif
f9a10dac test/data/artificial-gif/background-color.gif
36e7d9c7 test/data/artificial-gif/empty-palette.gif
db4c30eb test/data/artificial-gif/frame-out-of-bounds.gif
fdcc644f test/data/artificial-gif/metadata-empty.gif
fdcc644f test/data/artificial-gif/metadata-full.gif
6d03b5f3 test/data/artificial-gif/multiple-graphic-controls.gif
47c877fd test/data/artificial-gif/multiple-loop-counts.gif
76c44866 test/data/artificial-gif/no-frames.gif
6ec818c3 test/data/artificial-gif/pixel-data-none.gif
5e57adb2 test/data/artificial-gif/pixel-data-not-enough.gif
3e29f88a test/data/artificial-gif/pixel-data-too-much.gif
f50d1d50 test/data/artificial-gif/small-frame-interlaced.gif
beaec397 test/data/artificial-gif/transparent-index.gif
6ec818c3 test/data/artificial-gif/zero-width-frame.gif
0564b364 test/data/artificial-png/apng-skip-idat.png
e08a7cc8 test/data/artificial-png/key-value-pairs.png
076cb375 test/data/bricks-color.bmp
076cb375 test/data/bricks-color.png
f36c2e80 test/data/bricks-dither.bmp
3fc62e1e test/data/bricks-dither.gif
f36c2e80 test/data/bricks-dither.no-ancillary.png
f36c2e80 test/data/bricks-dither.png
c2bce675 test/data/bricks-gray.bmp
0e16e6eb test/data/bricks-gray.gif
c2bce675 test/data/bricks-gray.no-ancillary.png
c2bce675 test/data/bricks-gray.png
7aebfe6c test/data/bricks-nodither.bmp
b641fef2 test/data/bricks-nodither.gif
7aebfe6c test/data/bricks-nodither.png
ae2e547d test/data/bricks-nodither.wbmp
b47730a2 test/data/checkerboard.gamma1dot0.png
b47730a2 test/data/checkerboard.gamma2dot2.png
aa3e6c7c test/data/crude-flag.nie
3014b4c0 test/data/gifplayer-muybridge.gif
030f5a48 test/data/harvesters.bmp
0d213dc4 test/data/harvesters.gif
e776c90f test/data/hat.bmp
a161a63a test/data/hat.gif
e776c90f test/data/hat.png
d30bfe5d test/data/hat.wbmp
33a44f22 test/data/hibiscus.primitive.bmp
e948122d test/data/hibiscus.primitive.gif
33a44f22 test/data/hibiscus.primitive.png
60040742 test/data/hibiscus.regular.bmp
7b8dda15 test/data/hibiscus.regular.gif
60040742 test/data/hibiscus.regular.png
dcbb225a test/data/hippopotamus.bmp
21e17862 test/data/hippopotamus.interlaced.gif
dcbb225a test/data/hippopotamus.interlaced.png
a80781a1 test/data/hippopotamus.interlaced.truncated.gif
1f11edb9 test/data/hippopotamus.masked-with-muybridge.gif
7e6acf01 test/data/hippopotamus.masked-with-muybridge.png
dcbb225a test/data/hippopotamus.nie
21e17862 test/data/hippopotamus.regular.gif
dcbb225a test/data/hippopotamus.regular.png
2dccfe56 test/data/muybridge-frame-000.wbmp
db2733f5 test/data/muybridge.apng
db2733f5 test/data/muybridge.gif
bf7e8c96 test/data/pjw-thumbnail.bmp
73d48c08 test/data/pjw-thumbnail.gif
bf7e8c96 test/data/pjw-thumbnail.png
38cb4cbf test/data/red-blue-gradient.dcip3d65-no-chrm-no-gama.png
38cb4cbf test/data/red-blue-gradient.gamma1dot0.png
38cb4cbf test/data/red-blue-gradient.gamma1dot8.png
38cb4cbf test/data/red-blue-gradient.gamma2dot2.png
38cb4cbf test/data/red-blue-gradient.vanilla.png
75060601 test/data/rgb24png.bmp