Compare commits

..
Author SHA1 Message Date
Nigel Tao fab0dd534a release: wuffs gen -version=0.4.0-alpha.5 2024-07-09 12:08:25 +10:00
Nigel Tao 3be81643cc hello-wuffs-c: update endwhile syntax
Also fix lang/check
2024-07-09 10:39:24 +10:00
Nigel Tao 495f0280a8 base: add ETC__I_KNOW_THAT_ETC_BEST_WITH_ARCH_AVX2
Updates #148
2024-07-09 10:34:35 +10:00
Nigel Tao b64a761067 base: enable ETC__CPU_ARCH__X86_64_V2 on MSVC
If I understand the https://github.com/google/wuffs/issues/148
discussion correctly, a user overrode WUFFS_BASE__CPU_ARCH__X86_FAMILY
(without also providing /arch:AVX) to enable SSE4.2 code (even though,
technically, x86_64 doesn't guarantee SSE4.2, only SSE2). This seemed to
work fine in practice, but was unsupported by Wuffs and 'broke' by
fixing #145, now looking for WUFFS_BASE__CPU_ARCH__X86_64 instead of
WUFFS_BASE__CPU_ARCH__X86_FAMILY.

WUFFS_BASE__CPU_ARCH__X86_FAMILY has since been renamed to
WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_FAMILY and then removed entirely.

As SSE4.2 (roughly equivalent to x86-64-v2) seems to work fine at
compile time (with the existing cpuid detection at runtime), enable it
by default for MSVC, without need /arch.

Enabling x86-64-v3 too, by default, is held back for now, pending
further confirmation from MSVC users. The #148 user was exercising
Wuffs' PNG codec, which uses SSE4.2 but not AVX or AVX2. Currently, only
Wuffs' JPEG codec (and YCbCr conversion) uses AVX or AVX2.

GCC and Clang don't need this fiddliness, because they support
"__attribute__((target(arg)))".

Updates #148
2024-07-09 10:25:42 +10:00
Nigel Tao 7a57e2b600 base: remove ETC__CPU_ARCH__X86_FAMILY
Updates #148
2024-07-09 09:33:34 +10:00
Nigel Tao 4111785304 base: have MSVC detect AVX2 not AVX
The x86-64-v3 micro-architecture level requires AVX2.

Updates #148
2024-07-09 09:22:23 +10:00
Nigel Tao affa1e02d4 base: add WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
Updates #148
2024-07-09 09:17:09 +10:00
Nigel Tao 97b727a1ae base: warn defining private implementation macros
Updates #148
2024-07-08 21:08:05 +10:00
Nigel Tao 37a3c3ce9b base: rename WUFFS_BASE__CPU_ARCH__ETC
See
https://github.com/google/wuffs/issues/148#issuecomment-2130535812

Updates #148
2024-07-08 18:14:59 +10:00
Nigel Tao 5d4bb4c6e4 std/bmp: remove superfluous "while.goto_suspend" 2024-07-08 17:23:25 +10:00
Nigel Tao aae5997e12 lang: remove endwhile keyword 2024-07-08 17:15:48 +10:00
Nigel Tao 6c8a43390b test: add webp mimic tests and benches 2024-07-08 15:54:40 +10:00
Nigel Tao 5654506497 base: allow swizzling WebP Lossless to gray 2024-07-08 12:35:40 +10:00
Nigel Tao 00e6e71672 std/webp: implement VP8 Lossless 2024-07-07 22:13:50 +10:00
Nigel Tao 09f4500e19 std/webp: add new package (and vp8 placeholder) 2024-05-10 13:52:07 +10:00
Nigel Tao 16705a1816 test: fix lzip "wuffs mimic cflags" copy/pasto 2024-05-09 15:15:04 +10:00
Nigel Tao 3c1df67681 std/bmp: let decoded pixfmt be transparent
Fixes #147
2024-05-07 10:06:34 +10:00
Nigel Tao c4aa5e60d0 std/xz: enforce BCJ offset alignment 2024-04-29 22:33:51 +10:00
Nigel Tao d446e71e1f check: reject io_bind an io_writer to a roslice 2024-04-25 10:44:42 +10:00
Nigel Tao bf3afab25a check: bounds-check roslice peeks, not just slice 2024-04-23 23:19:25 +10:00
Nigel Tao 92ff96359a std/crc32: re-write x86_sse42 implementation
name                                                       old speed      new speed      delta

wuffs_crc32_ieee_10k/clang14                               13.5GB/s ± 0%  21.9GB/s ± 0%  +62.09%  (p=0.016 n=5+4)
wuffs_crc32_ieee_100k/clang14                              22.4GB/s ± 9%  29.7GB/s ± 0%  +32.76%  (p=0.016 n=5+4)

wuffs_crc32_ieee_10k/gcc12                                 14.2GB/s ± 2%  22.2GB/s ± 0%  +56.92%  (p=0.008 n=5+5)
wuffs_crc32_ieee_100k/gcc12                                21.3GB/s ± 3%  29.6GB/s ± 1%  +39.18%  (p=0.008 n=5+5)

wuffs_gzip_decode_10k/clang14                               366MB/s ± 0%   372MB/s ± 0%   +1.41%  (p=0.008 n=5+5)
wuffs_gzip_decode_100k/clang14                              482MB/s ± 0%   494MB/s ± 0%   +2.57%  (p=0.008 n=5+5)

wuffs_gzip_decode_10k/gcc12                                 398MB/s ± 0%   418MB/s ± 0%   +5.19%  (p=0.008 n=5+5)
wuffs_gzip_decode_100k/gcc12                                510MB/s ± 0%   537MB/s ± 0%   +5.21%  (p=0.008 n=5+5)

wuffs_png_decode_image_19k_8bpp/clang14                     263MB/s ± 0%   264MB/s ± 0%   +0.39%  (p=0.008 n=5+5)
wuffs_png_decode_image_40k_24bpp/clang14                    297MB/s ± 0%   298MB/s ± 0%   +0.16%  (p=0.008 n=5+5)
wuffs_png_decode_image_77k_8bpp/clang14                     932MB/s ± 0%   945MB/s ± 0%   +1.33%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang14   831MB/s ± 0%   833MB/s ± 0%   +0.25%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang14   799MB/s ± 0%   802MB/s ± 0%   +0.37%  (p=0.008 n=5+5)
wuffs_png_decode_image_4002k_24bpp/clang14                  306MB/s ± 0%   307MB/s ± 0%   +0.56%  (p=0.008 n=5+5)

wuffs_png_decode_image_19k_8bpp/gcc12                       283MB/s ± 0%   270MB/s ± 0%   -4.84%  (p=0.008 n=5+5)
wuffs_png_decode_image_40k_24bpp/gcc12                      330MB/s ± 0%   329MB/s ± 0%   -0.29%  (p=0.016 n=5+4)
wuffs_png_decode_image_77k_8bpp/gcc12                       992MB/s ± 0%   957MB/s ± 0%   -3.56%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc12     920MB/s ± 0%   908MB/s ± 0%   -1.30%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc12     875MB/s ± 0%   867MB/s ± 0%   -0.95%  (p=0.008 n=5+5)
wuffs_png_decode_image_4002k_24bpp/gcc12                    341MB/s ± 0%   342MB/s ± 0%   +0.25%  (p=0.008 n=5+5)
2024-04-23 23:10:30 +10:00
Nigel Tao e541e0cf79 std/crc64: re-write x86_sse42 implementation
name                           old speed      new speed       delta

wuffs_crc64_ecma_10k/clang14   5.84GB/s ± 0%  23.43GB/s ± 0%  +301.23%  (p=0.008 n=5+5)
wuffs_crc64_ecma_100k/clang14  6.18GB/s ± 0%  30.23GB/s ± 1%  +389.45%  (p=0.008 n=5+5)

wuffs_crc64_ecma_10k/gcc12     5.87GB/s ± 1%  24.02GB/s ± 0%  +309.21%  (p=0.008 n=5+5)
wuffs_crc64_ecma_100k/gcc12    6.21GB/s ± 0%  30.68GB/s ± 0%  +394.22%  (p=0.008 n=5+5)

$ time example-mzcat < linux-6.8.2.tar.xz > /dev/null
Before: user 0m7.604s
After:  user 0m7.432s
2024-04-22 14:05:16 +10:00
Nigel Tao e1f803324b test: use s/100/300/ digits of pi for crcNN tests 2024-04-22 09:13:22 +10:00
Nigel Tao 58d2a80691 std/crc64: fix x86_sse42 k1' magic number 2024-04-21 22:43:34 +10:00
Nigel Tao 77541659f3 std/crc64: tweak x86 to be more like std/crc32 2024-04-21 22:05:36 +10:00
Nigel Tao 9c704c4a6a std/crc32: tweak x86 to be more like std/crc64 2024-04-21 12:46:05 +10:00
Nigel Tao 5bf4c2cb51 std/lzma: link to "XZ/LZMA Worked Example" blog 2024-04-21 10:00:54 +10:00
Nigel Tao a3bfb57003 release: spin in v0.3.4
This copies wuffs-v0.3.c from the v0.3 branch to the main branch. The
main branch is currently working on an unstable v0.4.

Fixes #146
2024-04-19 21:47:55 +10:00
Nigel Tao da0d51d802 std/png: ignore tRNS chunks for color types 4, 6
Updates #146
2024-04-19 21:31:39 +10:00
97 changed files with 15666 additions and 2273 deletions

No files matched your search

+8
View File
@@ -21,6 +21,8 @@ The LICENSE has changed from a single license (Apache 2) to a dual license
- Added `std/lzma`.
- Added `std/netpbm`.
- Added `std/sha256`.
- Added `std/vp8`.
- Added `std/webp`.
- Added `std/xxhash32`.
- Added `std/xxhash64`.
- Added `std/xz`.
@@ -36,6 +38,7 @@ The LICENSE has changed from a single license (Apache 2) to a dual license
- Let `std/png` decode PNG color type 4 to `PIXEL_FORMAT__YA_NONPREMUL` (two
channels) instead of `PIXEL_FORMAT__BGRA_NONPREMUL` (four channels).
- Removed the `std/gif -> std/lzw` dependency.
- Removed `endwhile` keyword.
- Removed `example/bzcat`.
- Set image decoder pixel width and height inclusive maximum to `0xFF_FFFF`,
down from `0x7FFF_FFFF`.
@@ -54,6 +57,11 @@ code (instead of writing C/C++ code that _uses_ Wuffs' standard library).
a tab).
## 2024-04-19 version 0.3.4
- Have `std/png` ignore tRNS chunks for color types 4 (YA) and 6 (RGBA).
## 2023-04-08 version 0.3.3
The `wuffs_base__parse_number_f64` function has been further optimized.
+2
View File
@@ -64,7 +64,9 @@ to enable.
- `PNG: BASE, ADLER32, CRC32, DEFLATE, ZLIB`
- `SHA256: BASE`
- `TGA: BASE`
- `VP8: BASE`
- `WBMP: BASE`
- `WEBP: BASE, VP8`
- `XXHASH32: BASE`
- `XXHASH64: BASE`
- `XZ: BASE, CRC32, CRC64, LZMA, SHA256`
+1
View File
@@ -131,6 +131,7 @@ In Wuffs syntax, the `base.image_decoder` methods are:
- [std/png](/std/png)
- [std/tga](/std/tga)
- [std/wbmp](/std/wbmp)
- [std/webp](/std/webp)
## Examples
+13
View File
@@ -67,7 +67,9 @@ https://skia-review.googlesource.com/c/skia/+/290618
#define WUFFS_CONFIG__MODULE__NIE
#define WUFFS_CONFIG__MODULE__PNG
#define WUFFS_CONFIG__MODULE__TGA
#define WUFFS_CONFIG__MODULE__VP8
#define WUFFS_CONFIG__MODULE__WBMP
#define WUFFS_CONFIG__MODULE__WEBP
#define WUFFS_CONFIG__MODULE__ZLIB
// Defining the WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST (and the
@@ -164,6 +166,7 @@ union {
wuffs_png__decoder png;
wuffs_tga__decoder tga;
wuffs_wbmp__decoder wbmp;
wuffs_webp__decoder webp;
} g_potential_decoders;
wuffs_crc32__ieee_hasher g_digest_hasher;
@@ -413,6 +416,16 @@ initialize_image_decoder() {
wuffs_wbmp__decoder__upcast_as__wuffs_base__image_decoder(
&g_potential_decoders.wbmp);
return NULL;
case WUFFS_BASE__FOURCC__WEBP:
status = wuffs_webp__decoder__initialize(
&g_potential_decoders.webp, sizeof g_potential_decoders.webp,
WUFFS_VERSION, WUFFS_INITIALIZE__DEFAULT_OPTIONS);
TRY(wuffs_base__status__message(&status));
g_image_decoder =
wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(
&g_potential_decoders.webp);
return NULL;
}
return "main: unsupported file format";
}
+2
View File
@@ -80,7 +80,9 @@ The Escape key quits.
#define WUFFS_CONFIG__MODULE__NIE
#define WUFFS_CONFIG__MODULE__PNG
#define WUFFS_CONFIG__MODULE__TGA
#define WUFFS_CONFIG__MODULE__VP8
#define WUFFS_CONFIG__MODULE__WBMP
#define WUFFS_CONFIG__MODULE__WEBP
#define WUFFS_CONFIG__MODULE__ZLIB
// Defining the WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST (and the
@@ -78,7 +78,9 @@ isn't otherwise doing anything.
#define WUFFS_CONFIG__MODULE__NIE
#define WUFFS_CONFIG__MODULE__PNG
#define WUFFS_CONFIG__MODULE__TGA
#define WUFFS_CONFIG__MODULE__VP8
#define WUFFS_CONFIG__MODULE__WBMP
#define WUFFS_CONFIG__MODULE__WEBP
#define WUFFS_CONFIG__MODULE__ZLIB
// Defining the WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST (and the
+1 -1
View File
@@ -37,7 +37,7 @@ pub func parser.parse?(src: base.io_reader) {
// Uncomment this assertion to see what facts are known here.
// assert false
this.val = (10 * this.val) + (c as base.u32)
} endwhile
}
}
pub func parser.value() base.u32 {
+5
View File
@@ -100,6 +100,11 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
case WUFFS_BASE__FOURCC__WBMP:
return wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();
#endif
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
case WUFFS_BASE__FOURCC__WEBP:
return wuffs_webp__decoder::alloc_as__wuffs_base__image_decoder();
#endif
}
return wuffs_base__image_decoder::unique_ptr(nullptr);
+1
View File
@@ -91,6 +91,7 @@ class DecodeImageCallbacks {
// - WUFFS_BASE__FOURCC__PNG
// - WUFFS_BASE__FOURCC__TGA
// - WUFFS_BASE__FOURCC__WBMP
// - WUFFS_BASE__FOURCC__WEBP
virtual wuffs_base__image_decoder::unique_ptr //
SelectDecoder(uint32_t fourcc,
wuffs_base__slice_u8 prefix_data,
+68 -36
View File
@@ -34,6 +34,34 @@
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0
#define WUFFS_VERSION_STRING "0.0.0+0.00000000"
// ---------------- Private Implementation Macros Re-definition Check
// Users (those who #include the "wuffs-vM.N.c" file) should not define any
// WUFFS_PRIVATE_IMPL__ETC macros, only WUFFS_CONFIG__ETC macros (and
// WUFFS_IMPLEMENTATION). Mucking about with the private implementation macros
// is not supported and may break when upgrading to newer Wuffs versions.
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) || \
defined(WUFFS_PRIVATE_IMPL__HPD__DECIMAL_POINT__RANGE) || \
defined(WUFFS_PRIVATE_IMPL__HPD__DIGITS_PRECISION) || \
defined(WUFFS_PRIVATE_IMPL__HPD__SHIFT__MAX_INCL) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U16) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U32) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U64) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U8)
#if defined(__GNUC__) || defined(__clang__)
#warning "Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported"
#elif defined(_MSC_VER)
#pragma message("Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported")
#endif
#endif
// ---------------- Configuration
// Define WUFFS_CONFIG__AVOID_CPU_ARCH to avoid any code tied to a specific CPU
@@ -60,11 +88,11 @@
// intrinsics. Look for __ARM_FEATURE_CRC32 instead.
#if defined(__ARM_FEATURE_CRC32)
#include <arm_acle.h>
#define WUFFS_BASE__CPU_ARCH__ARM_CRC32
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32
#endif // defined(__ARM_FEATURE_CRC32)
#if defined(__ARM_NEON)
#include <arm_neon.h>
#define WUFFS_BASE__CPU_ARCH__ARM_NEON
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON
#endif // defined(__ARM_NEON)
#endif // defined(__ARM_FEATURE_UNALIGNED) etc
@@ -72,26 +100,32 @@
// 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(__i386__) || defined(__x86_64__)
//
// ----
//
// Technically, we could use the SSE family on 32-bit x86, not just 64-bit x86.
// But some intrinsics don't compile in 32-bit mode. It's not worth the hassle.
// https://github.com/google/wuffs/issues/145
#if defined(__x86_64__)
#if !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#if defined(__x86_64__)
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#endif // !defined(__native_client__)
#endif // defined(__i386__) || defined(__x86_64__)
#endif // defined(__x86_64__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_IX86) || defined(_M_X64)
#if defined(__AVX__) || defined(__clang__)
#if defined(_M_X64)
// We need <intrin.h> for the __cpuid function.
#include <intrin.h>
// That's not enough for X64 SIMD, with clang-cl, if we want to use
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#if defined(__AVX2__) || defined(__clang__)
// intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use
// "__attribute__((target(arg)))" without e.g. "/arch:AVX".
//
// Some web pages suggest that <immintrin.h> is all you need, as it pulls in
@@ -100,24 +134,22 @@
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#if defined(_M_X64)
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(_M_X64)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#else // defined(__AVX__) || defined(__clang__)
#else // defined(__AVX2__) || defined(__clang__)
// clang-cl (which defines both __clang__ and _MSC_VER) supports
// "__attribute__((target(arg)))".
//
// 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
// property of the source file (e.g. a /arch:AVX2 or -mavx2 compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
#if !defined(WUFFS_CONFIG__I_KNOW_THAT_WUFFS_MSVC_PERFORMS_BEST_WITH_ARCH_AVX2)
#pragma message("Wuffs with MSVC+IX86/X64 performs best with /arch:AVX2")
#endif
#endif // defined(__AVX__) || defined(__clang__)
#endif // defined(_M_IX86) || defined(_M_X64)
#endif // defined(__AVX2__) || defined(__clang__)
#endif // defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
@@ -141,20 +173,20 @@
static inline bool //
wuffs_base__cpu_arch__have_arm_crc32(void) {
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
return true;
#else
return false;
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
}
static inline bool //
wuffs_base__cpu_arch__have_arm_neon(void) {
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
return true;
#else
return false;
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
}
static inline bool //
@@ -163,7 +195,7 @@ wuffs_base__cpu_arch__have_x86_avx2(void) {
defined(__AVX2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
@@ -201,9 +233,9 @@ wuffs_base__cpu_arch__have_x86_avx2(void) {
}
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) &&
// defined(__AVX2__)
@@ -214,7 +246,7 @@ wuffs_base__cpu_arch__have_x86_bmi2(void) {
#if defined(__BMI2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
@@ -236,9 +268,9 @@ wuffs_base__cpu_arch__have_x86_bmi2(void) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__BMI2__)
}
@@ -248,7 +280,7 @@ wuffs_base__cpu_arch__have_x86_sse42(void) {
#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
@@ -272,9 +304,9 @@ wuffs_base__cpu_arch__have_x86_sse42(void) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
}
+110 -17
View File
@@ -10,7 +10,7 @@
// ---------------- Pixel Swizzler
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42(uint8_t* dst_ptr,
@@ -45,7 +45,7 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// --------
@@ -881,7 +881,7 @@ wuffs_private_impl__swizzle_swap_rgb_bgr(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42(uint8_t* dst_ptr,
@@ -925,7 +925,7 @@ wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42(uint8_t* dst_ptr,
}
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -3593,7 +3593,7 @@ wuffs_private_impl__swizzle_bgrw__bgrx(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42(uint8_t* dst_ptr,
@@ -3699,7 +3699,7 @@ wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -4457,7 +4457,7 @@ wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over(
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
@@ -4504,7 +4504,7 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -4680,6 +4680,87 @@ wuffs_private_impl__swizzle_xxxxxxxx__y_16be(uint8_t* dst_ptr,
// --------
static uint64_t //
wuffs_private_impl__swizzle_y__bgra_nonpremul__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 =
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0])));
uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__bgrx(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 =
0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__y_16be(uint8_t* dst_ptr,
size_t dst_len,
@@ -4825,7 +4906,7 @@ wuffs_private_impl__pixel_swizzler__prepare__y(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_xxxx__y__x86_sse42;
}
@@ -5296,7 +5377,7 @@ wuffs_private_impl__pixel_swizzler__prepare__bgr(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
}
@@ -5314,7 +5395,7 @@ wuffs_private_impl__pixel_swizzler__prepare__bgr(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
}
@@ -5332,6 +5413,15 @@ wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul(
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_private_impl__swizzle_y__bgra_nonpremul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -5394,7 +5484,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -5589,7 +5679,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -5611,6 +5701,9 @@ wuffs_private_impl__pixel_swizzler__prepare__bgrx(
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
return wuffs_private_impl__swizzle_y__bgrx;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
return wuffs_private_impl__swizzle_bgr_565__bgrx;
@@ -5658,7 +5751,7 @@ wuffs_private_impl__pixel_swizzler__prepare__rgb(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
}
@@ -5675,7 +5768,7 @@ wuffs_private_impl__pixel_swizzler__prepare__rgb(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
}
@@ -5714,7 +5807,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -5830,7 +5923,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -11,7 +11,7 @@
// --------
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static void //
wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2(
@@ -636,5 +636,5 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
return dst_ptr;
}
#endif
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
+5 -5
View File
@@ -10,7 +10,7 @@
// --------
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static void //
wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2(
@@ -47,7 +47,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
bool first_column,
bool last_column);
#endif
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// --------
@@ -1277,7 +1277,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
if (wuffs_base__cpu_arch__have_x86_avx2()) {
conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2;
break;
@@ -1288,7 +1288,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
if (wuffs_base__cpu_arch__have_x86_avx2()) {
conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_rgbx_x86_avx2;
break;
@@ -1338,7 +1338,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
upfuncs[1][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle;
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
#if defined(__GNUC__) && !defined(__clang__)
// Don't use our AVX2 implementation for GCC (but do use it for clang). For
// some unknown reason, GCC performs noticably better on the non-SIMD
+4 -4
View File
@@ -206,14 +206,14 @@ func (g *gen) writeFuncPrototype(b *buffer, n *a.Func) error {
return err
}
if caMacro != "" {
b.printf("#if defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
b.printf("#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__%s)\n", caMacro)
}
if err := g.writeFuncSignature(b, n, wfsCDecl); err != nil {
return err
}
b.writes(";\n")
if caMacro != "" {
b.printf("#endif // defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
b.printf("#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__%s)\n", caMacro)
}
b.writes("\n")
if n.Choosy() {
@@ -237,7 +237,7 @@ func (g *gen) writeFuncImpl(b *buffer, n *a.Func) error {
}
b.printf("// -------- func %s.%s\n\n", g.pkgName, n.QQID().Str(g.tm))
if caMacro != "" {
b.printf("#if defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
b.printf("#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__%s)\n", caMacro)
}
if caAttribute != "" {
b.printf("%s\n", caAttribute)
@@ -277,7 +277,7 @@ func (g *gen) writeFuncImpl(b *buffer, n *a.Func) error {
b.writex(k.bEpilogue)
b.writes("}\n")
if caMacro != "" {
b.printf("#endif // defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
b.printf("#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__%s)\n", caMacro)
}
if caName != "" {
b.printf("// ‼ WUFFS MULTI-FILE SECTION -%s\n", caName)
+4 -11
View File
@@ -245,7 +245,7 @@ func (g *gen) writeStatementChoose(b *buffer, n *a.Choose, depth uint32) error {
conclusive = true
break
}
b.printf("#if defined(WUFFS_BASE__CPU_ARCH__%s)\n"+
b.printf("#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__%s)\n"+
"wuffs_base__cpu_arch__have_%s() ? &%s%s__%s%s :\n"+
"#endif\n",
caMacro, caName, g.pkgPrefix, recv.Str(g.tm), id.Str(g.tm), suffix)
@@ -275,27 +275,20 @@ 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", // See the "X86_FAMILY" comment, below.
"X86_64_V2",
"x86_sse42",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")"
case t.IDX86AVX2:
caMacro, caName, caAttribute =
"X86_64",
"X86_64_V3",
"x86_avx2",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2,avx2\")"
case t.IDX86BMI2:
caMacro, caName, caAttribute =
"X86_64", // See the "X86_FAMILY" comment, below.
"X86_64_V3",
"x86_bmi2",
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"bmi2\")"
}
// "X86_FAMILY" (which covers both 32-bit and 64-bit x86) is
// technically correct, instead of "X86_64". But some intrinsics
// don't compile in 32-bit mode. It's not worth the hassle to
// support 32-bit x86 SIMD, so we gate on "X86_64" instead.
//
// https://github.com/google/wuffs/issues/145
}
}
return caMacro, caName, caAttribute, nil
+1 -1
View File
@@ -1259,7 +1259,7 @@ func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (bounds, e
}
}
} else if recvTyp.Eq(typeExprSliceU8) {
} else if recvTyp.Eq(typeExprSliceU8) || recvTyp.Eq(typeExprRosliceU8) {
if method >= t.IDPeekU8 {
if m := method - t.IDPeekU8; m < t.ID(len(ioMethodAdvances)) {
au := ioMethodAdvances[m]
+1 -1
View File
@@ -86,7 +86,7 @@ func TestCheck(tt *testing.T) {
{
// Redundant, but shows the labeled jump syntax.
continue.label
} endwhile.label
}.label
}
`) + "\n"
+16 -3
View File
@@ -49,8 +49,7 @@ func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, ad
return q.optimizeIOMethodAdvanceExpr(receiver, advanceExpr, update)
}
// Check if receiver looks like "a[i .. j]" where i and j are constants and
// ((j - i) >= advance).
// Check if the receiver looks like "a[i .. j]".
if _, i, j, ok := receiver.IsSlice(); ok {
icv := (*big.Int)(nil)
if i == nil {
@@ -64,11 +63,25 @@ func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, ad
jcv = j.ConstValue()
}
if (icv != nil) && (jcv != nil) {
switch {
case (icv != nil) && (jcv != nil):
// OK if i and j are constants and ((j - i) >= advance).
n := big.NewInt(0).Sub(jcv, icv)
if n.Cmp(advance) >= 0 {
retOK = true
}
case (i != nil) && (j != nil) && (j.Operator() == t.IDXBinaryPlus):
// OK if j is (i + constant) and (constant >= advance).
n := (*big.Int)(nil)
if j.LHS().AsExpr().Eq(i) {
n = j.RHS().AsExpr().ConstValue()
} else if j.RHS().AsExpr().Eq(i) {
n = j.LHS().AsExpr().ConstValue()
}
if n != nil && (n.Cmp(advance) >= 0) {
retOK = true
}
}
}
+5 -2
View File
@@ -163,7 +163,10 @@ func (q *checker) tcheckStatement(n *a.Node) error {
arg1Typ := (*a.TypeExpr)(nil)
switch n.Keyword() {
case t.IDIOBind:
arg1Typ = typeExprSliceU8
arg1Typ = typeExprRosliceU8
if n.IO().MType().Eq(typeExprIOWriter) {
arg1Typ = typeExprSliceU8
}
case t.IDIOForgetHistory:
// No-op.
case t.IDIOLimit:
@@ -173,7 +176,7 @@ func (q *checker) tcheckStatement(n *a.Node) error {
if err := q.tcheckExpr(n.Arg1(), 0); err != nil {
return err
}
if typ := n.Arg1().MType(); !typ.EqIgnoringRefinementsLHSReadOnly(arg1Typ) {
if typ := n.Arg1().MType(); !arg1Typ.EqIgnoringRefinementsLHSReadOnly(typ) {
return fmt.Errorf("check: %s expression %q, of type %q, does not have type %q",
n.Keyword().Str(q.tm), n.Arg1().Str(q.tm), typ.Str(q.tm), arg1Typ.Str(q.tm))
}
+13 -24
View File
@@ -756,24 +756,6 @@ func (p *parser) parseLabel() (t.ID, error) {
return 0, nil
}
func (p *parser) parseEndwhile(label t.ID) bool {
if p.peek1() != t.IDEndwhile {
return false
}
p.src = p.src[1:]
if label != 0 {
if p.peek1() != t.IDDot {
return false
}
p.src = p.src[1:]
if p.peek1() != label {
return false
}
p.src = p.src[1:]
}
return true
}
func (p *parser) parseStatement1() (*a.Node, error) {
x := p.peek1()
if x == t.IDVar {
@@ -930,14 +912,21 @@ func (p *parser) parseStatement1() (*a.Node, error) {
n.SetBody(body)
p.loops.Pop()
if !p.parseEndwhile(label) {
dotLabel := ""
if label != 0 {
dotLabel = "." + label.Str(p.tm)
if label != 0 {
seenDotLabel := false
if p.peek1() == t.IDDot {
p.src = p.src[1:]
if p.peek1() == label {
p.src = p.src[1:]
seenDotLabel = true
}
}
if !seenDotLabel {
return nil, fmt.Errorf(`parse: expected .%s at %s:%d`,
label.Str(p.tm), p.filename, p.line())
}
return nil, fmt.Errorf(`parse: expected endwhile%s at %s:%d`,
dotLabel, p.filename, p.line())
}
if !doubleCurly {
// No-op.
} else if n.HasContinue() {
+19 -21
View File
@@ -375,26 +375,25 @@ const (
IDConst = ID(0xB4)
IDContinue = ID(0xB5)
IDElse = ID(0xB6)
IDEndwhile = ID(0xB7)
IDFunc = ID(0xB8)
IDIOBind = ID(0xB9)
IDIOForgetHistory = ID(0xBA)
IDIOLimit = ID(0xBB)
IDIf = ID(0xBC)
IDImplements = ID(0xBD)
IDInv = ID(0xBE)
IDIterate = ID(0xBF)
IDPost = ID(0xC0)
IDPre = ID(0xC1)
IDPri = ID(0xC2)
IDPub = ID(0xC3)
IDReturn = ID(0xC4)
IDStruct = ID(0xC5)
IDUse = ID(0xC6)
IDVar = ID(0xC7)
IDVia = ID(0xC8)
IDWhile = ID(0xC9)
IDYield = ID(0xCA)
IDFunc = ID(0xB7)
IDIOBind = ID(0xB8)
IDIOForgetHistory = ID(0xB9)
IDIOLimit = ID(0xBA)
IDIf = ID(0xBB)
IDImplements = ID(0xBC)
IDInv = ID(0xBD)
IDIterate = ID(0xBE)
IDPost = ID(0xBF)
IDPre = ID(0xC0)
IDPri = ID(0xC1)
IDPub = ID(0xC2)
IDReturn = ID(0xC3)
IDStruct = ID(0xC4)
IDUse = ID(0xC5)
IDVar = ID(0xC6)
IDVia = ID(0xC7)
IDWhile = ID(0xC8)
IDYield = ID(0xC9)
)
const (
@@ -826,7 +825,6 @@ var builtInsByID = [nBuiltInIDs]string{
IDConst: "const",
IDContinue: "continue",
IDElse: "else",
IDEndwhile: "endwhile",
IDFunc: "func",
IDIOBind: "io_bind",
IDIOForgetHistory: "io_forget_history",
+5696 -626
View File
@@ -90,6 +90,34 @@ extern "C" {
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0
#define WUFFS_VERSION_STRING "0.0.0+0.00000000"
// ---------------- Private Implementation Macros Re-definition Check
// Users (those who #include the "wuffs-vM.N.c" file) should not define any
// WUFFS_PRIVATE_IMPL__ETC macros, only WUFFS_CONFIG__ETC macros (and
// WUFFS_IMPLEMENTATION). Mucking about with the private implementation macros
// is not supported and may break when upgrading to newer Wuffs versions.
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) || \
defined(WUFFS_PRIVATE_IMPL__HPD__DECIMAL_POINT__RANGE) || \
defined(WUFFS_PRIVATE_IMPL__HPD__DIGITS_PRECISION) || \
defined(WUFFS_PRIVATE_IMPL__HPD__SHIFT__MAX_INCL) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U16) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U32) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U64) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U8)
#if defined(__GNUC__) || defined(__clang__)
#warning "Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported"
#elif defined(_MSC_VER)
#pragma message("Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported")
#endif
#endif
// ---------------- Configuration
// Define WUFFS_CONFIG__AVOID_CPU_ARCH to avoid any code tied to a specific CPU
@@ -116,11 +144,11 @@ extern "C" {
// intrinsics. Look for __ARM_FEATURE_CRC32 instead.
#if defined(__ARM_FEATURE_CRC32)
#include <arm_acle.h>
#define WUFFS_BASE__CPU_ARCH__ARM_CRC32
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32
#endif // defined(__ARM_FEATURE_CRC32)
#if defined(__ARM_NEON)
#include <arm_neon.h>
#define WUFFS_BASE__CPU_ARCH__ARM_NEON
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON
#endif // defined(__ARM_NEON)
#endif // defined(__ARM_FEATURE_UNALIGNED) etc
@@ -128,26 +156,32 @@ 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(__i386__) || defined(__x86_64__)
//
// ----
//
// Technically, we could use the SSE family on 32-bit x86, not just 64-bit x86.
// But some intrinsics don't compile in 32-bit mode. It's not worth the hassle.
// https://github.com/google/wuffs/issues/145
#if defined(__x86_64__)
#if !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#if defined(__x86_64__)
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#endif // !defined(__native_client__)
#endif // defined(__i386__) || defined(__x86_64__)
#endif // defined(__x86_64__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_IX86) || defined(_M_X64)
#if defined(__AVX__) || defined(__clang__)
#if defined(_M_X64)
// We need <intrin.h> for the __cpuid function.
#include <intrin.h>
// That's not enough for X64 SIMD, with clang-cl, if we want to use
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#if defined(__AVX2__) || defined(__clang__)
// intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use
// "__attribute__((target(arg)))" without e.g. "/arch:AVX".
//
// Some web pages suggest that <immintrin.h> is all you need, as it pulls in
@@ -156,24 +190,22 @@ extern "C" {
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#if defined(_M_X64)
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(_M_X64)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#else // defined(__AVX__) || defined(__clang__)
#else // defined(__AVX2__) || defined(__clang__)
// clang-cl (which defines both __clang__ and _MSC_VER) supports
// "__attribute__((target(arg)))".
//
// 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
// property of the source file (e.g. a /arch:AVX2 or -mavx2 compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
#if !defined(WUFFS_CONFIG__I_KNOW_THAT_WUFFS_MSVC_PERFORMS_BEST_WITH_ARCH_AVX2)
#pragma message("Wuffs with MSVC+IX86/X64 performs best with /arch:AVX2")
#endif
#endif // defined(__AVX__) || defined(__clang__)
#endif // defined(_M_IX86) || defined(_M_X64)
#endif // defined(__AVX2__) || defined(__clang__)
#endif // defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
@@ -197,20 +229,20 @@ extern "C" {
static inline bool //
wuffs_base__cpu_arch__have_arm_crc32(void) {
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
return true;
#else
return false;
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
}
static inline bool //
wuffs_base__cpu_arch__have_arm_neon(void) {
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
return true;
#else
return false;
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
}
static inline bool //
@@ -219,7 +251,7 @@ wuffs_base__cpu_arch__have_x86_avx2(void) {
defined(__AVX2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
@@ -257,9 +289,9 @@ wuffs_base__cpu_arch__have_x86_avx2(void) {
}
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) &&
// defined(__AVX2__)
@@ -270,7 +302,7 @@ wuffs_base__cpu_arch__have_x86_bmi2(void) {
#if defined(__BMI2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
@@ -292,9 +324,9 @@ wuffs_base__cpu_arch__have_x86_bmi2(void) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__BMI2__)
}
@@ -304,7 +336,7 @@ wuffs_base__cpu_arch__have_x86_sse42(void) {
#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
@@ -328,9 +360,9 @@ wuffs_base__cpu_arch__have_x86_sse42(void) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
}
@@ -13249,6 +13281,140 @@ struct wuffs_tga__decoder__struct {
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
// ---------------- Public Consts
// ---------------- Struct Declarations
typedef struct wuffs_vp8__placeholder__struct wuffs_vp8__placeholder;
#ifdef __cplusplus
extern "C" {
#endif
// ---------------- Public Initializer Prototypes
// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self,
// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
//
// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_vp8__placeholder__initialize(
wuffs_vp8__placeholder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options);
size_t
sizeof__wuffs_vp8__placeholder(void);
// ---------------- Allocs
// These functions allocate and initialize Wuffs structs. They return NULL if
// memory allocation fails. If they return non-NULL, there is no need to call
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
// calling free on the returned pointer. That pointer is effectively a C++
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
wuffs_vp8__placeholder*
wuffs_vp8__placeholder__alloc(void);
// ---------------- Upcasts
// ---------------- Public Function Prototypes
#ifdef __cplusplus
} // extern "C"
#endif
// ---------------- Struct Definitions
// These structs' fields, and the sizeof them, are private implementation
// details that aren't guaranteed to be stable across Wuffs versions.
//
// See https://en.wikipedia.org/wiki/Opaque_pointer#C
#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
struct wuffs_vp8__placeholder__struct {
// Do not access the private_impl's or private_data's fields directly. There
// is no API/ABI compatibility or safety guarantee if you do so. Instead, use
// the wuffs_foo__bar__baz functions.
//
// It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
// can be stack allocated when WUFFS_IMPLEMENTATION is defined.
struct {
uint32_t magic;
uint32_t active_coroutine;
wuffs_base__vtable null_vtable;
uint32_t f_placeholder;
} private_impl;
#ifdef __cplusplus
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
using unique_ptr = std::unique_ptr<wuffs_vp8__placeholder, wuffs_unique_ptr_deleter>;
// On failure, the alloc_etc functions return nullptr. They don't throw.
static inline unique_ptr
alloc() {
return unique_ptr(wuffs_vp8__placeholder__alloc());
}
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
// Disallow constructing or copying an object via standard C++ mechanisms,
// e.g. the "new" operator, as this struct is intentionally opaque. Its total
// size and field layout is not part of the public, stable, memory-safe API.
// Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and
// call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as
// their first argument) rather than tweaking bar.private_impl.qux fields.
//
// In C, we can just leave wuffs_foo__bar as an incomplete type (unless
// WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in
// order to provide convenience methods. These forward on "this", so that you
// can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)".
wuffs_vp8__placeholder__struct() = delete;
wuffs_vp8__placeholder__struct(const wuffs_vp8__placeholder__struct&) = delete;
wuffs_vp8__placeholder__struct& operator=(
const wuffs_vp8__placeholder__struct&) = delete;
#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
#if !defined(WUFFS_IMPLEMENTATION)
// As above, the size of the struct is not part of the public API, and unless
// WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap
// allocated, not stack allocated. Its size is not intended to be known at
// compile time, but it is unfortunately divulged as a side effect of
// defining C++ convenience methods. Use "sizeof__T()", calling the function,
// instead of "sizeof T", invoking the operator. To make the two values
// different, so that passing the latter will be rejected by the initialize
// function, we add an arbitrary amount of dead weight.
uint8_t dead_weight[123000000]; // 123 MB.
#endif // !defined(WUFFS_IMPLEMENTATION)
inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
initialize(
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options) {
return wuffs_vp8__placeholder__initialize(
this, sizeof_star_self, wuffs_version, options);
}
#endif // __cplusplus
}; // struct wuffs_vp8__placeholder__struct
#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
@@ -13604,6 +13770,458 @@ struct wuffs_wbmp__decoder__struct {
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
extern const char wuffs_webp__error__bad_huffman_code_over_subscribed[];
extern const char wuffs_webp__error__bad_huffman_code_under_subscribed[];
extern const char wuffs_webp__error__bad_huffman_code[];
extern const char wuffs_webp__error__bad_back_reference[];
extern const char wuffs_webp__error__bad_color_cache[];
extern const char wuffs_webp__error__bad_header[];
extern const char wuffs_webp__error__bad_transform[];
extern const char wuffs_webp__error__short_chunk[];
extern const char wuffs_webp__error__truncated_input[];
extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[];
extern const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[];
extern const char wuffs_webp__error__unsupported_webp_file[];
// ---------------- Public Consts
#define WUFFS_WEBP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u
// ---------------- Struct Declarations
typedef struct wuffs_webp__decoder__struct wuffs_webp__decoder;
#ifdef __cplusplus
extern "C" {
#endif
// ---------------- Public Initializer Prototypes
// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self,
// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
//
// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_webp__decoder__initialize(
wuffs_webp__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options);
size_t
sizeof__wuffs_webp__decoder(void);
// ---------------- Allocs
// These functions allocate and initialize Wuffs structs. They return NULL if
// memory allocation fails. If they return non-NULL, there is no need to call
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
// calling free on the returned pointer. That pointer is effectively a C++
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
wuffs_webp__decoder*
wuffs_webp__decoder__alloc(void);
static inline wuffs_base__image_decoder*
wuffs_webp__decoder__alloc_as__wuffs_base__image_decoder(void) {
return (wuffs_base__image_decoder*)(wuffs_webp__decoder__alloc());
}
// ---------------- Upcasts
static inline wuffs_base__image_decoder*
wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(
wuffs_webp__decoder* p) {
return (wuffs_base__image_decoder*)p;
}
// ---------------- Public Function Prototypes
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__get_quirk(
const wuffs_webp__decoder* self,
uint32_t a_key);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__set_quirk(
wuffs_webp__decoder* self,
uint32_t a_key,
uint64_t a_value);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32
wuffs_webp__decoder__frame_dirty_rect(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_webp__decoder__num_animation_loops(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frame_configs(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frames(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__restart_frame(
wuffs_webp__decoder* self,
uint64_t a_index,
uint64_t a_io_position);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_webp__decoder__set_report_metadata(
wuffs_webp__decoder* self,
uint32_t a_fourcc,
bool a_report);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__tell_me_more(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
wuffs_webp__decoder__workbuf_len(
const wuffs_webp__decoder* self);
#ifdef __cplusplus
} // extern "C"
#endif
// ---------------- Struct Definitions
// These structs' fields, and the sizeof them, are private implementation
// details that aren't guaranteed to be stable across Wuffs versions.
//
// See https://en.wikipedia.org/wiki/Opaque_pointer#C
#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
struct wuffs_webp__decoder__struct {
// Do not access the private_impl's or private_data's fields directly. There
// is no API/ABI compatibility or safety guarantee if you do so. Instead, use
// the wuffs_foo__bar__baz functions.
//
// It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
// can be stack allocated when WUFFS_IMPLEMENTATION is defined.
struct {
uint32_t magic;
uint32_t active_coroutine;
wuffs_base__vtable vtable_for__wuffs_base__image_decoder;
wuffs_base__vtable null_vtable;
uint32_t f_pixfmt;
uint32_t f_width;
uint32_t f_height;
uint8_t f_call_sequence;
uint8_t f_code_length_code_lengths[19];
bool f_sub_chunk_has_padding;
uint64_t f_frame_config_io_position;
uint32_t f_riff_chunk_length;
uint32_t f_sub_chunk_length;
uint32_t f_bits;
uint32_t f_n_bits;
bool f_seen_transform[4];
uint8_t f_transform_type[4];
uint8_t f_transform_tile_size_log2[4];
uint32_t f_n_transforms;
uint32_t f_color_cache_bits;
uint32_t f_overall_color_cache_bits;
uint32_t f_overall_tile_size_log2;
uint32_t f_overall_n_huffman_groups;
uint32_t f_ht_n_symbols;
uint32_t f_ht_code_lengths_remaining;
uint32_t f_color_indexing_palette_size;
uint32_t f_color_indexing_width;
uint32_t f_workbuf_offset_for_transform[4];
uint32_t f_workbuf_offset_for_color_indexing;
wuffs_base__pixel_swizzler f_swizzler;
uint32_t p_decode_huffman_groups;
uint32_t p_decode_huffman_tree;
uint32_t p_decode_huffman_tree_simple;
uint32_t p_decode_code_length_code_lengths;
uint32_t p_build_code_lengths;
uint32_t p_decode_pixels_slow;
uint32_t p_decode_image_config;
uint32_t p_do_decode_image_config;
uint32_t p_do_decode_image_config_limited;
uint32_t p_do_decode_image_config_limited_vp8l;
uint32_t p_decode_frame_config;
uint32_t p_do_decode_frame_config;
uint32_t p_decode_frame;
uint32_t p_do_decode_frame;
uint32_t p_decode_transform;
uint32_t p_decode_color_cache_parameters;
uint32_t p_decode_hg_table;
uint32_t p_decode_pixels;
} private_impl;
struct {
uint8_t f_palette[1024];
uint32_t f_color_cache[2048];
uint16_t f_codes[2328];
uint16_t f_code_lengths[2328];
uint16_t f_code_lengths_huffman_nodes[37];
uint16_t f_huffman_nodes[256][6267];
struct {
uint32_t v_hg;
uint32_t v_ht;
} s_decode_huffman_groups;
struct {
uint32_t v_use_second_symbol;
uint32_t v_first_symbol_n_bits;
uint32_t v_symbol0;
uint32_t v_base_offset;
} s_decode_huffman_tree_simple;
struct {
uint32_t v_n_codes;
uint32_t v_i;
} s_decode_code_length_code_lengths;
struct {
uint32_t v_length_n_bits;
uint16_t v_prev_code_length;
uint32_t v_s;
uint32_t v_s_max;
uint16_t v_node;
uint16_t v_repeat_value;
uint32_t v_repeat_n_bits;
} s_build_code_lengths;
struct {
uint64_t v_p;
uint64_t v_p_max;
uint32_t v_tile_size_log2;
uint32_t v_width_in_tiles;
uint32_t v_x;
uint32_t v_y;
uint32_t v_hg;
uint16_t v_node;
uint32_t v_color;
uint32_t v_back_ref_len_n_bits;
uint32_t v_back_ref_len_minus_1;
uint32_t v_back_ref_dist_n_bits;
uint32_t v_back_ref_dist_premap_minus_1;
uint64_t v_color_cache_p;
} s_decode_pixels_slow;
struct {
uint64_t scratch;
} s_do_decode_image_config;
struct {
uint64_t scratch;
} s_do_decode_image_config_limited;
struct {
uint64_t scratch;
} s_do_decode_image_config_limited_vp8l;
struct {
uint32_t v_width;
} s_do_decode_frame;
struct {
uint32_t v_transform_type;
uint32_t v_tile_size_log2;
} s_decode_transform;
struct {
uint32_t v_tile_size_log2;
} s_decode_hg_table;
} private_data;
#ifdef __cplusplus
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
using unique_ptr = std::unique_ptr<wuffs_webp__decoder, wuffs_unique_ptr_deleter>;
// On failure, the alloc_etc functions return nullptr. They don't throw.
static inline unique_ptr
alloc() {
return unique_ptr(wuffs_webp__decoder__alloc());
}
static inline wuffs_base__image_decoder::unique_ptr
alloc_as__wuffs_base__image_decoder() {
return wuffs_base__image_decoder::unique_ptr(
wuffs_webp__decoder__alloc_as__wuffs_base__image_decoder());
}
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
// Disallow constructing or copying an object via standard C++ mechanisms,
// e.g. the "new" operator, as this struct is intentionally opaque. Its total
// size and field layout is not part of the public, stable, memory-safe API.
// Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and
// call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as
// their first argument) rather than tweaking bar.private_impl.qux fields.
//
// In C, we can just leave wuffs_foo__bar as an incomplete type (unless
// WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in
// order to provide convenience methods. These forward on "this", so that you
// can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)".
wuffs_webp__decoder__struct() = delete;
wuffs_webp__decoder__struct(const wuffs_webp__decoder__struct&) = delete;
wuffs_webp__decoder__struct& operator=(
const wuffs_webp__decoder__struct&) = delete;
#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
#if !defined(WUFFS_IMPLEMENTATION)
// As above, the size of the struct is not part of the public API, and unless
// WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap
// allocated, not stack allocated. Its size is not intended to be known at
// compile time, but it is unfortunately divulged as a side effect of
// defining C++ convenience methods. Use "sizeof__T()", calling the function,
// instead of "sizeof T", invoking the operator. To make the two values
// different, so that passing the latter will be rejected by the initialize
// function, we add an arbitrary amount of dead weight.
uint8_t dead_weight[123000000]; // 123 MB.
#endif // !defined(WUFFS_IMPLEMENTATION)
inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
initialize(
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options) {
return wuffs_webp__decoder__initialize(
this, sizeof_star_self, wuffs_version, options);
}
inline wuffs_base__image_decoder*
upcast_as__wuffs_base__image_decoder() {
return (wuffs_base__image_decoder*)this;
}
inline uint64_t
get_quirk(
uint32_t a_key) const {
return wuffs_webp__decoder__get_quirk(this, a_key);
}
inline wuffs_base__status
set_quirk(
uint32_t a_key,
uint64_t a_value) {
return wuffs_webp__decoder__set_quirk(this, a_key, a_value);
}
inline wuffs_base__status
decode_image_config(
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
return wuffs_webp__decoder__decode_image_config(this, a_dst, a_src);
}
inline wuffs_base__status
decode_frame_config(
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
return wuffs_webp__decoder__decode_frame_config(this, a_dst, a_src);
}
inline wuffs_base__status
decode_frame(
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
return wuffs_webp__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts);
}
inline wuffs_base__rect_ie_u32
frame_dirty_rect() const {
return wuffs_webp__decoder__frame_dirty_rect(this);
}
inline uint32_t
num_animation_loops() const {
return wuffs_webp__decoder__num_animation_loops(this);
}
inline uint64_t
num_decoded_frame_configs() const {
return wuffs_webp__decoder__num_decoded_frame_configs(this);
}
inline uint64_t
num_decoded_frames() const {
return wuffs_webp__decoder__num_decoded_frames(this);
}
inline wuffs_base__status
restart_frame(
uint64_t a_index,
uint64_t a_io_position) {
return wuffs_webp__decoder__restart_frame(this, a_index, a_io_position);
}
inline wuffs_base__empty_struct
set_report_metadata(
uint32_t a_fourcc,
bool a_report) {
return wuffs_webp__decoder__set_report_metadata(this, a_fourcc, a_report);
}
inline wuffs_base__status
tell_me_more(
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src) {
return wuffs_webp__decoder__tell_me_more(this, a_dst, a_minfo, a_src);
}
inline wuffs_base__range_ii_u64
workbuf_len() const {
return wuffs_webp__decoder__workbuf_len(this);
}
#endif // __cplusplus
}; // struct wuffs_webp__decoder__struct
#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__XXHASH32) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
@@ -14061,6 +14679,7 @@ struct wuffs_xxhash64__hasher__struct {
// ---------------- Status Codes
extern const char wuffs_xz__error__bad_bcj_offset[];
extern const char wuffs_xz__error__bad_block_header[];
extern const char wuffs_xz__error__bad_checksum[];
extern const char wuffs_xz__error__bad_filter[];
@@ -14250,6 +14869,7 @@ struct wuffs_xz__decoder__struct {
} s_decode_block_header_with_padding;
struct {
uint8_t v_flags;
uint8_t v_filter_id;
uint32_t v_shift;
uint32_t v_f;
uint64_t scratch;
@@ -14671,6 +15291,7 @@ class DecodeImageCallbacks {
// - WUFFS_BASE__FOURCC__PNG
// - WUFFS_BASE__FOURCC__TGA
// - WUFFS_BASE__FOURCC__WBMP
// - WUFFS_BASE__FOURCC__WEBP
virtual wuffs_base__image_decoder::unique_ptr //
SelectDecoder(uint32_t fourcc,
wuffs_base__slice_u8 prefix_data,
@@ -21042,7 +21663,7 @@ match:
// ---------------- Pixel Swizzler
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42(uint8_t* dst_ptr,
@@ -21077,7 +21698,7 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// --------
@@ -21913,7 +22534,7 @@ wuffs_private_impl__swizzle_swap_rgb_bgr(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42(uint8_t* dst_ptr,
@@ -21957,7 +22578,7 @@ wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42(uint8_t* dst_ptr,
}
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -24625,7 +25246,7 @@ wuffs_private_impl__swizzle_bgrw__bgrx(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42(uint8_t* dst_ptr,
@@ -24731,7 +25352,7 @@ wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -25489,7 +26110,7 @@ wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over(
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
@@ -25536,7 +26157,7 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -25712,6 +26333,87 @@ wuffs_private_impl__swizzle_xxxxxxxx__y_16be(uint8_t* dst_ptr,
// --------
static uint64_t //
wuffs_private_impl__swizzle_y__bgra_nonpremul__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 =
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0])));
uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__bgrx(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 =
0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__y_16be(uint8_t* dst_ptr,
size_t dst_len,
@@ -25857,7 +26559,7 @@ wuffs_private_impl__pixel_swizzler__prepare__y(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_xxxx__y__x86_sse42;
}
@@ -26328,7 +27030,7 @@ wuffs_private_impl__pixel_swizzler__prepare__bgr(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
}
@@ -26346,7 +27048,7 @@ wuffs_private_impl__pixel_swizzler__prepare__bgr(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
}
@@ -26364,6 +27066,15 @@ wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul(
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_private_impl__swizzle_y__bgra_nonpremul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -26426,7 +27137,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -26621,7 +27332,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -26643,6 +27354,9 @@ wuffs_private_impl__pixel_swizzler__prepare__bgrx(
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
return wuffs_private_impl__swizzle_y__bgrx;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
return wuffs_private_impl__swizzle_bgr_565__bgrx;
@@ -26690,7 +27404,7 @@ wuffs_private_impl__pixel_swizzler__prepare__rgb(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
}
@@ -26707,7 +27421,7 @@ wuffs_private_impl__pixel_swizzler__prepare__rgb(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
}
@@ -26746,7 +27460,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -26862,7 +27576,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -27150,7 +27864,7 @@ wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(
// --------
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static void //
wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2(
@@ -27187,7 +27901,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
bool first_column,
bool last_column);
#endif
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// --------
@@ -28417,7 +29131,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
if (wuffs_base__cpu_arch__have_x86_avx2()) {
conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2;
break;
@@ -28428,7 +29142,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
if (wuffs_base__cpu_arch__have_x86_avx2()) {
conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_rgbx_x86_avx2;
break;
@@ -28478,7 +29192,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
upfuncs[1][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle;
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
#if defined(__GNUC__) && !defined(__clang__)
// Don't use our AVX2 implementation for GCC (but do use it for clang). For
// some unknown reason, GCC performs noticably better on the non-SIMD
@@ -28530,7 +29244,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
// --------
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static void //
wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2(
@@ -29155,7 +29869,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
return dst_ptr;
}
#endif
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
#endif // !defined(WUFFS_CONFIG__MODULES) ||
@@ -29409,21 +30123,21 @@ wuffs_adler32__hasher__up__choosy_default(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_arm_neon(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ---------------- VTables
@@ -29571,10 +30285,10 @@ wuffs_adler32__hasher__update(
self->private_impl.f_started = true;
self->private_impl.f_state = 1u;
self->private_impl.choosy_up = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_adler32__hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -29697,7 +30411,7 @@ wuffs_adler32__hasher__checksum_u32(
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func adler32.hasher.up_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_arm_neon(
@@ -29798,13 +30512,13 @@ wuffs_adler32__hasher__up_arm_neon(
self->private_impl.f_state = (((v_s2 & 65535u) << 16u) | (v_s1 & 65535u));
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -29891,7 +30605,7 @@ wuffs_adler32__hasher__up_x86_sse42(
self->private_impl.f_state = (((v_s2 & 65535u) << 16u) | (v_s1 & 65535u));
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32)
@@ -31114,6 +31828,8 @@ wuffs_bmp__decoder__do_decode_image_config(
(self->private_impl.f_channel_num_bits[2u] > 8u) ||
(self->private_impl.f_channel_num_bits[3u] > 8u)) {
v_dst_pixfmt = 2164308923u;
} else if (((self->private_impl.f_src_pixfmt == 2198077448u) || (self->private_impl.f_src_pixfmt == 2147485832u) || (self->private_impl.f_src_pixfmt == 2415954056u)) || ((self->private_impl.f_src_pixfmt == 2164308923u) && (self->private_impl.f_channel_masks[3u] == 0u))) {
v_dst_pixfmt = 2415954056u;
}
wuffs_base__image_config__set(
a_dst,
@@ -31722,138 +32438,160 @@ wuffs_bmp__decoder__swizzle_rle(
v_dst = wuffs_base__utility__empty_slice_u8();
}
while (true) {
while (true) {
if (v_rle_state == 0u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (v_code == 0u) {
v_rle_state = 2u;
continue;
}
self->private_impl.f_rle_length = ((uint32_t)(v_code));
v_rle_state = 1u;
continue;
} else if (v_rle_state == 1u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_bits_per_pixel == 8u) {
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[v_p0] = v_code;
v_p0 += 1u;
}
} else {
v_indexes[0u] = ((uint8_t)(((uint8_t)(v_code >> 4u))));
v_indexes[1u] = ((uint8_t)(v_code & 15u));
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[(v_p0 + 0u)] = v_indexes[0u];
self->private_data.f_scratch[(v_p0 + 1u)] = v_indexes[1u];
v_p0 += 2u;
}
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, self->private_impl.f_rle_length));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, self->private_impl.f_rle_length);
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 2u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (v_code < 2u) {
if ((self->private_impl.f_dst_y >= self->private_impl.f_height) && (v_code == 0u)) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, 18446744073709551615u);
self->private_impl.f_dst_x = 0u;
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (v_code > 0u) {
goto label__outer__break;
}
v_rle_state = 0u;
goto label__outer__continue;
} else if (v_code == 2u) {
v_rle_state = 4u;
continue;
}
self->private_impl.f_rle_length = ((uint32_t)(v_code));
self->private_impl.f_rle_padded = ((self->private_impl.f_bits_per_pixel == 8u) && (((uint8_t)(v_code & 1u)) != 0u));
v_rle_state = 3u;
continue;
} else if (v_rle_state == 3u) {
if (self->private_impl.f_bits_per_pixel == 8u) {
v_n = wuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(
&self->private_impl.f_swizzler,
self->private_impl.f_rle_length,
v_dst,
v_dst_palette,
&iop_a_src,
io2_a_src);
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(v_n)));
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, ((uint32_t)(v_n)));
} else {
v_chunk_count = ((self->private_impl.f_rle_length + 3u) / 4u);
v_p0 = 0u;
while ((v_chunk_count > 0u) && (((uint64_t)(io2_a_src - iop_a_src)) >= 2u)) {
v_chunk_bits = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2u;
self->private_data.f_scratch[(v_p0 + 0u)] = ((uint8_t)((15u & (v_chunk_bits >> 12u))));
self->private_data.f_scratch[(v_p0 + 1u)] = ((uint8_t)((15u & (v_chunk_bits >> 8u))));
self->private_data.f_scratch[(v_p0 + 2u)] = ((uint8_t)((15u & (v_chunk_bits >> 4u))));
self->private_data.f_scratch[(v_p0 + 3u)] = ((uint8_t)((15u & (v_chunk_bits >> 0u))));
v_p0 = ((v_p0 & 255u) + 4u);
v_chunk_count -= 1u;
}
v_p0 = wuffs_base__u32__min(v_p0, self->private_impl.f_rle_length);
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, v_p0));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_p0);
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, v_p0);
}
if (self->private_impl.f_rle_length > 0u) {
goto label__goto_suspend__break;
}
if (self->private_impl.f_rle_padded) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
iop_a_src += 1u;
self->private_impl.f_rle_padded = false;
}
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 4u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
self->private_impl.f_rle_delta_x = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
v_rle_state = 5u;
continue;
}
if (v_rle_state == 0u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_rle_delta_x > 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, ((uint64_t)(self->private_impl.f_rle_delta_x)));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(self->private_impl.f_rle_delta_x)));
self->private_impl.f_rle_delta_x = 0u;
if (self->private_impl.f_dst_x > self->private_impl.f_width) {
if (v_code == 0u) {
v_rle_state = 2u;
continue;
}
self->private_impl.f_rle_length = ((uint32_t)(v_code));
v_rle_state = 1u;
continue;
} else if (v_rle_state == 1u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_bits_per_pixel == 8u) {
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[v_p0] = v_code;
v_p0 += 1u;
}
} else {
v_indexes[0u] = ((uint8_t)(((uint8_t)(v_code >> 4u))));
v_indexes[1u] = ((uint8_t)(v_code & 15u));
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[(v_p0 + 0u)] = v_indexes[0u];
self->private_data.f_scratch[(v_p0 + 1u)] = v_indexes[1u];
v_p0 += 2u;
}
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, self->private_impl.f_rle_length));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, self->private_impl.f_rle_length);
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 2u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (v_code < 2u) {
if ((self->private_impl.f_dst_y >= self->private_impl.f_height) && (v_code == 0u)) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, 18446744073709551615u);
self->private_impl.f_dst_x = 0u;
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (v_code > 0u) {
goto label__outer__break;
}
v_rle_state = 0u;
goto label__outer__continue;
} else if (v_code == 2u) {
v_rle_state = 4u;
continue;
}
if (v_code > 0u) {
self->private_impl.f_rle_length = ((uint32_t)(v_code));
self->private_impl.f_rle_padded = ((self->private_impl.f_bits_per_pixel == 8u) && (((uint8_t)(v_code & 1u)) != 0u));
v_rle_state = 3u;
continue;
} else if (v_rle_state == 3u) {
if (self->private_impl.f_bits_per_pixel == 8u) {
v_n = wuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(
&self->private_impl.f_swizzler,
self->private_impl.f_rle_length,
v_dst,
v_dst_palette,
&iop_a_src,
io2_a_src);
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(v_n)));
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, ((uint32_t)(v_n)));
} else {
v_chunk_count = ((self->private_impl.f_rle_length + 3u) / 4u);
v_p0 = 0u;
while ((v_chunk_count > 0u) && (((uint64_t)(io2_a_src - iop_a_src)) >= 2u)) {
v_chunk_bits = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2u;
self->private_data.f_scratch[(v_p0 + 0u)] = ((uint8_t)((15u & (v_chunk_bits >> 12u))));
self->private_data.f_scratch[(v_p0 + 1u)] = ((uint8_t)((15u & (v_chunk_bits >> 8u))));
self->private_data.f_scratch[(v_p0 + 2u)] = ((uint8_t)((15u & (v_chunk_bits >> 4u))));
self->private_data.f_scratch[(v_p0 + 3u)] = ((uint8_t)((15u & (v_chunk_bits >> 0u))));
v_p0 = ((v_p0 & 255u) + 4u);
v_chunk_count -= 1u;
}
v_p0 = wuffs_base__u32__min(v_p0, self->private_impl.f_rle_length);
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, v_p0));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_p0);
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, v_p0);
}
if (self->private_impl.f_rle_length > 0u) {
break;
}
if (self->private_impl.f_rle_padded) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
iop_a_src += 1u;
self->private_impl.f_rle_padded = false;
}
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 4u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
self->private_impl.f_rle_delta_x = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
v_rle_state = 5u;
continue;
}
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_rle_delta_x > 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, ((uint64_t)(self->private_impl.f_rle_delta_x)));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(self->private_impl.f_rle_delta_x)));
self->private_impl.f_rle_delta_x = 0u;
if (self->private_impl.f_dst_x > self->private_impl.f_width) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
}
if (v_code > 0u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_code -= 1u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
while (true) {
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
v_row = wuffs_private_impl__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);
}
if (v_code <= 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, ((uint64_t)(self->private_impl.f_dst_x)));
break;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, 18446744073709551615u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
@@ -31862,36 +32600,11 @@ wuffs_bmp__decoder__swizzle_rle(
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
while (true) {
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
v_row = wuffs_private_impl__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);
}
if (v_code <= 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, ((uint64_t)(self->private_impl.f_dst_x)));
break;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, 18446744073709551615u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_code -= 1u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
}
v_rle_state = 0u;
goto label__middle__continue;
}
v_rle_state = 0u;
goto label__middle__continue;
}
label__goto_suspend__break:;
self->private_impl.f_rle_state = v_rle_state;
status = wuffs_base__make_status(wuffs_bmp__note__internal_note_short_read);
goto ok;
@@ -35634,30 +36347,6 @@ WUFFS_CRC32__IEEE_TABLE[16][256] WUFFS_BASE__POTENTIALLY_UNUSED = {
},
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_K1K2[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
212u, 43u, 68u, 84u, 1u, 0u, 0u, 0u,
150u, 21u, 228u, 198u, 1u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_K3K4[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
208u, 151u, 25u, 117u, 1u, 0u, 0u, 0u,
158u, 0u, 170u, 204u, 0u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
36u, 97u, 205u, 99u, 1u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_PXMU[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
65u, 6u, 113u, 219u, 1u, 0u, 0u, 0u,
65u, 22u, 1u, 247u, 1u, 0u, 0u, 0u,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -35674,29 +36363,21 @@ wuffs_crc32__ieee_hasher__up__choosy_default(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_arm_crc32(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ---------------- VTables
@@ -35842,13 +36523,10 @@ wuffs_crc32__ieee_hasher__update(
if (self->private_impl.f_state == 0u) {
self->private_impl.choosy_up = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
wuffs_base__cpu_arch__have_arm_crc32() ? &wuffs_crc32__ieee_hasher__up_arm_crc32 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -36000,7 +36678,7 @@ wuffs_crc32__ieee_hasher__checksum_u32(
// ‼ WUFFS MULTI-FILE SECTION +arm_crc32
// -------- func crc32.ieee_hasher.up_arm_crc32
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_arm_crc32(
@@ -36070,133 +36748,13 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
// ‼ WUFFS MULTI-FILE SECTION -arm_crc32
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func crc32.ieee_hasher.up_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
uint32_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_k = {0};
__m128i v_x0 = {0};
__m128i v_x1 = {0};
__m128i v_x2 = {0};
__m128i v_x3 = {0};
__m128i v_y0 = {0};
__m128i v_y1 = {0};
__m128i v_y2 = {0};
__m128i v_y3 = {0};
uint64_t v_tail_index = 0;
v_s = (4294967295u ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0u) && ((15u & ((uint32_t)(0xFFFu & (uintptr_t)(a_x.ptr)))) != 0u)) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
if (((uint64_t)(a_x.len)) < 64u) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K1K2));
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, 64u);
v_p.ptr = i_slice_p.ptr;
v_p.len = 64;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 64) * 64));
while (v_p.ptr < i_end0_p) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_y1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(0u));
v_y3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(17u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(17u));
v_x3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(_mm_xor_si128(v_x0, v_y0), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 0u)));
v_x1 = _mm_xor_si128(_mm_xor_si128(v_x1, v_y1), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16u)));
v_x2 = _mm_xor_si128(_mm_xor_si128(v_x2, v_y2), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 32u)));
v_x3 = _mm_xor_si128(_mm_xor_si128(v_x3, v_y3), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 48u)));
v_p.ptr += 64;
}
v_p.len = 0;
}
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K3K4));
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x3);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_x1 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(16u));
v_x2 = _mm_set_epi32((int32_t)(0u), (int32_t)(4294967295u), (int32_t)(0u), (int32_t)(4294967295u));
v_x0 = _mm_srli_si128(v_x0, (int32_t)(8u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ));
v_x1 = _mm_srli_si128(v_x0, (int32_t)(4u));
v_x0 = _mm_and_si128(v_x0, v_x2);
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_PXMU));
v_x1 = _mm_and_si128(v_x0, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(16u));
v_x1 = _mm_and_si128(v_x1, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_s = ((uint32_t)(_mm_extract_epi32(v_x0, (int32_t)(1u))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551552u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc32.ieee_hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -36204,113 +36762,125 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
uint32_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_k = {0};
__m128i v_kk = {0};
__m128i v_x0 = {0};
__m128i v_x1 = {0};
__m128i v_x2 = {0};
__m128i v_x3 = {0};
__m128i v_x4 = {0};
__m128i v_x5 = {0};
__m128i v_x6 = {0};
__m128i v_x7 = {0};
__m128i v_y0 = {0};
__m128i v_y1 = {0};
__m128i v_y2 = {0};
__m128i v_y3 = {0};
uint64_t v_tail_index = 0;
__m128i v_y4 = {0};
__m128i v_y5 = {0};
__m128i v_y6 = {0};
__m128i v_y7 = {0};
v_s = (4294967295u ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0u) && ((15u & ((uint32_t)(0xFFFu & (uintptr_t)(a_x.ptr)))) != 0u)) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
if (((uint64_t)(a_x.len)) < 64u) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
if (((uint64_t)(a_x.len)) >= 128u) {
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_x4 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u));
v_x5 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u));
v_x6 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u));
v_x7 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u));
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(2433674945u), (int32_t)(0u), (int32_t)(872412467u));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
while (((uint64_t)(a_x.len)) >= 128u) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y1 = _mm_clmulepi64_si128(v_x1, v_kk, (int32_t)(0u));
v_x1 = _mm_clmulepi64_si128(v_x1, v_kk, (int32_t)(17u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(0u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(17u));
v_y3 = _mm_clmulepi64_si128(v_x3, v_kk, (int32_t)(0u));
v_x3 = _mm_clmulepi64_si128(v_x3, v_kk, (int32_t)(17u));
v_y4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(0u));
v_x4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(17u));
v_y5 = _mm_clmulepi64_si128(v_x5, v_kk, (int32_t)(0u));
v_x5 = _mm_clmulepi64_si128(v_x5, v_kk, (int32_t)(17u));
v_y6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(0u));
v_x6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(17u));
v_y7 = _mm_clmulepi64_si128(v_x7, v_kk, (int32_t)(0u));
v_x7 = _mm_clmulepi64_si128(v_x7, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y1 = _mm_xor_si128(v_y1, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
v_x1 = _mm_xor_si128(v_x1, v_y1);
v_y2 = _mm_xor_si128(v_y2, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u)));
v_x2 = _mm_xor_si128(v_x2, v_y2);
v_y3 = _mm_xor_si128(v_y3, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u)));
v_x3 = _mm_xor_si128(v_x3, v_y3);
v_y4 = _mm_xor_si128(v_y4, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u)));
v_x4 = _mm_xor_si128(v_x4, v_y4);
v_y5 = _mm_xor_si128(v_y5, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u)));
v_x5 = _mm_xor_si128(v_x5, v_y5);
v_y6 = _mm_xor_si128(v_y6, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u)));
v_x6 = _mm_xor_si128(v_x6, v_y6);
v_y7 = _mm_xor_si128(v_y7, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u)));
v_x7 = _mm_xor_si128(v_x7, v_y7);
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(3433693342u), (int32_t)(0u), (int32_t)(2926088593u));
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(0u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(17u));
v_y4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(0u));
v_x4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(17u));
v_y6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(0u));
v_x6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y2 = _mm_xor_si128(v_y2, v_x3);
v_x2 = _mm_xor_si128(v_x2, v_y2);
v_y4 = _mm_xor_si128(v_y4, v_x5);
v_x4 = _mm_xor_si128(v_x4, v_y4);
v_y6 = _mm_xor_si128(v_y6, v_x7);
v_x6 = _mm_xor_si128(v_x6, v_y6);
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(2166711591u), (int32_t)(0u), (int32_t)(4057597354u));
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(0u));
v_x4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y4 = _mm_xor_si128(v_y4, v_x6);
v_x4 = _mm_xor_si128(v_x4, v_y4);
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(496309207u), (int32_t)(0u), (int32_t)(2402626965u));
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, v_x4);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_kk = _mm_set_epi32((int32_t)(1u), (int32_t)(3681617473u), (int32_t)(3034951717u), (int32_t)(4144043585u));
v_s = ((uint32_t)(_mm_extract_epi32(_mm_clmulepi64_si128(_mm_clmulepi64_si128(_mm_cvtsi64_si128((int64_t)(((uint64_t)(_mm_extract_epi64(v_x0, (int32_t)(0u)))))), v_kk, (int32_t)(0u)), v_kk, (int32_t)(16u)), (int32_t)(2u))));
v_kk = _mm_set_epi32((int32_t)(1u), (int32_t)(3681617473u), (int32_t)(3034951717u), (int32_t)(4144043585u));
v_s = ((uint32_t)(_mm_extract_epi32(_mm_clmulepi64_si128(_mm_clmulepi64_si128(_mm_cvtsi64_si128((int64_t)((((uint64_t)(_mm_extract_epi64(v_x0, (int32_t)(1u)))) ^ ((uint64_t)(v_s))))), v_kk, (int32_t)(0u)), v_kk, (int32_t)(16u)), (int32_t)(2u))));
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K1K2));
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, 64u);
v_p.ptr = i_slice_p.ptr;
v_p.len = 64;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 64) * 64));
while (v_p.ptr < i_end0_p) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_y1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(0u));
v_y3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(17u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(17u));
v_x3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(_mm_xor_si128(v_x0, v_y0), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 0u)));
v_x1 = _mm_xor_si128(_mm_xor_si128(v_x1, v_y1), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16u)));
v_x2 = _mm_xor_si128(_mm_xor_si128(v_x2, v_y2), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 32u)));
v_x3 = _mm_xor_si128(_mm_xor_si128(v_x3, v_y3), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 48u)));
v_p.ptr += 64;
}
v_p.len = 0;
while (((uint64_t)(a_x.len)) >= 8u) {
v_kk = _mm_set_epi32((int32_t)(1u), (int32_t)(3681617473u), (int32_t)(3034951717u), (int32_t)(4144043585u));
v_s = ((uint32_t)(_mm_extract_epi32(_mm_clmulepi64_si128(_mm_clmulepi64_si128(_mm_cvtsi64_si128((int64_t)((wuffs_base__peek_u64le__no_bounds_check(a_x.ptr) ^ ((uint64_t)(v_s))))), v_kk, (int32_t)(0u)), v_kk, (int32_t)(16u)), (int32_t)(2u))));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 8u);
}
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K3K4));
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x3);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_x1 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(16u));
v_x2 = _mm_set_epi32((int32_t)(0u), (int32_t)(4294967295u), (int32_t)(0u), (int32_t)(4294967295u));
v_x0 = _mm_srli_si128(v_x0, (int32_t)(8u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ));
v_x1 = _mm_srli_si128(v_x0, (int32_t)(4u));
v_x0 = _mm_and_si128(v_x0, v_x2);
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_PXMU));
v_x1 = _mm_and_si128(v_x0, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(16u));
v_x1 = _mm_and_si128(v_x1, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_s = ((uint32_t)(_mm_extract_epi32(v_x0, (int32_t)(1u))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551552u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
while (((uint64_t)(a_x.len)) > 0u) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC32)
@@ -36591,27 +37161,33 @@ WUFFS_CRC64__ECMA_TABLE[8][256] WUFFS_BASE__POTENTIALLY_UNUSED = {
};
static const uint8_t
WUFFS_CRC64__SHUFFLE_707F[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
112u, 113u, 114u, 115u, 116u, 117u, 118u, 119u,
120u, 121u, 122u, 123u, 124u, 125u, 126u, 127u,
};
static const uint8_t
WUFFS_CRC64__SHUFFLE_8F80[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
143u, 142u, 141u, 140u, 139u, 138u, 137u, 136u,
135u, 134u, 133u, 132u, 131u, 130u, 129u, 128u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_K1K2[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
WUFFS_CRC64__ECMA_X86_SSE42_FOLD1[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
228u, 58u, 57u, 202u, 151u, 212u, 93u, 224u,
64u, 95u, 135u, 199u, 175u, 149u, 190u, 218u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_PXMU[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
133u, 30u, 14u, 175u, 43u, 175u, 216u, 146u,
WUFFS_CRC64__ECMA_X86_SSE42_FOLD2[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
68u, 250u, 158u, 138u, 0u, 91u, 9u, 96u,
81u, 175u, 225u, 15u, 163u, 83u, 230u, 59u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_FOLD4[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
243u, 65u, 212u, 157u, 187u, 239u, 227u, 106u,
244u, 45u, 132u, 167u, 84u, 96u, 31u, 8u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_FOLD8[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 16u, 204u, 79u, 29u, 215u, 87u, 135u,
64u, 231u, 61u, 247u, 42u, 107u, 216u, 215u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_MUPX[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
213u, 99u, 41u, 23u, 108u, 70u, 62u, 156u,
133u, 30u, 14u, 175u, 43u, 175u, 216u, 146u,
};
// ---------------- Private Initializer Prototypes
@@ -36630,13 +37206,13 @@ wuffs_crc64__ecma_hasher__up__choosy_default(
wuffs_crc64__ecma_hasher* self,
wuffs_base__slice_u8 a_x);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc64__ecma_hasher__up_x86_sse42(
wuffs_crc64__ecma_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ---------------- VTables
@@ -36782,7 +37358,7 @@ wuffs_crc64__ecma_hasher__update(
if (self->private_impl.f_state == 0u) {
self->private_impl.choosy_up = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc64__ecma_hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -36884,7 +37460,7 @@ wuffs_crc64__ecma_hasher__checksum_u64(
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc64.ecma_hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -36893,93 +37469,126 @@ wuffs_crc64__ecma_hasher__up_x86_sse42(
wuffs_base__slice_u8 a_x) {
uint64_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_s0 = {0};
__m128i v_s0_707F = {0};
__m128i v_s0_8F80 = {0};
__m128i v_x0 = {0};
__m128i v_aa = {0};
__m128i v_k1k2 = {0};
__m128i v_t0 = {0};
__m128i v_t1 = {0};
__m128i v_t2 = {0};
__m128i v_u0 = {0};
__m128i v_u1 = {0};
__m128i v_u2 = {0};
__m128i v_v0 = {0};
__m128i v_v1 = {0};
__m128i v_pxmu = {0};
__m128i v_w1 = {0};
__m128i v_w2 = {0};
uint64_t v_tail_index = 0;
uint8_t v_buf[48] = {0};
__m128i v_xa = {0};
__m128i v_xb = {0};
__m128i v_xc = {0};
__m128i v_xd = {0};
__m128i v_xe = {0};
__m128i v_xf = {0};
__m128i v_xg = {0};
__m128i v_xh = {0};
__m128i v_mu1 = {0};
__m128i v_mu2 = {0};
__m128i v_mu4 = {0};
__m128i v_mu8 = {0};
__m128i v_mupx = {0};
v_s = (18446744073709551615u ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0u) && ((15u & ((uint32_t)(0xFFFu & (uintptr_t)(a_x.ptr)))) != 0u)) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
if (((uint64_t)(a_x.len)) < 32u) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
do {
do {
if (((uint64_t)(a_x.len)) >= 128u) {
} else if (((uint64_t)(a_x.len)) >= 64u) {
v_xa = _mm_xor_si128(_mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)), _mm_cvtsi64_si128((int64_t)(v_s)));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_xc = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_xd = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 64u);
break;
} else if (((uint64_t)(a_x.len)) >= 32u) {
v_xa = _mm_xor_si128(_mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)), _mm_cvtsi64_si128((int64_t)(v_s)));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 32u);
goto label__chain2__break;
} else {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
self->private_impl.f_state = (18446744073709551615u ^ v_s);
return wuffs_base__make_empty_struct();
}
v_p.len = 0;
v_xa = _mm_xor_si128(_mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)), _mm_cvtsi64_si128((int64_t)(v_s)));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_xc = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_xd = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_xe = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u));
v_xf = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u));
v_xg = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u));
v_xh = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
v_mu8 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD8));
while (((uint64_t)(a_x.len)) >= 128u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
v_xc = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xc, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xc, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u)));
v_xd = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xd, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xd, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u)));
v_xe = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xe, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xe, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u)));
v_xf = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xf, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xf, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u)));
v_xg = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xg, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xg, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u)));
v_xh = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xh, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xh, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
}
v_mu4 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD4));
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(17u))), v_xe);
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(17u))), v_xf);
v_xc = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(17u))), v_xg);
v_xd = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(17u))), v_xh);
if (((uint64_t)(a_x.len)) > 64u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
v_xc = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u)));
v_xd = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 64u);
}
} while (0);
v_mu2 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD2));
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(17u))), v_xc);
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(17u))), v_xd);
if (((uint64_t)(a_x.len)) > 32u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 32u);
}
self->private_impl.f_state = (18446744073709551615u ^ v_s);
return wuffs_base__make_empty_struct();
}
v_s0 = _mm_cvtsi64_si128((int64_t)(v_s));
v_s0_707F = _mm_shuffle_epi8(v_s0, _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__SHUFFLE_707F)));
v_s0_8F80 = _mm_shuffle_epi8(v_s0, _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__SHUFFLE_8F80)));
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 16u);
v_k1k2 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_K1K2));
v_t0 = _mm_xor_si128(v_s0_707F, v_x0);
v_t1 = _mm_clmulepi64_si128(v_t0, v_k1k2, (int32_t)(0u));
v_t2 = _mm_clmulepi64_si128(v_t0, v_k1k2, (int32_t)(17u));
v_aa = _mm_xor_si128(_mm_xor_si128(v_t1, v_t2), v_s0_8F80);
while (((uint64_t)(a_x.len)) >= 32u) {
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
} while (0);
label__chain2__break:;
v_mu1 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD1));
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(17u))), v_xb);
if (((uint64_t)(a_x.len)) > 24u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 16u);
v_u0 = _mm_xor_si128(v_aa, v_x0);
v_u1 = _mm_clmulepi64_si128(v_u0, v_k1k2, (int32_t)(0u));
v_u2 = _mm_clmulepi64_si128(v_u0, v_k1k2, (int32_t)(17u));
v_aa = _mm_xor_si128(v_u1, v_u2);
}
if (((uint64_t)(a_x.len)) < 16u) {
return wuffs_base__make_empty_struct();
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 16u);
v_v0 = _mm_xor_si128(v_aa, v_x0);
v_v1 = _mm_clmulepi64_si128(v_v0, v_k1k2, (int32_t)(16u));
v_aa = _mm_xor_si128(v_v1, _mm_srli_si128(v_v0, (int32_t)(8u)));
v_pxmu = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_PXMU));
v_w1 = _mm_clmulepi64_si128(v_aa, v_pxmu, (int32_t)(16u));
v_w2 = _mm_clmulepi64_si128(v_w1, v_pxmu, (int32_t)(0u));
v_s = ((uint64_t)(_mm_extract_epi64(_mm_xor_si128(v_aa, _mm_xor_si128(v_w2, _mm_slli_si128(v_w1, (int32_t)(8u)))), (int32_t)(1u))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551600u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
if (((uint64_t)(a_x.len)) > 24u) {
return wuffs_base__make_empty_struct();
}
}
_mm_storeu_si128((__m128i*)(void*)(v_buf + (24u - ((uint64_t)(a_x.len)))), v_xa);
wuffs_private_impl__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(v_buf, ((24u - ((uint64_t)(a_x.len))) + 16u), 48), a_x);
v_mu2 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD2));
v_xa = _mm_lddqu_si128((const __m128i*)(const void*)(v_buf + 0u));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(v_buf + 16u));
v_xc = _mm_lddqu_si128((const __m128i*)(const void*)(v_buf + 32u));
v_xd = _mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(17u)));
v_xe = _mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu1, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu1, (int32_t)(17u)));
v_xa = _mm_xor_si128(v_xd, _mm_xor_si128(v_xe, v_xc));
v_mupx = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_MUPX));
v_xb = _mm_clmulepi64_si128(v_xa, v_mupx, (int32_t)(0u));
v_xc = _mm_clmulepi64_si128(v_xb, v_mupx, (int32_t)(16u));
v_s = ((uint64_t)(_mm_extract_epi64(_mm_xor_si128(_mm_xor_si128(v_xc, _mm_slli_si128(v_xb, (int32_t)(8u))), v_xa), (int32_t)(1u))));
self->private_impl.f_state = (18446744073709551615u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC64)
@@ -37118,14 +37727,14 @@ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -37459,7 +38068,7 @@ wuffs_deflate__decoder__do_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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
#endif
self->private_impl.choosy_decode_huffman_fast64);
@@ -38348,7 +38957,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -38556,7 +39165,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
return status;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
// -------- func deflate.decoder.decode_huffman_fast32
@@ -43306,7 +43915,7 @@ wuffs_jpeg__decoder__decode_idct__choosy_default(
uint64_t a_dst_stride,
uint32_t a_q);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_jpeg__decoder__decode_idct_x86_avx2(
@@ -43314,7 +43923,7 @@ wuffs_jpeg__decoder__decode_idct_x86_avx2(
wuffs_base__slice_u8 a_dst_buffer,
uint64_t a_dst_stride,
uint32_t a_q);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -44781,7 +45390,7 @@ wuffs_jpeg__decoder__decode_idct__choosy_default(
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func jpeg.decoder.decode_idct_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -45165,7 +45774,7 @@ wuffs_jpeg__decoder__decode_idct_x86_avx2(
wuffs_base__poke_u64le__no_bounds_check(a_dst_buffer.ptr, v_final7);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// -------- func jpeg.decoder.get_quirk
@@ -45514,7 +46123,7 @@ wuffs_jpeg__decoder__do_decode_image_config(
self->private_impl.f_payload_length = 0u;
}
self->private_impl.choosy_decode_idct = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_jpeg__decoder__decode_idct_x86_avx2 :
#endif
self->private_impl.choosy_decode_idct);
@@ -59312,40 +59921,40 @@ WUFFS_PNG__LATIN_1[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
// ---------------- Private Function Prototypes
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -59434,40 +60043,40 @@ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -59749,7 +60358,7 @@ sizeof__wuffs_png__decoder(void) {
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_1_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_arm_neon(
@@ -59789,13 +60398,13 @@ wuffs_png__decoder__filter_1_distance_4_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_3_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_arm_neon(
@@ -59881,13 +60490,13 @@ wuffs_png__decoder__filter_3_distance_4_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_4_distance_3_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_arm_neon(
@@ -60002,13 +60611,13 @@ wuffs_png__decoder__filter_4_distance_3_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_4_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_arm_neon(
@@ -60103,7 +60712,7 @@ wuffs_png__decoder__filter_4_distance_4_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// -------- func png.decoder.filter_1
@@ -60786,7 +61395,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -60827,13 +61436,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -60933,13 +61542,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -61060,13 +61669,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -61165,7 +61774,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// -------- func png.decoder.get_quirk
@@ -61909,35 +62518,35 @@ wuffs_png__decoder__choose_filter_implementations(
self->private_impl.choosy_filter_3 = (
&wuffs_png__decoder__filter_3_distance_3_fallback);
self->private_impl.choosy_filter_4 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
} else if (self->private_impl.f_filter_distance == 4u) {
self->private_impl.choosy_filter_1 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
self->private_impl.choosy_filter_3 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
self->private_impl.choosy_filter_4 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
@@ -62137,20 +62746,22 @@ wuffs_png__decoder__decode_other_chunk(
self->private_impl.f_seen_srgb = true;
}
} else if (self->private_impl.f_chunk_type == 1397641844u) {
if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3u) || ((self->private_impl.f_color_type == 3u) && ! self->private_impl.f_seen_plte)) {
if (self->private_impl.f_seen_trns || ((self->private_impl.f_color_type == 3u) && ! self->private_impl.f_seen_plte)) {
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(9);
status = wuffs_png__decoder__decode_trns(self, 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_color_type > 3u) {
} else {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
status = wuffs_png__decoder__decode_trns(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_trns = true;
}
@@ -67778,6 +68389,87 @@ wuffs_tga__decoder__workbuf_len(
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8)
// ---------------- Status Codes Implementations
// ---------------- Private Consts
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
// ---------------- VTables
// ---------------- Initializer Implementations
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_vp8__placeholder__initialize(
wuffs_vp8__placeholder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options){
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (sizeof(*self) != sizeof_star_self) {
return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver);
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
}
if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
// The whole point of this if-check is to detect an uninitialized *self.
// We disable the warning on GCC. Clang-5.0 does not have this warning.
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
if (self->private_impl.magic != 0) {
return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed);
}
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else {
if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
memset(self, 0, sizeof(*self));
options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
} else {
memset(&(self->private_impl), 0, sizeof(self->private_impl));
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return wuffs_base__make_status(NULL);
}
wuffs_vp8__placeholder*
wuffs_vp8__placeholder__alloc(void) {
wuffs_vp8__placeholder* x =
(wuffs_vp8__placeholder*)(calloc(sizeof(wuffs_vp8__placeholder), 1));
if (!x) {
return NULL;
}
if (wuffs_vp8__placeholder__initialize(
x, sizeof(wuffs_vp8__placeholder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) {
free(x);
return NULL;
}
return x;
}
size_t
sizeof__wuffs_vp8__placeholder(void) {
return sizeof(wuffs_vp8__placeholder);
}
// ---------------- Function Implementations
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)
// ---------------- Status Codes Implementations
@@ -68700,6 +69392,4360 @@ wuffs_wbmp__decoder__workbuf_len(
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
// ---------------- Status Codes Implementations
const char wuffs_webp__error__bad_huffman_code_over_subscribed[] = "#webp: bad Huffman code (over-subscribed)";
const char wuffs_webp__error__bad_huffman_code_under_subscribed[] = "#webp: bad Huffman code (under-subscribed)";
const char wuffs_webp__error__bad_huffman_code[] = "#webp: bad Huffman code";
const char wuffs_webp__error__bad_back_reference[] = "#webp: bad back-reference";
const char wuffs_webp__error__bad_color_cache[] = "#webp: bad color cache";
const char wuffs_webp__error__bad_header[] = "#webp: bad header";
const char wuffs_webp__error__bad_transform[] = "#webp: bad transform";
const char wuffs_webp__error__short_chunk[] = "#webp: short chunk";
const char wuffs_webp__error__truncated_input[] = "#webp: truncated input";
const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups";
const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[] = "#webp: unsupported transform after color indexing transform";
const char wuffs_webp__error__unsupported_webp_file[] = "#webp: unsupported WebP file";
const char wuffs_webp__error__internal_error_inconsistent_huffman_code[] = "#webp: internal error: inconsistent Huffman code";
const char wuffs_webp__error__internal_error_inconsistent_dst_buffer[] = "#webp: internal error: inconsistent dst buffer";
const char wuffs_webp__error__internal_error_inconsistent_n_bits[] = "#webp: internal error: inconsistent n_bits";
// ---------------- Private Consts
static const uint8_t
WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[19] WUFFS_BASE__POTENTIALLY_UNUSED = {
17u, 18u, 0u, 1u, 2u, 3u, 4u, 5u,
16u, 6u, 7u, 8u, 9u, 10u, 11u, 12u,
13u, 14u, 15u,
};
static const uint8_t
WUFFS_WEBP__REPEAT_N_BITS[4] WUFFS_BASE__POTENTIALLY_UNUSED = {
2u, 3u, 7u, 0u,
};
static const uint8_t
WUFFS_WEBP__REPEAT_COUNTS[4] WUFFS_BASE__POTENTIALLY_UNUSED = {
3u, 3u, 11u, 0u,
};
static const uint16_t
WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[5] WUFFS_BASE__POTENTIALLY_UNUSED = {
1612u, 0u, 511u, 1022u, 1533u,
};
static const uint32_t
WUFFS_WEBP__SIGN_EXTEND_I8_I32[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u,
8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u,
16u, 17u, 18u, 19u, 20u, 21u, 22u, 23u,
24u, 25u, 26u, 27u, 28u, 29u, 30u, 31u,
32u, 33u, 34u, 35u, 36u, 37u, 38u, 39u,
40u, 41u, 42u, 43u, 44u, 45u, 46u, 47u,
48u, 49u, 50u, 51u, 52u, 53u, 54u, 55u,
56u, 57u, 58u, 59u, 60u, 61u, 62u, 63u,
64u, 65u, 66u, 67u, 68u, 69u, 70u, 71u,
72u, 73u, 74u, 75u, 76u, 77u, 78u, 79u,
80u, 81u, 82u, 83u, 84u, 85u, 86u, 87u,
88u, 89u, 90u, 91u, 92u, 93u, 94u, 95u,
96u, 97u, 98u, 99u, 100u, 101u, 102u, 103u,
104u, 105u, 106u, 107u, 108u, 109u, 110u, 111u,
112u, 113u, 114u, 115u, 116u, 117u, 118u, 119u,
120u, 121u, 122u, 123u, 124u, 125u, 126u, 127u,
4294967168u, 4294967169u, 4294967170u, 4294967171u, 4294967172u, 4294967173u, 4294967174u, 4294967175u,
4294967176u, 4294967177u, 4294967178u, 4294967179u, 4294967180u, 4294967181u, 4294967182u, 4294967183u,
4294967184u, 4294967185u, 4294967186u, 4294967187u, 4294967188u, 4294967189u, 4294967190u, 4294967191u,
4294967192u, 4294967193u, 4294967194u, 4294967195u, 4294967196u, 4294967197u, 4294967198u, 4294967199u,
4294967200u, 4294967201u, 4294967202u, 4294967203u, 4294967204u, 4294967205u, 4294967206u, 4294967207u,
4294967208u, 4294967209u, 4294967210u, 4294967211u, 4294967212u, 4294967213u, 4294967214u, 4294967215u,
4294967216u, 4294967217u, 4294967218u, 4294967219u, 4294967220u, 4294967221u, 4294967222u, 4294967223u,
4294967224u, 4294967225u, 4294967226u, 4294967227u, 4294967228u, 4294967229u, 4294967230u, 4294967231u,
4294967232u, 4294967233u, 4294967234u, 4294967235u, 4294967236u, 4294967237u, 4294967238u, 4294967239u,
4294967240u, 4294967241u, 4294967242u, 4294967243u, 4294967244u, 4294967245u, 4294967246u, 4294967247u,
4294967248u, 4294967249u, 4294967250u, 4294967251u, 4294967252u, 4294967253u, 4294967254u, 4294967255u,
4294967256u, 4294967257u, 4294967258u, 4294967259u, 4294967260u, 4294967261u, 4294967262u, 4294967263u,
4294967264u, 4294967265u, 4294967266u, 4294967267u, 4294967268u, 4294967269u, 4294967270u, 4294967271u,
4294967272u, 4294967273u, 4294967274u, 4294967275u, 4294967276u, 4294967277u, 4294967278u, 4294967279u,
4294967280u, 4294967281u, 4294967282u, 4294967283u, 4294967284u, 4294967285u, 4294967286u, 4294967287u,
4294967288u, 4294967289u, 4294967290u, 4294967291u, 4294967292u, 4294967293u, 4294967294u, 4294967295u,
};
static const uint8_t
WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u,
22u, 26u, 38u, 42u, 56u, 5u, 55u, 57u,
21u, 27u, 54u, 58u, 37u, 43u, 72u, 4u,
71u, 73u, 20u, 28u, 53u, 59u, 70u, 74u,
36u, 44u, 88u, 69u, 75u, 52u, 60u, 3u,
87u, 89u, 19u, 29u, 86u, 90u, 35u, 45u,
68u, 76u, 85u, 91u, 51u, 61u, 104u, 2u,
103u, 105u, 18u, 30u, 102u, 106u, 34u, 46u,
84u, 92u, 67u, 77u, 101u, 107u, 50u, 62u,
120u, 1u, 119u, 121u, 83u, 93u, 17u, 31u,
100u, 108u, 66u, 78u, 118u, 122u, 33u, 47u,
117u, 123u, 49u, 63u, 99u, 109u, 82u, 94u,
0u, 116u, 124u, 65u, 79u, 16u, 32u, 98u,
110u, 48u, 115u, 125u, 81u, 95u, 64u, 114u,
126u, 97u, 111u, 80u, 113u, 127u, 96u, 112u,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_groups(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_n_huffman_groups);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree_simple(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_code_length_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths_huffman_nodes(
wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_huffman_nodes(
wuffs_webp__decoder* self,
uint32_t a_hg,
uint32_t a_ht);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels_slow(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_predictor(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data);
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
wuffs_webp__decoder__absolute_difference(
const wuffs_webp__decoder* self,
uint32_t a_a,
uint32_t a_b);
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode12(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl);
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode13(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_cross_color(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_subtract_green(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_color_indexing(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_transform(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_color_cache_parameters(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_hg_table(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__swizzle(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_src,
wuffs_base__pixel_blend a_blend);
// ---------------- VTables
const wuffs_base__image_decoder__func_ptrs
wuffs_webp__decoder__func_ptrs_for__wuffs_base__image_decoder = {
(wuffs_base__status(*)(void*,
wuffs_base__pixel_buffer*,
wuffs_base__io_buffer*,
wuffs_base__pixel_blend,
wuffs_base__slice_u8,
wuffs_base__decode_frame_options*))(&wuffs_webp__decoder__decode_frame),
(wuffs_base__status(*)(void*,
wuffs_base__frame_config*,
wuffs_base__io_buffer*))(&wuffs_webp__decoder__decode_frame_config),
(wuffs_base__status(*)(void*,
wuffs_base__image_config*,
wuffs_base__io_buffer*))(&wuffs_webp__decoder__decode_image_config),
(wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_webp__decoder__frame_dirty_rect),
(uint64_t(*)(const void*,
uint32_t))(&wuffs_webp__decoder__get_quirk),
(uint32_t(*)(const void*))(&wuffs_webp__decoder__num_animation_loops),
(uint64_t(*)(const void*))(&wuffs_webp__decoder__num_decoded_frame_configs),
(uint64_t(*)(const void*))(&wuffs_webp__decoder__num_decoded_frames),
(wuffs_base__status(*)(void*,
uint64_t,
uint64_t))(&wuffs_webp__decoder__restart_frame),
(wuffs_base__status(*)(void*,
uint32_t,
uint64_t))(&wuffs_webp__decoder__set_quirk),
(wuffs_base__empty_struct(*)(void*,
uint32_t,
bool))(&wuffs_webp__decoder__set_report_metadata),
(wuffs_base__status(*)(void*,
wuffs_base__io_buffer*,
wuffs_base__more_information*,
wuffs_base__io_buffer*))(&wuffs_webp__decoder__tell_me_more),
(wuffs_base__range_ii_u64(*)(const void*))(&wuffs_webp__decoder__workbuf_len),
};
// ---------------- Initializer Implementations
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_webp__decoder__initialize(
wuffs_webp__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options){
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (sizeof(*self) != sizeof_star_self) {
return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver);
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
}
if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
// The whole point of this if-check is to detect an uninitialized *self.
// We disable the warning on GCC. Clang-5.0 does not have this warning.
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
if (self->private_impl.magic != 0) {
return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed);
}
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else {
if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
memset(self, 0, sizeof(*self));
options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
} else {
memset(&(self->private_impl), 0, sizeof(self->private_impl));
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
self->private_impl.vtable_for__wuffs_base__image_decoder.vtable_name =
wuffs_base__image_decoder__vtable_name;
self->private_impl.vtable_for__wuffs_base__image_decoder.function_pointers =
(const void*)(&wuffs_webp__decoder__func_ptrs_for__wuffs_base__image_decoder);
return wuffs_base__make_status(NULL);
}
wuffs_webp__decoder*
wuffs_webp__decoder__alloc(void) {
wuffs_webp__decoder* x =
(wuffs_webp__decoder*)(calloc(sizeof(wuffs_webp__decoder), 1));
if (!x) {
return NULL;
}
if (wuffs_webp__decoder__initialize(
x, sizeof(wuffs_webp__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) {
free(x);
return NULL;
}
return x;
}
size_t
sizeof__wuffs_webp__decoder(void) {
return sizeof(wuffs_webp__decoder);
}
// ---------------- Function Implementations
// -------- func webp.decoder.decode_huffman_groups
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_groups(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_n_huffman_groups) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_hg = 0;
uint32_t v_ht = 0;
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_groups;
if (coro_susp_point) {
v_hg = self->private_data.s_decode_huffman_groups.v_hg;
v_ht = self->private_data.s_decode_huffman_groups.v_ht;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
v_hg = 0u;
while (v_hg < a_n_huffman_groups) {
v_ht = 0u;
while (v_ht < 5u) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__decode_huffman_tree(self, a_src, v_hg, v_ht);
if (status.repr) {
goto suspend;
}
v_ht += 1u;
}
v_hg += 1u;
}
goto ok;
ok:
self->private_impl.p_decode_huffman_groups = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_huffman_groups = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_huffman_groups.v_hg = v_hg;
self->private_data.s_decode_huffman_groups.v_ht = v_ht;
goto exit;
exit:
return status;
}
// -------- func webp.decoder.decode_huffman_tree
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_simple = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (a_ht >= 4u) {
self->private_impl.f_ht_n_symbols = 40u;
} else if (a_ht > 0u) {
self->private_impl.f_ht_n_symbols = 256u;
} else if (self->private_impl.f_color_cache_bits == 0u) {
self->private_impl.f_ht_n_symbols = 280u;
} else {
self->private_impl.f_ht_n_symbols = (280u + (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits));
}
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_simple = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
if (v_use_simple != 0u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_webp__decoder__decode_huffman_tree_simple(self, a_src, a_hg, a_ht);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_code_length_code_lengths(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
v_status = wuffs_webp__decoder__build_code_lengths_huffman_nodes(self);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__build_code_lengths(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
v_status = wuffs_webp__decoder__build_huffman_nodes(self, a_hg, a_ht);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
}
ok:
self->private_impl.p_decode_huffman_tree = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_huffman_tree = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_huffman_tree_simple
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree_simple(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_second_symbol = 0;
uint32_t v_first_symbol_n_bits = 0;
uint32_t v_symbol0 = 0;
uint32_t v_symbol1 = 0;
uint32_t v_base_offset = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree_simple;
if (coro_susp_point) {
v_use_second_symbol = self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol;
v_first_symbol_n_bits = self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits;
v_symbol0 = self->private_data.s_decode_huffman_tree_simple.v_symbol0;
v_base_offset = self->private_data.s_decode_huffman_tree_simple.v_base_offset;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 2u) {
{
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_c8 = t_0;
}
if (self->private_impl.f_n_bits >= 2u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_use_second_symbol = (self->private_impl.f_bits & 1u);
v_first_symbol_n_bits = ((((self->private_impl.f_bits & 2u) >> 1u) * 7u) + 1u);
self->private_impl.f_bits >>= 2u;
self->private_impl.f_n_bits -= 2u;
if (self->private_impl.f_n_bits < v_first_symbol_n_bits) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= v_first_symbol_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_symbol0 = (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_first_symbol_n_bits) - 1u));
self->private_impl.f_bits >>= v_first_symbol_n_bits;
self->private_impl.f_n_bits -= v_first_symbol_n_bits;
v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht]));
if (v_use_second_symbol != 0u) {
if (self->private_impl.f_n_bits < 8u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
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++;
v_c8 = t_2;
}
if (self->private_impl.f_n_bits >= 8u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_symbol1 = (self->private_impl.f_bits & 255u);
self->private_impl.f_bits >>= 8u;
self->private_impl.f_n_bits -= 8u;
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 0u)] = ((uint16_t)((v_base_offset + 1u)));
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 1u)] = ((uint16_t)((v_symbol0 | 32768u)));
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 2u)] = ((uint16_t)((v_symbol1 | 32768u)));
} else {
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_symbol0 | 32768u)));
}
goto ok;
ok:
self->private_impl.p_decode_huffman_tree_simple = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_huffman_tree_simple = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol = v_use_second_symbol;
self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits = v_first_symbol_n_bits;
self->private_data.s_decode_huffman_tree_simple.v_symbol0 = v_symbol0;
self->private_data.s_decode_huffman_tree_simple.v_base_offset = v_base_offset;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_code_length_code_lengths
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_code_length_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_n_codes = 0;
uint32_t v_i = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_code_length_code_lengths;
if (coro_susp_point) {
v_n_codes = self->private_data.s_decode_code_length_code_lengths.v_n_codes;
v_i = self->private_data.s_decode_code_length_code_lengths.v_i;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 4u) {
{
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_c8 = t_0;
}
if (self->private_impl.f_n_bits >= 4u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_n_codes = ((self->private_impl.f_bits & 15u) + 4u);
self->private_impl.f_bits >>= 4u;
self->private_impl.f_n_bits -= 4u;
v_i = 0u;
while (v_i < v_n_codes) {
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = ((uint8_t)((self->private_impl.f_bits & 7u)));
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
v_i += 1u;
}
while (v_i < 19u) {
self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = 0u;
v_i += 1u;
}
goto ok;
ok:
self->private_impl.p_decode_code_length_code_lengths = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_code_length_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_code_length_code_lengths.v_n_codes = v_n_codes;
self->private_data.s_decode_code_length_code_lengths.v_i = v_i;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.build_code_lengths_huffman_nodes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths_huffman_nodes(
wuffs_webp__decoder* self) {
uint32_t v_code_bits = 0;
uint32_t v_code_len = 0;
uint32_t v_symbol = 0;
uint32_t v_histogram[8] = {0};
uint32_t v_n_used_symbols = 0;
uint32_t v_last_used_symbol = 0;
uint32_t v_subscription_weight = 0;
uint32_t v_subscription_total = 0;
uint32_t v_curr_code = 0;
uint32_t v_next_codes[9] = {0};
uint32_t v_n_branches = 0;
uint32_t v_h = 0;
uint32_t v_children = 0;
uint16_t v_node = 0;
v_symbol = 0u;
while (v_symbol < 19u) {
v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol]));
if (v_code_len != 0u) {
v_histogram[v_code_len] += 1u;
v_n_used_symbols += 1u;
v_last_used_symbol = v_symbol;
}
v_symbol += 1u;
}
if (v_n_used_symbols < 1u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
} else if (v_n_used_symbols == 1u) {
self->private_data.f_code_lengths_huffman_nodes[0u] = ((uint16_t)((v_last_used_symbol | 32768u)));
return wuffs_base__make_status(NULL);
}
v_subscription_weight = 16384u;
v_code_len = 1u;
while (true) {
v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u));
v_next_codes[(v_code_len + 1u)] = v_curr_code;
v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len]));
v_subscription_weight >>= 1u;
if (v_code_len >= 7u) {
break;
}
v_code_len += 1u;
}
if (v_subscription_total > 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed);
} else if (v_subscription_total < 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed);
}
self->private_data.f_code_lengths_huffman_nodes[0u] = 0u;
v_symbol = 0u;
while (v_symbol < 19u) {
v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol]));
if (v_code_len > 0u) {
v_code_bits = v_next_codes[v_code_len];
v_next_codes[v_code_len] += 1u;
v_code_bits <<= (32u - v_code_len);
v_h = 0u;
while (v_code_len > 0u) {
v_node = self->private_data.f_code_lengths_huffman_nodes[v_h];
if (v_node == 0u) {
v_children = ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches))));
v_children = wuffs_base__u32__min(v_children, 35u);
self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)(v_children));
self->private_data.f_code_lengths_huffman_nodes[(v_children + 0u)] = 0u;
self->private_data.f_code_lengths_huffman_nodes[(v_children + 1u)] = 0u;
v_h = (v_children + (v_code_bits >> 31u));
v_n_branches += 1u;
} else {
v_children = ((uint32_t)(v_node));
v_h = (wuffs_base__u32__min(v_children, 35u) + (v_code_bits >> 31u));
}
v_code_bits <<= 1u;
v_code_len -= 1u;
}
self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)((v_symbol | 32768u)));
}
v_symbol += 1u;
}
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.build_huffman_nodes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_huffman_nodes(
wuffs_webp__decoder* self,
uint32_t a_hg,
uint32_t a_ht) {
uint32_t v_base_offset = 0;
uint32_t v_code_bits = 0;
uint32_t v_code_len = 0;
uint32_t v_symbol = 0;
uint32_t v_histogram[16] = {0};
uint32_t v_n_used_symbols = 0;
uint32_t v_last_used_symbol = 0;
uint32_t v_subscription_weight = 0;
uint32_t v_subscription_total = 0;
uint32_t v_curr_code = 0;
uint32_t v_next_codes[17] = {0};
uint32_t v_n_branches = 0;
uint32_t v_h = 0;
uint32_t v_children = 0;
uint16_t v_node = 0;
v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht]));
v_symbol = 0u;
while (v_symbol < self->private_impl.f_ht_n_symbols) {
v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u))));
if (v_code_len != 0u) {
v_histogram[v_code_len] += 1u;
v_n_used_symbols += 1u;
v_last_used_symbol = v_symbol;
}
v_symbol += 1u;
}
if (v_n_used_symbols < 1u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
} else if (v_n_used_symbols == 1u) {
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_last_used_symbol | 32768u)));
return wuffs_base__make_status(NULL);
}
v_subscription_weight = 16384u;
v_code_len = 1u;
while (true) {
v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u));
v_next_codes[(v_code_len + 1u)] = v_curr_code;
v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len]));
v_subscription_weight >>= 1u;
if (v_code_len >= 15u) {
break;
}
v_code_len += 1u;
}
if (v_subscription_total > 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed);
} else if (v_subscription_total < 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed);
}
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = 0u;
v_symbol = 0u;
while (v_symbol < self->private_impl.f_ht_n_symbols) {
v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u))));
if (v_code_len != 0u) {
v_code_bits = v_next_codes[v_code_len];
v_next_codes[v_code_len] += 1u;
v_code_bits <<= (32u - v_code_len);
v_h = v_base_offset;
while (v_code_len > 0u) {
v_node = self->private_data.f_huffman_nodes[a_hg][v_h];
if (v_node == 0u) {
v_children = ((uint32_t)(v_base_offset + ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches))))));
v_children = wuffs_base__u32__min(v_children, 6265u);
self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)(v_children));
self->private_data.f_huffman_nodes[a_hg][(v_children + 0u)] = 0u;
self->private_data.f_huffman_nodes[a_hg][(v_children + 1u)] = 0u;
v_h = (v_children + (v_code_bits >> 31u));
v_n_branches += 1u;
} else {
v_children = ((uint32_t)(v_node));
v_h = (wuffs_base__u32__min(v_children, 6265u) + (v_code_bits >> 31u));
}
v_code_bits <<= 1u;
v_code_len -= 1u;
}
self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)((v_symbol | 32768u)));
}
v_symbol += 1u;
}
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.build_code_lengths
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_length = 0;
uint32_t v_length_n_bits = 0;
uint32_t v_length = 0;
uint16_t v_prev_code_length = 0;
uint32_t v_h = 0;
uint32_t v_s = 0;
uint32_t v_s_max = 0;
uint16_t v_node = 0;
uint32_t v_symbol = 0;
uint16_t v_repeat_value = 0;
uint32_t v_repeat_n_bits = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_build_code_lengths;
if (coro_susp_point) {
v_length_n_bits = self->private_data.s_build_code_lengths.v_length_n_bits;
v_prev_code_length = self->private_data.s_build_code_lengths.v_prev_code_length;
v_s = self->private_data.s_build_code_lengths.v_s;
v_s_max = self->private_data.s_build_code_lengths.v_s_max;
v_node = self->private_data.s_build_code_lengths.v_node;
v_repeat_value = self->private_data.s_build_code_lengths.v_repeat_value;
v_repeat_n_bits = self->private_data.s_build_code_lengths.v_repeat_n_bits;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_length = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
self->private_impl.f_ht_code_lengths_remaining = self->private_impl.f_ht_n_symbols;
if (v_use_length != 0u) {
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_length_n_bits = (((self->private_impl.f_bits & 7u) * 2u) + 2u);
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
while (self->private_impl.f_n_bits < v_length_n_bits) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
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++;
v_c8 = t_2;
}
if (self->private_impl.f_n_bits >= v_length_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_length = ((self->private_impl.f_bits & ((((uint32_t)(1u)) << v_length_n_bits) - 1u)) + 2u);
self->private_impl.f_bits >>= v_length_n_bits;
self->private_impl.f_n_bits -= v_length_n_bits;
if (v_length > self->private_impl.f_ht_n_symbols) {
status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
goto exit;
}
self->private_impl.f_ht_code_lengths_remaining = v_length;
}
v_prev_code_length = 8u;
while (v_s < self->private_impl.f_ht_n_symbols) {
if (self->private_impl.f_ht_code_lengths_remaining <= 0u) {
while (v_s < self->private_impl.f_ht_n_symbols) {
self->private_data.f_code_lengths[v_s] = 0u;
v_s += 1u;
}
break;
}
self->private_impl.f_ht_code_lengths_remaining -= 1u;
v_h = 0u;
while (true) {
v_node = self->private_data.f_code_lengths_huffman_nodes[v_h];
if (v_node >= 32768u) {
break;
} else if (v_node > 35u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code);
goto exit;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
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_c8 = t_3;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_symbol = ((uint32_t)(((uint16_t)(v_node & 32767u))));
if (v_symbol == 0u) {
self->private_data.f_code_lengths[v_s] = 0u;
v_s += 1u;
continue;
} else if (v_symbol < 16u) {
v_prev_code_length = ((uint16_t)(v_symbol));
self->private_data.f_code_lengths[v_s] = v_prev_code_length;
v_s += 1u;
continue;
} else if (v_symbol == 16u) {
v_repeat_value = v_prev_code_length;
} else {
v_repeat_value = 0u;
}
v_repeat_n_bits = ((uint32_t)(WUFFS_WEBP__REPEAT_N_BITS[(v_symbol & 3u)]));
v_s_max = ((uint32_t)(((uint32_t)(WUFFS_WEBP__REPEAT_COUNTS[(v_symbol & 3u)])) + v_s));
if (self->private_impl.f_n_bits < v_repeat_n_bits) {
{
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_4 = *iop_a_src++;
v_c8 = t_4;
}
if (self->private_impl.f_n_bits >= v_repeat_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_s_max += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_repeat_n_bits) - 1u));
self->private_impl.f_bits >>= v_repeat_n_bits;
self->private_impl.f_n_bits -= v_repeat_n_bits;
if (v_s_max > self->private_impl.f_ht_n_symbols) {
status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
goto exit;
}
while (v_s < v_s_max) {
self->private_data.f_code_lengths[v_s] = v_repeat_value;
v_s += 1u;
}
}
goto ok;
ok:
self->private_impl.p_build_code_lengths = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_build_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_build_code_lengths.v_length_n_bits = v_length_n_bits;
self->private_data.s_build_code_lengths.v_prev_code_length = v_prev_code_length;
self->private_data.s_build_code_lengths.v_s = v_s;
self->private_data.s_build_code_lengths.v_s_max = v_s_max;
self->private_data.s_build_code_lengths.v_node = v_node;
self->private_data.s_build_code_lengths.v_repeat_value = v_repeat_value;
self->private_data.s_build_code_lengths.v_repeat_n_bits = v_repeat_n_bits;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_pixels_slow
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels_slow(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint64_t v_p = 0;
uint64_t v_p_max = 0;
uint32_t v_tile_size_log2 = 0;
uint32_t v_width_in_tiles = 0;
uint32_t v_x = 0;
uint32_t v_y = 0;
uint32_t v_i = 0;
uint32_t v_hg = 0;
uint32_t v_h = 0;
uint16_t v_node = 0;
uint32_t v_pixel_g = 0;
uint32_t v_color = 0;
wuffs_base__slice_u8 v_dst_pixel = {0};
uint32_t v_back_ref_len_n_bits = 0;
uint32_t v_back_ref_len_minus_1 = 0;
uint32_t v_back_ref_dist_n_bits = 0;
uint32_t v_back_ref_dist_sym = 0;
uint32_t v_back_ref_dist_premap_minus_1 = 0;
uint32_t v_back_ref_dist_minus_1 = 0;
uint32_t v_dm = 0;
uint32_t v_dx = 0;
uint32_t v_dy = 0;
uint64_t v_p_end = 0;
uint64_t v_dist4 = 0;
uint64_t v_q = 0;
wuffs_base__slice_u8 v_color_cache_pixels = {0};
uint64_t v_color_cache_p = 0;
uint32_t v_color_cache_shift = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_pixels_slow;
if (coro_susp_point) {
v_p = self->private_data.s_decode_pixels_slow.v_p;
v_p_max = self->private_data.s_decode_pixels_slow.v_p_max;
v_tile_size_log2 = self->private_data.s_decode_pixels_slow.v_tile_size_log2;
v_width_in_tiles = self->private_data.s_decode_pixels_slow.v_width_in_tiles;
v_x = self->private_data.s_decode_pixels_slow.v_x;
v_y = self->private_data.s_decode_pixels_slow.v_y;
v_hg = self->private_data.s_decode_pixels_slow.v_hg;
v_node = self->private_data.s_decode_pixels_slow.v_node;
v_color = self->private_data.s_decode_pixels_slow.v_color;
v_back_ref_len_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits;
v_back_ref_len_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1;
v_back_ref_dist_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits;
v_back_ref_dist_premap_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1;
v_color_cache_p = self->private_data.s_decode_pixels_slow.v_color_cache_p;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
v_p_max = ((uint64_t)((4u * a_width * a_height)));
if (((uint64_t)(a_dst.len)) < v_p_max) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
if (a_tile_size_log2 != 0u) {
v_tile_size_log2 = a_tile_size_log2;
v_width_in_tiles = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
} else {
v_tile_size_log2 = 31u;
v_width_in_tiles = 1u;
}
while (v_p < v_p_max) {
v_i = ((uint32_t)(((uint32_t)(((uint32_t)(((uint32_t)((v_y >> v_tile_size_log2) * v_width_in_tiles)) + (v_x >> v_tile_size_log2))) * 4u)) + 1u));
if (((uint64_t)(v_i)) < ((uint64_t)(a_tile_data.len))) {
v_hg = ((uint32_t)(a_tile_data.ptr[((uint64_t)(v_i))]));
}
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[0u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
} else if (v_node > 6265u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code);
goto exit;
}
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_pixel_g = ((uint32_t)(((uint16_t)(v_node & 32767u))));
if (v_pixel_g < 256u) {
v_color = (v_pixel_g << 8u);
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[1u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_1;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 16u);
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[2u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
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++;
v_c8 = t_2;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 0u);
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[3u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
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_c8 = t_3;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 24u);
} else if (v_pixel_g < 280u) {
if (v_pixel_g < 260u) {
v_back_ref_len_minus_1 = (v_pixel_g - 256u);
} else {
v_back_ref_len_n_bits = ((v_pixel_g - 258u) >> 1u);
v_back_ref_len_minus_1 = ((((uint32_t)(2u)) + (v_pixel_g & 1u)) << v_back_ref_len_n_bits);
while (self->private_impl.f_n_bits < v_back_ref_len_n_bits) {
{
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_4 = *iop_a_src++;
v_c8 = t_4;
}
if (self->private_impl.f_n_bits >= v_back_ref_len_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_back_ref_len_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_len_n_bits) - 1u));
self->private_impl.f_bits >>= v_back_ref_len_n_bits;
self->private_impl.f_n_bits -= v_back_ref_len_n_bits;
}
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[4u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
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_c8 = t_5;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_back_ref_dist_sym = ((uint32_t)(((uint16_t)(v_node & 32767u))));
if (v_back_ref_dist_sym < 4u) {
v_back_ref_dist_premap_minus_1 = v_back_ref_dist_sym;
} else if (v_back_ref_dist_sym < 40u) {
v_back_ref_dist_n_bits = ((v_back_ref_dist_sym - 2u) >> 1u);
v_back_ref_dist_premap_minus_1 = ((((uint32_t)(2u)) + (v_back_ref_dist_sym & 1u)) << v_back_ref_dist_n_bits);
while (self->private_impl.f_n_bits < v_back_ref_dist_n_bits) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
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_c8 = t_6;
}
if (self->private_impl.f_n_bits >= v_back_ref_dist_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_back_ref_dist_premap_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_dist_n_bits) - 1u));
self->private_impl.f_bits >>= v_back_ref_dist_n_bits;
self->private_impl.f_n_bits -= v_back_ref_dist_n_bits;
}
if (v_back_ref_dist_premap_minus_1 >= 120u) {
v_back_ref_dist_minus_1 = (v_back_ref_dist_premap_minus_1 - 120u);
} else {
v_dm = ((uint32_t)(WUFFS_WEBP__DISTANCE_MAP[v_back_ref_dist_premap_minus_1]));
v_dy = (v_dm >> 4u);
v_dx = ((uint32_t)(7u - (v_dm & 15u)));
v_back_ref_dist_minus_1 = ((uint32_t)((a_width * v_dy) + v_dx));
}
v_p_end = (v_p + ((uint64_t)(((v_back_ref_len_minus_1 + 1u) * 4u))));
v_dist4 = ((((uint64_t)(v_back_ref_dist_minus_1)) * 4u) + 4u);
if ((v_p_end > v_p_max) || (v_p_end > ((uint64_t)(a_dst.len))) || (v_p < v_dist4)) {
status = wuffs_base__make_status(wuffs_webp__error__bad_back_reference);
goto exit;
}
v_q = (v_p - v_dist4);
while ((v_q < v_p) && (v_p < v_p_end)) {
a_dst.ptr[v_p] = a_dst.ptr[v_q];
v_p += 1u;
v_q += 1u;
}
v_x += (v_back_ref_len_minus_1 + 1u);
while (v_x >= a_width) {
v_x -= a_width;
v_y += 1u;
}
continue;
} else {
if ((v_color_cache_p > v_p) || (v_p > ((uint64_t)(a_dst.len)))) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
v_color_cache_pixels = wuffs_base__slice_u8__subslice_ij(a_dst, v_color_cache_p, v_p);
v_color_cache_p = v_p;
v_color_cache_shift = ((32u - self->private_impl.f_color_cache_bits) & 31u);
while (((uint64_t)(v_color_cache_pixels.len)) >= 4u) {
v_color = wuffs_base__peek_u32le__no_bounds_check(v_color_cache_pixels.ptr);
self->private_data.f_color_cache[((((uint32_t)(v_color * 506832829u)) >> v_color_cache_shift) & 2047u)] = v_color;
v_color_cache_pixels = wuffs_base__slice_u8__subslice_i(v_color_cache_pixels, 4u);
}
v_color = self->private_data.f_color_cache[((v_pixel_g - 280u) & 2047u)];
}
if (v_p > ((uint64_t)(a_dst.len))) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
v_dst_pixel = wuffs_base__slice_u8__subslice_i(a_dst, v_p);
if (((uint64_t)(v_dst_pixel.len)) < 4u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
wuffs_base__poke_u32le__no_bounds_check(v_dst_pixel.ptr, v_color);
v_p += 4u;
v_x += 1u;
if (v_x == a_width) {
v_x = 0u;
v_y += 1u;
}
}
goto ok;
ok:
self->private_impl.p_decode_pixels_slow = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_pixels_slow = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_pixels_slow.v_p = v_p;
self->private_data.s_decode_pixels_slow.v_p_max = v_p_max;
self->private_data.s_decode_pixels_slow.v_tile_size_log2 = v_tile_size_log2;
self->private_data.s_decode_pixels_slow.v_width_in_tiles = v_width_in_tiles;
self->private_data.s_decode_pixels_slow.v_x = v_x;
self->private_data.s_decode_pixels_slow.v_y = v_y;
self->private_data.s_decode_pixels_slow.v_hg = v_hg;
self->private_data.s_decode_pixels_slow.v_node = v_node;
self->private_data.s_decode_pixels_slow.v_color = v_color;
self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits = v_back_ref_len_n_bits;
self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1 = v_back_ref_len_minus_1;
self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits = v_back_ref_dist_n_bits;
self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1 = v_back_ref_dist_premap_minus_1;
self->private_data.s_decode_pixels_slow.v_color_cache_p = v_color_cache_p;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.apply_transform_predictor
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_predictor(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data) {
uint64_t v_w4 = 0;
wuffs_base__slice_u8 v_prev_row = {0};
wuffs_base__slice_u8 v_curr_row = {0};
uint32_t v_tile_size_log2 = 0;
uint32_t v_tiles_per_row = 0;
uint32_t v_mask = 0;
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_t = 0;
wuffs_base__slice_u8 v_tile_data = {0};
uint8_t v_mode = 0;
uint32_t v_l0 = 0;
uint32_t v_l1 = 0;
uint32_t v_l2 = 0;
uint32_t v_l3 = 0;
uint32_t v_c0 = 0;
uint32_t v_c1 = 0;
uint32_t v_c2 = 0;
uint32_t v_c3 = 0;
uint32_t v_t0 = 0;
uint32_t v_t1 = 0;
uint32_t v_t2 = 0;
uint32_t v_t3 = 0;
uint32_t v_sum_l = 0;
uint32_t v_sum_t = 0;
if ((self->private_impl.f_width <= 0u) || (self->private_impl.f_height <= 0u)) {
return wuffs_base__make_empty_struct();
}
v_w4 = ((uint64_t)((self->private_impl.f_width * 4u)));
v_curr_row = wuffs_base__utility__empty_slice_u8();
if (v_w4 <= ((uint64_t)(a_pix.len))) {
v_curr_row = wuffs_base__slice_u8__subslice_j(a_pix, v_w4);
}
if (((uint64_t)(v_curr_row.len)) >= 4u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[3u] += 255u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
while (((uint64_t)(v_curr_row.len)) >= 8u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_curr_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_curr_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
}
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[0u]));
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_y = 1u;
while (v_y < self->private_impl.f_height) {
v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row)));
v_tile_data = wuffs_base__utility__empty_slice_u8();
if (v_t <= ((uint64_t)(a_tile_data.len))) {
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
if (((uint64_t)(v_tile_data.len)) >= 4u) {
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
}
}
if (v_w4 <= ((uint64_t)(a_pix.len))) {
v_prev_row = a_pix;
a_pix = wuffs_base__slice_u8__subslice_i(a_pix, v_w4);
v_curr_row = a_pix;
}
if ((((uint64_t)(v_prev_row.len)) >= 4u) && (((uint64_t)(v_curr_row.len)) >= 4u)) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[0u] += v_prev_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[1u] += v_prev_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[2u] += v_prev_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[3u] += v_prev_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
v_x = 1u;
while (v_x < self->private_impl.f_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
}
if ((((uint64_t)(v_prev_row.len)) < 12u) || (((uint64_t)(v_curr_row.len)) < 8u)) {
break;
}
if (v_mode == 0u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += 255u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 1u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_curr_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_curr_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 2u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_prev_row.ptr[4u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_prev_row.ptr[5u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_prev_row.ptr[6u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_prev_row.ptr[7u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 3u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_prev_row.ptr[8u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_prev_row.ptr[9u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_prev_row.ptr[10u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_prev_row.ptr[11u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 4u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_prev_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_prev_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_prev_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_prev_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 5u) {
v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u);
v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u);
v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u);
v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 6u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 7u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 8u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 9u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 10u) {
v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u);
v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u);
v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u);
v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u);
v_t0 = ((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u);
v_t1 = ((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u);
v_t2 = ((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u);
v_t3 = ((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + v_t0) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + v_t1) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + v_t2) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + v_t3) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 11u) {
v_l0 = ((uint32_t)(v_curr_row.ptr[0u]));
v_l1 = ((uint32_t)(v_curr_row.ptr[1u]));
v_l2 = ((uint32_t)(v_curr_row.ptr[2u]));
v_l3 = ((uint32_t)(v_curr_row.ptr[3u]));
v_c0 = ((uint32_t)(v_prev_row.ptr[0u]));
v_c1 = ((uint32_t)(v_prev_row.ptr[1u]));
v_c2 = ((uint32_t)(v_prev_row.ptr[2u]));
v_c3 = ((uint32_t)(v_prev_row.ptr[3u]));
v_t0 = ((uint32_t)(v_prev_row.ptr[4u]));
v_t1 = ((uint32_t)(v_prev_row.ptr[5u]));
v_t2 = ((uint32_t)(v_prev_row.ptr[6u]));
v_t3 = ((uint32_t)(v_prev_row.ptr[7u]));
v_sum_l = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_t0) +
wuffs_webp__decoder__absolute_difference(self, v_c1, v_t1) +
wuffs_webp__decoder__absolute_difference(self, v_c2, v_t2) +
wuffs_webp__decoder__absolute_difference(self, v_c3, v_t3));
v_sum_t = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_l0) +
wuffs_webp__decoder__absolute_difference(self, v_c1, v_l1) +
wuffs_webp__decoder__absolute_difference(self, v_c2, v_l2) +
wuffs_webp__decoder__absolute_difference(self, v_c3, v_l3));
if (v_sum_l < v_sum_t) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(v_l0));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(v_l1));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(v_l2));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(v_l3));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(v_t0));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(v_t1));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(v_t2));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(v_t3));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
} else if (v_mode == 12u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 13u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
v_prev_row = wuffs_base__slice_u8__subslice_i(v_prev_row, 4u);
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.absolute_difference
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
wuffs_webp__decoder__absolute_difference(
const wuffs_webp__decoder* self,
uint32_t a_a,
uint32_t a_b) {
if (a_a < a_b) {
return (a_b - a_a);
}
return (a_a - a_b);
}
// -------- func webp.decoder.mode12
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode12(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl) {
uint32_t v_v = 0;
v_v = ((uint32_t)((((uint32_t)(a_l)) + ((uint32_t)(a_t))) - ((uint32_t)(a_tl))));
if (v_v < 256u) {
return ((uint8_t)(v_v));
} else if (v_v < 512u) {
return 255u;
}
return 0u;
}
// -------- func webp.decoder.mode13
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode13(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl) {
uint32_t v_x = 0;
uint32_t v_y = 0;
uint32_t v_z = 0;
uint32_t v_v = 0;
v_x = ((((uint32_t)(a_l)) + ((uint32_t)(a_t))) / 2u);
v_y = ((uint32_t)(a_tl));
v_z = ((uint32_t)(v_x - v_y));
v_v = ((uint32_t)(v_x + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_z + (v_z >> 31u))), 1u)));
if (v_v < 256u) {
return ((uint8_t)(v_v));
} else if (v_v < 512u) {
return 255u;
}
return 0u;
}
// -------- func webp.decoder.apply_transform_cross_color
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_cross_color(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data) {
uint32_t v_tile_size_log2 = 0;
uint32_t v_tiles_per_row = 0;
uint32_t v_mask = 0;
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_t = 0;
wuffs_base__slice_u8 v_tile_data = {0};
uint32_t v_g2r = 0;
uint32_t v_g2b = 0;
uint32_t v_r2b = 0;
uint8_t v_b = 0;
uint8_t v_g = 0;
uint8_t v_r = 0;
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[1u]));
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row)));
v_tile_data = wuffs_base__utility__empty_slice_u8();
if (v_t <= ((uint64_t)(a_tile_data.len))) {
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
}
v_x = 0u;
while (v_x < self->private_impl.f_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
v_g2r = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[0u]];
v_g2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[1u]];
v_r2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[2u]];
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
}
if (((uint64_t)(a_pix.len)) >= 4u) {
v_b = a_pix.ptr[0u];
v_g = a_pix.ptr[1u];
v_r = a_pix.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_r += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2r)) >> 5u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2b)) >> 5u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_r] * v_r2b)) >> 5u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
a_pix.ptr[0u] = v_b;
a_pix.ptr[2u] = v_r;
a_pix = wuffs_base__slice_u8__subslice_i(a_pix, 4u);
}
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.apply_transform_subtract_green
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_subtract_green(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix) {
wuffs_base__slice_u8 v_p = {0};
uint8_t v_g = 0;
{
wuffs_base__slice_u8 i_slice_p = a_pix;
v_p.ptr = i_slice_p.ptr;
v_p.len = 4;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 4) * 4));
while (v_p.ptr < i_end0_p) {
v_g = v_p.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[0u] += v_g;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[2u] += v_g;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_p.ptr += 4;
}
v_p.len = 0;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.apply_transform_color_indexing
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_color_indexing(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix) {
uint32_t v_tile_size_log2 = 0;
uint32_t v_bits_per_pixel = 0;
uint32_t v_x_mask = 0;
uint32_t v_s_mask = 0;
uint64_t v_src_index = 0;
uint32_t v_y = 0;
uint64_t v_di = 0;
uint64_t v_dj = 0;
wuffs_base__slice_u8 v_dst = {0};
uint32_t v_x = 0;
uint32_t v_s = 0;
uint32_t v_p = 0;
uint8_t v_p0 = 0;
uint8_t v_p1 = 0;
uint8_t v_p2 = 0;
uint8_t v_p3 = 0;
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u]));
if (v_tile_size_log2 == 0u) {
}
v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2);
v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_s_mask = ((((uint32_t)(1u)) << v_bits_per_pixel) - 1u);
v_src_index = ((uint64_t)((self->private_impl.f_workbuf_offset_for_color_indexing + 1u)));
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_di = ((uint64_t)((4u * (v_y + 0u) * self->private_impl.f_width)));
v_dj = ((uint64_t)((4u * (v_y + 1u) * self->private_impl.f_width)));
if ((v_di > v_dj) || (v_dj > ((uint64_t)(a_pix.len)))) {
break;
}
v_dst = wuffs_base__slice_u8__subslice_ij(a_pix, v_di, v_dj);
v_x = 0u;
while (((uint64_t)(v_dst.len)) >= 4u) {
if (((v_x & v_x_mask) == 0u) && (v_src_index < ((uint64_t)(a_pix.len)))) {
v_s = ((uint32_t)(a_pix.ptr[v_src_index]));
v_src_index += 4u;
}
v_p = ((v_s & v_s_mask) * 4u);
v_s >>= v_bits_per_pixel;
v_p0 = self->private_data.f_palette[(v_p + 0u)];
v_p1 = self->private_data.f_palette[(v_p + 1u)];
v_p2 = self->private_data.f_palette[(v_p + 2u)];
v_p3 = self->private_data.f_palette[(v_p + 3u)];
v_dst.ptr[0u] = v_p0;
v_dst.ptr[1u] = v_p1;
v_dst.ptr[2u] = v_p2;
v_dst.ptr[3u] = v_p3;
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, 4u);
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.get_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__get_quirk(
const wuffs_webp__decoder* self,
uint32_t a_key) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return 0u;
}
// -------- func webp.decoder.set_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__set_quirk(
wuffs_webp__decoder* self,
uint32_t a_key,
uint64_t a_value) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
// -------- func webp.decoder.decode_image_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 1)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_image_config(self, a_dst, a_src);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_image_config
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 0u) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1179011410u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
self->private_impl.f_riff_chunk_length = t_1;
}
if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_riff_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_riff_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_riff_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if (a_dst != NULL) {
wuffs_base__image_config__set(
a_dst,
self->private_impl.f_pixfmt,
0u,
self->private_impl.f_width,
self->private_impl.f_height,
self->private_impl.f_frame_config_io_position,
false);
}
self->private_impl.f_call_sequence = 32u;
ok:
self->private_impl.p_do_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1346520407u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
if (v_c32 == 540561494u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
} else if (v_c32 == 1278758998u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
if (num_bits_2 == 24) {
t_2 = ((uint32_t)(*scratch));
break;
}
num_bits_2 += 8u;
*scratch |= ((uint64_t)(num_bits_2)) << 56;
}
}
self->private_impl.f_sub_chunk_length = t_2;
}
if (self->private_impl.f_sub_chunk_length < 4u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_3 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src);
v_status = t_3;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
}
} else if (v_c32 == 1480085590u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
} else {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
ok:
self->private_impl.p_do_decode_image_config_limited = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited_vp8l
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint32_t v_transform_size = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_0 = *iop_a_src++;
v_c32 = t_0;
}
if (v_c32 != 47u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
self->private_impl.f_pixfmt = 2415954056u;
if ((v_c32 & 1u) != 0u) {
self->private_impl.f_pixfmt = 2164295816u;
}
v_c32 >>= 1u;
if (v_c32 != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (0u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (1u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
goto ok;
ok:
self->private_impl.p_do_decode_image_config_limited_vp8l = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 2)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_frame_config(self, a_dst, a_src);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 2 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 32u) {
} else if (self->private_impl.f_call_sequence < 32u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_image_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 40u) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
} else if (self->private_impl.f_call_sequence == 64u) {
self->private_impl.f_call_sequence = 96u;
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
if (a_dst != NULL) {
wuffs_base__frame_config__set(
a_dst,
wuffs_base__utility__make_rect_ie_u32(
0u,
0u,
self->private_impl.f_width,
self->private_impl.f_height),
((wuffs_base__flicks)(0u)),
0u,
self->private_impl.f_frame_config_io_position,
0u,
false,
false,
0u);
}
self->private_impl.f_call_sequence = 64u;
ok:
self->private_impl.p_do_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_dst || !a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 3)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_frame(self,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_has_more = 0;
uint32_t v_width = 0;
wuffs_base__slice_u8 v_dst = {0};
wuffs_base__slice_u8 v_tile_data = {0};
wuffs_base__status v_status = wuffs_base__make_status(NULL);
wuffs_base__slice_u8 v_pix = {0};
uint32_t v_which = 0;
uint32_t v_transform_type = 0;
uint64_t v_ti = 0;
uint64_t v_tj = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
if (coro_susp_point) {
v_width = self->private_data.s_do_decode_frame.v_width;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 64u) {
} else if (self->private_impl.f_call_sequence < 64u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
self->private_impl.f_seen_transform[0u] = false;
self->private_impl.f_seen_transform[1u] = false;
self->private_impl.f_seen_transform[2u] = false;
self->private_impl.f_seen_transform[3u] = false;
self->private_impl.f_n_transforms = 0u;
while (true) {
if (self->private_impl.f_n_bits < 1u) {
{
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_0 = *iop_a_src++;
v_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_has_more = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
if (v_has_more == 0u) {
break;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
}
v_width = self->private_impl.f_width;
if (self->private_impl.f_seen_transform[3u]) {
v_width = self->private_impl.f_color_indexing_width;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_overall_color_cache_bits = self->private_impl.f_color_cache_bits;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_color_cache_bits = self->private_impl.f_overall_color_cache_bits;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
while (true) {
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_dst = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_1 = wuffs_webp__decoder__decode_pixels(self,
v_dst,
a_src,
v_width,
self->private_impl.f_height,
v_tile_data,
self->private_impl.f_overall_tile_size_log2);
v_status = t_1;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
}
if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
v_which = self->private_impl.f_n_transforms;
while (v_which > 0u) {
v_which -= 1u;
v_transform_type = ((uint32_t)(self->private_impl.f_transform_type[v_which]));
v_tile_data = wuffs_base__utility__empty_slice_u8();
if (v_transform_type < 2u) {
v_ti = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)]));
v_tj = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]));
if ((v_ti <= v_tj) && (v_tj <= ((uint64_t)(a_workbuf.len)))) {
v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_ti, v_tj);
}
}
if (v_transform_type == 0u) {
wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_tile_data);
} else if (v_transform_type == 1u) {
wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_tile_data);
} else if (v_transform_type == 2u) {
wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix);
} else {
wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix);
v_width = self->private_impl.f_width;
}
}
v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, a_blend);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
self->private_impl.f_call_sequence = 96u;
ok:
self->private_impl.p_do_decode_frame = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_do_decode_frame.v_width = v_width;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_transform
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_transform(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_transform_type = 0;
uint32_t v_tile_size_log2 = 0;
wuffs_base__slice_u8 v_p = {0};
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_transform;
if (coro_susp_point) {
v_transform_type = self->private_data.s_decode_transform.v_transform_type;
v_tile_size_log2 = self->private_data.s_decode_transform.v_tile_size_log2;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 2u) {
{
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_c8 = t_0;
}
if (self->private_impl.f_n_bits >= 2u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_transform_type = (self->private_impl.f_bits & 3u);
self->private_impl.f_bits >>= 2u;
self->private_impl.f_n_bits -= 2u;
if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) {
status = wuffs_base__make_status(wuffs_webp__error__bad_transform);
goto exit;
} else if (self->private_impl.f_seen_transform[3u]) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_transform_after_color_indexing_transform);
goto exit;
}
self->private_impl.f_seen_transform[v_transform_type] = true;
self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type));
self->private_impl.f_n_transforms += 1u;
if (v_transform_type < 2u) {
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u);
self->private_impl.f_transform_tile_size_log2[v_transform_type] = ((uint8_t)(v_tile_size_log2));
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_webp__decoder__decode_pixels(self,
wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))),
a_src,
((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(),
0u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (v_transform_type == 2u) {
} else {
if (self->private_impl.f_n_bits < 8u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
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++;
v_c8 = t_2;
}
if (self->private_impl.f_n_bits >= 8u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
self->private_impl.f_color_indexing_palette_size = ((self->private_impl.f_bits & 255u) + 1u);
self->private_impl.f_bits >>= 8u;
self->private_impl.f_n_bits -= 8u;
if (self->private_impl.f_color_indexing_palette_size <= 2u) {
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 7u) / 8u);
self->private_impl.f_transform_tile_size_log2[3u] = 3u;
} else if (self->private_impl.f_color_indexing_palette_size <= 4u) {
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 3u) / 4u);
self->private_impl.f_transform_tile_size_log2[3u] = 2u;
} else if (self->private_impl.f_color_indexing_palette_size <= 16u) {
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 1u) / 2u);
self->private_impl.f_transform_tile_size_log2[3u] = 1u;
} else {
self->private_impl.f_color_indexing_width = self->private_impl.f_width;
self->private_impl.f_transform_tile_size_log2[3u] = 0u;
}
if (self->private_impl.f_width >= self->private_impl.f_color_indexing_width) {
self->private_impl.f_workbuf_offset_for_color_indexing = (4u * (self->private_impl.f_width - self->private_impl.f_color_indexing_width) * self->private_impl.f_height);
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
status = wuffs_webp__decoder__decode_pixels(self,
wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)),
a_src,
self->private_impl.f_color_indexing_palette_size,
1u,
wuffs_base__utility__empty_slice_u8(),
0u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
wuffs_private_impl__bulk_memset(&self->private_data.f_palette[(4u * self->private_impl.f_color_indexing_palette_size)], (1024u - (4u * self->private_impl.f_color_indexing_palette_size)), 0u);
v_p = wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size));
while (((uint64_t)(v_p.len)) >= 8u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[4u] += v_p.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[5u] += v_p.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[6u] += v_p.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[7u] += v_p.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u);
}
}
goto ok;
ok:
self->private_impl.p_decode_transform = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_transform = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_transform.v_transform_type = v_transform_type;
self->private_data.s_decode_transform.v_tile_size_log2 = v_tile_size_log2;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_color_cache_parameters
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_color_cache_parameters(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_color_cache = 0;
uint32_t v_color_cache_bits = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_color_cache_parameters;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_color_cache = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
self->private_impl.f_color_cache_bits = 0u;
if (v_use_color_cache != 0u) {
if (self->private_impl.f_n_bits < 4u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 4u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_color_cache_bits = (self->private_impl.f_bits & 15u);
self->private_impl.f_bits >>= 4u;
self->private_impl.f_n_bits -= 4u;
if ((v_color_cache_bits < 1u) || (11u < v_color_cache_bits)) {
status = wuffs_base__make_status(wuffs_webp__error__bad_color_cache);
goto exit;
}
self->private_impl.f_color_cache_bits = v_color_cache_bits;
}
goto ok;
ok:
self->private_impl.p_decode_color_cache_parameters = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_color_cache_parameters = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_hg_table
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_hg_table(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_hg_table = 0;
uint32_t v_tile_size_log2 = 0;
wuffs_base__slice_u8 v_hg_pixels = {0};
uint64_t v_n = 0;
wuffs_base__slice_u8 v_p = {0};
uint32_t v_hg_plus_1 = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_hg_table;
if (coro_susp_point) {
v_tile_size_log2 = self->private_data.s_decode_hg_table.v_tile_size_log2;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_hg_table = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
if (v_use_hg_table == 0u) {
self->private_impl.f_overall_n_huffman_groups = 1u;
self->private_impl.f_overall_tile_size_log2 = 0u;
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
if (((uint64_t)(v_hg_pixels.len)) >= 4u) {
v_hg_pixels.ptr[0u] = 0u;
v_hg_pixels.ptr[1u] = 0u;
v_hg_pixels.ptr[2u] = 0u;
v_hg_pixels.ptr[3u] = 0u;
}
status = wuffs_base__make_status(NULL);
goto ok;
}
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u);
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
self->private_impl.f_overall_tile_size_log2 = v_tile_size_log2;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_webp__decoder__decode_pixels(self,
wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))),
a_src,
((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(),
0u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_overall_n_huffman_groups = 1u;
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
v_n = ((uint64_t)((((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * 4u)));
if (v_n > ((uint64_t)(v_hg_pixels.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_p = wuffs_base__slice_u8__subslice_j(v_hg_pixels, v_n);
while (((uint64_t)(v_p.len)) >= 4u) {
if (v_p.ptr[2u] != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_number_of_huffman_groups);
goto exit;
}
v_hg_plus_1 = (((uint32_t)(v_p.ptr[1u])) + 1u);
if (self->private_impl.f_overall_n_huffman_groups < v_hg_plus_1) {
self->private_impl.f_overall_n_huffman_groups = v_hg_plus_1;
}
v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u);
}
ok:
self->private_impl.p_decode_hg_table = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_hg_table = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_hg_table.v_tile_size_log2 = v_tile_size_log2;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_pixels
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_i = 0;
uint32_t v_n = 0;
uint32_t coro_susp_point = self->private_impl.p_decode_pixels;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
v_i = 0u;
v_n = (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits);
while (v_i < v_n) {
self->private_data.f_color_cache[v_i] = 0u;
v_i += 1u;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__decode_pixels_slow(self,
a_dst,
a_src,
a_width,
a_height,
a_tile_data,
a_tile_size_log2);
if (status.repr) {
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_pixels = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_pixels = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
return status;
}
// -------- func webp.decoder.swizzle
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__swizzle(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_src,
wuffs_base__pixel_blend a_blend) {
wuffs_base__status v_status = wuffs_base__make_status(NULL);
wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0;
uint32_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_bytes_per_row = 0;
wuffs_base__slice_u8 v_dst_palette = {0};
wuffs_base__table_u8 v_tab = {0};
uint64_t v_src_bytes_per_row = 0;
wuffs_base__slice_u8 v_dst = {0};
uint32_t v_y = 0;
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
wuffs_base__pixel_buffer__pixel_format(a_dst),
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)),
wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt),
wuffs_base__utility__empty_slice_u8(),
a_blend);
if ( ! wuffs_base__status__is_ok(&v_status)) {
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
}
v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst);
v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt);
if ((v_dst_bits_per_pixel & 7u) != 0u) {
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u);
v_dst_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 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_palette, 1024));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u);
v_src_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 4u)));
while (v_src_bytes_per_row <= ((uint64_t)(a_src.len))) {
v_dst = wuffs_private_impl__table_u8__row_u32(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);
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(a_src, v_src_bytes_per_row));
a_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_bytes_per_row);
v_y += 1u;
}
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.frame_dirty_rect
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32
wuffs_webp__decoder__frame_dirty_rect(
const wuffs_webp__decoder* self) {
if (!self) {
return wuffs_base__utility__empty_rect_ie_u32();
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return wuffs_base__utility__empty_rect_ie_u32();
}
return wuffs_base__utility__make_rect_ie_u32(
0u,
0u,
self->private_impl.f_width,
self->private_impl.f_height);
}
// -------- func webp.decoder.num_animation_loops
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_webp__decoder__num_animation_loops(
const wuffs_webp__decoder* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return 0u;
}
// -------- func webp.decoder.num_decoded_frame_configs
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frame_configs(
const wuffs_webp__decoder* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
if (self->private_impl.f_call_sequence > 32u) {
return 1u;
}
return 0u;
}
// -------- func webp.decoder.num_decoded_frames
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frames(
const wuffs_webp__decoder* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
if (self->private_impl.f_call_sequence > 64u) {
return 1u;
}
return 0u;
}
// -------- func webp.decoder.restart_frame
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__restart_frame(
wuffs_webp__decoder* self,
uint64_t a_index,
uint64_t a_io_position) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (self->private_impl.f_call_sequence < 32u) {
return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
}
if ((a_index != 0u) || (a_io_position != self->private_impl.f_frame_config_io_position)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
self->private_impl.f_call_sequence = 40u;
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.set_report_metadata
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_webp__decoder__set_report_metadata(
wuffs_webp__decoder* self,
uint32_t a_fourcc,
bool a_report) {
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.tell_me_more
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__tell_me_more(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_dst || !a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 4)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
goto exit;
goto ok;
ok:
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.workbuf_len
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
wuffs_webp__decoder__workbuf_len(
const wuffs_webp__decoder* self) {
if (!self) {
return wuffs_base__utility__empty_range_ii_u64();
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return wuffs_base__utility__empty_range_ii_u64();
}
return wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])));
}
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__XXHASH32)
// ---------------- Status Codes Implementations
@@ -69603,6 +74649,7 @@ wuffs_xxhash64__hasher__checksum_u64(
// ---------------- Status Codes Implementations
const char wuffs_xz__error__bad_bcj_offset[] = "#xz: bad BCJ offset";
const char wuffs_xz__error__bad_block_header[] = "#xz: bad block header";
const char wuffs_xz__error__bad_checksum[] = "#xz: bad checksum";
const char wuffs_xz__error__bad_filter[] = "#xz: bad filter";
@@ -69654,6 +74701,12 @@ WUFFS_XZ__ZEROES[3] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 0u, 0u,
};
static const uint8_t
WUFFS_XZ__BCJ_OFFSET_ALIGNMENT[12] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 0u, 0u, 0u, 1u, 4u, 16u, 4u,
2u, 4u, 4u, 2u,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -71454,6 +76507,8 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_c32 = 0;
uint32_t v_alignment = 0;
uint8_t v_flags = 0;
uint8_t v_filter_id = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
@@ -71475,6 +76530,7 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
uint32_t coro_susp_point = self->private_impl.p_decode_block_header_sans_padding;
if (coro_susp_point) {
v_flags = self->private_data.s_decode_block_header_sans_padding.v_flags;
v_filter_id = self->private_data.s_decode_block_header_sans_padding.v_filter_id;
v_shift = self->private_data.s_decode_block_header_sans_padding.v_shift;
v_f = self->private_data.s_decode_block_header_sans_padding.v_f;
}
@@ -71677,8 +76733,16 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
*scratch |= ((uint64_t)(num_bits_7)) << 56;
}
}
self->private_impl.f_bcj_pos = t_7;
v_c32 = t_7;
}
v_alignment = ((uint32_t)(WUFFS_XZ__BCJ_OFFSET_ALIGNMENT[v_filter_id]));
if (v_alignment > 0u) {
if ((v_c32 % v_alignment) != 0u) {
status = wuffs_base__make_status(wuffs_xz__error__bad_bcj_offset);
goto exit;
}
}
self->private_impl.f_bcj_pos = v_c32;
} else {
status = wuffs_base__make_status(wuffs_xz__error__unsupported_filter);
goto exit;
@@ -71745,6 +76809,7 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
suspend:
self->private_impl.p_decode_block_header_sans_padding = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_block_header_sans_padding.v_flags = v_flags;
self->private_data.s_decode_block_header_sans_padding.v_filter_id = v_filter_id;
self->private_data.s_decode_block_header_sans_padding.v_shift = v_shift;
self->private_data.s_decode_block_header_sans_padding.v_f = v_f;
@@ -72826,6 +77891,11 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
case WUFFS_BASE__FOURCC__WBMP:
return wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();
#endif
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
case WUFFS_BASE__FOURCC__WEBP:
return wuffs_webp__decoder::alloc_as__wuffs_base__image_decoder();
#endif
}
return wuffs_base__image_decoder::unique_ptr(nullptr);
+20 -18
View File
@@ -85,15 +85,15 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// 00d5e35865a2f2718f4bb2596adaaa54bd639bbe committed on 2023-04-08.
#define WUFFS_VERSION 0x000030003
// a138188d5742c0469de983878a430bdbe7e50e77 committed on 2024-04-19.
#define WUFFS_VERSION 0x000030004
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 3
#define WUFFS_VERSION_PATCH 3
#define WUFFS_VERSION_PATCH 4
#define WUFFS_VERSION_PRE_RELEASE_LABEL ""
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3399
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20230408
#define WUFFS_VERSION_STRING "0.3.3+3399.20230408"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3401
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20240419
#define WUFFS_VERSION_STRING "0.3.4+3401.20240419"
// ---------------- Configuration
@@ -41569,20 +41569,22 @@ wuffs_png__decoder__decode_other_chunk(
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)) {
if (self->private_impl.f_seen_trns || ((self->private_impl.f_color_type == 3) && ! self->private_impl.f_seen_plte)) {
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(9);
status = wuffs_png__decoder__decode_trns(self, 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_color_type > 3) {
} else {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
status = wuffs_png__decoder__decode_trns(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_trns = true;
}
+5701 -631
View File
@@ -81,15 +81,43 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// a27a7598f09f289e5cf3c9f7d8c0bd8134c6a39d committed on 2024-04-06.
// 3be81643cc77e83e0125b150502ea273bf02839d committed on 2024-07-09.
#define WUFFS_VERSION 0x000040000
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 4
#define WUFFS_VERSION_PATCH 0
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.4"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3742
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20240406
#define WUFFS_VERSION_STRING "0.4.0-alpha.4+3742.20240406"
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.5"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3771
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20240709
#define WUFFS_VERSION_STRING "0.4.0-alpha.5+3771.20240709"
// ---------------- Private Implementation Macros Re-definition Check
// Users (those who #include the "wuffs-vM.N.c" file) should not define any
// WUFFS_PRIVATE_IMPL__ETC macros, only WUFFS_CONFIG__ETC macros (and
// WUFFS_IMPLEMENTATION). Mucking about with the private implementation macros
// is not supported and may break when upgrading to newer Wuffs versions.
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) || \
defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) || \
defined(WUFFS_PRIVATE_IMPL__HPD__DECIMAL_POINT__RANGE) || \
defined(WUFFS_PRIVATE_IMPL__HPD__DIGITS_PRECISION) || \
defined(WUFFS_PRIVATE_IMPL__HPD__SHIFT__MAX_INCL) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U16) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U32) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U64) || \
defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U8)
#if defined(__GNUC__) || defined(__clang__)
#warning "Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported"
#elif defined(_MSC_VER)
#pragma message("Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported")
#endif
#endif
// ---------------- Configuration
@@ -117,11 +145,11 @@ extern "C" {
// intrinsics. Look for __ARM_FEATURE_CRC32 instead.
#if defined(__ARM_FEATURE_CRC32)
#include <arm_acle.h>
#define WUFFS_BASE__CPU_ARCH__ARM_CRC32
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32
#endif // defined(__ARM_FEATURE_CRC32)
#if defined(__ARM_NEON)
#include <arm_neon.h>
#define WUFFS_BASE__CPU_ARCH__ARM_NEON
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON
#endif // defined(__ARM_NEON)
#endif // defined(__ARM_FEATURE_UNALIGNED) etc
@@ -129,26 +157,32 @@ 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(__i386__) || defined(__x86_64__)
//
// ----
//
// Technically, we could use the SSE family on 32-bit x86, not just 64-bit x86.
// But some intrinsics don't compile in 32-bit mode. It's not worth the hassle.
// https://github.com/google/wuffs/issues/145
#if defined(__x86_64__)
#if !defined(__native_client__)
#include <cpuid.h>
#include <x86intrin.h>
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#if defined(__x86_64__)
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(__x86_64__)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#endif // !defined(__native_client__)
#endif // defined(__i386__) || defined(__x86_64__)
#endif // defined(__x86_64__)
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_IX86) || defined(_M_X64)
#if defined(__AVX__) || defined(__clang__)
#if defined(_M_X64)
// We need <intrin.h> for the __cpuid function.
#include <intrin.h>
// That's not enough for X64 SIMD, with clang-cl, if we want to use
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#if defined(__AVX2__) || defined(__clang__)
// intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use
// "__attribute__((target(arg)))" without e.g. "/arch:AVX".
//
// Some web pages suggest that <immintrin.h> is all you need, as it pulls in
@@ -157,24 +191,22 @@ extern "C" {
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
#if defined(_M_X64)
#define WUFFS_BASE__CPU_ARCH__X86_64
#endif // defined(_M_X64)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#else // defined(__AVX__) || defined(__clang__)
#else // defined(__AVX2__) || defined(__clang__)
// clang-cl (which defines both __clang__ and _MSC_VER) supports
// "__attribute__((target(arg)))".
//
// 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
// property of the source file (e.g. a /arch:AVX2 or -mavx2 compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
#if !defined(WUFFS_CONFIG__I_KNOW_THAT_WUFFS_MSVC_PERFORMS_BEST_WITH_ARCH_AVX2)
#pragma message("Wuffs with MSVC+IX86/X64 performs best with /arch:AVX2")
#endif
#endif // defined(__AVX__) || defined(__clang__)
#endif // defined(_M_IX86) || defined(_M_X64)
#endif // defined(__AVX2__) || defined(__clang__)
#endif // defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
@@ -198,20 +230,20 @@ extern "C" {
static inline bool //
wuffs_base__cpu_arch__have_arm_crc32(void) {
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
return true;
#else
return false;
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
}
static inline bool //
wuffs_base__cpu_arch__have_arm_neon(void) {
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
return true;
#else
return false;
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
}
static inline bool //
@@ -220,7 +252,7 @@ wuffs_base__cpu_arch__have_x86_avx2(void) {
defined(__AVX2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_AVX2 = (1 << 5)
const unsigned int avx2_ebx7 = 0x00000020;
@@ -258,9 +290,9 @@ wuffs_base__cpu_arch__have_x86_avx2(void) {
}
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) &&
// defined(__AVX2__)
@@ -271,7 +303,7 @@ wuffs_base__cpu_arch__have_x86_bmi2(void) {
#if defined(__BMI2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_BMI2 = (1 << 8)
const unsigned int bmi2_ebx7 = 0x00000100;
@@ -293,9 +325,9 @@ wuffs_base__cpu_arch__have_x86_bmi2(void) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__BMI2__)
}
@@ -305,7 +337,7 @@ wuffs_base__cpu_arch__have_x86_sse42(void) {
#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
return true;
#else
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// GCC defines these macros but MSVC does not.
// - bit_PCLMUL = (1 << 1)
// - bit_POPCNT = (1 << 23)
@@ -329,9 +361,9 @@ wuffs_base__cpu_arch__have_x86_sse42(void) {
return true;
}
#else
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
#error "WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
return false;
#endif // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
}
@@ -13250,6 +13282,140 @@ struct wuffs_tga__decoder__struct {
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
// ---------------- Public Consts
// ---------------- Struct Declarations
typedef struct wuffs_vp8__placeholder__struct wuffs_vp8__placeholder;
#ifdef __cplusplus
extern "C" {
#endif
// ---------------- Public Initializer Prototypes
// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self,
// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
//
// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_vp8__placeholder__initialize(
wuffs_vp8__placeholder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options);
size_t
sizeof__wuffs_vp8__placeholder(void);
// ---------------- Allocs
// These functions allocate and initialize Wuffs structs. They return NULL if
// memory allocation fails. If they return non-NULL, there is no need to call
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
// calling free on the returned pointer. That pointer is effectively a C++
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
wuffs_vp8__placeholder*
wuffs_vp8__placeholder__alloc(void);
// ---------------- Upcasts
// ---------------- Public Function Prototypes
#ifdef __cplusplus
} // extern "C"
#endif
// ---------------- Struct Definitions
// These structs' fields, and the sizeof them, are private implementation
// details that aren't guaranteed to be stable across Wuffs versions.
//
// See https://en.wikipedia.org/wiki/Opaque_pointer#C
#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
struct wuffs_vp8__placeholder__struct {
// Do not access the private_impl's or private_data's fields directly. There
// is no API/ABI compatibility or safety guarantee if you do so. Instead, use
// the wuffs_foo__bar__baz functions.
//
// It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
// can be stack allocated when WUFFS_IMPLEMENTATION is defined.
struct {
uint32_t magic;
uint32_t active_coroutine;
wuffs_base__vtable null_vtable;
uint32_t f_placeholder;
} private_impl;
#ifdef __cplusplus
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
using unique_ptr = std::unique_ptr<wuffs_vp8__placeholder, wuffs_unique_ptr_deleter>;
// On failure, the alloc_etc functions return nullptr. They don't throw.
static inline unique_ptr
alloc() {
return unique_ptr(wuffs_vp8__placeholder__alloc());
}
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
// Disallow constructing or copying an object via standard C++ mechanisms,
// e.g. the "new" operator, as this struct is intentionally opaque. Its total
// size and field layout is not part of the public, stable, memory-safe API.
// Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and
// call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as
// their first argument) rather than tweaking bar.private_impl.qux fields.
//
// In C, we can just leave wuffs_foo__bar as an incomplete type (unless
// WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in
// order to provide convenience methods. These forward on "this", so that you
// can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)".
wuffs_vp8__placeholder__struct() = delete;
wuffs_vp8__placeholder__struct(const wuffs_vp8__placeholder__struct&) = delete;
wuffs_vp8__placeholder__struct& operator=(
const wuffs_vp8__placeholder__struct&) = delete;
#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
#if !defined(WUFFS_IMPLEMENTATION)
// As above, the size of the struct is not part of the public API, and unless
// WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap
// allocated, not stack allocated. Its size is not intended to be known at
// compile time, but it is unfortunately divulged as a side effect of
// defining C++ convenience methods. Use "sizeof__T()", calling the function,
// instead of "sizeof T", invoking the operator. To make the two values
// different, so that passing the latter will be rejected by the initialize
// function, we add an arbitrary amount of dead weight.
uint8_t dead_weight[123000000]; // 123 MB.
#endif // !defined(WUFFS_IMPLEMENTATION)
inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
initialize(
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options) {
return wuffs_vp8__placeholder__initialize(
this, sizeof_star_self, wuffs_version, options);
}
#endif // __cplusplus
}; // struct wuffs_vp8__placeholder__struct
#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
@@ -13605,6 +13771,458 @@ struct wuffs_wbmp__decoder__struct {
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
extern const char wuffs_webp__error__bad_huffman_code_over_subscribed[];
extern const char wuffs_webp__error__bad_huffman_code_under_subscribed[];
extern const char wuffs_webp__error__bad_huffman_code[];
extern const char wuffs_webp__error__bad_back_reference[];
extern const char wuffs_webp__error__bad_color_cache[];
extern const char wuffs_webp__error__bad_header[];
extern const char wuffs_webp__error__bad_transform[];
extern const char wuffs_webp__error__short_chunk[];
extern const char wuffs_webp__error__truncated_input[];
extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[];
extern const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[];
extern const char wuffs_webp__error__unsupported_webp_file[];
// ---------------- Public Consts
#define WUFFS_WEBP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u
// ---------------- Struct Declarations
typedef struct wuffs_webp__decoder__struct wuffs_webp__decoder;
#ifdef __cplusplus
extern "C" {
#endif
// ---------------- Public Initializer Prototypes
// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self,
// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
//
// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_webp__decoder__initialize(
wuffs_webp__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options);
size_t
sizeof__wuffs_webp__decoder(void);
// ---------------- Allocs
// These functions allocate and initialize Wuffs structs. They return NULL if
// memory allocation fails. If they return non-NULL, there is no need to call
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
// calling free on the returned pointer. That pointer is effectively a C++
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
wuffs_webp__decoder*
wuffs_webp__decoder__alloc(void);
static inline wuffs_base__image_decoder*
wuffs_webp__decoder__alloc_as__wuffs_base__image_decoder(void) {
return (wuffs_base__image_decoder*)(wuffs_webp__decoder__alloc());
}
// ---------------- Upcasts
static inline wuffs_base__image_decoder*
wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(
wuffs_webp__decoder* p) {
return (wuffs_base__image_decoder*)p;
}
// ---------------- Public Function Prototypes
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__get_quirk(
const wuffs_webp__decoder* self,
uint32_t a_key);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__set_quirk(
wuffs_webp__decoder* self,
uint32_t a_key,
uint64_t a_value);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32
wuffs_webp__decoder__frame_dirty_rect(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_webp__decoder__num_animation_loops(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frame_configs(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frames(
const wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__restart_frame(
wuffs_webp__decoder* self,
uint64_t a_index,
uint64_t a_io_position);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_webp__decoder__set_report_metadata(
wuffs_webp__decoder* self,
uint32_t a_fourcc,
bool a_report);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__tell_me_more(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
wuffs_webp__decoder__workbuf_len(
const wuffs_webp__decoder* self);
#ifdef __cplusplus
} // extern "C"
#endif
// ---------------- Struct Definitions
// These structs' fields, and the sizeof them, are private implementation
// details that aren't guaranteed to be stable across Wuffs versions.
//
// See https://en.wikipedia.org/wiki/Opaque_pointer#C
#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
struct wuffs_webp__decoder__struct {
// Do not access the private_impl's or private_data's fields directly. There
// is no API/ABI compatibility or safety guarantee if you do so. Instead, use
// the wuffs_foo__bar__baz functions.
//
// It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
// can be stack allocated when WUFFS_IMPLEMENTATION is defined.
struct {
uint32_t magic;
uint32_t active_coroutine;
wuffs_base__vtable vtable_for__wuffs_base__image_decoder;
wuffs_base__vtable null_vtable;
uint32_t f_pixfmt;
uint32_t f_width;
uint32_t f_height;
uint8_t f_call_sequence;
uint8_t f_code_length_code_lengths[19];
bool f_sub_chunk_has_padding;
uint64_t f_frame_config_io_position;
uint32_t f_riff_chunk_length;
uint32_t f_sub_chunk_length;
uint32_t f_bits;
uint32_t f_n_bits;
bool f_seen_transform[4];
uint8_t f_transform_type[4];
uint8_t f_transform_tile_size_log2[4];
uint32_t f_n_transforms;
uint32_t f_color_cache_bits;
uint32_t f_overall_color_cache_bits;
uint32_t f_overall_tile_size_log2;
uint32_t f_overall_n_huffman_groups;
uint32_t f_ht_n_symbols;
uint32_t f_ht_code_lengths_remaining;
uint32_t f_color_indexing_palette_size;
uint32_t f_color_indexing_width;
uint32_t f_workbuf_offset_for_transform[4];
uint32_t f_workbuf_offset_for_color_indexing;
wuffs_base__pixel_swizzler f_swizzler;
uint32_t p_decode_huffman_groups;
uint32_t p_decode_huffman_tree;
uint32_t p_decode_huffman_tree_simple;
uint32_t p_decode_code_length_code_lengths;
uint32_t p_build_code_lengths;
uint32_t p_decode_pixels_slow;
uint32_t p_decode_image_config;
uint32_t p_do_decode_image_config;
uint32_t p_do_decode_image_config_limited;
uint32_t p_do_decode_image_config_limited_vp8l;
uint32_t p_decode_frame_config;
uint32_t p_do_decode_frame_config;
uint32_t p_decode_frame;
uint32_t p_do_decode_frame;
uint32_t p_decode_transform;
uint32_t p_decode_color_cache_parameters;
uint32_t p_decode_hg_table;
uint32_t p_decode_pixels;
} private_impl;
struct {
uint8_t f_palette[1024];
uint32_t f_color_cache[2048];
uint16_t f_codes[2328];
uint16_t f_code_lengths[2328];
uint16_t f_code_lengths_huffman_nodes[37];
uint16_t f_huffman_nodes[256][6267];
struct {
uint32_t v_hg;
uint32_t v_ht;
} s_decode_huffman_groups;
struct {
uint32_t v_use_second_symbol;
uint32_t v_first_symbol_n_bits;
uint32_t v_symbol0;
uint32_t v_base_offset;
} s_decode_huffman_tree_simple;
struct {
uint32_t v_n_codes;
uint32_t v_i;
} s_decode_code_length_code_lengths;
struct {
uint32_t v_length_n_bits;
uint16_t v_prev_code_length;
uint32_t v_s;
uint32_t v_s_max;
uint16_t v_node;
uint16_t v_repeat_value;
uint32_t v_repeat_n_bits;
} s_build_code_lengths;
struct {
uint64_t v_p;
uint64_t v_p_max;
uint32_t v_tile_size_log2;
uint32_t v_width_in_tiles;
uint32_t v_x;
uint32_t v_y;
uint32_t v_hg;
uint16_t v_node;
uint32_t v_color;
uint32_t v_back_ref_len_n_bits;
uint32_t v_back_ref_len_minus_1;
uint32_t v_back_ref_dist_n_bits;
uint32_t v_back_ref_dist_premap_minus_1;
uint64_t v_color_cache_p;
} s_decode_pixels_slow;
struct {
uint64_t scratch;
} s_do_decode_image_config;
struct {
uint64_t scratch;
} s_do_decode_image_config_limited;
struct {
uint64_t scratch;
} s_do_decode_image_config_limited_vp8l;
struct {
uint32_t v_width;
} s_do_decode_frame;
struct {
uint32_t v_transform_type;
uint32_t v_tile_size_log2;
} s_decode_transform;
struct {
uint32_t v_tile_size_log2;
} s_decode_hg_table;
} private_data;
#ifdef __cplusplus
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
using unique_ptr = std::unique_ptr<wuffs_webp__decoder, wuffs_unique_ptr_deleter>;
// On failure, the alloc_etc functions return nullptr. They don't throw.
static inline unique_ptr
alloc() {
return unique_ptr(wuffs_webp__decoder__alloc());
}
static inline wuffs_base__image_decoder::unique_ptr
alloc_as__wuffs_base__image_decoder() {
return wuffs_base__image_decoder::unique_ptr(
wuffs_webp__decoder__alloc_as__wuffs_base__image_decoder());
}
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
// Disallow constructing or copying an object via standard C++ mechanisms,
// e.g. the "new" operator, as this struct is intentionally opaque. Its total
// size and field layout is not part of the public, stable, memory-safe API.
// Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and
// call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as
// their first argument) rather than tweaking bar.private_impl.qux fields.
//
// In C, we can just leave wuffs_foo__bar as an incomplete type (unless
// WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in
// order to provide convenience methods. These forward on "this", so that you
// can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)".
wuffs_webp__decoder__struct() = delete;
wuffs_webp__decoder__struct(const wuffs_webp__decoder__struct&) = delete;
wuffs_webp__decoder__struct& operator=(
const wuffs_webp__decoder__struct&) = delete;
#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
#if !defined(WUFFS_IMPLEMENTATION)
// As above, the size of the struct is not part of the public API, and unless
// WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap
// allocated, not stack allocated. Its size is not intended to be known at
// compile time, but it is unfortunately divulged as a side effect of
// defining C++ convenience methods. Use "sizeof__T()", calling the function,
// instead of "sizeof T", invoking the operator. To make the two values
// different, so that passing the latter will be rejected by the initialize
// function, we add an arbitrary amount of dead weight.
uint8_t dead_weight[123000000]; // 123 MB.
#endif // !defined(WUFFS_IMPLEMENTATION)
inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
initialize(
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options) {
return wuffs_webp__decoder__initialize(
this, sizeof_star_self, wuffs_version, options);
}
inline wuffs_base__image_decoder*
upcast_as__wuffs_base__image_decoder() {
return (wuffs_base__image_decoder*)this;
}
inline uint64_t
get_quirk(
uint32_t a_key) const {
return wuffs_webp__decoder__get_quirk(this, a_key);
}
inline wuffs_base__status
set_quirk(
uint32_t a_key,
uint64_t a_value) {
return wuffs_webp__decoder__set_quirk(this, a_key, a_value);
}
inline wuffs_base__status
decode_image_config(
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
return wuffs_webp__decoder__decode_image_config(this, a_dst, a_src);
}
inline wuffs_base__status
decode_frame_config(
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
return wuffs_webp__decoder__decode_frame_config(this, a_dst, a_src);
}
inline wuffs_base__status
decode_frame(
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
return wuffs_webp__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts);
}
inline wuffs_base__rect_ie_u32
frame_dirty_rect() const {
return wuffs_webp__decoder__frame_dirty_rect(this);
}
inline uint32_t
num_animation_loops() const {
return wuffs_webp__decoder__num_animation_loops(this);
}
inline uint64_t
num_decoded_frame_configs() const {
return wuffs_webp__decoder__num_decoded_frame_configs(this);
}
inline uint64_t
num_decoded_frames() const {
return wuffs_webp__decoder__num_decoded_frames(this);
}
inline wuffs_base__status
restart_frame(
uint64_t a_index,
uint64_t a_io_position) {
return wuffs_webp__decoder__restart_frame(this, a_index, a_io_position);
}
inline wuffs_base__empty_struct
set_report_metadata(
uint32_t a_fourcc,
bool a_report) {
return wuffs_webp__decoder__set_report_metadata(this, a_fourcc, a_report);
}
inline wuffs_base__status
tell_me_more(
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src) {
return wuffs_webp__decoder__tell_me_more(this, a_dst, a_minfo, a_src);
}
inline wuffs_base__range_ii_u64
workbuf_len() const {
return wuffs_webp__decoder__workbuf_len(this);
}
#endif // __cplusplus
}; // struct wuffs_webp__decoder__struct
#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP) || defined(WUFFS_NONMONOLITHIC)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__XXHASH32) || defined(WUFFS_NONMONOLITHIC)
// ---------------- Status Codes
@@ -14062,6 +14680,7 @@ struct wuffs_xxhash64__hasher__struct {
// ---------------- Status Codes
extern const char wuffs_xz__error__bad_bcj_offset[];
extern const char wuffs_xz__error__bad_block_header[];
extern const char wuffs_xz__error__bad_checksum[];
extern const char wuffs_xz__error__bad_filter[];
@@ -14251,6 +14870,7 @@ struct wuffs_xz__decoder__struct {
} s_decode_block_header_with_padding;
struct {
uint8_t v_flags;
uint8_t v_filter_id;
uint32_t v_shift;
uint32_t v_f;
uint64_t scratch;
@@ -14672,6 +15292,7 @@ class DecodeImageCallbacks {
// - WUFFS_BASE__FOURCC__PNG
// - WUFFS_BASE__FOURCC__TGA
// - WUFFS_BASE__FOURCC__WBMP
// - WUFFS_BASE__FOURCC__WEBP
virtual wuffs_base__image_decoder::unique_ptr //
SelectDecoder(uint32_t fourcc,
wuffs_base__slice_u8 prefix_data,
@@ -21043,7 +21664,7 @@ match:
// ---------------- Pixel Swizzler
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42(uint8_t* dst_ptr,
@@ -21078,7 +21699,7 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// --------
@@ -21914,7 +22535,7 @@ wuffs_private_impl__swizzle_swap_rgb_bgr(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42(uint8_t* dst_ptr,
@@ -21958,7 +22579,7 @@ wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42(uint8_t* dst_ptr,
}
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -24626,7 +25247,7 @@ wuffs_private_impl__swizzle_bgrw__bgrx(uint8_t* dst_ptr,
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42(uint8_t* dst_ptr,
@@ -24732,7 +25353,7 @@ wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -25490,7 +26111,7 @@ wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over(
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
@@ -25537,7 +26158,7 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
@@ -25713,6 +26334,87 @@ wuffs_private_impl__swizzle_xxxxxxxx__y_16be(uint8_t* dst_ptr,
// --------
static uint64_t //
wuffs_private_impl__swizzle_y__bgra_nonpremul__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 =
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0])));
uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__bgrx(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t src_len4 = src_len / 4;
size_t len = (dst_len < src_len4) ? dst_len : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 =
0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
s += 1 * 4;
d += 1 * 1;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_private_impl__swizzle_y__y_16be(uint8_t* dst_ptr,
size_t dst_len,
@@ -25858,7 +26560,7 @@ wuffs_private_impl__pixel_swizzler__prepare__y(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_xxxx__y__x86_sse42;
}
@@ -26329,7 +27031,7 @@ wuffs_private_impl__pixel_swizzler__prepare__bgr(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
}
@@ -26347,7 +27049,7 @@ wuffs_private_impl__pixel_swizzler__prepare__bgr(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
}
@@ -26365,6 +27067,15 @@ wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul(
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_private_impl__swizzle_y__bgra_nonpremul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -26427,7 +27138,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -26622,7 +27333,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -26644,6 +27355,9 @@ wuffs_private_impl__pixel_swizzler__prepare__bgrx(
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
return wuffs_private_impl__swizzle_y__bgrx;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
return wuffs_private_impl__swizzle_bgr_565__bgrx;
@@ -26691,7 +27405,7 @@ wuffs_private_impl__pixel_swizzler__prepare__rgb(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
}
@@ -26708,7 +27422,7 @@ wuffs_private_impl__pixel_swizzler__prepare__rgb(
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
}
@@ -26747,7 +27461,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -26863,7 +27577,7 @@ wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
}
@@ -27151,7 +27865,7 @@ wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(
// --------
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static void //
wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2(
@@ -27188,7 +27902,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
bool first_column,
bool last_column);
#endif
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// --------
@@ -28418,7 +29132,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
if (wuffs_base__cpu_arch__have_x86_avx2()) {
conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2;
break;
@@ -28429,7 +29143,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
if (wuffs_base__cpu_arch__have_x86_avx2()) {
conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_rgbx_x86_avx2;
break;
@@ -28479,7 +29193,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
upfuncs[1][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle;
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
#if defined(__GNUC__) && !defined(__clang__)
// Don't use our AVX2 implementation for GCC (but do use it for clang). For
// some unknown reason, GCC performs noticably better on the non-SIMD
@@ -28531,7 +29245,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
// --------
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static void //
wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2(
@@ -29156,7 +29870,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
return dst_ptr;
}
#endif
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
#endif // !defined(WUFFS_CONFIG__MODULES) ||
@@ -29410,21 +30124,21 @@ wuffs_adler32__hasher__up__choosy_default(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_arm_neon(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ---------------- VTables
@@ -29572,10 +30286,10 @@ wuffs_adler32__hasher__update(
self->private_impl.f_started = true;
self->private_impl.f_state = 1u;
self->private_impl.choosy_up = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_adler32__hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -29698,7 +30412,7 @@ wuffs_adler32__hasher__checksum_u32(
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func adler32.hasher.up_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_adler32__hasher__up_arm_neon(
@@ -29799,13 +30513,13 @@ wuffs_adler32__hasher__up_arm_neon(
self->private_impl.f_state = (((v_s2 & 65535u) << 16u) | (v_s1 & 65535u));
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -29892,7 +30606,7 @@ wuffs_adler32__hasher__up_x86_sse42(
self->private_impl.f_state = (((v_s2 & 65535u) << 16u) | (v_s1 & 65535u));
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32)
@@ -31115,6 +31829,8 @@ wuffs_bmp__decoder__do_decode_image_config(
(self->private_impl.f_channel_num_bits[2u] > 8u) ||
(self->private_impl.f_channel_num_bits[3u] > 8u)) {
v_dst_pixfmt = 2164308923u;
} else if (((self->private_impl.f_src_pixfmt == 2198077448u) || (self->private_impl.f_src_pixfmt == 2147485832u) || (self->private_impl.f_src_pixfmt == 2415954056u)) || ((self->private_impl.f_src_pixfmt == 2164308923u) && (self->private_impl.f_channel_masks[3u] == 0u))) {
v_dst_pixfmt = 2415954056u;
}
wuffs_base__image_config__set(
a_dst,
@@ -31723,138 +32439,160 @@ wuffs_bmp__decoder__swizzle_rle(
v_dst = wuffs_base__utility__empty_slice_u8();
}
while (true) {
while (true) {
if (v_rle_state == 0u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (v_code == 0u) {
v_rle_state = 2u;
continue;
}
self->private_impl.f_rle_length = ((uint32_t)(v_code));
v_rle_state = 1u;
continue;
} else if (v_rle_state == 1u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_bits_per_pixel == 8u) {
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[v_p0] = v_code;
v_p0 += 1u;
}
} else {
v_indexes[0u] = ((uint8_t)(((uint8_t)(v_code >> 4u))));
v_indexes[1u] = ((uint8_t)(v_code & 15u));
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[(v_p0 + 0u)] = v_indexes[0u];
self->private_data.f_scratch[(v_p0 + 1u)] = v_indexes[1u];
v_p0 += 2u;
}
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, self->private_impl.f_rle_length));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, self->private_impl.f_rle_length);
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 2u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (v_code < 2u) {
if ((self->private_impl.f_dst_y >= self->private_impl.f_height) && (v_code == 0u)) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, 18446744073709551615u);
self->private_impl.f_dst_x = 0u;
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (v_code > 0u) {
goto label__outer__break;
}
v_rle_state = 0u;
goto label__outer__continue;
} else if (v_code == 2u) {
v_rle_state = 4u;
continue;
}
self->private_impl.f_rle_length = ((uint32_t)(v_code));
self->private_impl.f_rle_padded = ((self->private_impl.f_bits_per_pixel == 8u) && (((uint8_t)(v_code & 1u)) != 0u));
v_rle_state = 3u;
continue;
} else if (v_rle_state == 3u) {
if (self->private_impl.f_bits_per_pixel == 8u) {
v_n = wuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(
&self->private_impl.f_swizzler,
self->private_impl.f_rle_length,
v_dst,
v_dst_palette,
&iop_a_src,
io2_a_src);
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(v_n)));
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, ((uint32_t)(v_n)));
} else {
v_chunk_count = ((self->private_impl.f_rle_length + 3u) / 4u);
v_p0 = 0u;
while ((v_chunk_count > 0u) && (((uint64_t)(io2_a_src - iop_a_src)) >= 2u)) {
v_chunk_bits = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2u;
self->private_data.f_scratch[(v_p0 + 0u)] = ((uint8_t)((15u & (v_chunk_bits >> 12u))));
self->private_data.f_scratch[(v_p0 + 1u)] = ((uint8_t)((15u & (v_chunk_bits >> 8u))));
self->private_data.f_scratch[(v_p0 + 2u)] = ((uint8_t)((15u & (v_chunk_bits >> 4u))));
self->private_data.f_scratch[(v_p0 + 3u)] = ((uint8_t)((15u & (v_chunk_bits >> 0u))));
v_p0 = ((v_p0 & 255u) + 4u);
v_chunk_count -= 1u;
}
v_p0 = wuffs_base__u32__min(v_p0, self->private_impl.f_rle_length);
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, v_p0));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_p0);
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, v_p0);
}
if (self->private_impl.f_rle_length > 0u) {
goto label__goto_suspend__break;
}
if (self->private_impl.f_rle_padded) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
iop_a_src += 1u;
self->private_impl.f_rle_padded = false;
}
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 4u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
}
self->private_impl.f_rle_delta_x = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
v_rle_state = 5u;
continue;
}
if (v_rle_state == 0u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
goto label__goto_suspend__break;
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_rle_delta_x > 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, ((uint64_t)(self->private_impl.f_rle_delta_x)));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(self->private_impl.f_rle_delta_x)));
self->private_impl.f_rle_delta_x = 0u;
if (self->private_impl.f_dst_x > self->private_impl.f_width) {
if (v_code == 0u) {
v_rle_state = 2u;
continue;
}
self->private_impl.f_rle_length = ((uint32_t)(v_code));
v_rle_state = 1u;
continue;
} else if (v_rle_state == 1u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_bits_per_pixel == 8u) {
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[v_p0] = v_code;
v_p0 += 1u;
}
} else {
v_indexes[0u] = ((uint8_t)(((uint8_t)(v_code >> 4u))));
v_indexes[1u] = ((uint8_t)(v_code & 15u));
v_p0 = 0u;
while (v_p0 < self->private_impl.f_rle_length) {
self->private_data.f_scratch[(v_p0 + 0u)] = v_indexes[0u];
self->private_data.f_scratch[(v_p0 + 1u)] = v_indexes[1u];
v_p0 += 2u;
}
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, self->private_impl.f_rle_length));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, self->private_impl.f_rle_length);
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 2u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (v_code < 2u) {
if ((self->private_impl.f_dst_y >= self->private_impl.f_height) && (v_code == 0u)) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, 18446744073709551615u);
self->private_impl.f_dst_x = 0u;
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (v_code > 0u) {
goto label__outer__break;
}
v_rle_state = 0u;
goto label__outer__continue;
} else if (v_code == 2u) {
v_rle_state = 4u;
continue;
}
if (v_code > 0u) {
self->private_impl.f_rle_length = ((uint32_t)(v_code));
self->private_impl.f_rle_padded = ((self->private_impl.f_bits_per_pixel == 8u) && (((uint8_t)(v_code & 1u)) != 0u));
v_rle_state = 3u;
continue;
} else if (v_rle_state == 3u) {
if (self->private_impl.f_bits_per_pixel == 8u) {
v_n = wuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(
&self->private_impl.f_swizzler,
self->private_impl.f_rle_length,
v_dst,
v_dst_palette,
&iop_a_src,
io2_a_src);
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(v_n)));
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, ((uint32_t)(v_n)));
} else {
v_chunk_count = ((self->private_impl.f_rle_length + 3u) / 4u);
v_p0 = 0u;
while ((v_chunk_count > 0u) && (((uint64_t)(io2_a_src - iop_a_src)) >= 2u)) {
v_chunk_bits = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
iop_a_src += 2u;
self->private_data.f_scratch[(v_p0 + 0u)] = ((uint8_t)((15u & (v_chunk_bits >> 12u))));
self->private_data.f_scratch[(v_p0 + 1u)] = ((uint8_t)((15u & (v_chunk_bits >> 8u))));
self->private_data.f_scratch[(v_p0 + 2u)] = ((uint8_t)((15u & (v_chunk_bits >> 4u))));
self->private_data.f_scratch[(v_p0 + 3u)] = ((uint8_t)((15u & (v_chunk_bits >> 0u))));
v_p0 = ((v_p0 & 255u) + 4u);
v_chunk_count -= 1u;
}
v_p0 = wuffs_base__u32__min(v_p0, self->private_impl.f_rle_length);
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, v_p0));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_p0);
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rle_length, v_p0);
}
if (self->private_impl.f_rle_length > 0u) {
break;
}
if (self->private_impl.f_rle_padded) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
iop_a_src += 1u;
self->private_impl.f_rle_padded = false;
}
v_rle_state = 0u;
goto label__middle__continue;
} else if (v_rle_state == 4u) {
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
self->private_impl.f_rle_delta_x = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
v_rle_state = 5u;
continue;
}
if (((uint64_t)(io2_a_src - iop_a_src)) < 1u) {
break;
}
v_code = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
iop_a_src += 1u;
if (self->private_impl.f_rle_delta_x > 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_dst, v_dst_palette, ((uint64_t)(self->private_impl.f_rle_delta_x)));
wuffs_private_impl__u32__sat_add_indirect(&self->private_impl.f_dst_x, ((uint32_t)(self->private_impl.f_rle_delta_x)));
self->private_impl.f_rle_delta_x = 0u;
if (self->private_impl.f_dst_x > self->private_impl.f_width) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
}
if (v_code > 0u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_code -= 1u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
while (true) {
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
v_row = wuffs_private_impl__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);
}
if (v_code <= 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, ((uint64_t)(self->private_impl.f_dst_x)));
break;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, 18446744073709551615u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
@@ -31863,36 +32601,11 @@ wuffs_bmp__decoder__swizzle_rle(
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
while (true) {
self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc;
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
goto exit;
}
v_row = wuffs_private_impl__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);
}
if (v_code <= 0u) {
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, ((uint64_t)(self->private_impl.f_dst_x)));
break;
}
wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(&self->private_impl.f_swizzler, v_row, v_dst_palette, 18446744073709551615u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_code -= 1u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
}
v_rle_state = 0u;
goto label__middle__continue;
}
v_rle_state = 0u;
goto label__middle__continue;
}
label__goto_suspend__break:;
self->private_impl.f_rle_state = v_rle_state;
status = wuffs_base__make_status(wuffs_bmp__note__internal_note_short_read);
goto ok;
@@ -35635,30 +36348,6 @@ WUFFS_CRC32__IEEE_TABLE[16][256] WUFFS_BASE__POTENTIALLY_UNUSED = {
},
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_K1K2[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
212u, 43u, 68u, 84u, 1u, 0u, 0u, 0u,
150u, 21u, 228u, 198u, 1u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_K3K4[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
208u, 151u, 25u, 117u, 1u, 0u, 0u, 0u,
158u, 0u, 170u, 204u, 0u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
36u, 97u, 205u, 99u, 1u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_CRC32__IEEE_X86_SSE42_PXMU[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
65u, 6u, 113u, 219u, 1u, 0u, 0u, 0u,
65u, 22u, 1u, 247u, 1u, 0u, 0u, 0u,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -35675,29 +36364,21 @@ wuffs_crc32__ieee_hasher__up__choosy_default(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_arm_crc32(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ---------------- VTables
@@ -35843,13 +36524,10 @@ wuffs_crc32__ieee_hasher__update(
if (self->private_impl.f_state == 0u) {
self->private_impl.choosy_up = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
wuffs_base__cpu_arch__have_arm_crc32() ? &wuffs_crc32__ieee_hasher__up_arm_crc32 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
#endif
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -36001,7 +36679,7 @@ wuffs_crc32__ieee_hasher__checksum_u32(
// ‼ WUFFS MULTI-FILE SECTION +arm_crc32
// -------- func crc32.ieee_hasher.up_arm_crc32
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_arm_crc32(
@@ -36071,133 +36749,13 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)
// ‼ WUFFS MULTI-FILE SECTION -arm_crc32
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func crc32.ieee_hasher.up_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__up_x86_avx2(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
uint32_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_k = {0};
__m128i v_x0 = {0};
__m128i v_x1 = {0};
__m128i v_x2 = {0};
__m128i v_x3 = {0};
__m128i v_y0 = {0};
__m128i v_y1 = {0};
__m128i v_y2 = {0};
__m128i v_y3 = {0};
uint64_t v_tail_index = 0;
v_s = (4294967295u ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0u) && ((15u & ((uint32_t)(0xFFFu & (uintptr_t)(a_x.ptr)))) != 0u)) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
if (((uint64_t)(a_x.len)) < 64u) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K1K2));
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, 64u);
v_p.ptr = i_slice_p.ptr;
v_p.len = 64;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 64) * 64));
while (v_p.ptr < i_end0_p) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_y1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(0u));
v_y3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(17u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(17u));
v_x3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(_mm_xor_si128(v_x0, v_y0), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 0u)));
v_x1 = _mm_xor_si128(_mm_xor_si128(v_x1, v_y1), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16u)));
v_x2 = _mm_xor_si128(_mm_xor_si128(v_x2, v_y2), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 32u)));
v_x3 = _mm_xor_si128(_mm_xor_si128(v_x3, v_y3), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 48u)));
v_p.ptr += 64;
}
v_p.len = 0;
}
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K3K4));
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x3);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_x1 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(16u));
v_x2 = _mm_set_epi32((int32_t)(0u), (int32_t)(4294967295u), (int32_t)(0u), (int32_t)(4294967295u));
v_x0 = _mm_srli_si128(v_x0, (int32_t)(8u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ));
v_x1 = _mm_srli_si128(v_x0, (int32_t)(4u));
v_x0 = _mm_and_si128(v_x0, v_x2);
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_PXMU));
v_x1 = _mm_and_si128(v_x0, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(16u));
v_x1 = _mm_and_si128(v_x1, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_s = ((uint32_t)(_mm_extract_epi32(v_x0, (int32_t)(1u))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551552u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc32.ieee_hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -36205,113 +36763,125 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
uint32_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_k = {0};
__m128i v_kk = {0};
__m128i v_x0 = {0};
__m128i v_x1 = {0};
__m128i v_x2 = {0};
__m128i v_x3 = {0};
__m128i v_x4 = {0};
__m128i v_x5 = {0};
__m128i v_x6 = {0};
__m128i v_x7 = {0};
__m128i v_y0 = {0};
__m128i v_y1 = {0};
__m128i v_y2 = {0};
__m128i v_y3 = {0};
uint64_t v_tail_index = 0;
__m128i v_y4 = {0};
__m128i v_y5 = {0};
__m128i v_y6 = {0};
__m128i v_y7 = {0};
v_s = (4294967295u ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0u) && ((15u & ((uint32_t)(0xFFFu & (uintptr_t)(a_x.ptr)))) != 0u)) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
if (((uint64_t)(a_x.len)) < 64u) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
if (((uint64_t)(a_x.len)) >= 128u) {
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_x4 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u));
v_x5 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u));
v_x6 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u));
v_x7 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u));
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(2433674945u), (int32_t)(0u), (int32_t)(872412467u));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
while (((uint64_t)(a_x.len)) >= 128u) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y1 = _mm_clmulepi64_si128(v_x1, v_kk, (int32_t)(0u));
v_x1 = _mm_clmulepi64_si128(v_x1, v_kk, (int32_t)(17u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(0u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(17u));
v_y3 = _mm_clmulepi64_si128(v_x3, v_kk, (int32_t)(0u));
v_x3 = _mm_clmulepi64_si128(v_x3, v_kk, (int32_t)(17u));
v_y4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(0u));
v_x4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(17u));
v_y5 = _mm_clmulepi64_si128(v_x5, v_kk, (int32_t)(0u));
v_x5 = _mm_clmulepi64_si128(v_x5, v_kk, (int32_t)(17u));
v_y6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(0u));
v_x6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(17u));
v_y7 = _mm_clmulepi64_si128(v_x7, v_kk, (int32_t)(0u));
v_x7 = _mm_clmulepi64_si128(v_x7, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y1 = _mm_xor_si128(v_y1, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
v_x1 = _mm_xor_si128(v_x1, v_y1);
v_y2 = _mm_xor_si128(v_y2, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u)));
v_x2 = _mm_xor_si128(v_x2, v_y2);
v_y3 = _mm_xor_si128(v_y3, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u)));
v_x3 = _mm_xor_si128(v_x3, v_y3);
v_y4 = _mm_xor_si128(v_y4, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u)));
v_x4 = _mm_xor_si128(v_x4, v_y4);
v_y5 = _mm_xor_si128(v_y5, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u)));
v_x5 = _mm_xor_si128(v_x5, v_y5);
v_y6 = _mm_xor_si128(v_y6, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u)));
v_x6 = _mm_xor_si128(v_x6, v_y6);
v_y7 = _mm_xor_si128(v_y7, _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u)));
v_x7 = _mm_xor_si128(v_x7, v_y7);
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(3433693342u), (int32_t)(0u), (int32_t)(2926088593u));
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(0u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_kk, (int32_t)(17u));
v_y4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(0u));
v_x4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(17u));
v_y6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(0u));
v_x6 = _mm_clmulepi64_si128(v_x6, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y2 = _mm_xor_si128(v_y2, v_x3);
v_x2 = _mm_xor_si128(v_x2, v_y2);
v_y4 = _mm_xor_si128(v_y4, v_x5);
v_x4 = _mm_xor_si128(v_x4, v_y4);
v_y6 = _mm_xor_si128(v_y6, v_x7);
v_x6 = _mm_xor_si128(v_x6, v_y6);
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(2166711591u), (int32_t)(0u), (int32_t)(4057597354u));
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(0u));
v_x4 = _mm_clmulepi64_si128(v_x4, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y4 = _mm_xor_si128(v_y4, v_x6);
v_x4 = _mm_xor_si128(v_x4, v_y4);
v_kk = _mm_set_epi32((int32_t)(0u), (int32_t)(496309207u), (int32_t)(0u), (int32_t)(2402626965u));
v_y0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_kk, (int32_t)(17u));
v_y0 = _mm_xor_si128(v_y0, v_x4);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_kk = _mm_set_epi32((int32_t)(1u), (int32_t)(3681617473u), (int32_t)(3034951717u), (int32_t)(4144043585u));
v_s = ((uint32_t)(_mm_extract_epi32(_mm_clmulepi64_si128(_mm_clmulepi64_si128(_mm_cvtsi64_si128((int64_t)(((uint64_t)(_mm_extract_epi64(v_x0, (int32_t)(0u)))))), v_kk, (int32_t)(0u)), v_kk, (int32_t)(16u)), (int32_t)(2u))));
v_kk = _mm_set_epi32((int32_t)(1u), (int32_t)(3681617473u), (int32_t)(3034951717u), (int32_t)(4144043585u));
v_s = ((uint32_t)(_mm_extract_epi32(_mm_clmulepi64_si128(_mm_clmulepi64_si128(_mm_cvtsi64_si128((int64_t)((((uint64_t)(_mm_extract_epi64(v_x0, (int32_t)(1u)))) ^ ((uint64_t)(v_s))))), v_kk, (int32_t)(0u)), v_kk, (int32_t)(16u)), (int32_t)(2u))));
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
v_x1 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_x2 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_x3 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_x0 = _mm_xor_si128(v_x0, _mm_cvtsi32_si128((int32_t)(v_s)));
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K1K2));
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, 64u);
v_p.ptr = i_slice_p.ptr;
v_p.len = 64;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 64) * 64));
while (v_p.ptr < i_end0_p) {
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_y1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_y2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(0u));
v_y3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(17u));
v_x2 = _mm_clmulepi64_si128(v_x2, v_k, (int32_t)(17u));
v_x3 = _mm_clmulepi64_si128(v_x3, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(_mm_xor_si128(v_x0, v_y0), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 0u)));
v_x1 = _mm_xor_si128(_mm_xor_si128(v_x1, v_y1), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 16u)));
v_x2 = _mm_xor_si128(_mm_xor_si128(v_x2, v_y2), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 32u)));
v_x3 = _mm_xor_si128(_mm_xor_si128(v_x3, v_y3), _mm_lddqu_si128((const __m128i*)(const void*)(v_p.ptr + 48u)));
v_p.ptr += 64;
}
v_p.len = 0;
while (((uint64_t)(a_x.len)) >= 8u) {
v_kk = _mm_set_epi32((int32_t)(1u), (int32_t)(3681617473u), (int32_t)(3034951717u), (int32_t)(4144043585u));
v_s = ((uint32_t)(_mm_extract_epi32(_mm_clmulepi64_si128(_mm_clmulepi64_si128(_mm_cvtsi64_si128((int64_t)((wuffs_base__peek_u64le__no_bounds_check(a_x.ptr) ^ ((uint64_t)(v_s))))), v_kk, (int32_t)(0u)), v_kk, (int32_t)(16u)), (int32_t)(2u))));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 8u);
}
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K3K4));
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x2);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_y0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(17u));
v_x0 = _mm_xor_si128(v_x0, v_x3);
v_x0 = _mm_xor_si128(v_x0, v_y0);
v_x1 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(16u));
v_x2 = _mm_set_epi32((int32_t)(0u), (int32_t)(4294967295u), (int32_t)(0u), (int32_t)(4294967295u));
v_x0 = _mm_srli_si128(v_x0, (int32_t)(8u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_K5ZZ));
v_x1 = _mm_srli_si128(v_x0, (int32_t)(4u));
v_x0 = _mm_and_si128(v_x0, v_x2);
v_x0 = _mm_clmulepi64_si128(v_x0, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_k = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC32__IEEE_X86_SSE42_PXMU));
v_x1 = _mm_and_si128(v_x0, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(16u));
v_x1 = _mm_and_si128(v_x1, v_x2);
v_x1 = _mm_clmulepi64_si128(v_x1, v_k, (int32_t)(0u));
v_x0 = _mm_xor_si128(v_x0, v_x1);
v_s = ((uint32_t)(_mm_extract_epi32(v_x0, (int32_t)(1u))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551552u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
while (((uint64_t)(a_x.len)) > 0u) {
v_s = (WUFFS_CRC32__IEEE_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
self->private_impl.f_state = (4294967295u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC32)
@@ -36592,27 +37162,33 @@ WUFFS_CRC64__ECMA_TABLE[8][256] WUFFS_BASE__POTENTIALLY_UNUSED = {
};
static const uint8_t
WUFFS_CRC64__SHUFFLE_707F[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
112u, 113u, 114u, 115u, 116u, 117u, 118u, 119u,
120u, 121u, 122u, 123u, 124u, 125u, 126u, 127u,
};
static const uint8_t
WUFFS_CRC64__SHUFFLE_8F80[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
143u, 142u, 141u, 140u, 139u, 138u, 137u, 136u,
135u, 134u, 133u, 132u, 131u, 130u, 129u, 128u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_K1K2[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
WUFFS_CRC64__ECMA_X86_SSE42_FOLD1[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
228u, 58u, 57u, 202u, 151u, 212u, 93u, 224u,
64u, 95u, 135u, 199u, 175u, 149u, 190u, 218u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_PXMU[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
133u, 30u, 14u, 175u, 43u, 175u, 216u, 146u,
WUFFS_CRC64__ECMA_X86_SSE42_FOLD2[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
68u, 250u, 158u, 138u, 0u, 91u, 9u, 96u,
81u, 175u, 225u, 15u, 163u, 83u, 230u, 59u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_FOLD4[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
243u, 65u, 212u, 157u, 187u, 239u, 227u, 106u,
244u, 45u, 132u, 167u, 84u, 96u, 31u, 8u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_FOLD8[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 16u, 204u, 79u, 29u, 215u, 87u, 135u,
64u, 231u, 61u, 247u, 42u, 107u, 216u, 215u,
};
static const uint8_t
WUFFS_CRC64__ECMA_X86_SSE42_MUPX[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
213u, 99u, 41u, 23u, 108u, 70u, 62u, 156u,
133u, 30u, 14u, 175u, 43u, 175u, 216u, 146u,
};
// ---------------- Private Initializer Prototypes
@@ -36631,13 +37207,13 @@ wuffs_crc64__ecma_hasher__up__choosy_default(
wuffs_crc64__ecma_hasher* self,
wuffs_base__slice_u8 a_x);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_crc64__ecma_hasher__up_x86_sse42(
wuffs_crc64__ecma_hasher* self,
wuffs_base__slice_u8 a_x);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ---------------- VTables
@@ -36783,7 +37359,7 @@ wuffs_crc64__ecma_hasher__update(
if (self->private_impl.f_state == 0u) {
self->private_impl.choosy_up = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc64__ecma_hasher__up_x86_sse42 :
#endif
self->private_impl.choosy_up);
@@ -36885,7 +37461,7 @@ wuffs_crc64__ecma_hasher__checksum_u64(
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc64.ecma_hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -36894,93 +37470,126 @@ wuffs_crc64__ecma_hasher__up_x86_sse42(
wuffs_base__slice_u8 a_x) {
uint64_t v_s = 0;
wuffs_base__slice_u8 v_p = {0};
__m128i v_s0 = {0};
__m128i v_s0_707F = {0};
__m128i v_s0_8F80 = {0};
__m128i v_x0 = {0};
__m128i v_aa = {0};
__m128i v_k1k2 = {0};
__m128i v_t0 = {0};
__m128i v_t1 = {0};
__m128i v_t2 = {0};
__m128i v_u0 = {0};
__m128i v_u1 = {0};
__m128i v_u2 = {0};
__m128i v_v0 = {0};
__m128i v_v1 = {0};
__m128i v_pxmu = {0};
__m128i v_w1 = {0};
__m128i v_w2 = {0};
uint64_t v_tail_index = 0;
uint8_t v_buf[48] = {0};
__m128i v_xa = {0};
__m128i v_xb = {0};
__m128i v_xc = {0};
__m128i v_xd = {0};
__m128i v_xe = {0};
__m128i v_xf = {0};
__m128i v_xg = {0};
__m128i v_xh = {0};
__m128i v_mu1 = {0};
__m128i v_mu2 = {0};
__m128i v_mu4 = {0};
__m128i v_mu8 = {0};
__m128i v_mupx = {0};
v_s = (18446744073709551615u ^ self->private_impl.f_state);
while ((((uint64_t)(a_x.len)) > 0u) && ((15u & ((uint32_t)(0xFFFu & (uintptr_t)(a_x.ptr)))) != 0u)) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ a_x.ptr[0u]))] ^ (v_s >> 8u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
}
if (((uint64_t)(a_x.len)) < 32u) {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
do {
do {
if (((uint64_t)(a_x.len)) >= 128u) {
} else if (((uint64_t)(a_x.len)) >= 64u) {
v_xa = _mm_xor_si128(_mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)), _mm_cvtsi64_si128((int64_t)(v_s)));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_xc = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_xd = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 64u);
break;
} else if (((uint64_t)(a_x.len)) >= 32u) {
v_xa = _mm_xor_si128(_mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)), _mm_cvtsi64_si128((int64_t)(v_s)));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 32u);
goto label__chain2__break;
} else {
{
wuffs_base__slice_u8 i_slice_p = a_x;
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
}
self->private_impl.f_state = (18446744073709551615u ^ v_s);
return wuffs_base__make_empty_struct();
}
v_p.len = 0;
v_xa = _mm_xor_si128(_mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)), _mm_cvtsi64_si128((int64_t)(v_s)));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u));
v_xc = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u));
v_xd = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u));
v_xe = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u));
v_xf = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u));
v_xg = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u));
v_xh = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
v_mu8 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD8));
while (((uint64_t)(a_x.len)) >= 128u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
v_xc = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xc, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xc, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u)));
v_xd = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xd, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xd, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u)));
v_xe = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xe, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xe, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 64u)));
v_xf = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xf, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xf, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 80u)));
v_xg = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xg, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xg, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 96u)));
v_xh = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xh, v_mu8, (int32_t)(0u)), _mm_clmulepi64_si128(v_xh, v_mu8, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 112u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 128u);
}
v_mu4 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD4));
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(17u))), v_xe);
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(17u))), v_xf);
v_xc = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(17u))), v_xg);
v_xd = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(17u))), v_xh);
if (((uint64_t)(a_x.len)) > 64u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
v_xc = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xc, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 32u)));
v_xd = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(0u)), _mm_clmulepi64_si128(v_xd, v_mu4, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 48u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 64u);
}
} while (0);
v_mu2 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD2));
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(17u))), v_xc);
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(17u))), v_xd);
if (((uint64_t)(a_x.len)) > 32u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
v_xb = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu2, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 16u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 32u);
}
self->private_impl.f_state = (18446744073709551615u ^ v_s);
return wuffs_base__make_empty_struct();
}
v_s0 = _mm_cvtsi64_si128((int64_t)(v_s));
v_s0_707F = _mm_shuffle_epi8(v_s0, _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__SHUFFLE_707F)));
v_s0_8F80 = _mm_shuffle_epi8(v_s0, _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__SHUFFLE_8F80)));
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 16u);
v_k1k2 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_K1K2));
v_t0 = _mm_xor_si128(v_s0_707F, v_x0);
v_t1 = _mm_clmulepi64_si128(v_t0, v_k1k2, (int32_t)(0u));
v_t2 = _mm_clmulepi64_si128(v_t0, v_k1k2, (int32_t)(17u));
v_aa = _mm_xor_si128(_mm_xor_si128(v_t1, v_t2), v_s0_8F80);
while (((uint64_t)(a_x.len)) >= 32u) {
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
} while (0);
label__chain2__break:;
v_mu1 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD1));
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(17u))), v_xb);
if (((uint64_t)(a_x.len)) > 24u) {
v_xa = _mm_xor_si128(_mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu1, (int32_t)(17u))), _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u)));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 16u);
v_u0 = _mm_xor_si128(v_aa, v_x0);
v_u1 = _mm_clmulepi64_si128(v_u0, v_k1k2, (int32_t)(0u));
v_u2 = _mm_clmulepi64_si128(v_u0, v_k1k2, (int32_t)(17u));
v_aa = _mm_xor_si128(v_u1, v_u2);
}
if (((uint64_t)(a_x.len)) < 16u) {
return wuffs_base__make_empty_struct();
}
v_x0 = _mm_lddqu_si128((const __m128i*)(const void*)(a_x.ptr + 0u));
a_x = wuffs_base__slice_u8__subslice_i(a_x, 16u);
v_v0 = _mm_xor_si128(v_aa, v_x0);
v_v1 = _mm_clmulepi64_si128(v_v0, v_k1k2, (int32_t)(16u));
v_aa = _mm_xor_si128(v_v1, _mm_srli_si128(v_v0, (int32_t)(8u)));
v_pxmu = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_PXMU));
v_w1 = _mm_clmulepi64_si128(v_aa, v_pxmu, (int32_t)(16u));
v_w2 = _mm_clmulepi64_si128(v_w1, v_pxmu, (int32_t)(0u));
v_s = ((uint64_t)(_mm_extract_epi64(_mm_xor_si128(v_aa, _mm_xor_si128(v_w2, _mm_slli_si128(v_w1, (int32_t)(8u)))), (int32_t)(1u))));
v_tail_index = (((uint64_t)(a_x.len)) & 18446744073709551600u);
if (v_tail_index < ((uint64_t)(a_x.len))) {
{
wuffs_base__slice_u8 i_slice_p = wuffs_base__slice_u8__subslice_i(a_x, v_tail_index);
v_p.ptr = i_slice_p.ptr;
v_p.len = 1;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(i_slice_p.ptr, i_slice_p.len);
while (v_p.ptr < i_end0_p) {
v_s = (WUFFS_CRC64__ECMA_TABLE[0u][((uint8_t)(((uint8_t)(v_s)) ^ v_p.ptr[0u]))] ^ (v_s >> 8u));
v_p.ptr += 1;
}
v_p.len = 0;
if (((uint64_t)(a_x.len)) > 24u) {
return wuffs_base__make_empty_struct();
}
}
_mm_storeu_si128((__m128i*)(void*)(v_buf + (24u - ((uint64_t)(a_x.len)))), v_xa);
wuffs_private_impl__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(v_buf, ((24u - ((uint64_t)(a_x.len))) + 16u), 48), a_x);
v_mu2 = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_FOLD2));
v_xa = _mm_lddqu_si128((const __m128i*)(const void*)(v_buf + 0u));
v_xb = _mm_lddqu_si128((const __m128i*)(const void*)(v_buf + 16u));
v_xc = _mm_lddqu_si128((const __m128i*)(const void*)(v_buf + 32u));
v_xd = _mm_xor_si128(_mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(0u)), _mm_clmulepi64_si128(v_xa, v_mu2, (int32_t)(17u)));
v_xe = _mm_xor_si128(_mm_clmulepi64_si128(v_xb, v_mu1, (int32_t)(0u)), _mm_clmulepi64_si128(v_xb, v_mu1, (int32_t)(17u)));
v_xa = _mm_xor_si128(v_xd, _mm_xor_si128(v_xe, v_xc));
v_mupx = _mm_lddqu_si128((const __m128i*)(const void*)(WUFFS_CRC64__ECMA_X86_SSE42_MUPX));
v_xb = _mm_clmulepi64_si128(v_xa, v_mupx, (int32_t)(0u));
v_xc = _mm_clmulepi64_si128(v_xb, v_mupx, (int32_t)(16u));
v_s = ((uint64_t)(_mm_extract_epi64(_mm_xor_si128(_mm_xor_si128(v_xc, _mm_slli_si128(v_xb, (int32_t)(8u))), v_xa), (int32_t)(1u))));
self->private_impl.f_state = (18446744073709551615u ^ v_s);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC64)
@@ -37119,14 +37728,14 @@ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -37460,7 +38069,7 @@ wuffs_deflate__decoder__do_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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
#endif
self->private_impl.choosy_decode_huffman_fast64);
@@ -38349,7 +38958,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -38557,7 +39166,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
return status;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
// -------- func deflate.decoder.decode_huffman_fast32
@@ -43307,7 +43916,7 @@ wuffs_jpeg__decoder__decode_idct__choosy_default(
uint64_t a_dst_stride,
uint32_t a_q);
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_jpeg__decoder__decode_idct_x86_avx2(
@@ -43315,7 +43924,7 @@ wuffs_jpeg__decoder__decode_idct_x86_avx2(
wuffs_base__slice_u8 a_dst_buffer,
uint64_t a_dst_stride,
uint32_t a_q);
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -44782,7 +45391,7 @@ wuffs_jpeg__decoder__decode_idct__choosy_default(
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
// -------- func jpeg.decoder.decode_idct_x86_avx2
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -45166,7 +45775,7 @@ wuffs_jpeg__decoder__decode_idct_x86_avx2(
wuffs_base__poke_u64le__no_bounds_check(a_dst_buffer.ptr, v_final7);
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
// -------- func jpeg.decoder.get_quirk
@@ -45515,7 +46124,7 @@ wuffs_jpeg__decoder__do_decode_image_config(
self->private_impl.f_payload_length = 0u;
}
self->private_impl.choosy_decode_idct = (
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_jpeg__decoder__decode_idct_x86_avx2 :
#endif
self->private_impl.choosy_decode_idct);
@@ -59313,40 +59922,40 @@ WUFFS_PNG__LATIN_1[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
// ---------------- Private Function Prototypes
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_arm_neon(
wuffs_png__decoder* self,
wuffs_base__slice_u8 a_curr,
wuffs_base__slice_u8 a_prev);
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -59435,40 +60044,40 @@ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -59750,7 +60359,7 @@ sizeof__wuffs_png__decoder(void) {
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_1_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_1_distance_4_arm_neon(
@@ -59790,13 +60399,13 @@ wuffs_png__decoder__filter_1_distance_4_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_3_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_3_distance_4_arm_neon(
@@ -59882,13 +60491,13 @@ wuffs_png__decoder__filter_3_distance_4_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_4_distance_3_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_3_arm_neon(
@@ -60003,13 +60612,13 @@ wuffs_png__decoder__filter_4_distance_3_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_4_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_png__decoder__filter_4_distance_4_arm_neon(
@@ -60104,7 +60713,7 @@ wuffs_png__decoder__filter_4_distance_4_arm_neon(
}
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// -------- func png.decoder.filter_1
@@ -60787,7 +61396,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -60828,13 +61437,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -60934,13 +61543,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -61061,13 +61670,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ 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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
@@ -61166,7 +61775,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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// -------- func png.decoder.get_quirk
@@ -61910,35 +62519,35 @@ wuffs_png__decoder__choose_filter_implementations(
self->private_impl.choosy_filter_3 = (
&wuffs_png__decoder__filter_3_distance_3_fallback);
self->private_impl.choosy_filter_4 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
} else if (self->private_impl.f_filter_distance == 4u) {
self->private_impl.choosy_filter_1 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
self->private_impl.choosy_filter_3 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
self->private_impl.choosy_filter_4 = (
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
#if defined(WUFFS_PRIVATE_IMPL__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_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
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);
@@ -62138,20 +62747,22 @@ wuffs_png__decoder__decode_other_chunk(
self->private_impl.f_seen_srgb = true;
}
} else if (self->private_impl.f_chunk_type == 1397641844u) {
if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3u) || ((self->private_impl.f_color_type == 3u) && ! self->private_impl.f_seen_plte)) {
if (self->private_impl.f_seen_trns || ((self->private_impl.f_color_type == 3u) && ! self->private_impl.f_seen_plte)) {
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(9);
status = wuffs_png__decoder__decode_trns(self, 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_color_type > 3u) {
} else {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
status = wuffs_png__decoder__decode_trns(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_trns = true;
}
@@ -67779,6 +68390,87 @@ wuffs_tga__decoder__workbuf_len(
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8)
// ---------------- Status Codes Implementations
// ---------------- Private Consts
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
// ---------------- VTables
// ---------------- Initializer Implementations
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_vp8__placeholder__initialize(
wuffs_vp8__placeholder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options){
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (sizeof(*self) != sizeof_star_self) {
return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver);
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
}
if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
// The whole point of this if-check is to detect an uninitialized *self.
// We disable the warning on GCC. Clang-5.0 does not have this warning.
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
if (self->private_impl.magic != 0) {
return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed);
}
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else {
if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
memset(self, 0, sizeof(*self));
options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
} else {
memset(&(self->private_impl), 0, sizeof(self->private_impl));
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
return wuffs_base__make_status(NULL);
}
wuffs_vp8__placeholder*
wuffs_vp8__placeholder__alloc(void) {
wuffs_vp8__placeholder* x =
(wuffs_vp8__placeholder*)(calloc(sizeof(wuffs_vp8__placeholder), 1));
if (!x) {
return NULL;
}
if (wuffs_vp8__placeholder__initialize(
x, sizeof(wuffs_vp8__placeholder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) {
free(x);
return NULL;
}
return x;
}
size_t
sizeof__wuffs_vp8__placeholder(void) {
return sizeof(wuffs_vp8__placeholder);
}
// ---------------- Function Implementations
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)
// ---------------- Status Codes Implementations
@@ -68701,6 +69393,4360 @@ wuffs_wbmp__decoder__workbuf_len(
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
// ---------------- Status Codes Implementations
const char wuffs_webp__error__bad_huffman_code_over_subscribed[] = "#webp: bad Huffman code (over-subscribed)";
const char wuffs_webp__error__bad_huffman_code_under_subscribed[] = "#webp: bad Huffman code (under-subscribed)";
const char wuffs_webp__error__bad_huffman_code[] = "#webp: bad Huffman code";
const char wuffs_webp__error__bad_back_reference[] = "#webp: bad back-reference";
const char wuffs_webp__error__bad_color_cache[] = "#webp: bad color cache";
const char wuffs_webp__error__bad_header[] = "#webp: bad header";
const char wuffs_webp__error__bad_transform[] = "#webp: bad transform";
const char wuffs_webp__error__short_chunk[] = "#webp: short chunk";
const char wuffs_webp__error__truncated_input[] = "#webp: truncated input";
const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups";
const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[] = "#webp: unsupported transform after color indexing transform";
const char wuffs_webp__error__unsupported_webp_file[] = "#webp: unsupported WebP file";
const char wuffs_webp__error__internal_error_inconsistent_huffman_code[] = "#webp: internal error: inconsistent Huffman code";
const char wuffs_webp__error__internal_error_inconsistent_dst_buffer[] = "#webp: internal error: inconsistent dst buffer";
const char wuffs_webp__error__internal_error_inconsistent_n_bits[] = "#webp: internal error: inconsistent n_bits";
// ---------------- Private Consts
static const uint8_t
WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[19] WUFFS_BASE__POTENTIALLY_UNUSED = {
17u, 18u, 0u, 1u, 2u, 3u, 4u, 5u,
16u, 6u, 7u, 8u, 9u, 10u, 11u, 12u,
13u, 14u, 15u,
};
static const uint8_t
WUFFS_WEBP__REPEAT_N_BITS[4] WUFFS_BASE__POTENTIALLY_UNUSED = {
2u, 3u, 7u, 0u,
};
static const uint8_t
WUFFS_WEBP__REPEAT_COUNTS[4] WUFFS_BASE__POTENTIALLY_UNUSED = {
3u, 3u, 11u, 0u,
};
static const uint16_t
WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[5] WUFFS_BASE__POTENTIALLY_UNUSED = {
1612u, 0u, 511u, 1022u, 1533u,
};
static const uint32_t
WUFFS_WEBP__SIGN_EXTEND_I8_I32[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u,
8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u,
16u, 17u, 18u, 19u, 20u, 21u, 22u, 23u,
24u, 25u, 26u, 27u, 28u, 29u, 30u, 31u,
32u, 33u, 34u, 35u, 36u, 37u, 38u, 39u,
40u, 41u, 42u, 43u, 44u, 45u, 46u, 47u,
48u, 49u, 50u, 51u, 52u, 53u, 54u, 55u,
56u, 57u, 58u, 59u, 60u, 61u, 62u, 63u,
64u, 65u, 66u, 67u, 68u, 69u, 70u, 71u,
72u, 73u, 74u, 75u, 76u, 77u, 78u, 79u,
80u, 81u, 82u, 83u, 84u, 85u, 86u, 87u,
88u, 89u, 90u, 91u, 92u, 93u, 94u, 95u,
96u, 97u, 98u, 99u, 100u, 101u, 102u, 103u,
104u, 105u, 106u, 107u, 108u, 109u, 110u, 111u,
112u, 113u, 114u, 115u, 116u, 117u, 118u, 119u,
120u, 121u, 122u, 123u, 124u, 125u, 126u, 127u,
4294967168u, 4294967169u, 4294967170u, 4294967171u, 4294967172u, 4294967173u, 4294967174u, 4294967175u,
4294967176u, 4294967177u, 4294967178u, 4294967179u, 4294967180u, 4294967181u, 4294967182u, 4294967183u,
4294967184u, 4294967185u, 4294967186u, 4294967187u, 4294967188u, 4294967189u, 4294967190u, 4294967191u,
4294967192u, 4294967193u, 4294967194u, 4294967195u, 4294967196u, 4294967197u, 4294967198u, 4294967199u,
4294967200u, 4294967201u, 4294967202u, 4294967203u, 4294967204u, 4294967205u, 4294967206u, 4294967207u,
4294967208u, 4294967209u, 4294967210u, 4294967211u, 4294967212u, 4294967213u, 4294967214u, 4294967215u,
4294967216u, 4294967217u, 4294967218u, 4294967219u, 4294967220u, 4294967221u, 4294967222u, 4294967223u,
4294967224u, 4294967225u, 4294967226u, 4294967227u, 4294967228u, 4294967229u, 4294967230u, 4294967231u,
4294967232u, 4294967233u, 4294967234u, 4294967235u, 4294967236u, 4294967237u, 4294967238u, 4294967239u,
4294967240u, 4294967241u, 4294967242u, 4294967243u, 4294967244u, 4294967245u, 4294967246u, 4294967247u,
4294967248u, 4294967249u, 4294967250u, 4294967251u, 4294967252u, 4294967253u, 4294967254u, 4294967255u,
4294967256u, 4294967257u, 4294967258u, 4294967259u, 4294967260u, 4294967261u, 4294967262u, 4294967263u,
4294967264u, 4294967265u, 4294967266u, 4294967267u, 4294967268u, 4294967269u, 4294967270u, 4294967271u,
4294967272u, 4294967273u, 4294967274u, 4294967275u, 4294967276u, 4294967277u, 4294967278u, 4294967279u,
4294967280u, 4294967281u, 4294967282u, 4294967283u, 4294967284u, 4294967285u, 4294967286u, 4294967287u,
4294967288u, 4294967289u, 4294967290u, 4294967291u, 4294967292u, 4294967293u, 4294967294u, 4294967295u,
};
static const uint8_t
WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u,
22u, 26u, 38u, 42u, 56u, 5u, 55u, 57u,
21u, 27u, 54u, 58u, 37u, 43u, 72u, 4u,
71u, 73u, 20u, 28u, 53u, 59u, 70u, 74u,
36u, 44u, 88u, 69u, 75u, 52u, 60u, 3u,
87u, 89u, 19u, 29u, 86u, 90u, 35u, 45u,
68u, 76u, 85u, 91u, 51u, 61u, 104u, 2u,
103u, 105u, 18u, 30u, 102u, 106u, 34u, 46u,
84u, 92u, 67u, 77u, 101u, 107u, 50u, 62u,
120u, 1u, 119u, 121u, 83u, 93u, 17u, 31u,
100u, 108u, 66u, 78u, 118u, 122u, 33u, 47u,
117u, 123u, 49u, 63u, 99u, 109u, 82u, 94u,
0u, 116u, 124u, 65u, 79u, 16u, 32u, 98u,
110u, 48u, 115u, 125u, 81u, 95u, 64u, 114u,
126u, 97u, 111u, 80u, 113u, 127u, 96u, 112u,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_groups(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_n_huffman_groups);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree_simple(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_code_length_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths_huffman_nodes(
wuffs_webp__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_huffman_nodes(
wuffs_webp__decoder* self,
uint32_t a_hg,
uint32_t a_ht);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels_slow(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_predictor(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data);
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
wuffs_webp__decoder__absolute_difference(
const wuffs_webp__decoder* self,
uint32_t a_a,
uint32_t a_b);
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode12(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl);
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode13(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_cross_color(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_subtract_green(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_color_indexing(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_transform(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_color_cache_parameters(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_hg_table(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__swizzle(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_src,
wuffs_base__pixel_blend a_blend);
// ---------------- VTables
const wuffs_base__image_decoder__func_ptrs
wuffs_webp__decoder__func_ptrs_for__wuffs_base__image_decoder = {
(wuffs_base__status(*)(void*,
wuffs_base__pixel_buffer*,
wuffs_base__io_buffer*,
wuffs_base__pixel_blend,
wuffs_base__slice_u8,
wuffs_base__decode_frame_options*))(&wuffs_webp__decoder__decode_frame),
(wuffs_base__status(*)(void*,
wuffs_base__frame_config*,
wuffs_base__io_buffer*))(&wuffs_webp__decoder__decode_frame_config),
(wuffs_base__status(*)(void*,
wuffs_base__image_config*,
wuffs_base__io_buffer*))(&wuffs_webp__decoder__decode_image_config),
(wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_webp__decoder__frame_dirty_rect),
(uint64_t(*)(const void*,
uint32_t))(&wuffs_webp__decoder__get_quirk),
(uint32_t(*)(const void*))(&wuffs_webp__decoder__num_animation_loops),
(uint64_t(*)(const void*))(&wuffs_webp__decoder__num_decoded_frame_configs),
(uint64_t(*)(const void*))(&wuffs_webp__decoder__num_decoded_frames),
(wuffs_base__status(*)(void*,
uint64_t,
uint64_t))(&wuffs_webp__decoder__restart_frame),
(wuffs_base__status(*)(void*,
uint32_t,
uint64_t))(&wuffs_webp__decoder__set_quirk),
(wuffs_base__empty_struct(*)(void*,
uint32_t,
bool))(&wuffs_webp__decoder__set_report_metadata),
(wuffs_base__status(*)(void*,
wuffs_base__io_buffer*,
wuffs_base__more_information*,
wuffs_base__io_buffer*))(&wuffs_webp__decoder__tell_me_more),
(wuffs_base__range_ii_u64(*)(const void*))(&wuffs_webp__decoder__workbuf_len),
};
// ---------------- Initializer Implementations
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
wuffs_webp__decoder__initialize(
wuffs_webp__decoder* self,
size_t sizeof_star_self,
uint64_t wuffs_version,
uint32_t options){
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (sizeof(*self) != sizeof_star_self) {
return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver);
}
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
}
if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
// The whole point of this if-check is to detect an uninitialized *self.
// We disable the warning on GCC. Clang-5.0 does not have this warning.
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
if (self->private_impl.magic != 0) {
return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed);
}
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else {
if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
memset(self, 0, sizeof(*self));
options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
} else {
memset(&(self->private_impl), 0, sizeof(self->private_impl));
}
}
self->private_impl.magic = WUFFS_BASE__MAGIC;
self->private_impl.vtable_for__wuffs_base__image_decoder.vtable_name =
wuffs_base__image_decoder__vtable_name;
self->private_impl.vtable_for__wuffs_base__image_decoder.function_pointers =
(const void*)(&wuffs_webp__decoder__func_ptrs_for__wuffs_base__image_decoder);
return wuffs_base__make_status(NULL);
}
wuffs_webp__decoder*
wuffs_webp__decoder__alloc(void) {
wuffs_webp__decoder* x =
(wuffs_webp__decoder*)(calloc(sizeof(wuffs_webp__decoder), 1));
if (!x) {
return NULL;
}
if (wuffs_webp__decoder__initialize(
x, sizeof(wuffs_webp__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) {
free(x);
return NULL;
}
return x;
}
size_t
sizeof__wuffs_webp__decoder(void) {
return sizeof(wuffs_webp__decoder);
}
// ---------------- Function Implementations
// -------- func webp.decoder.decode_huffman_groups
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_groups(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_n_huffman_groups) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_hg = 0;
uint32_t v_ht = 0;
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_groups;
if (coro_susp_point) {
v_hg = self->private_data.s_decode_huffman_groups.v_hg;
v_ht = self->private_data.s_decode_huffman_groups.v_ht;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
v_hg = 0u;
while (v_hg < a_n_huffman_groups) {
v_ht = 0u;
while (v_ht < 5u) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__decode_huffman_tree(self, a_src, v_hg, v_ht);
if (status.repr) {
goto suspend;
}
v_ht += 1u;
}
v_hg += 1u;
}
goto ok;
ok:
self->private_impl.p_decode_huffman_groups = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_huffman_groups = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_huffman_groups.v_hg = v_hg;
self->private_data.s_decode_huffman_groups.v_ht = v_ht;
goto exit;
exit:
return status;
}
// -------- func webp.decoder.decode_huffman_tree
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_simple = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (a_ht >= 4u) {
self->private_impl.f_ht_n_symbols = 40u;
} else if (a_ht > 0u) {
self->private_impl.f_ht_n_symbols = 256u;
} else if (self->private_impl.f_color_cache_bits == 0u) {
self->private_impl.f_ht_n_symbols = 280u;
} else {
self->private_impl.f_ht_n_symbols = (280u + (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits));
}
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_simple = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
if (v_use_simple != 0u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_webp__decoder__decode_huffman_tree_simple(self, a_src, a_hg, a_ht);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_code_length_code_lengths(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
v_status = wuffs_webp__decoder__build_code_lengths_huffman_nodes(self);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__build_code_lengths(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
v_status = wuffs_webp__decoder__build_huffman_nodes(self, a_hg, a_ht);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
}
ok:
self->private_impl.p_decode_huffman_tree = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_huffman_tree = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_huffman_tree_simple
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_tree_simple(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_hg,
uint32_t a_ht) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_second_symbol = 0;
uint32_t v_first_symbol_n_bits = 0;
uint32_t v_symbol0 = 0;
uint32_t v_symbol1 = 0;
uint32_t v_base_offset = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree_simple;
if (coro_susp_point) {
v_use_second_symbol = self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol;
v_first_symbol_n_bits = self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits;
v_symbol0 = self->private_data.s_decode_huffman_tree_simple.v_symbol0;
v_base_offset = self->private_data.s_decode_huffman_tree_simple.v_base_offset;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 2u) {
{
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_c8 = t_0;
}
if (self->private_impl.f_n_bits >= 2u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_use_second_symbol = (self->private_impl.f_bits & 1u);
v_first_symbol_n_bits = ((((self->private_impl.f_bits & 2u) >> 1u) * 7u) + 1u);
self->private_impl.f_bits >>= 2u;
self->private_impl.f_n_bits -= 2u;
if (self->private_impl.f_n_bits < v_first_symbol_n_bits) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= v_first_symbol_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_symbol0 = (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_first_symbol_n_bits) - 1u));
self->private_impl.f_bits >>= v_first_symbol_n_bits;
self->private_impl.f_n_bits -= v_first_symbol_n_bits;
v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht]));
if (v_use_second_symbol != 0u) {
if (self->private_impl.f_n_bits < 8u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
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++;
v_c8 = t_2;
}
if (self->private_impl.f_n_bits >= 8u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_symbol1 = (self->private_impl.f_bits & 255u);
self->private_impl.f_bits >>= 8u;
self->private_impl.f_n_bits -= 8u;
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 0u)] = ((uint16_t)((v_base_offset + 1u)));
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 1u)] = ((uint16_t)((v_symbol0 | 32768u)));
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 2u)] = ((uint16_t)((v_symbol1 | 32768u)));
} else {
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_symbol0 | 32768u)));
}
goto ok;
ok:
self->private_impl.p_decode_huffman_tree_simple = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_huffman_tree_simple = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol = v_use_second_symbol;
self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits = v_first_symbol_n_bits;
self->private_data.s_decode_huffman_tree_simple.v_symbol0 = v_symbol0;
self->private_data.s_decode_huffman_tree_simple.v_base_offset = v_base_offset;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_code_length_code_lengths
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_code_length_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_n_codes = 0;
uint32_t v_i = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_code_length_code_lengths;
if (coro_susp_point) {
v_n_codes = self->private_data.s_decode_code_length_code_lengths.v_n_codes;
v_i = self->private_data.s_decode_code_length_code_lengths.v_i;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 4u) {
{
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_c8 = t_0;
}
if (self->private_impl.f_n_bits >= 4u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_n_codes = ((self->private_impl.f_bits & 15u) + 4u);
self->private_impl.f_bits >>= 4u;
self->private_impl.f_n_bits -= 4u;
v_i = 0u;
while (v_i < v_n_codes) {
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = ((uint8_t)((self->private_impl.f_bits & 7u)));
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
v_i += 1u;
}
while (v_i < 19u) {
self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = 0u;
v_i += 1u;
}
goto ok;
ok:
self->private_impl.p_decode_code_length_code_lengths = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_code_length_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_code_length_code_lengths.v_n_codes = v_n_codes;
self->private_data.s_decode_code_length_code_lengths.v_i = v_i;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.build_code_lengths_huffman_nodes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths_huffman_nodes(
wuffs_webp__decoder* self) {
uint32_t v_code_bits = 0;
uint32_t v_code_len = 0;
uint32_t v_symbol = 0;
uint32_t v_histogram[8] = {0};
uint32_t v_n_used_symbols = 0;
uint32_t v_last_used_symbol = 0;
uint32_t v_subscription_weight = 0;
uint32_t v_subscription_total = 0;
uint32_t v_curr_code = 0;
uint32_t v_next_codes[9] = {0};
uint32_t v_n_branches = 0;
uint32_t v_h = 0;
uint32_t v_children = 0;
uint16_t v_node = 0;
v_symbol = 0u;
while (v_symbol < 19u) {
v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol]));
if (v_code_len != 0u) {
v_histogram[v_code_len] += 1u;
v_n_used_symbols += 1u;
v_last_used_symbol = v_symbol;
}
v_symbol += 1u;
}
if (v_n_used_symbols < 1u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
} else if (v_n_used_symbols == 1u) {
self->private_data.f_code_lengths_huffman_nodes[0u] = ((uint16_t)((v_last_used_symbol | 32768u)));
return wuffs_base__make_status(NULL);
}
v_subscription_weight = 16384u;
v_code_len = 1u;
while (true) {
v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u));
v_next_codes[(v_code_len + 1u)] = v_curr_code;
v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len]));
v_subscription_weight >>= 1u;
if (v_code_len >= 7u) {
break;
}
v_code_len += 1u;
}
if (v_subscription_total > 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed);
} else if (v_subscription_total < 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed);
}
self->private_data.f_code_lengths_huffman_nodes[0u] = 0u;
v_symbol = 0u;
while (v_symbol < 19u) {
v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol]));
if (v_code_len > 0u) {
v_code_bits = v_next_codes[v_code_len];
v_next_codes[v_code_len] += 1u;
v_code_bits <<= (32u - v_code_len);
v_h = 0u;
while (v_code_len > 0u) {
v_node = self->private_data.f_code_lengths_huffman_nodes[v_h];
if (v_node == 0u) {
v_children = ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches))));
v_children = wuffs_base__u32__min(v_children, 35u);
self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)(v_children));
self->private_data.f_code_lengths_huffman_nodes[(v_children + 0u)] = 0u;
self->private_data.f_code_lengths_huffman_nodes[(v_children + 1u)] = 0u;
v_h = (v_children + (v_code_bits >> 31u));
v_n_branches += 1u;
} else {
v_children = ((uint32_t)(v_node));
v_h = (wuffs_base__u32__min(v_children, 35u) + (v_code_bits >> 31u));
}
v_code_bits <<= 1u;
v_code_len -= 1u;
}
self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)((v_symbol | 32768u)));
}
v_symbol += 1u;
}
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.build_huffman_nodes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_huffman_nodes(
wuffs_webp__decoder* self,
uint32_t a_hg,
uint32_t a_ht) {
uint32_t v_base_offset = 0;
uint32_t v_code_bits = 0;
uint32_t v_code_len = 0;
uint32_t v_symbol = 0;
uint32_t v_histogram[16] = {0};
uint32_t v_n_used_symbols = 0;
uint32_t v_last_used_symbol = 0;
uint32_t v_subscription_weight = 0;
uint32_t v_subscription_total = 0;
uint32_t v_curr_code = 0;
uint32_t v_next_codes[17] = {0};
uint32_t v_n_branches = 0;
uint32_t v_h = 0;
uint32_t v_children = 0;
uint16_t v_node = 0;
v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht]));
v_symbol = 0u;
while (v_symbol < self->private_impl.f_ht_n_symbols) {
v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u))));
if (v_code_len != 0u) {
v_histogram[v_code_len] += 1u;
v_n_used_symbols += 1u;
v_last_used_symbol = v_symbol;
}
v_symbol += 1u;
}
if (v_n_used_symbols < 1u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
} else if (v_n_used_symbols == 1u) {
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_last_used_symbol | 32768u)));
return wuffs_base__make_status(NULL);
}
v_subscription_weight = 16384u;
v_code_len = 1u;
while (true) {
v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u));
v_next_codes[(v_code_len + 1u)] = v_curr_code;
v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len]));
v_subscription_weight >>= 1u;
if (v_code_len >= 15u) {
break;
}
v_code_len += 1u;
}
if (v_subscription_total > 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed);
} else if (v_subscription_total < 32768u) {
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed);
}
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = 0u;
v_symbol = 0u;
while (v_symbol < self->private_impl.f_ht_n_symbols) {
v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u))));
if (v_code_len != 0u) {
v_code_bits = v_next_codes[v_code_len];
v_next_codes[v_code_len] += 1u;
v_code_bits <<= (32u - v_code_len);
v_h = v_base_offset;
while (v_code_len > 0u) {
v_node = self->private_data.f_huffman_nodes[a_hg][v_h];
if (v_node == 0u) {
v_children = ((uint32_t)(v_base_offset + ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches))))));
v_children = wuffs_base__u32__min(v_children, 6265u);
self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)(v_children));
self->private_data.f_huffman_nodes[a_hg][(v_children + 0u)] = 0u;
self->private_data.f_huffman_nodes[a_hg][(v_children + 1u)] = 0u;
v_h = (v_children + (v_code_bits >> 31u));
v_n_branches += 1u;
} else {
v_children = ((uint32_t)(v_node));
v_h = (wuffs_base__u32__min(v_children, 6265u) + (v_code_bits >> 31u));
}
v_code_bits <<= 1u;
v_code_len -= 1u;
}
self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)((v_symbol | 32768u)));
}
v_symbol += 1u;
}
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.build_code_lengths
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__build_code_lengths(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_length = 0;
uint32_t v_length_n_bits = 0;
uint32_t v_length = 0;
uint16_t v_prev_code_length = 0;
uint32_t v_h = 0;
uint32_t v_s = 0;
uint32_t v_s_max = 0;
uint16_t v_node = 0;
uint32_t v_symbol = 0;
uint16_t v_repeat_value = 0;
uint32_t v_repeat_n_bits = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_build_code_lengths;
if (coro_susp_point) {
v_length_n_bits = self->private_data.s_build_code_lengths.v_length_n_bits;
v_prev_code_length = self->private_data.s_build_code_lengths.v_prev_code_length;
v_s = self->private_data.s_build_code_lengths.v_s;
v_s_max = self->private_data.s_build_code_lengths.v_s_max;
v_node = self->private_data.s_build_code_lengths.v_node;
v_repeat_value = self->private_data.s_build_code_lengths.v_repeat_value;
v_repeat_n_bits = self->private_data.s_build_code_lengths.v_repeat_n_bits;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_length = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
self->private_impl.f_ht_code_lengths_remaining = self->private_impl.f_ht_n_symbols;
if (v_use_length != 0u) {
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_length_n_bits = (((self->private_impl.f_bits & 7u) * 2u) + 2u);
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
while (self->private_impl.f_n_bits < v_length_n_bits) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
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++;
v_c8 = t_2;
}
if (self->private_impl.f_n_bits >= v_length_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_length = ((self->private_impl.f_bits & ((((uint32_t)(1u)) << v_length_n_bits) - 1u)) + 2u);
self->private_impl.f_bits >>= v_length_n_bits;
self->private_impl.f_n_bits -= v_length_n_bits;
if (v_length > self->private_impl.f_ht_n_symbols) {
status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
goto exit;
}
self->private_impl.f_ht_code_lengths_remaining = v_length;
}
v_prev_code_length = 8u;
while (v_s < self->private_impl.f_ht_n_symbols) {
if (self->private_impl.f_ht_code_lengths_remaining <= 0u) {
while (v_s < self->private_impl.f_ht_n_symbols) {
self->private_data.f_code_lengths[v_s] = 0u;
v_s += 1u;
}
break;
}
self->private_impl.f_ht_code_lengths_remaining -= 1u;
v_h = 0u;
while (true) {
v_node = self->private_data.f_code_lengths_huffman_nodes[v_h];
if (v_node >= 32768u) {
break;
} else if (v_node > 35u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code);
goto exit;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
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_c8 = t_3;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_symbol = ((uint32_t)(((uint16_t)(v_node & 32767u))));
if (v_symbol == 0u) {
self->private_data.f_code_lengths[v_s] = 0u;
v_s += 1u;
continue;
} else if (v_symbol < 16u) {
v_prev_code_length = ((uint16_t)(v_symbol));
self->private_data.f_code_lengths[v_s] = v_prev_code_length;
v_s += 1u;
continue;
} else if (v_symbol == 16u) {
v_repeat_value = v_prev_code_length;
} else {
v_repeat_value = 0u;
}
v_repeat_n_bits = ((uint32_t)(WUFFS_WEBP__REPEAT_N_BITS[(v_symbol & 3u)]));
v_s_max = ((uint32_t)(((uint32_t)(WUFFS_WEBP__REPEAT_COUNTS[(v_symbol & 3u)])) + v_s));
if (self->private_impl.f_n_bits < v_repeat_n_bits) {
{
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_4 = *iop_a_src++;
v_c8 = t_4;
}
if (self->private_impl.f_n_bits >= v_repeat_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_s_max += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_repeat_n_bits) - 1u));
self->private_impl.f_bits >>= v_repeat_n_bits;
self->private_impl.f_n_bits -= v_repeat_n_bits;
if (v_s_max > self->private_impl.f_ht_n_symbols) {
status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
goto exit;
}
while (v_s < v_s_max) {
self->private_data.f_code_lengths[v_s] = v_repeat_value;
v_s += 1u;
}
}
goto ok;
ok:
self->private_impl.p_build_code_lengths = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_build_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_build_code_lengths.v_length_n_bits = v_length_n_bits;
self->private_data.s_build_code_lengths.v_prev_code_length = v_prev_code_length;
self->private_data.s_build_code_lengths.v_s = v_s;
self->private_data.s_build_code_lengths.v_s_max = v_s_max;
self->private_data.s_build_code_lengths.v_node = v_node;
self->private_data.s_build_code_lengths.v_repeat_value = v_repeat_value;
self->private_data.s_build_code_lengths.v_repeat_n_bits = v_repeat_n_bits;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_pixels_slow
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels_slow(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint64_t v_p = 0;
uint64_t v_p_max = 0;
uint32_t v_tile_size_log2 = 0;
uint32_t v_width_in_tiles = 0;
uint32_t v_x = 0;
uint32_t v_y = 0;
uint32_t v_i = 0;
uint32_t v_hg = 0;
uint32_t v_h = 0;
uint16_t v_node = 0;
uint32_t v_pixel_g = 0;
uint32_t v_color = 0;
wuffs_base__slice_u8 v_dst_pixel = {0};
uint32_t v_back_ref_len_n_bits = 0;
uint32_t v_back_ref_len_minus_1 = 0;
uint32_t v_back_ref_dist_n_bits = 0;
uint32_t v_back_ref_dist_sym = 0;
uint32_t v_back_ref_dist_premap_minus_1 = 0;
uint32_t v_back_ref_dist_minus_1 = 0;
uint32_t v_dm = 0;
uint32_t v_dx = 0;
uint32_t v_dy = 0;
uint64_t v_p_end = 0;
uint64_t v_dist4 = 0;
uint64_t v_q = 0;
wuffs_base__slice_u8 v_color_cache_pixels = {0};
uint64_t v_color_cache_p = 0;
uint32_t v_color_cache_shift = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_pixels_slow;
if (coro_susp_point) {
v_p = self->private_data.s_decode_pixels_slow.v_p;
v_p_max = self->private_data.s_decode_pixels_slow.v_p_max;
v_tile_size_log2 = self->private_data.s_decode_pixels_slow.v_tile_size_log2;
v_width_in_tiles = self->private_data.s_decode_pixels_slow.v_width_in_tiles;
v_x = self->private_data.s_decode_pixels_slow.v_x;
v_y = self->private_data.s_decode_pixels_slow.v_y;
v_hg = self->private_data.s_decode_pixels_slow.v_hg;
v_node = self->private_data.s_decode_pixels_slow.v_node;
v_color = self->private_data.s_decode_pixels_slow.v_color;
v_back_ref_len_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits;
v_back_ref_len_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1;
v_back_ref_dist_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits;
v_back_ref_dist_premap_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1;
v_color_cache_p = self->private_data.s_decode_pixels_slow.v_color_cache_p;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
v_p_max = ((uint64_t)((4u * a_width * a_height)));
if (((uint64_t)(a_dst.len)) < v_p_max) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
if (a_tile_size_log2 != 0u) {
v_tile_size_log2 = a_tile_size_log2;
v_width_in_tiles = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
} else {
v_tile_size_log2 = 31u;
v_width_in_tiles = 1u;
}
while (v_p < v_p_max) {
v_i = ((uint32_t)(((uint32_t)(((uint32_t)(((uint32_t)((v_y >> v_tile_size_log2) * v_width_in_tiles)) + (v_x >> v_tile_size_log2))) * 4u)) + 1u));
if (((uint64_t)(v_i)) < ((uint64_t)(a_tile_data.len))) {
v_hg = ((uint32_t)(a_tile_data.ptr[((uint64_t)(v_i))]));
}
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[0u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
} else if (v_node > 6265u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code);
goto exit;
}
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_pixel_g = ((uint32_t)(((uint16_t)(v_node & 32767u))));
if (v_pixel_g < 256u) {
v_color = (v_pixel_g << 8u);
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[1u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_1;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 16u);
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[2u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
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++;
v_c8 = t_2;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 0u);
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[3u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
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_c8 = t_3;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 24u);
} else if (v_pixel_g < 280u) {
if (v_pixel_g < 260u) {
v_back_ref_len_minus_1 = (v_pixel_g - 256u);
} else {
v_back_ref_len_n_bits = ((v_pixel_g - 258u) >> 1u);
v_back_ref_len_minus_1 = ((((uint32_t)(2u)) + (v_pixel_g & 1u)) << v_back_ref_len_n_bits);
while (self->private_impl.f_n_bits < v_back_ref_len_n_bits) {
{
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_4 = *iop_a_src++;
v_c8 = t_4;
}
if (self->private_impl.f_n_bits >= v_back_ref_len_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_back_ref_len_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_len_n_bits) - 1u));
self->private_impl.f_bits >>= v_back_ref_len_n_bits;
self->private_impl.f_n_bits -= v_back_ref_len_n_bits;
}
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[4u]));
while (true) {
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
if (v_node >= 32768u) {
break;
}
if (self->private_impl.f_n_bits < 1u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
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_c8 = t_5;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
}
v_back_ref_dist_sym = ((uint32_t)(((uint16_t)(v_node & 32767u))));
if (v_back_ref_dist_sym < 4u) {
v_back_ref_dist_premap_minus_1 = v_back_ref_dist_sym;
} else if (v_back_ref_dist_sym < 40u) {
v_back_ref_dist_n_bits = ((v_back_ref_dist_sym - 2u) >> 1u);
v_back_ref_dist_premap_minus_1 = ((((uint32_t)(2u)) + (v_back_ref_dist_sym & 1u)) << v_back_ref_dist_n_bits);
while (self->private_impl.f_n_bits < v_back_ref_dist_n_bits) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
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_c8 = t_6;
}
if (self->private_impl.f_n_bits >= v_back_ref_dist_n_bits) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_back_ref_dist_premap_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_dist_n_bits) - 1u));
self->private_impl.f_bits >>= v_back_ref_dist_n_bits;
self->private_impl.f_n_bits -= v_back_ref_dist_n_bits;
}
if (v_back_ref_dist_premap_minus_1 >= 120u) {
v_back_ref_dist_minus_1 = (v_back_ref_dist_premap_minus_1 - 120u);
} else {
v_dm = ((uint32_t)(WUFFS_WEBP__DISTANCE_MAP[v_back_ref_dist_premap_minus_1]));
v_dy = (v_dm >> 4u);
v_dx = ((uint32_t)(7u - (v_dm & 15u)));
v_back_ref_dist_minus_1 = ((uint32_t)((a_width * v_dy) + v_dx));
}
v_p_end = (v_p + ((uint64_t)(((v_back_ref_len_minus_1 + 1u) * 4u))));
v_dist4 = ((((uint64_t)(v_back_ref_dist_minus_1)) * 4u) + 4u);
if ((v_p_end > v_p_max) || (v_p_end > ((uint64_t)(a_dst.len))) || (v_p < v_dist4)) {
status = wuffs_base__make_status(wuffs_webp__error__bad_back_reference);
goto exit;
}
v_q = (v_p - v_dist4);
while ((v_q < v_p) && (v_p < v_p_end)) {
a_dst.ptr[v_p] = a_dst.ptr[v_q];
v_p += 1u;
v_q += 1u;
}
v_x += (v_back_ref_len_minus_1 + 1u);
while (v_x >= a_width) {
v_x -= a_width;
v_y += 1u;
}
continue;
} else {
if ((v_color_cache_p > v_p) || (v_p > ((uint64_t)(a_dst.len)))) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
v_color_cache_pixels = wuffs_base__slice_u8__subslice_ij(a_dst, v_color_cache_p, v_p);
v_color_cache_p = v_p;
v_color_cache_shift = ((32u - self->private_impl.f_color_cache_bits) & 31u);
while (((uint64_t)(v_color_cache_pixels.len)) >= 4u) {
v_color = wuffs_base__peek_u32le__no_bounds_check(v_color_cache_pixels.ptr);
self->private_data.f_color_cache[((((uint32_t)(v_color * 506832829u)) >> v_color_cache_shift) & 2047u)] = v_color;
v_color_cache_pixels = wuffs_base__slice_u8__subslice_i(v_color_cache_pixels, 4u);
}
v_color = self->private_data.f_color_cache[((v_pixel_g - 280u) & 2047u)];
}
if (v_p > ((uint64_t)(a_dst.len))) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
v_dst_pixel = wuffs_base__slice_u8__subslice_i(a_dst, v_p);
if (((uint64_t)(v_dst_pixel.len)) < 4u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
goto exit;
}
wuffs_base__poke_u32le__no_bounds_check(v_dst_pixel.ptr, v_color);
v_p += 4u;
v_x += 1u;
if (v_x == a_width) {
v_x = 0u;
v_y += 1u;
}
}
goto ok;
ok:
self->private_impl.p_decode_pixels_slow = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_pixels_slow = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_pixels_slow.v_p = v_p;
self->private_data.s_decode_pixels_slow.v_p_max = v_p_max;
self->private_data.s_decode_pixels_slow.v_tile_size_log2 = v_tile_size_log2;
self->private_data.s_decode_pixels_slow.v_width_in_tiles = v_width_in_tiles;
self->private_data.s_decode_pixels_slow.v_x = v_x;
self->private_data.s_decode_pixels_slow.v_y = v_y;
self->private_data.s_decode_pixels_slow.v_hg = v_hg;
self->private_data.s_decode_pixels_slow.v_node = v_node;
self->private_data.s_decode_pixels_slow.v_color = v_color;
self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits = v_back_ref_len_n_bits;
self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1 = v_back_ref_len_minus_1;
self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits = v_back_ref_dist_n_bits;
self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1 = v_back_ref_dist_premap_minus_1;
self->private_data.s_decode_pixels_slow.v_color_cache_p = v_color_cache_p;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.apply_transform_predictor
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_predictor(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data) {
uint64_t v_w4 = 0;
wuffs_base__slice_u8 v_prev_row = {0};
wuffs_base__slice_u8 v_curr_row = {0};
uint32_t v_tile_size_log2 = 0;
uint32_t v_tiles_per_row = 0;
uint32_t v_mask = 0;
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_t = 0;
wuffs_base__slice_u8 v_tile_data = {0};
uint8_t v_mode = 0;
uint32_t v_l0 = 0;
uint32_t v_l1 = 0;
uint32_t v_l2 = 0;
uint32_t v_l3 = 0;
uint32_t v_c0 = 0;
uint32_t v_c1 = 0;
uint32_t v_c2 = 0;
uint32_t v_c3 = 0;
uint32_t v_t0 = 0;
uint32_t v_t1 = 0;
uint32_t v_t2 = 0;
uint32_t v_t3 = 0;
uint32_t v_sum_l = 0;
uint32_t v_sum_t = 0;
if ((self->private_impl.f_width <= 0u) || (self->private_impl.f_height <= 0u)) {
return wuffs_base__make_empty_struct();
}
v_w4 = ((uint64_t)((self->private_impl.f_width * 4u)));
v_curr_row = wuffs_base__utility__empty_slice_u8();
if (v_w4 <= ((uint64_t)(a_pix.len))) {
v_curr_row = wuffs_base__slice_u8__subslice_j(a_pix, v_w4);
}
if (((uint64_t)(v_curr_row.len)) >= 4u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[3u] += 255u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
while (((uint64_t)(v_curr_row.len)) >= 8u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_curr_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_curr_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
}
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[0u]));
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_y = 1u;
while (v_y < self->private_impl.f_height) {
v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row)));
v_tile_data = wuffs_base__utility__empty_slice_u8();
if (v_t <= ((uint64_t)(a_tile_data.len))) {
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
if (((uint64_t)(v_tile_data.len)) >= 4u) {
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
}
}
if (v_w4 <= ((uint64_t)(a_pix.len))) {
v_prev_row = a_pix;
a_pix = wuffs_base__slice_u8__subslice_i(a_pix, v_w4);
v_curr_row = a_pix;
}
if ((((uint64_t)(v_prev_row.len)) >= 4u) && (((uint64_t)(v_curr_row.len)) >= 4u)) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[0u] += v_prev_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[1u] += v_prev_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[2u] += v_prev_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[3u] += v_prev_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
v_x = 1u;
while (v_x < self->private_impl.f_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
}
if ((((uint64_t)(v_prev_row.len)) < 12u) || (((uint64_t)(v_curr_row.len)) < 8u)) {
break;
}
if (v_mode == 0u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += 255u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 1u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_curr_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_curr_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 2u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_prev_row.ptr[4u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_prev_row.ptr[5u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_prev_row.ptr[6u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_prev_row.ptr[7u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 3u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_prev_row.ptr[8u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_prev_row.ptr[9u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_prev_row.ptr[10u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_prev_row.ptr[11u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 4u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += v_prev_row.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += v_prev_row.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += v_prev_row.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += v_prev_row.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 5u) {
v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u);
v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u);
v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u);
v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 6u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 7u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 8u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 9u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 10u) {
v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u);
v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u);
v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u);
v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u);
v_t0 = ((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u);
v_t1 = ((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u);
v_t2 = ((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u);
v_t3 = ((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u);
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + v_t0) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + v_t1) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + v_t2) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + v_t3) / 2u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 11u) {
v_l0 = ((uint32_t)(v_curr_row.ptr[0u]));
v_l1 = ((uint32_t)(v_curr_row.ptr[1u]));
v_l2 = ((uint32_t)(v_curr_row.ptr[2u]));
v_l3 = ((uint32_t)(v_curr_row.ptr[3u]));
v_c0 = ((uint32_t)(v_prev_row.ptr[0u]));
v_c1 = ((uint32_t)(v_prev_row.ptr[1u]));
v_c2 = ((uint32_t)(v_prev_row.ptr[2u]));
v_c3 = ((uint32_t)(v_prev_row.ptr[3u]));
v_t0 = ((uint32_t)(v_prev_row.ptr[4u]));
v_t1 = ((uint32_t)(v_prev_row.ptr[5u]));
v_t2 = ((uint32_t)(v_prev_row.ptr[6u]));
v_t3 = ((uint32_t)(v_prev_row.ptr[7u]));
v_sum_l = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_t0) +
wuffs_webp__decoder__absolute_difference(self, v_c1, v_t1) +
wuffs_webp__decoder__absolute_difference(self, v_c2, v_t2) +
wuffs_webp__decoder__absolute_difference(self, v_c3, v_t3));
v_sum_t = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_l0) +
wuffs_webp__decoder__absolute_difference(self, v_c1, v_l1) +
wuffs_webp__decoder__absolute_difference(self, v_c2, v_l2) +
wuffs_webp__decoder__absolute_difference(self, v_c3, v_l3));
if (v_sum_l < v_sum_t) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(v_l0));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(v_l1));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(v_l2));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(v_l3));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += ((uint8_t)(v_t0));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += ((uint8_t)(v_t1));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += ((uint8_t)(v_t2));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += ((uint8_t)(v_t3));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
} else if (v_mode == 12u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
} else if (v_mode == 13u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[4u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[5u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[6u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_curr_row.ptr[7u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
v_prev_row = wuffs_base__slice_u8__subslice_i(v_prev_row, 4u);
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.absolute_difference
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
wuffs_webp__decoder__absolute_difference(
const wuffs_webp__decoder* self,
uint32_t a_a,
uint32_t a_b) {
if (a_a < a_b) {
return (a_b - a_a);
}
return (a_a - a_b);
}
// -------- func webp.decoder.mode12
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode12(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl) {
uint32_t v_v = 0;
v_v = ((uint32_t)((((uint32_t)(a_l)) + ((uint32_t)(a_t))) - ((uint32_t)(a_tl))));
if (v_v < 256u) {
return ((uint8_t)(v_v));
} else if (v_v < 512u) {
return 255u;
}
return 0u;
}
// -------- func webp.decoder.mode13
WUFFS_BASE__GENERATED_C_CODE
static uint8_t
wuffs_webp__decoder__mode13(
const wuffs_webp__decoder* self,
uint8_t a_l,
uint8_t a_t,
uint8_t a_tl) {
uint32_t v_x = 0;
uint32_t v_y = 0;
uint32_t v_z = 0;
uint32_t v_v = 0;
v_x = ((((uint32_t)(a_l)) + ((uint32_t)(a_t))) / 2u);
v_y = ((uint32_t)(a_tl));
v_z = ((uint32_t)(v_x - v_y));
v_v = ((uint32_t)(v_x + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_z + (v_z >> 31u))), 1u)));
if (v_v < 256u) {
return ((uint8_t)(v_v));
} else if (v_v < 512u) {
return 255u;
}
return 0u;
}
// -------- func webp.decoder.apply_transform_cross_color
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_cross_color(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix,
wuffs_base__slice_u8 a_tile_data) {
uint32_t v_tile_size_log2 = 0;
uint32_t v_tiles_per_row = 0;
uint32_t v_mask = 0;
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_t = 0;
wuffs_base__slice_u8 v_tile_data = {0};
uint32_t v_g2r = 0;
uint32_t v_g2b = 0;
uint32_t v_r2b = 0;
uint8_t v_b = 0;
uint8_t v_g = 0;
uint8_t v_r = 0;
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[1u]));
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row)));
v_tile_data = wuffs_base__utility__empty_slice_u8();
if (v_t <= ((uint64_t)(a_tile_data.len))) {
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
}
v_x = 0u;
while (v_x < self->private_impl.f_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
v_g2r = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[0u]];
v_g2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[1u]];
v_r2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[2u]];
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
}
if (((uint64_t)(a_pix.len)) >= 4u) {
v_b = a_pix.ptr[0u];
v_g = a_pix.ptr[1u];
v_r = a_pix.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_r += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2r)) >> 5u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2b)) >> 5u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_r] * v_r2b)) >> 5u)));
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
a_pix.ptr[0u] = v_b;
a_pix.ptr[2u] = v_r;
a_pix = wuffs_base__slice_u8__subslice_i(a_pix, 4u);
}
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.apply_transform_subtract_green
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_subtract_green(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix) {
wuffs_base__slice_u8 v_p = {0};
uint8_t v_g = 0;
{
wuffs_base__slice_u8 i_slice_p = a_pix;
v_p.ptr = i_slice_p.ptr;
v_p.len = 4;
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 4) * 4));
while (v_p.ptr < i_end0_p) {
v_g = v_p.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[0u] += v_g;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[2u] += v_g;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_p.ptr += 4;
}
v_p.len = 0;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.apply_transform_color_indexing
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_transform_color_indexing(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_pix) {
uint32_t v_tile_size_log2 = 0;
uint32_t v_bits_per_pixel = 0;
uint32_t v_x_mask = 0;
uint32_t v_s_mask = 0;
uint64_t v_src_index = 0;
uint32_t v_y = 0;
uint64_t v_di = 0;
uint64_t v_dj = 0;
wuffs_base__slice_u8 v_dst = {0};
uint32_t v_x = 0;
uint32_t v_s = 0;
uint32_t v_p = 0;
uint8_t v_p0 = 0;
uint8_t v_p1 = 0;
uint8_t v_p2 = 0;
uint8_t v_p3 = 0;
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u]));
if (v_tile_size_log2 == 0u) {
}
v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2);
v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
v_s_mask = ((((uint32_t)(1u)) << v_bits_per_pixel) - 1u);
v_src_index = ((uint64_t)((self->private_impl.f_workbuf_offset_for_color_indexing + 1u)));
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_di = ((uint64_t)((4u * (v_y + 0u) * self->private_impl.f_width)));
v_dj = ((uint64_t)((4u * (v_y + 1u) * self->private_impl.f_width)));
if ((v_di > v_dj) || (v_dj > ((uint64_t)(a_pix.len)))) {
break;
}
v_dst = wuffs_base__slice_u8__subslice_ij(a_pix, v_di, v_dj);
v_x = 0u;
while (((uint64_t)(v_dst.len)) >= 4u) {
if (((v_x & v_x_mask) == 0u) && (v_src_index < ((uint64_t)(a_pix.len)))) {
v_s = ((uint32_t)(a_pix.ptr[v_src_index]));
v_src_index += 4u;
}
v_p = ((v_s & v_s_mask) * 4u);
v_s >>= v_bits_per_pixel;
v_p0 = self->private_data.f_palette[(v_p + 0u)];
v_p1 = self->private_data.f_palette[(v_p + 1u)];
v_p2 = self->private_data.f_palette[(v_p + 2u)];
v_p3 = self->private_data.f_palette[(v_p + 3u)];
v_dst.ptr[0u] = v_p0;
v_dst.ptr[1u] = v_p1;
v_dst.ptr[2u] = v_p2;
v_dst.ptr[3u] = v_p3;
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, 4u);
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.get_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__get_quirk(
const wuffs_webp__decoder* self,
uint32_t a_key) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return 0u;
}
// -------- func webp.decoder.set_quirk
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__set_quirk(
wuffs_webp__decoder* self,
uint32_t a_key,
uint64_t a_value) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
// -------- func webp.decoder.decode_image_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 1)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_image_config(self, a_dst, a_src);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_image_config
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config(
wuffs_webp__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence != 0u) {
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1179011410u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
self->private_impl.f_riff_chunk_length = t_1;
}
if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_riff_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_src);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_riff_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_riff_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
}
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
if (a_dst != NULL) {
wuffs_base__image_config__set(
a_dst,
self->private_impl.f_pixfmt,
0u,
self->private_impl.f_width,
self->private_impl.f_height,
self->private_impl.f_frame_config_io_position,
false);
}
self->private_impl.f_call_sequence = 32u;
ok:
self->private_impl.p_do_decode_image_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
uint32_t t_0;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
if (num_bits_0 == 24) {
t_0 = ((uint32_t)(*scratch));
break;
}
num_bits_0 += 8u;
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_c32 = t_0;
}
if (v_c32 != 1346520407u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
if (v_c32 == 540561494u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
} else if (v_c32 == 1278758998u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
uint32_t t_2;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
if (num_bits_2 == 24) {
t_2 = ((uint32_t)(*scratch));
break;
}
num_bits_2 += 8u;
*scratch |= ((uint64_t)(num_bits_2)) << 56;
}
}
self->private_impl.f_sub_chunk_length = t_2;
}
if (self->private_impl.f_sub_chunk_length < 4u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_3 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src);
v_status = t_3;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
}
} else if (v_c32 == 1480085590u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
} else {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
ok:
self->private_impl.p_do_decode_image_config_limited = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.do_decode_image_config_limited_vp8l
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_c32 = 0;
uint32_t v_transform_size = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint32_t t_0 = *iop_a_src++;
v_c32 = t_0;
}
if (v_c32 != 47u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
uint32_t t_1;
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
iop_a_src += 4;
} else {
self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
while (true) {
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch;
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
*scratch <<= 8;
*scratch >>= 8;
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
if (num_bits_1 == 24) {
t_1 = ((uint32_t)(*scratch));
break;
}
num_bits_1 += 8u;
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_c32 = t_1;
}
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
v_c32 >>= 14u;
self->private_impl.f_pixfmt = 2415954056u;
if ((v_c32 & 1u) != 0u) {
self->private_impl.f_pixfmt = 2164295816u;
}
v_c32 >>= 1u;
if (v_c32 != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (0u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (1u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
goto ok;
ok:
self->private_impl.p_do_decode_image_config_limited_vp8l = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 2)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_frame_config(self, a_dst, a_src);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 2 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame_config
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame_config(
wuffs_webp__decoder* self,
wuffs_base__frame_config* a_dst,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_config;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 32u) {
} else if (self->private_impl.f_call_sequence < 32u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_image_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (self->private_impl.f_call_sequence == 40u) {
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
goto exit;
}
} else if (self->private_impl.f_call_sequence == 64u) {
self->private_impl.f_call_sequence = 96u;
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
if (a_dst != NULL) {
wuffs_base__frame_config__set(
a_dst,
wuffs_base__utility__make_rect_ie_u32(
0u,
0u,
self->private_impl.f_width,
self->private_impl.f_height),
((wuffs_base__flicks)(0u)),
0u,
self->private_impl.f_frame_config_io_position,
0u,
false,
false,
0u);
}
self->private_impl.f_call_sequence = 64u;
ok:
self->private_impl.p_do_decode_frame_config = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_frame
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_dst || !a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 3)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_frame(self,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_frame = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0;
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.do_decode_frame
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__do_decode_frame(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src,
wuffs_base__pixel_blend a_blend,
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_has_more = 0;
uint32_t v_width = 0;
wuffs_base__slice_u8 v_dst = {0};
wuffs_base__slice_u8 v_tile_data = {0};
wuffs_base__status v_status = wuffs_base__make_status(NULL);
wuffs_base__slice_u8 v_pix = {0};
uint32_t v_which = 0;
uint32_t v_transform_type = 0;
uint64_t v_ti = 0;
uint64_t v_tj = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
if (coro_susp_point) {
v_width = self->private_data.s_do_decode_frame.v_width;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 64u) {
} else if (self->private_impl.f_call_sequence < 64u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else {
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
goto ok;
}
self->private_impl.f_seen_transform[0u] = false;
self->private_impl.f_seen_transform[1u] = false;
self->private_impl.f_seen_transform[2u] = false;
self->private_impl.f_seen_transform[3u] = false;
self->private_impl.f_n_transforms = 0u;
while (true) {
if (self->private_impl.f_n_bits < 1u) {
{
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_0 = *iop_a_src++;
v_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_has_more = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
if (v_has_more == 0u) {
break;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
}
v_width = self->private_impl.f_width;
if (self->private_impl.f_seen_transform[3u]) {
v_width = self->private_impl.f_color_indexing_width;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_overall_color_cache_bits = self->private_impl.f_color_cache_bits;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_color_cache_bits = self->private_impl.f_overall_color_cache_bits;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
while (true) {
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len))) ||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_dst = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_1 = wuffs_webp__decoder__decode_pixels(self,
v_dst,
a_src,
v_width,
self->private_impl.f_height,
v_tile_data,
self->private_impl.f_overall_tile_size_log2);
v_status = t_1;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
}
if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
v_which = self->private_impl.f_n_transforms;
while (v_which > 0u) {
v_which -= 1u;
v_transform_type = ((uint32_t)(self->private_impl.f_transform_type[v_which]));
v_tile_data = wuffs_base__utility__empty_slice_u8();
if (v_transform_type < 2u) {
v_ti = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)]));
v_tj = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]));
if ((v_ti <= v_tj) && (v_tj <= ((uint64_t)(a_workbuf.len)))) {
v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_ti, v_tj);
}
}
if (v_transform_type == 0u) {
wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_tile_data);
} else if (v_transform_type == 1u) {
wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_tile_data);
} else if (v_transform_type == 2u) {
wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix);
} else {
wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix);
v_width = self->private_impl.f_width;
}
}
v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, a_blend);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
goto exit;
} else if (wuffs_base__status__is_suspension(&status)) {
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
goto exit;
}
goto ok;
}
self->private_impl.f_call_sequence = 96u;
ok:
self->private_impl.p_do_decode_frame = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_do_decode_frame.v_width = v_width;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_transform
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_transform(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_transform_type = 0;
uint32_t v_tile_size_log2 = 0;
wuffs_base__slice_u8 v_p = {0};
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_transform;
if (coro_susp_point) {
v_transform_type = self->private_data.s_decode_transform.v_transform_type;
v_tile_size_log2 = self->private_data.s_decode_transform.v_tile_size_log2;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 2u) {
{
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_c8 = t_0;
}
if (self->private_impl.f_n_bits >= 2u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_transform_type = (self->private_impl.f_bits & 3u);
self->private_impl.f_bits >>= 2u;
self->private_impl.f_n_bits -= 2u;
if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) {
status = wuffs_base__make_status(wuffs_webp__error__bad_transform);
goto exit;
} else if (self->private_impl.f_seen_transform[3u]) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_transform_after_color_indexing_transform);
goto exit;
}
self->private_impl.f_seen_transform[v_transform_type] = true;
self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type));
self->private_impl.f_n_transforms += 1u;
if (v_transform_type < 2u) {
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u);
self->private_impl.f_transform_tile_size_log2[v_transform_type] = ((uint8_t)(v_tile_size_log2));
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_webp__decoder__decode_pixels(self,
wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))),
a_src,
((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(),
0u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else if (v_transform_type == 2u) {
} else {
if (self->private_impl.f_n_bits < 8u) {
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
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++;
v_c8 = t_2;
}
if (self->private_impl.f_n_bits >= 8u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
self->private_impl.f_color_indexing_palette_size = ((self->private_impl.f_bits & 255u) + 1u);
self->private_impl.f_bits >>= 8u;
self->private_impl.f_n_bits -= 8u;
if (self->private_impl.f_color_indexing_palette_size <= 2u) {
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 7u) / 8u);
self->private_impl.f_transform_tile_size_log2[3u] = 3u;
} else if (self->private_impl.f_color_indexing_palette_size <= 4u) {
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 3u) / 4u);
self->private_impl.f_transform_tile_size_log2[3u] = 2u;
} else if (self->private_impl.f_color_indexing_palette_size <= 16u) {
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 1u) / 2u);
self->private_impl.f_transform_tile_size_log2[3u] = 1u;
} else {
self->private_impl.f_color_indexing_width = self->private_impl.f_width;
self->private_impl.f_transform_tile_size_log2[3u] = 0u;
}
if (self->private_impl.f_width >= self->private_impl.f_color_indexing_width) {
self->private_impl.f_workbuf_offset_for_color_indexing = (4u * (self->private_impl.f_width - self->private_impl.f_color_indexing_width) * self->private_impl.f_height);
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
status = wuffs_webp__decoder__decode_pixels(self,
wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)),
a_src,
self->private_impl.f_color_indexing_palette_size,
1u,
wuffs_base__utility__empty_slice_u8(),
0u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
wuffs_private_impl__bulk_memset(&self->private_data.f_palette[(4u * self->private_impl.f_color_indexing_palette_size)], (1024u - (4u * self->private_impl.f_color_indexing_palette_size)), 0u);
v_p = wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size));
while (((uint64_t)(v_p.len)) >= 8u) {
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[4u] += v_p.ptr[0u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[5u] += v_p.ptr[1u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[6u] += v_p.ptr[2u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_p.ptr[7u] += v_p.ptr[3u];
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u);
}
}
goto ok;
ok:
self->private_impl.p_decode_transform = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_transform = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_transform.v_transform_type = v_transform_type;
self->private_data.s_decode_transform.v_tile_size_log2 = v_tile_size_log2;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_color_cache_parameters
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_color_cache_parameters(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_color_cache = 0;
uint32_t v_color_cache_bits = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_color_cache_parameters;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_color_cache = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
self->private_impl.f_color_cache_bits = 0u;
if (v_use_color_cache != 0u) {
if (self->private_impl.f_n_bits < 4u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 4u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_color_cache_bits = (self->private_impl.f_bits & 15u);
self->private_impl.f_bits >>= 4u;
self->private_impl.f_n_bits -= 4u;
if ((v_color_cache_bits < 1u) || (11u < v_color_cache_bits)) {
status = wuffs_base__make_status(wuffs_webp__error__bad_color_cache);
goto exit;
}
self->private_impl.f_color_cache_bits = v_color_cache_bits;
}
goto ok;
ok:
self->private_impl.p_decode_color_cache_parameters = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_color_cache_parameters = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_hg_table
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_hg_table(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_use_hg_table = 0;
uint32_t v_tile_size_log2 = 0;
wuffs_base__slice_u8 v_hg_pixels = {0};
uint64_t v_n = 0;
wuffs_base__slice_u8 v_p = {0};
uint32_t v_hg_plus_1 = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_decode_hg_table;
if (coro_susp_point) {
v_tile_size_log2 = self->private_data.s_decode_hg_table.v_tile_size_log2;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_n_bits < 1u) {
{
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_c8 = t_0;
}
self->private_impl.f_bits = ((uint32_t)(v_c8));
self->private_impl.f_n_bits = 8u;
}
v_use_hg_table = (self->private_impl.f_bits & 1u);
self->private_impl.f_bits >>= 1u;
self->private_impl.f_n_bits -= 1u;
if (v_use_hg_table == 0u) {
self->private_impl.f_overall_n_huffman_groups = 1u;
self->private_impl.f_overall_tile_size_log2 = 0u;
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
if (((uint64_t)(v_hg_pixels.len)) >= 4u) {
v_hg_pixels.ptr[0u] = 0u;
v_hg_pixels.ptr[1u] = 0u;
v_hg_pixels.ptr[2u] = 0u;
v_hg_pixels.ptr[3u] = 0u;
}
status = wuffs_base__make_status(NULL);
goto ok;
}
if (self->private_impl.f_n_bits < 3u) {
{
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_c8 = t_1;
}
if (self->private_impl.f_n_bits >= 3u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
goto exit;
}
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
self->private_impl.f_n_bits += 8u;
}
v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u);
self->private_impl.f_bits >>= 3u;
self->private_impl.f_n_bits -= 3u;
self->private_impl.f_overall_tile_size_log2 = v_tile_size_log2;
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
status = wuffs_webp__decoder__decode_pixels(self,
wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))),
a_src,
((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(),
0u);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
self->private_impl.f_overall_n_huffman_groups = 1u;
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
v_n = ((uint64_t)((((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * 4u)));
if (v_n > ((uint64_t)(v_hg_pixels.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_p = wuffs_base__slice_u8__subslice_j(v_hg_pixels, v_n);
while (((uint64_t)(v_p.len)) >= 4u) {
if (v_p.ptr[2u] != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_number_of_huffman_groups);
goto exit;
}
v_hg_plus_1 = (((uint32_t)(v_p.ptr[1u])) + 1u);
if (self->private_impl.f_overall_n_huffman_groups < v_hg_plus_1) {
self->private_impl.f_overall_n_huffman_groups = v_hg_plus_1;
}
v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u);
}
ok:
self->private_impl.p_decode_hg_table = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_hg_table = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_hg_table.v_tile_size_log2 = v_tile_size_log2;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func webp.decoder.decode_pixels
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_pixels(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_dst,
wuffs_base__io_buffer* a_src,
uint32_t a_width,
uint32_t a_height,
wuffs_base__slice_u8 a_tile_data,
uint32_t a_tile_size_log2) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_i = 0;
uint32_t v_n = 0;
uint32_t coro_susp_point = self->private_impl.p_decode_pixels;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
v_i = 0u;
v_n = (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits);
while (v_i < v_n) {
self->private_data.f_color_cache[v_i] = 0u;
v_i += 1u;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_webp__decoder__decode_pixels_slow(self,
a_dst,
a_src,
a_width,
a_height,
a_tile_data,
a_tile_size_log2);
if (status.repr) {
goto suspend;
}
goto ok;
ok:
self->private_impl.p_decode_pixels = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_pixels = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
goto exit;
exit:
return status;
}
// -------- func webp.decoder.swizzle
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__swizzle(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_src,
wuffs_base__pixel_blend a_blend) {
wuffs_base__status v_status = wuffs_base__make_status(NULL);
wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0;
uint32_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_bytes_per_row = 0;
wuffs_base__slice_u8 v_dst_palette = {0};
wuffs_base__table_u8 v_tab = {0};
uint64_t v_src_bytes_per_row = 0;
wuffs_base__slice_u8 v_dst = {0};
uint32_t v_y = 0;
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
wuffs_base__pixel_buffer__pixel_format(a_dst),
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)),
wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt),
wuffs_base__utility__empty_slice_u8(),
a_blend);
if ( ! wuffs_base__status__is_ok(&v_status)) {
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
}
v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst);
v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt);
if ((v_dst_bits_per_pixel & 7u) != 0u) {
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u);
v_dst_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 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_palette, 1024));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u);
v_src_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 4u)));
while (v_src_bytes_per_row <= ((uint64_t)(a_src.len))) {
v_dst = wuffs_private_impl__table_u8__row_u32(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);
}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(a_src, v_src_bytes_per_row));
a_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_bytes_per_row);
v_y += 1u;
}
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.frame_dirty_rect
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32
wuffs_webp__decoder__frame_dirty_rect(
const wuffs_webp__decoder* self) {
if (!self) {
return wuffs_base__utility__empty_rect_ie_u32();
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return wuffs_base__utility__empty_rect_ie_u32();
}
return wuffs_base__utility__make_rect_ie_u32(
0u,
0u,
self->private_impl.f_width,
self->private_impl.f_height);
}
// -------- func webp.decoder.num_animation_loops
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_webp__decoder__num_animation_loops(
const wuffs_webp__decoder* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return 0u;
}
// -------- func webp.decoder.num_decoded_frame_configs
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frame_configs(
const wuffs_webp__decoder* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
if (self->private_impl.f_call_sequence > 32u) {
return 1u;
}
return 0u;
}
// -------- func webp.decoder.num_decoded_frames
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_webp__decoder__num_decoded_frames(
const wuffs_webp__decoder* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
if (self->private_impl.f_call_sequence > 64u) {
return 1u;
}
return 0u;
}
// -------- func webp.decoder.restart_frame
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__restart_frame(
wuffs_webp__decoder* self,
uint64_t a_index,
uint64_t a_io_position) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (self->private_impl.f_call_sequence < 32u) {
return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
}
if ((a_index != 0u) || (a_io_position != self->private_impl.f_frame_config_io_position)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
self->private_impl.f_call_sequence = 40u;
return wuffs_base__make_status(NULL);
}
// -------- func webp.decoder.set_report_metadata
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_webp__decoder__set_report_metadata(
wuffs_webp__decoder* self,
uint32_t a_fourcc,
bool a_report) {
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.tell_me_more
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
wuffs_webp__decoder__tell_me_more(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_dst,
wuffs_base__more_information* a_minfo,
wuffs_base__io_buffer* a_src) {
if (!self) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_status(
(self->private_impl.magic == WUFFS_BASE__DISABLED)
? wuffs_base__error__disabled_by_previous_error
: wuffs_base__error__initialize_not_called);
}
if (!a_dst || !a_src) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if ((self->private_impl.active_coroutine != 0) &&
(self->private_impl.active_coroutine != 4)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
}
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
goto exit;
goto ok;
ok:
goto exit;
exit:
if (wuffs_base__status__is_error(&status)) {
self->private_impl.magic = WUFFS_BASE__DISABLED;
}
return status;
}
// -------- func webp.decoder.workbuf_len
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
wuffs_webp__decoder__workbuf_len(
const wuffs_webp__decoder* self) {
if (!self) {
return wuffs_base__utility__empty_range_ii_u64();
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return wuffs_base__utility__empty_range_ii_u64();
}
return wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])));
}
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__XXHASH32)
// ---------------- Status Codes Implementations
@@ -69604,6 +74650,7 @@ wuffs_xxhash64__hasher__checksum_u64(
// ---------------- Status Codes Implementations
const char wuffs_xz__error__bad_bcj_offset[] = "#xz: bad BCJ offset";
const char wuffs_xz__error__bad_block_header[] = "#xz: bad block header";
const char wuffs_xz__error__bad_checksum[] = "#xz: bad checksum";
const char wuffs_xz__error__bad_filter[] = "#xz: bad filter";
@@ -69655,6 +74702,12 @@ WUFFS_XZ__ZEROES[3] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 0u, 0u,
};
static const uint8_t
WUFFS_XZ__BCJ_OFFSET_ALIGNMENT[12] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 0u, 0u, 0u, 1u, 4u, 16u, 4u,
2u, 4u, 4u, 2u,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -71455,6 +76508,8 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
wuffs_base__status status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0;
uint32_t v_c32 = 0;
uint32_t v_alignment = 0;
uint8_t v_flags = 0;
uint8_t v_filter_id = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
@@ -71476,6 +76531,7 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
uint32_t coro_susp_point = self->private_impl.p_decode_block_header_sans_padding;
if (coro_susp_point) {
v_flags = self->private_data.s_decode_block_header_sans_padding.v_flags;
v_filter_id = self->private_data.s_decode_block_header_sans_padding.v_filter_id;
v_shift = self->private_data.s_decode_block_header_sans_padding.v_shift;
v_f = self->private_data.s_decode_block_header_sans_padding.v_f;
}
@@ -71678,8 +76734,16 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
*scratch |= ((uint64_t)(num_bits_7)) << 56;
}
}
self->private_impl.f_bcj_pos = t_7;
v_c32 = t_7;
}
v_alignment = ((uint32_t)(WUFFS_XZ__BCJ_OFFSET_ALIGNMENT[v_filter_id]));
if (v_alignment > 0u) {
if ((v_c32 % v_alignment) != 0u) {
status = wuffs_base__make_status(wuffs_xz__error__bad_bcj_offset);
goto exit;
}
}
self->private_impl.f_bcj_pos = v_c32;
} else {
status = wuffs_base__make_status(wuffs_xz__error__unsupported_filter);
goto exit;
@@ -71746,6 +76810,7 @@ wuffs_xz__decoder__decode_block_header_sans_padding(
suspend:
self->private_impl.p_decode_block_header_sans_padding = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_decode_block_header_sans_padding.v_flags = v_flags;
self->private_data.s_decode_block_header_sans_padding.v_filter_id = v_filter_id;
self->private_data.s_decode_block_header_sans_padding.v_shift = v_shift;
self->private_data.s_decode_block_header_sans_padding.v_f = v_f;
@@ -72827,6 +77892,11 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
case WUFFS_BASE__FOURCC__WBMP:
return wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();
#endif
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
case WUFFS_BASE__FOURCC__WEBP:
return wuffs_webp__decoder::alloc_as__wuffs_base__image_decoder();
#endif
}
return wuffs_base__image_decoder::unique_ptr(nullptr);
+18 -4
View File
@@ -36,6 +36,7 @@ import (
var (
algorithm = flag.String("algorithm", "adler32", "checksum algorithm")
count = flag.Int("count", 300, "number of cases (max 300), needs -pi flag")
pi = flag.Bool("pi", false, "checksum the digits of pi instead of stdin")
)
@@ -50,19 +51,32 @@ func main1() error {
flag.Parse()
if *pi {
const digits = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170"
if len(digits) != 99 {
const digits = "3." +
"141592653589793238462643383279502884197169399375105820974944592307816406" +
"286208998628034825342117067982148086513282306647093844609550582231725359" +
"408128481117450284102701938521105559644622948954930381964428810975665933" +
"446128475648233786783165271201909145648566923460348610454326648213393607" +
"260249141"
if len(digits) != 299 {
panic("bad len(digits)")
} else if (*count < 0) || (len(digits) < (*count - 1)) {
return fmt.Errorf("invalid count: %d", *count)
}
for i := 0; i < 100; i++ {
newLine := false
for i := 0; i < *count; i++ {
if err := do(strings.NewReader(digits[:i])); err != nil {
return err
}
fmt.Print(",")
if i&7 == 7 {
newLine = i&7 == 7
if newLine {
fmt.Println()
}
}
if !newLine {
fmt.Println()
}
} else {
if err := do(os.Stdin); err != nil {
return err
+5
View File
@@ -66,7 +66,9 @@
#define WUFFS_CONFIG__MODULE__NIE
#define WUFFS_CONFIG__MODULE__PNG
#define WUFFS_CONFIG__MODULE__TGA
#define WUFFS_CONFIG__MODULE__VP8
#define WUFFS_CONFIG__MODULE__WBMP
#define WUFFS_CONFIG__MODULE__WEBP
#define WUFFS_CONFIG__MODULE__ZLIB
// If building this program in an environment that doesn't easily accommodate
@@ -129,6 +131,9 @@ handle_image_decoder(wuffs_base__io_buffer src,
case WUFFS_BASE__FOURCC__WBMP:
dec = wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();
break;
case WUFFS_BASE__FOURCC__WEBP:
dec = wuffs_webp__decoder::alloc_as__wuffs_base__image_decoder();
break;
default:
return unsupported_file_format;
}
+167
View File
@@ -0,0 +1,167 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//go:build ignore
// +build ignore
package main
// print-crc32-x86-sse42-code.go prints the std/crc32 x86/SSE4.2 Wuffs code
// based on some C code generated by https://github.com/corsix/fast-crc32/
//
// Usage: go run print-crc32-x86-sse42-code.go
import (
"fmt"
"regexp"
"strconv"
"strings"
)
func main() {
var (
reXEqLoadu = regexp.MustCompile(`^__m128i x(\d+) = _mm_loadu_si128`)
reKEqSetr = regexp.MustCompile(`^k = _mm_setr_epi32\(([^,]+), ([^,]+), ([^,]+), ([^\)]+)\);$`)
reYEqClmul = regexp.MustCompile(`^y(\d+) = clmul_lo\(x(\d+), k\), x(\d+) = clmul_hi\(x(\d+), k\);$`)
reYEqXorLoadu = regexp.MustCompile(`^y(\d+) = _mm_xor_si128\(y(\d+), _mm_loadu_si128`)
reYEqXorYX = regexp.MustCompile(`^y(\d+) = _mm_xor_si128\(y(\d+), x(\d+)\), x(\d+) = _mm_xor_si128\(x(\d+), y(\d+)\);$`)
)
fmt.Println("// BEGIN script/print-crc32-x86-sse42-code.go generated code.")
for src := srcSSECRC32V8; src != ""; {
i := strings.IndexByte(src, '\n')
line := strings.TrimSpace(src[:i])
src = src[i+1:]
if (line == "") || strings.HasPrefix(line, "/*") {
continue
} else if s := reXEqLoadu.FindStringSubmatch(line); len(s) > 0 {
n, _ := strconv.Atoi(s[1])
fmt.Printf("x%d = util.make_m128i_slice128(a: args.x[0x%02X .. 0x%02X])\n", n, 16*(n), 16*(n+1))
} else if line == "__m128i k;" {
continue
} else if s := reKEqSetr.FindStringSubmatch(line); len(s) > 0 {
fmt.Printf("kk = util.make_m128i_multiple_u32(a00: %s, a01: %s, a02: %s, a03: %s)\n", s[1], s[2], s[3], s[4])
} else if line == "x0 = _mm_xor_si128(_mm_cvtsi32_si128(crc0), x0);" {
fmt.Printf("x0 = x0._mm_xor_si128(b: util.make_m128i_single_u32(a: s))\n")
} else if line == "buf += 128;" {
fmt.Printf("args.x = args.x[128 ..]\n")
} else if line == "len -= 128;" {
continue
} else if line == "while (len >= 128) {" {
fmt.Printf("while args.x.length() >= 128 {\n")
} else if line == "}" {
fmt.Printf("} endwhile\n")
} else if s := reYEqClmul.FindStringSubmatch(line); len(s) > 0 {
fmt.Printf("y%s = x%s._mm_clmulepi64_si128(b: kk, imm8: 0x00)\n", s[1], s[2])
fmt.Printf("x%s = x%s._mm_clmulepi64_si128(b: kk, imm8: 0x11)\n", s[3], s[4])
} else if s := reYEqXorLoadu.FindStringSubmatch(line); len(s) > 0 {
n, _ := strconv.Atoi(s[1])
fmt.Printf("y%d = y%d._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x%02X .. 0x%02X]))\n", n, n, 16*(n), 16*(n+1))
fmt.Printf("x%d = x%d._mm_xor_si128(b: y%d)\n", n, n, n)
} else if s := reYEqXorYX.FindStringSubmatch(line); len(s) > 0 {
fmt.Printf("y%s = y%s._mm_xor_si128(b: x%s)\n", s[1], s[2], s[3])
fmt.Printf("x%s = x%s._mm_xor_si128(b: y%s)\n", s[4], s[5], s[6])
} else if line == "crc0 = crc_u64(0, _mm_extract_epi64(x0, 0));" {
fmt.Printf("kk = util.make_m128i_multiple_u32(a00: 0xF701_1641, a01: 0xB4E5_B025, a02: 0xDB71_0641, a03: 1)\n")
fmt.Printf("s = util.make_m128i_single_u64(a: x0._mm_extract_epi64(imm8: 0)).\n")
fmt.Printf(" _mm_clmulepi64_si128(b: kk, imm8: 0x00).\n")
fmt.Printf(" _mm_clmulepi64_si128(b: kk, imm8: 0x10).\n")
fmt.Printf(" _mm_extract_epi32(imm8: 2)\n")
// fmt.Printf("s = util.make_m128i_single_u64(a: (s as base.u64) ^ args.x.peek_u64le()).\n")
} else if line == "crc0 = crc_u64(crc0, _mm_extract_epi64(x0, 1));" {
fmt.Printf("kk = util.make_m128i_multiple_u32(a00: 0xF701_1641, a01: 0xB4E5_B025, a02: 0xDB71_0641, a03: 1)\n")
fmt.Printf("s = util.make_m128i_single_u64(a: x0._mm_extract_epi64(imm8: 1) ^ (s as base.u64)).\n")
fmt.Printf(" _mm_clmulepi64_si128(b: kk, imm8: 0x00).\n")
fmt.Printf(" _mm_clmulepi64_si128(b: kk, imm8: 0x10).\n")
fmt.Printf(" _mm_extract_epi32(imm8: 2)\n")
} else {
fmt.Printf("// Could not process %q.\n", line)
break
}
}
fmt.Println("// END script/print-crc32-x86-sse42-code.go generated code.")
}
// This is the core (inside "if (len >= 128)") of the code produced by
// generate.c in https://github.com/corsix/fast-crc32/ when parameterized by
// "./generate -i sse -p crc32 -a v8".
const srcSSECRC32V8 = `
/* First vector chunk. */
__m128i x0 = _mm_loadu_si128((const __m128i*)buf), y0;
__m128i x1 = _mm_loadu_si128((const __m128i*)(buf + 16)), y1;
__m128i x2 = _mm_loadu_si128((const __m128i*)(buf + 32)), y2;
__m128i x3 = _mm_loadu_si128((const __m128i*)(buf + 48)), y3;
__m128i x4 = _mm_loadu_si128((const __m128i*)(buf + 64)), y4;
__m128i x5 = _mm_loadu_si128((const __m128i*)(buf + 80)), y5;
__m128i x6 = _mm_loadu_si128((const __m128i*)(buf + 96)), y6;
__m128i x7 = _mm_loadu_si128((const __m128i*)(buf + 112)), y7;
__m128i k;
k = _mm_setr_epi32(0x33fff533, 0, 0x910eeec1, 0);
x0 = _mm_xor_si128(_mm_cvtsi32_si128(crc0), x0);
buf += 128;
len -= 128;
/* Main loop. */
while (len >= 128) {
y0 = clmul_lo(x0, k), x0 = clmul_hi(x0, k);
y1 = clmul_lo(x1, k), x1 = clmul_hi(x1, k);
y2 = clmul_lo(x2, k), x2 = clmul_hi(x2, k);
y3 = clmul_lo(x3, k), x3 = clmul_hi(x3, k);
y4 = clmul_lo(x4, k), x4 = clmul_hi(x4, k);
y5 = clmul_lo(x5, k), x5 = clmul_hi(x5, k);
y6 = clmul_lo(x6, k), x6 = clmul_hi(x6, k);
y7 = clmul_lo(x7, k), x7 = clmul_hi(x7, k);
y0 = _mm_xor_si128(y0, _mm_loadu_si128((const __m128i*)buf)), x0 = _mm_xor_si128(x0, y0);
y1 = _mm_xor_si128(y1, _mm_loadu_si128((const __m128i*)(buf + 16))), x1 = _mm_xor_si128(x1, y1);
y2 = _mm_xor_si128(y2, _mm_loadu_si128((const __m128i*)(buf + 32))), x2 = _mm_xor_si128(x2, y2);
y3 = _mm_xor_si128(y3, _mm_loadu_si128((const __m128i*)(buf + 48))), x3 = _mm_xor_si128(x3, y3);
y4 = _mm_xor_si128(y4, _mm_loadu_si128((const __m128i*)(buf + 64))), x4 = _mm_xor_si128(x4, y4);
y5 = _mm_xor_si128(y5, _mm_loadu_si128((const __m128i*)(buf + 80))), x5 = _mm_xor_si128(x5, y5);
y6 = _mm_xor_si128(y6, _mm_loadu_si128((const __m128i*)(buf + 96))), x6 = _mm_xor_si128(x6, y6);
y7 = _mm_xor_si128(y7, _mm_loadu_si128((const __m128i*)(buf + 112))), x7 = _mm_xor_si128(x7, y7);
buf += 128;
len -= 128;
}
/* Reduce x0 ... x7 to just x0. */
k = _mm_setr_epi32(0xae689191, 0, 0xccaa009e, 0);
y0 = clmul_lo(x0, k), x0 = clmul_hi(x0, k);
y2 = clmul_lo(x2, k), x2 = clmul_hi(x2, k);
y4 = clmul_lo(x4, k), x4 = clmul_hi(x4, k);
y6 = clmul_lo(x6, k), x6 = clmul_hi(x6, k);
y0 = _mm_xor_si128(y0, x1), x0 = _mm_xor_si128(x0, y0);
y2 = _mm_xor_si128(y2, x3), x2 = _mm_xor_si128(x2, y2);
y4 = _mm_xor_si128(y4, x5), x4 = _mm_xor_si128(x4, y4);
y6 = _mm_xor_si128(y6, x7), x6 = _mm_xor_si128(x6, y6);
k = _mm_setr_epi32(0xf1da05aa, 0, 0x81256527, 0);
y0 = clmul_lo(x0, k), x0 = clmul_hi(x0, k);
y4 = clmul_lo(x4, k), x4 = clmul_hi(x4, k);
y0 = _mm_xor_si128(y0, x2), x0 = _mm_xor_si128(x0, y0);
y4 = _mm_xor_si128(y4, x6), x4 = _mm_xor_si128(x4, y4);
k = _mm_setr_epi32(0x8f352d95, 0, 0x1d9513d7, 0);
y0 = clmul_lo(x0, k), x0 = clmul_hi(x0, k);
y0 = _mm_xor_si128(y0, x4), x0 = _mm_xor_si128(x0, y0);
/* Reduce 128 bits to 32 bits, and multiply by x^32. */
crc0 = crc_u64(0, _mm_extract_epi64(x0, 0));
crc0 = crc_u64(crc0, _mm_extract_epi64(x0, 1));
`
@@ -13,6 +13,8 @@
package main
// This program is obsolete.
//
// print-crc32-x86-sse42-magic-numbers.go prints the std/crc32
// IEEE_X86_SSE42_ETC magic number tables.
//
@@ -60,7 +62,7 @@ const px = "100000100110000010001110110110111"
// P(x)' = 0x1_11011011_01110001_00000110_01000001
const pxdash = "111011011011100010000011001000001"
var spaces = strings.Repeat(" ", 1024)
var spaces = strings.Repeat(" ", 9999)
func debugf(format string, a ...interface{}) {
if false { // Change false to true to show the long divisions.
+16 -8
View File
@@ -23,8 +23,10 @@ package main
//
// Output:
// Px' = 0x92D8_AF2B_AF0E_1E85
// k1' = 0xE05D_D497_CA39_3AE4
// k2' = 0xDABE_95AF_C787_5F40
// k1' = 0x6AE3_EFBB_9DD4_41F3
// k2' = 0x081F_6054_A784_2DF4
// k3' = 0xE05D_D497_CA39_3AE4
// k4' = 0xDABE_95AF_C787_5F40
// μ' = 0x9C3E_466C_1729_63D5
import (
@@ -38,7 +40,7 @@ import (
// P(x) = 0b1_01000010_11110000_11100001_11101011_10101001_11101010_00110110_10010011
const px = "10100001011110000111000011110101110101001111010100011011010010011"
var spaces = strings.Repeat(" ", 1024)
var spaces = strings.Repeat(" ", 9999)
func debugf(format string, a ...interface{}) {
if false { // Change false to true to show the long divisions.
@@ -66,7 +68,7 @@ func calcKn(name string, power int) {
b := []byte(numerator)
i := 0
debugf(" %s\n", numerator)
for i+len(px) <= len(numerator) {
for i+len(px) < len(numerator) {
for j := 0; j < len(px); j++ {
b[i+j] ^= 1 & px[j]
}
@@ -85,7 +87,7 @@ func calcMu(name string) {
b := []byte(numerator)
i := 0
debugf(" %s\n", numerator)
for i+len(px) <= len(numerator) {
for i+len(px) < len(numerator) {
for j := 0; j < len(px); j++ {
b[i+j] ^= 1 & px[j]
}
@@ -103,8 +105,14 @@ func calcMu(name string) {
}
func main() {
show("Px'", px)
calcKn("k1'", 128+64)
calcKn("k2'", 128)
calcKn("fold1a'", 128+64)
calcKn("fold1b'", 128)
calcKn("fold2a'", 256+64)
calcKn("fold2b'", 256)
calcKn("fold4a'", 512+64)
calcKn("fold4b'", 512)
calcKn("fold8a'", 1024+64)
calcKn("fold8b'", 1024)
calcMu("μ' ")
show("Px'", px)
}
+5
View File
@@ -54,7 +54,9 @@ print-image-metadata prints images' metadata.
#define WUFFS_CONFIG__MODULE__NIE
#define WUFFS_CONFIG__MODULE__PNG
#define WUFFS_CONFIG__MODULE__TGA
#define WUFFS_CONFIG__MODULE__VP8
#define WUFFS_CONFIG__MODULE__WBMP
#define WUFFS_CONFIG__MODULE__WEBP
#define WUFFS_CONFIG__MODULE__ZLIB
// If building this program in an environment that doesn't easily accommodate
@@ -391,6 +393,9 @@ redirect:
case WUFFS_BASE__FOURCC__WBMP:
dec = wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();
break;
case WUFFS_BASE__FOURCC__WEBP:
dec = wuffs_webp__decoder::alloc_as__wuffs_base__image_decoder();
break;
default:
return "main: unsupported file format";
}
+1 -1
View File
@@ -71,7 +71,7 @@ pri func hasher.up!(x: roslice base.u8),
s1 %= 65521
s2 %= 65521
args.x = remaining
} endwhile
}
this.state = ((s2 & 0xFFFF) << 16) | (s1 & 0xFFFF)
}
+2 -2
View File
@@ -44,7 +44,7 @@ pri func hasher.up_arm_neon!(x: roslice base.u8),
s1 ~mod+= args.x[0] as base.u32
s2 ~mod+= s1
args.x = args.x[1 ..]
} endwhile
}
s1 %= 65521
s2 %= 65521
@@ -186,6 +186,6 @@ pri func hasher.up_arm_neon!(x: roslice base.u8),
s1 %= 65521
s2 %= 65521
args.x = remaining
} endwhile
}
this.state = ((s2 & 0xFFFF) << 16) | (s1 & 0xFFFF)
}
+1 -1
View File
@@ -172,6 +172,6 @@ pri func hasher.up_x86_sse42!(x: roslice base.u8),
s1 %= 65521
s2 %= 65521
args.x = remaining
} endwhile
}
this.state = ((s2 & 0xFFFF) << 16) | (s1 & 0xFFFF)
}
+49 -47
View File
@@ -95,7 +95,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -383,6 +383,11 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
(this.channel_num_bits[2] > 8) or
(this.channel_num_bits[3] > 8) {
dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
} else if ((this.src_pixfmt == base.PIXEL_FORMAT__INDEXED__BGRA_BINARY) or
(this.src_pixfmt == base.PIXEL_FORMAT__BGR) or
(this.src_pixfmt == base.PIXEL_FORMAT__BGRX)) or
((this.src_pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE) and (this.channel_masks[3] == 0)) {
dst_pixfmt = base.PIXEL_FORMAT__BGRX
}
args.dst.set!(
@@ -406,7 +411,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -452,7 +457,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -505,7 +510,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
return status
}
yield? base."$short read"
} endwhile
}
args.src.skip_u32?(n: this.pending_pad)
this.pending_pad = 0
@@ -546,7 +551,7 @@ pri func decoder.swizzle_none!(dst: ptr base.pixel_buffer, src: base.io_reader)
}
this.pending_pad -= 1
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
} endwhile
}
while.inner true {
if this.dst_x == this.width {
@@ -586,7 +591,7 @@ pri func decoder.swizzle_none!(dst: ptr base.pixel_buffer, src: base.io_reader)
worst_case: src_bytes_per_pixel * 8)
}
j -= 8
} endwhile
}
while j > 0 {
if args.src.length() >= ((src_bytes_per_pixel * 1) as base.u64) {
args.src.skip_u32_fast!(
@@ -594,7 +599,7 @@ pri func decoder.swizzle_none!(dst: ptr base.pixel_buffer, src: base.io_reader)
worst_case: src_bytes_per_pixel * 1)
}
j -= 1
} endwhile
}
} else {
n = this.swizzler.swizzle_interleaved_from_reader!(
dst: dst[i ..],
@@ -605,8 +610,8 @@ pri func decoder.swizzle_none!(dst: ptr base.pixel_buffer, src: base.io_reader)
return "@internal note: short read"
}
this.dst_x ~sat+= (n & 0xFFFF_FFFF) as base.u32
} endwhile.inner
} endwhile.outer
}.inner
}.outer
return ok
}
@@ -667,11 +672,10 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
dst = this.util.empty_slice_u8()
}
while.goto_suspend true {{
while.inner true {
if rle_state == RLE_STATE_NEUTRAL {
if args.src.length() < 1 {
break.goto_suspend
break.inner
}
code = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
@@ -685,7 +689,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
} else if rle_state == RLE_STATE_RUN {
if args.src.length() < 1 {
break.goto_suspend
break.inner
}
code = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
@@ -695,7 +699,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
assert p0 < 255 via "a < b: a < c; c <= b"(c: this.rle_length)
this.scratch[p0] = code
p0 += 1
} endwhile
}
} else {
indexes[0] = (code >> 4) as base.u8
indexes[1] = code & 0x0F
@@ -705,7 +709,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
this.scratch[p0 + 0] = indexes[0]
this.scratch[p0 + 1] = indexes[1]
p0 += 2
} endwhile
}
}
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst,
@@ -717,7 +721,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
} else if rle_state == RLE_STATE_ESCAPE {
if args.src.length() < 1 {
break.goto_suspend
break.inner
}
code = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
@@ -769,7 +773,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
this.scratch[p0 + 0x03] = (0x0F & (chunk_bits >> 0x00)) as base.u8
p0 = (p0 & 255) + 0x04
chunk_count -= 1
} endwhile
}
p0 = p0.min(no_more_than: this.rle_length)
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst,
@@ -780,11 +784,11 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
}
if this.rle_length > 0 {
break.goto_suspend
break.inner
}
if this.rle_padded {
if args.src.length() < 1 {
break.goto_suspend
break.inner
}
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
this.rle_padded = false
@@ -794,7 +798,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
} else if rle_state == RLE_STATE_DELTA_X {
if args.src.length() < 1 {
break.goto_suspend
break.inner
}
this.rle_delta_x = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
@@ -803,7 +807,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
} // else (rle_state == RLE_STATE_DELTA_Y).
if args.src.length() < 1 {
break.goto_suspend
break.inner
}
code = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
@@ -844,18 +848,16 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
dst_palette: dst_palette,
num_pixels: 0xFFFF_FFFF_FFFF_FFFF)
code -= 1
} endwhile
}
}
rle_state = RLE_STATE_NEUTRAL
continue.middle
} endwhile.inner
}} endwhile.goto_suspend
}.inner
this.rle_state = rle_state
return "@internal note: short read"
} endwhile.middle
} endwhile.outer
}.middle
}.outer
while this.dst_y < this.height {
row = tab.row_u32(y: this.dst_y)
@@ -867,7 +869,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
dst_palette: dst_palette,
num_pixels: 0xFFFF_FFFF_FFFF_FFFF)
this.dst_y ~mod+= this.dst_y_inc
} endwhile
}
return ok
}
@@ -911,7 +913,7 @@ pri func decoder.swizzle_bitfields!(dst: ptr base.pixel_buffer, src: base.io_rea
}
this.pending_pad -= 1
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
} endwhile
}
while.inner true {
if this.dst_x == this.width {
@@ -965,17 +967,17 @@ pri func decoder.swizzle_bitfields!(dst: ptr base.pixel_buffer, src: base.io_rea
{
c |= c ~mod<< num_bits
num_bits *= 2
} endwhile
}
c >>= num_bits - 16
this.scratch[(8 * p0) + (2 * channel) + 0] = (0xFF & (c >> 0)) as base.u8
this.scratch[(8 * p0) + (2 * channel) + 1] = (0xFF & (c >> 8)) as base.u8
}
channel += 1
} endwhile
}
p0 += 1
} endwhile
}
// -------- END convert to PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE.
dst = tab.row_u32(y: this.dst_y)
@@ -995,8 +997,8 @@ pri func decoder.swizzle_bitfields!(dst: ptr base.pixel_buffer, src: base.io_rea
return "@internal note: short read"
}
this.dst_x ~sat+= (n & 0xFFFF_FFFF) as base.u32
} endwhile.inner
} endwhile.outer
}.inner
}.outer
return ok
}
@@ -1059,12 +1061,12 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
args.src.skip_u32_fast!(actual: 256, worst_case: 256)
this.dst_x = this.width.min(no_more_than: this.dst_x ~mod+ (pixels_per_chunk * 64))
chunk_count -= 64
} endwhile
}
while (chunk_count >= 8) and (args.src.length() >= 32) {
args.src.skip_u32_fast!(actual: 32, worst_case: 32)
this.dst_x = this.width.min(no_more_than: this.dst_x ~mod+ (pixels_per_chunk * 8))
chunk_count -= 8
} endwhile
}
while chunk_count > 0 {
if args.src.length() < 4 {
return "@internal note: short read"
@@ -1072,7 +1074,7 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
args.src.skip_u32_fast!(actual: 4, worst_case: 4)
this.dst_x = this.width.min(no_more_than: this.dst_x ~mod+ (pixels_per_chunk * 1))
chunk_count -= 1
} endwhile
}
continue.loop
}
dst = dst[i ..]
@@ -1120,7 +1122,7 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
this.scratch[p0 + 0x1F] = (0x01 & (chunk_bits >> 0x00)) as base.u8
p0 = (p0 & 511) + 0x20
chunk_count -= 1
} endwhile
}
} else if this.bits_per_pixel == 2 {
// Calculate the remaining number of 32-bit chunks. At 2 bits per
@@ -1148,7 +1150,7 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
this.scratch[p0 + 0x0F] = (0x03 & (chunk_bits >> 0x00)) as base.u8
p0 = (p0 & 511) + 0x10
chunk_count -= 1
} endwhile
}
} else {
// Calculate the remaining number of 32-bit chunks. At 4 bits per
@@ -1168,7 +1170,7 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
this.scratch[p0 + 0x07] = (0x0F & (chunk_bits >> 0x00)) as base.u8
p0 = (p0 & 511) + 0x08
chunk_count -= 1
} endwhile
}
}
p0 = p0.min(no_more_than: this.width ~sat- this.dst_x)
@@ -1180,7 +1182,7 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
return "@internal note: short read"
}
this.dst_x ~sat+= (n & 0xFFFF_FFFF) as base.u32
} endwhile.loop
}.loop
return ok
}
@@ -1236,7 +1238,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
@@ -1274,7 +1276,7 @@ pri func decoder.read_palette?(src: base.io_reader) {
this.src_palette[(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
this.src_palette[(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
i += 1
} endwhile
}
} else {
while (i < 256) and (this.padding >= 4) {
this.padding -= 4
@@ -1285,7 +1287,7 @@ pri func decoder.read_palette?(src: base.io_reader) {
this.src_palette[(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
this.src_palette[(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
i += 1
} endwhile
}
}
while i < 256 {
@@ -1294,7 +1296,7 @@ pri func decoder.read_palette?(src: base.io_reader) {
this.src_palette[(4 * i) + 2] = 0x00
this.src_palette[(4 * i) + 3] = 0xFF
i += 1
} endwhile
}
}
pri func decoder.process_masks?() {
@@ -1311,7 +1313,7 @@ pri func decoder.process_masks?() {
{
n ~mod+= 1
mask >>= 1
} endwhile
}
this.channel_shifts[i] = (n & 31) as base.u8
n = 0
@@ -1320,7 +1322,7 @@ pri func decoder.process_masks?() {
{
n ~mod+= 1
mask >>= 1
} endwhile
}
if (mask <> 0) or (n > 32) {
return "#bad header"
}
@@ -1330,5 +1332,5 @@ pri func decoder.process_masks?() {
}
i += 1
} endwhile
}
}
+31 -31
View File
@@ -140,7 +140,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
@@ -185,7 +185,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
this.bits ~mod<<= 1
this.n_bits -= 1
i += 1
} endwhile
}
if tag == 0x1772_4538_5090 {
break
@@ -209,7 +209,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
this.decode_huffman_slow?(src: args.src)
} endwhile
}
this.invert_bwt!()
@@ -228,7 +228,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
this.flush_slow?(dst: args.dst)
} endwhile
}
this.block_checksum_have ^= 0xFFFF_FFFF
if (not this.ignore_checksum) and (this.block_checksum_have <> this.block_checksum_want) {
@@ -237,7 +237,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
this.final_checksum_have = this.block_checksum_have ^ (
(this.final_checksum_have >> 31) |
(this.final_checksum_have ~mod<< 1))
} endwhile
}
// Read the 32-bit final checksum.
final_checksum_want = 0
@@ -254,7 +254,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
this.bits ~mod<<= 1
this.n_bits -= 1
i += 1
} endwhile
}
if (not this.ignore_checksum) and (this.final_checksum_have <> final_checksum_want) {
return "#bad checksum"
}
@@ -284,7 +284,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
this.bits ~mod<<= 1
this.n_bits -= 1
i += 1
} endwhile
}
// Read the "block randomized" bit.
if this.n_bits <= 0 {
@@ -314,14 +314,14 @@ pri func decoder.prepare_block?(src: base.io_reader) {
this.bits ~mod<<= 1
this.n_bits -= 1
i += 1
} endwhile
}
// Reset the presence bitmap.
i = 0
while i < 256 {
this.presence[i] = 0
i += 1
} endwhile
}
// Read the 16-bit high-level presence bitmap.
i = 0
@@ -338,7 +338,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
this.bits ~mod<<= 1
this.n_bits -= 1
i += 16
} endwhile
}
// Read the 16-bit low-level presence bitmaps.
this.scratch = 0
@@ -363,8 +363,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
if (i & 15) == 0 {
break
}
} endwhile
} endwhile
}
}
if (this.scratch < 1) or (256 < this.scratch) {
return "#bad block header"
}
@@ -385,7 +385,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
this.bits ~mod<<= 1
this.n_bits -= 1
i += 1
} endwhile
}
if (this.scratch < 2) or (6 < this.scratch) {
return "#bad block header"
}
@@ -406,7 +406,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
this.bits ~mod<<= 1
this.n_bits -= 1
i += 1
} endwhile
}
if (this.scratch < 1) or (18001 < this.scratch) {
return "#bad block header"
}
@@ -418,7 +418,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
assert i < 6 via "a < b: a < c; c <= b"(c: this.num_huffman_codes)
this.mtft[i] = i as base.u8
i += 1
} endwhile
}
// Read each section's Huffman code selector, applying the MTFT.
i = 0
@@ -447,7 +447,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
if selector >= this.num_huffman_codes {
return "#bad block header"
}
} endwhile
}
// Move to front.
if selector == 0 {
@@ -462,7 +462,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
}
i += 1
} endwhile
}
// Read the Huffman codes.
i = 0
@@ -475,7 +475,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
}
this.build_huffman_table!(which: i)
i += 1
} endwhile
}
// Initialize the MTFT state.
i = 0
@@ -486,14 +486,14 @@ pri func decoder.prepare_block?(src: base.io_reader) {
j ~mod+= 1
}
i += 1
} endwhile
}
// Initialize the letter counts.
i = 0
while i < 256 {
this.letter_counts[i] = 0
i += 1
} endwhile
}
}
pri func decoder.read_code_lengths?(src: base.io_reader) {
@@ -517,7 +517,7 @@ pri func decoder.read_code_lengths?(src: base.io_reader) {
this.bits ~mod<<= 1
this.n_bits -= 1
i += 1
} endwhile
}
// Read the code lengths.
i = 0
@@ -557,12 +557,12 @@ pri func decoder.read_code_lengths?(src: base.io_reader) {
}
this.bits ~mod<<= 1
this.n_bits -= 1
} endwhile
}
this.code_lengths_bitmask |= (1 as base.u32) << (code_length & 31)
this.bwt[i] = code_length
i += 1
} endwhile
}
}
// build_huffman_tree builds a canonical Huffman tree given the symbols' code
@@ -669,7 +669,7 @@ pri func decoder.build_huffman_tree!(which: base.u32[..= 5]) base.status {
this.huffman_trees[args.which][num_branch_nodes][1] = 0
num_branch_nodes += 1
stack_height += 1
} endwhile
}
node_index = stack_values[stack_height - 1]
if symbol_index < 2 {
@@ -694,13 +694,13 @@ pri func decoder.build_huffman_tree!(which: base.u32[..= 5]) base.status {
break
}
stack_height -= 1
} endwhile
}
}
symbol_index += 1
} endwhile
}
code_length += 1
} endwhile
}
if stack_height <> 0 {
return "#bad Huffman code (under-subscribed)"
@@ -724,10 +724,10 @@ pri func decoder.build_huffman_table!(which: base.u32[..= 5]) {
child = this.huffman_trees[args.which][child][bits >> 31]
bits ~mod<<= 1
n_bits += 1
} endwhile
}
this.huffman_tables[args.which][i] = (child | (n_bits << 12)) as base.u16
i += 1
} endwhile
}
}
// invert_bwt performs "two passes over the data, and one pass over the
@@ -748,7 +748,7 @@ pri func decoder.invert_bwt!() {
sum ~mod+= this.letter_counts[i]
this.letter_counts[i] = old_sum
i += 1
} endwhile
}
// Second data pass, but per the README.md file, calculate the U column
// instead of the BWT technical report's T column.
@@ -759,7 +759,7 @@ pri func decoder.invert_bwt!() {
this.bwt[this.letter_counts[letter] & 1_048575] |= i << 12
this.letter_counts[letter] ~mod+= 1
i += 1
} endwhile
}
}
// The table below was created by script/print-crc32-magic-numbers.go with the
+2 -2
View File
@@ -56,12 +56,12 @@ pri func decoder.flush_fast!(dst: base.io_writer) {
args.dst.write_u8_fast!(a: flush_prev)
}
flush_repeat_count -= 1
} endwhile
}
flush_repeat_count = 0
flush_prev = curr
block_size -= 1
}
} endwhile
}
this.flush_pointer = flush_pointer
this.flush_repeat_count = flush_repeat_count
+2 -2
View File
@@ -54,12 +54,12 @@ pri func decoder.flush_slow?(dst: base.io_writer) {
(block_checksum_have ~mod<< 8)
args.dst.write_u8?(a: flush_prev)
flush_repeat_count -= 1
} endwhile
}
flush_repeat_count = 0
flush_prev = curr
block_size -= 1
}
} endwhile
}
this.flush_pointer = flush_pointer
this.flush_repeat_count = flush_repeat_count
+3 -3
View File
@@ -62,7 +62,7 @@ pri func decoder.decode_huffman_fast!(src: base.io_reader) base.status {
return "#internal error: inconsistent Huffman decoder state"
}
n_bits -= 1
} endwhile
}
if child < 0x300 { // mNN symbol.
// Move to front.
@@ -108,8 +108,8 @@ pri func decoder.decode_huffman_fast!(src: base.io_reader) base.status {
assert i < 900000 via "a < b: a < c; c <= b"(c: j)
this.bwt[i] = mtft0
i += 1
} endwhile
} endwhile.outer
}
}.outer
this.bits = bits
this.n_bits = n_bits
+3 -3
View File
@@ -94,8 +94,8 @@ pri func decoder.decode_huffman_slow?(src: base.io_reader) {
assert i < 900000 via "a < b: a < c; c <= b"(c: j)
this.bwt[i] = mtft0
i += 1
} endwhile
}
break
} endwhile
} endwhile.outer
}
}.outer
}
+10 -10
View File
@@ -230,7 +230,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
continue.outer
}
return "#internal error: inconsistent I/O"
}} endwhile.goto_have_string_length
}}.goto_have_string_length
}
if c_major == 0 {
@@ -362,7 +362,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
continue.outer
}
break.goto_parsed_a_leaf_value
} endwhile
}
// -------- END Major type 2: a byte string.
} else if c_major == 3 {
@@ -447,7 +447,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
continue.outer
}
break.goto_parsed_a_leaf_value
} endwhile
}
// -------- END Major type 3: a text string.
} else if c_major == 4 {
@@ -459,7 +459,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
while (token_length > 0) and (args.src.can_undo_byte()) {
args.src.undo_byte!()
token_length -= 1
} endwhile
}
return "#unsupported recursion depth"
}
@@ -526,7 +526,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
while (token_length > 0) and (args.src.can_undo_byte()) {
args.src.undo_byte!()
token_length -= 1
} endwhile
}
return "#unsupported recursion depth"
}
@@ -713,14 +713,14 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
// -------- END Major type 7: miscellaneous.
}
break.goto_fail
}} endwhile.goto_fail
}}.goto_fail
if args.src.can_undo_byte() {
args.src.undo_byte!()
return "#bad input"
}
return "#internal error: inconsistent I/O"
}} endwhile.goto_parsed_a_leaf_value
}}.goto_parsed_a_leaf_value
// We've just parsed a leaf (non-container) value, or the (explicit or
// implicit) close of a container (array or object).
@@ -753,7 +753,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
{
yield? base."$short write"
continue
} endwhile
}
depth -= 1
// Fill in FROM_ETC.
@@ -787,11 +787,11 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
value_minor: vminor_alt,
continued: 0,
length: 0)
} endwhile
}
// We've parsed the top-level value and we're therefore done overall.
break.outer
} endwhile.outer
}.outer
this.end_of_data = true
}
-1
View File
@@ -28,7 +28,6 @@ pub func ieee_hasher.update!(x: roslice base.u8) {
if this.state == 0 {
choose up = [
up_arm_crc32,
up_x86_avx2,
up_x86_sse42]
}
this.up!(x: args.x)
+1 -1
View File
@@ -22,7 +22,7 @@ pri func ieee_hasher.up_arm_crc32!(x: roslice base.u8),
while (args.x.length() > 0) and ((15 & args.x.uintptr_low_12_bits()) <> 0) {
s = s.crc32b(b: args.x[0])
args.x = args.x[1 ..]
} endwhile
}
iterate (p = args.x)(length: 8, advance: 8, unroll: 16) {
s = s.crc32d(b: p.peek_u64le())
-134
View File
@@ -1,134 +0,0 @@
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// --------
// See "SIMD Implementations" in README.md for a link to Gopal et al. "Fast CRC
// Computation for Generic Polynomials Using PCLMULQDQ Instruction".
// up_x86_avx2 is exactly the same as up_x86_sse42 except for the "choose
// cpu_arch >= x86_avx2". With AVX, PCLMULQDQ has a three-operand form, not
// just a two-operand form: https://www.felixcloutier.com/x86/pclmulqdq
pri func ieee_hasher.up_x86_avx2!(x: roslice base.u8),
choose cpu_arch >= x86_avx2,
{
var s : base.u32
var p : roslice base.u8
var util : base.x86_sse42_utility
var k : base.x86_m128i
var x0 : base.x86_m128i
var x1 : base.x86_m128i
var x2 : base.x86_m128i
var x3 : base.x86_m128i
var y0 : base.x86_m128i
var y1 : base.x86_m128i
var y2 : base.x86_m128i
var y3 : base.x86_m128i
var tail_index : base.u64
s = 0xFFFF_FFFF ^ this.state
// Align to a 16-byte boundary.
while (args.x.length() > 0) and ((15 & args.x.uintptr_low_12_bits()) <> 0) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ args.x[0]] ^ (s >> 8)
args.x = args.x[1 ..]
} endwhile
// For short inputs, just do a simple loop.
if args.x.length() < 64 {
iterate (p = args.x)(length: 1, advance: 1, unroll: 1) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
}
this.state = 0xFFFF_FFFF ^ s
return nothing
}
// Load 128×4 = 512 bits from the first 64-byte chunk.
x0 = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])
x1 = util.make_m128i_slice128(a: args.x[0x10 .. 0x20])
x2 = util.make_m128i_slice128(a: args.x[0x20 .. 0x30])
x3 = util.make_m128i_slice128(a: args.x[0x30 .. 0x40])
// Combine with the initial state.
x0 = x0._mm_xor_si128(b: util.make_m128i_single_u32(a: s))
// Process the remaining 64-byte chunks.
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K1K2[.. 16])
iterate (p = args.x[64 ..])(length: 64, advance: 64, unroll: 1) {
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
y1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x00)
y2 = x2._mm_clmulepi64_si128(b: k, imm8: 0x00)
y3 = x3._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x11)
x2 = x2._mm_clmulepi64_si128(b: k, imm8: 0x11)
x3 = x3._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: y0)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x00 .. 0x10]))
x1 = x1._mm_xor_si128(b: y1)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x10 .. 0x20]))
x2 = x2._mm_xor_si128(b: y2)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x20 .. 0x30]))
x3 = x3._mm_xor_si128(b: y3)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x30 .. 0x40]))
}
// Reduce 128×4 = 512 bits to 128 bits.
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K3K4[.. 16])
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x1)
x0 = x0._mm_xor_si128(b: y0)
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x2)
x0 = x0._mm_xor_si128(b: y0)
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x3)
x0 = x0._mm_xor_si128(b: y0)
// Reduce 128 bits to 64 bits.
x1 = x0._mm_clmulepi64_si128(b: k, imm8: 0x10)
x2 = util.make_m128i_multiple_u32(
a00: 0xFFFF_FFFF,
a01: 0x0000_0000,
a02: 0xFFFF_FFFF,
a03: 0x0000_0000)
x0 = x0._mm_srli_si128(imm8: 8)
x0 = x0._mm_xor_si128(b: x1)
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K5ZZ[.. 16])
x1 = x0._mm_srli_si128(imm8: 4)
x0 = x0._mm_and_si128(b: x2)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_xor_si128(b: x1)
// Reduce 64 bits to 32 bits (Barrett Reduction) and extract.
//
// Barrett Reduction is Algorithm 1 (page 14) of Gopal et al., after
// adjusting for bit-reflection as per Figure 12 (page 21).
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_PXMU[.. 16])
x1 = x0._mm_and_si128(b: x2)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x10)
x1 = x1._mm_and_si128(b: x2)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_xor_si128(b: x1)
s = x0._mm_extract_epi32(imm8: 1)
// Handle the tail of args.x that wasn't a complete 64-byte chunk.
tail_index = args.x.length() & 0xFFFF_FFFF_FFFF_FFC0 // And-not 64.
if tail_index < args.x.length() {
iterate (p = args.x[tail_index ..])(length: 1, advance: 1, unroll: 1) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
}
}
this.state = 0xFFFF_FFFF ^ s
}
+110 -117
View File
@@ -8,29 +8,29 @@
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// --------
// See "SIMD Implementations" in README.md for a link to Gopal et al. "Fast CRC
// Computation for Generic Polynomials Using PCLMULQDQ Instruction".
pri func ieee_hasher.up_x86_sse42!(x: roslice base.u8),
choose cpu_arch >= x86_sse42,
{
var s : base.u32
var p : roslice base.u8
var util : base.x86_sse42_utility
var k : base.x86_m128i
var kk : base.x86_m128i
var x0 : base.x86_m128i
var x1 : base.x86_m128i
var x2 : base.x86_m128i
var x3 : base.x86_m128i
var x4 : base.x86_m128i
var x5 : base.x86_m128i
var x6 : base.x86_m128i
var x7 : base.x86_m128i
var y0 : base.x86_m128i
var y1 : base.x86_m128i
var y2 : base.x86_m128i
var y3 : base.x86_m128i
var tail_index : base.u64
var y4 : base.x86_m128i
var y5 : base.x86_m128i
var y6 : base.x86_m128i
var y7 : base.x86_m128i
s = 0xFFFF_FFFF ^ this.state
@@ -38,120 +38,113 @@ pri func ieee_hasher.up_x86_sse42!(x: roslice base.u8),
while (args.x.length() > 0) and ((15 & args.x.uintptr_low_12_bits()) <> 0) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ args.x[0]] ^ (s >> 8)
args.x = args.x[1 ..]
} endwhile
// For short inputs, just do a simple loop.
if args.x.length() < 64 {
iterate (p = args.x)(length: 1, advance: 1, unroll: 1) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
}
this.state = 0xFFFF_FFFF ^ s
return nothing
}
// Load 128×4 = 512 bits from the first 64-byte chunk.
x0 = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])
x1 = util.make_m128i_slice128(a: args.x[0x10 .. 0x20])
x2 = util.make_m128i_slice128(a: args.x[0x20 .. 0x30])
x3 = util.make_m128i_slice128(a: args.x[0x30 .. 0x40])
// Combine with the initial state.
x0 = x0._mm_xor_si128(b: util.make_m128i_single_u32(a: s))
// Process the remaining 64-byte chunks.
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K1K2[.. 16])
iterate (p = args.x[64 ..])(length: 64, advance: 64, unroll: 1) {
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
y1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x00)
y2 = x2._mm_clmulepi64_si128(b: k, imm8: 0x00)
y3 = x3._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x11)
x2 = x2._mm_clmulepi64_si128(b: k, imm8: 0x11)
x3 = x3._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: y0)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x00 .. 0x10]))
x1 = x1._mm_xor_si128(b: y1)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x10 .. 0x20]))
x2 = x2._mm_xor_si128(b: y2)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x20 .. 0x30]))
x3 = x3._mm_xor_si128(b: y3)._mm_xor_si128(b: util.make_m128i_slice128(a: p[0x30 .. 0x40]))
if args.x.length() >= 128 {
// BEGIN script/print-crc32-x86-sse42-code.go generated code.
x0 = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])
x1 = util.make_m128i_slice128(a: args.x[0x10 .. 0x20])
x2 = util.make_m128i_slice128(a: args.x[0x20 .. 0x30])
x3 = util.make_m128i_slice128(a: args.x[0x30 .. 0x40])
x4 = util.make_m128i_slice128(a: args.x[0x40 .. 0x50])
x5 = util.make_m128i_slice128(a: args.x[0x50 .. 0x60])
x6 = util.make_m128i_slice128(a: args.x[0x60 .. 0x70])
x7 = util.make_m128i_slice128(a: args.x[0x70 .. 0x80])
kk = util.make_m128i_multiple_u32(a00: 0x33FF_F533, a01: 0, a02: 0x910E_EEC1, a03: 0)
x0 = x0._mm_xor_si128(b: util.make_m128i_single_u32(a: s))
args.x = args.x[128 ..]
while args.x.length() >= 128 {
y0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y1 = x1._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x1 = x1._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y2 = x2._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x2 = x2._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y3 = x3._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x3 = x3._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y4 = x4._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x4 = x4._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y5 = x5._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x5 = x5._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y6 = x6._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x6 = x6._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y7 = x7._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x7 = x7._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y0 = y0._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x00 .. 0x10]))
x0 = x0._mm_xor_si128(b: y0)
y1 = y1._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x10 .. 0x20]))
x1 = x1._mm_xor_si128(b: y1)
y2 = y2._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x20 .. 0x30]))
x2 = x2._mm_xor_si128(b: y2)
y3 = y3._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x30 .. 0x40]))
x3 = x3._mm_xor_si128(b: y3)
y4 = y4._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x40 .. 0x50]))
x4 = x4._mm_xor_si128(b: y4)
y5 = y5._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x50 .. 0x60]))
x5 = x5._mm_xor_si128(b: y5)
y6 = y6._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x60 .. 0x70]))
x6 = x6._mm_xor_si128(b: y6)
y7 = y7._mm_xor_si128(b: util.make_m128i_slice128(a: args.x[0x70 .. 0x80]))
x7 = x7._mm_xor_si128(b: y7)
args.x = args.x[128 ..]
}
kk = util.make_m128i_multiple_u32(a00: 0xAE68_9191, a01: 0, a02: 0xCCAA_009E, a03: 0)
y0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y2 = x2._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x2 = x2._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y4 = x4._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x4 = x4._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y6 = x6._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x6 = x6._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y0 = y0._mm_xor_si128(b: x1)
x0 = x0._mm_xor_si128(b: y0)
y2 = y2._mm_xor_si128(b: x3)
x2 = x2._mm_xor_si128(b: y2)
y4 = y4._mm_xor_si128(b: x5)
x4 = x4._mm_xor_si128(b: y4)
y6 = y6._mm_xor_si128(b: x7)
x6 = x6._mm_xor_si128(b: y6)
kk = util.make_m128i_multiple_u32(a00: 0xF1DA_05AA, a01: 0, a02: 0x8125_6527, a03: 0)
y0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y4 = x4._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x4 = x4._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y0 = y0._mm_xor_si128(b: x2)
x0 = x0._mm_xor_si128(b: y0)
y4 = y4._mm_xor_si128(b: x6)
x4 = x4._mm_xor_si128(b: y4)
kk = util.make_m128i_multiple_u32(a00: 0x8F35_2D95, a01: 0, a02: 0x1D95_13D7, a03: 0)
y0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: kk, imm8: 0x11)
y0 = y0._mm_xor_si128(b: x4)
x0 = x0._mm_xor_si128(b: y0)
kk = util.make_m128i_multiple_u32(a00: 0xF701_1641, a01: 0xB4E5_B025, a02: 0xDB71_0641, a03: 1)
s = util.make_m128i_single_u64(a: x0._mm_extract_epi64(imm8: 0)).
_mm_clmulepi64_si128(b: kk, imm8: 0x00).
_mm_clmulepi64_si128(b: kk, imm8: 0x10).
_mm_extract_epi32(imm8: 2)
kk = util.make_m128i_multiple_u32(a00: 0xF701_1641, a01: 0xB4E5_B025, a02: 0xDB71_0641, a03: 1)
s = util.make_m128i_single_u64(a: x0._mm_extract_epi64(imm8: 1) ^ (s as base.u64)).
_mm_clmulepi64_si128(b: kk, imm8: 0x00).
_mm_clmulepi64_si128(b: kk, imm8: 0x10).
_mm_extract_epi32(imm8: 2)
// END script/print-crc32-x86-sse42-code.go generated code.
}
// Reduce 128×4 = 512 bits to 128 bits.
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K3K4[.. 16])
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x1)
x0 = x0._mm_xor_si128(b: y0)
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x2)
x0 = x0._mm_xor_si128(b: y0)
y0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x11)
x0 = x0._mm_xor_si128(b: x3)
x0 = x0._mm_xor_si128(b: y0)
while args.x.length() >= 8 {
kk = util.make_m128i_multiple_u32(a00: 0xF701_1641, a01: 0xB4E5_B025, a02: 0xDB71_0641, a03: 1)
s = util.make_m128i_single_u64(a: args.x.peek_u64le() ^ (s as base.u64)).
_mm_clmulepi64_si128(b: kk, imm8: 0x00).
_mm_clmulepi64_si128(b: kk, imm8: 0x10).
_mm_extract_epi32(imm8: 2)
args.x = args.x[8 ..]
}
// Reduce 128 bits to 64 bits.
x1 = x0._mm_clmulepi64_si128(b: k, imm8: 0x10)
x2 = util.make_m128i_multiple_u32(
a00: 0xFFFF_FFFF,
a01: 0x0000_0000,
a02: 0xFFFF_FFFF,
a03: 0x0000_0000)
x0 = x0._mm_srli_si128(imm8: 8)
x0 = x0._mm_xor_si128(b: x1)
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_K5ZZ[.. 16])
x1 = x0._mm_srli_si128(imm8: 4)
x0 = x0._mm_and_si128(b: x2)
x0 = x0._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_xor_si128(b: x1)
// Reduce 64 bits to 32 bits (Barrett Reduction) and extract.
//
// Barrett Reduction is Algorithm 1 (page 14) of Gopal et al., after
// adjusting for bit-reflection as per Figure 12 (page 21).
k = util.make_m128i_slice128(a: IEEE_X86_SSE42_PXMU[.. 16])
x1 = x0._mm_and_si128(b: x2)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x10)
x1 = x1._mm_and_si128(b: x2)
x1 = x1._mm_clmulepi64_si128(b: k, imm8: 0x00)
x0 = x0._mm_xor_si128(b: x1)
s = x0._mm_extract_epi32(imm8: 1)
// Handle the tail of args.x that wasn't a complete 64-byte chunk.
tail_index = args.x.length() & 0xFFFF_FFFF_FFFF_FFC0 // And-not 64.
if tail_index < args.x.length() {
iterate (p = args.x[tail_index ..])(length: 1, advance: 1, unroll: 1) {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
}
while args.x.length() > 0 {
s = IEEE_TABLE[0][((s & 0xFF) as base.u8) ^ args.x[0]] ^ (s >> 8)
args.x = args.x[1 ..]
}
this.state = 0xFFFF_FFFF ^ s
}
// These constants come from page 22 of Gopal et al. They are also reproduced
// by script/print-crc32-x86-sse42-magic-numbers.go which is runnable online at
// https://play.golang.org/p/wH1q6GfhKOE
//
// The k6' constant from the Gopal paper is unused.
pri const IEEE_X86_SSE42_K1K2 : roarray[16] base.u8 = [
0xD4, 0x2B, 0x44, 0x54, 0x01, 0x00, 0x00, 0x00, // k1' = 0x1_5444_2BD4
0x96, 0x15, 0xE4, 0xC6, 0x01, 0x00, 0x00, 0x00, // k2' = 0x1_C6E4_1596
]
pri const IEEE_X86_SSE42_K3K4 : roarray[16] base.u8 = [
0xD0, 0x97, 0x19, 0x75, 0x01, 0x00, 0x00, 0x00, // k3' = 0x1_7519_97D0
0x9E, 0x00, 0xAA, 0xCC, 0x00, 0x00, 0x00, 0x00, // k4' = 0x0_CCAA_009E
]
pri const IEEE_X86_SSE42_K5ZZ : roarray[16] base.u8 = [
0x24, 0x61, 0xCD, 0x63, 0x01, 0x00, 0x00, 0x00, // k5' = 0x1_63CD_6124
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Unused
]
pri const IEEE_X86_SSE42_PXMU : roarray[16] base.u8 = [
0x41, 0x06, 0x71, 0xDB, 0x01, 0x00, 0x00, 0x00, // Px' = 0x1_DB71_0641
0x41, 0x16, 0x01, 0xF7, 0x01, 0x00, 0x00, 0x00, // μ' = 0x1_F701_1641
]
+196 -90
View File
@@ -12,6 +12,8 @@
// Like std/crc32's x86 SIMD implementation, this is based on Gopal et al.
// "Fast CRC Computation for Generic Polynomials Using PCLMULQDQ Instruction".
// and further optimized a la
// https://github.com/JoernEngel/joernblog/blob/778f0007b9a580e477608691f1aa86369f0efdd2/crc64.c
pri func ecma_hasher.up_x86_sse42!(x: roslice base.u8),
choose cpu_arch >= x86_sse42,
@@ -19,26 +21,22 @@ pri func ecma_hasher.up_x86_sse42!(x: roslice base.u8),
var s : base.u64
var p : roslice base.u8
var util : base.x86_sse42_utility
var s0 : base.x86_m128i
var s0_707F : base.x86_m128i
var s0_8F80 : base.x86_m128i
var x0 : base.x86_m128i
var aa : base.x86_m128i
var k1k2 : base.x86_m128i
var t0 : base.x86_m128i
var t1 : base.x86_m128i
var t2 : base.x86_m128i
var u0 : base.x86_m128i
var u1 : base.x86_m128i
var u2 : base.x86_m128i
var v0 : base.x86_m128i
var v1 : base.x86_m128i
var pxmu : base.x86_m128i
var w1 : base.x86_m128i
var w2 : base.x86_m128i
var buf : array[48] base.u8
var tail_index : base.u64
var util : base.x86_sse42_utility
var xa : base.x86_m128i
var xb : base.x86_m128i
var xc : base.x86_m128i
var xd : base.x86_m128i
var xe : base.x86_m128i
var xf : base.x86_m128i
var xg : base.x86_m128i
var xh : base.x86_m128i
var mu1 : base.x86_m128i
var mu2 : base.x86_m128i
var mu4 : base.x86_m128i
var mu8 : base.x86_m128i
var mupx : base.x86_m128i
s = 0xFFFF_FFFF_FFFF_FFFF ^ this.state
@@ -46,10 +44,33 @@ pri func ecma_hasher.up_x86_sse42!(x: roslice base.u8),
while (args.x.length() > 0) and ((15 & args.x.uintptr_low_12_bits()) <> 0) {
s = ECMA_TABLE[0][((s & 0xFF) as base.u8) ^ args.x[0]] ^ (s >> 8)
args.x = args.x[1 ..]
} endwhile
}
// For short inputs, just do a simple loop.
if args.x.length() < 0x20 {
while.chain2 true {{
while.chain4 true {{
if args.x.length() >= 0x80 {
// No-op.
} else if args.x.length() >= 0x40 {
// Set up 4 accumulators.
xa = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])._mm_xor_si128(b:
util.make_m128i_single_u64(a: s))
xb = util.make_m128i_slice128(a: args.x[0x10 .. 0x20])
xc = util.make_m128i_slice128(a: args.x[0x20 .. 0x30])
xd = util.make_m128i_slice128(a: args.x[0x30 .. 0x40])
args.x = args.x[0x40 ..]
break.chain4
} else if args.x.length() >= 0x20 {
// Set up 2 accumulators.
xa = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])._mm_xor_si128(b:
util.make_m128i_single_u64(a: s))
xb = util.make_m128i_slice128(a: args.x[0x10 .. 0x20])
args.x = args.x[0x20 ..]
break.chain2
} else {
// For short inputs, just do a simple loop.
iterate (p = args.x)(length: 1, advance: 1, unroll: 1) {
s = ECMA_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
}
@@ -57,89 +78,174 @@ pri func ecma_hasher.up_x86_sse42!(x: roslice base.u8),
return nothing
}
// Process N 16-byte chunks (1 on ramp, N-2 main loop, 1 off ramp). The
// algorithm is loosely based on https://github.com/rawrunprotected/crc but
// modified to always start and end on 16-byte alignment boundaries. It
// also doesn't crash on zero-length input.
// On ramp.
s0 = util.make_m128i_single_u64(a: s)
s0_707F = s0._mm_shuffle_epi8(b: util.make_m128i_slice128(a: SHUFFLE_707F[.. 16]))
s0_8F80 = s0._mm_shuffle_epi8(b: util.make_m128i_slice128(a: SHUFFLE_8F80[.. 16]))
x0 = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])
args.x = args.x[0x10 ..]
k1k2 = util.make_m128i_slice128(a: ECMA_X86_SSE42_K1K2[.. 16])
t0 = s0_707F._mm_xor_si128(b: x0)
t1 = t0._mm_clmulepi64_si128(b: k1k2, imm8: 0x00)
t2 = t0._mm_clmulepi64_si128(b: k1k2, imm8: 0x11)
aa = t1._mm_xor_si128(b: t2)._mm_xor_si128(b: s0_8F80)
// Set up 8 accumulators.
xa = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])._mm_xor_si128(b:
util.make_m128i_single_u64(a: s))
xb = util.make_m128i_slice128(a: args.x[0x10 .. 0x20])
xc = util.make_m128i_slice128(a: args.x[0x20 .. 0x30])
xd = util.make_m128i_slice128(a: args.x[0x30 .. 0x40])
xe = util.make_m128i_slice128(a: args.x[0x40 .. 0x50])
xf = util.make_m128i_slice128(a: args.x[0x50 .. 0x60])
xg = util.make_m128i_slice128(a: args.x[0x60 .. 0x70])
xh = util.make_m128i_slice128(a: args.x[0x70 .. 0x80])
args.x = args.x[0x80 ..]
// Main loop.
while args.x.length() >= 0x20 {
x0 = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])
args.x = args.x[0x10 ..]
u0 = aa._mm_xor_si128(b: x0)
u1 = u0._mm_clmulepi64_si128(b: k1k2, imm8: 0x00)
u2 = u0._mm_clmulepi64_si128(b: k1k2, imm8: 0x11)
aa = u1._mm_xor_si128(b: u2)
} endwhile
// Off ramp.
if args.x.length() < 0x10 {
// Unreachable, but the "if" is needed by the bounds checker.
return nothing
mu8 = util.make_m128i_slice128(a: ECMA_X86_SSE42_FOLD8[.. 16])
while args.x.length() >= 0x80 {
xa = xa._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x00 .. 0x10]))
xb = xb._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xb._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x10 .. 0x20]))
xc = xc._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xc._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x20 .. 0x30]))
xd = xd._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xd._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x30 .. 0x40]))
xe = xe._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xe._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x40 .. 0x50]))
xf = xf._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xf._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x50 .. 0x60]))
xg = xg._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xg._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x60 .. 0x70]))
xh = xh._mm_clmulepi64_si128(b: mu8, imm8: 0x00)._mm_xor_si128(b:
xh._mm_clmulepi64_si128(b: mu8, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x70 .. 0x80]))
args.x = args.x[0x80 ..]
}
x0 = util.make_m128i_slice128(a: args.x[0x00 .. 0x10])
args.x = args.x[0x10 ..]
v0 = aa._mm_xor_si128(b: x0)
v1 = v0._mm_clmulepi64_si128(b: k1k2, imm8: 0x10)
aa = v1._mm_xor_si128(b: v0._mm_srli_si128(imm8: 8))
// Reduce 8 chains down to 4.
mu4 = util.make_m128i_slice128(a: ECMA_X86_SSE42_FOLD4[.. 16])
xa = xa._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
xe)
xb = xb._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xb._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
xf)
xc = xc._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xc._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
xg)
xd = xd._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xd._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
xh)
if args.x.length() > 0x40 {
xa = xa._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x00 .. 0x10]))
xb = xb._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xb._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x10 .. 0x20]))
xc = xc._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xc._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x20 .. 0x30]))
xd = xd._mm_clmulepi64_si128(b: mu4, imm8: 0x00)._mm_xor_si128(b:
xd._mm_clmulepi64_si128(b: mu4, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x30 .. 0x40]))
args.x = args.x[0x40 ..]
}
// Barrett reduction.
pxmu = util.make_m128i_slice128(a: ECMA_X86_SSE42_PXMU[.. 16])
w1 = aa._mm_clmulepi64_si128(b: pxmu, imm8: 0x10)
w2 = w1._mm_clmulepi64_si128(b: pxmu, imm8: 0x00)
s = aa._mm_xor_si128(b:
w2._mm_xor_si128(b:
w1._mm_slli_si128(imm8: 8)))._mm_extract_epi64(imm8: 1)
break.chain4
}}.chain4
// Reduce 4 chains down to 2.
mu2 = util.make_m128i_slice128(a: ECMA_X86_SSE42_FOLD2[.. 16])
xa = xa._mm_clmulepi64_si128(b: mu2, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu2, imm8: 0x11))._mm_xor_si128(b:
xc)
xb = xb._mm_clmulepi64_si128(b: mu2, imm8: 0x00)._mm_xor_si128(b:
xb._mm_clmulepi64_si128(b: mu2, imm8: 0x11))._mm_xor_si128(b:
xd)
if args.x.length() > 0x20 {
xa = xa._mm_clmulepi64_si128(b: mu2, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu2, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x00 .. 0x10]))
xb = xb._mm_clmulepi64_si128(b: mu2, imm8: 0x00)._mm_xor_si128(b:
xb._mm_clmulepi64_si128(b: mu2, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x10 .. 0x20]))
args.x = args.x[0x20 ..]
}
// Handle the tail of args.x that wasn't a complete 16-byte chunk.
tail_index = args.x.length() & 0xFFFF_FFFF_FFFF_FFF0 // And-not 16.
if tail_index < args.x.length() {
iterate (p = args.x[tail_index ..])(length: 1, advance: 1, unroll: 1) {
s = ECMA_TABLE[0][((s & 0xFF) as base.u8) ^ p[0]] ^ (s >> 8)
break.chain2
}}.chain2
// Reduce 2 chains down to 1.
mu1 = util.make_m128i_slice128(a: ECMA_X86_SSE42_FOLD1[.. 16])
xa = xa._mm_clmulepi64_si128(b: mu1, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu1, imm8: 0x11))._mm_xor_si128(b:
xb)
if args.x.length() > 24 {
xa = xa._mm_clmulepi64_si128(b: mu1, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu1, imm8: 0x11))._mm_xor_si128(b:
util.make_m128i_slice128(a: args.x[0x00 .. 0x10]))
args.x = args.x[0x10 ..]
if args.x.length() > 24 {
return nothing // Unreachable.
}
}
assert args.x.length() <= 24
// Copy our accumulator xa and the remaining data to buf, a 48-byte buffer.
// The buffer includes the implicitly appended 8 bytes for the CRC.
//
// | 0-padding | xa | args.x | 0-padding |
// | 0-24 bytes | 16 bytes | 0-24 bytes| 8 bytes |
//
assert (24 - args.x.length()) <= ((24 - args.x.length()) + 16) via "a <= (a + b): 0 <= b"()
xa.store_slice128!(a: buf[24 - args.x.length() .. (24 - args.x.length()) + 16])
buf[(24 - args.x.length()) + 16 ..].copy_from_slice!(s: args.x)
// Reduce the 48-byte buffer down to a 16-byte (128-bit) accumulator.
mu2 = util.make_m128i_slice128(a: ECMA_X86_SSE42_FOLD2[.. 16])
xa = util.make_m128i_slice128(a: buf[0x00 .. 0x10])
xb = util.make_m128i_slice128(a: buf[0x10 .. 0x20])
xc = util.make_m128i_slice128(a: buf[0x20 .. 0x30])
xd = xa._mm_clmulepi64_si128(b: mu2, imm8: 0x00)._mm_xor_si128(b:
xa._mm_clmulepi64_si128(b: mu2, imm8: 0x11))
xe = xb._mm_clmulepi64_si128(b: mu1, imm8: 0x00)._mm_xor_si128(b:
xb._mm_clmulepi64_si128(b: mu1, imm8: 0x11))
xa = xd._mm_xor_si128(b: xe._mm_xor_si128(b: xc))
// Reduce 128-bit to 64-bit via Barrett reduction.
mupx = util.make_m128i_slice128(a: ECMA_X86_SSE42_MUPX[.. 16])
xb = xa._mm_clmulepi64_si128(b: mupx, imm8: 0x00)
xc = xb._mm_clmulepi64_si128(b: mupx, imm8: 0x10)
s = xc._mm_xor_si128(b: xb._mm_slli_si128(imm8: 8)).
_mm_xor_si128(b: xa)._mm_extract_epi64(imm8: 1)
this.state = 0xFFFF_FFFF_FFFF_FFFF ^ s
}
pri const SHUFFLE_707F : roarray[16] base.u8 = [
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
]
pri const SHUFFLE_8F80 : roarray[16] base.u8 = [
0x8F, 0x8E, 0x8D, 0x8C, 0x8B, 0x8A, 0x89, 0x88,
0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
]
// These constants are reproduced by
// script/print-crc64-x86-sse42-magic-numbers.go
//
// The rkN names match the numbers at
// https://github.com/intel/isa-l/blob/7b30857e20b84e5afab1a28291189b9dc571110d/crc/crc64_ecma_refl_by16_10.asm#L33-L56
pri const ECMA_X86_SSE42_K1K2 : roarray[16] base.u8 = [
0xE4, 0x3A, 0x39, 0xCA, 0x97, 0xD4, 0x5D, 0xE0, // k1' = 0xE05D_D497_CA39_3AE4
0x40, 0x5F, 0x87, 0xC7, 0xAF, 0x95, 0xBE, 0xDA, // k2' = 0xDABE_95AF_C787_5F40
pri const ECMA_X86_SSE42_FOLD1 : roarray[16] base.u8 = [
0xE4, 0x3A, 0x39, 0xCA, 0x97, 0xD4, 0x5D, 0xE0, // fold1a' = 0xE05D_D497_CA39_3AE4 = rk2
0x40, 0x5F, 0x87, 0xC7, 0xAF, 0x95, 0xBE, 0xDA, // fold1b' = 0xDABE_95AF_C787_5F40 = rk1
]
pri const ECMA_X86_SSE42_PXMU : roarray[16] base.u8 = [
0x85, 0x1E, 0x0E, 0xAF, 0x2B, 0xAF, 0xD8, 0x92, // Px' = 0x92D8_AF2B_AF0E_1E85
0xD5, 0x63, 0x29, 0x17, 0x6C, 0x46, 0x3E, 0x9C, // μ' = 0x9C3E_466C_1729_63D5
pri const ECMA_X86_SSE42_FOLD2 : roarray[16] base.u8 = [
0x44, 0xFA, 0x9E, 0x8A, 0x00, 0x5B, 0x09, 0x60, // fold2a' = 0x6009_5B00_8A9E_FA44 = rk20
0x51, 0xAF, 0xE1, 0x0F, 0xA3, 0x53, 0xE6, 0x3B, // fold2b' = 0x3BE6_53A3_0FE1_AF51 = rk19
]
pri const ECMA_X86_SSE42_FOLD4 : roarray[16] base.u8 = [
0xF3, 0x41, 0xD4, 0x9D, 0xBB, 0xEF, 0xE3, 0x6A, // fold4a' = 0x6AE3_EFBB_9DD4_41F3 = rk16
0xF4, 0x2D, 0x84, 0xA7, 0x54, 0x60, 0x1F, 0x08, // fold4b' = 0x081F_6054_A784_2DF4 = rk15
]
pri const ECMA_X86_SSE42_FOLD8 : roarray[16] base.u8 = [
0x00, 0x10, 0xCC, 0x4F, 0x1D, 0xD7, 0x57, 0x87, // fold8a' = 0x8757_D71D_4FCC_1000 = rk4
0x40, 0xE7, 0x3D, 0xF7, 0x2A, 0x6B, 0xD8, 0xD7, // fold8b' = 0xD7D8_6B2A_F73D_E740 = rk3
]
pri const ECMA_X86_SSE42_MUPX : roarray[16] base.u8 = [
0xD5, 0x63, 0x29, 0x17, 0x6C, 0x46, 0x3E, 0x9C, // μ' = 0x9C3E_466C_1729_63D5 = rk7
0x85, 0x1E, 0x0E, 0xAF, 0x2B, 0xAF, 0xD8, 0x92, // Px' = 0x92D8_AF2B_AF0E_1E85 = rk8
]
+29 -29
View File
@@ -224,7 +224,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
@@ -245,7 +245,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
// can change the veracity of any args.dst assertions?
this.add_history!(hist: args.dst.since(mark: mark))
yield? status
} endwhile
}
}
pri func decoder.decode_blocks?(dst: base.io_writer, src: base.io_reader) {
@@ -261,7 +261,7 @@ pri func decoder.decode_blocks?(dst: base.io_writer, src: base.io_reader) {
b0 = args.src.read_u8_as_u32?()
this.bits |= b0 << (this.n_bits & 3)
this.n_bits = (this.n_bits & 3) + 8
} endwhile
}
final = this.bits & 0x01
type = (this.bits >> 1) & 0x03
this.bits >>= 3
@@ -304,8 +304,8 @@ pri func decoder.decode_blocks?(dst: base.io_writer, src: base.io_reader) {
if this.end_of_block {
continue.outer
}
} endwhile
} endwhile.outer
}
}.outer
}
// decode_uncompressed decodes an uncompresed block as per the RFC section
@@ -339,7 +339,7 @@ pri func decoder.decode_uncompressed?(dst: base.io_writer, src: base.io_reader)
} else {
yield? base."$short read"
}
} endwhile
}
}
// init_fixed_huffman initializes this.huffs as per the RFC section 3.2.6.
@@ -350,23 +350,23 @@ pri func decoder.init_fixed_huffman!() base.status {
while i < 144 {
this.code_lengths[i] = 8
i += 1
} endwhile
}
while i < 256 {
this.code_lengths[i] = 9
i += 1
} endwhile
}
while i < 280 {
this.code_lengths[i] = 7
i += 1
} endwhile
}
while i < 288 {
this.code_lengths[i] = 8
i += 1
} endwhile
}
while i < 320 {
this.code_lengths[i] = 5
i += 1
} endwhile
}
status = this.init_huff!(which: 0, n_codes0: 0, n_codes1: 288, base_symbol: 257)
if status.is_error() {
@@ -407,7 +407,7 @@ pri func decoder.init_dynamic_huffman?(src: base.io_reader) {
b0 = args.src.read_u8_as_u32?()
bits |= b0 << n_bits
n_bits += 8
} endwhile
}
n_lit = bits.low_bits(n: 5) + 257
if n_lit > 286 {
return "#bad literal/length code count"
@@ -432,17 +432,17 @@ pri func decoder.init_dynamic_huffman?(src: base.io_reader) {
b1 = args.src.read_u8_as_u32?()
bits |= b1 << n_bits
n_bits += 8
} endwhile
}
assert i < 19 via "a < b: a < c; c <= b"(c: n_clen)
this.code_lengths[CODE_ORDER[i]] = (bits & 0x07) as base.u8
bits >>= 3
n_bits -= 3
i += 1
} endwhile
}
while i < 19 {
this.code_lengths[CODE_ORDER[i]] = 0
i += 1
} endwhile
}
status = this.init_huff!(which: 0, n_codes0: 0, n_codes1: 19, base_symbol: 0xFFF)
if status.is_error() {
return status
@@ -469,7 +469,7 @@ pri func decoder.init_dynamic_huffman?(src: base.io_reader) {
b2 = args.src.read_u8_as_u32?()
bits |= b2 << n_bits
n_bits += 8
} endwhile
}
// For H-CL, there should be no redirections and all symbols should be
// literals.
if (table_entry >> 24) <> 0x80 {
@@ -518,7 +518,7 @@ pri func decoder.init_dynamic_huffman?(src: base.io_reader) {
b3 = args.src.read_u8_as_u32?()
bits |= b3 << n_bits
n_bits += 8
} endwhile
}
rep_count += bits.low_bits(n: n_extra_bits)
bits >>= n_extra_bits
n_bits -= n_extra_bits
@@ -532,8 +532,8 @@ pri func decoder.init_dynamic_huffman?(src: base.io_reader) {
this.code_lengths[i] = rep_symbol
i += 1
rep_count -= 1
} endwhile
} endwhile
}
}
if i <> (n_lit + n_dist) {
return "#bad Huffman code length count"
@@ -626,7 +626,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
}
counts[this.code_lengths[i] & 15] += 1
i += 1
} endwhile
}
if ((counts[0] as base.u32) + args.n_codes0) == args.n_codes1 {
return "#no Huffman codes"
}
@@ -645,7 +645,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
}
remaining -= counts[i] as base.u32
i += 1
} endwhile
}
if remaining <> 0 {
// As a special case, allow a degenerate H-D Huffman table, with only
// one 1-bit code.
@@ -661,7 +661,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
return ok
}
i += 1
} endwhile
}
}
return "#bad Huffman code (under-subscribed)"
}
@@ -690,7 +690,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
// bounds checking can handle it.
n_symbols = n_symbols + count
i += 1
} endwhile
}
if n_symbols > 288 {
return "#internal error: inconsistent Huffman decoder state"
}
@@ -730,7 +730,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
offsets[this.code_lengths[i] & 15] += 1
}
i += 1
} endwhile
}
// Calculate min_cl and max_cl.
//
@@ -748,7 +748,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
return "#bad Huffman minimum code length"
}
min_cl += 1
} endwhile
}
max_cl = 15
while true,
inv n_symbols <= 288,
@@ -760,7 +760,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
return "#no Huffman codes"
}
max_cl -= 1
} endwhile
}
if max_cl <= 9 {
this.n_huffs_bits[args.which] = max_cl
} else {
@@ -848,7 +848,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
}
remaining <<= 1
j += 1
} endwhile
}
if (j <= 9) or (15 < j) {
return "#internal error: inconsistent Huffman decoder state"
}
@@ -909,7 +909,7 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
}
assert (top + ((high_bits | reversed_key) & 511)) < 1024 via "a < b: a < c; c <= b"(c: HUFFS_TABLE_SIZE)
this.huffs[args.which][top + ((high_bits | reversed_key) & 511)] = value
} endwhile
}
i += 1
if i >= n_symbols {
@@ -920,6 +920,6 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
if code >= (1 << 15) {
return "#internal error: inconsistent Huffman decoder state"
}
} endwhile
}
return ok
}
+3 -3
View File
@@ -266,8 +266,8 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
up_to: length, distance: (dist_minus_1 + 1))
}
break
} endwhile
} endwhile.loop
}
}.loop
// Ensure n_bits < 8 by rewindng args.src, if we loaded too many of its
// bytes into the bits variable.
@@ -291,7 +291,7 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
} else {
return "#internal error: inconsistent I/O"
}
} endwhile
}
this.bits = (bits & (((1 as base.u64) << n_bits) - 1)) as base.u32
this.n_bits = n_bits
+3 -3
View File
@@ -366,8 +366,8 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
up_to: length, distance: (dist_minus_1 + 1))
}
break
} endwhile
} endwhile.loop
}
}.loop
// Ensure n_bits < 8 by rewindng args.src, if we loaded too many of its
// bytes into the bits variable.
@@ -388,7 +388,7 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
} else {
return "#internal error: inconsistent I/O"
}
} endwhile
}
this.bits = bits & (((1 as base.u32) << n_bits) - 1)
this.n_bits = n_bits
+3 -3
View File
@@ -265,8 +265,8 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
up_to: length, distance: (dist_minus_1 + 1))
}
break
} endwhile
} endwhile.loop
}
}.loop
// Ensure n_bits < 8 by rewindng args.src, if we loaded too many of its
// bytes into the bits variable.
@@ -290,7 +290,7 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
} else {
return "#internal error: inconsistent I/O"
}
} endwhile
}
this.bits = (bits & (((1 as base.u64) << n_bits) - 1)) as base.u32
this.n_bits = n_bits
+8 -8
View File
@@ -58,7 +58,7 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
b0 = args.src.read_u8_as_u32?()
bits |= b0 << n_bits
n_bits += 8
} endwhile
}
if (table_entry >> 31) <> 0 {
// Literal.
@@ -86,7 +86,7 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
b1 = args.src.read_u8_as_u32?()
bits |= b1 << n_bits
n_bits += 8
} endwhile
}
if (table_entry >> 31) <> 0 {
// Literal.
@@ -126,7 +126,7 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
b2 = args.src.read_u8_as_u32?()
bits |= b2 << n_bits
n_bits += 8
} endwhile
}
// The "+ 253" is the same as "- 3", after the "& 0xFF", but the
// plus form won't require an underflow check.
length = ((length + 253 + bits.low_bits(n: table_entry_n_bits)) & 0xFF) + 3
@@ -147,7 +147,7 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
b3 = args.src.read_u8_as_u32?()
bits |= b3 << n_bits
n_bits += 8
} endwhile
}
// Check for a redirect.
if (table_entry >> 28) == 1 {
redir_top = (table_entry >> 8) & 0xFFFF
@@ -164,7 +164,7 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
b4 = args.src.read_u8_as_u32?()
bits |= b4 << n_bits
n_bits += 8
} endwhile
}
}
// For H-D, all symbols should be base_number + extra_bits.
@@ -191,7 +191,7 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
b5 = args.src.read_u8_as_u32?()
bits |= b5 << n_bits
n_bits += 8
} endwhile
}
dist_minus_1 = (dist_minus_1 + bits.low_bits(n: table_entry_n_bits)) & 0x7FFF
bits >>= table_entry_n_bits
n_bits -= table_entry_n_bits
@@ -243,8 +243,8 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
}
length -= n_copied
yield? base."$short write"
} endwhile.inner
} endwhile.loop
}.inner
}.loop
// TODO: "assert n_bits < 8"? What about (bits >> n_bits)?
+23 -23
View File
@@ -141,7 +141,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -205,7 +205,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
@@ -249,7 +249,7 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
}
break
} endwhile
}
chunk_length = args.src.peek_u8_as_u64()
if chunk_length <= 0 {
@@ -278,7 +278,7 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
}
yield? base."$even more information"
} endwhile
}
if args.minfo <> nullptr {
args.minfo.set!(
@@ -363,7 +363,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -411,7 +411,7 @@ pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.
post args.src.length() > 0,
{
yield? base."$short read"
} endwhile
}
flags = args.src.peek_u8()
if (flags & 0x80) <> 0 {
background_color = this.black_color_u32_argb_premul
@@ -477,7 +477,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return "#truncated input"
}
yield? status
} endwhile
}
}
// TODO: honor args.opts.
@@ -548,7 +548,7 @@ pri func decoder.decode_up_to_id_part1?(src: base.io_reader) {
this.call_sequence = 0x60
break
}
} endwhile
}
}
// decode_header reads either "GIF87a" or "GIF89a".
@@ -597,7 +597,7 @@ pri func decoder.decode_lsd?(src: base.io_reader) {
this.palettes[0][(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
this.palettes[0][(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
i += 1
} endwhile
}
if this.quirks[QUIRK_HONOR_BACKGROUND_COLOR - QUIRKS_BASE] {
if (background_color_index <> 0) and
@@ -626,7 +626,7 @@ pri func decoder.decode_lsd?(src: base.io_reader) {
this.palettes[0][(4 * i) + 2] = 0x00
this.palettes[0][(4 * i) + 3] = 0xFF
i += 1
} endwhile
}
}
// decode_extension reads an extension. The Extension Introducer byte has
@@ -662,7 +662,7 @@ pri func decoder.skip_blocks?(src: base.io_reader) {
return ok
}
args.src.skip_u32?(n: block_size as base.u32)
} endwhile
}
}
// decode_ae reads an Application Extension.
@@ -706,7 +706,7 @@ pri func decoder.decode_ae?(src: base.io_reader) {
is_iccp = is_iccp and (c8 == ICCRGBG1012[block_size])
is_xmp = is_xmp and (c8 == XMPDATAXMP[block_size])
block_size += 1
} endwhile
}
if is_animexts or is_netscape {
// Those 11 bytes should be followed by 0x03, 0x01 and then the loop
@@ -755,7 +755,7 @@ pri func decoder.decode_ae?(src: base.io_reader) {
}
break.goto_done
}} endwhile.goto_done
}}.goto_done
this.skip_blocks?(src: args.src)
}
@@ -866,7 +866,7 @@ pri func decoder.decode_id_part1?(dst: ptr base.pixel_buffer, src: base.io_reade
this.palettes[1][(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
this.palettes[1][(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
i += 1
} endwhile
}
// Set the remaining palette entries to opaque black.
while i < 256 {
this.palettes[1][(4 * i) + 0] = 0x00
@@ -874,7 +874,7 @@ pri func decoder.decode_id_part1?(dst: ptr base.pixel_buffer, src: base.io_reade
this.palettes[1][(4 * i) + 2] = 0x00
this.palettes[1][(4 * i) + 3] = 0xFF
i += 1
} endwhile
}
} else if this.quirks[QUIRK_REJECT_EMPTY_PALETTE - QUIRKS_BASE] and (not this.has_global_palette) {
return "#bad palette"
} else if this.gc_has_transparent_index {
@@ -953,7 +953,7 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade
}
while args.src.length() == 0 {
yield? base."$short read"
} endwhile
}
if this.compressed_ri == this.compressed_wi {
this.compressed_ri = 0
@@ -978,7 +978,7 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade
}
block_size = args.src.peek_u8_as_u64()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
} endwhile
}
while.inner true {
if (this.compressed_ri > this.compressed_wi) or (this.compressed_wi > 4096) {
@@ -1032,8 +1032,8 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade
return "#bad LZW code"
}
return "#internal error: inconsistent I/O"
} endwhile.inner
} endwhile.outer
}.inner
}.outer
this.compressed_ri = 0
this.compressed_wi = 0
@@ -1138,7 +1138,7 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: roslice b
replicate_dst = tab.row_u32(y: replicate_y0)
replicate_dst.copy_from_slice!(s: replicate_src)
replicate_y0 += 1
} endwhile
}
this.dirty_max_excl_y = this.dirty_max_excl_y.max(no_less_than: replicate_y1)
}
@@ -1146,7 +1146,7 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: roslice b
while (this.interlace > 0) and (this.dst_y >= this.frame_rect_y1) {
this.interlace -= 1
this.dst_y = this.frame_rect_y0 ~sat+ INTERLACE_START[this.interlace]
} endwhile
}
continue
}
@@ -1172,7 +1172,7 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: roslice b
while (this.interlace > 0) and (this.dst_y >= this.frame_rect_y1) {
this.interlace -= 1
this.dst_y = this.frame_rect_y0 ~sat+ INTERLACE_START[this.interlace]
} endwhile
}
continue
}
@@ -1180,6 +1180,6 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: roslice b
return "#internal error: inconsistent I/O"
}
break
} endwhile
}
return ok
}
+4 -4
View File
@@ -41,7 +41,7 @@ pri func decoder.lzw_init!() {
this.lzw_lm1s[i] = 0
this.lzw_suffixes[i][0] = i as base.u8
i += 1
} endwhile
}
}
pri func decoder.lzw_read_from!(src: base.io_reader) {
@@ -194,7 +194,7 @@ pri func decoder.lzw_read_from!(src: base.io_reader) {
// in practice, but is necessary for the overflow checker.
o = (o ~mod- 8) & 8191
c = this.lzw_prefixes[c] as base.u32
} endwhile
}
first_byte = this.lzw_suffixes[c][0]
if code == save_code {
@@ -235,7 +235,7 @@ pri func decoder.lzw_read_from!(src: base.io_reader) {
this.lzw_read_from_return_value = 1
break
}
} endwhile
}
// Rewind args.src, if we're not in "$short read" and we've read too many
// bits.
@@ -248,7 +248,7 @@ pri func decoder.lzw_read_from!(src: base.io_reader) {
this.lzw_read_from_return_value = 5
break
}
} endwhile
}
}
this.lzw_save_code = save_code
+4 -4
View File
@@ -65,7 +65,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
@@ -113,7 +113,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
if c8 == 0 {
break
}
} endwhile
}
}
// Handle FCOMMENT.
@@ -123,7 +123,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
if c8 == 0 {
break
}
} endwhile
}
}
// Handle FHCRC.
@@ -148,7 +148,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
checksum_want = args.src.read_u32le?()
decoded_length_want = args.src.read_u32le?()
if (not this.ignore_checksum) and
+1 -1
View File
@@ -628,7 +628,7 @@ pri func decoder.decode_idct_x86_avx2!(dst_buffer: slice base.u8, dst_stride: ba
// intermediatedh = i16x16 [in.d0 .. in.d3 in.d4 .. in.d7 in.h0 .. in.h4 in.h5 .. in.h7]
break.goto_do_second_pass
}} endwhile.goto_do_second_pass
}}.goto_do_second_pass
// ----
+59 -59
View File
@@ -342,7 +342,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -373,7 +373,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
}
// Getting here is invalid according to the JPEG spec, but libjpeg
// treats this as a warning (JWRN_EXTRANEOUS_DATA), not an error.
} endwhile
}
while true {
c8 = args.src.read_u8?()
if c8 <> 0xFF {
@@ -382,7 +382,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
}
// Section B.1.1.2: "Any marker may optionally be preceded by any
// number of [0xFF] fill bytes".
} endwhile
}
if marker == 0x00 {
// Ignore byte stuffing.
@@ -472,7 +472,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
args.src.skip_u32?(n: this.payload_length)
this.payload_length = 0
} endwhile
}
choose decode_idct = [
// TODO: decode_idct_arm_neon,
@@ -522,7 +522,7 @@ pri func decoder.decode_dqt?(src: base.io_reader) {
while i < 64 {
i += 1
this.quant_tables[q][UNZIG[i]] = args.src.read_u8_as_u16?()
} endwhile
}
this.seen_dqt[q] = true
if this.sof_marker == 0 {
@@ -530,10 +530,10 @@ pri func decoder.decode_dqt?(src: base.io_reader) {
while i < 64 {
this.saved_quant_tables[q][i] = this.quant_tables[q][i]
i += 1
} endwhile
}
this.saved_seen_dqt[q] = true
}
} endwhile
}
}
pri func decoder.decode_dri?(src: base.io_reader) {
@@ -596,7 +596,7 @@ pri func decoder.decode_appn?(src: base.io_reader, marker: base.u8) {
}
}
break.goto_done
}} endwhile.goto_done
}}.goto_done
args.src.skip_u32?(n: this.payload_length)
this.payload_length = 0
@@ -692,10 +692,10 @@ pri func decoder.decode_sof?(src: base.io_reader) {
return "#bad SOF marker"
}
j += 1
} endwhile
}
i += 1
} endwhile
}
if this.num_components == 1 {
// The first (and only) component's H and V factors are effectively
@@ -721,7 +721,7 @@ pri func decoder.decode_sof?(src: base.io_reader) {
has_v24 = has_v24 or (this.components_v[i] == 2) or (this.components_v[i] == 4)
has_v3 = has_v3 or (this.components_v[i] == 3)
i += 1
} endwhile
}
if (has_h24 and has_h3) or (has_v24 and has_v3) {
return "#unsupported fractional sampling"
}
@@ -786,9 +786,9 @@ pri func decoder.decode_sof?(src: base.io_reader) {
{
this.block_smoothing_lowest_scan_al[i][j] = 16
j += 1
} endwhile
}
i += 1
} endwhile
}
}
this.components_workbuf_offsets[0] = 0
@@ -829,7 +829,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -896,7 +896,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
}
yield? ddf_status
} endwhile
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -954,7 +954,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
// Getting here is invalid according to the JPEG spec, but libjpeg
// treats this as a warning (JWRN_EXTRANEOUS_DATA), not an error.
} endwhile
}
while true {
c8 = args.src.read_u8?()
if c8 <> 0xFF {
@@ -963,7 +963,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
// Section B.1.1.2: "Any marker may optionally be preceded by any
// number of [0xFF] fill bytes".
} endwhile
}
if marker == 0x00 {
// Ignore byte stuffing.
@@ -1038,7 +1038,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
args.src.skip_u32?(n: this.payload_length)
this.payload_length = 0
} endwhile
}
this.call_sequence = 0x60
}
@@ -1080,14 +1080,14 @@ pri func decoder.decode_dht?(src: base.io_reader) {
while i < 16 {
this.dht_temp_counts[i] = args.src.read_u8?()
i += 1
} endwhile
}
working_total_count = 0
i = 0
while i < 16 {
working_total_count =
(working_total_count + (this.dht_temp_counts[i] as base.u32)) & 0xFFFF
i += 1
} endwhile
}
if (working_total_count <= 0) or (256 < working_total_count) {
return "#bad DHT marker"
}
@@ -1103,11 +1103,11 @@ pri func decoder.decode_dht?(src: base.io_reader) {
assert i < 256 via "a < b: a < c; c <= b"(c: total_count)
this.huff_tables_symbols[tc4_th][i] = args.src.read_u8?()
i += 1
} endwhile
}
while i < 256 {
this.huff_tables_symbols[tc4_th][i] = 0
i += 1
} endwhile
}
// For tc == 0 (DC, not AC tables), the symbols must not exceed 15 (for
// lossy JPEG) or 16 (for lossless JPEG). We only support lossy.
@@ -1119,7 +1119,7 @@ pri func decoder.decode_dht?(src: base.io_reader) {
return "#bad DHT marker"
}
i += 1
} endwhile
}
}
failed = this.calculate_huff_tables!(tc4_th: tc4_th, total_count: total_count)
@@ -1128,7 +1128,7 @@ pri func decoder.decode_dht?(src: base.io_reader) {
}
this.seen_dht[tc4_th] = true
} endwhile
}
}
pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: base.u32[..= 256]) base.bool {
@@ -1155,12 +1155,12 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas
{
k = 0
bit_length_minus_one = (bit_length_minus_one + 1) & 15
} endwhile
}
assert k < 255 via "a < b: a < c; c <= b"(c: this.dht_temp_counts[bit_length_minus_one])
k += 1
this.dht_temp_bit_lengths[i] = (bit_length_minus_one + 1) as base.u8
i += 1
} endwhile
}
// Calculate dht_temp_bit_strings.
bit_length = 0
@@ -1176,7 +1176,7 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas
}
bit_length += 1
bit_string ~mod<<= 1
} endwhile
}
this.dht_temp_bit_strings[i] = (bit_string & 0xFFFF) as base.u16
bit_string ~mod+= 1
@@ -1188,7 +1188,7 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas
}
i += 1
} endwhile
}
// Calculate huff_tables_slow[args.tc4_th].
k = 0
@@ -1208,14 +1208,14 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas
if bit_length_minus_one == 0 {
break
}
} endwhile
}
// Calculate huff_tables_fast[args.tc4_th].
i = 0
while i < 256 {
this.huff_tables_fast[args.tc4_th][i] = 0xFFFF
i += 1
} endwhile
}
j = 0
bit_length_minus_one = 0
while bit_length_minus_one < 8 {
@@ -1236,13 +1236,13 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas
this.huff_tables_fast[args.tc4_th][prefix] = fast
prefix ~mod+= 1
reps -= 1
} endwhile
}
k += 1
j ~mod+= 1
} endwhile
}
bit_length_minus_one += 1
} endwhile
}
return false
}
@@ -1321,8 +1321,8 @@ pri func decoder.decode_sos?(src: base.io_reader, workbuf: slice base.u8) {
break.fill_bitstream
}
yield? base."$short read"
} endwhile.fill_bitstream
} endwhile.decode_mcu
}.fill_bitstream
}.decode_mcu
if this.sof_marker >= 0xC2 {
this.save_mcu_blocks!(mx: mx, my: my, workbuf: args.workbuf)
@@ -1350,9 +1350,9 @@ pri func decoder.decode_sos?(src: base.io_reader, workbuf: slice base.u8) {
}
mx += 1
} endwhile
}
my += 1
} endwhile
}
this.scan_count ~sat+= 1
}
@@ -1399,7 +1399,7 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
break
}
j += 1
} endwhile
}
// Section B.2.3: "the value of C_sj shall be different from the values
// of C_s1 to C_sj–1".
@@ -1412,7 +1412,7 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
return "#bad SOS marker"
}
j += 1
} endwhile
}
c8 = args.src.read_u8?()
if ((c8 >> 4) > 3) or ((c8 & 0x0F) > 3) {
@@ -1429,7 +1429,7 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
}
i += 1
} endwhile
}
if this.sof_marker < 0xC2 {
// At this point, for sequential (not progressive) JPEGs, we should
@@ -1506,10 +1506,10 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
assert j <= 9 via "a <= b: a <= c; c <= b"(c: j_max_incl)
this.block_smoothing_lowest_scan_al[this.scan_comps_cselector[i]][j] = this.scan_al
j += 1
} endwhile
}
i += 1
} endwhile
}
if this.scan_num_components == 1 {
this.calculate_single_component_scan_fields!()
@@ -1607,10 +1607,10 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool {
}
}
hv -= 1
} endwhile
}
i += 1
} endwhile
}
if total_hv > 10 {
return true
}
@@ -1629,7 +1629,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool {
this.mcu_blocks_dc_hselector[b] = 0 | this.scan_comps_td[ssel]
this.mcu_blocks_ac_hselector[b] = 4 | this.scan_comps_ta[ssel]
b += 1
} endwhile
}
this.scan_width_in_mcus = this.width_in_mcus
this.scan_height_in_mcus = this.height_in_mcus
@@ -1675,7 +1675,7 @@ pri func decoder.fill_bitstream!(src: base.io_reader) {
wi += 1
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
}
} endwhile
}
// If we hit a "\xFF\x??" marker then pad the bitstream. In this method
// invocation, insert up to 264 bytes of implicit zeroes. Repeated calls to
@@ -1738,7 +1738,7 @@ pri func decoder.load_mcu_blocks!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2
this.mcu_blocks[b .. (b + 1)].bulk_load_host_endian!(src: args.workbuf[offset ..])
}
b += 1
} endwhile
}
}
pri func decoder.save_mcu_blocks!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2000], workbuf: slice base.u8) {
@@ -1768,7 +1768,7 @@ pri func decoder.save_mcu_blocks!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2
this.mcu_blocks[b .. (b + 1)].bulk_save_host_endian!(dst: args.workbuf[offset ..])
}
b += 1
} endwhile
}
}
pri func decoder.skip_past_the_next_restart_marker?(src: base.io_reader) {
@@ -1810,7 +1810,7 @@ pri func decoder.skip_past_the_next_restart_marker?(src: base.io_reader) {
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
break
}
} endwhile
}
this.next_restart_marker = (this.next_restart_marker ~mod+ 1) & 7
}
@@ -1846,7 +1846,7 @@ pri func decoder.apply_progressive_idct!(workbuf: slice base.u8) {
block_smoothing_applicable = false
}
csel += 1
} endwhile
}
csel = 0
while csel < this.num_components {
@@ -1906,12 +1906,12 @@ pri func decoder.apply_progressive_idct!(workbuf: slice base.u8) {
}
mx += 1
} endwhile
}
my += 1
} endwhile
}
csel += 1
} endwhile
}
this.mcu_blocks[.. 1].bulk_load_host_endian!(src: stashed_mcu_blocks_0[..])
}
@@ -1955,7 +1955,7 @@ pri func decoder.swizzle_gray!(dst: ptr base.pixel_buffer, workbuf: slice base.u
args.workbuf = this.util.empty_slice_u8()
}
y += 1
} endwhile
}
return ok
}
@@ -2073,9 +2073,9 @@ pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.sta
{
this.quant_tables[i][j] = this.saved_quant_tables[i][j]
j += 1
} endwhile
}
i += 1
} endwhile
}
i = 0
while i < 4 {
@@ -2085,15 +2085,15 @@ pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.sta
{
this.block_smoothing_lowest_scan_al[i][j] = 16
j += 1
} endwhile
}
i += 1
} endwhile
}
i = 0
while i < 8 {
this.seen_dht[i] = false
i += 1
} endwhile
}
return ok
}
+2 -2
View File
@@ -92,9 +92,9 @@ pri func decoder.load_mcu_blocks_for_single_component_smooth!(mx: base.u32[..= 0
}
dx += 1
} endwhile
}
dy += 1
} endwhile
}
q = this.components_tq[args.csel]
q_00 = this.quant_tables[q][0x00] as base.u32
+6 -6
View File
@@ -115,7 +115,7 @@ pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], m
dc_extend = EXTEND[dc_symbol]
break
}
} endwhile
}
}
// Process the dc_value in the next dc_symbol (up to 15) bits.
@@ -134,7 +134,7 @@ pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], m
this.mcu_zig_index = 1
break.dc_component
} endwhile.dc_component
}.dc_component
// Ensure that we have enough bits for this iteration of the
// while.block loop body. Worst case, there are 64 components and
@@ -234,7 +234,7 @@ pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], m
ac_symbol = 0
break
}
} endwhile
}
}
// Split the 8-bit ac_symbol into two 4-bit halves, per section
@@ -256,7 +256,7 @@ pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], m
} else if ac_rrrr < 15 {
break.ac_components
}
} endwhile.ac_components
}.ac_components
assert this.mcu_current_block < 10
mcb = this.mcu_current_block
@@ -278,11 +278,11 @@ pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], m
q: this.components_tq[csel] as base.u32)
}
} endwhile.block
}.block
this.mcu_current_block = 0
break.goto_done
}} endwhile.goto_done
}}.goto_done
pos = (r.position() & 0xFFFF_FFFF) as base.u32
if pos > this.bitstream_wi {
@@ -147,7 +147,7 @@ pri func decoder.decode_mcu_progressive_ac_high_bits!(workbuf: slice base.u8, mx
ac_symbol = 0
break
}
} endwhile
}
}
// Split the 8-bit ac_symbol into two 4-bit halves, per section
@@ -176,13 +176,13 @@ pri func decoder.decode_mcu_progressive_ac_high_bits!(workbuf: slice base.u8, mx
}
break.ac_components
}
} endwhile.ac_components
}.ac_components
break.block
} endwhile.block
}.block
break.goto_done
}} endwhile.goto_done
}}.goto_done
pos = (r.position() & 0xFFFF_FFFF) as base.u32
if pos > this.bitstream_wi {
@@ -105,7 +105,7 @@ pri func decoder.decode_mcu_progressive_ac_low_bit!(workbuf: slice base.u8, mx:
ac_symbol = 0
break
}
} endwhile
}
}
// Split the 8-bit ac_symbol into two 4-bit halves, per section
@@ -169,7 +169,7 @@ pri func decoder.decode_mcu_progressive_ac_low_bit!(workbuf: slice base.u8, mx:
}
assert this.mcu_zig_index < 63 via "a < b: a < c; c <= b"(c: (this.scan_se as base.u32))
this.mcu_zig_index += 1
} endwhile.refine_non_zeroes
}.refine_non_zeroes
if ac_value <> 0 {
this.mcu_blocks[0][UNZIG[1 + this.mcu_zig_index]] = ac_value
@@ -180,10 +180,10 @@ pri func decoder.decode_mcu_progressive_ac_low_bit!(workbuf: slice base.u8, mx:
}
assert this.mcu_zig_index < 63 via "a < b: a < c; c <= b"(c: (this.scan_se as base.u32))
this.mcu_zig_index += 1
} endwhile.ac_components
}.ac_components
break.block
}} endwhile.goto_do_eob
}}.goto_do_eob
if this.eob_run <= 0 {
ret = 2 // Internal error.
@@ -222,15 +222,15 @@ pri func decoder.decode_mcu_progressive_ac_low_bit!(workbuf: slice base.u8, mx:
}
assert this.mcu_zig_index < 63 via "a < b: a < c; c <= b"(c: (this.scan_se as base.u32))
this.mcu_zig_index += 1
} endwhile.refine_eob_non_zeroes
}.refine_eob_non_zeroes
this.eob_run -= 1
break.block
} endwhile.block
}.block
break.goto_done
}} endwhile.goto_done
}}.goto_done
pos = (r.position() & 0xFFFF_FFFF) as base.u32
if pos > this.bitstream_wi {
@@ -95,7 +95,7 @@ pri func decoder.decode_mcu_progressive_dc_high_bits!(workbuf: slice base.u8, mx
dc_extend = EXTEND[dc_symbol]
break
}
} endwhile
}
}
// Process the dc_value in the next dc_symbol (up to 15) bits.
@@ -113,15 +113,15 @@ pri func decoder.decode_mcu_progressive_dc_high_bits!(workbuf: slice base.u8, mx
this.mcu_previous_dc_values[csel] ~mod<< this.scan_al
break.dc_component
} endwhile.dc_component
}.dc_component
assert this.mcu_current_block < 10
this.mcu_current_block += 1
} endwhile.block
}.block
this.mcu_current_block = 0
break.goto_done
}} endwhile.goto_done
}}.goto_done
pos = (r.position() & 0xFFFF_FFFF) as base.u32
if pos > this.bitstream_wi {
@@ -63,15 +63,15 @@ pri func decoder.decode_mcu_progressive_dc_low_bit!(workbuf: slice base.u8, mx:
n_bits ~mod-= 1
break.dc_component
} endwhile.dc_component
}.dc_component
assert this.mcu_current_block < 10
this.mcu_current_block += 1
} endwhile.block
}.block
this.mcu_current_block = 0
break.goto_done
}} endwhile.goto_done
}}.goto_done
pos = (r.position() & 0xFFFF_FFFF) as base.u32
if pos > this.bitstream_wi {
+23 -23
View File
@@ -199,7 +199,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
continue.outer
}
whitespace_length += 1
} endwhile.ws
}.ws
// Emit whitespace.
if whitespace_length > 0 {
@@ -296,7 +296,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
continue.string_loop_outer
}
string_length += 4
} endwhile
}
c8 = args.src.peek_u8()
char = LUT_CHARS[c8]
@@ -826,8 +826,8 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
continue.string_loop_outer
}
return "#bad UTF-8"
} endwhile.string_loop_inner
} endwhile.string_loop_outer
}.string_loop_inner
}.string_loop_outer
// Emit the trailing '"'.
while true {
@@ -853,7 +853,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
continued: 0,
length: 1)
break
} endwhile
}
// As above, expect must have contained EXPECT_STRING. If it didn't
// also contain EXPECT_NUMBER (excluding EXPECT_COMMENT) then we
@@ -936,7 +936,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
} else {
return "#internal error: inconsistent I/O"
}
} endwhile
}
if number_status == 1 {
if this.quirks[QUIRK_ALLOW_INF_NAN_NUMBERS - QUIRKS_BASE] {
@@ -952,9 +952,9 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
post args.dst.length() > 0,
{
yield? base."$short write"
} endwhile
}
}
} endwhile
}
break.goto_parsed_a_leaf_value
// -------- END parse numbers.
@@ -1185,7 +1185,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
}
return "#bad input"
}} endwhile.goto_parsed_a_leaf_value
}}.goto_parsed_a_leaf_value
// We've just parsed a leaf (non-container) value: literal (null,
// false, true), number or string.
@@ -1193,7 +1193,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
break.outer
}
expect = expect_after_value
} endwhile.outer
}.outer
if this.quirks[QUIRK_ALLOW_TRAILING_FILLER - QUIRKS_BASE] or
this.quirks[QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF - QUIRKS_BASE] {
@@ -1335,7 +1335,7 @@ pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
n = this.decode_digits!(src: args.src, n: n)
break.goto_done
}} endwhile.goto_done
}}.goto_done
return n | floating_point
}
@@ -1371,7 +1371,7 @@ pri func decoder.decode_digits!(src: base.io_reader, n: base.u32[..= 99]) base.u
}
n += 1
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
} endwhile
}
if n == args.n {
n |= 0x100
}
@@ -1424,7 +1424,7 @@ pri func decoder.decode_leading?(dst: base.token_writer, src: base.io_reader) {
}
}
break
} endwhile
}
}
pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
@@ -1446,7 +1446,7 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
return ok
}
yield? base."$short read"
} endwhile
}
c16 = args.src.peek_u16le()
if (c16 == '/*'le) and this.quirks[QUIRK_ALLOW_COMMENT_BLOCK - QUIRKS_BASE] {
@@ -1473,7 +1473,7 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
post args.dst.length() > 0,
{
yield? base."$short write"
} endwhile
}
length = 0
continue.comment_block
}
@@ -1503,12 +1503,12 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
post args.dst.length() > 0,
{
yield? base."$short write"
} endwhile
}
length = 0
continue.comment_block
}
length += 1
} endwhile.comment_block
}.comment_block
} else if (c16 == '//'le) and this.quirks[QUIRK_ALLOW_COMMENT_LINE - QUIRKS_BASE] {
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
@@ -1540,7 +1540,7 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
post args.dst.length() > 0,
{
yield? base."$short write"
} endwhile
}
length = 0
continue.comment_line
}
@@ -1569,12 +1569,12 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
post args.dst.length() > 0,
{
yield? base."$short write"
} endwhile
}
length = 0
continue.comment_line
}
length += 1
} endwhile.comment_line
}.comment_line
}
}
@@ -1686,7 +1686,7 @@ pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
}
return "#bad input"
} endwhile
}
}
pri func decoder.decode_trailer?(dst: base.token_writer, src: base.io_reader) {
@@ -1747,6 +1747,6 @@ pri func decoder.decode_trailer?(dst: base.token_writer, src: base.io_reader) {
continue.outer
}
whitespace_length += 1
} endwhile.inner
} endwhile.outer
}.inner
}.outer
}
+4 -4
View File
@@ -68,7 +68,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
@@ -129,7 +129,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
// Check the checksum.
checksum_want = args.src.read_u32le?()
@@ -164,12 +164,12 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break.outer
}
yield? base."$short read"
} endwhile
}
c32 = args.src.peek_u32le()
if c32 <> 'LZIP'le {
break.outer
}
this.crc32.reset!()
this.lzma.reset!()
} endwhile.outer
}.outer
}
+7
View File
@@ -329,3 +329,10 @@ mask or, equivalently, a subtraction):
That's a "forward" binary tree, where the bits occur in MSB to LSB order. A
"reverse" binary tree uses the opposite order.
## Further Reading
A longer discussion of LZMA compression, including range coding and the XZ
container format, is at [XZ/LZMA Worked
Example](https://nigeltao.github.io/blog/2024/xz-lzma-part-1-range-coding.html).
+16 -16
View File
@@ -168,7 +168,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
assert args.dst.length() >= 282
@@ -269,7 +269,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len_state = CLAMP_NO_MORE_THAN_3[tree_node & 0x07] as base.u32
len = (tree_node & 0x07) + 2
assert len >= 1
@@ -338,7 +338,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0x07) + 10
assert len >= 1
len_state = 3
@@ -389,12 +389,12 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0xFF) + 18
assert len >= 1
len_state = 3
break.goto_have_len
}} endwhile.goto_have_len
}}.goto_have_len
// AlgOve23 slot = decodeSlot(min(len-2, 3))
slot = 1
@@ -425,7 +425,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
slot &= 0x3F
// AlgOve24 distBiasedBy1 = decodeDistBiasedBy1(slot)
@@ -474,7 +474,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
rep ~mod+= dist_extra_bits
} else {
@@ -511,7 +511,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
if num_extra_bits <= 4 {
break
}
} endwhile
}
dist_extra_bits ~mod<<= 4
// Read 4 "zzzz" bits.
@@ -551,7 +551,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
if num_extra_bits <= 0 {
break
}
} endwhile
}
rep ~mod+= dist_extra_bits
}
@@ -789,7 +789,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0x07) + 2
assert len >= 1
state = STATE_TRANSITION_LONGREP[state] as base.u32
@@ -858,7 +858,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0x07) + 10
assert len >= 1
state = STATE_TRANSITION_LONGREP[state] as base.u32
@@ -909,15 +909,15 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0xFF) + 18
assert len >= 1
state = STATE_TRANSITION_LONGREP[state] as base.u32
break.goto_after_decode_len
}} endwhile.goto_after_decode_len
}}.goto_after_decode_len
break.goto_do_the_lz_copy
}} endwhile.goto_do_the_lz_copy
}}.goto_do_the_lz_copy
assert args.dst.length() >= 282
// AlgOve90 labelDoTheLZCopy:
@@ -945,7 +945,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
inv dist >= 1,
{
wb_index ~mod+= this.dict_size as base.u64
} endwhile
}
if wb_index >= args.workbuf.length() {
return "#internal error: inconsistent dictionary state"
}
@@ -1008,7 +1008,7 @@ pri func decoder.decode_bitstream_fast!(dst: base.io_writer, src: base.io_reader
match_byte = match_cusp >> 8
prev_byte = (match_cusp & 0xFF) as base.u8
}
} endwhile.outer
}.outer
this.stashed_bytes[0] = prev_byte
this.stashed_bytes[1] = (match_byte & 0xFF) as base.u8
+18 -18
View File
@@ -187,7 +187,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile.high_state
}.high_state
} else {
tree_node = 1
@@ -211,7 +211,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile.low_state
}.low_state
}
// AlgOve03 emitLiteral(literal)
@@ -294,7 +294,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len_state = CLAMP_NO_MORE_THAN_3[tree_node & 0x07] as base.u32
len = (tree_node & 0x07) + 2
assert len >= 1
@@ -349,7 +349,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0x07) + 10
assert len >= 1
len_state = 3
@@ -390,12 +390,12 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0xFF) + 18
assert len >= 1
len_state = 3
break.goto_have_len
}} endwhile.goto_have_len
}}.goto_have_len
// AlgOve23 slot = decodeSlot(min(len-2, 3))
slot = 1
@@ -421,7 +421,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
slot &= 0x3F
// AlgOve24 distBiasedBy1 = decodeDistBiasedBy1(slot)
@@ -465,7 +465,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
rep ~mod+= dist_extra_bits
} else {
@@ -497,7 +497,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
if num_extra_bits <= 4 {
break
}
} endwhile
}
dist_extra_bits ~mod<<= 4
// Read 4 "zzzz" bits.
@@ -532,7 +532,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
if num_extra_bits <= 0 {
break
}
} endwhile
}
rep ~mod+= dist_extra_bits
}
@@ -741,7 +741,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0x07) + 2
assert len >= 1
state = STATE_TRANSITION_LONGREP[state] as base.u32
@@ -796,7 +796,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0x07) + 10
assert len >= 1
state = STATE_TRANSITION_LONGREP[state] as base.u32
@@ -837,15 +837,15 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
bits = (bits ~mod<< 8) | (c8 as base.u32)
range ~mod<<= 8
}
} endwhile
}
len = (tree_node & 0xFF) + 18
assert len >= 1
state = STATE_TRANSITION_LONGREP[state] as base.u32
break.goto_after_decode_len
}} endwhile.goto_after_decode_len
}}.goto_after_decode_len
break.goto_do_the_lz_copy
}} endwhile.goto_do_the_lz_copy
}}.goto_do_the_lz_copy
// AlgOve90 labelDoTheLZCopy:
// AlgOve94 emitCopy(len, mrud[0])
@@ -866,7 +866,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
post 274 <= args.dst.length(),
{
yield? base."$short write"
} endwhile
}
assert (len as base.u64) <= args.dst.length() via "a <= b: a <= c; c <= b"(c: 274)
// Copy from the args.workbuf history, if necessary.
@@ -880,7 +880,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
inv dist >= 1,
{
wb_index ~mod+= this.dict_size as base.u64
} endwhile
}
if wb_index >= args.workbuf.length() {
return "#internal error: inconsistent dictionary state"
}
@@ -934,7 +934,7 @@ pri func decoder.decode_bitstream_slow?(dst: base.io_writer, src: base.io_reader
up_to: len, distance: dist)
match_byte = match_cusp >> 8
prev_byte = (match_cusp & 0xFF) as base.u8
} endwhile.outer
}.outer
this.stashed_bytes[0] = prev_byte
this.stashed_bytes[1] = (match_byte & 0xFF) as base.u8
+33 -33
View File
@@ -356,7 +356,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
return ah_status
}
yield? dti_status
} endwhile
}
}
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: roslice base.u8) {
@@ -422,7 +422,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
post args.src.length() > 0,
{
yield? base."$short read"
} endwhile
}
if args.src.peek_u8() == 0x00 {
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
@@ -456,7 +456,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
} else {
yield? base."$short read"
}
} endwhile
}
continue
}
this.decoded_length = header_byte as base.u64
@@ -523,7 +523,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
while args.workbuf.length() < ((this.dict_size as base.u64) + 273) {
yield? base."$short workbuf"
} endwhile
}
while true {
smark = args.src.mark()
@@ -533,7 +533,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
if this.decoded_length == 0xFFFF_FFFF_FFFF_FFFF {
if this.stashed_bits <> 0 {
@@ -557,7 +557,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
} else if this.lzma2_encoded_length_have <> this.lzma2_encoded_length_want {
return "#bad LZMA2 header"
}
} endwhile
}
}
pri func decoder.decode_bitstream?(dst: base.io_writer, src: base.io_reader, workbuf: roslice base.u8) {
@@ -576,7 +576,7 @@ pri func decoder.decode_bitstream?(dst: base.io_writer, src: base.io_reader, wor
if this.end_of_chunk {
break
}
} endwhile
}
}
pri func decoder.update_stashed_bytes?(dst: base.io_writer, workbuf: roslice base.u8) {
@@ -587,7 +587,7 @@ pri func decoder.update_stashed_bytes?(dst: base.io_writer, workbuf: roslice bas
while args.dst.length() <= 0 {
yield? base."$short write"
} endwhile
}
dist = 1
which = 0
@@ -607,7 +607,7 @@ pri func decoder.update_stashed_bytes?(dst: base.io_writer, workbuf: roslice bas
inv which < 2,
{
wb_index ~mod+= this.dict_size as base.u64
} endwhile
}
if wb_index >= args.workbuf.length() {
return "#internal error: inconsistent dictionary state"
}
@@ -616,7 +616,7 @@ pri func decoder.update_stashed_bytes?(dst: base.io_writer, workbuf: roslice bas
dist = 1 + this.stashed_rep0
which += 1
} endwhile
}
}
// Preconditions:
@@ -637,7 +637,7 @@ pri func decoder.decode_optional_end_of_stream?(src: base.io_reader, workbuf: ro
return "#bad bitstream trailer"
}
yield? status
} endwhile
}
this.stashed_pos_end = this.stashed_pos
}
@@ -658,37 +658,37 @@ pri func decoder.initialize_probs!() {
while i < (12 << 4) {
this.probs_ao00[i] = 1024
i += 1
} endwhile
}
i = 0
while i < 12 {
this.probs_ao20[i] = 1024
i += 1
} endwhile
}
i = 0
while i < 12 {
this.probs_ao40[i] = 1024
i += 1
} endwhile
}
i = 0
while i < (12 << 4) {
this.probs_ao41[i] = 1024
i += 1
} endwhile
}
i = 0
while i < 12 {
this.probs_ao60[i] = 1024
i += 1
} endwhile
}
i = 0
while i < 12 {
this.probs_ao63[i] = 1024
i += 1
} endwhile
}
i = 0
while i < 16 {
@@ -698,9 +698,9 @@ pri func decoder.initialize_probs!() {
{
this.probs_match_len_low[i][j] = 1024
j += 1
} endwhile
}
i += 1
} endwhile
}
i = 0
while i < 16 {
@@ -710,15 +710,15 @@ pri func decoder.initialize_probs!() {
{
this.probs_match_len_mid[i][j] = 1024
j += 1
} endwhile
}
i += 1
} endwhile
}
i = 0
while i < 256 {
this.probs_match_len_high[0][i] = 1024
i += 1
} endwhile
}
i = 0
while i < 16 {
@@ -728,9 +728,9 @@ pri func decoder.initialize_probs!() {
{
this.probs_longrep_len_low[i][j] = 1024
j += 1
} endwhile
}
i += 1
} endwhile
}
i = 0
while i < 16 {
@@ -740,15 +740,15 @@ pri func decoder.initialize_probs!() {
{
this.probs_longrep_len_mid[i][j] = 1024
j += 1
} endwhile
}
i += 1
} endwhile
}
i = 0
while i < 256 {
this.probs_longrep_len_high[0][i] = 1024
i += 1
} endwhile
}
i = 0
while i < 4 {
@@ -758,21 +758,21 @@ pri func decoder.initialize_probs!() {
{
this.probs_slot[i][j] = 1024
j += 1
} endwhile
}
i += 1
} endwhile
}
i = 0
while i < 128 {
this.probs_small_dist[i] = 1024
i += 1
} endwhile
}
i = 0
while i < 16 {
this.probs_large_dist[i] = 1024
i += 1
} endwhile
}
i = 0
while i < 16 {
@@ -782,9 +782,9 @@ pri func decoder.initialize_probs!() {
{
this.probs_lit[i][j] = 1024
j += 1
} endwhile
}
i += 1
} endwhile
}
// Reset some other LZMA state too. They're not probabilities, but they
// need resetting whenever the probabilities do.
+6 -6
View File
@@ -117,7 +117,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
this.lm1s[i] = 0
this.suffixes[i][0] = i as base.u8
i += 1
} endwhile
}
while true {
this.read_from!(src: args.src)
@@ -139,7 +139,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
} else {
return "#internal error: inconsistent I/O"
}
} endwhile
}
}
pri func decoder.read_from!(src: base.io_reader) {
@@ -292,7 +292,7 @@ pri func decoder.read_from!(src: base.io_reader) {
// in practice, but is necessary for the overflow checker.
o = (o ~mod- 8) & 8191
c = this.prefixes[c] as base.u32
} endwhile
}
first_byte = this.suffixes[c][0]
if code == save_code {
@@ -333,7 +333,7 @@ pri func decoder.read_from!(src: base.io_reader) {
this.read_from_return_value = 1
break
}
} endwhile
}
// Rewind args.src, if we're not in "$short read" and we've read too many
// bits.
@@ -346,7 +346,7 @@ pri func decoder.read_from!(src: base.io_reader) {
this.read_from_return_value = 5
break
}
} endwhile
}
}
this.save_code = save_code
@@ -374,7 +374,7 @@ pri func decoder.write_to?(dst: base.io_writer) {
}
this.output_ri = (this.output_ri ~mod+ ((n & 0xFFFF_FFFF) as base.u32)) & 8191
yield? base."$short write"
} endwhile
}
}
// Deprecated. Use transform_io and an io_writer instead.
+16 -16
View File
@@ -53,7 +53,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -97,14 +97,14 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
if c8 == 0x0A {
break
}
} endwhile
}
continue
} else if (c8 < '0') or ('9' < c8) {
return "#bad header"
}
this.width = ((c8 - '0') as base.u32)
break
} endwhile
}
while true {
c8 = args.src.read_u8?()
if (c8 == ' ') or (c8 == 0x09) {
@@ -117,7 +117,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
return "#unsupported Netpbm file"
}
this.width = n
} endwhile
}
// Decode height.
while true {
@@ -131,14 +131,14 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
if c8 == 0x0A {
break
}
} endwhile
}
continue
} else if (c8 < '0') or ('9' < c8) {
return "#bad header"
}
this.height = ((c8 - '0') as base.u32)
break
} endwhile
}
while true {
c8 = args.src.read_u8?()
if (c8 == ' ') or (c8 == 0x09) or (c8 == 0x0D) {
@@ -153,7 +153,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
return "#unsupported Netpbm file"
}
this.height = n
} endwhile
}
// Decode max_value.
while true {
@@ -167,14 +167,14 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
if c8 == 0x0A {
break
}
} endwhile
}
continue
} else if (c8 < '0') or ('9' < c8) {
return "#bad header"
}
this.max_value = ((c8 - '0') as base.u32)
break
} endwhile
}
while true {
c8 = args.src.read_u8?()
if (c8 == ' ') or (c8 == 0x09) or (c8 == 0x0D) {
@@ -189,7 +189,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
return "#unsupported Netpbm file"
}
this.max_value = n
} endwhile
}
if this.max_value <> 255 {
return "#unsupported Netpbm file"
@@ -219,7 +219,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -265,7 +265,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -300,7 +300,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
return status
}
yield? base."$short read"
} endwhile
}
this.call_sequence = 0x60
}
@@ -359,7 +359,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
worst_case: src_bytes_per_pixel * 8)
}
j -= 8
} endwhile
}
while j > 0 {
if args.src.length() >= ((src_bytes_per_pixel * 1) as base.u64) {
args.src.skip_u32_fast!(
@@ -367,7 +367,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
worst_case: src_bytes_per_pixel * 1)
}
j -= 1
} endwhile
}
} else {
n = this.swizzler.swizzle_interleaved_from_reader!(
dst: dst[i ..],
@@ -378,7 +378,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
return "@internal note: short read"
}
this.dst_x ~sat+= (n & 0xFFFF_FFFF) as base.u32
} endwhile
}
return ok
}
+7 -7
View File
@@ -49,7 +49,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -115,7 +115,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -161,7 +161,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -196,7 +196,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
return status
}
yield? base."$short read"
} endwhile
}
this.call_sequence = 0x60
}
@@ -255,7 +255,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
worst_case: src_bytes_per_pixel * 8)
}
j -= 8
} endwhile
}
while j > 0 {
if args.src.length() >= ((src_bytes_per_pixel * 1) as base.u64) {
args.src.skip_u32_fast!(
@@ -263,7 +263,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
worst_case: src_bytes_per_pixel * 1)
}
j -= 1
} endwhile
}
} else {
n = this.swizzler.swizzle_interleaved_from_reader!(
dst: dst[i ..],
@@ -274,7 +274,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
return "@internal note: short read"
}
this.dst_x ~sat+= (n & 0xFFFF_FFFF) as base.u32
} endwhile
}
return ok
}
+8 -8
View File
@@ -32,9 +32,9 @@ pri func decoder.filter_1!(curr: slice base.u8),
args.curr[i] = args.curr[i] ~mod+ fa
fa = args.curr[i]
i ~mod+= filter_distance
} endwhile
}
i_start += 1
} endwhile
}
}
pri func decoder.filter_1_distance_3_fallback!(curr: slice base.u8) {
@@ -91,7 +91,7 @@ pri func decoder.filter_2!(curr: slice base.u8, prev: slice base.u8) {
assert i < args.prev.length() via "a < b: a < c; c <= b"(c: n)
args.curr[i] = args.curr[i] ~mod+ (args.prev[i])
i += 1
} endwhile
}
}
// Filter 3: Average.
@@ -115,7 +115,7 @@ pri func decoder.filter_3!(curr: slice base.u8, prev: slice base.u8),
args.curr[i] = args.curr[i] ~mod+ (args.curr[i - filter_distance] / 2)
i += 1
assert i >= filter_distance via "a >= b: a >= (b + c); 0 <= c"(c: 1)
} endwhile
}
} else {
n = args.curr.length().min(no_more_than: args.prev.length())
@@ -129,7 +129,7 @@ pri func decoder.filter_3!(curr: slice base.u8, prev: slice base.u8),
assert i < args.prev.length() via "a < b: a < c; c <= b"(c: n)
args.curr[i] = args.curr[i] ~mod+ (args.prev[i] / 2)
i += 1
} endwhile
}
i = filter_distance
assert i >= filter_distance via "a >= b: a == b"()
@@ -147,7 +147,7 @@ pri func decoder.filter_3!(curr: slice base.u8, prev: slice base.u8),
(args.prev[i] as base.u32)) / 2) as base.u8)
i += 1
assert i >= filter_distance via "a >= b: a >= (b + c); 0 <= c"(c: 1)
} endwhile
}
}
}
@@ -245,7 +245,7 @@ pri func decoder.filter_4!(curr: slice base.u8, prev: slice base.u8),
assert i < args.prev.length() via "a < b: a < c; c <= b"(c: n)
args.curr[i] = args.curr[i] ~mod+ args.prev[i]
i += 1
} endwhile
}
i = filter_distance
assert i >= filter_distance via "a >= b: a == b"()
@@ -285,7 +285,7 @@ pri func decoder.filter_4!(curr: slice base.u8, prev: slice base.u8),
args.curr[i] = args.curr[i] ~mod+ ((fa & 0xFF) as base.u8)
i += 1
assert i >= filter_distance via "a >= b: a >= (b + c); 0 <= c"(c: 1)
} endwhile
}
}
pri func decoder.filter_4_distance_3_fallback!(curr: slice base.u8, prev: slice base.u8) {
+36 -27
View File
@@ -174,7 +174,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -218,7 +218,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
break
}
yield? status
} endwhile
}
// Verify CRC-32 checksum.
checksum_want = args.src.read_u32be?()
@@ -283,7 +283,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
break
}
yield? status
} endwhile
}
// If we have metadata, delay reading (skipping) the ancillary chunk's
// CRC-32 checksum until the end of tell_me_more.
@@ -297,7 +297,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
(checksum_have <> checksum_want) {
return "#bad checksum"
}
} endwhile
}
if (this.color_type == 3) and (not this.seen_plte) {
return "#missing palette"
@@ -617,11 +617,20 @@ pri func decoder.decode_other_chunk?(src: base.io_reader, framy: base.bool) {
}
} else if this.chunk_type == 'tRNS'le {
if this.seen_trns or (this.color_type > 3) or
if this.seen_trns or
((this.color_type == 3) and (not this.seen_plte)) {
return "#bad chunk"
} else if this.color_type > 3 {
// No-op, ignoring the chunk. The PNG spec section "11.3.2.1
// tRNS Transparency" says that "A tRNS chunk shall not appear
// for colour types 4 and 6, since a full alpha channel is
// already present in those cases." However, some real-world
// PNG images (incorrectly) have these. libpng treats this as a
// "benign error", not a fatal one. See
// https://github.com/google/wuffs/issues/146
} else {
this.decode_trns?(src: args.src)
}
this.decode_trns?(src: args.src)
this.seen_trns = true
}
}
@@ -801,7 +810,7 @@ pri func decoder.decode_iccp?(src: base.io_reader) {
if c8 == 0 {
break
}
} endwhile
}
// Compression method.
if this.chunk_length <= 0 {
@@ -843,7 +852,7 @@ pri func decoder.decode_plte?(src: base.io_reader) {
this.src_palette[(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
this.src_palette[(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
i += 1
} endwhile
}
// Set the remaining palette entries to opaque black.
while i < 256 {
@@ -852,7 +861,7 @@ pri func decoder.decode_plte?(src: base.io_reader) {
this.src_palette[(4 * i) + 2] = 0x00
this.src_palette[(4 * i) + 3] = 0xFF
i += 1
} endwhile
}
}
pri func decoder.decode_srgb?(src: base.io_reader) {
@@ -936,7 +945,7 @@ pri func decoder.decode_trns?(src: base.io_reader) {
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"
@@ -952,7 +961,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -1020,7 +1029,7 @@ pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.
}
args.src.skip_u32?(n: 4) // Skip the checksum.
this.chunk_length = 0
} endwhile
}
}
if args.dst <> nullptr {
@@ -1102,7 +1111,7 @@ pri func decoder.skip_frame?(src: base.io_reader) {
// +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
this.call_sequence = 0x20
@@ -1117,7 +1126,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -1181,7 +1190,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
// +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!()
@@ -1237,7 +1246,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
}
yield? status
} endwhile
}
status = this.filter_and_swizzle!(dst: args.dst, workbuf: args.workbuf)
if not status.is_ok() {
return status
@@ -1249,7 +1258,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
break
}
this.interlace_pass += 1
} endwhile
}
this.num_decoded_frames_value ~sat+= 1
this.call_sequence = 0x20
@@ -1345,7 +1354,7 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
return "#internal error: zlib decoder did not exhaust its input"
}
yield? base."$short read"
} endwhile
}
if this.workbuf_wi <> this.pass_workbuf_length {
return base."#not enough data"
@@ -1421,7 +1430,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
@@ -1458,7 +1467,7 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
}
this.metadata_y = this.metadata_z
yield? base."$even more information"
} endwhile
}
}
if this.metadata_is_zlib_compressed {
@@ -1565,7 +1574,7 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
this.ztxt_ri += 1
args.dst.write_u16le_fast!(a: c16)
}
} endwhile
}
if zlib_status.is_ok() {
this.metadata_is_zlib_compressed = false
@@ -1598,7 +1607,7 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
c8 = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
args.dst.write_u8_fast!(a: c8)
} endwhile
}
} else {
// Other uncompressed keys and values are Latin-1.
@@ -1639,9 +1648,9 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
args.dst.write_u16le_fast!(a: c16)
}
} endwhile
}
}
} endwhile.loop
}.loop
// Key-value pairs come in... pairs.
if this.metadata_fourcc == 'KVPK'be {
@@ -1679,8 +1688,8 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
if c8 == 0 {
break
}
} endwhile
} endwhile
}
}
} else if this.chunk_type == 'zTXt'le {
// Compression method.
@@ -1699,7 +1708,7 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
return ok
}
break.goto_done
}} endwhile.goto_done
}}.goto_done
if this.chunk_length <> 0 {
return "#bad chunk"
+1 -1
View File
@@ -97,7 +97,7 @@ pri func decoder.filter_and_swizzle!(dst: ptr base.pixel_buffer, workbuf: slice
prev_row = curr_row
y += 1
} endwhile
}
return ok
}
+4 -4
View File
@@ -157,7 +157,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
}
}
x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
} endwhile
}
} else if this.depth < 8 {
multiplier = 1
@@ -210,7 +210,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
}
}
x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
} endwhile
}
} else {
while x < this.frame_rect_x1,
@@ -314,12 +314,12 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
src: bits_unpacked[.. 8])
}
x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
} endwhile
}
}
prev_row = curr_row
y += (1 as base.u32) << INTERLACING[this.interlace_pass][3]
} endwhile
}
return ok
}
+10 -10
View File
@@ -94,7 +94,7 @@ pub func hasher.update!(x: roslice base.u8) {
this.buf_data[this.buf_len] = args.x[0]
this.buf_len += 1
args.x = args.x[1 ..]
} endwhile
}
this.buf_len = 0
this.up!(x: this.buf_data[..])
}
@@ -189,7 +189,7 @@ pri func hasher.up!(x: roslice base.u8) {
((w15 ~mod<< 14) | (w15 >> 18))
w[i] = ((s1 ~mod+ w[i - 7]) ~mod+ s0) ~mod+ w[i - 16]
i += 1
} endwhile
}
i = 0
while i < 64 {
@@ -216,7 +216,7 @@ pri func hasher.up!(x: roslice base.u8) {
a = t1 ~mod+ t2
i += 1
} endwhile
}
a ~mod+= this.h0
this.h0 = a
@@ -283,7 +283,7 @@ pub func hasher.checksum_bitvec256() base.bitvec256 {
while i < 64 {
buf_data[i] = this.buf_data[i]
i += 1
} endwhile
}
// Pad with a 1 bit and then zero or more 0 bits, until we're at 56 bytes
// (448 bits), modulo 64 bytes (512 bits).
@@ -294,7 +294,7 @@ pub func hasher.checksum_bitvec256() base.bitvec256 {
while buf_len < 56 {
buf_data[buf_len] = 0x00
buf_len += 1
} endwhile
}
final_block = true
} else {
@@ -304,7 +304,7 @@ pub func hasher.checksum_bitvec256() base.bitvec256 {
while buf_len < 64 {
buf_data[buf_len] = 0x00
buf_len += 1
} endwhile
}
}
h0 = this.h0
@@ -385,7 +385,7 @@ pub func hasher.checksum_bitvec256() base.bitvec256 {
((w15 ~mod<< 14) | (w15 >> 18))
w[i] = ((s1 ~mod+ w[i - 7]) ~mod+ s0) ~mod+ w[i - 16]
i += 1
} endwhile
}
i = 0
while i < 64 {
@@ -412,7 +412,7 @@ pub func hasher.checksum_bitvec256() base.bitvec256 {
a = t1 ~mod+ t2
i += 1
} endwhile
}
a ~mod+= h0
b ~mod+= h1
@@ -441,8 +441,8 @@ pub func hasher.checksum_bitvec256() base.bitvec256 {
while buf_len < 56 {
buf_data[buf_len] = 0x00
buf_len += 1
} endwhile
} endwhile
}
}
return this.util.make_bitvec256(
e00: (h as base.u64) | ((g as base.u64) << 32),
+8 -8
View File
@@ -65,7 +65,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -214,14 +214,14 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
this.src_palette[((i & 0xFF) * 4) + 3] = 0xFF
}
i += 1
} endwhile
}
while i < 0x100 {
this.src_palette[(i * 4) + 0] = 0x00
this.src_palette[(i * 4) + 1] = 0x00
this.src_palette[(i * 4) + 2] = 0x00
this.src_palette[(i * 4) + 3] = 0xFF
i += 1
} endwhile
}
}
this.frame_config_io_position = args.src.position()
@@ -248,7 +248,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -294,7 +294,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -545,7 +545,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
}
}
} endwhile
}
dst_x = 0
if (this.header_image_descriptor & 0x20) == 0 { // Bottom-to-top.
@@ -558,9 +558,9 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
// effectively literals.
lit_length = this.width
}
} endwhile
}
break.resume
} endwhile.resume
}.resume
this.call_sequence = 0x60
}
+24
View File
@@ -0,0 +1,24 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// --------
// This code is a placeholder. std/webp depends on std/vp8 (a lossy image
// codec) even though, in the very short term, std/webp only implements the
// lossless VP8L format. In the medium term, though, std/webp will also support
// VP8 and the resultant code changes will be smaller and simpler if std/webp
// depends on std/vp8 right from the start.
//
// Also, a std/webm package does not exist yet, but might in the future. If it
// does, it will also depend on std/vp8 (but not std/webp).
pub struct placeholder?(
placeholder : base.u32,
)
+9 -9
View File
@@ -44,7 +44,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
@@ -64,7 +64,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
return "#bad header"
}
i += 1
} endwhile
}
// Width, height.
i = 0
@@ -82,7 +82,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
return base."#unsupported image dimension"
}
p <<= 7
} endwhile
}
if i == 0 {
this.width = p
@@ -90,7 +90,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
this.height = p
}
i += 1
} endwhile
}
this.frame_config_io_position = args.src.position()
@@ -116,7 +116,7 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
@@ -162,7 +162,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -231,7 +231,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
if dst_x_in_bytes <= dst.length() {
dst = dst[dst_x_in_bytes ..]
}
} endwhile
}
c8 = args.src.peek_u8()
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
}
@@ -255,9 +255,9 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
dst_x += 1
} endwhile
}
dst_y += 1
} endwhile
}
}
this.call_sequence = 0x60
+531
View File
@@ -0,0 +1,531 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_huffman_groups?(src: base.io_reader, n_huffman_groups: base.u32[..= 256]) {
var hg : base.u32
var ht : base.u32
hg = 0
while hg < args.n_huffman_groups {
assert hg < 256 via "a < b: a < c; c <= b"(c: args.n_huffman_groups)
ht = 0
while ht < 5,
inv hg < 256,
{
this.decode_huffman_tree?(src: args.src, hg: hg, ht: ht)
ht += 1
}
hg += 1
}
}
pri func decoder.decode_huffman_tree?(src: base.io_reader, hg: base.u32[..= 255], ht: base.u32[..= 4]) {
var c8 : base.u8
var use_simple : base.u32[..= 1]
var status : base.status
if args.ht >= 4 {
this.ht_n_symbols = 40
} else if args.ht > 0 {
this.ht_n_symbols = 256
} else if this.color_cache_bits == 0 {
this.ht_n_symbols = 280
} else {
this.ht_n_symbols = 280 + ((1 as base.u32) << this.color_cache_bits)
}
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
use_simple = this.bits & 1
this.bits >>= 1
this.n_bits -= 1
if use_simple <> 0 {
this.decode_huffman_tree_simple?(src: args.src, hg: args.hg, ht: args.ht)
} else {
this.decode_code_length_code_lengths?(src: args.src)
status = this.build_code_lengths_huffman_nodes!()
if not status.is_ok() {
return status
}
this.build_code_lengths?(src: args.src)
status = this.build_huffman_nodes!(hg: args.hg, ht: args.ht)
if not status.is_ok() {
return status
}
}
}
pri func decoder.decode_huffman_tree_simple?(src: base.io_reader, hg: base.u32[..= 255], ht: base.u32[..= 4]) {
var c8 : base.u8
var use_second_symbol : base.u32[..= 1]
var first_symbol_n_bits : base.u32[..= 8]
var symbol0 : base.u32[..= 0xFF]
var symbol1 : base.u32[..= 0xFF]
var base_offset : base.u32[..= 0x064C]
if this.n_bits < 2 {
c8 = args.src.read_u8?()
if this.n_bits >= 2 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 2
}
use_second_symbol = this.bits & 1
first_symbol_n_bits = (((this.bits & 2) >> 1) * 7) + 1
this.bits >>= 2
this.n_bits -= 2
if this.n_bits < first_symbol_n_bits {
c8 = args.src.read_u8?()
if this.n_bits >= first_symbol_n_bits {
return "#internal error: inconsistent n_bits"
}
assert this.n_bits < 8 via "a < b: a < c; c <= b"(c: first_symbol_n_bits)
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 8
assert first_symbol_n_bits <= this.n_bits via "a <= b: a <= c; c <= b"(c: 8)
assert this.n_bits >= first_symbol_n_bits via "a >= b: b <= a"()
}
symbol0 = this.bits & (((1 as base.u32) << first_symbol_n_bits) - 1)
this.bits >>= first_symbol_n_bits
this.n_bits -= first_symbol_n_bits
base_offset = HUFFMAN_TABLE_BASE_OFFSETS[args.ht] as base.u32
if use_second_symbol <> 0 {
if this.n_bits < 8 {
c8 = args.src.read_u8?()
if this.n_bits >= 8 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 8
}
symbol1 = this.bits & 0xFF
this.bits >>= 8
this.n_bits -= 8
this.huffman_nodes[args.hg][base_offset + 0] = (base_offset + 1) as base.u16
this.huffman_nodes[args.hg][base_offset + 1] = (symbol0 | 0x8000) as base.u16
this.huffman_nodes[args.hg][base_offset + 2] = (symbol1 | 0x8000) as base.u16
} else {
this.huffman_nodes[args.hg][base_offset] = (symbol0 | 0x8000) as base.u16
}
}
pri func decoder.decode_code_length_code_lengths?(src: base.io_reader) {
var c8 : base.u8
var n_codes : base.u32[..= 19]
var i : base.u32
if this.n_bits < 4 {
c8 = args.src.read_u8?()
if this.n_bits >= 4 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 4
}
n_codes = (this.bits & 15) + 4
this.bits >>= 4
this.n_bits -= 4
i = 0
while i < n_codes {
assert i < 19 via "a < b: a < c; c <= b"(c: n_codes)
if this.n_bits < 3 {
c8 = args.src.read_u8?()
if this.n_bits >= 3 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 3
}
this.code_length_code_lengths[CODE_LENGTH_CODE_ORDER[i]] = (this.bits & 7) as base.u8
this.bits >>= 3
this.n_bits -= 3
i += 1
}
while i < 19 {
this.code_length_code_lengths[CODE_LENGTH_CODE_ORDER[i]] = 0
i += 1
}
}
pri func decoder.build_code_lengths_huffman_nodes!() base.status {
var code_bits : base.u32
var code_len : base.u32[..= 7] // The "code length code length".
var symbol : base.u32[..= 19] // The "code length or 16, 17, 18".
var histogram : array[8] base.u32
var n_used_symbols : base.u32
var last_used_symbol : base.u32[..= 18]
var subscription_weight : base.u32[..= 0x8000]
var subscription_total : base.u32
var curr_code : base.u32
var next_codes : array[9] base.u32
var n_branches : base.u32
var h : base.u32[..= 36]
var children : base.u32
var node : base.u16
symbol = 0
while symbol < 19 {
code_len = this.code_length_code_lengths[symbol] as base.u32
if code_len <> 0 {
histogram[code_len] ~mod+= 1
n_used_symbols ~mod+= 1
last_used_symbol = symbol
}
symbol += 1
}
if n_used_symbols < 1 {
return "#bad Huffman code"
} else if n_used_symbols == 1 {
this.code_lengths_huffman_nodes[0] = (last_used_symbol | 0x8000) as base.u16
return ok
}
subscription_weight = 1 << 14
code_len = 1
while true {
curr_code = (curr_code ~mod+ histogram[code_len]) ~mod<< 1
next_codes[code_len + 1] = curr_code
subscription_total ~mod+= subscription_weight ~mod* histogram[code_len]
subscription_weight >>= 1
if code_len >= 7 {
break
}
code_len += 1
}
if subscription_total > (1 << 15) {
return "#bad Huffman code (over-subscribed)"
} else if subscription_total < (1 << 15) {
return "#bad Huffman code (under-subscribed)"
}
this.code_lengths_huffman_nodes[0] = 0
symbol = 0
while symbol < 19 {
code_len = this.code_length_code_lengths[symbol] as base.u32
if code_len > 0 {
code_bits = next_codes[code_len]
next_codes[code_len] ~mod+= 1
// Insert {symbol, code_bits, code_len} into the node tree.
code_bits ~mod<<= 32 - code_len
h = 0
while code_len > 0,
inv symbol < 19,
{
node = this.code_lengths_huffman_nodes[h]
if node == 0 {
children = 1 ~mod+ (2 ~mod* n_branches)
children = children.min(no_more_than: 35)
this.code_lengths_huffman_nodes[h] = children as base.u16
this.code_lengths_huffman_nodes[children + 0] = 0
this.code_lengths_huffman_nodes[children + 1] = 0
h = children + (code_bits >> 31)
n_branches ~mod+= 1
} else {
children = node as base.u32
h = children.min(no_more_than: 35) + (code_bits >> 31)
}
code_bits ~mod<<= 1
code_len -= 1
}
this.code_lengths_huffman_nodes[h] = (symbol | 0x8000) as base.u16
}
symbol += 1
}
return ok
}
pri func decoder.build_huffman_nodes!(hg: base.u32[..= 255], ht: base.u32[..= 4]) base.status {
var base_offset : base.u32[..= 0x064C]
var code_bits : base.u32
var code_len : base.u32[..= 15]
var symbol : base.u32[..= 2328]
var histogram : array[16] base.u32
var n_used_symbols : base.u32
var last_used_symbol : base.u32[..= 2328]
var subscription_weight : base.u32[..= 0x8000]
var subscription_total : base.u32
var curr_code : base.u32
var next_codes : array[17] base.u32
var n_branches : base.u32
var h : base.u32[..= 0x187A]
var children : base.u32
var node : base.u16
base_offset = HUFFMAN_TABLE_BASE_OFFSETS[args.ht] as base.u32
symbol = 0
while symbol < this.ht_n_symbols {
assert symbol < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols)
code_len = (this.code_lengths[symbol] & 15) as base.u32
if code_len <> 0 {
histogram[code_len] ~mod+= 1
n_used_symbols ~mod+= 1
last_used_symbol = symbol
}
symbol += 1
}
if n_used_symbols < 1 {
return "#bad Huffman code"
} else if n_used_symbols == 1 {
this.huffman_nodes[args.hg][base_offset] = (last_used_symbol | 0x8000) as base.u16
return ok
}
subscription_weight = 1 << 14
code_len = 1
while true {
curr_code = (curr_code ~mod+ histogram[code_len]) ~mod<< 1
next_codes[code_len + 1] = curr_code
subscription_total ~mod+= subscription_weight ~mod* histogram[code_len]
subscription_weight >>= 1
if code_len >= 15 {
break
}
code_len += 1
}
if subscription_total > (1 << 15) {
return "#bad Huffman code (over-subscribed)"
} else if subscription_total < (1 << 15) {
return "#bad Huffman code (under-subscribed)"
}
this.huffman_nodes[args.hg][base_offset] = 0
symbol = 0
while symbol < this.ht_n_symbols {
assert symbol < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols)
code_len = (this.code_lengths[symbol] & 15) as base.u32
if code_len <> 0 {
code_bits = next_codes[code_len]
next_codes[code_len] ~mod+= 1
// Insert {symbol, code_bits, code_len} into the node tree.
code_bits ~mod<<= 32 - code_len
h = base_offset
while code_len > 0,
inv symbol < 2328,
{
node = this.huffman_nodes[args.hg][h]
if node == 0 {
children = base_offset ~mod+ (1 ~mod+ (2 ~mod* n_branches))
children = children.min(no_more_than: 0x1879)
this.huffman_nodes[args.hg][h] = children as base.u16
this.huffman_nodes[args.hg][children + 0] = 0
this.huffman_nodes[args.hg][children + 1] = 0
h = children + (code_bits >> 31)
n_branches ~mod+= 1
} else {
children = node as base.u32
h = children.min(no_more_than: 0x1879) + (code_bits >> 31)
}
code_bits ~mod<<= 1
code_len -= 1
}
this.huffman_nodes[args.hg][h] = (symbol | 0x8000) as base.u16
}
symbol += 1
}
return ok
}
pri func decoder.build_code_lengths?(src: base.io_reader) {
var c8 : base.u8
var use_length : base.u32[..= 1]
var length_n_bits : base.u32[..= 16]
var length : base.u32[..= 65537]
var prev_code_length : base.u16[..= 15]
var h : base.u32[..= 36]
var s : base.u32[..= 2328]
var s_max : base.u32
var node : base.u16
var symbol : base.u32[..= 0x7FFF]
var repeat_value : base.u16[..= 15]
var repeat_n_bits : base.u32[..= 7]
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
use_length = this.bits & 1
this.bits >>= 1
this.n_bits -= 1
this.ht_code_lengths_remaining = this.ht_n_symbols
if use_length <> 0 {
if this.n_bits < 3 {
c8 = args.src.read_u8?()
if this.n_bits >= 3 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 3
}
length_n_bits = ((this.bits & 7) * 2) + 2
this.bits >>= 3
this.n_bits -= 3
while this.n_bits < length_n_bits,
post this.n_bits >= length_n_bits,
{
c8 = args.src.read_u8?()
if this.n_bits >= length_n_bits {
return "#internal error: inconsistent n_bits"
}
assert this.n_bits < 16 via "a < b: a < c; c <= b"(c: length_n_bits)
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
}
length = (this.bits & (((1 as base.u32) << length_n_bits) - 1)) + 2
this.bits >>= length_n_bits
this.n_bits -= length_n_bits
if length > this.ht_n_symbols {
return "#bad Huffman code"
}
this.ht_code_lengths_remaining = length
}
prev_code_length = 8
while s < this.ht_n_symbols {
assert s < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols)
if this.ht_code_lengths_remaining <= 0 {
while s < this.ht_n_symbols {
assert s < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols)
this.code_lengths[s] = 0
s += 1
}
break
}
this.ht_code_lengths_remaining -= 1
h = 0
while true,
inv s < 2328,
{
node = this.code_lengths_huffman_nodes[h]
if node >= 0x8000 {
break
} else if node > 35 {
return "#internal error: inconsistent Huffman code"
}
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
h = (node as base.u32) + (this.bits & 1)
this.bits >>= 1
this.n_bits -= 1
}
symbol = (node & 0x7FFF) as base.u32
if symbol == 0 {
this.code_lengths[s] = 0
s += 1
continue
} else if symbol < 16 {
prev_code_length = symbol as base.u16
this.code_lengths[s] = prev_code_length
s += 1
continue
} else if symbol == 16 {
repeat_value = prev_code_length
} else {
repeat_value = 0
}
repeat_n_bits = REPEAT_N_BITS[symbol & 3] as base.u32
s_max = (REPEAT_COUNTS[symbol & 3] as base.u32) ~mod+ s
if this.n_bits < repeat_n_bits {
c8 = args.src.read_u8?()
if this.n_bits >= repeat_n_bits {
return "#internal error: inconsistent n_bits"
}
assert this.n_bits < 7 via "a < b: a < c; c <= b"(c: repeat_n_bits)
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 8
assert repeat_n_bits <= this.n_bits via "a <= b: a <= c; c <= b"(c: 8)
assert this.n_bits >= repeat_n_bits via "a >= b: b <= a"()
}
s_max ~mod+= this.bits & (((1 as base.u32) << repeat_n_bits) - 1)
this.bits >>= repeat_n_bits
this.n_bits -= repeat_n_bits
if s_max > this.ht_n_symbols {
return "#bad Huffman code"
}
assert s_max <= 2328 via "a <= b: a <= c; c <= b"(c: this.ht_n_symbols)
while s < s_max,
inv s_max <= 2328,
{
assert s < 2328 via "a < b: a < c; c <= b"(c: s_max)
this.code_lengths[s] = repeat_value
s += 1
}
}
}
pri const CODE_LENGTH_CODE_ORDER : roarray[19] base.u8[..= 18] = [
17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
]
pri const REPEAT_N_BITS : roarray[4] base.u8[..= 7] = [2, 3, 7, 0]
pri const REPEAT_COUNTS : roarray[4] base.u8[..= 11] = [3, 3, 11, 0]
// See the decoder.huffman_nodes comment re five (5) Huffman trees.
pri const HUFFMAN_TABLE_BASE_OFFSETS : roarray[5] base.u16[..= 0x064C] = [
0x064C,
0x0000,
0x01FF,
0x03FE,
0x05FD,
]
+308
View File
@@ -0,0 +1,308 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_pixels_slow?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) {
var c8 : base.u8
var p : base.u64
var p_max : base.u64[..= 0x4000_0000]
var tile_size_log2 : base.u32[..= 31]
var width_in_tiles : base.u32[..= 0x20FF]
var x : base.u32
var y : base.u32
var i : base.u32
var hg : base.u32[..= 0xFF]
var h : base.u32[..= 0x187A]
var node : base.u16
var pixel_g : base.u32[..= 0x7FFF]
var color : base.u32 // u32 0xAARR_GGBB, non-premultiplied alpha.
var dst_pixel : slice base.u8
var back_ref_len_n_bits : base.u32[..= 11]
var back_ref_len_minus_1 : base.u32[..= 0x1FFF] // 0x1FFF = 8191.
var back_ref_dist_n_bits : base.u32[..= 18]
var back_ref_dist_sym : base.u32[..= 0x7FFF]
var back_ref_dist_premap_minus_1 : base.u32[..= 0xF_FFFF] // 0xF_FFFF = 1048575.
var back_ref_dist_minus_1 : base.u32
var dm : base.u32[..= 0xFF]
var dx : base.u32
var dy : base.u32
var p_end : base.u64[..= 0x4000_8000]
var dist4 : base.u64
var q : base.u64
var color_cache_pixels : slice base.u8
var color_cache_p : base.u64
var color_cache_shift : base.u32[..= 31]
p_max = (4 * args.width * args.height) as base.u64
if args.dst.length() < p_max {
return "#internal error: inconsistent dst buffer"
}
if args.tile_size_log2 <> 0 {
tile_size_log2 = args.tile_size_log2
width_in_tiles = (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
} else {
tile_size_log2 = 31
width_in_tiles = 1
}
while p < p_max {
// The "~mod+ 1" selects the green pixel of the BGRA 4-byte group.
i = ((((y >> tile_size_log2) ~mod* width_in_tiles) ~mod+ (x >> tile_size_log2)) ~mod* 4) ~mod+ 1
if (i as base.u64) < args.tile_data.length() {
hg = args.tile_data[i as base.u64] as base.u32
}
// Decode the Green+etc symbol.
h = HUFFMAN_TABLE_BASE_OFFSETS[0] as base.u32
while true,
inv p < p_max,
{
node = this.huffman_nodes[hg][h]
if node >= 0x8000 {
break
} else if node > 0x1879 {
return "#internal error: inconsistent Huffman code"
}
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
h = (node as base.u32) + (this.bits & 1)
this.bits >>= 1
this.n_bits -= 1
}
pixel_g = (node & 0x7FFF) as base.u32
if pixel_g < 0x100 { // Literal pixel.
color = pixel_g << 8
// Decode the Red symbol.
h = HUFFMAN_TABLE_BASE_OFFSETS[1] as base.u32
while true,
inv p < p_max,
{
node = this.huffman_nodes[hg][h]
if node >= 0x8000 {
break
}
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
this.bits >>= 1
this.n_bits -= 1
}
color |= ((node & 0xFF) as base.u32) << 16
// Decode the Blue symbol.
h = HUFFMAN_TABLE_BASE_OFFSETS[2] as base.u32
while true,
inv p < p_max,
{
node = this.huffman_nodes[hg][h]
if node >= 0x8000 {
break
}
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
this.bits >>= 1
this.n_bits -= 1
}
color |= ((node & 0xFF) as base.u32) << 0
// Decode the Alpha symbol.
h = HUFFMAN_TABLE_BASE_OFFSETS[3] as base.u32
while true,
inv p < p_max,
{
node = this.huffman_nodes[hg][h]
if node >= 0x8000 {
break
}
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
this.bits >>= 1
this.n_bits -= 1
}
color |= ((node & 0xFF) as base.u32) << 24
} else if pixel_g < 0x118 { // Back-ref pixel.
// Decode the back-ref length.
if pixel_g < 0x104 {
back_ref_len_minus_1 = pixel_g - 0x100
} else {
back_ref_len_n_bits = (pixel_g - 0x102) >> 1
back_ref_len_minus_1 = ((2 as base.u32) + (pixel_g & 1)) << back_ref_len_n_bits
assert back_ref_len_minus_1 <= 6144
while this.n_bits < back_ref_len_n_bits,
inv p < p_max,
inv back_ref_len_minus_1 <= 6144,
post this.n_bits >= back_ref_len_n_bits,
{
c8 = args.src.read_u8?()
if this.n_bits >= back_ref_len_n_bits {
return "#internal error: inconsistent n_bits"
}
assert this.n_bits < 12 via "a < b: a < c; c <= b"(c: back_ref_len_n_bits)
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
}
back_ref_len_minus_1 += this.bits & (((1 as base.u32) << back_ref_len_n_bits) - 1)
this.bits >>= back_ref_len_n_bits
this.n_bits -= back_ref_len_n_bits
}
// Decode the back-ref distance.
h = HUFFMAN_TABLE_BASE_OFFSETS[4] as base.u32
while true,
inv p < p_max,
{
node = this.huffman_nodes[hg][h]
if node >= 0x8000 {
break
}
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
this.bits >>= 1
this.n_bits -= 1
}
back_ref_dist_sym = (node & 0x7FFF) as base.u32
if back_ref_dist_sym < 4 {
back_ref_dist_premap_minus_1 = back_ref_dist_sym
} else if back_ref_dist_sym < 40 {
back_ref_dist_n_bits = (back_ref_dist_sym - 2) >> 1
back_ref_dist_premap_minus_1 = ((2 as base.u32) + (back_ref_dist_sym & 1)) << back_ref_dist_n_bits
assert back_ref_dist_premap_minus_1 <= 786432
while this.n_bits < back_ref_dist_n_bits,
inv p < p_max,
inv back_ref_dist_premap_minus_1 <= 786432,
post this.n_bits >= back_ref_dist_n_bits,
{
c8 = args.src.read_u8?()
if this.n_bits >= back_ref_dist_n_bits {
return "#internal error: inconsistent n_bits"
}
assert this.n_bits < 24 via "a < b: a < c; c <= b"(c: back_ref_dist_n_bits)
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
}
back_ref_dist_premap_minus_1 += this.bits & (((1 as base.u32) << back_ref_dist_n_bits) - 1)
this.bits >>= back_ref_dist_n_bits
this.n_bits -= back_ref_dist_n_bits
}
if back_ref_dist_premap_minus_1 >= 120 {
back_ref_dist_minus_1 = back_ref_dist_premap_minus_1 - 120
} else {
dm = DISTANCE_MAP[back_ref_dist_premap_minus_1] as base.u32
dy = dm >> 4
dx = 7 ~mod- (dm & 15)
back_ref_dist_minus_1 = (args.width * dy) ~mod+ dx
}
// Apply the (back_ref_len_minus_1, back_ref_dist_minus_1) pair.
assert p < 0x4000_0000 via "a < b: a < c; c <= b"(c: p_max)
p_end = p + (((back_ref_len_minus_1 + 1) * 4) as base.u64)
dist4 = ((back_ref_dist_minus_1 as base.u64) * 4) + 4
if (p_end > p_max) or (p_end > args.dst.length()) or (p < dist4) {
return "#bad back-reference"
}
q = p - dist4
while (q < p) and (p < p_end),
inv p_end <= args.dst.length(),
{
assert q < p_end via "a < b: a < c; c < b"(c: p)
assert p < 0x4000_8000 via "a < b: a < c; c <= b"(c: p_end)
assert q < 0x4000_8000 via "a < b: a < c; c <= b"(c: p_end)
assert p < args.dst.length() via "a < b: a < c; c <= b"(c: p_end)
assert q < args.dst.length() via "a < b: a < c; c <= b"(c: p_end)
args.dst[p] = args.dst[q]
p += 1
q += 1
}
// Update (x, y).
x ~mod+= back_ref_len_minus_1 + 1
while x >= args.width {
x -= args.width
y ~mod+= 1
}
continue
} else { // Color cache pixel.
// Insert previous pixels into this.color_cache.
if (color_cache_p > p) or (p > args.dst.length()) {
return "#internal error: inconsistent dst buffer"
}
color_cache_pixels = args.dst[color_cache_p .. p]
color_cache_p = p
color_cache_shift = (32 - this.color_cache_bits) & 31
while color_cache_pixels.length() >= 4,
inv pixel_g >= 0x118,
{
color = color_cache_pixels.peek_u32le()
this.color_cache[((color ~mod* 0x1E35_A7BD) >> color_cache_shift) & 2047] = color
color_cache_pixels = color_cache_pixels[4 ..]
}
// Look up this.color_cache.
color = this.color_cache[(pixel_g - 0x118) & 2047]
}
// Set the dst pixel to the color.
if p > args.dst.length() {
return "#internal error: inconsistent dst buffer"
}
dst_pixel = args.dst[p ..]
if dst_pixel.length() < 4 {
return "#internal error: inconsistent dst buffer"
}
dst_pixel.poke_u32le!(a: color)
p ~mod+= 4
// Update (x, y).
x ~mod+= 1
if x == args.width {
x = 0
y ~mod+= 1
}
}
}
+464
View File
@@ -0,0 +1,464 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.apply_transform_predictor!(pix: slice base.u8, tile_data: roslice base.u8) {
var w4 : base.u64[..= 0x1_0000]
var prev_row : roslice base.u8
var curr_row : slice base.u8
var tile_size_log2 : base.u32[..= 9]
var tiles_per_row : base.u32[..= 16895]
var mask : base.u32
var y : base.u32[..= 0x4000]
var x : base.u32[..= 0x4000]
var t : base.u64
var tile_data : roslice base.u8
var mode : base.u8[..= 0x0F]
var l0 : base.u32[..= 0xFF]
var l1 : base.u32[..= 0xFF]
var l2 : base.u32[..= 0xFF]
var l3 : base.u32[..= 0xFF]
var c0 : base.u32[..= 0xFF]
var c1 : base.u32[..= 0xFF]
var c2 : base.u32[..= 0xFF]
var c3 : base.u32[..= 0xFF]
var t0 : base.u32[..= 0xFF]
var t1 : base.u32[..= 0xFF]
var t2 : base.u32[..= 0xFF]
var t3 : base.u32[..= 0xFF]
var sum_l : base.u32
var sum_t : base.u32
if (this.width <= 0) or (this.height <= 0) {
return nothing
}
w4 = (this.width * 4) as base.u64
curr_row = this.util.empty_slice_u8()
if w4 <= args.pix.length() {
curr_row = args.pix[.. w4]
}
// The first pixel's predictor is mode 0 (opaque black).
if curr_row.length() >= 4 {
curr_row[3] ~mod+= 0xFF
}
// The rest of the first row's predictor is mode 1 (L).
while curr_row.length() >= 8 {
curr_row[4] ~mod+= curr_row[0]
curr_row[5] ~mod+= curr_row[1]
curr_row[6] ~mod+= curr_row[2]
curr_row[7] ~mod+= curr_row[3]
curr_row = curr_row[4 ..]
}
tile_size_log2 = this.transform_tile_size_log2[0] as base.u32
tiles_per_row = (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
mask = ((1 as base.u32) << tile_size_log2) - 1
y = 1
while y < this.height {
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
t = (4 * (y >> tile_size_log2) * tiles_per_row) as base.u64
tile_data = this.util.empty_slice_u8()
if t <= args.tile_data.length() {
tile_data = args.tile_data[t ..]
if tile_data.length() >= 4 {
mode = tile_data[1] & 0x0F
tile_data = tile_data[4 ..]
}
}
if w4 <= args.pix.length() {
prev_row = args.pix
args.pix = args.pix[w4 ..]
curr_row = args.pix
}
// The first column's predictor is mode 2 (T).
if (prev_row.length() >= 4) and (curr_row.length() >= 4) {
curr_row[0] ~mod+= prev_row[0]
curr_row[1] ~mod+= prev_row[1]
curr_row[2] ~mod+= prev_row[2]
curr_row[3] ~mod+= prev_row[3]
}
x = 1
while x < this.width,
inv y < 0x4000,
{
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
if ((x & mask) == 0) and (tile_data.length() >= 4) {
mode = tile_data[1] & 0x0F
tile_data = tile_data[4 ..]
}
if (prev_row.length() < 12) or (curr_row.length() < 8) {
break
}
if mode == 0 { // Opaque black.
curr_row[7] ~mod+= 0xFF
} else if mode == 1 { // L
curr_row[4] ~mod+= curr_row[0]
curr_row[5] ~mod+= curr_row[1]
curr_row[6] ~mod+= curr_row[2]
curr_row[7] ~mod+= curr_row[3]
} else if mode == 2 { // T
curr_row[4] ~mod+= prev_row[4]
curr_row[5] ~mod+= prev_row[5]
curr_row[6] ~mod+= prev_row[6]
curr_row[7] ~mod+= prev_row[7]
} else if mode == 3 { // TR
curr_row[4] ~mod+= prev_row[8]
curr_row[5] ~mod+= prev_row[9]
curr_row[6] ~mod+= prev_row[10]
curr_row[7] ~mod+= prev_row[11]
} else if mode == 4 { // TL
curr_row[4] ~mod+= prev_row[0]
curr_row[5] ~mod+= prev_row[1]
curr_row[6] ~mod+= prev_row[2]
curr_row[7] ~mod+= prev_row[3]
} else if mode == 5 { // Average2(Average2(L, TR), T).
l0 = ((curr_row[0] as base.u32) + (prev_row[8] as base.u32)) / 2
l1 = ((curr_row[1] as base.u32) + (prev_row[9] as base.u32)) / 2
l2 = ((curr_row[2] as base.u32) + (prev_row[10] as base.u32)) / 2
l3 = ((curr_row[3] as base.u32) + (prev_row[11] as base.u32)) / 2
curr_row[4] ~mod+= ((l0 + (prev_row[4] as base.u32)) / 2) as base.u8
curr_row[5] ~mod+= ((l1 + (prev_row[5] as base.u32)) / 2) as base.u8
curr_row[6] ~mod+= ((l2 + (prev_row[6] as base.u32)) / 2) as base.u8
curr_row[7] ~mod+= ((l3 + (prev_row[7] as base.u32)) / 2) as base.u8
} else if mode == 6 { // Average2(L, TL).
curr_row[4] ~mod+= (((curr_row[0] as base.u32) + (prev_row[0] as base.u32)) / 2) as base.u8
curr_row[5] ~mod+= (((curr_row[1] as base.u32) + (prev_row[1] as base.u32)) / 2) as base.u8
curr_row[6] ~mod+= (((curr_row[2] as base.u32) + (prev_row[2] as base.u32)) / 2) as base.u8
curr_row[7] ~mod+= (((curr_row[3] as base.u32) + (prev_row[3] as base.u32)) / 2) as base.u8
} else if mode == 7 { // Average2(L, T).
curr_row[4] ~mod+= (((curr_row[0] as base.u32) + (prev_row[4] as base.u32)) / 2) as base.u8
curr_row[5] ~mod+= (((curr_row[1] as base.u32) + (prev_row[5] as base.u32)) / 2) as base.u8
curr_row[6] ~mod+= (((curr_row[2] as base.u32) + (prev_row[6] as base.u32)) / 2) as base.u8
curr_row[7] ~mod+= (((curr_row[3] as base.u32) + (prev_row[7] as base.u32)) / 2) as base.u8
} else if mode == 8 { // Average2(TL, T).
curr_row[4] ~mod+= (((prev_row[0] as base.u32) + (prev_row[4] as base.u32)) / 2) as base.u8
curr_row[5] ~mod+= (((prev_row[1] as base.u32) + (prev_row[5] as base.u32)) / 2) as base.u8
curr_row[6] ~mod+= (((prev_row[2] as base.u32) + (prev_row[6] as base.u32)) / 2) as base.u8
curr_row[7] ~mod+= (((prev_row[3] as base.u32) + (prev_row[7] as base.u32)) / 2) as base.u8
} else if mode == 9 { // Average2(T, TR).
curr_row[4] ~mod+= (((prev_row[4] as base.u32) + (prev_row[8] as base.u32)) / 2) as base.u8
curr_row[5] ~mod+= (((prev_row[5] as base.u32) + (prev_row[9] as base.u32)) / 2) as base.u8
curr_row[6] ~mod+= (((prev_row[6] as base.u32) + (prev_row[10] as base.u32)) / 2) as base.u8
curr_row[7] ~mod+= (((prev_row[7] as base.u32) + (prev_row[11] as base.u32)) / 2) as base.u8
} else if mode == 10 { // Average2(Average2(L, TL), Average2(T, TR)).
l0 = ((curr_row[0] as base.u32) + (prev_row[0] as base.u32)) / 2
l1 = ((curr_row[1] as base.u32) + (prev_row[1] as base.u32)) / 2
l2 = ((curr_row[2] as base.u32) + (prev_row[2] as base.u32)) / 2
l3 = ((curr_row[3] as base.u32) + (prev_row[3] as base.u32)) / 2
t0 = ((prev_row[4] as base.u32) + (prev_row[8] as base.u32)) / 2
t1 = ((prev_row[5] as base.u32) + (prev_row[9] as base.u32)) / 2
t2 = ((prev_row[6] as base.u32) + (prev_row[10] as base.u32)) / 2
t3 = ((prev_row[7] as base.u32) + (prev_row[11] as base.u32)) / 2
curr_row[4] ~mod+= ((l0 + t0) / 2) as base.u8
curr_row[5] ~mod+= ((l1 + t1) / 2) as base.u8
curr_row[6] ~mod+= ((l2 + t2) / 2) as base.u8
curr_row[7] ~mod+= ((l3 + t3) / 2) as base.u8
} else if mode == 11 { // Select(L, T, TL).
l0 = curr_row[0] as base.u32
l1 = curr_row[1] as base.u32
l2 = curr_row[2] as base.u32
l3 = curr_row[3] as base.u32
c0 = prev_row[0] as base.u32
c1 = prev_row[1] as base.u32
c2 = prev_row[2] as base.u32
c3 = prev_row[3] as base.u32
t0 = prev_row[4] as base.u32
t1 = prev_row[5] as base.u32
t2 = prev_row[6] as base.u32
t3 = prev_row[7] as base.u32
sum_l = this.absolute_difference(a: c0, b: t0) +
this.absolute_difference(a: c1, b: t1) +
this.absolute_difference(a: c2, b: t2) +
this.absolute_difference(a: c3, b: t3)
sum_t = this.absolute_difference(a: c0, b: l0) +
this.absolute_difference(a: c1, b: l1) +
this.absolute_difference(a: c2, b: l2) +
this.absolute_difference(a: c3, b: l3)
if sum_l < sum_t {
curr_row[4] ~mod+= l0 as base.u8
curr_row[5] ~mod+= l1 as base.u8
curr_row[6] ~mod+= l2 as base.u8
curr_row[7] ~mod+= l3 as base.u8
} else {
curr_row[4] ~mod+= t0 as base.u8
curr_row[5] ~mod+= t1 as base.u8
curr_row[6] ~mod+= t2 as base.u8
curr_row[7] ~mod+= t3 as base.u8
}
} else if mode == 12 { // ClampAddSubtractFull(L, T, TL).
curr_row[4] ~mod+= this.mode12(l: curr_row[0], t: prev_row[4], tl: prev_row[0])
curr_row[5] ~mod+= this.mode12(l: curr_row[1], t: prev_row[5], tl: prev_row[1])
curr_row[6] ~mod+= this.mode12(l: curr_row[2], t: prev_row[6], tl: prev_row[2])
curr_row[7] ~mod+= this.mode12(l: curr_row[3], t: prev_row[7], tl: prev_row[3])
} else if mode == 13 { // ClampAddSubtractHalf(Average2(L, T), TL).
curr_row[4] ~mod+= this.mode13(l: curr_row[0], t: prev_row[4], tl: prev_row[0])
curr_row[5] ~mod+= this.mode13(l: curr_row[1], t: prev_row[5], tl: prev_row[1])
curr_row[6] ~mod+= this.mode13(l: curr_row[2], t: prev_row[6], tl: prev_row[2])
curr_row[7] ~mod+= this.mode13(l: curr_row[3], t: prev_row[7], tl: prev_row[3])
}
curr_row = curr_row[4 ..]
prev_row = prev_row[4 ..]
x += 1
}
y += 1
}
}
pri func decoder.absolute_difference(a: base.u32[..= 0xFF], b: base.u32[..= 0xFF]) base.u32[..= 0xFF] {
if args.a < args.b {
assert args.b > args.a via "a > b: b < a"()
return args.b - args.a
}
return args.a - args.b
}
pri func decoder.mode12(l: base.u8, t: base.u8, tl: base.u8) base.u8 {
var v : base.u32
v = ((args.l as base.u32) + (args.t as base.u32)) ~mod- (args.tl as base.u32)
// Return clamp(v), where v is a signed i32.
if v < 256 {
return v as base.u8
} else if v < 512 {
return 255
}
return 0
}
pri func decoder.mode13(l: base.u8, t: base.u8, tl: base.u8) base.u8 {
var x : base.u32[..= 0xFF]
var y : base.u32[..= 0xFF]
var z : base.u32
var v : base.u32
x = ((args.l as base.u32) + (args.t as base.u32)) / 2
y = args.tl as base.u32
// Calculate "v = x + ((x - y) / 2)" but using signed (i32) arithmetic
// instead of unsigned (u32) arithmetic.
z = x ~mod- y
v = x ~mod+ this.util.sign_extend_rshift_u32(a: z ~mod+ (z >> 31), n: 1)
// Return clamp(v), where v is a signed i32.
if v < 256 {
return v as base.u8
} else if v < 512 {
return 255
}
return 0
}
pri func decoder.apply_transform_cross_color!(pix: slice base.u8, tile_data: roslice base.u8) {
var tile_size_log2 : base.u32[..= 9]
var tiles_per_row : base.u32[..= 16895]
var mask : base.u32
var y : base.u32[..= 0x4000]
var x : base.u32[..= 0x4000]
var t : base.u64
var tile_data : roslice base.u8
var g2r : base.u32
var g2b : base.u32
var r2b : base.u32
var b : base.u8
var g : base.u8
var r : base.u8
tile_size_log2 = this.transform_tile_size_log2[1] as base.u32
tiles_per_row = (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
mask = ((1 as base.u32) << tile_size_log2) - 1
y = 0
while y < this.height {
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
t = (4 * (y >> tile_size_log2) * tiles_per_row) as base.u64
tile_data = this.util.empty_slice_u8()
if t <= args.tile_data.length() {
tile_data = args.tile_data[t ..]
}
x = 0
while x < this.width,
inv y < 0x4000,
{
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
if ((x & mask) == 0) and (tile_data.length() >= 4) {
g2r = SIGN_EXTEND_I8_I32[tile_data[0]]
g2b = SIGN_EXTEND_I8_I32[tile_data[1]]
r2b = SIGN_EXTEND_I8_I32[tile_data[2]]
tile_data = tile_data[4 ..]
}
if args.pix.length() >= 4 {
b = args.pix[0]
g = args.pix[1]
r = args.pix[2]
r ~mod+= (((SIGN_EXTEND_I8_I32[g] ~mod* g2r) >> 5) & 0xFF) as base.u8
b ~mod+= (((SIGN_EXTEND_I8_I32[g] ~mod* g2b) >> 5) & 0xFF) as base.u8
b ~mod+= (((SIGN_EXTEND_I8_I32[r] ~mod* r2b) >> 5) & 0xFF) as base.u8
args.pix[0] = b
args.pix[2] = r
args.pix = args.pix[4 ..]
}
x += 1
}
y += 1
}
}
pri func decoder.apply_transform_subtract_green!(pix: slice base.u8) {
var p : slice base.u8
var g : base.u8
iterate (p = args.pix)(length: 4, advance: 4, unroll: 1) {
g = p[1]
p[0] ~mod+= g
p[2] ~mod+= g
}
}
pri func decoder.apply_transform_color_indexing!(pix: slice base.u8) {
var tile_size_log2 : base.u32[..= 9]
var bits_per_pixel : base.u32[..= 8]
var x_mask : base.u32
var s_mask : base.u32[..= 0xFF]
var src_index : base.u64
var y : base.u32[..= 0x4000]
var di : base.u64
var dj : base.u64
var dst : slice base.u8
var x : base.u32
var s : base.u32[..= 0xFF]
var p : base.u32[..= 0x3FC]
var p0 : base.u8
var p1 : base.u8
var p2 : base.u8
var p3 : base.u8
tile_size_log2 = this.transform_tile_size_log2[3] as base.u32
if tile_size_log2 == 0 {
// TODO: the code below is correct, but we could possibly simplify the
// case where the src and dst pixel counts are 1:1.
}
bits_per_pixel = (8 as base.u32) >> tile_size_log2
x_mask = ((1 as base.u32) << tile_size_log2) - 1
s_mask = ((1 as base.u32) << bits_per_pixel) - 1
// The "+ 1" selects the green pixel of the BGRA 4-byte group.
src_index = (this.workbuf_offset_for_color_indexing + 1) as base.u64
y = 0
while y < this.height {
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
di = (4 * (y + 0) * this.width) as base.u64
dj = (4 * (y + 1) * this.width) as base.u64
if (di > dj) or (dj > args.pix.length()) {
break
}
dst = args.pix[di .. dj]
x = 0
while dst.length() >= 4,
inv y < 0x4000,
{
if ((x & x_mask) == 0) and (src_index < args.pix.length()) {
s = args.pix[src_index] as base.u32
src_index ~mod+= 4
}
p = (s & s_mask) * 4
s >>= bits_per_pixel
p0 = this.palette[p + 0]
p1 = this.palette[p + 1]
p2 = this.palette[p + 2]
p3 = this.palette[p + 3]
dst[0] = p0
dst[1] = p1
dst[2] = p2
dst[3] = p3
dst = dst[4 ..]
x ~mod+= 1
}
y += 1
}
}
// TODO: we shouldn't need a lookup table for converting i8 to i32.
pri const SIGN_EXTEND_I8_I32 : roarray[256] base.u32 = [
0x0000_0000, 0x0000_0001, 0x0000_0002, 0x0000_0003, 0x0000_0004, 0x0000_0005, 0x0000_0006, 0x0000_0007,
0x0000_0008, 0x0000_0009, 0x0000_000A, 0x0000_000B, 0x0000_000C, 0x0000_000D, 0x0000_000E, 0x0000_000F,
0x0000_0010, 0x0000_0011, 0x0000_0012, 0x0000_0013, 0x0000_0014, 0x0000_0015, 0x0000_0016, 0x0000_0017,
0x0000_0018, 0x0000_0019, 0x0000_001A, 0x0000_001B, 0x0000_001C, 0x0000_001D, 0x0000_001E, 0x0000_001F,
0x0000_0020, 0x0000_0021, 0x0000_0022, 0x0000_0023, 0x0000_0024, 0x0000_0025, 0x0000_0026, 0x0000_0027,
0x0000_0028, 0x0000_0029, 0x0000_002A, 0x0000_002B, 0x0000_002C, 0x0000_002D, 0x0000_002E, 0x0000_002F,
0x0000_0030, 0x0000_0031, 0x0000_0032, 0x0000_0033, 0x0000_0034, 0x0000_0035, 0x0000_0036, 0x0000_0037,
0x0000_0038, 0x0000_0039, 0x0000_003A, 0x0000_003B, 0x0000_003C, 0x0000_003D, 0x0000_003E, 0x0000_003F,
0x0000_0040, 0x0000_0041, 0x0000_0042, 0x0000_0043, 0x0000_0044, 0x0000_0045, 0x0000_0046, 0x0000_0047,
0x0000_0048, 0x0000_0049, 0x0000_004A, 0x0000_004B, 0x0000_004C, 0x0000_004D, 0x0000_004E, 0x0000_004F,
0x0000_0050, 0x0000_0051, 0x0000_0052, 0x0000_0053, 0x0000_0054, 0x0000_0055, 0x0000_0056, 0x0000_0057,
0x0000_0058, 0x0000_0059, 0x0000_005A, 0x0000_005B, 0x0000_005C, 0x0000_005D, 0x0000_005E, 0x0000_005F,
0x0000_0060, 0x0000_0061, 0x0000_0062, 0x0000_0063, 0x0000_0064, 0x0000_0065, 0x0000_0066, 0x0000_0067,
0x0000_0068, 0x0000_0069, 0x0000_006A, 0x0000_006B, 0x0000_006C, 0x0000_006D, 0x0000_006E, 0x0000_006F,
0x0000_0070, 0x0000_0071, 0x0000_0072, 0x0000_0073, 0x0000_0074, 0x0000_0075, 0x0000_0076, 0x0000_0077,
0x0000_0078, 0x0000_0079, 0x0000_007A, 0x0000_007B, 0x0000_007C, 0x0000_007D, 0x0000_007E, 0x0000_007F,
0xFFFF_FF80, 0xFFFF_FF81, 0xFFFF_FF82, 0xFFFF_FF83, 0xFFFF_FF84, 0xFFFF_FF85, 0xFFFF_FF86, 0xFFFF_FF87,
0xFFFF_FF88, 0xFFFF_FF89, 0xFFFF_FF8A, 0xFFFF_FF8B, 0xFFFF_FF8C, 0xFFFF_FF8D, 0xFFFF_FF8E, 0xFFFF_FF8F,
0xFFFF_FF90, 0xFFFF_FF91, 0xFFFF_FF92, 0xFFFF_FF93, 0xFFFF_FF94, 0xFFFF_FF95, 0xFFFF_FF96, 0xFFFF_FF97,
0xFFFF_FF98, 0xFFFF_FF99, 0xFFFF_FF9A, 0xFFFF_FF9B, 0xFFFF_FF9C, 0xFFFF_FF9D, 0xFFFF_FF9E, 0xFFFF_FF9F,
0xFFFF_FFA0, 0xFFFF_FFA1, 0xFFFF_FFA2, 0xFFFF_FFA3, 0xFFFF_FFA4, 0xFFFF_FFA5, 0xFFFF_FFA6, 0xFFFF_FFA7,
0xFFFF_FFA8, 0xFFFF_FFA9, 0xFFFF_FFAA, 0xFFFF_FFAB, 0xFFFF_FFAC, 0xFFFF_FFAD, 0xFFFF_FFAE, 0xFFFF_FFAF,
0xFFFF_FFB0, 0xFFFF_FFB1, 0xFFFF_FFB2, 0xFFFF_FFB3, 0xFFFF_FFB4, 0xFFFF_FFB5, 0xFFFF_FFB6, 0xFFFF_FFB7,
0xFFFF_FFB8, 0xFFFF_FFB9, 0xFFFF_FFBA, 0xFFFF_FFBB, 0xFFFF_FFBC, 0xFFFF_FFBD, 0xFFFF_FFBE, 0xFFFF_FFBF,
0xFFFF_FFC0, 0xFFFF_FFC1, 0xFFFF_FFC2, 0xFFFF_FFC3, 0xFFFF_FFC4, 0xFFFF_FFC5, 0xFFFF_FFC6, 0xFFFF_FFC7,
0xFFFF_FFC8, 0xFFFF_FFC9, 0xFFFF_FFCA, 0xFFFF_FFCB, 0xFFFF_FFCC, 0xFFFF_FFCD, 0xFFFF_FFCE, 0xFFFF_FFCF,
0xFFFF_FFD0, 0xFFFF_FFD1, 0xFFFF_FFD2, 0xFFFF_FFD3, 0xFFFF_FFD4, 0xFFFF_FFD5, 0xFFFF_FFD6, 0xFFFF_FFD7,
0xFFFF_FFD8, 0xFFFF_FFD9, 0xFFFF_FFDA, 0xFFFF_FFDB, 0xFFFF_FFDC, 0xFFFF_FFDD, 0xFFFF_FFDE, 0xFFFF_FFDF,
0xFFFF_FFE0, 0xFFFF_FFE1, 0xFFFF_FFE2, 0xFFFF_FFE3, 0xFFFF_FFE4, 0xFFFF_FFE5, 0xFFFF_FFE6, 0xFFFF_FFE7,
0xFFFF_FFE8, 0xFFFF_FFE9, 0xFFFF_FFEA, 0xFFFF_FFEB, 0xFFFF_FFEC, 0xFFFF_FFED, 0xFFFF_FFEE, 0xFFFF_FFEF,
0xFFFF_FFF0, 0xFFFF_FFF1, 0xFFFF_FFF2, 0xFFFF_FFF3, 0xFFFF_FFF4, 0xFFFF_FFF5, 0xFFFF_FFF6, 0xFFFF_FFF7,
0xFFFF_FFF8, 0xFFFF_FFF9, 0xFFFF_FFFA, 0xFFFF_FFFB, 0xFFFF_FFFC, 0xFFFF_FFFD, 0xFFFF_FFFE, 0xFFFF_FFFF,
]
+856
View File
@@ -0,0 +1,856 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
use "std/vp8"
pub status "#bad Huffman code (over-subscribed)"
pub status "#bad Huffman code (under-subscribed)"
pub status "#bad Huffman code"
pub status "#bad back-reference"
pub status "#bad color cache"
pub status "#bad header"
pub status "#bad transform"
pub status "#short chunk"
pub status "#truncated input"
pub status "#unsupported number of Huffman groups"
pub status "#unsupported transform after color indexing transform"
pub status "#unsupported WebP file"
pri status "#internal error: inconsistent Huffman code"
pri status "#internal error: inconsistent dst buffer"
pri status "#internal error: inconsistent n_bits"
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
pub struct decoder? implements base.image_decoder(
pixfmt : base.u32,
width : base.u32[..= 0x4000],
height : base.u32[..= 0x4000],
// The call sequence state machine is discussed in
// (/doc/std/image-decoders-call-sequence.md).
call_sequence : base.u8,
code_length_code_lengths : array[19] base.u8[..= 7],
sub_chunk_has_padding : base.bool,
frame_config_io_position : base.u64,
riff_chunk_length : base.u32,
sub_chunk_length : base.u32,
bits : base.u32,
n_bits : base.u32[..= 31],
seen_transform : array[4] base.bool,
transform_type : array[4] base.u8[..= 3],
transform_tile_size_log2 : array[4] base.u8[..= 9],
n_transforms : base.u32[..= 4],
color_cache_bits : base.u32[..= 11],
overall_color_cache_bits : base.u32[..= 11],
overall_tile_size_log2 : base.u32[..= 9],
overall_n_huffman_groups : base.u32[..= 256],
ht_n_symbols : base.u32[..= 2328],
ht_code_lengths_remaining : base.u32,
color_indexing_palette_size : base.u32[..= 256],
color_indexing_width : base.u32[..= 0x4000],
// The 0th element is for the Meta (Huffman Group) selectors.
// The 1st element is for the Predictor transform.
// The 2nd element is for the Cross Color transform.
// The 3rd element is overall workbuf length.
workbuf_offset_for_transform : array[4] base.u32[..= 0x4C00_0000],
// If the Color Indexing transform is present then workbuf[i .. j]
// holds the pre-transformed pixel data (the Green component of the
// pixel's bgra data holds color indexes) and workbuf[0 .. j] holds the
// post-transformed data:
//
// - i is workbuf_offset_for_color_indexing
// - j is workbuf_offset_for_transform[0]
//
// i is calculated as:
//
// - if there are 8 bits per color index then i is 0.
// - if there are 4 bits per color index then i is j*1/2, roughly.
// - if there are 2 bits per color index then i is j*3/4, roughly.
// - if there are 1 bits per color index then i is j*7/8, roughly.
//
// The two slices (workbuf[i .. j] and workbuf[0 .. j]) overlap.
// apply_transform_color_indexing modifies the pixel buffer in-place.
workbuf_offset_for_color_indexing : base.u32[..= 0x4000_0000],
swizzler : base.pixel_swizzler,
util : base.utility,
) + (
palette : array[4 * 256] base.u8,
color_cache : array[2048] base.u32,
codes : array[2328] base.u16,
code_lengths : array[2328] base.u16,
// Each node is a base.u16 whose bit patterns are:
//
// - 0000_0000_0000_0000 Invalid.
// - 0CCC_CCCC_CCCC_CCCC Branch node (children_offset is CCC).
// - 1SSS_SSSS_SSSS_SSSS Leaf node (symbol is SSS, it may be zero).
code_lengths_huffman_nodes : array[37] base.u16,
// A Huffman group has five (5) Huffman trees.
//
// Start .. End Size
// 0x064C .. 0x187B 0x122F (1) Green, back-ref length, color cache.
// 0x0000 .. 0x01FF 0x01FF (2) Red.
// 0x01FF .. 0x03FE 0x01FF (3) Blue.
// 0x03FE .. 0x05FD 0x01FF (4) Alpha.
// 0x05FD .. 0x064C 0x004F (5) Back-ref distance.
//
// The Green+etc tree is last (in terms of start offset) because it's
// by far the largest (worst case) and its color cache component has
// variable length.
//
// 0x122F = 4655 = ((2 * 2328) - 1) and the same 2328 turns up in func
// decoder.decode_huffman_tree.
//
// 2328 is (256 + 24 + 2048), combining 256 Green values, 24 back-ref
// lengths and up to 2048 = (1 << 11) color cache keys.
//
// 0x01FF = 511 = ((2 * 256) - 1) is for 256 Red (Blue, Alpha) values.
//
// 0x004F = 79 = ((2 * 40) - 1) is for 40 back-ref distances.
//
// 0x187B = 6267 and (0x187B * sizeof(u16)) = 12534. Overall, this
// field takes 0x30_F600 = 3_208704 bytes of memory.
//
// The base.u16's bits are the same as for code_lengths_huffman_nodes.
huffman_nodes : array[256] array[0x187B] base.u16,
)
pub func decoder.get_quirk(key: base.u32) base.u64 {
return 0
}
pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
return base."#unsupported option"
}
pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
var status : base.status
while true {
status =? this.do_decode_image_config?(dst: args.dst, src: args.src)
if (status == base."$short read") and args.src.is_closed() {
return "#truncated input"
}
yield? status
}
}
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
var c32 : base.u32
var r_mark : base.u64
var status : base.status
if this.call_sequence <> 0x00 {
return base."#bad call sequence"
}
c32 = args.src.read_u32le?()
if c32 <> 'RIFF'le {
return "#bad header"
}
this.riff_chunk_length = args.src.read_u32le?()
if (this.riff_chunk_length & 1) <> 0 {
return "#bad header"
}
while true {
io_limit (io: args.src, limit: this.riff_chunk_length as base.u64) {
r_mark = args.src.mark()
status =? this.do_decode_image_config_limited?(src: args.src)
this.riff_chunk_length ~sat-=
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
}
if status.is_ok() {
break
} else if not status.is_suspension() {
return status
} else if (status == base."$short read") and (this.riff_chunk_length == 0) {
return "#short chunk"
}
yield? status
}
this.frame_config_io_position = args.src.position()
if args.dst <> nullptr {
args.dst.set!(
pixfmt: this.pixfmt,
pixsub: 0,
width: this.width,
height: this.height,
first_frame_io_position: this.frame_config_io_position,
first_frame_is_opaque: false)
}
this.call_sequence = 0x20
}
pri func decoder.do_decode_image_config_limited?(src: base.io_reader) {
var c32 : base.u32
var r_mark : base.u64
var status : base.status
c32 = args.src.read_u32le?()
if c32 <> 'WEBP'le {
return "#bad header"
}
c32 = args.src.read_u32le?()
if c32 == 'VP8 'le {
return "#unsupported WebP file"
} else if c32 == 'VP8L'le {
this.sub_chunk_length = args.src.read_u32le?()
if this.sub_chunk_length < 4 {
return "#bad header"
}
this.sub_chunk_has_padding = (this.sub_chunk_length & 1) <> 0
while true {
io_limit (io: args.src, limit: this.sub_chunk_length as base.u64) {
r_mark = args.src.mark()
status =? this.do_decode_image_config_limited_vp8l?(src: args.src)
this.sub_chunk_length ~sat-=
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
}
if status.is_ok() {
break
} else if not status.is_suspension() {
return status
} else if (status == base."$short read") and (this.sub_chunk_length == 0) {
return "#short chunk"
}
yield? status
}
} else if c32 == 'VP8X'le {
return "#unsupported WebP file"
} else {
return "#bad header"
}
}
pri func decoder.do_decode_image_config_limited_vp8l?(src: base.io_reader) {
var c32 : base.u32
var transform_size : base.u32[..= 0x400_0000]
c32 = args.src.read_u8_as_u32?()
if c32 <> 0x2F {
return "#bad header"
}
c32 = args.src.read_u32le?()
this.width = (c32 & 0x3FFF) + 1
c32 >>= 14
this.height = (c32 & 0x3FFF) + 1
c32 >>= 14
this.pixfmt = base.PIXEL_FORMAT__BGRX
if (c32 & 1) <> 0 {
this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
}
c32 >>= 1
if c32 <> 0 {
return "#bad header"
}
transform_size = 4 * ((this.width + 3) >> 2) * ((this.height + 3) >> 2)
this.workbuf_offset_for_transform[0] = (4 * this.width * this.height) + (0 * transform_size)
this.workbuf_offset_for_transform[1] = (4 * this.width * this.height) + (1 * transform_size)
this.workbuf_offset_for_transform[2] = (4 * this.width * this.height) + (2 * transform_size)
this.workbuf_offset_for_transform[3] = (4 * this.width * this.height) + (3 * transform_size)
}
pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
var status : base.status
while true {
status =? this.do_decode_frame_config?(dst: args.dst, src: args.src)
if (status == base."$short read") and args.src.is_closed() {
return "#truncated input"
}
yield? status
}
}
pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
if this.call_sequence == 0x20 {
// No-op.
} else if this.call_sequence < 0x20 {
this.do_decode_image_config?(dst: nullptr, src: args.src)
} else if this.call_sequence == 0x28 {
if this.frame_config_io_position <> args.src.position() {
return base."#bad restart"
}
} else if this.call_sequence == 0x40 {
this.call_sequence = 0x60
return base."@end of data"
} else {
return base."@end of data"
}
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,
io_position: this.frame_config_io_position,
disposal: 0,
opaque_within_bounds: false,
overwrite_instead_of_blend: false,
background_color: 0x0000_0000)
}
this.call_sequence = 0x40
}
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 status : base.status
while true {
status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
if (status == base."$short read") and args.src.is_closed() {
return "#truncated input"
}
yield? status
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
var c8 : base.u8
var has_more : base.u32[..= 1]
var width : base.u32[..= 0x4000]
var dst : slice base.u8
var tile_data : roslice base.u8
var status : base.status
var pix : slice base.u8
var which : base.u32[..= 4]
var transform_type : base.u32[..= 3]
var ti : base.u64
var tj : base.u64
if this.call_sequence == 0x40 {
// No-op.
} else if this.call_sequence < 0x40 {
this.do_decode_frame_config?(dst: nullptr, src: args.src)
} else {
return base."@end of data"
}
this.seen_transform[0] = false
this.seen_transform[1] = false
this.seen_transform[2] = false
this.seen_transform[3] = false
this.n_transforms = 0
while true {
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
has_more = this.bits & 1
this.bits >>= 1
this.n_bits -= 1
if has_more == 0 {
break
}
this.decode_transform?(src: args.src, workbuf: args.workbuf)
}
width = this.width
if this.seen_transform[3] {
width = this.color_indexing_width
}
this.decode_color_cache_parameters?(src: args.src)
this.overall_color_cache_bits = this.color_cache_bits
this.decode_hg_table?(src: args.src, width: width, workbuf: args.workbuf)
this.color_cache_bits = this.overall_color_cache_bits
this.decode_huffman_groups?(src: args.src, n_huffman_groups: this.overall_n_huffman_groups)
while true {
if ((this.workbuf_offset_for_color_indexing as base.u64) > (this.workbuf_offset_for_transform[0] as base.u64)) or
((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) or
((this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length()) {
return base."#bad workbuf length"
}
dst = args.workbuf[
(this.workbuf_offset_for_color_indexing as base.u64) ..
(this.workbuf_offset_for_transform[0] as base.u64)]
tile_data = args.workbuf[
(this.workbuf_offset_for_transform[0] as base.u64) ..
(this.workbuf_offset_for_transform[1] as base.u64)]
status =? this.decode_pixels?(
dst: dst,
src: args.src,
width: width,
height: this.height,
tile_data: tile_data,
tile_size_log2: this.overall_tile_size_log2)
if status.is_ok() {
break
}
yield? status
}
if (this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length() {
return base."#bad workbuf length"
}
pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)]
which = this.n_transforms
while which > 0 {
which -= 1
transform_type = this.transform_type[which] as base.u32
tile_data = this.util.empty_slice_u8()
if transform_type < 2 {
ti = this.workbuf_offset_for_transform[transform_type + 1] as base.u64
tj = this.workbuf_offset_for_transform[transform_type + 2] as base.u64
if (ti <= tj) and (tj <= args.workbuf.length()) {
tile_data = args.workbuf[ti .. tj]
}
}
if transform_type == 0 {
this.apply_transform_predictor!(pix: pix, tile_data: tile_data)
} else if transform_type == 1 {
this.apply_transform_cross_color!(pix: pix, tile_data: tile_data)
} else if transform_type == 2 {
this.apply_transform_subtract_green!(pix: pix)
} else {
this.apply_transform_color_indexing!(pix: pix)
width = this.width
}
}
status = this.swizzle!(
dst: args.dst,
src: pix,
blend: args.blend)
if not status.is_ok() {
return status
}
this.call_sequence = 0x60
}
pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) {
var c8 : base.u8
var transform_type : base.u32[..= 3]
var tile_size_log2 : base.u32[..= 9]
var p : slice base.u8
if this.n_bits < 2 {
c8 = args.src.read_u8?()
if this.n_bits >= 2 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 2
}
transform_type = this.bits & 3
this.bits >>= 2
this.n_bits -= 2
if this.seen_transform[transform_type] or (this.n_transforms >= 4) {
return "#bad transform"
} else if this.seen_transform[3] {
return "#unsupported transform after color indexing transform"
}
this.seen_transform[transform_type] = true
this.transform_type[this.n_transforms] = transform_type as base.u8
this.n_transforms += 1
if transform_type < 2 { // Predictor, Cross Color transform.
if this.n_bits < 3 {
c8 = args.src.read_u8?()
if this.n_bits >= 3 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 3
}
tile_size_log2 = (this.bits & 7) + 2
this.transform_tile_size_log2[transform_type] = tile_size_log2 as base.u8
this.bits >>= 3
this.n_bits -= 3
this.decode_color_cache_parameters?(src: args.src)
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or
((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) {
return base."#bad workbuf length"
}
this.decode_pixels?(
dst: args.workbuf[
(this.workbuf_offset_for_transform[transform_type + 1] as base.u64) ..
(this.workbuf_offset_for_transform[transform_type + 2] as base.u64)],
src: args.src,
width: (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
tile_data: this.util.empty_slice_u8(),
tile_size_log2: 0)
} else if transform_type == 2 { // Subtract Green transform.
// No-op.
} else { // Color Indexing transform.
if this.n_bits < 8 {
c8 = args.src.read_u8?()
if this.n_bits >= 8 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 8
}
this.color_indexing_palette_size = (this.bits & 0xFF) + 1
this.bits >>= 8
this.n_bits -= 8
if this.color_indexing_palette_size <= 2 {
this.color_indexing_width = (this.width + 7) / 8
this.transform_tile_size_log2[3] = 3
} else if this.color_indexing_palette_size <= 4 {
this.color_indexing_width = (this.width + 3) / 4
this.transform_tile_size_log2[3] = 2
} else if this.color_indexing_palette_size <= 16 {
this.color_indexing_width = (this.width + 1) / 2
this.transform_tile_size_log2[3] = 1
} else {
this.color_indexing_width = this.width
this.transform_tile_size_log2[3] = 0
}
if this.width >= this.color_indexing_width {
this.workbuf_offset_for_color_indexing = 4 * (this.width - this.color_indexing_width) * this.height
}
this.decode_color_cache_parameters?(src: args.src)
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
this.decode_pixels?(
dst: this.palette[.. 4 * this.color_indexing_palette_size],
src: args.src,
width: this.color_indexing_palette_size,
height: 1,
tile_data: this.util.empty_slice_u8(),
tile_size_log2: 0)
this.palette[4 * this.color_indexing_palette_size .. 1024].bulk_memset!(byte_value: 0)
p = this.palette[.. 4 * this.color_indexing_palette_size]
while p.length() >= 8 {
p[4] ~mod+= p[0]
p[5] ~mod+= p[1]
p[6] ~mod+= p[2]
p[7] ~mod+= p[3]
p = p[4 ..]
}
}
}
pri func decoder.decode_color_cache_parameters?(src: base.io_reader) {
var c8 : base.u8
var use_color_cache : base.u32[..= 1]
var color_cache_bits : base.u32[..= 15]
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
use_color_cache = this.bits & 1
this.bits >>= 1
this.n_bits -= 1
this.color_cache_bits = 0
if use_color_cache <> 0 {
if this.n_bits < 4 {
c8 = args.src.read_u8?()
if this.n_bits >= 4 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 4
}
color_cache_bits = this.bits & 15
this.bits >>= 4
this.n_bits -= 4
if (color_cache_bits < 1) or (11 < color_cache_bits) {
return "#bad color cache"
}
this.color_cache_bits = color_cache_bits
}
}
pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) {
var c8 : base.u8
var use_hg_table : base.u32[..= 1]
var tile_size_log2 : base.u32[..= 9]
var hg_pixels : slice base.u8
var n : base.u64
var p : roslice base.u8
var hg_plus_1 : base.u32[..= 256]
if this.n_bits < 1 {
c8 = args.src.read_u8?()
this.bits = (c8 as base.u32)
this.n_bits = 8
assert this.n_bits >= 1
}
use_hg_table = this.bits & 1
this.bits >>= 1
this.n_bits -= 1
if use_hg_table == 0 {
this.overall_n_huffman_groups = 1
this.overall_tile_size_log2 = 0
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
return base."#bad workbuf length"
}
hg_pixels = args.workbuf[
this.workbuf_offset_for_transform[0] as base.u64 ..
this.workbuf_offset_for_transform[1] as base.u64]
if hg_pixels.length() >= 4 {
hg_pixels[0] = 0x00
hg_pixels[1] = 0x00
hg_pixels[2] = 0x00
hg_pixels[3] = 0x00
}
return ok
}
if this.n_bits < 3 {
c8 = args.src.read_u8?()
if this.n_bits >= 3 {
return "#internal error: inconsistent n_bits"
}
this.bits |= (c8 as base.u32) << this.n_bits
this.n_bits += 8
assert this.n_bits >= 3
}
tile_size_log2 = (this.bits & 7) + 2
this.bits >>= 3
this.n_bits -= 3
this.overall_tile_size_log2 = tile_size_log2
this.decode_color_cache_parameters?(src: args.src)
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1)
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
return base."#bad workbuf length"
}
this.decode_pixels?(
dst: args.workbuf[
(this.workbuf_offset_for_transform[0] as base.u64) ..
(this.workbuf_offset_for_transform[1] as base.u64)],
src: args.src,
width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
tile_data: this.util.empty_slice_u8(),
tile_size_log2: 0)
this.overall_n_huffman_groups = 1
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
return base."#bad workbuf length"
}
hg_pixels = args.workbuf[
this.workbuf_offset_for_transform[0] as base.u64 ..
this.workbuf_offset_for_transform[1] as base.u64]
n = (((args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
((this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) *
4) as base.u64
if n > hg_pixels.length() {
return base."#bad workbuf length"
}
p = hg_pixels[.. n]
while p.length() >= 4 {
if p[2] <> 0 {
return "#unsupported number of Huffman groups"
}
hg_plus_1 = (p[1] as base.u32) + 1
if this.overall_n_huffman_groups < hg_plus_1 {
this.overall_n_huffman_groups = hg_plus_1
}
p = p[4 ..]
}
}
pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) {
var i : base.u32
var n : base.u32[..= 2048]
i = 0
n = (1 as base.u32) << this.color_cache_bits
while i < n {
assert i < 2048 via "a < b: a < c; c <= b"(c: n)
this.color_cache[i] = 0
i += 1
}
this.decode_pixels_slow?(
dst: args.dst,
src: args.src,
width: args.width,
height: args.height,
tile_data: args.tile_data,
tile_size_log2: args.tile_size_log2)
}
pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: roslice base.u8, blend: base.pixel_blend) base.status {
var status : base.status
var dst_pixfmt : base.pixel_format
var dst_bits_per_pixel : base.u32[..= 256]
var dst_bytes_per_pixel : base.u32[..= 32]
var dst_bytes_per_row : base.u64
var dst_palette : slice base.u8
var tab : table base.u8
var src_bytes_per_row : base.u64
var dst : slice base.u8
var y : base.u32
status = this.swizzler.prepare!(
dst_pixfmt: args.dst.pixel_format(),
dst_palette: args.dst.palette_or_else(fallback: this.palette[..]),
src_pixfmt: this.util.make_pixel_format(repr: this.pixfmt),
src_palette: this.util.empty_slice_u8(),
blend: args.blend)
if not status.is_ok() {
return status
}
// TODO: the dst_pixfmt variable shouldn't be necessary. We should be able
// to chain the two calls: "args.dst.pixel_format().bits_per_pixel()".
dst_pixfmt = args.dst.pixel_format()
dst_bits_per_pixel = dst_pixfmt.bits_per_pixel()
if (dst_bits_per_pixel & 7) <> 0 {
return base."#unsupported option"
}
dst_bytes_per_pixel = dst_bits_per_pixel / 8
dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64
dst_palette = args.dst.palette_or_else(fallback: this.palette[..])
tab = args.dst.plane(p: 0)
src_bytes_per_row = (this.width * 4) as base.u64
while src_bytes_per_row <= args.src.length() {
dst = tab.row_u32(y: y)
if dst_bytes_per_row < dst.length() {
dst = dst[.. dst_bytes_per_row]
}
this.swizzler.swizzle_interleaved_from_slice!(
dst: dst,
dst_palette: dst_palette,
src: args.src[.. src_bytes_per_row])
args.src = args.src[src_bytes_per_row ..]
y ~mod+= 1
}
return ok
}
pub func decoder.frame_dirty_rect() base.rect_ie_u32 {
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)
}
pub func decoder.num_animation_loops() base.u32 {
return 0
}
pub func decoder.num_decoded_frame_configs() base.u64 {
if this.call_sequence > 0x20 {
return 1
}
return 0
}
pub func decoder.num_decoded_frames() base.u64 {
if this.call_sequence > 0x40 {
return 1
}
return 0
}
pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
if this.call_sequence < 0x20 {
return base."#bad call sequence"
}
if (args.index <> 0) or (args.io_position <> this.frame_config_io_position) {
return base."#bad argument"
}
this.call_sequence = 0x28
return ok
}
pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
// No-op.
}
pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
return base."#no more information"
}
pub func decoder.workbuf_len() base.range_ii_u64 {
return this.util.make_range_ii_u64(
min_incl: this.workbuf_offset_for_transform[3] as base.u64,
max_incl: this.workbuf_offset_for_transform[3] as base.u64)
}
pri const DISTANCE_MAP : roarray[120] base.u8 = [
0x18, 0x07, 0x17, 0x19, 0x28, 0x06, 0x27, 0x29, 0x16, 0x1A,
0x26, 0x2A, 0x38, 0x05, 0x37, 0x39, 0x15, 0x1B, 0x36, 0x3A,
0x25, 0x2B, 0x48, 0x04, 0x47, 0x49, 0x14, 0x1C, 0x35, 0x3B,
0x46, 0x4A, 0x24, 0x2C, 0x58, 0x45, 0x4B, 0x34, 0x3C, 0x03,
0x57, 0x59, 0x13, 0x1D, 0x56, 0x5A, 0x23, 0x2D, 0x44, 0x4C,
0x55, 0x5B, 0x33, 0x3D, 0x68, 0x02, 0x67, 0x69, 0x12, 0x1E,
0x66, 0x6A, 0x22, 0x2E, 0x54, 0x5C, 0x43, 0x4D, 0x65, 0x6B,
0x32, 0x3E, 0x78, 0x01, 0x77, 0x79, 0x53, 0x5D, 0x11, 0x1F,
0x64, 0x6C, 0x42, 0x4E, 0x76, 0x7A, 0x21, 0x2F, 0x75, 0x7B,
0x31, 0x3F, 0x63, 0x6D, 0x52, 0x5E, 0x00, 0x74, 0x7C, 0x41,
0x4F, 0x10, 0x20, 0x62, 0x6E, 0x30, 0x73, 0x7D, 0x51, 0x5F,
0x40, 0x72, 0x7E, 0x61, 0x6F, 0x50, 0x71, 0x7F, 0x60, 0x70,
]
+3 -3
View File
@@ -69,7 +69,7 @@ pub func hasher.update!(x: roslice base.u8) {
this.up!(x: args.x)
args.x = remaining
} endwhile
}
}
pub func hasher.update_u32!(x: roslice base.u8) base.u32 {
@@ -135,7 +135,7 @@ pri func hasher.up!(x: roslice base.u8) {
this.buf_data[this.buf_len] = args.x[0]
this.buf_len += 1
args.x = args.x[1 ..]
} endwhile
}
buf_len = (this.buf_len & 15) as base.u32
v0 = this.v0
@@ -249,7 +249,7 @@ pub func hasher.checksum_u32() base.u32 {
ret ~mod*= XXH_PRIME32_1
i += 1
} endwhile
}
ret ^= ret >> 15
ret ~mod*= XXH_PRIME32_2
+2 -2
View File
@@ -138,7 +138,7 @@ pri func hasher.up!(x: roslice base.u8) {
this.buf_data[this.buf_len] = args.x[0]
this.buf_len += 1
args.x = args.x[1 ..]
} endwhile
}
buf_len = this.buf_len & 31
v0 = this.v0
@@ -330,7 +330,7 @@ pub func hasher.checksum_u64() base.u64 {
ret ~mod*= XXH_PRIME64_1
i += 1
} endwhile
}
ret ^= ret >> 33
ret ~mod*= XXH_PRIME64_2
+15 -15
View File
@@ -37,7 +37,7 @@ pri func decoder.apply_non_final_filters!(dst_slice: slice base.u8) base.u8,
delta_pos ~mod-= 1
args.dst_slice[i] = c8
i += 1
} endwhile
}
this.filters[f] &= 0xFFFF
this.filters[f] |= (delta_pos ~mod<< 24)
}
@@ -46,7 +46,7 @@ pri func decoder.apply_non_final_filters!(dst_slice: slice base.u8) base.u8,
break
}
f -= 1
} endwhile
}
return 0
}
@@ -145,7 +145,7 @@ pri func decoder.apply_filter_04_x86!(dst_slice: slice base.u8) base.u8 {
break
}
src = dst ^ FILTER_04_X86_MASK_TO_XOR_OPERAND[prev_mask & 7]
} endwhile
}
dst &= 0x01FF_FFFF
dst |= 0 ~mod- (dst & 0x0100_0000)
@@ -157,7 +157,7 @@ pri func decoder.apply_filter_04_x86!(dst_slice: slice base.u8) base.u8 {
i ~mod+= 5
p ~mod+= 5
s = s[5 ..]
} endwhile
}
prev_pos = i ~mod- prev_pos
if prev_pos > 3 {
@@ -194,7 +194,7 @@ pri func decoder.apply_filter_05_powerpc!(dst_slice: slice base.u8) base.u8 {
}
p ~mod+= 4
s = s[4 ..]
} endwhile
}
this.bcj_pos = p
return s.length() as base.u8
@@ -250,7 +250,7 @@ pri func decoder.apply_filter_06_ia64!(dst_slice: slice base.u8) base.u8 {
{
x |= (s[j + byte_pos] as base.u64) << (8 * j)
j += 1
} endwhile
}
norm = x >> bit_res
if (((norm >> 37) & 0x0F) <> 0x05) or
@@ -276,20 +276,20 @@ pri func decoder.apply_filter_06_ia64!(dst_slice: slice base.u8) base.u8 {
{
s[j + byte_pos] = ((x >> (8 * j)) & 0xFF) as base.u8
j += 1
} endwhile
}
break.goto_done
}} endwhile.goto_done
}}.goto_done
if slot >= 2 {
break
}
slot += 1
} endwhile
}
p ~mod+= 16
s = s[16 ..]
} endwhile
}
this.bcj_pos = p
return s.length() as base.u8
@@ -318,7 +318,7 @@ pri func decoder.apply_filter_07_arm!(dst_slice: slice base.u8) base.u8 {
}
p ~mod+= 4
s = s[4 ..]
} endwhile
}
this.bcj_pos = p ~mod- 8
return s.length() as base.u8
@@ -356,7 +356,7 @@ pri func decoder.apply_filter_08_armthumb!(dst_slice: slice base.u8) base.u8 {
s[3] = (((y >> 0x08) & 0x07) | 0xF8) as base.u8
p ~mod+= 4
s = s[4 ..]
} endwhile
}
this.bcj_pos = p ~mod- 4
return s.length() as base.u8
@@ -387,7 +387,7 @@ pri func decoder.apply_filter_09_sparc!(dst_slice: slice base.u8) base.u8 {
}
p ~mod+= 4
s = s[4 ..]
} endwhile
}
this.bcj_pos = p
return s.length() as base.u8
@@ -435,7 +435,7 @@ pri func decoder.apply_filter_0a_arm64!(dst_slice: slice base.u8) base.u8 {
}
p ~mod+= 4
s = s[4 ..]
} endwhile
}
this.bcj_pos = p
return s.length() as base.u8
@@ -537,7 +537,7 @@ pri func decoder.apply_filter_0b_riscv!(dst_slice: slice base.u8) base.u8 {
p ~mod+= 2
s = s[2 ..]
} endwhile
}
this.bcj_pos = p
return s.length() as base.u8
+50 -23
View File
@@ -17,6 +17,7 @@ use "std/crc64"
use "std/lzma"
use "std/sha256"
pub status "#bad BCJ offset"
pub status "#bad block header"
pub status "#bad checksum"
pub status "#bad filter"
@@ -144,7 +145,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
@@ -221,7 +222,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
checksum32_want = args.src.read_u32le?()
if this.ignore_checksum {
@@ -272,7 +273,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
i8 -= 1
} endwhile
}
}
}
compressed_size ~mod+= args.src.count_since(mark: smark)
@@ -291,7 +292,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
if (this.block_has_compressed_size and (this.block_compressed_size <> compressed_size)) or
(this.block_has_uncompressed_size and (this.block_uncompressed_size <> uncompressed_size)) {
@@ -341,7 +342,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
return "#bad padding"
}
compressed_size ~mod+= 1
} endwhile
}
this.lzma_needs_reset = true
@@ -381,7 +382,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
return "#bad checksum"
}
}
} endwhile.blocks
}.blocks
// Verify the index.
this.backwards_size = 0
@@ -399,7 +400,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
if not this.ignore_checksum {
this.crc32.update!(x: ZEROES[.. 3 & (0 ~mod- (3 & this.backwards_size))])
}
@@ -409,7 +410,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
return "#bad index"
}
this.backwards_size ~mod+= 1
} endwhile
}
this.backwards_size >>= 2
if (this.backwards_size == 0) or (this.backwards_size > 0xFFFF_FFFF) {
return "#bad index"
@@ -435,7 +436,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
if (not this.ignore_checksum) and (checksum32_want <> this.crc32.checksum_u32()) {
return "#bad checksum"
}
@@ -461,7 +462,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
}
}
yield? base."$short read"
} endwhile
}
c32 = args.src.peek_u32le()
if c32 == '\xFD\x37\x7A\x58'le {
@@ -470,9 +471,9 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
return "#bad header (concatenated stream)"
}
args.src.skip_u32_fast!(actual: 4, worst_case: 4)
} endwhile.stream_padding
}.stream_padding
this.started_verify_index = false
} endwhile.streams
}.streams
}
pri func decoder.decode_block_header_with_padding?(src: base.io_reader) {
@@ -493,7 +494,7 @@ pri func decoder.decode_block_header_with_padding?(src: base.io_reader) {
break
}
yield? status
} endwhile
}
if padded_size_have > padded_size_want {
return "#bad block header"
@@ -507,11 +508,13 @@ pri func decoder.decode_block_header_with_padding?(src: base.io_reader) {
}
padded_size_have += 1
} endwhile
}
}
pri func decoder.decode_block_header_sans_padding?(src: base.io_reader) {
var c8 : base.u8
var c32 : base.u32
var alignment : base.u32
var flags : base.u8
var filter_id : base.u8
var status : base.status
@@ -546,7 +549,7 @@ pri func decoder.decode_block_header_sans_padding?(src: base.io_reader) {
}
this.block_compressed_size |= (1 as base.u64) << 63
break
} endwhile
}
}
this.block_has_uncompressed_size = (flags & 0x80) <> 0
@@ -570,7 +573,7 @@ pri func decoder.decode_block_header_sans_padding?(src: base.io_reader) {
}
this.block_uncompressed_size |= (1 as base.u64) << 63
break
} endwhile
}
}
// Configure the non-final filters.
@@ -600,7 +603,7 @@ pri func decoder.decode_block_header_sans_padding?(src: base.io_reader) {
{
this.filter_data[f][k] = 0x00
k += 1
} endwhile
}
} else if (filter_id < 0x03) or (0x0B < filter_id) {
return "#unsupported filter"
@@ -633,14 +636,21 @@ pri func decoder.decode_block_header_sans_padding?(src: base.io_reader) {
if c8 == 0x00 {
this.bcj_pos = 0
} else if c8 == 0x04 {
this.bcj_pos = args.src.read_u32le?()
c32 = args.src.read_u32le?()
alignment = BCJ_OFFSET_ALIGNMENT[filter_id] as base.u32
if alignment > 0 {
if (c32 % alignment) <> 0 {
return "#bad BCJ offset"
}
}
this.bcj_pos = c32
} else {
return "#unsupported filter"
}
}
f += 1
} endwhile
}
// Configure the final filter (which must be LZMA2).
@@ -701,7 +711,7 @@ pri func decoder.verify_index?(src: base.io_reader) {
}
this.num_index_blocks |= (1 as base.u64) << 63
break
} endwhile
}
if this.num_index_blocks <> this.num_actual_blocks {
return "#bad index"
}
@@ -728,7 +738,7 @@ pri func decoder.verify_index?(src: base.io_reader) {
}
this.index_block_compressed_size |= (1 as base.u64) << 63
break
} endwhile
}
this.index_block_uncompressed_size = 0
shift = 0
@@ -748,7 +758,7 @@ pri func decoder.verify_index?(src: base.io_reader) {
}
this.index_block_uncompressed_size |= (1 as base.u64) << 63
break
} endwhile
}
// Update the verification_want_etc values. The hash function is
// loosely based on https://en.wikipedia.org/wiki/MurmurHash#Algorithm
@@ -768,7 +778,7 @@ pri func decoder.verify_index?(src: base.io_reader) {
hash ^= this.verification_want_hashed_sizes[1]
hash = (hash ~mod<< 13) | (hash >> 19)
this.verification_want_hashed_sizes[1] = (hash ~mod* 5) ~mod+ 0xE654_6B64
} endwhile
}
if (this.verification_have_hashed_sizes[0] <> this.verification_want_hashed_sizes[0]) or
(this.verification_have_hashed_sizes[1] <> this.verification_want_hashed_sizes[1]) or
@@ -800,3 +810,20 @@ pri const CHECKSUM_LENGTH : roarray[4] base.u8 = [
]
pri const ZEROES : roarray[3] base.u8 = [0, 0, 0]
// See https://tukaani.org/xz/xz-file-format.txt section 5.3.2.
// Branch/Call/Jump Filters for Executables.
pri const BCJ_OFFSET_ALIGNMENT : roarray[12] base.u8 = [
0x00, // 0x00: Unused.
0x00, // 0x01: Unused.
0x00, // 0x02: Unused.
0x00, // 0x03: Unused.
0x01, // 0x04: x86.
0x04, // 0x05: powerpc.
0x10, // 0x06: ia64.
0x04, // 0x07: arm.
0x02, // 0x08: armthumb.
0x04, // 0x09: sparc.
0x04, // 0x0A: arm64.
0x02, // 0x0B: riscv.
]
+2 -2
View File
@@ -112,7 +112,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
return "#truncated input"
}
yield? status
} endwhile
}
}
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
@@ -165,7 +165,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
break
}
yield? status
} endwhile
}
if not this.quirks[QUIRK_JUST_RAW_DEFLATE - QUIRKS_BASE] {
checksum_want = args.src.read_u32be?()
@@ -161,6 +161,7 @@ OK. bfebcca4 test/3pdata/blinksuite/rgb-jpeg-red.jpg
OK. 6ed3c2e7 test/3pdata/blinksuite/rgb-jpeg-with-adobe-marker-only.jpg
OK. cfb6f39d test/3pdata/blinksuite/rgb-png-with-cmyk-color-profile.png
OK. a3454fb7 test/3pdata/blinksuite/short-app-extension-string.gif
OK. 7c80a001 test/3pdata/blinksuite/size-failure.b186640109.webp
BAD 2398258b test/3pdata/blinksuite/size-failure.gif
OK. 5c4b1a8b test/3pdata/blinksuite/small-square-with-colorspin-profile.jpg
OK. 44dc95b9 test/3pdata/blinksuite/sprite_all_fragments_same.png
@@ -168,6 +169,7 @@ OK. 9a7e5ec7 test/3pdata/blinksuite/sprite_alternate_fragments_same.png
OK. 1b1f5f96 test/3pdata/blinksuite/stripes-large.png
OK. 6b85cdb9 test/3pdata/blinksuite/stripes-small.png
OK. 16c2c0fe test/3pdata/blinksuite/test-load.jpg
OK. 19d3a207 test/3pdata/blinksuite/test3.webp
BAD ed67a9a5 test/3pdata/blinksuite/wrong-block-length.gif
OK. 577c5c4c test/3pdata/blinksuite/ycbcr-420-fast-int-progressive.jpg
OK. bf4cd8e2 test/3pdata/blinksuite/ycbcr-420-float-progressive.jpg
+113
View File
@@ -0,0 +1,113 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
#include "webp/decode.h"
static void //
mimiclib_convert_to_y_from_bgra_nonpremul(uint8_t* dst,
const uint8_t* src,
uint32_t n) {
while (n--) {
uint32_t s0_nonpremul = wuffs_base__peek_u32le__no_bounds_check(src);
uint32_t s0_premul =
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
s0_nonpremul);
dst[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0_premul);
dst += 1;
src += 4;
}
}
const char* //
mimic_webp_decode(uint64_t* n_bytes_out,
wuffs_base__io_buffer* dst,
uint32_t wuffs_initialize_flags,
wuffs_base__pixel_format pixfmt,
uint32_t* quirks_ptr,
size_t quirks_len,
wuffs_base__io_buffer* src) {
wuffs_base__io_buffer dst_fallback =
wuffs_base__slice_u8__writer(g_mimiclib_scratch_slice_u8);
if (!dst) {
dst = &dst_fallback;
}
WebPDecoderConfig config;
if (!WebPInitDecoderConfig(&config)) {
return "mimic_webp_decode: WebPInitDecoderConfig failed";
} else if (WebPGetFeatures(wuffs_base__io_buffer__reader_pointer(src),
wuffs_base__io_buffer__reader_length(src),
&config.input) != VP8_STATUS_OK) {
return "mimic_webp_decode: WebPGetFeatures failed";
}
const uint32_t w = config.input.width;
const uint32_t h = config.input.height;
if ((w > 0x4000) || (h > 0x4000)) {
return "mimic_webp_decode: impossible WebP dimensions";
}
switch (pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
if (((1 * w * h) > wuffs_base__io_buffer__writer_length(dst)) ||
((4 * w * h) > g_mimiclib_scratch_slice_u8.len)) {
return "mimic_webp_decode: image is too large";
}
config.output.u.RGBA.rgba = g_mimiclib_scratch_slice_u8.ptr;
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
if ((4 * w * h) > wuffs_base__io_buffer__writer_length(dst)) {
return "mimic_webp_decode: image is too large";
}
config.output.u.RGBA.rgba = wuffs_base__io_buffer__writer_pointer(dst);
break;
default:
return "mimic_webp_decode: unsupported pixfmt";
}
config.output.colorspace = MODE_BGRA;
config.output.width = w;
config.output.height = h;
config.output.is_external_memory = 1;
config.output.u.RGBA.stride = 4 * w;
config.output.u.RGBA.size = 4 * w * h;
VP8StatusCode status =
WebPDecode(wuffs_base__io_buffer__reader_pointer(src),
wuffs_base__io_buffer__reader_length(src), &config);
WebPFreeDecBuffer(&config.output);
if (status != VP8_STATUS_OK) {
return "mimic_webp_decode: WebPDecode failed";
}
size_t n = 0;
switch (pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
mimiclib_convert_to_y_from_bgra_nonpremul(
wuffs_base__io_buffer__writer_pointer(dst),
g_mimiclib_scratch_slice_u8.ptr, 1 * w * h);
n = 1 * w * h;
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
n = 4 * w * h;
break;
default:
break;
}
dst->meta.wi += n;
if (n_bytes_out) {
*n_bytes_out += n;
}
return NULL;
}
+41 -5
View File
@@ -172,15 +172,18 @@ do_test_xxxxx_crc32_ieee_pi(bool mimic) {
const char* digits =
"3."
"141592653589793238462643383279502884197169399375105820974944592307816406"
"2862089986280348253421170";
if (strlen(digits) != 99) {
"286208998628034825342117067982148086513282306647093844609550582231725359"
"408128481117450284102701938521105559644622948954930381964428810975665933"
"446128475648233786783165271201909145648566923460348610454326648213393607"
"260249141";
if (strlen(digits) != 299) {
RETURN_FAIL("strlen(digits): have %d, want 99", (int)(strlen(digits)));
}
// The want values are determined by script/checksum.go.
//
// wants[i] is the checksum of the first i bytes of the digits string.
uint32_t wants[100] = {
uint32_t wants[300] = {
0x00000000, 0x6DD28E9B, 0x69647A00, 0x83B58BCD, 0x16E010BE, 0xAF13912C,
0xB6C654DC, 0x02D43F2E, 0xC60167FD, 0xDE72F5D2, 0xECB2EAA3, 0x22E1CE23,
0x26F4BB12, 0x099FD2E0, 0x2D041A2F, 0xC14373C1, 0x61A5D6D0, 0xEB60F999,
@@ -197,10 +200,43 @@ do_test_xxxxx_crc32_ieee_pi(bool mimic) {
0xACF0D063, 0x20CC1F13, 0x7E9EDAD2, 0xE5A44AA7, 0xC550F584, 0x101040DF,
0x0BC4A511, 0x706E5A5A, 0x71CE81A3, 0xBB75E3F2, 0x3EDA6848, 0x8B8F08F2,
0xA9384B2B, 0xB6C07F06, 0x6D644EE4, 0xCAD8CCB4, 0x3F70B461, 0x205F9F77,
0x4D9D54B7, 0xD69454CC, 0xF8BB504D, 0xFC4E595C,
0x4D9D54B7, 0xD69454CC, 0xF8BB504D, 0xFC4E595C, 0x7F992992, 0x74C121C3,
0x8F1E35AE, 0xCBE1C7C9, 0xF8A625DE, 0xE24FB641, 0xF28F2588, 0x1991D324,
0xC8C1AA23, 0x58AFE7CB, 0x1156CECB, 0x88166658, 0xE6E42017, 0xEEE7EF7C,
0x438864F5, 0x3794D9E4, 0xBD850CB5, 0xD6644C94, 0x036FEC30, 0x3B622554,
0x71858DDC, 0x7CA2004A, 0xFCCA400C, 0xFD91594A, 0x1BF35E52, 0xE8AC4D1D,
0x99EE9787, 0x80F3E32C, 0xC1EE8438, 0x357B2C0E, 0x1356890A, 0x6DC1D812,
0x77659B3E, 0x45A7539E, 0xE329C631, 0xD58C0252, 0x7FB0EBC9, 0xF81274F2,
0x499E3F49, 0x629BE990, 0x73B1E71A, 0x97AE021F, 0x974A1DFA, 0xD94E7AB1,
0xD16D43FB, 0xAE0F6D79, 0xA470A170, 0xA3171AA5, 0x52C49F5C, 0x988F8E53,
0x71266077, 0xD4C57CF2, 0xA967015F, 0x08CB305C, 0x98D581FC, 0x374F8401,
0xF4EC90A5, 0x25945440, 0x1C469F46, 0x6C15B902, 0x6AD35F3B, 0x45BAE55A,
0x912EBC02, 0x149F1883, 0x871356BA, 0xA8EFA673, 0x3D7F1001, 0x6DEFF18B,
0x10B8FFDB, 0xE5CA6C82, 0x808FC7D7, 0x9530AF35, 0x3BF47A17, 0x79E826AE,
0xB5A64D67, 0xC9B6ECBB, 0xDFA6335F, 0x78D705E1, 0x23AEDACA, 0xFF23AEDA,
0xE24833CA, 0xFFE24833, 0x3228E4DB, 0x0C8B59AC, 0x2CDA7FA2, 0xCB420383,
0x69C2EA8D, 0x89B5837A, 0xAA8C93AC, 0x52CD04D5, 0x055DF067, 0x29D3FE18,
0x9E422C2D, 0xC1F035F7, 0xD0AE8CB2, 0xA8B81BA9, 0xC2702DCC, 0x66CB2197,
0x03DF435D, 0xEFD9A519, 0xE7589ED2, 0xE53D8CE3, 0x245EF45A, 0x782CFD26,
0x21C3B238, 0x32F6C521, 0xB65BB188, 0x19D507B0, 0x48A4893C, 0xDBFC072F,
0x260DA6DB, 0x7B984C78, 0xDA144AEC, 0xB4DEC00D, 0x63BDD869, 0xB0BC4F8A,
0x80DAB1F4, 0xD782622F, 0xC6D431A0, 0x25A66CE1, 0x249E6FBA, 0x3628BEE9,
0x5A3C9DD5, 0xEC36A4CB, 0xF65A7A8F, 0x8E47DFF3, 0x4E85AEFB, 0xAE908594,
0xEA74BDCC, 0x618EE11E, 0x006EE491, 0x9DDD733B, 0xDC44BACC, 0xFFDC44BA,
0x41F4CC54, 0x96473632, 0xD5F96CA2, 0x52B2712A, 0x21E92CB4, 0xA1FF1022,
0x561D5143, 0xF23B776F, 0x594E6C10, 0x073BE005, 0x1AD285ED, 0x5D7DA3F7,
0x3951A411, 0x9E52AE77, 0x4D235986, 0x899162C9, 0x16EA3457, 0x781E49E6,
0xCACDB6B3, 0xA11434B8, 0x41AA0424, 0x21FA34C1, 0x1FF4132A, 0x21A46AD6,
0xEB20F825, 0x56578EAB, 0x5CEA57FA, 0xD03396D0, 0x9CD65F4F, 0x8B2D04C5,
0x18330003, 0x84A918AE, 0xC531F8D6, 0x02A7C882, 0xF0025EFC, 0x4EFBEB7A,
0xAD2619DD, 0x7B1367C7, 0xF1A09B55, 0xE8461ED8, 0x0C513756, 0x71B2BECE,
0x117FD392, 0x04C533B6, 0x3FBEA99E, 0x0A307AFE, 0xA9B9F459, 0xE81E07B7,
0x4F388625, 0xC8970376, 0xD47CCD91, 0xEA0E5184, 0x67382EED, 0xB30E2870,
0x4D0E0500, 0xF496D124, 0x56483882, 0x19351439, 0x42A4C708, 0xFA42F3D4,
0x9B91EA33, 0x4CFDEBC4, 0x11429CC7, 0x86CDFA38, 0xDB326E5C, 0xE1DAC006,
};
for (int i = 0; i < 100; i++) {
for (int i = 0; i < 300; i++) {
uint32_t have;
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
.ptr = (uint8_t*)(digits),
+76 -7
View File
@@ -172,15 +172,18 @@ do_test_xxxxx_crc64_ecma_pi(bool mimic) {
const char* digits =
"3."
"141592653589793238462643383279502884197169399375105820974944592307816406"
"2862089986280348253421170";
if (strlen(digits) != 99) {
"286208998628034825342117067982148086513282306647093844609550582231725359"
"408128481117450284102701938521105559644622948954930381964428810975665933"
"446128475648233786783165271201909145648566923460348610454326648213393607"
"260249141";
if (strlen(digits) != 299) {
RETURN_FAIL("strlen(digits): have %d, want 99", (int)(strlen(digits)));
}
// The want values are determined by script/checksum.go.
//
// wants[i] is the checksum of the first i bytes of the digits string.
uint64_t wants[100] = {
uint64_t wants[300] = {
0x0000000000000000, 0xDEAB38D23CD56AB6, 0x5C257BEFCFF13F5E,
0x4BABD3D6697B9834, 0x1FE60AA0B20E44C1, 0x34C4D86E0BC41325,
0x6202C4935B5F9D03, 0x9A46F1A15337D622, 0x62AC46BA94076EC6,
@@ -214,10 +217,76 @@ do_test_xxxxx_crc64_ecma_pi(bool mimic) {
0xD95A00F0AA88414E, 0x711F777C8CCA7837, 0xEB588853B0AB557A,
0x3F7F198620ADF0A4, 0xAB6528C764F3FBA2, 0xABF132F625B7A5A9,
0x5C5021E5EBE85D91, 0x2DAAE4B7F46D14D4, 0x0EC74F51E656E908,
0x6EAE027D39CA7F0D,
0x6EAE027D39CA7F0D, 0x296411D9BEF21CAF, 0x5CD2B4C6C4731828,
0xD1449E41F0377567, 0xCD8A517B3411F4A5, 0x97ED64E2CD8FE6A1,
0xABCDBABA001ED9B4, 0xD66A3B5C09E02EC2, 0x3728E501A021E172,
0x8FA8940B26443942, 0xFE1D703B20894A27, 0xD1E651850DD38F35,
0x1F7C4722E16AECD6, 0x75255A768CCCB0C3, 0x34AE1B3EDDFAD1D1,
0x0EDE4BAE6F7F7ECD, 0xFC2B6F15F9316343, 0x4E650E206AAF7C2F,
0xEE0921C815AF1439, 0x5BCC63E550CB7344, 0x096893C531E1790B,
0xA657229B5135C9C1, 0xFC83E67CCC0F29F4, 0xF52124238F0847A7,
0x97D5CF979534FF12, 0x5406CB2C056D8466, 0xCE2AA2700EBAB269,
0xB5604D9DAD3E3B6C, 0xF194CCC5BC245CEC, 0x38BC6FD133B249C9,
0xFF38BC6FD133B249, 0xB9C79AFAEF99C298, 0x9E613FB2E8CE3A24,
0xD1862DCA841BC845, 0xFD66EFDCB67509EB, 0x7F1AE71B815FE7A8,
0x947A450AFA64B48F, 0x6C83D6861E275F73, 0xC85945D10A1DC0C8,
0x3736D67F2D221C9C, 0xE61ABC24C5DDC3F4, 0x7A6F48AA80CE6B25,
0x96C8595437943720, 0x9624FE45C9236D7C, 0x3F0265F036D4789C,
0xE61288974AC63590, 0xE5EE29247AE43BE0, 0x8B86598AD1D3D6C1,
0xFCAE3707DD8FCFEB, 0x7F1B2FC35A341D6E, 0x89ABC57D4A0214C4,
0xFCAC1A9B2A141E29, 0xD2C151B1FA870E5C, 0xFB2ECA1C63B7AD57,
0xC77D9CEA9A463CF3, 0x02BB5D50E640B2D4, 0x81BCAB3B568B3AC6,
0x08203BA2C448375C, 0xBF7BE0C18C308167, 0x063F50611F1BEE30,
0x647B5DA7FAF77A84, 0xE327224DE4E832D5, 0x815D37444B899246,
0x86E6F742C735C582, 0x53CE4207552CB338, 0x938F2BBC63A3F1BF,
0xAEA70B17A752D1E4, 0xB492189BE138DD11, 0xA3840BF2F6073422,
0xAA6B0B7A3B8A5F78, 0x8C1066BB0A818EC1, 0x34572E02107C9CEF,
0x408CDEE95CCF5307, 0xE2910D6181E104E2, 0xCC2B5C473FCF2CCA,
0xFFCC2B5C473FCF2C, 0x1A3CBEBAC1C224D1, 0x495AA3E24084B90C,
0xA61710AB7644AC01, 0x2A8919953FE38E41, 0x864D236C1641AF9E,
0x9D7B04552969FE74, 0xC8A8BD03D92A8E69, 0x0648833CDD4EF43F,
0x5B242247A40392A4, 0xAB0173FCA57755C0, 0x4FA0FC93A85C3407,
0x2A60AE79073D96D9, 0xF9610212D7BB05EC, 0xB7E06FCCB31628F8,
0x01EE71FD9737FEFD, 0xF6F9F8EA590D634D, 0x35BF1F336A801E1C,
0x2C51D32609437289, 0xDC3000F0662D3BE7, 0x889A36FD529103FC,
0x7A01C820595927E5, 0x40C2880F7E8676BC, 0x5AF070E3BC0F5438,
0xAFFCACE3D322735F, 0xBCF98D089A79F71E, 0x2FFD24EA65ED975D,
0xFBD3F6693828C7CE, 0xC3816A9B3D5089C0, 0x4FC87C8ACFC413DB,
0x82D46944DBFCA25A, 0x770F9BA9960734AE, 0x2479AD961C8AAF0E,
0x1671CE4556E1E145, 0x8671DBBBC628ADF1, 0x01DFE049E042C078,
0xC83419E7C5E3A557, 0x80E4FCD0CA0797CF, 0x377E6BC62CE206CB,
0x0BB3483C6E6C425D, 0x302C866145555B7A, 0xB0F0985B4597F0C2,
0x8460331CA4CAC9C3, 0x345F5E57B7D2D7A8, 0x1B65F560E19DC7D7,
0x0EF18040314319DB, 0x829550B811022550, 0x0FFAA84AC21C8827,
0xED6D0F302859BBF0, 0x461E8674C04B4E5A, 0x74EEE018F1429F7F,
0xCB6499B9C3ACB935, 0xEBE2F3BD75E433BB, 0xAEDF66CFA6449626,
0x6298DF2DFAF21D86, 0xA48BBB26C50FC886, 0x283CECCFCEA1D706,
0xE2F9BD53A7736A66, 0xCE9C5D067118AC87, 0x2B734A77B94BDC5F,
0x77A63C8AA56583D0, 0xBE96BE698FFEA2CD, 0x846E553A9600A091,
0xA2262F107CDF0241, 0xB99A846990342E28, 0xD284672F083D2E6C,
0x390DA7D5F2A95EA5, 0xECC920909CC60038, 0x201E6060F7CD4463,
0xB58E795FBDC74C9A, 0x121C32DC4D0D86FF, 0xCA90B3C42CBFF832,
0x1F6731C0A04B80A1, 0x186B7C5121D442BD, 0x5AA8D917E250060C,
0x51A565D87CF8C4D8, 0xBEB0BD30DD273F8A, 0x1779DFFADB8F42CB,
0x37E9F6E506F38E1E, 0xE788BBAB74591C78, 0x44A30A3127E65CDE,
0xBEA5BB5F347C2112, 0x6B70B36BCEFA7182, 0x5323D4437C257C8C,
0x14B1FDCDFF705CB5, 0x917F3DF2D5F8BF73, 0xB3747ABE8159411B,
0x10ADA12ED0C00AD1, 0x0EFA48147F724416, 0x2C6A96712E5680D3,
0x75164CA7DF038CAF, 0xEFA08A25B9B5B6D7, 0x75D586BB8B946F99,
0x2EA6D04EFD5374DB, 0x82B507E81FCE353D, 0xD7D19B4E7050F030,
0x902E853B7DD891C1, 0x344B10E1900BC5F0, 0xB243963CB9B3BC7F,
0xCBA234CFE7E44816, 0xA3FB3BDEA201E8B7, 0x91C87734C6A5CEC7,
0x4F9A3597603FE69C, 0x554C5C792E378161, 0x3AAFDEB0F3D14837,
0xACB94213D733B17E, 0x789282A5CB2D9774, 0xF7125CB62AFE773A,
0xE8FB34262D537D48, 0xB9D05972A665A257, 0xFB45DB14A0EB4FFB,
0x452D1FFEB39DE093, 0x2E9628D7B86B7D54, 0xBC78E78CAE12BE10,
0x6B726E371D601F1D, 0xDBAE995EF22A2EEE, 0x8BB8193AAB5B18D4,
0xC69FD2969721DE58, 0xF81F25C1138417BA, 0xD51C589D25ADA831,
0x58D2C7C252A56DC5, 0x87ADA01D6A83E763, 0x0522377F94A3416B,
0x05A0B8E8F65D61CD, 0x7051556BBF39A309, 0x6ED0946703931047,
};
for (int i = 0; i < 100; i++) {
for (int i = 0; i < 300; i++) {
uint64_t have = 0;
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
.ptr = (uint8_t*)(digits),
@@ -308,7 +377,7 @@ bench_wuffs_crc64_ecma_10k() {
return do_bench_io_buffers(
wuffs_bench_crc64_ecma,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
&g_crc64_midsummer_gt, UINT64_MAX, UINT64_MAX, 200);
&g_crc64_midsummer_gt, UINT64_MAX, UINT64_MAX, 2000);
}
const char* //
@@ -317,7 +386,7 @@ bench_wuffs_crc64_ecma_100k() {
return do_bench_io_buffers(
wuffs_bench_crc64_ecma,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
&g_crc64_pi_gt, UINT64_MAX, UINT64_MAX, 20);
&g_crc64_pi_gt, UINT64_MAX, UINT64_MAX, 200);
}
// ---------------- Mimic Benches
+1 -1
View File
@@ -590,7 +590,7 @@ test_wuffs_jpeg_decode_idct() {
if (f == 0) {
func_name = "choosy_default";
func = &wuffs_jpeg__decoder__decode_idct__choosy_default;
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
} else if (wuffs_base__cpu_arch__have_x86_avx2()) {
func_name = "x86_avx2";
func = &wuffs_jpeg__decoder__decode_idct_x86_avx2;
+1 -1
View File
@@ -33,7 +33,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -ldeflate -lz
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
+122
View File
@@ -0,0 +1,122 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// ----------------
/*
This test program is typically run indirectly, by the "wuffs test" or "wuffs
bench" commands. These commands take an optional "-mimic" flag to check that
Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as
giflib for GIF, libpng for PNG, etc.
To manually run this test:
for CC in clang gcc; do
$CC -std=c99 -Wall -Werror vp8.c && ./a.out
rm -f a.out
done
Each edition should print "PASS", amongst other information, and exit(0).
Add the "wuffs mimic cflags" (everything after the colon below) to the C
compiler flags (after the .c file) to run the mimic tests.
To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace
the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
//
// To use that single file as a "foo.c"-like implementation, instead of a
// "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or
// compiling it.
#define WUFFS_IMPLEMENTATION
// 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__VP8
// 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.
#include "../../../release/c/wuffs-unsupported-snapshot.c"
#include "../testlib/testlib.c"
#ifdef WUFFS_MIMIC
// No mimic library.
#endif
// ---------------- VP8 Tests
// No VP8 tests.
// ---------------- Mimic Tests
#ifdef WUFFS_MIMIC
// No mimic tests.
#endif // WUFFS_MIMIC
// ---------------- VP8 Benches
// No VP8 benches.
// ---------------- Mimic Benches
#ifdef WUFFS_MIMIC
// No mimic benches.
#endif // WUFFS_MIMIC
// ---------------- Manifest
proc g_tests[] = {
// No VP8 tests.
#ifdef WUFFS_MIMIC
// No mimic tests.
#endif // WUFFS_MIMIC
NULL,
};
proc g_benches[] = {
// No VP8 benches.
#ifdef WUFFS_MIMIC
// No mimic benches.
#endif // WUFFS_MIMIC
NULL,
};
int //
main(int argc, char** argv) {
g_proc_package_name = "std/vp8";
return test_main(argc, argv, g_tests, g_benches);
}
+28
View File
@@ -374,6 +374,10 @@ test_wuffs_pixel_swizzler_swizzle() {
// When updating this list, also consider updating the pixel formats that
// fuzz/c/std/pixel_swizzler_fuzzer.c exercises and those that
// wuffs_aux::DecodeImageCallbacks::SelectPixfmt accepts.
//
// SelectPixfmt excludes WUFFS_BASE__PIXEL_FORMAT__Y, even though we test
// it here, since it doesn't support every source pixel format in the
// srcs array. See "dst WUFFS_BASE__PIXEL_FORMAT__Y allow-list" below.
{
.color = 0xFF000010,
.pixfmt_repr = WUFFS_BASE__PIXEL_FORMAT__BGR_565,
@@ -406,6 +410,10 @@ test_wuffs_pixel_swizzler_swizzle() {
.color = 0x33002233,
.pixfmt_repr = WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL,
},
{
.color = 0xFF999999,
.pixfmt_repr = WUFFS_BASE__PIXEL_FORMAT__Y,
},
};
const wuffs_base__pixel_blend blends[] = {
@@ -443,6 +451,19 @@ test_wuffs_pixel_swizzler_swizzle() {
}
for (size_t d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
// See "dst WUFFS_BASE__PIXEL_FORMAT__Y allow-list" above.
if (dsts[d].pixfmt_repr == WUFFS_BASE__PIXEL_FORMAT__Y) {
switch (srcs[s].pixfmt_repr) {
case WUFFS_BASE__PIXEL_FORMAT__Y:
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
break;
default:
continue;
}
}
// 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,
@@ -502,6 +523,13 @@ test_wuffs_pixel_swizzler_swizzle() {
if (dst_transparency == WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__OPAQUE) {
want_dst_pixel |= 0xFF000000;
}
if (dsts[d].pixfmt_repr == WUFFS_BASE__PIXEL_FORMAT__Y) {
want_dst_pixel =
0xFF000000 |
(0x00010101 *
wuffs_base__color_u32_argb_premul__as__color_u8_gray(
want_dst_pixel));
}
wuffs_base__color_u32_argb_premul have_dst_pixel =
wuffs_base__pixel_buffer__color_u32_at(&dst_pixbuf, width / 2,
height / 2);
+323
View File
@@ -0,0 +1,323 @@
// Copyright 2024 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// ----------------
/*
This test program is typically run indirectly, by the "wuffs test" or "wuffs
bench" commands. These commands take an optional "-mimic" flag to check that
Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as
giflib for GIF, libpng for PNG, etc.
To manually run this test:
for CC in clang gcc; do
$CC -std=c99 -Wall -Werror webp.c && ./a.out
rm -f a.out
done
Each edition should print "PASS", amongst other information, and exit(0).
Add the "wuffs mimic cflags" (everything after the colon below) to the C
compiler flags (after the .c file) to run the mimic tests.
To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace
the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -lwebp
// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
//
// To use that single file as a "foo.c"-like implementation, instead of a
// "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or
// compiling it.
#define WUFFS_IMPLEMENTATION
// 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__VP8
#define WUFFS_CONFIG__MODULE__WEBP
// 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.
#include "../../../release/c/wuffs-unsupported-snapshot.c"
#include "../testlib/testlib.c"
#ifdef WUFFS_MIMIC
#include "../mimiclib/webp.c"
#endif
static wuffs_webp__decoder g_webp_decoder;
// ---------------- WebP Tests
const char* //
wuffs_webp_decode(uint64_t* n_bytes_out,
wuffs_base__io_buffer* dst,
uint32_t wuffs_initialize_flags,
wuffs_base__pixel_format pixfmt,
uint32_t* quirks_ptr,
size_t quirks_len,
wuffs_base__io_buffer* src) {
wuffs_webp__decoder* dec = &g_webp_decoder;
CHECK_STATUS("initialize",
wuffs_webp__decoder__initialize(dec, sizeof *dec, WUFFS_VERSION,
wuffs_initialize_flags));
return do_run__wuffs_base__image_decoder(
wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(dec),
n_bytes_out, dst, pixfmt, quirks_ptr, quirks_len, src);
}
// --------
const char* //
test_wuffs_webp_decode_interface() {
CHECK_FOCUS(__func__);
wuffs_webp__decoder* dec = &g_webp_decoder;
CHECK_STATUS("initialize",
wuffs_webp__decoder__initialize(
dec, sizeof *dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
return do_test__wuffs_base__image_decoder(
wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(dec),
"test/data/bricks-color.lossless.webp", 0, SIZE_MAX, 160, 120,
0xFF022460);
}
// ---------------- Mimic Tests
#ifdef WUFFS_MIMIC
const char* //
do_test_mimic_webp_decode(const char* filename) {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, filename));
src.meta.ri = 0;
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
.data = g_have_slice_u8,
});
CHECK_STRING(wuffs_webp_decode(
NULL, &have, WUFFS_INITIALIZE__DEFAULT_OPTIONS,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, &src));
src.meta.ri = 0;
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = g_want_slice_u8,
});
CHECK_STRING(mimic_webp_decode(
NULL, &want, WUFFS_INITIALIZE__DEFAULT_OPTIONS,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, &src));
return check_io_buffers_equal("", &have, &want);
}
const char* //
test_mimic_webp_lossless_decode_image_19k_8bpp() {
CHECK_FOCUS(__func__);
return do_test_mimic_webp_decode("test/data/bricks-gray.lossless.webp");
}
const char* //
test_mimic_webp_lossless_decode_image_40k_24bpp() {
CHECK_FOCUS(__func__);
return do_test_mimic_webp_decode("test/data/hat.lossless.webp");
}
const char* //
test_mimic_webp_lossless_decode_image_77k_8bpp() {
CHECK_FOCUS(__func__);
return do_test_mimic_webp_decode("test/data/bricks-dither.lossless.webp");
}
const char* //
test_mimic_webp_lossless_decode_image_552k_32bpp() {
CHECK_FOCUS(__func__);
return do_test_mimic_webp_decode(
"test/data/hibiscus.primitive.lossless.webp");
}
const char* //
test_mimic_webp_lossless_decode_image_4002k_24bpp() {
CHECK_FOCUS(__func__);
return do_test_mimic_webp_decode("test/data/harvesters.lossless.webp");
}
#endif // WUFFS_MIMIC
// ---------------- WebP Benches
const char* //
bench_wuffs_webp_lossless_decode_image_19k_8bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&wuffs_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__Y), NULL, 0,
"test/data/bricks-gray.lossless.webp", 0, SIZE_MAX, 50);
}
const char* //
bench_wuffs_webp_lossless_decode_image_40k_24bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&wuffs_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, "test/data/hat.lossless.webp", 0, SIZE_MAX, 30);
}
const char* //
bench_wuffs_webp_lossless_decode_image_77k_8bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&wuffs_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, "test/data/bricks-dither.lossless.webp", 0, SIZE_MAX, 50);
}
const char* //
bench_wuffs_webp_lossless_decode_image_552k_32bpp() {
uint32_t q = WUFFS_BASE__QUIRK_IGNORE_CHECKSUM;
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&wuffs_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
&q, 1, "test/data/hibiscus.primitive.lossless.webp", 0, SIZE_MAX, 4);
}
const char* //
bench_wuffs_webp_lossless_decode_image_4002k_24bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&wuffs_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, "test/data/harvesters.lossless.webp", 0, SIZE_MAX, 1);
}
// ---------------- Mimic Benches
#ifdef WUFFS_MIMIC
const char* //
bench_mimic_webp_lossless_decode_image_19k_8bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&mimic_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__Y), NULL, 0,
"test/data/bricks-gray.lossless.webp", 0, SIZE_MAX, 50);
}
const char* //
bench_mimic_webp_lossless_decode_image_40k_24bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&mimic_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, "test/data/hat.lossless.webp", 0, SIZE_MAX, 30);
}
const char* //
bench_mimic_webp_lossless_decode_image_77k_8bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&mimic_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, "test/data/bricks-dither.lossless.webp", 0, SIZE_MAX, 50);
}
const char* //
bench_mimic_webp_lossless_decode_image_552k_32bpp() {
uint32_t q = WUFFS_BASE__QUIRK_IGNORE_CHECKSUM;
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&mimic_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
&q, 1, "test/data/hibiscus.primitive.lossless.webp", 0, SIZE_MAX, 4);
}
const char* //
bench_mimic_webp_lossless_decode_image_4002k_24bpp() {
CHECK_FOCUS(__func__);
return do_bench_image_decode(
&mimic_webp_decode,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
NULL, 0, "test/data/harvesters.lossless.webp", 0, SIZE_MAX, 1);
}
#endif // WUFFS_MIMIC
// ---------------- Manifest
proc g_tests[] = {
test_wuffs_webp_decode_interface,
#ifdef WUFFS_MIMIC
test_mimic_webp_lossless_decode_image_19k_8bpp,
test_mimic_webp_lossless_decode_image_40k_24bpp,
test_mimic_webp_lossless_decode_image_77k_8bpp,
test_mimic_webp_lossless_decode_image_552k_32bpp,
test_mimic_webp_lossless_decode_image_4002k_24bpp,
#endif // WUFFS_MIMIC
NULL,
};
proc g_benches[] = {
bench_wuffs_webp_lossless_decode_image_19k_8bpp,
bench_wuffs_webp_lossless_decode_image_40k_24bpp,
bench_wuffs_webp_lossless_decode_image_77k_8bpp,
bench_wuffs_webp_lossless_decode_image_552k_32bpp,
bench_wuffs_webp_lossless_decode_image_4002k_24bpp,
#ifdef WUFFS_MIMIC
bench_mimic_webp_lossless_decode_image_19k_8bpp,
bench_mimic_webp_lossless_decode_image_40k_24bpp,
bench_mimic_webp_lossless_decode_image_77k_8bpp,
bench_mimic_webp_lossless_decode_image_552k_32bpp,
bench_mimic_webp_lossless_decode_image_4002k_24bpp,
#endif // WUFFS_MIMIC
NULL,
};
int //
main(int argc, char** argv) {
g_proc_package_name = "std/webp";
return test_main(argc, argv, g_tests, g_benches);
}
+10
View File
@@ -26,20 +26,24 @@ OK. e08a7cc8 test/data/artificial-png/exif.png
OK. e08a7cc8 test/data/artificial-png/key-value-pairs.png
OK. 076cb375 test/data/bricks-color.bmp
OK. 72a1f9cc test/data/bricks-color.jpeg
OK. 076cb375 test/data/bricks-color.lossless.webp
OK. 076cb375 test/data/bricks-color.png
OK. 076cb375 test/data/bricks-color.tga
OK. f36c2e80 test/data/bricks-dither.bmp
OK. f36c2e80 test/data/bricks-dither.gif
OK. f36c2e80 test/data/bricks-dither.lossless.webp
OK. f36c2e80 test/data/bricks-dither.no-ancillary.png
OK. f36c2e80 test/data/bricks-dither.png
OK. c2bce675 test/data/bricks-gray.bmp
OK. c2bce675 test/data/bricks-gray.gif
OK. 3a2478ad test/data/bricks-gray.jpeg
OK. c2bce675 test/data/bricks-gray.lossless.webp
OK. c2bce675 test/data/bricks-gray.no-ancillary.png
OK. c2bce675 test/data/bricks-gray.png
OK. c2bce675 test/data/bricks-gray.tga
OK. 7aebfe6c test/data/bricks-nodither.bmp
OK. 7aebfe6c test/data/bricks-nodither.gif
OK. 7aebfe6c test/data/bricks-nodither.lossless.webp
OK. 7aebfe6c test/data/bricks-nodither.png
OK. 7aebfe6c test/data/bricks-nodither.tga
OK. ae2e547d test/data/bricks-nodither.wbmp
@@ -50,19 +54,23 @@ OK. 3014b4c0 test/data/gifplayer-muybridge.gif
OK. 030f5a48 test/data/harvesters.bmp
OK. c18b3d5a test/data/harvesters.gif
OK. f217df74 test/data/harvesters.jpeg
OK. 030f5a48 test/data/harvesters.lossless.webp
OK. 030f5a48 test/data/harvesters.png
OK. e776c90f test/data/hat.bmp
OK. 6dcba6a4 test/data/hat.gif
OK. 2298f3ca test/data/hat.jpeg
OK. e776c90f test/data/hat.lossless.webp
OK. e776c90f test/data/hat.png
OK. d30bfe5d test/data/hat.wbmp
OK. 33a44f22 test/data/hibiscus.primitive.bmp
OK. 25e212b3 test/data/hibiscus.primitive.gif
OK. 9624fa44 test/data/hibiscus.primitive.jpeg
OK. 33a44f22 test/data/hibiscus.primitive.lossless.webp
OK. 33a44f22 test/data/hibiscus.primitive.png
OK. 60040742 test/data/hibiscus.regular.bmp
OK. b727da8b test/data/hibiscus.regular.gif
OK. 41e39405 test/data/hibiscus.regular.jpeg
OK. 60040742 test/data/hibiscus.regular.lossless.webp
OK. 60040742 test/data/hibiscus.regular.png
OK. dcbb225a test/data/hippopotamus.bmp
OK. ed4b78fc test/data/hippopotamus.interlaced.gif
@@ -70,6 +78,7 @@ OK. dcbb225a test/data/hippopotamus.interlaced.png
BAD c3c4bd65 test/data/hippopotamus.interlaced.truncated.gif
BAD 7c6a771b test/data/hippopotamus.interlaced.truncated.png
OK. 96bdbbb3 test/data/hippopotamus.jpeg
OK. dcbb225a test/data/hippopotamus.lossless.webp
OK. d3bbed27 test/data/hippopotamus.masked-with-muybridge.gif
OK. 7e6acf01 test/data/hippopotamus.masked-with-muybridge.png
OK. dcbb225a test/data/hippopotamus.nie
@@ -114,6 +123,7 @@ OK. d42a13cd test/data/peacock.s2x2-420.jpeg
OK. bf7e8c96 test/data/pjw-thumbnail.bmp
OK. bf7e8c96 test/data/pjw-thumbnail.gif
OK. 7c67a37f test/data/pjw-thumbnail.jpeg
OK. bf7e8c96 test/data/pjw-thumbnail.lossless.webp
OK. bf7e8c96 test/data/pjw-thumbnail.png
OK. 38cb4cbf test/data/red-blue-gradient.dcip3d65-no-chrm-no-gama.png
OK. 38cb4cbf test/data/red-blue-gradient.gamma1dot0.png