Compare commits

...
Author SHA1 Message Date
Nigel Tao 870cfd18a7 release: wuffs gen -version=0.4.0-alpha.6 2024-08-05 00:14:21 +10:00
Nigel Tao ffb64df0a0 aux: add QuirkKeyValuePair type 2024-08-05 00:12:15 +10:00
Nigel Tao 3215f6afac fuzz: remove "not enough data" from pixel swizzler 2024-08-04 23:36:10 +10:00
Nigel Tao 8a722790af example/imageviewer: change screen_gamma flag 2024-08-04 23:25:07 +10:00
Nigel Tao d270839e3f std/jpeg: let use_lower_quality work with CMYK 2024-08-04 23:16:58 +10:00
Nigel Tao c9fff5b207 std/jpeg: add and use WUFFS_BASE__QUIRK_QUALITY 2024-08-04 23:15:58 +10:00
Nigel Tao fb769ff82f base: disable SIMD on MSVC x86_64 by default
This recreates the case as of commit f1698226 (tag v0.4.0-alpha.4), in
that, by default (without #define'ing a macro or passing an /arch:ETC
compiler flag), Wuffs does not use SIMD on MSVC x86_64.

Commit b64a7610 (after tag v0.4.0-alpha.4, before tag v0.4.0-alpha.5)
changed the default so that x86_64_v2 (roughly equivalent to SSE4.2) was
enabled by default, since the user from issue #148 was enabling that
anyway (in an unsupported way, by #define'ing a macro that was a private
implementation detail) with no problems (and better performance).

However, another user later reported (in issue #151) that enabling SIMD
on MSVC x86_64 somehow lead to ICEs (Internal Compiler Errors).

This commit restores the default to "no SIMD" and it is up to the MSVC
user to opt in to the SIMD code paths. Clang and GCC are unaffected:
SIMD remains enabled by default.

Updates #148
Updates #151
2024-07-31 17:12:55 +10:00
Nigel Tao 5e0b2ae0d5 script: add print-json-token-etc usage comments 2024-07-27 09:41:00 +10:00
Nigel Tao a7fb1e8d69 script: avoid gcc -Wstringop-overread for strnlen 2024-07-27 09:33:39 +10:00
Nigel Tao ce1f59e9ce base: format token-public.h constants 2024-07-27 09:11:53 +10:00
Nigel Tao 42b070e487 std/jpeg: halve maximum scan count from 64 to 32
cjpeg defaults to using 1 (sequential) or 10 (progressive) scans. 32 is
still easily more than what's seen in practice.

The previous commit (f9c384d6 std/jpeg: add "expect multiple scans"
check) makes Wuffs more closely match libjpeg. Without that commit,
though, this commit halves the time taken to decode the oss-fuzz test
case (linked below) from 6 to 3 seconds, in an optimized build. For the
debug-sanitizer fuzzer build, without this commit, that test case times
out after 60 seconds but this commit should halve the time taken.

Updates https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=70340
2024-07-24 22:09:25 +10:00
Nigel Tao f9c384d6b2 std/jpeg: add "expect multiple scans" check
Updates https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=70340
2024-07-23 21:53:32 +10:00
Nigel Tao d0603f3b94 test/3pdata: add webpsuite 2024-07-09 21:43:24 +10:00
Nigel Tao c6aebf819f std/webp: re-implement 8-bit color indexing 2024-07-09 16:50:58 +10:00
Nigel Tao 8fe987e0b2 base: add sign_extend_convert_u8_u32 2024-07-09 16:31:58 +10:00
Nigel Tao d1a9749571 check: drop pointer-typed facts on suspension 2024-07-09 16:21:47 +10:00
Nigel Tao f37cfcf554 check: drop more facts when calling coroutines 2024-07-09 14:11:31 +10:00
Nigel Tao cc9ee184d0 cgen: omit consecutive Wconversion gcc pragmas 2024-07-09 12:39:16 +10:00
39 changed files with 2769 additions and 1953 deletions

No files matched your search

+4
View File
@@ -26,7 +26,11 @@ The LICENSE has changed from a single license (Apache 2) to a dual license
- Added `std/xxhash32`. - Added `std/xxhash32`.
- Added `std/xxhash64`. - Added `std/xxhash64`.
- Added `std/xz`. - Added `std/xz`.
- Added `WUFFS_BASE__QUIRK_QUALITY`.
- Added `WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY`.
- Added `WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST`. - Added `WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST`.
- Added `WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2`.
- Added `WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3`.
- Added `wuffs_base__status__is_truncated_input_error`. - Added `wuffs_base__status__is_truncated_input_error`.
- Changed `lzw.set_literal_width` to `lzw.set_quirk`. - Changed `lzw.set_literal_width` to `lzw.set_quirk`.
- Changed `set_quirk_enabled!(quirk: u32, enabled: bool)` to `set_quirk!(key: - Changed `set_quirk_enabled!(quirk: u32, enabled: bool)` to `set_quirk!(key:
+10
View File
@@ -62,6 +62,16 @@ Common quirks:
at a cost of being less able to detect data corruption and to deviate from a at a cost of being less able to detect data corruption and to deviate from a
strict reading of the relevant file format specifications, accepting some strict reading of the relevant file format specifications, accepting some
inputs that are technically invalid (but otherwise decode fine). inputs that are technically invalid (but otherwise decode fine).
- `WUFFS_BASE__QUIRK_QUALITY` configures decoders (for a lossy format, where
there is some leeway in "a/the correct decoding") or encoders to use lower
than, equal to or higher than the default quality setting. Lower-than-default
obviously produces a worse result on some measure. But, if the codec behavior
depends on the quirk value, lowering quality can improve other measures:
being faster (less time taken), lighter (less "work buffer" memory required),
etc. Conversely, asking for higher quality might be a no-op (depending on the
codec) but, if it does affect behavior, it typically trades off in the other
direction: higher quality and/or tighter (smaller output) but also slower,
heavier, etc.
Package-specific quirks: Package-specific quirks:
+16 -3
View File
@@ -132,6 +132,7 @@ struct {
int remaining_argc; int remaining_argc;
char** remaining_argv; char** remaining_argv;
bool lower_quality;
double screen_gamma; double screen_gamma;
} g_flags = {0}; } g_flags = {0};
@@ -139,7 +140,8 @@ static const char* g_usage =
"Usage: imageviewer -flags input0.gif input1.png\n" "Usage: imageviewer -flags input0.gif input1.png\n"
"\n" "\n"
"Flags:\n" "Flags:\n"
" -screen_gamma=N.N (default 2.2; 0 disables gamma correction)"; " -lower-quality (exercise lower-image-quality code paths)\n"
" -screen-gamma=N.N (default 2.2; 0 disables gamma correction)";
const char* // const char* //
parse_flags(int argc, char** argv) { parse_flags(int argc, char** argv) {
@@ -165,7 +167,11 @@ parse_flags(int argc, char** argv) {
} }
} }
if (!strncmp(arg, "screen_gamma=", 13)) { if (!strcmp(arg, "lower-quality")) {
g_flags.lower_quality = true;
continue;
}
if (!strncmp(arg, "screen-gamma=", 13)) {
g_flags.screen_gamma = atof(arg + 13); g_flags.screen_gamma = atof(arg + 13);
continue; continue;
} }
@@ -265,10 +271,17 @@ load_image(const char* filename) {
dia_flags |= wuffs_aux::DecodeImageArgFlags::REPORT_METADATA_GAMA; dia_flags |= wuffs_aux::DecodeImageArgFlags::REPORT_METADATA_GAMA;
} }
const wuffs_aux::QuirkKeyValuePair wuffs_base__quirk_quality = {
WUFFS_BASE__QUIRK_QUALITY,
WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY,
};
MyDecodeImageCallbacks callbacks; MyDecodeImageCallbacks callbacks;
wuffs_aux::sync_io::FileInput input(file); wuffs_aux::sync_io::FileInput input(file);
wuffs_aux::DecodeImageResult res = wuffs_aux::DecodeImage( wuffs_aux::DecodeImageResult res = wuffs_aux::DecodeImage(
callbacks, input, wuffs_aux::DecodeImageArgQuirks::DefaultValue(), callbacks, input,
wuffs_aux::DecodeImageArgQuirks(&wuffs_base__quirk_quality,
g_flags.lower_quality ? 1 : 0),
wuffs_aux::DecodeImageArgFlags(dia_flags), wuffs_aux::DecodeImageArgFlags(dia_flags),
// Use PIXEL_BLEND__SRC_OVER, not the default PIXEL_BLEND__SRC, because // Use PIXEL_BLEND__SRC_OVER, not the default PIXEL_BLEND__SRC, because
// we also pass a background color. // we also pass a background color.
+11 -11
View File
@@ -139,7 +139,7 @@ static const char* g_usage =
uint8_t g_dst_array[DST_BUFFER_ARRAY_SIZE]; uint8_t g_dst_array[DST_BUFFER_ARRAY_SIZE];
wuffs_base__io_buffer g_dst; wuffs_base__io_buffer g_dst;
std::vector<uint32_t> g_quirks; std::vector<wuffs_aux::QuirkKeyValuePair> g_quirks;
struct { struct {
int remaining_argc; int remaining_argc;
@@ -149,9 +149,9 @@ struct {
std::string // std::string //
parse_flags(int argc, char** argv) { parse_flags(int argc, char** argv) {
#if defined(WUFFS_EXAMPLE_SPEAK_JWCC_NOT_JSON) #if defined(WUFFS_EXAMPLE_SPEAK_JWCC_NOT_JSON)
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, 1});
#endif #endif
int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name.
@@ -175,22 +175,22 @@ parse_flags(int argc, char** argv) {
} }
if (!strcmp(arg, "input-allow-comments")) { if (!strcmp(arg, "input-allow-comments")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, 1});
continue; continue;
} }
if (!strcmp(arg, "input-allow-extra-comma")) { if (!strcmp(arg, "input-allow-extra-comma")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, 1});
continue; continue;
} }
if (!strcmp(arg, "input-allow-inf-nan-numbers")) { if (!strcmp(arg, "input-allow-inf-nan-numbers")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS, 1});
continue; continue;
} }
if (!strcmp(arg, "input-jwcc") || !strcmp(arg, "jwcc")) { if (!strcmp(arg, "input-jwcc") || !strcmp(arg, "jwcc")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, 1});
continue; continue;
} }
+12 -12
View File
@@ -215,7 +215,7 @@ static const char* g_usage =
// ---- // ----
std::vector<uint32_t> g_quirks; std::vector<wuffs_aux::QuirkKeyValuePair> g_quirks;
std::string g_dst; std::string g_dst;
@@ -239,9 +239,9 @@ parse_flags(int argc, char** argv) {
g_flags.max_output_depth = 0xFFFFFFFF; g_flags.max_output_depth = 0xFFFFFFFF;
#if defined(WUFFS_EXAMPLE_SPEAK_JWCC_NOT_JSON) #if defined(WUFFS_EXAMPLE_SPEAK_JWCC_NOT_JSON)
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, 1});
#endif #endif
int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name.
@@ -281,22 +281,22 @@ parse_flags(int argc, char** argv) {
return g_usage; return g_usage;
} }
if (!strcmp(arg, "input-allow-comments")) { if (!strcmp(arg, "input-allow-comments")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, 1});
continue; continue;
} }
if (!strcmp(arg, "input-allow-extra-comma")) { if (!strcmp(arg, "input-allow-extra-comma")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, 1});
continue; continue;
} }
if (!strcmp(arg, "input-allow-inf-nan-numbers")) { if (!strcmp(arg, "input-allow-inf-nan-numbers")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS, 1});
continue; continue;
} }
if (!strcmp(arg, "input-jwcc") || !strcmp(arg, "jwcc")) { if (!strcmp(arg, "input-jwcc") || !strcmp(arg, "jwcc")) {
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, 1});
g_quirks.push_back(WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA); g_quirks.push_back({WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, 1});
continue; continue;
} }
if (!strncmp(arg, "q=", 2) || !strncmp(arg, "query=", 6)) { if (!strncmp(arg, "q=", 2) || !strncmp(arg, "query=", 6)) {
@@ -547,7 +547,7 @@ main1(int argc, char** argv) {
TRY(parse_flags(argc, argv)); TRY(parse_flags(argc, argv));
if (!g_flags.strict_json_pointer_syntax) { if (!g_flags.strict_json_pointer_syntax) {
g_quirks.push_back( g_quirks.push_back(
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T); {WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T, 1});
} }
FILE* in = stdin; FILE* in = stdin;
+2 -2
View File
@@ -499,11 +499,11 @@ fuzz_cpp(const uint8_t* in_ptr, size_t in_len, uint64_t hash) {
const char* json_pointer = json_pointers[hash & 15]; const char* json_pointer = json_pointers[hash & 15];
hash = wuffs_base__u64__rotate_right(hash, 4); hash = wuffs_base__u64__rotate_right(hash, 4);
std::vector<uint32_t> quirks; std::vector<wuffs_aux::QuirkKeyValuePair> quirks;
for (uint32_t i = 0; g_quirks[i]; i++) { for (uint32_t i = 0; g_quirks[i]; i++) {
uint64_t bit = 1 << (i & 63); uint64_t bit = 1 << (i & 63);
if (hash & bit) { if (hash & bit) {
quirks.push_back(g_quirks[i]); quirks.push_back({g_quirks[i], 1});
} }
} }
+59 -25
View File
@@ -124,13 +124,17 @@ const char* //
fuzz_swizzle_interleaved_from_slice(wuffs_base__io_buffer* src, uint64_t hash) { fuzz_swizzle_interleaved_from_slice(wuffs_base__io_buffer* src, uint64_t hash) {
uint8_t dst_palette_array[1024]; uint8_t dst_palette_array[1024];
uint8_t src_palette_array[1024]; uint8_t src_palette_array[1024];
if ((src->meta.wi - src->meta.ri) < 2048) { if ((src->meta.wi - src->meta.ri) >= 2048) {
return "fuzz: not enough data"; memcpy(dst_palette_array, src->data.ptr + src->meta.ri, 1024);
src->meta.ri += 1024;
memcpy(src_palette_array, src->data.ptr + src->meta.ri, 1024);
src->meta.ri += 1024;
} else {
for (uint32_t i = 0; i < 1024; i++) {
dst_palette_array[i] = (uint8_t)i;
src_palette_array[i] = (uint8_t)i;
}
} }
memcpy(dst_palette_array, src->data.ptr + src->meta.ri, 1024);
src->meta.ri += 1024;
memcpy(src_palette_array, src->data.ptr + src->meta.ri, 1024);
src->meta.ri += 1024;
wuffs_base__slice_u8 dst_palette = wuffs_base__slice_u8 dst_palette =
wuffs_base__make_slice_u8(&dst_palette_array[0], 1024); wuffs_base__make_slice_u8(&dst_palette_array[0], 1024);
wuffs_base__slice_u8 src_palette = wuffs_base__slice_u8 src_palette =
@@ -178,17 +182,25 @@ fuzz_swizzle_interleaved_from_slice(wuffs_base__io_buffer* src, uint64_t hash) {
// Position dst_slice and src_slice so that reading or writing one byte past // Position dst_slice and src_slice so that reading or writing one byte past
// their end will cause a segmentation fault. // their end will cause a segmentation fault.
if ((src->meta.wi - src->meta.ri) < (dst_len + src_len)) {
return "fuzz: not enough data";
}
wuffs_base__slice_u8 dst_slice = wuffs_base__slice_u8 dst_slice =
wuffs_base__make_slice_u8(dst_alloc + alloc_size - dst_len, dst_len); wuffs_base__make_slice_u8(dst_alloc + alloc_size - dst_len, dst_len);
memcpy(dst_slice.ptr, src->data.ptr + src->meta.ri, dst_len);
src->meta.ri += dst_len;
wuffs_base__slice_u8 src_slice = wuffs_base__slice_u8 src_slice =
wuffs_base__make_slice_u8(src_alloc + alloc_size - src_len, src_len); wuffs_base__make_slice_u8(src_alloc + alloc_size - src_len, src_len);
memcpy(src_slice.ptr, src->data.ptr + src->meta.ri, src_len);
src->meta.ri += src_len; // Fill in dst_slice and src_slice.
if ((src->meta.wi - src->meta.ri) >= (dst_len + src_len)) {
memcpy(dst_slice.ptr, src->data.ptr + src->meta.ri, dst_len);
src->meta.ri += dst_len;
memcpy(src_slice.ptr, src->data.ptr + src->meta.ri, src_len);
src->meta.ri += src_len;
} else {
for (size_t i = 0; i < dst_len; i++) {
dst_slice.ptr[i] = (uint8_t)i;
}
for (size_t i = 0; i < src_len; i++) {
src_slice.ptr[i] = (uint8_t)i;
}
}
// When manually testing this program, enabling this code should lead to a // When manually testing this program, enabling this code should lead to a
// segmentation fault. // segmentation fault.
@@ -214,16 +226,34 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) {
wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format(
pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]);
uint32_t width = (63 & (hash >> 8)) + 1; uint32_t x_min_incl = (63 & (hash >> 8)) + 1;
uint32_t height = (63 & (hash >> 14)) + 1; uint32_t x_max_excl = (63 & (hash >> 14)) + 1;
uint32_t y_min_incl = (63 & (hash >> 20)) + 1;
uint32_t y_max_excl = (63 & (hash >> 26)) + 1;
uint32_t width_in_mcus = (3 & (hash >> 20)) + 1; uint32_t width_in_mcus = (3 & (hash >> 32)) + 1;
uint32_t height_in_mcus = (3 & (hash >> 22)) + 1; uint32_t height_in_mcus = (3 & (hash >> 34)) + 1;
uint32_t allow_hv3 = 1 & (hash >> 24); uint32_t allow_hv3 = 1 & (hash >> 36);
bool is_rgb_or_cmyk = 1 & (hash >> 25); bool is_rgb_or_cmyk = 1 & (hash >> 37);
bool triangle_filter_for_2to1 = 1 & (hash >> 26); bool triangle_filter_for_2to1 = 1 & (hash >> 38);
bool use_4th_component = 1 & (hash >> 27); bool use_4th_component = 1 & (hash >> 39);
if (triangle_filter_for_2to1) {
x_min_incl = 0;
y_min_incl = 0;
} else {
if (x_min_incl > x_max_excl) {
uint32_t a = x_min_incl;
x_min_incl = x_max_excl;
x_max_excl = a;
}
if (y_min_incl > y_max_excl) {
uint32_t a = y_min_incl;
y_min_incl = y_max_excl;
y_max_excl = a;
}
}
uint32_t possible_hv_values[2][4] = { uint32_t possible_hv_values[2][4] = {
{1, 1, 2, 4}, {1, 1, 2, 4},
@@ -253,8 +283,10 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) {
h0, wuffs_base__u32__max(h1, wuffs_base__u32__max(h2, h3))); h0, wuffs_base__u32__max(h1, wuffs_base__u32__max(h2, h3)));
uint32_t vmax = wuffs_base__u32__max( uint32_t vmax = wuffs_base__u32__max(
v0, wuffs_base__u32__max(v1, wuffs_base__u32__max(v2, v3))); v0, wuffs_base__u32__max(v1, wuffs_base__u32__max(v2, v3)));
width = wuffs_base__u32__min(width, 8 * width_in_mcus * hmax); x_max_excl = x_min_incl + wuffs_base__u32__min(x_max_excl - x_min_incl,
height = wuffs_base__u32__min(height, 8 * height_in_mcus * vmax); 8 * width_in_mcus * hmax);
y_max_excl = y_min_incl + wuffs_base__u32__min(y_max_excl - y_min_incl,
8 * height_in_mcus * vmax);
static size_t dst_alloc_size = 0; static size_t dst_alloc_size = 0;
if (dst_alloc_size == 0) { if (dst_alloc_size == 0) {
@@ -271,7 +303,8 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) {
wuffs_base__pixel_buffer dst_pixbuf; wuffs_base__pixel_buffer dst_pixbuf;
wuffs_base__pixel_config dst_pixcfg; wuffs_base__pixel_config dst_pixcfg;
wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, width, height); wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, x_max_excl,
y_max_excl);
uint64_t dst_pixbuf_len = wuffs_base__pixel_config__pixbuf_len(&dst_pixcfg); uint64_t dst_pixbuf_len = wuffs_base__pixel_config__pixbuf_len(&dst_pixcfg);
if (dst_pixbuf_len > dst_alloc_size) { if (dst_pixbuf_len > dst_alloc_size) {
return "fuzz: internal error: dst_alloc_size is too small"; return "fuzz: internal error: dst_alloc_size is too small";
@@ -368,7 +401,8 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) {
uint8_t scratch_buffer[2048]; uint8_t scratch_buffer[2048];
wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck( wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck(
&swizzler, &dst_pixbuf, dst_palette, // &swizzler, &dst_pixbuf, dst_palette, //
width, height, // x_min_incl, x_max_excl, //
y_min_incl, y_max_excl, //
src0, src1, src2, src3, // src0, src1, src2, src3, //
width0, width1, width2, width3, // width0, width1, width2, width3, //
height0, height1, height2, height3, // height0, height1, height2, height3, //
+3
View File
@@ -16,6 +16,7 @@
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
#include <utility>
namespace wuffs_aux { namespace wuffs_aux {
@@ -28,6 +29,8 @@ using IOBuffer = wuffs_base__io_buffer;
// nullptr, since calling free(nullptr) is a no-op. // nullptr, since calling free(nullptr) is a no-op.
using MemOwner = std::unique_ptr<void, decltype(&free)>; using MemOwner = std::unique_ptr<void, decltype(&free)>;
using QuirkKeyValuePair = std::pair<uint32_t, uint64_t>;
namespace sync_io { namespace sync_io {
// -------- // --------
+6 -8
View File
@@ -28,15 +28,13 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input, sync_io::Input& input,
IOBuffer& buffer) {} IOBuffer& buffer) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0) DecodeCborArgQuirks::DecodeCborArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeCborArgQuirks // DecodeCborArgQuirks //
DecodeCborArgQuirks::DefaultValue() { DecodeCborArgQuirks::DefaultValue() {
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32()); return DecodeCborArgQuirks(nullptr, 0);
} }
DecodeCborResult // DecodeCborResult //
@@ -65,8 +63,8 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
ret_error_message = "wuffs_aux::DecodeCbor: out of memory"; ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
goto done; goto done;
} }
for (size_t i = 0; i < quirks.repr.len; i++) { for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk(quirks.repr.ptr[i], 1); dec->set_quirk(quirks.ptr[i].first, quirks.ptr[i].second);
} }
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB. // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
+4 -3
View File
@@ -75,13 +75,14 @@ class DecodeCborCallbacks {
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor. // DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
struct DecodeCborArgQuirks { struct DecodeCborArgQuirks {
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeCborArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeCborArgQuirks DefaultValue(); static DecodeCborArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeCbor calls callbacks based on the CBOR-formatted data in input. // DecodeCbor calls callbacks based on the CBOR-formatted data in input.
+12 -13
View File
@@ -197,15 +197,13 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
const char DecodeImage_UnsupportedPixelFormat[] = // const char DecodeImage_UnsupportedPixelFormat[] = //
"wuffs_aux::DecodeImage: unsupported pixel format"; "wuffs_aux::DecodeImage: unsupported pixel format";
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0) DecodeImageArgQuirks::DecodeImageArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeImageArgQuirks // DecodeImageArgQuirks //
DecodeImageArgQuirks::DefaultValue() { DecodeImageArgQuirks::DefaultValue() {
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32()); return DecodeImageArgQuirks(nullptr, 0);
} }
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {} DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
@@ -303,7 +301,8 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks, DecodeImageCallbacks& callbacks,
sync_io::Input& input, sync_io::Input& input,
wuffs_base__io_buffer& io_buf, wuffs_base__io_buffer& io_buf,
wuffs_base__slice_u32 quirks, const QuirkKeyValuePair* quirks_ptr,
const size_t quirks_len,
uint64_t flags, uint64_t flags,
wuffs_base__pixel_blend pixel_blend, wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color, wuffs_base__color_u32_argb_premul background_color,
@@ -386,8 +385,8 @@ redirect:
} }
// Apply quirks. // Apply quirks.
for (size_t i = 0; i < quirks.len; i++) { for (size_t i = 0; i < quirks_len; i++) {
image_decoder->set_quirk(quirks.ptr[i], 1); image_decoder->set_quirk(quirks_ptr[i].first, quirks_ptr[i].second);
} }
// Apply flags. // Apply flags.
@@ -614,10 +613,10 @@ DecodeImage(DecodeImageCallbacks& callbacks,
} }
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr); wuffs_base__image_decoder::unique_ptr image_decoder(nullptr);
DecodeImageResult result = DecodeImageResult result = DecodeImage0(
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr, image_decoder, callbacks, input, *io_buf, quirks.ptr, quirks.len,
flags.repr, pixel_blend.repr, background_color.repr, flags.repr, pixel_blend.repr, background_color.repr,
max_incl_dimension.repr, max_incl_metadata_length.repr); max_incl_dimension.repr, max_incl_metadata_length.repr);
callbacks.Done(result, input, *io_buf, std::move(image_decoder)); callbacks.Done(result, input, *io_buf, std::move(image_decoder));
return result; return result;
} }
+4 -3
View File
@@ -200,13 +200,14 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
// DecodeImageArgQuirks wraps an optional argument to DecodeImage. // DecodeImageArgQuirks wraps an optional argument to DecodeImage.
struct DecodeImageArgQuirks { struct DecodeImageArgQuirks {
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeImageArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeImageArgQuirks DefaultValue(); static DecodeImageArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeImageArgFlags wraps an optional argument to DecodeImage. // DecodeImageArgFlags wraps an optional argument to DecodeImage.
+8 -10
View File
@@ -33,15 +33,13 @@ const char DecodeJson_BadJsonPointer[] = //
const char DecodeJson_NoMatch[] = // const char DecodeJson_NoMatch[] = //
"wuffs_aux::DecodeJson: no match"; "wuffs_aux::DecodeJson: no match";
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0) DecodeJsonArgQuirks::DecodeJsonArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeJsonArgQuirks // DecodeJsonArgQuirks //
DecodeJsonArgQuirks::DefaultValue() { DecodeJsonArgQuirks::DefaultValue() {
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32()); return DecodeJsonArgQuirks(nullptr, 0);
} }
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0) DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
@@ -386,11 +384,11 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done; goto done;
} }
bool allow_tilde_n_tilde_r_tilde_t = false; bool allow_tilde_n_tilde_r_tilde_t = false;
for (size_t i = 0; i < quirks.repr.len; i++) { for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk(quirks.repr.ptr[i], 1); dec->set_quirk(quirks.ptr[i].first, quirks.ptr[i].second);
if (quirks.repr.ptr[i] == if (quirks.ptr[i].first ==
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) { WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
allow_tilde_n_tilde_r_tilde_t = true; allow_tilde_n_tilde_r_tilde_t = (quirks.ptr[i].second != 0);
} }
} }
+4 -3
View File
@@ -76,13 +76,14 @@ extern const char DecodeJson_NoMatch[];
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson. // DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
struct DecodeJsonArgQuirks { struct DecodeJsonArgQuirks {
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeJsonArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeJsonArgQuirks DefaultValue(); static DecodeJsonArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson. // DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
+3
View File
@@ -173,6 +173,9 @@ wuffs_private_impl__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {
// ---------------- Numeric Types (Utility) // ---------------- Numeric Types (Utility)
#define wuffs_base__utility__sign_extend_convert_u8_u32(a) \
((uint32_t)(int32_t)(int8_t)(a))
#define wuffs_base__utility__sign_extend_convert_u16_u32(a) \ #define wuffs_base__utility__sign_extend_convert_u16_u32(a) \
((uint32_t)(int32_t)(int16_t)(a)) ((uint32_t)(int32_t)(int16_t)(a))
+68 -18
View File
@@ -119,12 +119,62 @@
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1) #elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_X64) #if defined(_M_X64)
// We need <intrin.h> for the __cpuid function.
#include <intrin.h> // On X86_64, Microsoft Visual C/C++ (MSVC) only supports SSE2 by default.
// There are /arch:SSE2, /arch:AVX and /arch:AVX2 compiler flags (the AVX2 one
// is roughly equivalent to X86_64_V3), but there is no /arch:SSE42 compiler
// flag that's equivalent to X86_64_V2.
//
// For getting maximum performance with X86_64 MSVC and Wuffs, pass /arch:AVX2
// (and then test on the oldest hardware you intend to support).
//
// Absent that compiler flag, either define one of the three macros listed
// below or else the X86_64 SIMD code will be disabled and you'll get a #pragma
// message stating this library "performs best with /arch:AVX2". This message
// is harmless and ignorable, in that the non-SIMD code is still correct and
// reasonably performant, but is a reminder that when combining Wuffs and MSVC,
// some compiler configuration is required for maximum performance.
//
// - WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY
// - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2 (enables SSE4.2 and below)
// - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3 (enables AVX2 and below)
//
// Defining the first one (WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
// or defining none of those three (the default state) are equivalent (in that
// both disable the SIMD code paths), other than that pragma message.
//
// When defining these WUFFS_CONFIG__ENABLE_ETC macros with MSVC, be aware that
// some users report it leading to ICEs (Internal Compiler Errors), but other
// users report no problems at all (and improved performance). It's unclear
// exactly what combination of SIMD code and MSVC configuration lead to ICEs.
// Do your own testing with your own MSVC version and configuration.
//
// https://github.com/google/wuffs/issues/148
// https://github.com/google/wuffs/issues/151
// https://developercommunity.visualstudio.com/t/fatal--error-C1001:-Internal-compiler-er/10703305
//
// Clang (including clang-cl) and GCC don't need this WUFFS_CONFIG__ETC macro
// machinery, or having the Wuffs-the-library user to fiddle with compiler
// flags, because they support "__attribute__((target(arg)))".
#if defined(__AVX2__) || defined(__clang__) || \
defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__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_V2
#if defined(__AVX2__) || defined(__clang__) #define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#elif defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#elif !defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
#pragma message("Wuffs with MSVC+X64 performs best with /arch:AVX2")
#endif // defined(__AVX2__) || defined(__clang__) || etc
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
#if defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
#error "MSVC_CPU_ARCH simultaneously enabled and disabled"
#endif
#include <intrin.h>
// intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use // intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use
// "__attribute__((target(arg)))" without e.g. "/arch:AVX". // "__attribute__((target(arg)))" without e.g. "/arch:AVX".
// //
@@ -134,23 +184,9 @@
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT #include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2 #include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL #include <wmmintrin.h> // AES, PCLMUL
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#else // defined(__AVX2__) || defined(__clang__) #endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// 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:AVX2 or -mavx2 compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#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(__AVX2__) || defined(__clang__)
#endif // defined(_M_X64) #endif // defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1) #endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0) #endif // (#if-chain ref AVOID_CPU_ARCH_0)
@@ -1700,3 +1736,17 @@ wuffs_base__table__flattened_length(size_t width,
WUFFS_BASE__MAYBE_STATIC int32_t // WUFFS_BASE__MAYBE_STATIC int32_t //
wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data, wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data,
bool prefix_closed); bool prefix_closed);
// ---------------- Quirk Values
// These constants are the value half of a key-value pair, where the key is
// WUFFS_BASE__QUIRK_QUALITY.
//
// In the Wuffs API, set_quirk takes a u64 value. These macro definitions are
// likewise unsigned values (uint64_t) but for this particular key, they are
// best interpreted as signed values (int64_t). "Lower-than-default quality"
// and "higher-than-default quality", as signed values, are -1 and +1.
//
// See doc/note/quirks.md for some more discussion about trade-offs.
#define WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY UINT64_MAX
#define WUFFS_BASE__QUIRK_QUALITY__VALUE__HIGHER_QUALITY ((uint64_t)1)
+4 -2
View File
@@ -39,8 +39,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
const wuffs_base__pixel_swizzler* p, const wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
wuffs_base__slice_u8 dst_palette, wuffs_base__slice_u8 dst_palette,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src0,
wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src1,
wuffs_base__slice_u8 src2, wuffs_base__slice_u8 src2,
+311 -117
View File
@@ -625,8 +625,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
static void // static void //
wuffs_private_impl__swizzle_ycck__general__triangle_filter( wuffs_private_impl__swizzle_ycck__general__triangle_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -648,6 +650,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
uint8_t* scratch_buffer_2k_ptr, uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) { wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) {
if ((x_min_incl != 0) || (y_min_incl != 0)) {
return;
}
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
@@ -660,7 +666,7 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
// First row. // First row.
uint32_t h1v2_bias = 1u; uint32_t h1v2_bias = 1u;
wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
dst, width, 0u, // dst, x_max_excl, 0u, //
src_ptr0, src_ptr1, src_ptr2, src_ptr3, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
@@ -672,10 +678,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
h1v2_bias = 2u; h1v2_bias = 2u;
// Middle rows. // Middle rows.
bool last_row = height == 2u * half_height_for_2to1; bool last_row = y_max_excl == 2u * half_height_for_2to1;
uint32_t y_max_excl = last_row ? (height - 1u) : height; uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl;
uint32_t y; uint32_t y;
for (y = 1u; y < y_max_excl; y++) { for (y = 1u; y < middle_y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
const uint8_t* src0_minor = const uint8_t* src0_minor =
(inv_v0 != 2u) (inv_v0 != 2u)
@@ -702,11 +708,11 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
uint32_t total_src_len3 = 0u; uint32_t total_src_len3 = 0u;
uint32_t x = 0u; uint32_t x = 0u;
while (x < width) { while (x < x_max_excl) {
bool first_column = x == 0u; bool first_column = x == 0u;
uint32_t end = x + 480u; uint32_t end = x + 480u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
@@ -762,9 +768,9 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
} }
// Last row. // Last row.
if (y_max_excl != height) { if (middle_y_max_excl != y_max_excl) {
wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
dst, width, height - 1u, // dst, x_max_excl, middle_y_max_excl, //
src_ptr0, src_ptr1, src_ptr2, src_ptr3, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
@@ -860,8 +866,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
static void // static void //
wuffs_private_impl__swizzle_ycc__general__triangle_filter( wuffs_private_impl__swizzle_ycc__general__triangle_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -879,6 +887,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
uint8_t* scratch_buffer_2k_ptr, uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
if ((x_min_incl != 0) || (y_min_incl != 0)) {
return;
}
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
@@ -889,7 +901,7 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
// First row. // First row.
uint32_t h1v2_bias = 1u; uint32_t h1v2_bias = 1u;
wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
dst, width, 0u, // dst, x_max_excl, 0u, //
src_ptr0, src_ptr1, src_ptr2, // src_ptr0, src_ptr1, src_ptr2, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
@@ -901,10 +913,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
h1v2_bias = 2u; h1v2_bias = 2u;
// Middle rows. // Middle rows.
bool last_row = height == 2u * half_height_for_2to1; bool last_row = y_max_excl == 2u * half_height_for_2to1;
uint32_t y_max_excl = last_row ? (height - 1u) : height; uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl;
uint32_t y; uint32_t y;
for (y = 1u; y < y_max_excl; y++) { for (y = 1u; y < middle_y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
const uint8_t* src0_minor = const uint8_t* src0_minor =
(inv_v0 != 2u) (inv_v0 != 2u)
@@ -925,11 +937,11 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
uint32_t total_src_len2 = 0u; uint32_t total_src_len2 = 0u;
uint32_t x = 0u; uint32_t x = 0u;
while (x < width) { while (x < x_max_excl) {
bool first_column = x == 0u; bool first_column = x == 0u;
uint32_t end = x + 672u; uint32_t end = x + 672u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
@@ -974,16 +986,16 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
} }
// Last row. // Last row.
if (y_max_excl != height) { if (middle_y_max_excl != y_max_excl) {
wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
dst, width, height - 1u, // dst, x_max_excl, middle_y_max_excl, //
src_ptr0, src_ptr1, src_ptr2, // src_ptr0, src_ptr1, src_ptr2, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
inv_v0, inv_v1, inv_v2, // inv_v0, inv_v1, inv_v2, //
half_width_for_2to1, // half_width_for_2to1, //
h1v2_bias, // h1v2_bias, //
scratch_buffer_2k_ptr, // scratch_buffer_2k_ptr, //
upfunc0, upfunc1, upfunc2, conv3func); upfunc0, upfunc1, upfunc2, conv3func);
} }
} }
@@ -991,8 +1003,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
static void // static void //
wuffs_private_impl__swizzle_ycc__general__box_filter( wuffs_private_impl__swizzle_ycc__general__box_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -1018,41 +1032,44 @@ wuffs_private_impl__swizzle_ycc__general__box_filter(
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
uint32_t y; uint32_t y;
for (y = 0u; y < height; y++) { for (y = y_min_incl; y < y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major =
const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0);
const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); const uint8_t* src1_major =
src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1);
const uint8_t* src2_major =
src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2);
uint32_t x = 0u; uint32_t x = x_min_incl;
while (x < width) { while (x < x_max_excl) {
uint32_t end = x + 672u; uint32_t end = x + 672u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
const uint8_t* up0 = (*upfunc0)( // const uint8_t* up0 = (*upfunc0)( //
scratch_buffer_2k_ptr + (0u * 672u), // scratch_buffer_2k_ptr + (0u * 672u), //
src0_major + (x / inv_h0), // src0_major + ((x - x_min_incl) / inv_h0), //
src0_major + (x / inv_h0), // src0_major + ((x - x_min_incl) / inv_h0), //
src_len0, // src_len0, //
0u, false, false); 0u, false, false);
const uint8_t* up1 = (*upfunc1)( // const uint8_t* up1 = (*upfunc1)( //
scratch_buffer_2k_ptr + (1u * 672u), // scratch_buffer_2k_ptr + (1u * 672u), //
src1_major + (x / inv_h1), // src1_major + ((x - x_min_incl) / inv_h1), //
src1_major + (x / inv_h1), // src1_major + ((x - x_min_incl) / inv_h1), //
src_len1, // src_len1, //
0u, false, false); 0u, false, false);
const uint8_t* up2 = (*upfunc2)( // const uint8_t* up2 = (*upfunc2)( //
scratch_buffer_2k_ptr + (2u * 672u), // scratch_buffer_2k_ptr + (2u * 672u), //
src2_major + (x / inv_h2), // src2_major + ((x - x_min_incl) / inv_h2), //
src2_major + (x / inv_h2), // src2_major + ((x - x_min_incl) / inv_h2), //
src_len2, // src_len2, //
0u, false, false); 0u, false, false);
(*conv3func)(dst, x, end, y, up0, up1, up2); (*conv3func)(dst, x, end, y, up0, up1, up2);
@@ -1061,6 +1078,100 @@ wuffs_private_impl__swizzle_ycc__general__box_filter(
} }
} }
static void //
wuffs_private_impl__swizzle_ycck__general__box_filter(
wuffs_base__pixel_buffer* dst,
uint32_t x_min_incl,
uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0,
const uint8_t* src_ptr1,
const uint8_t* src_ptr2,
const uint8_t* src_ptr3,
uint32_t stride0,
uint32_t stride1,
uint32_t stride2,
uint32_t stride3,
uint32_t inv_h0,
uint32_t inv_h1,
uint32_t inv_h2,
uint32_t inv_h3,
uint32_t inv_v0,
uint32_t inv_v1,
uint32_t inv_v2,
uint32_t inv_v3,
uint32_t half_width_for_2to1,
uint32_t half_height_for_2to1,
uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) {
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
(*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 =
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc3 =
(*upfuncs)[(inv_h3 - 1u) & 3u][(inv_v3 - 1u) & 3u];
uint32_t y;
for (y = y_min_incl; y < y_max_excl; y++) {
const uint8_t* src0_major =
src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0);
const uint8_t* src1_major =
src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1);
const uint8_t* src2_major =
src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2);
const uint8_t* src3_major =
src_ptr3 + (((y - y_min_incl) / inv_v3) * (size_t)stride3);
uint32_t x = x_min_incl;
while (x < x_max_excl) {
uint32_t end = x + 480u;
if (end > x_max_excl) {
end = x_max_excl;
}
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
uint32_t src_len3 = ((end - x) + inv_h3 - 1u) / inv_h3;
const uint8_t* up0 = (*upfunc0)( //
scratch_buffer_2k_ptr + (0u * 480u), //
src0_major + ((x - x_min_incl) / inv_h0), //
src0_major + ((x - x_min_incl) / inv_h0), //
src_len0, //
0u, false, false);
const uint8_t* up1 = (*upfunc1)( //
scratch_buffer_2k_ptr + (1u * 480u), //
src1_major + ((x - x_min_incl) / inv_h1), //
src1_major + ((x - x_min_incl) / inv_h1), //
src_len1, //
0u, false, false);
const uint8_t* up2 = (*upfunc2)( //
scratch_buffer_2k_ptr + (2u * 480u), //
src2_major + ((x - x_min_incl) / inv_h2), //
src2_major + ((x - x_min_incl) / inv_h2), //
src_len2, //
0u, false, false);
const uint8_t* up3 = (*upfunc3)( //
scratch_buffer_2k_ptr + (3u * 480u), //
src3_major + ((x - x_min_incl) / inv_h3), //
src3_major + ((x - x_min_incl) / inv_h3), //
src_len3, //
0u, false, false);
(*conv4func)(dst, x, end, y, up0, up1, up2, up3);
x = end;
}
}
}
// -------- // --------
// wuffs_private_impl__swizzle_flattened_length is like // wuffs_private_impl__swizzle_flattened_length is like
@@ -1085,8 +1196,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
const wuffs_base__pixel_swizzler* p, const wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
wuffs_base__slice_u8 dst_palette, wuffs_base__slice_u8 dst_palette,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src0,
wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src1,
wuffs_base__slice_u8 src2, wuffs_base__slice_u8 src2,
@@ -1116,13 +1229,18 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
wuffs_base__slice_u8 scratch_buffer_2k) { wuffs_base__slice_u8 scratch_buffer_2k) {
if (!p) { if (!p) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver); return wuffs_base__make_status(wuffs_base__error__bad_receiver);
} else if (!dst || (width > 0xFFFFu) || (height > 0xFFFFu) || // } else if (!dst || //
(4u <= ((unsigned int)h0 - 1u)) || // (x_min_incl > x_max_excl) || //
(4u <= ((unsigned int)h1 - 1u)) || // (x_max_excl > 0xFFFFu) || //
(4u <= ((unsigned int)h2 - 1u)) || // (y_min_incl > y_max_excl) || //
(4u <= ((unsigned int)v0 - 1u)) || // (y_max_excl > 0xFFFFu) || //
(4u <= ((unsigned int)v1 - 1u)) || // (4u <= ((unsigned int)h0 - 1u)) || //
(4u <= ((unsigned int)v2 - 1u)) || // (4u <= ((unsigned int)h1 - 1u)) || //
(4u <= ((unsigned int)h2 - 1u)) || //
(4u <= ((unsigned int)v0 - 1u)) || //
(4u <= ((unsigned int)v1 - 1u)) || //
(4u <= ((unsigned int)v2 - 1u)) || //
(triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) ||
(scratch_buffer_2k.len < 2048u)) { (scratch_buffer_2k.len < 2048u)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument); return wuffs_base__make_status(wuffs_base__error__bad_argument);
} }
@@ -1149,21 +1267,69 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
uint32_t inv_v2 = max_incl_v / v2; uint32_t inv_v2 = max_incl_v / v2;
uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u;
uint32_t half_width_for_2to1 = (width + 1u) / 2u; if (x_min_incl != 0) {
uint32_t half_height_for_2to1 = (height + 1u) / 2u; if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) ||
(x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
}
if (y_min_incl != 0) {
if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) ||
(y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
}
width = wuffs_private_impl__u32__min_of_5( // uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u;
width, // if (inv_h0 == 2) {
width0 * inv_h0, // half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0);
width1 * inv_h1, // }
width2 * inv_h2, // if (inv_h1 == 2) {
wuffs_base__pixel_config__width(&dst->pixcfg)); half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1);
height = wuffs_private_impl__u32__min_of_5( // }
height, // if (inv_h2 == 2) {
height0 * inv_v0, // half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2);
height1 * inv_v1, // }
height2 * inv_v2, // if (inv_h3 == 2) {
wuffs_base__pixel_config__height(&dst->pixcfg)); half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3);
}
uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u;
if (inv_v0 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0);
}
if (inv_v1 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1);
}
if (inv_v2 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2);
}
if (inv_v3 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3);
}
x_max_excl = wuffs_base__u32__min( //
wuffs_base__pixel_config__width(&dst->pixcfg), //
x_min_incl + wuffs_private_impl__u32__min_of_5( //
x_max_excl - x_min_incl, //
width0 * inv_h0, //
width1 * inv_h1, //
width2 * inv_h2, //
inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF));
y_max_excl = wuffs_base__u32__min( //
wuffs_base__pixel_config__height(&dst->pixcfg), //
y_min_incl + wuffs_private_impl__u32__min_of_5( //
y_max_excl - y_min_incl, //
height0 * inv_v0, //
height1 * inv_v1, //
height2 * inv_v2, //
inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF));
if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) {
return wuffs_base__make_status(NULL);
}
uint32_t width = x_max_excl - x_min_incl;
uint32_t height = y_max_excl - y_min_incl;
if (((h0 * inv_h0) != max_incl_h) || // if (((h0 * inv_h0) != max_incl_h) || //
((h1 * inv_h1) != max_incl_h) || // ((h1 * inv_h1) != max_incl_h) || //
@@ -1264,10 +1430,6 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
// ---- // ----
if ((width <= 0u) || (height <= 0u)) {
return wuffs_base__make_status(NULL);
}
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL;
if (is_rgb_or_cmyk) { if (is_rgb_or_cmyk) {
@@ -1302,28 +1464,58 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
} }
} }
void (*func)(wuffs_base__pixel_buffer * dst, // void (*func3)(wuffs_base__pixel_buffer * dst, //
uint32_t width, // uint32_t x_min_incl, //
uint32_t height, // uint32_t x_max_excl, //
const uint8_t* src_ptr0, // uint32_t y_min_incl, //
const uint8_t* src_ptr1, // uint32_t y_max_excl, //
const uint8_t* src_ptr2, // const uint8_t* src_ptr0, //
uint32_t stride0, // const uint8_t* src_ptr1, //
uint32_t stride1, // const uint8_t* src_ptr2, //
uint32_t stride2, // uint32_t stride0, //
uint32_t inv_h0, // uint32_t stride1, //
uint32_t inv_h1, // uint32_t stride2, //
uint32_t inv_h2, // uint32_t inv_h0, //
uint32_t inv_v0, // uint32_t inv_h1, //
uint32_t inv_v1, // uint32_t inv_h2, //
uint32_t inv_v2, // uint32_t inv_v0, //
uint32_t half_width_for_2to1, // uint32_t inv_v1, //
uint32_t half_height_for_2to1, // uint32_t inv_v2, //
uint8_t* scratch_buffer_2k_ptr, // uint32_t half_width_for_2to1, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], uint32_t half_height_for_2to1, //
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) = uint8_t* scratch_buffer_2k_ptr, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) =
&wuffs_private_impl__swizzle_ycc__general__box_filter; &wuffs_private_impl__swizzle_ycc__general__box_filter;
void (*func4)(wuffs_base__pixel_buffer * dst, //
uint32_t x_min_incl, //
uint32_t x_max_excl, //
uint32_t y_min_incl, //
uint32_t y_max_excl, //
const uint8_t* src_ptr0, //
const uint8_t* src_ptr1, //
const uint8_t* src_ptr2, //
const uint8_t* src_ptr3, //
uint32_t stride0, //
uint32_t stride1, //
uint32_t stride2, //
uint32_t stride3, //
uint32_t inv_h0, //
uint32_t inv_h1, //
uint32_t inv_h2, //
uint32_t inv_h3, //
uint32_t inv_v0, //
uint32_t inv_v1, //
uint32_t inv_v2, //
uint32_t inv_v3, //
uint32_t half_width_for_2to1, //
uint32_t half_height_for_2to1, //
uint8_t* scratch_buffer_2k_ptr, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) =
&wuffs_private_impl__swizzle_ycck__general__box_filter;
wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4]; wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4];
memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs, memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs,
sizeof upfuncs); sizeof upfuncs);
@@ -1331,8 +1523,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
if (triangle_filter_for_2to1 && if (triangle_filter_for_2to1 &&
(wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) || (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) || wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2))) { wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) ||
func = &wuffs_private_impl__swizzle_ycc__general__triangle_filter; wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h3, inv_v3))) {
func3 = &wuffs_private_impl__swizzle_ycc__general__triangle_filter;
func4 = &wuffs_private_impl__swizzle_ycck__general__triangle_filter;
upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle; upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle;
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle; upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
@@ -1364,23 +1558,23 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = wuffs_private_impl__swizzle_ycc__convert_4_func conv4func =
is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general
: &wuffs_private_impl__swizzle_ycck__convert_4_general; : &wuffs_private_impl__swizzle_ycck__convert_4_general;
wuffs_private_impl__swizzle_ycck__general__triangle_filter( // (*func4)( //
dst, width, height, // dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
src0.ptr, src1.ptr, src2.ptr, src3.ptr, // src0.ptr, src1.ptr, src2.ptr, src3.ptr, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
inv_v0, inv_v1, inv_v2, inv_v3, // inv_v0, inv_v1, inv_v2, inv_v3, //
half_width_for_2to1, half_height_for_2to1, // half_width_for_2to1, half_height_for_2to1, //
scratch_buffer_2k.ptr, &upfuncs, conv4func); scratch_buffer_2k.ptr, &upfuncs, conv4func);
} else { } else {
(*func)( // (*func3)( //
dst, width, height, // dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
src0.ptr, src1.ptr, src2.ptr, // src0.ptr, src1.ptr, src2.ptr, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
inv_v0, inv_v1, inv_v2, // inv_v0, inv_v1, inv_v2, //
half_width_for_2to1, half_height_for_2to1, // half_width_for_2to1, half_height_for_2to1, //
scratch_buffer_2k.ptr, &upfuncs, conv3func); scratch_buffer_2k.ptr, &upfuncs, conv3func);
} }
+50 -42
View File
@@ -39,49 +39,53 @@ wuffs_base__make_token(uint64_t repr) {
// -------- // --------
#define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF // clang-format off
#define WUFFS_BASE__TOKEN__VALUE__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42
#define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38
#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17
#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16
#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46
// -------- // --------
#define WUFFS_BASE__TOKEN__VBC__FILLER 0 #define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF
#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1
#define WUFFS_BASE__TOKEN__VBC__STRING 2 #define WUFFS_BASE__TOKEN__VALUE__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3 #define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__LITERAL 4 #define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42
#define WUFFS_BASE__TOKEN__VBC__NUMBER 5 #define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6 #define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38
#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17
#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16
#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46
// --------
#define WUFFS_BASE__TOKEN__VBC__FILLER 0
#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1
#define WUFFS_BASE__TOKEN__VBC__STRING 2
#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3
#define WUFFS_BASE__TOKEN__VBC__LITERAL 4
#define WUFFS_BASE__TOKEN__VBC__NUMBER 5
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7 #define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001 #define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004
// COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE. // COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE.
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000
// -------- // --------
@@ -101,11 +105,11 @@ wuffs_base__make_token(uint64_t repr) {
// //
// The lack of any particular bit is conservative: it is valid for all-ASCII // The lack of any particular bit is conservative: it is valid for all-ASCII
// strings, in a single- or multi-token chain, to have none of these bits set. // strings, in a single- or multi-token chain, to have none of these bits set.
#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8 0x00001 #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8 0x00001
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004
#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010 #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040
// CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded) // CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded)
@@ -120,22 +124,22 @@ wuffs_base__make_token(uint64_t repr) {
// When src is the empty string, multiple conversion algorithms are applicable // When src is the empty string, multiple conversion algorithms are applicable
// (so these bits are not necessarily mutually exclusive), all producing the // (so these bits are not necessarily mutually exclusive), all producing the
// same empty dst string. // same empty dst string.
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001 #define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001
#define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002 #define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002
#define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004 #define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004
#define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008 #define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008
// -------- // --------
@@ -148,8 +152,8 @@ wuffs_base__make_token(uint64_t repr) {
// For a source string of "+123" or "-0x9A", only the first two are valid. // For a source string of "+123" or "-0x9A", only the first two are valid.
// //
// For a source string of "123.", only the first one is valid. // For a source string of "123.", only the first one is valid.
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010
@@ -161,11 +165,15 @@ wuffs_base__make_token(uint64_t repr) {
// "300", which are big-endian, little-endian or text. For binary formats, the // "300", which are big-endian, little-endian or text. For binary formats, the
// token length (after adjusting for FORMAT_IGNORE_ETC) discriminates // token length (after adjusting for FORMAT_IGNORE_ETC) discriminates
// e.g. u16 little-endian vs u32 little-endian. // e.g. u16 little-endian vs u32 little-endian.
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000
// --------
// clang-format on
// -------- // --------
+10
View File
@@ -237,6 +237,16 @@ func (b *buffer) writeb(x byte) { *b = append(*b, x)
func (b *buffer) writes(s string) { *b = append(*b, s...) } func (b *buffer) writes(s string) { *b = append(*b, s...) }
func (b *buffer) writex(s []byte) { *b = append(*b, s...) } func (b *buffer) writex(s []byte) { *b = append(*b, s...) }
func (b *buffer) undoWrites(s string) bool {
nb := len(*b)
ns := len(s)
if (nb < ns) || (string((*b)[nb-ns:]) != s) {
return false
}
*b = (*b)[:nb-ns]
return true
}
func expandBangInsert(b *buffer, s string, m map[string]func(*buffer) error) error { func expandBangInsert(b *buffer, s string, m map[string]func(*buffer) error) error {
for { for {
remaining := "" remaining := ""
+15 -8
View File
@@ -183,14 +183,23 @@ func (g *gen) writeStatementAssign1(b *buffer, op t.ID, lhs *a.Expr, rhs *a.Expr
} }
} }
} }
const disableWconversion0 = "" +
"#if defined(__GNUC__)\n" +
"#pragma GCC diagnostic push\n" +
"#pragma GCC diagnostic ignored \"-Wconversion\"\n" +
"#endif\n"
const disableWconversion1 = "" +
"#if defined(__GNUC__)\n" +
"#pragma GCC diagnostic pop\n" +
"#endif\n"
// "x += 1" triggers -Wconversion, if x is smaller than an int (i.e. a // "x += 1" triggers -Wconversion, if x is smaller than an int (i.e. a
// uint8_t or a uint16_t). This is arguably a clang/gcc bug, but in any // uint8_t or a uint16_t). This is arguably a clang/gcc bug, but in any
// case, we work around it in Wuffs. // case, we work around it in Wuffs.
if disableWconversion { if disableWconversion && !b.undoWrites(disableWconversion1) {
b.writes("#if defined(__GNUC__)\n") b.writes(disableWconversion0)
b.writes("#pragma GCC diagnostic push\n")
b.writes("#pragma GCC diagnostic ignored \"-Wconversion\"\n")
b.writes("#endif\n")
} }
n := len(*b) n := len(*b)
@@ -213,9 +222,7 @@ func (g *gen) writeStatementAssign1(b *buffer, op t.ID, lhs *a.Expr, rhs *a.Expr
} }
if disableWconversion { if disableWconversion {
b.writes("#if defined(__GNUC__)\n") b.writes(disableWconversion1)
b.writes("#pragma GCC diagnostic pop\n")
b.writes("#endif\n")
} }
return nil return nil
+6 -2
View File
@@ -153,6 +153,7 @@ var Consts = [...]struct {
// ---- // ----
{t.IDU32, "1", "QUIRK_IGNORE_CHECKSUM"}, {t.IDU32, "1", "QUIRK_IGNORE_CHECKSUM"},
{t.IDU32, "2", "QUIRK_QUALITY"},
// ---- // ----
@@ -395,6 +396,7 @@ var funcsOther = [...]string{
"min_incl_x: u32, min_incl_y: u32, max_incl_x: u32, max_incl_y: u32) rect_ii_u32", "min_incl_x: u32, min_incl_y: u32, max_incl_x: u32, max_incl_y: u32) rect_ii_u32",
"utility.make_rect_ie_u32(" + "utility.make_rect_ie_u32(" +
"min_incl_x: u32, min_incl_y: u32, max_excl_x: u32, max_excl_y: u32) rect_ie_u32", "min_incl_x: u32, min_incl_y: u32, max_excl_x: u32, max_excl_y: u32) rect_ie_u32",
"utility.sign_extend_convert_u8_u32(a: u8) u32",
"utility.sign_extend_convert_u16_u32(a: u16) u32", "utility.sign_extend_convert_u16_u32(a: u16) u32",
"utility.sign_extend_rshift_u32(a: u32, n: u32[..= 31]) u32", "utility.sign_extend_rshift_u32(a: u32, n: u32[..= 31]) u32",
"utility.sign_extend_rshift_u64(a: u64, n: u32[..= 63]) u64", "utility.sign_extend_rshift_u64(a: u64, n: u32[..= 63]) u64",
@@ -690,8 +692,10 @@ var funcsOther = [...]string{
"pixel_swizzler.swizzle_ycck!(" + "pixel_swizzler.swizzle_ycck!(" +
"dst: ptr pixel_buffer," + "dst: ptr pixel_buffer," +
"dst_palette: slice u8," + "dst_palette: slice u8," +
"width: u32[..= 0xFFFF]," + "x_min_incl: u32[..= 0xFFFF]," +
"height: u32[..= 0xFFFF]," + "x_max_excl: u32[..= 0xFFFF]," +
"y_min_incl: u32[..= 0xFFFF]," +
"y_max_excl: u32[..= 0xFFFF]," +
"src0: slice u8," + "src0: slice u8," +
"src1: slice u8," + "src1: slice u8," +
"src2: slice u8," + "src2: slice u8," +
+27 -8
View File
@@ -207,11 +207,30 @@ func invert(tm *t.Map, n *a.Expr) (*a.Expr, error) {
return o, nil return o, nil
} }
var errUpdateReturnsNil = errors.New("update returns nil")
func updateFactsForSuspension(x *a.Expr) (*a.Expr, error) { func updateFactsForSuspension(x *a.Expr) (*a.Expr, error) {
if x.Mentions(exprArgs) || x.Mentions(exprThis) { // Drop any facts involving args, this or ptr-typed local variables.
if err := x.AsNode().Walk(func(innerNode *a.Node) error {
if innerNode.Kind() != a.KExpr {
return nil
}
n := innerNode.AsExpr()
if n.MType().HasPointers() {
return errUpdateReturnsNil
} else if n.Operator() == 0 {
switch n.Ident() {
case t.IDArgs, t.IDThis:
return errUpdateReturnsNil
}
}
return nil
}); err == errUpdateReturnsNil {
return nil, nil return nil, nil
} else if err != nil {
return nil, err
} }
// TODO: drop any facts involving ptr-typed local variables?
return x, nil return x, nil
} }
@@ -463,18 +482,18 @@ func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error {
lTyp = lhs.MType() lTyp = lhs.MType()
} }
if (rhs.Operator() == a.ExprOperatorCall) && rhs.Effect().Coroutine() && (op != t.IDEqQuestion) {
if err := q.facts.update(updateFactsForSuspension); err != nil {
return err
}
}
nb, err := q.bcheckAssignment1(lhs, lTyp, op, rhs) nb, err := q.bcheckAssignment1(lhs, lTyp, op, rhs)
if err != nil { if err != nil {
return err return err
} }
if (rhs.Operator() == a.ExprOperatorCall) && rhs.Effect().Impure() { if (rhs.Operator() == a.ExprOperatorCall) && rhs.Effect().Impure() {
if rhs.Effect().Coroutine() && (op != t.IDEqQuestion) {
if err := q.facts.update(updateFactsForSuspension); err != nil {
return err
}
}
recv := rhs.LHS().AsExpr().LHS().AsExpr() recv := rhs.LHS().AsExpr().LHS().AsExpr()
if err := q.facts.update(func(x *a.Expr) (*a.Expr, error) { if err := q.facts.update(func(x *a.Expr) (*a.Expr, error) {
if _, ok := oldFacts[x]; !ok { if _, ok := oldFacts[x]; !ok {
+823 -757
View File
@@ -175,12 +175,62 @@ extern "C" {
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1) #elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_X64) #if defined(_M_X64)
// We need <intrin.h> for the __cpuid function.
#include <intrin.h> // On X86_64, Microsoft Visual C/C++ (MSVC) only supports SSE2 by default.
// There are /arch:SSE2, /arch:AVX and /arch:AVX2 compiler flags (the AVX2 one
// is roughly equivalent to X86_64_V3), but there is no /arch:SSE42 compiler
// flag that's equivalent to X86_64_V2.
//
// For getting maximum performance with X86_64 MSVC and Wuffs, pass /arch:AVX2
// (and then test on the oldest hardware you intend to support).
//
// Absent that compiler flag, either define one of the three macros listed
// below or else the X86_64 SIMD code will be disabled and you'll get a #pragma
// message stating this library "performs best with /arch:AVX2". This message
// is harmless and ignorable, in that the non-SIMD code is still correct and
// reasonably performant, but is a reminder that when combining Wuffs and MSVC,
// some compiler configuration is required for maximum performance.
//
// - WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY
// - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2 (enables SSE4.2 and below)
// - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3 (enables AVX2 and below)
//
// Defining the first one (WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
// or defining none of those three (the default state) are equivalent (in that
// both disable the SIMD code paths), other than that pragma message.
//
// When defining these WUFFS_CONFIG__ENABLE_ETC macros with MSVC, be aware that
// some users report it leading to ICEs (Internal Compiler Errors), but other
// users report no problems at all (and improved performance). It's unclear
// exactly what combination of SIMD code and MSVC configuration lead to ICEs.
// Do your own testing with your own MSVC version and configuration.
//
// https://github.com/google/wuffs/issues/148
// https://github.com/google/wuffs/issues/151
// https://developercommunity.visualstudio.com/t/fatal--error-C1001:-Internal-compiler-er/10703305
//
// Clang (including clang-cl) and GCC don't need this WUFFS_CONFIG__ETC macro
// machinery, or having the Wuffs-the-library user to fiddle with compiler
// flags, because they support "__attribute__((target(arg)))".
#if defined(__AVX2__) || defined(__clang__) || \
defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__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_V2
#if defined(__AVX2__) || defined(__clang__) #define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#elif defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#elif !defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
#pragma message("Wuffs with MSVC+X64 performs best with /arch:AVX2")
#endif // defined(__AVX2__) || defined(__clang__) || etc
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
#if defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
#error "MSVC_CPU_ARCH simultaneously enabled and disabled"
#endif
#include <intrin.h>
// intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use // intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use
// "__attribute__((target(arg)))" without e.g. "/arch:AVX". // "__attribute__((target(arg)))" without e.g. "/arch:AVX".
// //
@@ -190,23 +240,9 @@ extern "C" {
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT #include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2 #include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL #include <wmmintrin.h> // AES, PCLMUL
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#else // defined(__AVX2__) || defined(__clang__) #endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// 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:AVX2 or -mavx2 compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#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(__AVX2__) || defined(__clang__)
#endif // defined(_M_X64) #endif // defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1) #endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0) #endif // (#if-chain ref AVOID_CPU_ARCH_0)
@@ -913,6 +949,8 @@ typedef struct wuffs_base__transform__output__struct {
#define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1 #define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1
#define WUFFS_BASE__QUIRK_QUALITY 2
// -------- // --------
// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a
@@ -1978,6 +2016,20 @@ WUFFS_BASE__MAYBE_STATIC int32_t //
wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data, wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data,
bool prefix_closed); bool prefix_closed);
// ---------------- Quirk Values
// These constants are the value half of a key-value pair, where the key is
// WUFFS_BASE__QUIRK_QUALITY.
//
// In the Wuffs API, set_quirk takes a u64 value. These macro definitions are
// likewise unsigned values (uint64_t) but for this particular key, they are
// best interpreted as signed values (int64_t). "Lower-than-default quality"
// and "higher-than-default quality", as signed values, are -1 and +1.
//
// See doc/note/quirks.md for some more discussion about trade-offs.
#define WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY UINT64_MAX
#define WUFFS_BASE__QUIRK_QUALITY__VALUE__HIGHER_QUALITY ((uint64_t)1)
// ---------------- Ranges and Rects // ---------------- Ranges and Rects
// See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md // See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md
@@ -3350,49 +3402,53 @@ wuffs_base__make_token(uint64_t repr) {
// -------- // --------
#define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF // clang-format off
#define WUFFS_BASE__TOKEN__VALUE__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42
#define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38
#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17
#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16
#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46
// -------- // --------
#define WUFFS_BASE__TOKEN__VBC__FILLER 0 #define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF
#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1
#define WUFFS_BASE__TOKEN__VBC__STRING 2 #define WUFFS_BASE__TOKEN__VALUE__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3 #define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__LITERAL 4 #define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42
#define WUFFS_BASE__TOKEN__VBC__NUMBER 5 #define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6 #define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38
#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17
#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16
#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46
// --------
#define WUFFS_BASE__TOKEN__VBC__FILLER 0
#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1
#define WUFFS_BASE__TOKEN__VBC__STRING 2
#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3
#define WUFFS_BASE__TOKEN__VBC__LITERAL 4
#define WUFFS_BASE__TOKEN__VBC__NUMBER 5
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7 #define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001 #define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004
// COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE. // COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE.
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000
// -------- // --------
@@ -3412,11 +3468,11 @@ wuffs_base__make_token(uint64_t repr) {
// //
// The lack of any particular bit is conservative: it is valid for all-ASCII // The lack of any particular bit is conservative: it is valid for all-ASCII
// strings, in a single- or multi-token chain, to have none of these bits set. // strings, in a single- or multi-token chain, to have none of these bits set.
#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8 0x00001 #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8 0x00001
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004
#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010 #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040
// CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded) // CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded)
@@ -3431,22 +3487,22 @@ wuffs_base__make_token(uint64_t repr) {
// When src is the empty string, multiple conversion algorithms are applicable // When src is the empty string, multiple conversion algorithms are applicable
// (so these bits are not necessarily mutually exclusive), all producing the // (so these bits are not necessarily mutually exclusive), all producing the
// same empty dst string. // same empty dst string.
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001 #define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001
#define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002 #define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002
#define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004 #define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004
#define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008 #define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008
// -------- // --------
@@ -3459,8 +3515,8 @@ wuffs_base__make_token(uint64_t repr) {
// For a source string of "+123" or "-0x9A", only the first two are valid. // For a source string of "+123" or "-0x9A", only the first two are valid.
// //
// For a source string of "123.", only the first one is valid. // For a source string of "123.", only the first one is valid.
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010
@@ -3472,11 +3528,15 @@ wuffs_base__make_token(uint64_t repr) {
// "300", which are big-endian, little-endian or text. For binary formats, the // "300", which are big-endian, little-endian or text. For binary formats, the
// token length (after adjusting for FORMAT_IGNORE_ETC) discriminates // token length (after adjusting for FORMAT_IGNORE_ETC) discriminates
// e.g. u16 little-endian vs u32 little-endian. // e.g. u16 little-endian vs u32 little-endian.
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000
// --------
// clang-format on
// -------- // --------
@@ -9601,6 +9661,7 @@ extern const char wuffs_jpeg__error__bad_sof_marker[];
extern const char wuffs_jpeg__error__bad_sos_marker[]; extern const char wuffs_jpeg__error__bad_sos_marker[];
extern const char wuffs_jpeg__error__bad_header[]; extern const char wuffs_jpeg__error__bad_header[];
extern const char wuffs_jpeg__error__bad_marker[]; extern const char wuffs_jpeg__error__bad_marker[];
extern const char wuffs_jpeg__error__bad_scan_count[];
extern const char wuffs_jpeg__error__missing_huffman_table[]; extern const char wuffs_jpeg__error__missing_huffman_table[];
extern const char wuffs_jpeg__error__missing_quantization_table[]; extern const char wuffs_jpeg__error__missing_quantization_table[];
extern const char wuffs_jpeg__error__truncated_input[]; extern const char wuffs_jpeg__error__truncated_input[];
@@ -9845,6 +9906,12 @@ struct wuffs_jpeg__decoder__struct {
uint32_t f_bitstream_ri; uint32_t f_bitstream_ri;
uint32_t f_bitstream_wi; uint32_t f_bitstream_wi;
bool f_bitstream_is_closed; bool f_bitstream_is_closed;
bool f_expect_multiple_scans;
bool f_use_lower_quality;
bool f_swizzle_immediately;
wuffs_base__status f_swizzle_immediately_status;
uint32_t f_swizzle_immediately_b_offsets[10];
uint32_t f_swizzle_immediately_c_offsets[5];
uint32_t f_bitstream_padding; uint32_t f_bitstream_padding;
uint16_t f_quant_tables[4][64]; uint16_t f_quant_tables[4][64];
uint16_t f_saved_quant_tables[4][64]; uint16_t f_saved_quant_tables[4][64];
@@ -9880,6 +9947,7 @@ struct wuffs_jpeg__decoder__struct {
uint32_t p_skip_past_the_next_restart_marker; uint32_t p_skip_past_the_next_restart_marker;
uint32_t (*choosy_decode_mcu)( uint32_t (*choosy_decode_mcu)(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -9888,6 +9956,7 @@ struct wuffs_jpeg__decoder__struct {
struct { struct {
uint8_t f_bitstream_buffer[2048]; uint8_t f_bitstream_buffer[2048];
uint16_t f_mcu_blocks[10][64]; uint16_t f_mcu_blocks[10][64];
uint8_t f_swizzle_immediately_buffer[640];
uint8_t f_swizzle_ycck_scratch_buffer_2k[2048]; uint8_t f_swizzle_ycck_scratch_buffer_2k[2048];
uint8_t f_dht_temp_counts[16]; uint8_t f_dht_temp_counts[16];
uint8_t f_dht_temp_bit_lengths[256]; uint8_t f_dht_temp_bit_lengths[256];
@@ -14992,6 +15061,7 @@ struct wuffs_xz__decoder__struct {
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
#include <utility>
namespace wuffs_aux { namespace wuffs_aux {
@@ -15004,6 +15074,8 @@ using IOBuffer = wuffs_base__io_buffer;
// nullptr, since calling free(nullptr) is a no-op. // nullptr, since calling free(nullptr) is a no-op.
using MemOwner = std::unique_ptr<void, decltype(&free)>; using MemOwner = std::unique_ptr<void, decltype(&free)>;
using QuirkKeyValuePair = std::pair<uint32_t, uint64_t>;
namespace sync_io { namespace sync_io {
// -------- // --------
@@ -15186,13 +15258,14 @@ class DecodeCborCallbacks {
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor. // DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
struct DecodeCborArgQuirks { struct DecodeCborArgQuirks {
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeCborArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeCborArgQuirks DefaultValue(); static DecodeCborArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeCbor calls callbacks based on the CBOR-formatted data in input. // DecodeCbor calls callbacks based on the CBOR-formatted data in input.
@@ -15400,13 +15473,14 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
// DecodeImageArgQuirks wraps an optional argument to DecodeImage. // DecodeImageArgQuirks wraps an optional argument to DecodeImage.
struct DecodeImageArgQuirks { struct DecodeImageArgQuirks {
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeImageArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeImageArgQuirks DefaultValue(); static DecodeImageArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeImageArgFlags wraps an optional argument to DecodeImage. // DecodeImageArgFlags wraps an optional argument to DecodeImage.
@@ -15618,13 +15692,14 @@ extern const char DecodeJson_NoMatch[];
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson. // DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
struct DecodeJsonArgQuirks { struct DecodeJsonArgQuirks {
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeJsonArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeJsonArgQuirks DefaultValue(); static DecodeJsonArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson. // DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
@@ -15834,6 +15909,9 @@ wuffs_private_impl__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {
// ---------------- Numeric Types (Utility) // ---------------- Numeric Types (Utility)
#define wuffs_base__utility__sign_extend_convert_u8_u32(a) \
((uint32_t)(int32_t)(int8_t)(a))
#define wuffs_base__utility__sign_extend_convert_u16_u32(a) \ #define wuffs_base__utility__sign_extend_convert_u16_u32(a) \
((uint32_t)(int32_t)(int16_t)(a)) ((uint32_t)(int32_t)(int16_t)(a))
@@ -16543,8 +16621,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
const wuffs_base__pixel_swizzler* p, const wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
wuffs_base__slice_u8 dst_palette, wuffs_base__slice_u8 dst_palette,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src0,
wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src1,
wuffs_base__slice_u8 src2, wuffs_base__slice_u8 src2,
@@ -28479,8 +28559,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
static void // static void //
wuffs_private_impl__swizzle_ycck__general__triangle_filter( wuffs_private_impl__swizzle_ycck__general__triangle_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -28502,6 +28584,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
uint8_t* scratch_buffer_2k_ptr, uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) { wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) {
if ((x_min_incl != 0) || (y_min_incl != 0)) {
return;
}
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
@@ -28514,7 +28600,7 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
// First row. // First row.
uint32_t h1v2_bias = 1u; uint32_t h1v2_bias = 1u;
wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
dst, width, 0u, // dst, x_max_excl, 0u, //
src_ptr0, src_ptr1, src_ptr2, src_ptr3, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
@@ -28526,10 +28612,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
h1v2_bias = 2u; h1v2_bias = 2u;
// Middle rows. // Middle rows.
bool last_row = height == 2u * half_height_for_2to1; bool last_row = y_max_excl == 2u * half_height_for_2to1;
uint32_t y_max_excl = last_row ? (height - 1u) : height; uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl;
uint32_t y; uint32_t y;
for (y = 1u; y < y_max_excl; y++) { for (y = 1u; y < middle_y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
const uint8_t* src0_minor = const uint8_t* src0_minor =
(inv_v0 != 2u) (inv_v0 != 2u)
@@ -28556,11 +28642,11 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
uint32_t total_src_len3 = 0u; uint32_t total_src_len3 = 0u;
uint32_t x = 0u; uint32_t x = 0u;
while (x < width) { while (x < x_max_excl) {
bool first_column = x == 0u; bool first_column = x == 0u;
uint32_t end = x + 480u; uint32_t end = x + 480u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
@@ -28616,9 +28702,9 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
} }
// Last row. // Last row.
if (y_max_excl != height) { if (middle_y_max_excl != y_max_excl) {
wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
dst, width, height - 1u, // dst, x_max_excl, middle_y_max_excl, //
src_ptr0, src_ptr1, src_ptr2, src_ptr3, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
@@ -28714,8 +28800,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
static void // static void //
wuffs_private_impl__swizzle_ycc__general__triangle_filter( wuffs_private_impl__swizzle_ycc__general__triangle_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -28733,6 +28821,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
uint8_t* scratch_buffer_2k_ptr, uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
if ((x_min_incl != 0) || (y_min_incl != 0)) {
return;
}
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
@@ -28743,7 +28835,7 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
// First row. // First row.
uint32_t h1v2_bias = 1u; uint32_t h1v2_bias = 1u;
wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
dst, width, 0u, // dst, x_max_excl, 0u, //
src_ptr0, src_ptr1, src_ptr2, // src_ptr0, src_ptr1, src_ptr2, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
@@ -28755,10 +28847,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
h1v2_bias = 2u; h1v2_bias = 2u;
// Middle rows. // Middle rows.
bool last_row = height == 2u * half_height_for_2to1; bool last_row = y_max_excl == 2u * half_height_for_2to1;
uint32_t y_max_excl = last_row ? (height - 1u) : height; uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl;
uint32_t y; uint32_t y;
for (y = 1u; y < y_max_excl; y++) { for (y = 1u; y < middle_y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
const uint8_t* src0_minor = const uint8_t* src0_minor =
(inv_v0 != 2u) (inv_v0 != 2u)
@@ -28779,11 +28871,11 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
uint32_t total_src_len2 = 0u; uint32_t total_src_len2 = 0u;
uint32_t x = 0u; uint32_t x = 0u;
while (x < width) { while (x < x_max_excl) {
bool first_column = x == 0u; bool first_column = x == 0u;
uint32_t end = x + 672u; uint32_t end = x + 672u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
@@ -28828,16 +28920,16 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
} }
// Last row. // Last row.
if (y_max_excl != height) { if (middle_y_max_excl != y_max_excl) {
wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
dst, width, height - 1u, // dst, x_max_excl, middle_y_max_excl, //
src_ptr0, src_ptr1, src_ptr2, // src_ptr0, src_ptr1, src_ptr2, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
inv_v0, inv_v1, inv_v2, // inv_v0, inv_v1, inv_v2, //
half_width_for_2to1, // half_width_for_2to1, //
h1v2_bias, // h1v2_bias, //
scratch_buffer_2k_ptr, // scratch_buffer_2k_ptr, //
upfunc0, upfunc1, upfunc2, conv3func); upfunc0, upfunc1, upfunc2, conv3func);
} }
} }
@@ -28845,8 +28937,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
static void // static void //
wuffs_private_impl__swizzle_ycc__general__box_filter( wuffs_private_impl__swizzle_ycc__general__box_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -28872,41 +28966,44 @@ wuffs_private_impl__swizzle_ycc__general__box_filter(
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
uint32_t y; uint32_t y;
for (y = 0u; y < height; y++) { for (y = y_min_incl; y < y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major =
const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0);
const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); const uint8_t* src1_major =
src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1);
const uint8_t* src2_major =
src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2);
uint32_t x = 0u; uint32_t x = x_min_incl;
while (x < width) { while (x < x_max_excl) {
uint32_t end = x + 672u; uint32_t end = x + 672u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
const uint8_t* up0 = (*upfunc0)( // const uint8_t* up0 = (*upfunc0)( //
scratch_buffer_2k_ptr + (0u * 672u), // scratch_buffer_2k_ptr + (0u * 672u), //
src0_major + (x / inv_h0), // src0_major + ((x - x_min_incl) / inv_h0), //
src0_major + (x / inv_h0), // src0_major + ((x - x_min_incl) / inv_h0), //
src_len0, // src_len0, //
0u, false, false); 0u, false, false);
const uint8_t* up1 = (*upfunc1)( // const uint8_t* up1 = (*upfunc1)( //
scratch_buffer_2k_ptr + (1u * 672u), // scratch_buffer_2k_ptr + (1u * 672u), //
src1_major + (x / inv_h1), // src1_major + ((x - x_min_incl) / inv_h1), //
src1_major + (x / inv_h1), // src1_major + ((x - x_min_incl) / inv_h1), //
src_len1, // src_len1, //
0u, false, false); 0u, false, false);
const uint8_t* up2 = (*upfunc2)( // const uint8_t* up2 = (*upfunc2)( //
scratch_buffer_2k_ptr + (2u * 672u), // scratch_buffer_2k_ptr + (2u * 672u), //
src2_major + (x / inv_h2), // src2_major + ((x - x_min_incl) / inv_h2), //
src2_major + (x / inv_h2), // src2_major + ((x - x_min_incl) / inv_h2), //
src_len2, // src_len2, //
0u, false, false); 0u, false, false);
(*conv3func)(dst, x, end, y, up0, up1, up2); (*conv3func)(dst, x, end, y, up0, up1, up2);
@@ -28915,6 +29012,100 @@ wuffs_private_impl__swizzle_ycc__general__box_filter(
} }
} }
static void //
wuffs_private_impl__swizzle_ycck__general__box_filter(
wuffs_base__pixel_buffer* dst,
uint32_t x_min_incl,
uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0,
const uint8_t* src_ptr1,
const uint8_t* src_ptr2,
const uint8_t* src_ptr3,
uint32_t stride0,
uint32_t stride1,
uint32_t stride2,
uint32_t stride3,
uint32_t inv_h0,
uint32_t inv_h1,
uint32_t inv_h2,
uint32_t inv_h3,
uint32_t inv_v0,
uint32_t inv_v1,
uint32_t inv_v2,
uint32_t inv_v3,
uint32_t half_width_for_2to1,
uint32_t half_height_for_2to1,
uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) {
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
(*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 =
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc3 =
(*upfuncs)[(inv_h3 - 1u) & 3u][(inv_v3 - 1u) & 3u];
uint32_t y;
for (y = y_min_incl; y < y_max_excl; y++) {
const uint8_t* src0_major =
src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0);
const uint8_t* src1_major =
src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1);
const uint8_t* src2_major =
src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2);
const uint8_t* src3_major =
src_ptr3 + (((y - y_min_incl) / inv_v3) * (size_t)stride3);
uint32_t x = x_min_incl;
while (x < x_max_excl) {
uint32_t end = x + 480u;
if (end > x_max_excl) {
end = x_max_excl;
}
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
uint32_t src_len3 = ((end - x) + inv_h3 - 1u) / inv_h3;
const uint8_t* up0 = (*upfunc0)( //
scratch_buffer_2k_ptr + (0u * 480u), //
src0_major + ((x - x_min_incl) / inv_h0), //
src0_major + ((x - x_min_incl) / inv_h0), //
src_len0, //
0u, false, false);
const uint8_t* up1 = (*upfunc1)( //
scratch_buffer_2k_ptr + (1u * 480u), //
src1_major + ((x - x_min_incl) / inv_h1), //
src1_major + ((x - x_min_incl) / inv_h1), //
src_len1, //
0u, false, false);
const uint8_t* up2 = (*upfunc2)( //
scratch_buffer_2k_ptr + (2u * 480u), //
src2_major + ((x - x_min_incl) / inv_h2), //
src2_major + ((x - x_min_incl) / inv_h2), //
src_len2, //
0u, false, false);
const uint8_t* up3 = (*upfunc3)( //
scratch_buffer_2k_ptr + (3u * 480u), //
src3_major + ((x - x_min_incl) / inv_h3), //
src3_major + ((x - x_min_incl) / inv_h3), //
src_len3, //
0u, false, false);
(*conv4func)(dst, x, end, y, up0, up1, up2, up3);
x = end;
}
}
}
// -------- // --------
// wuffs_private_impl__swizzle_flattened_length is like // wuffs_private_impl__swizzle_flattened_length is like
@@ -28939,8 +29130,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
const wuffs_base__pixel_swizzler* p, const wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
wuffs_base__slice_u8 dst_palette, wuffs_base__slice_u8 dst_palette,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src0,
wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src1,
wuffs_base__slice_u8 src2, wuffs_base__slice_u8 src2,
@@ -28970,13 +29163,18 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
wuffs_base__slice_u8 scratch_buffer_2k) { wuffs_base__slice_u8 scratch_buffer_2k) {
if (!p) { if (!p) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver); return wuffs_base__make_status(wuffs_base__error__bad_receiver);
} else if (!dst || (width > 0xFFFFu) || (height > 0xFFFFu) || // } else if (!dst || //
(4u <= ((unsigned int)h0 - 1u)) || // (x_min_incl > x_max_excl) || //
(4u <= ((unsigned int)h1 - 1u)) || // (x_max_excl > 0xFFFFu) || //
(4u <= ((unsigned int)h2 - 1u)) || // (y_min_incl > y_max_excl) || //
(4u <= ((unsigned int)v0 - 1u)) || // (y_max_excl > 0xFFFFu) || //
(4u <= ((unsigned int)v1 - 1u)) || // (4u <= ((unsigned int)h0 - 1u)) || //
(4u <= ((unsigned int)v2 - 1u)) || // (4u <= ((unsigned int)h1 - 1u)) || //
(4u <= ((unsigned int)h2 - 1u)) || //
(4u <= ((unsigned int)v0 - 1u)) || //
(4u <= ((unsigned int)v1 - 1u)) || //
(4u <= ((unsigned int)v2 - 1u)) || //
(triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) ||
(scratch_buffer_2k.len < 2048u)) { (scratch_buffer_2k.len < 2048u)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument); return wuffs_base__make_status(wuffs_base__error__bad_argument);
} }
@@ -29003,21 +29201,69 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
uint32_t inv_v2 = max_incl_v / v2; uint32_t inv_v2 = max_incl_v / v2;
uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u;
uint32_t half_width_for_2to1 = (width + 1u) / 2u; if (x_min_incl != 0) {
uint32_t half_height_for_2to1 = (height + 1u) / 2u; if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) ||
(x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
}
if (y_min_incl != 0) {
if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) ||
(y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
}
width = wuffs_private_impl__u32__min_of_5( // uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u;
width, // if (inv_h0 == 2) {
width0 * inv_h0, // half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0);
width1 * inv_h1, // }
width2 * inv_h2, // if (inv_h1 == 2) {
wuffs_base__pixel_config__width(&dst->pixcfg)); half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1);
height = wuffs_private_impl__u32__min_of_5( // }
height, // if (inv_h2 == 2) {
height0 * inv_v0, // half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2);
height1 * inv_v1, // }
height2 * inv_v2, // if (inv_h3 == 2) {
wuffs_base__pixel_config__height(&dst->pixcfg)); half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3);
}
uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u;
if (inv_v0 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0);
}
if (inv_v1 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1);
}
if (inv_v2 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2);
}
if (inv_v3 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3);
}
x_max_excl = wuffs_base__u32__min( //
wuffs_base__pixel_config__width(&dst->pixcfg), //
x_min_incl + wuffs_private_impl__u32__min_of_5( //
x_max_excl - x_min_incl, //
width0 * inv_h0, //
width1 * inv_h1, //
width2 * inv_h2, //
inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF));
y_max_excl = wuffs_base__u32__min( //
wuffs_base__pixel_config__height(&dst->pixcfg), //
y_min_incl + wuffs_private_impl__u32__min_of_5( //
y_max_excl - y_min_incl, //
height0 * inv_v0, //
height1 * inv_v1, //
height2 * inv_v2, //
inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF));
if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) {
return wuffs_base__make_status(NULL);
}
uint32_t width = x_max_excl - x_min_incl;
uint32_t height = y_max_excl - y_min_incl;
if (((h0 * inv_h0) != max_incl_h) || // if (((h0 * inv_h0) != max_incl_h) || //
((h1 * inv_h1) != max_incl_h) || // ((h1 * inv_h1) != max_incl_h) || //
@@ -29118,10 +29364,6 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
// ---- // ----
if ((width <= 0u) || (height <= 0u)) {
return wuffs_base__make_status(NULL);
}
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL;
if (is_rgb_or_cmyk) { if (is_rgb_or_cmyk) {
@@ -29156,28 +29398,58 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
} }
} }
void (*func)(wuffs_base__pixel_buffer * dst, // void (*func3)(wuffs_base__pixel_buffer * dst, //
uint32_t width, // uint32_t x_min_incl, //
uint32_t height, // uint32_t x_max_excl, //
const uint8_t* src_ptr0, // uint32_t y_min_incl, //
const uint8_t* src_ptr1, // uint32_t y_max_excl, //
const uint8_t* src_ptr2, // const uint8_t* src_ptr0, //
uint32_t stride0, // const uint8_t* src_ptr1, //
uint32_t stride1, // const uint8_t* src_ptr2, //
uint32_t stride2, // uint32_t stride0, //
uint32_t inv_h0, // uint32_t stride1, //
uint32_t inv_h1, // uint32_t stride2, //
uint32_t inv_h2, // uint32_t inv_h0, //
uint32_t inv_v0, // uint32_t inv_h1, //
uint32_t inv_v1, // uint32_t inv_h2, //
uint32_t inv_v2, // uint32_t inv_v0, //
uint32_t half_width_for_2to1, // uint32_t inv_v1, //
uint32_t half_height_for_2to1, // uint32_t inv_v2, //
uint8_t* scratch_buffer_2k_ptr, // uint32_t half_width_for_2to1, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], uint32_t half_height_for_2to1, //
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) = uint8_t* scratch_buffer_2k_ptr, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) =
&wuffs_private_impl__swizzle_ycc__general__box_filter; &wuffs_private_impl__swizzle_ycc__general__box_filter;
void (*func4)(wuffs_base__pixel_buffer * dst, //
uint32_t x_min_incl, //
uint32_t x_max_excl, //
uint32_t y_min_incl, //
uint32_t y_max_excl, //
const uint8_t* src_ptr0, //
const uint8_t* src_ptr1, //
const uint8_t* src_ptr2, //
const uint8_t* src_ptr3, //
uint32_t stride0, //
uint32_t stride1, //
uint32_t stride2, //
uint32_t stride3, //
uint32_t inv_h0, //
uint32_t inv_h1, //
uint32_t inv_h2, //
uint32_t inv_h3, //
uint32_t inv_v0, //
uint32_t inv_v1, //
uint32_t inv_v2, //
uint32_t inv_v3, //
uint32_t half_width_for_2to1, //
uint32_t half_height_for_2to1, //
uint8_t* scratch_buffer_2k_ptr, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) =
&wuffs_private_impl__swizzle_ycck__general__box_filter;
wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4]; wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4];
memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs, memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs,
sizeof upfuncs); sizeof upfuncs);
@@ -29185,8 +29457,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
if (triangle_filter_for_2to1 && if (triangle_filter_for_2to1 &&
(wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) || (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) || wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2))) { wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) ||
func = &wuffs_private_impl__swizzle_ycc__general__triangle_filter; wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h3, inv_v3))) {
func3 = &wuffs_private_impl__swizzle_ycc__general__triangle_filter;
func4 = &wuffs_private_impl__swizzle_ycck__general__triangle_filter;
upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle; upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle;
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle; upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
@@ -29218,23 +29492,23 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = wuffs_private_impl__swizzle_ycc__convert_4_func conv4func =
is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general
: &wuffs_private_impl__swizzle_ycck__convert_4_general; : &wuffs_private_impl__swizzle_ycck__convert_4_general;
wuffs_private_impl__swizzle_ycck__general__triangle_filter( // (*func4)( //
dst, width, height, // dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
src0.ptr, src1.ptr, src2.ptr, src3.ptr, // src0.ptr, src1.ptr, src2.ptr, src3.ptr, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
inv_v0, inv_v1, inv_v2, inv_v3, // inv_v0, inv_v1, inv_v2, inv_v3, //
half_width_for_2to1, half_height_for_2to1, // half_width_for_2to1, half_height_for_2to1, //
scratch_buffer_2k.ptr, &upfuncs, conv4func); scratch_buffer_2k.ptr, &upfuncs, conv4func);
} else { } else {
(*func)( // (*func3)( //
dst, width, height, // dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
src0.ptr, src1.ptr, src2.ptr, // src0.ptr, src1.ptr, src2.ptr, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
inv_v0, inv_v1, inv_v2, // inv_v0, inv_v1, inv_v2, //
half_width_for_2to1, half_height_for_2to1, // half_width_for_2to1, half_height_for_2to1, //
scratch_buffer_2k.ptr, &upfuncs, conv3func); scratch_buffer_2k.ptr, &upfuncs, conv3func);
} }
@@ -30953,6 +31227,7 @@ wuffs_bmp__decoder__do_decode_image_config(
uint32_t v_width = 0; uint32_t v_width = 0;
uint32_t v_height = 0; uint32_t v_height = 0;
uint32_t v_planes = 0; uint32_t v_planes = 0;
uint32_t v_n = 0;
uint32_t v_dst_pixfmt = 0; uint32_t v_dst_pixfmt = 0;
uint32_t v_byte_width = 0; uint32_t v_byte_width = 0;
@@ -31710,7 +31985,8 @@ wuffs_bmp__decoder__do_decode_image_config(
} }
} }
} else if (self->private_impl.f_bitmap_info_len >= 40u) { } else if (self->private_impl.f_bitmap_info_len >= 40u) {
self->private_data.s_do_decode_image_config.scratch = (self->private_impl.f_bitmap_info_len - 40u); v_n = (self->private_impl.f_bitmap_info_len - 40u);
self->private_data.s_do_decode_image_config.scratch = v_n;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(45); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(45);
if (self->private_data.s_do_decode_image_config.scratch > ((uint64_t)(io2_a_src - iop_a_src))) { if (self->private_data.s_do_decode_image_config.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_do_decode_image_config.scratch -= ((uint64_t)(io2_a_src - iop_a_src)); self->private_data.s_do_decode_image_config.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
@@ -43655,6 +43931,7 @@ const char wuffs_jpeg__error__bad_sof_marker[] = "#jpeg: bad SOF marker";
const char wuffs_jpeg__error__bad_sos_marker[] = "#jpeg: bad SOS marker"; const char wuffs_jpeg__error__bad_sos_marker[] = "#jpeg: bad SOS marker";
const char wuffs_jpeg__error__bad_header[] = "#jpeg: bad header"; const char wuffs_jpeg__error__bad_header[] = "#jpeg: bad header";
const char wuffs_jpeg__error__bad_marker[] = "#jpeg: bad marker"; const char wuffs_jpeg__error__bad_marker[] = "#jpeg: bad marker";
const char wuffs_jpeg__error__bad_scan_count[] = "#jpeg: bad scan count";
const char wuffs_jpeg__error__missing_huffman_table[] = "#jpeg: missing Huffman table"; const char wuffs_jpeg__error__missing_huffman_table[] = "#jpeg: missing Huffman table";
const char wuffs_jpeg__error__missing_quantization_table[] = "#jpeg: missing Quantization table"; const char wuffs_jpeg__error__missing_quantization_table[] = "#jpeg: missing Quantization table";
const char wuffs_jpeg__error__truncated_input[] = "#jpeg: truncated input"; const char wuffs_jpeg__error__truncated_input[] = "#jpeg: truncated input";
@@ -43999,6 +44276,7 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status static wuffs_base__status
wuffs_jpeg__decoder__decode_sos( wuffs_jpeg__decoder__decode_sos(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src, wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf); wuffs_base__slice_u8 a_workbuf);
@@ -44081,14 +44359,23 @@ static wuffs_base__status
wuffs_jpeg__decoder__swizzle_gray( wuffs_jpeg__decoder__swizzle_gray(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf); wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1,
uint64_t a_stride);
WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status static wuffs_base__status
wuffs_jpeg__decoder__swizzle_colorful( wuffs_jpeg__decoder__swizzle_colorful(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf); wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1);
WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__GENERATED_C_CODE
static bool static bool
@@ -44109,6 +44396,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu( wuffs_jpeg__decoder__decode_mcu(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44117,6 +44405,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu__choosy_default( wuffs_jpeg__decoder__decode_mcu__choosy_default(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44125,6 +44414,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44133,6 +44423,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44141,6 +44432,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44149,6 +44441,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -45792,6 +46085,11 @@ wuffs_jpeg__decoder__get_quirk(
return 0; return 0;
} }
if (a_key == 2u) {
if (self->private_impl.f_use_lower_quality) {
return 18446744073709551615u;
}
}
return 0u; return 0u;
} }
@@ -45813,6 +46111,10 @@ wuffs_jpeg__decoder__set_quirk(
: wuffs_base__error__initialize_not_called); : wuffs_base__error__initialize_not_called);
} }
if (a_key == 2u) {
self->private_impl.f_use_lower_quality = (a_value >= 9223372036854775808u);
return wuffs_base__make_status(NULL);
}
return wuffs_base__make_status(wuffs_base__error__unsupported_option); return wuffs_base__make_status(wuffs_base__error__unsupported_option);
} }
@@ -47099,14 +47401,27 @@ wuffs_jpeg__decoder__decode_frame(
if ((v_ddf_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) { if ((v_ddf_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
v_ddf_status = wuffs_base__make_status(wuffs_jpeg__error__truncated_input); v_ddf_status = wuffs_base__make_status(wuffs_jpeg__error__truncated_input);
} }
if (wuffs_base__status__is_error(&v_ddf_status) || (v_scan_count < self->private_impl.f_scan_count)) { if ( ! self->private_impl.f_swizzle_immediately && (wuffs_base__status__is_error(&v_ddf_status) || (v_scan_count < self->private_impl.f_scan_count))) {
if (self->private_impl.f_sof_marker >= 194u) { if (self->private_impl.f_sof_marker >= 194u) {
wuffs_jpeg__decoder__apply_progressive_idct(self, a_workbuf); wuffs_jpeg__decoder__apply_progressive_idct(self, a_workbuf);
} }
if (self->private_impl.f_num_components == 1u) { if (self->private_impl.f_num_components == 1u) {
v_swizzle_status = wuffs_jpeg__decoder__swizzle_gray(self, a_dst, a_workbuf); v_swizzle_status = wuffs_jpeg__decoder__swizzle_gray(self,
a_dst,
a_workbuf,
0u,
4294967295u,
0u,
4294967295u,
((uint64_t)(self->private_impl.f_components_workbuf_widths[0u])));
} else { } else {
v_swizzle_status = wuffs_jpeg__decoder__swizzle_colorful(self, a_dst, a_workbuf); v_swizzle_status = wuffs_jpeg__decoder__swizzle_colorful(self,
a_dst,
a_workbuf,
0u,
4294967295u,
0u,
4294967295u);
} }
if (wuffs_base__status__is_error(&v_ddf_status)) { if (wuffs_base__status__is_error(&v_ddf_status)) {
status = v_ddf_status; status = v_ddf_status;
@@ -47211,9 +47526,14 @@ wuffs_jpeg__decoder__do_decode_frame(
} }
goto ok; goto ok;
} }
self->private_impl.f_swizzle_immediately = false;
if (self->private_impl.f_components_workbuf_offsets[8u] > ((uint64_t)(a_workbuf.len))) { if (self->private_impl.f_components_workbuf_offsets[8u] > ((uint64_t)(a_workbuf.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); if (self->private_impl.f_sof_marker >= 194u) {
goto exit; status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
self->private_impl.f_swizzle_immediately = self->private_impl.f_use_lower_quality;
self->private_impl.f_swizzle_immediately_status = wuffs_base__make_status(NULL);
} else if (self->private_impl.f_components_workbuf_offsets[4u] < self->private_impl.f_components_workbuf_offsets[8u]) { } else if (self->private_impl.f_components_workbuf_offsets[4u] < self->private_impl.f_components_workbuf_offsets[8u]) {
wuffs_private_impl__bulk_memset(a_workbuf.ptr + self->private_impl.f_components_workbuf_offsets[4u], (self->private_impl.f_components_workbuf_offsets[8u] - self->private_impl.f_components_workbuf_offsets[4u]), 0u); wuffs_private_impl__bulk_memset(a_workbuf.ptr + self->private_impl.f_components_workbuf_offsets[4u], (self->private_impl.f_components_workbuf_offsets[8u] - self->private_impl.f_components_workbuf_offsets[4u]), 0u);
} }
@@ -47326,7 +47646,7 @@ wuffs_jpeg__decoder__do_decode_frame(
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
} }
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_jpeg__decoder__decode_sos(self, a_src, a_workbuf); status = wuffs_jpeg__decoder__decode_sos(self, a_dst, a_src, a_workbuf);
if (a_src) { if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri; iop_a_src = a_src->data.ptr + a_src->meta.ri;
} }
@@ -47673,13 +47993,6 @@ wuffs_jpeg__decoder__calculate_huff_tables(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_k += 1u; v_k += 1u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_j += 1u; v_j += 1u;
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -47696,6 +48009,7 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status static wuffs_base__status
wuffs_jpeg__decoder__decode_sos( wuffs_jpeg__decoder__decode_sos(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src, wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL); wuffs_base__status status = wuffs_base__make_status(NULL);
@@ -47713,9 +48027,12 @@ wuffs_jpeg__decoder__decode_sos(
switch (coro_susp_point) { switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_scan_count >= 64u) { if (self->private_impl.f_scan_count >= 32u) {
status = wuffs_base__make_status(wuffs_jpeg__error__unsupported_scan_count); status = wuffs_base__make_status(wuffs_jpeg__error__unsupported_scan_count);
goto exit; goto exit;
} else if ((self->private_impl.f_scan_count > 0u) && ! self->private_impl.f_expect_multiple_scans) {
status = wuffs_base__make_status(wuffs_jpeg__error__bad_scan_count);
goto exit;
} }
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_jpeg__decoder__prepare_scan(self, a_src); status = wuffs_jpeg__decoder__prepare_scan(self, a_src);
@@ -47745,12 +48062,26 @@ wuffs_jpeg__decoder__decode_sos(
wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf); wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf);
} }
while (true) { while (true) {
v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self, a_workbuf, v_mx, v_my); v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self,
a_dst,
a_workbuf,
v_mx,
v_my);
if (v_decode_mcu_result == 0u) { if (v_decode_mcu_result == 0u) {
break; break;
} else if (v_decode_mcu_result != 1u) { } else if (v_decode_mcu_result == 1u) {
} else if (v_decode_mcu_result == 2u) {
status = wuffs_base__make_status(wuffs_jpeg__error__internal_error_inconsistent_decoder_state); status = wuffs_base__make_status(wuffs_jpeg__error__internal_error_inconsistent_decoder_state);
goto exit; goto exit;
} else {
status = self->private_impl.f_swizzle_immediately_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;
} }
while (true) { while (true) {
v_bitstream_length = ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri)); v_bitstream_length = ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri));
@@ -47939,6 +48270,9 @@ wuffs_jpeg__decoder__prepare_scan(
} }
v_i += 1u; v_i += 1u;
} }
if (self->private_impl.f_scan_count == 0u) {
self->private_impl.f_expect_multiple_scans = ((self->private_impl.f_sof_marker >= 194u) || (self->private_impl.f_scan_num_components < self->private_impl.f_num_components));
}
if (self->private_impl.f_sof_marker < 194u) { if (self->private_impl.f_sof_marker < 194u) {
self->private_data.s_prepare_scan.scratch = 3u; self->private_data.s_prepare_scan.scratch = 3u;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -48188,6 +48522,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
uint32_t v_b = 0; uint32_t v_b = 0;
uint32_t v_bx_offset = 0; uint32_t v_bx_offset = 0;
uint32_t v_by_offset = 0; uint32_t v_by_offset = 0;
uint32_t v_sibo = 0;
uint8_t v_ssel = 0; uint8_t v_ssel = 0;
uint8_t v_csel = 0; uint8_t v_csel = 0;
@@ -48200,6 +48535,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
v_h = ((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])); v_h = ((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]]));
v_v = ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]])); v_v = ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]]));
v_hv = (((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])) * ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]]))); v_hv = (((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])) * ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]])));
self->private_impl.f_swizzle_immediately_c_offsets[v_i] = ((uint32_t)(64u * v_total_hv));
v_total_hv += v_hv; v_total_hv += v_hv;
while (v_hv > 0u) { while (v_hv > 0u) {
self->private_impl.f_scan_comps_bx_offset[(v_b & 15u)] = ((uint8_t)((v_bx_offset & 3u))); self->private_impl.f_scan_comps_bx_offset[(v_b & 15u)] = ((uint8_t)((v_bx_offset & 3u)));
@@ -48222,6 +48558,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
return true; return true;
} }
self->private_impl.f_mcu_num_blocks = v_total_hv; self->private_impl.f_mcu_num_blocks = v_total_hv;
self->private_impl.f_swizzle_immediately_c_offsets[self->private_impl.f_scan_num_components] = ((uint32_t)(64u * v_total_hv));
v_b = 0u; v_b = 0u;
while (v_b < self->private_impl.f_mcu_num_blocks) { while (v_b < self->private_impl.f_mcu_num_blocks) {
v_ssel = self->private_impl.f_mcu_blocks_sselector[v_b]; v_ssel = self->private_impl.f_mcu_blocks_sselector[v_b];
@@ -48231,6 +48568,8 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
self->private_impl.f_mcu_blocks_my_mul[v_b] = (8u * ((uint32_t)(self->private_impl.f_components_v[v_csel])) * self->private_impl.f_components_workbuf_widths[v_csel]); self->private_impl.f_mcu_blocks_my_mul[v_b] = (8u * ((uint32_t)(self->private_impl.f_components_v[v_csel])) * self->private_impl.f_components_workbuf_widths[v_csel]);
self->private_impl.f_mcu_blocks_dc_hselector[v_b] = ((uint8_t)(0u | self->private_impl.f_scan_comps_td[v_ssel])); self->private_impl.f_mcu_blocks_dc_hselector[v_b] = ((uint8_t)(0u | self->private_impl.f_scan_comps_td[v_ssel]));
self->private_impl.f_mcu_blocks_ac_hselector[v_b] = ((uint8_t)(4u | self->private_impl.f_scan_comps_ta[v_ssel])); self->private_impl.f_mcu_blocks_ac_hselector[v_b] = ((uint8_t)(4u | self->private_impl.f_scan_comps_ta[v_ssel]));
v_sibo = ((uint32_t)(self->private_impl.f_swizzle_immediately_c_offsets[v_csel] + ((8u * ((uint32_t)(self->private_impl.f_scan_comps_bx_offset[v_b]))) + (64u * ((uint32_t)(self->private_impl.f_scan_comps_by_offset[v_b])) * ((uint32_t)(self->private_impl.f_components_h[v_csel]))))));
self->private_impl.f_swizzle_immediately_b_offsets[v_b] = wuffs_base__u32__min(v_sibo, 576u);
v_b += 1u; v_b += 1u;
} }
self->private_impl.f_scan_width_in_mcus = self->private_impl.f_width_in_mcus; self->private_impl.f_scan_width_in_mcus = self->private_impl.f_width_in_mcus;
@@ -48566,15 +48905,21 @@ static wuffs_base__status
wuffs_jpeg__decoder__swizzle_gray( wuffs_jpeg__decoder__swizzle_gray(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1,
uint64_t a_stride) {
wuffs_base__pixel_format v_dst_pixfmt = {0}; wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0; uint32_t v_dst_bits_per_pixel = 0;
uint32_t v_dst_bytes_per_pixel = 0; uint32_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_length = 0; uint64_t v_x0 = 0;
uint64_t v_x1 = 0;
wuffs_base__table_u8 v_tab = {0}; wuffs_base__table_u8 v_tab = {0};
wuffs_base__slice_u8 v_dst = {0}; wuffs_base__slice_u8 v_dst = {0};
uint32_t v_y = 0; uint32_t v_y = 0;
uint64_t v_stride = 0; uint32_t v_y1 = 0;
v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); 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); v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt);
@@ -48582,18 +48927,24 @@ wuffs_jpeg__decoder__swizzle_gray(
return wuffs_base__make_status(wuffs_base__error__unsupported_option); 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_pixel = (v_dst_bits_per_pixel / 8u);
v_dst_length = ((uint64_t)((v_dst_bytes_per_pixel * self->private_impl.f_width))); v_x0 = ((uint64_t)((v_dst_bytes_per_pixel * wuffs_base__u32__min(a_x0, self->private_impl.f_width))));
v_x1 = ((uint64_t)((v_dst_bytes_per_pixel * wuffs_base__u32__min(a_x1, self->private_impl.f_width))));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u);
v_y = 0u; v_y = a_y0;
while (v_y < self->private_impl.f_height) { v_y1 = wuffs_base__u32__min(a_y1, self->private_impl.f_height);
while (v_y < v_y1) {
v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y); v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y);
if (v_dst_length < ((uint64_t)(v_dst.len))) { if (v_x1 < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_length); v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_x1);
}
if (v_x0 < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_x0);
} else {
v_dst = wuffs_base__utility__empty_slice_u8();
} }
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), a_workbuf); wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), a_workbuf);
v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[0u])); if (a_stride <= ((uint64_t)(a_workbuf.len))) {
if (v_stride <= ((uint64_t)(a_workbuf.len))) { a_workbuf = wuffs_base__slice_u8__subslice_i(a_workbuf, a_stride);
a_workbuf = wuffs_base__slice_u8__subslice_i(a_workbuf, v_stride);
} else { } else {
a_workbuf = wuffs_base__utility__empty_slice_u8(); a_workbuf = wuffs_base__utility__empty_slice_u8();
} }
@@ -48609,54 +48960,109 @@ static wuffs_base__status
wuffs_jpeg__decoder__swizzle_colorful( wuffs_jpeg__decoder__swizzle_colorful(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1) {
uint64_t v_i = 0;
uint64_t v_j = 0;
wuffs_base__slice_u8 v_src0 = {0}; wuffs_base__slice_u8 v_src0 = {0};
wuffs_base__slice_u8 v_src1 = {0}; wuffs_base__slice_u8 v_src1 = {0};
wuffs_base__slice_u8 v_src2 = {0}; wuffs_base__slice_u8 v_src2 = {0};
wuffs_base__slice_u8 v_src3 = {0}; wuffs_base__slice_u8 v_src3 = {0};
uint32_t v_width0 = 0;
uint32_t v_width1 = 0;
uint32_t v_width2 = 0;
uint32_t v_width3 = 0;
uint32_t v_height0 = 0;
uint32_t v_height1 = 0;
uint32_t v_height2 = 0;
uint32_t v_height3 = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL); wuffs_base__status v_status = wuffs_base__make_status(NULL);
if ((self->private_impl.f_components_workbuf_offsets[0u] <= self->private_impl.f_components_workbuf_offsets[1u]) && (self->private_impl.f_components_workbuf_offsets[1u] <= ((uint64_t)(a_workbuf.len)))) { if (self->private_impl.f_swizzle_immediately) {
v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[0u]));
self->private_impl.f_components_workbuf_offsets[0u], v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[1u]));
self->private_impl.f_components_workbuf_offsets[1u]); if ((v_i <= v_j) && (v_j <= 640u)) {
} v_src0 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
if ((self->private_impl.f_components_workbuf_offsets[1u] <= self->private_impl.f_components_workbuf_offsets[2u]) && (self->private_impl.f_components_workbuf_offsets[2u] <= ((uint64_t)(a_workbuf.len)))) { v_width0 = (8u * ((uint32_t)(self->private_impl.f_components_h[0u])));
v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_height0 = (8u * ((uint32_t)(self->private_impl.f_components_v[0u])));
self->private_impl.f_components_workbuf_offsets[1u], }
self->private_impl.f_components_workbuf_offsets[2u]); v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[1u]));
} v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[2u]));
if ((self->private_impl.f_components_workbuf_offsets[2u] <= self->private_impl.f_components_workbuf_offsets[3u]) && (self->private_impl.f_components_workbuf_offsets[3u] <= ((uint64_t)(a_workbuf.len)))) { if ((v_i <= v_j) && (v_j <= 640u)) {
v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_src1 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
self->private_impl.f_components_workbuf_offsets[2u], v_width1 = (8u * ((uint32_t)(self->private_impl.f_components_h[1u])));
self->private_impl.f_components_workbuf_offsets[3u]); v_height1 = (8u * ((uint32_t)(self->private_impl.f_components_v[1u])));
} }
if ((self->private_impl.f_components_workbuf_offsets[3u] <= self->private_impl.f_components_workbuf_offsets[4u]) && (self->private_impl.f_components_workbuf_offsets[4u] <= ((uint64_t)(a_workbuf.len)))) { v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[2u]));
v_src3 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[3u]));
self->private_impl.f_components_workbuf_offsets[3u], if ((v_i <= v_j) && (v_j <= 640u)) {
self->private_impl.f_components_workbuf_offsets[4u]); v_src2 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
v_width2 = (8u * ((uint32_t)(self->private_impl.f_components_h[2u])));
v_height2 = (8u * ((uint32_t)(self->private_impl.f_components_v[2u])));
}
v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[3u]));
v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[4u]));
if ((v_i <= v_j) && (v_j <= 640u)) {
v_src3 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
v_width3 = (8u * ((uint32_t)(self->private_impl.f_components_h[3u])));
v_height3 = (8u * ((uint32_t)(self->private_impl.f_components_v[3u])));
}
} else {
if ((self->private_impl.f_components_workbuf_offsets[0u] <= self->private_impl.f_components_workbuf_offsets[1u]) && (self->private_impl.f_components_workbuf_offsets[1u] <= ((uint64_t)(a_workbuf.len)))) {
v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[0u],
self->private_impl.f_components_workbuf_offsets[1u]);
v_width0 = self->private_impl.f_components_workbuf_widths[0u];
v_height0 = self->private_impl.f_components_workbuf_heights[0u];
}
if ((self->private_impl.f_components_workbuf_offsets[1u] <= self->private_impl.f_components_workbuf_offsets[2u]) && (self->private_impl.f_components_workbuf_offsets[2u] <= ((uint64_t)(a_workbuf.len)))) {
v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[1u],
self->private_impl.f_components_workbuf_offsets[2u]);
v_width1 = self->private_impl.f_components_workbuf_widths[1u];
v_height1 = self->private_impl.f_components_workbuf_heights[1u];
}
if ((self->private_impl.f_components_workbuf_offsets[2u] <= self->private_impl.f_components_workbuf_offsets[3u]) && (self->private_impl.f_components_workbuf_offsets[3u] <= ((uint64_t)(a_workbuf.len)))) {
v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[2u],
self->private_impl.f_components_workbuf_offsets[3u]);
v_width2 = self->private_impl.f_components_workbuf_widths[2u];
v_height2 = self->private_impl.f_components_workbuf_heights[2u];
}
if ((self->private_impl.f_components_workbuf_offsets[3u] <= self->private_impl.f_components_workbuf_offsets[4u]) && (self->private_impl.f_components_workbuf_offsets[4u] <= ((uint64_t)(a_workbuf.len)))) {
v_src3 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[3u],
self->private_impl.f_components_workbuf_offsets[4u]);
v_width3 = self->private_impl.f_components_workbuf_widths[3u];
v_height3 = self->private_impl.f_components_workbuf_heights[3u];
}
} }
v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler, v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler,
a_dst, a_dst,
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
self->private_impl.f_width, (a_x0 & 65535u),
self->private_impl.f_height, wuffs_base__u32__min(a_x1, self->private_impl.f_width),
(a_y0 & 65535u),
wuffs_base__u32__min(a_y1, self->private_impl.f_height),
v_src0, v_src0,
v_src1, v_src1,
v_src2, v_src2,
v_src3, v_src3,
self->private_impl.f_components_workbuf_widths[0u], v_width0,
self->private_impl.f_components_workbuf_widths[1u], v_width1,
self->private_impl.f_components_workbuf_widths[2u], v_width2,
self->private_impl.f_components_workbuf_widths[3u], v_width3,
self->private_impl.f_components_workbuf_heights[0u], v_height0,
self->private_impl.f_components_workbuf_heights[1u], v_height1,
self->private_impl.f_components_workbuf_heights[2u], v_height2,
self->private_impl.f_components_workbuf_heights[3u], v_height3,
self->private_impl.f_components_workbuf_widths[0u], v_width0,
self->private_impl.f_components_workbuf_widths[1u], v_width1,
self->private_impl.f_components_workbuf_widths[2u], v_width2,
self->private_impl.f_components_workbuf_widths[3u], v_width3,
self->private_impl.f_components_h[0u], self->private_impl.f_components_h[0u],
self->private_impl.f_components_h[1u], self->private_impl.f_components_h[1u],
self->private_impl.f_components_h[2u], self->private_impl.f_components_h[2u],
@@ -48666,7 +49072,7 @@ wuffs_jpeg__decoder__swizzle_colorful(
self->private_impl.f_components_v[2u], self->private_impl.f_components_v[2u],
self->private_impl.f_components_v[3u], self->private_impl.f_components_v[3u],
self->private_impl.f_is_rgb_or_cmyk, self->private_impl.f_is_rgb_or_cmyk,
true, ! self->private_impl.f_use_lower_quality,
wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048)); wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048));
return wuffs_private_impl__status__ensure_not_a_suspension(v_status); return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
} }
@@ -48778,6 +49184,7 @@ wuffs_jpeg__decoder__restart_frame(
} }
self->private_impl.f_call_sequence = 40u; self->private_impl.f_call_sequence = 40u;
self->private_impl.f_bitstream_is_closed = false; self->private_impl.f_bitstream_is_closed = false;
self->private_impl.f_expect_multiple_scans = false;
self->private_impl.f_frame_config_io_position = a_io_position; self->private_impl.f_frame_config_io_position = a_io_position;
self->private_impl.f_scan_count = 0u; self->private_impl.f_scan_count = 0u;
self->private_impl.f_restart_interval = self->private_impl.f_saved_restart_interval; self->private_impl.f_restart_interval = self->private_impl.f_saved_restart_interval;
@@ -48876,6 +49283,9 @@ wuffs_jpeg__decoder__workbuf_len(
return wuffs_base__utility__empty_range_ii_u64(); return wuffs_base__utility__empty_range_ii_u64();
} }
if (self->private_impl.f_use_lower_quality && (self->private_impl.f_sof_marker < 194u)) {
return wuffs_base__utility__make_range_ii_u64(0u, self->private_impl.f_components_workbuf_offsets[8u]);
}
return wuffs_base__utility__make_range_ii_u64(self->private_impl.f_components_workbuf_offsets[8u], self->private_impl.f_components_workbuf_offsets[8u]); return wuffs_base__utility__make_range_ii_u64(self->private_impl.f_components_workbuf_offsets[8u], self->private_impl.f_components_workbuf_offsets[8u]);
} }
@@ -49512,16 +49922,18 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu( wuffs_jpeg__decoder__decode_mcu(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
return (*self->private_impl.choosy_decode_mcu)(self, a_workbuf, a_mx, a_my); return (*self->private_impl.choosy_decode_mcu)(self, a_dst, a_workbuf, a_mx, a_my);
} }
WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu__choosy_default( wuffs_jpeg__decoder__decode_mcu__choosy_default(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -49721,11 +50133,47 @@ wuffs_jpeg__decoder__decode_mcu__choosy_default(
if (self->private_impl.f_test_only_interrupt_decode_mcu) { if (self->private_impl.f_test_only_interrupt_decode_mcu) {
goto label__goto_done__break; goto label__goto_done__break;
} }
v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]]; if ( ! self->private_impl.f_swizzle_immediately) {
v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[v_csel])); v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]];
v_offset = (self->private_impl.f_mcu_blocks_offset[v_mcb] + (((uint64_t)(self->private_impl.f_mcu_blocks_mx_mul[v_mcb])) * ((uint64_t)(a_mx))) + (((uint64_t)(self->private_impl.f_mcu_blocks_my_mul[v_mcb])) * ((uint64_t)(a_my)))); v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[v_csel]));
if (v_offset <= ((uint64_t)(a_workbuf.len))) { v_offset = (self->private_impl.f_mcu_blocks_offset[v_mcb] + (((uint64_t)(self->private_impl.f_mcu_blocks_mx_mul[v_mcb])) * ((uint64_t)(a_mx))) + (((uint64_t)(self->private_impl.f_mcu_blocks_my_mul[v_mcb])) * ((uint64_t)(a_my))));
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel]))); if (v_offset <= ((uint64_t)(a_workbuf.len))) {
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel])));
}
} else if (self->private_impl.f_num_components == 1u) {
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__make_slice_u8(self->private_data.f_swizzle_immediately_buffer, 64), 8u, ((uint32_t)(self->private_impl.f_components_tq[v_csel])));
self->private_impl.f_swizzle_immediately_status = wuffs_jpeg__decoder__swizzle_gray(self,
a_dst,
wuffs_base__make_slice_u8(self->private_data.f_swizzle_immediately_buffer, 64),
((a_mx + 0u) * 8u),
((a_mx + 1u) * 8u),
((a_my + 0u) * 8u),
((a_my + 1u) * 8u),
8u);
if ( ! wuffs_base__status__is_ok(&self->private_impl.f_swizzle_immediately_status)) {
v_ret = 3u;
goto label__goto_done__break;
}
break;
} else {
v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]];
v_stride = (8u * ((uint64_t)(self->private_impl.f_components_h[v_csel])));
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, self->private_impl.f_swizzle_immediately_b_offsets[v_mcb], 640), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel])));
if (self->private_impl.f_mcu_current_block < self->private_impl.f_mcu_num_blocks) {
continue;
}
self->private_impl.f_swizzle_immediately_status = wuffs_jpeg__decoder__swizzle_colorful(self,
a_dst,
wuffs_base__utility__empty_slice_u8(),
((a_mx + 0u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_h))),
((a_mx + 1u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_h))),
((a_my + 0u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_v))),
((a_my + 1u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_v))));
if ( ! wuffs_base__status__is_ok(&self->private_impl.f_swizzle_immediately_status)) {
v_ret = 3u;
goto label__goto_done__break;
}
break;
} }
} }
self->private_impl.f_mcu_current_block = 0u; self->private_impl.f_mcu_current_block = 0u;
@@ -49754,6 +50202,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -49921,6 +50370,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -50182,6 +50632,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -50322,6 +50773,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -69436,42 +69888,6 @@ WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[5] WUFFS_BASE__POTENTIALLY_UNUSED = {
1612u, 0u, 511u, 1022u, 1533u, 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 static const uint8_t
WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = { WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u, 24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u,
@@ -71022,29 +71438,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71076,29 +71471,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[0u] += v_prev_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[3u] += v_prev_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71128,29 +71502,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71161,29 +71514,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_prev_row.ptr[4u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_prev_row.ptr[7u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71194,29 +71526,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_prev_row.ptr[8u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_prev_row.ptr[11u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71227,29 +71538,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_prev_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_prev_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71264,29 +71554,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); 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))); 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))); 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))); v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71297,29 +71566,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71330,29 +71578,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71363,29 +71590,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71396,29 +71602,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71437,29 +71622,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + v_t0) / 2u))); 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))); 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))); 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))); v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + v_t3) / 2u)));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71491,29 +71655,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(v_l0)); 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)); 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)); 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)); v_curr_row.ptr[7u] += ((uint8_t)(v_l3));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71524,29 +71667,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(v_t0)); 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)); 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)); 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)); v_curr_row.ptr[7u] += ((uint8_t)(v_t3));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71558,29 +71680,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #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]); 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]); 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]); 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]); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71591,29 +71692,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #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]); 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]); 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]); 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]); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71723,9 +71803,9 @@ wuffs_webp__decoder__apply_transform_cross_color(
v_x = 0u; v_x = 0u;
while (v_x < self->private_impl.f_width) { while (v_x < self->private_impl.f_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) { 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_g2r = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[0u]);
v_g2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[1u]]; v_g2b = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[1u]);
v_r2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[2u]]; v_r2b = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[2u]);
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u); v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
} }
if (((uint64_t)(a_pix.len)) >= 4u) { if (((uint64_t)(a_pix.len)) >= 4u) {
@@ -71736,23 +71816,9 @@ wuffs_webp__decoder__apply_transform_cross_color(
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_r += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2r)) >> 5u))); v_r += ((uint8_t)((((uint32_t)(wuffs_base__utility__sign_extend_convert_u8_u32(v_g) * v_g2r)) >> 5u)));
#if defined(__GNUC__) v_b += ((uint8_t)((((uint32_t)(wuffs_base__utility__sign_extend_convert_u8_u32(v_g) * v_g2b)) >> 5u)));
#pragma GCC diagnostic pop v_b += ((uint8_t)((((uint32_t)(wuffs_base__utility__sign_extend_convert_u8_u32(v_r) * v_r2b)) >> 5u)));
#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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
#endif #endif
@@ -71789,13 +71855,6 @@ wuffs_webp__decoder__apply_transform_subtract_green(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_p.ptr[0u] += v_g; 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; v_p.ptr[2u] += v_g;
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71833,6 +71892,26 @@ wuffs_webp__decoder__apply_transform_color_indexing(
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u])); v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u]));
if (v_tile_size_log2 == 0u) { if (v_tile_size_log2 == 0u) {
{
wuffs_base__slice_u8 i_slice_dst = a_pix;
v_dst.ptr = i_slice_dst.ptr;
v_dst.len = 4;
const uint8_t* i_end0_dst = wuffs_private_impl__ptr_u8_plus_len(v_dst.ptr, (((i_slice_dst.len - (size_t)(v_dst.ptr - i_slice_dst.ptr)) / 4) * 4));
while (v_dst.ptr < i_end0_dst) {
v_p = (((uint32_t)(v_dst.ptr[1u])) * 4u);
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.ptr += 4;
}
v_dst.len = 0;
}
return wuffs_base__make_empty_struct();
} }
v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2); v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2);
v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u); v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
@@ -72929,6 +73008,7 @@ wuffs_webp__decoder__decode_transform(
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL); wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0; uint8_t v_c8 = 0;
uint32_t v_transform_type = 0; uint32_t v_transform_type = 0;
uint32_t v_tile_size_log2 = 0; uint32_t v_tile_size_log2 = 0;
@@ -73027,28 +73107,34 @@ wuffs_webp__decoder__decode_transform(
if (status.repr) { if (status.repr) {
goto suspend; 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)))) { while (true) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); 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)))) {
goto exit; 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)); {
} if (a_src) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
status = wuffs_webp__decoder__decode_pixels(self, }
wuffs_base__slice_u8__subslice_ij(a_workbuf, wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])), wuffs_base__slice_u8__subslice_ij(a_workbuf,
((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 + 1u)])),
a_src, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))),
((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), a_src,
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(), ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
0u); wuffs_base__utility__empty_slice_u8(),
if (a_src) { 0u);
iop_a_src = a_src->data.ptr + a_src->meta.ri; v_status = t_2;
} if (a_src) {
if (status.repr) { iop_a_src = a_src->data.ptr + a_src->meta.ri;
goto suspend; }
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
} }
} else if (v_transform_type == 2u) { } else if (v_transform_type == 2u) {
} else { } else {
@@ -73059,8 +73145,8 @@ wuffs_webp__decoder__decode_transform(
status = wuffs_base__make_status(wuffs_base__suspension__short_read); status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend; goto suspend;
} }
uint8_t t_2 = *iop_a_src++; uint8_t t_3 = *iop_a_src++;
v_c8 = t_2; v_c8 = t_3;
} }
if (self->private_impl.f_n_bits >= 8u) { if (self->private_impl.f_n_bits >= 8u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
@@ -73135,29 +73221,8 @@ wuffs_webp__decoder__decode_transform(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_p.ptr[4u] += v_p.ptr[0u]; 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]; 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]; 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]; v_p.ptr[7u] += v_p.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -73166,7 +73231,6 @@ wuffs_webp__decoder__decode_transform(
} }
} }
goto ok;
ok: ok:
self->private_impl.p_decode_transform = 0; self->private_impl.p_decode_transform = 0;
goto exit; goto exit;
@@ -73290,6 +73354,7 @@ wuffs_webp__decoder__decode_hg_table(
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL); wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0; uint8_t v_c8 = 0;
uint32_t v_use_hg_table = 0; uint32_t v_use_hg_table = 0;
uint32_t v_tile_size_log2 = 0; uint32_t v_tile_size_log2 = 0;
@@ -73394,28 +73459,34 @@ wuffs_webp__decoder__decode_hg_table(
if (status.repr) { if (status.repr) {
goto suspend; 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)))) { while (true) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); 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)))) {
goto exit; 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)); {
} if (a_src) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
status = wuffs_webp__decoder__decode_pixels(self, }
wuffs_base__slice_u8__subslice_ij(a_workbuf, wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
a_src, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))),
((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), a_src,
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(), ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
0u); wuffs_base__utility__empty_slice_u8(),
if (a_src) { 0u);
iop_a_src = a_src->data.ptr + a_src->meta.ri; v_status = t_2;
} if (a_src) {
if (status.repr) { iop_a_src = a_src->data.ptr + a_src->meta.ri;
goto suspend; }
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
} }
self->private_impl.f_overall_n_huffman_groups = 1u; 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)))) { 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)))) {
@@ -77457,15 +77528,13 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input, sync_io::Input& input,
IOBuffer& buffer) {} IOBuffer& buffer) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0) DecodeCborArgQuirks::DecodeCborArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeCborArgQuirks // DecodeCborArgQuirks //
DecodeCborArgQuirks::DefaultValue() { DecodeCborArgQuirks::DefaultValue() {
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32()); return DecodeCborArgQuirks(nullptr, 0);
} }
DecodeCborResult // DecodeCborResult //
@@ -77494,8 +77563,8 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
ret_error_message = "wuffs_aux::DecodeCbor: out of memory"; ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
goto done; goto done;
} }
for (size_t i = 0; i < quirks.repr.len; i++) { for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk(quirks.repr.ptr[i], 1); dec->set_quirk(quirks.ptr[i].first, quirks.ptr[i].second);
} }
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB. // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
@@ -77988,15 +78057,13 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
const char DecodeImage_UnsupportedPixelFormat[] = // const char DecodeImage_UnsupportedPixelFormat[] = //
"wuffs_aux::DecodeImage: unsupported pixel format"; "wuffs_aux::DecodeImage: unsupported pixel format";
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0) DecodeImageArgQuirks::DecodeImageArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeImageArgQuirks // DecodeImageArgQuirks //
DecodeImageArgQuirks::DefaultValue() { DecodeImageArgQuirks::DefaultValue() {
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32()); return DecodeImageArgQuirks(nullptr, 0);
} }
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {} DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
@@ -78094,7 +78161,8 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks, DecodeImageCallbacks& callbacks,
sync_io::Input& input, sync_io::Input& input,
wuffs_base__io_buffer& io_buf, wuffs_base__io_buffer& io_buf,
wuffs_base__slice_u32 quirks, const QuirkKeyValuePair* quirks_ptr,
const size_t quirks_len,
uint64_t flags, uint64_t flags,
wuffs_base__pixel_blend pixel_blend, wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color, wuffs_base__color_u32_argb_premul background_color,
@@ -78177,8 +78245,8 @@ redirect:
} }
// Apply quirks. // Apply quirks.
for (size_t i = 0; i < quirks.len; i++) { for (size_t i = 0; i < quirks_len; i++) {
image_decoder->set_quirk(quirks.ptr[i], 1); image_decoder->set_quirk(quirks_ptr[i].first, quirks_ptr[i].second);
} }
// Apply flags. // Apply flags.
@@ -78405,10 +78473,10 @@ DecodeImage(DecodeImageCallbacks& callbacks,
} }
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr); wuffs_base__image_decoder::unique_ptr image_decoder(nullptr);
DecodeImageResult result = DecodeImageResult result = DecodeImage0(
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr, image_decoder, callbacks, input, *io_buf, quirks.ptr, quirks.len,
flags.repr, pixel_blend.repr, background_color.repr, flags.repr, pixel_blend.repr, background_color.repr,
max_incl_dimension.repr, max_incl_metadata_length.repr); max_incl_dimension.repr, max_incl_metadata_length.repr);
callbacks.Done(result, input, *io_buf, std::move(image_decoder)); callbacks.Done(result, input, *io_buf, std::move(image_decoder));
return result; return result;
} }
@@ -78443,15 +78511,13 @@ const char DecodeJson_BadJsonPointer[] = //
const char DecodeJson_NoMatch[] = // const char DecodeJson_NoMatch[] = //
"wuffs_aux::DecodeJson: no match"; "wuffs_aux::DecodeJson: no match";
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0) DecodeJsonArgQuirks::DecodeJsonArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeJsonArgQuirks // DecodeJsonArgQuirks //
DecodeJsonArgQuirks::DefaultValue() { DecodeJsonArgQuirks::DefaultValue() {
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32()); return DecodeJsonArgQuirks(nullptr, 0);
} }
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0) DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
@@ -78796,11 +78862,11 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done; goto done;
} }
bool allow_tilde_n_tilde_r_tilde_t = false; bool allow_tilde_n_tilde_r_tilde_t = false;
for (size_t i = 0; i < quirks.repr.len; i++) { for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk(quirks.repr.ptr[i], 1); dec->set_quirk(quirks.ptr[i].first, quirks.ptr[i].second);
if (quirks.repr.ptr[i] == if (quirks.ptr[i].first ==
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) { WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
allow_tilde_n_tilde_r_tilde_t = true; allow_tilde_n_tilde_r_tilde_t = (quirks.ptr[i].second != 0);
} }
} }
+828 -762
View File
@@ -81,15 +81,15 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically. // each major.minor branch, the commit count should increase monotonically.
// //
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision // WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// 3be81643cc77e83e0125b150502ea273bf02839d committed on 2024-07-09. // ffb64df0a0b127e20d5eb0e1aab40c29409c0c3e committed on 2024-08-04.
#define WUFFS_VERSION 0x000040000 #define WUFFS_VERSION 0x000040000
#define WUFFS_VERSION_MAJOR 0 #define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 4 #define WUFFS_VERSION_MINOR 4
#define WUFFS_VERSION_PATCH 0 #define WUFFS_VERSION_PATCH 0
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.5" #define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.6"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3771 #define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3789
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20240709 #define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20240804
#define WUFFS_VERSION_STRING "0.4.0-alpha.5+3771.20240709" #define WUFFS_VERSION_STRING "0.4.0-alpha.6+3789.20240804"
// ---------------- Private Implementation Macros Re-definition Check // ---------------- Private Implementation Macros Re-definition Check
@@ -176,12 +176,62 @@ extern "C" {
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1) #elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
#if defined(_M_X64) #if defined(_M_X64)
// We need <intrin.h> for the __cpuid function.
#include <intrin.h> // On X86_64, Microsoft Visual C/C++ (MSVC) only supports SSE2 by default.
// There are /arch:SSE2, /arch:AVX and /arch:AVX2 compiler flags (the AVX2 one
// is roughly equivalent to X86_64_V3), but there is no /arch:SSE42 compiler
// flag that's equivalent to X86_64_V2.
//
// For getting maximum performance with X86_64 MSVC and Wuffs, pass /arch:AVX2
// (and then test on the oldest hardware you intend to support).
//
// Absent that compiler flag, either define one of the three macros listed
// below or else the X86_64 SIMD code will be disabled and you'll get a #pragma
// message stating this library "performs best with /arch:AVX2". This message
// is harmless and ignorable, in that the non-SIMD code is still correct and
// reasonably performant, but is a reminder that when combining Wuffs and MSVC,
// some compiler configuration is required for maximum performance.
//
// - WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY
// - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2 (enables SSE4.2 and below)
// - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3 (enables AVX2 and below)
//
// Defining the first one (WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
// or defining none of those three (the default state) are equivalent (in that
// both disable the SIMD code paths), other than that pragma message.
//
// When defining these WUFFS_CONFIG__ENABLE_ETC macros with MSVC, be aware that
// some users report it leading to ICEs (Internal Compiler Errors), but other
// users report no problems at all (and improved performance). It's unclear
// exactly what combination of SIMD code and MSVC configuration lead to ICEs.
// Do your own testing with your own MSVC version and configuration.
//
// https://github.com/google/wuffs/issues/148
// https://github.com/google/wuffs/issues/151
// https://developercommunity.visualstudio.com/t/fatal--error-C1001:-Internal-compiler-er/10703305
//
// Clang (including clang-cl) and GCC don't need this WUFFS_CONFIG__ETC macro
// machinery, or having the Wuffs-the-library user to fiddle with compiler
// flags, because they support "__attribute__((target(arg)))".
#if defined(__AVX2__) || defined(__clang__) || \
defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__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_V2
#if defined(__AVX2__) || defined(__clang__) #define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#elif defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2)
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2
#elif !defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
#pragma message("Wuffs with MSVC+X64 performs best with /arch:AVX2")
#endif // defined(__AVX2__) || defined(__clang__) || etc
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
#if defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)
#error "MSVC_CPU_ARCH simultaneously enabled and disabled"
#endif
#include <intrin.h>
// intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use // intrin.h isn't enough for X64 SIMD, with clang-cl, if we want to use
// "__attribute__((target(arg)))" without e.g. "/arch:AVX". // "__attribute__((target(arg)))" without e.g. "/arch:AVX".
// //
@@ -191,23 +241,9 @@ extern "C" {
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT #include <immintrin.h> // AVX, AVX2, FMA, POPCNT
#include <nmmintrin.h> // SSE4.2 #include <nmmintrin.h> // SSE4.2
#include <wmmintrin.h> // AES, PCLMUL #include <wmmintrin.h> // AES, PCLMUL
#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3
#else // defined(__AVX2__) || defined(__clang__) #endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
// 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:AVX2 or -mavx2 compiler flag), not
// of individual functions (that can be conditionally selected at runtime).
#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(__AVX2__) || defined(__clang__)
#endif // defined(_M_X64) #endif // defined(_M_X64)
#endif // (#if-chain ref AVOID_CPU_ARCH_1) #endif // (#if-chain ref AVOID_CPU_ARCH_1)
#endif // (#if-chain ref AVOID_CPU_ARCH_0) #endif // (#if-chain ref AVOID_CPU_ARCH_0)
@@ -914,6 +950,8 @@ typedef struct wuffs_base__transform__output__struct {
#define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1 #define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1
#define WUFFS_BASE__QUIRK_QUALITY 2
// -------- // --------
// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a
@@ -1979,6 +2017,20 @@ WUFFS_BASE__MAYBE_STATIC int32_t //
wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data, wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data,
bool prefix_closed); bool prefix_closed);
// ---------------- Quirk Values
// These constants are the value half of a key-value pair, where the key is
// WUFFS_BASE__QUIRK_QUALITY.
//
// In the Wuffs API, set_quirk takes a u64 value. These macro definitions are
// likewise unsigned values (uint64_t) but for this particular key, they are
// best interpreted as signed values (int64_t). "Lower-than-default quality"
// and "higher-than-default quality", as signed values, are -1 and +1.
//
// See doc/note/quirks.md for some more discussion about trade-offs.
#define WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY UINT64_MAX
#define WUFFS_BASE__QUIRK_QUALITY__VALUE__HIGHER_QUALITY ((uint64_t)1)
// ---------------- Ranges and Rects // ---------------- Ranges and Rects
// See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md // See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md
@@ -3351,49 +3403,53 @@ wuffs_base__make_token(uint64_t repr) {
// -------- // --------
#define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF // clang-format off
#define WUFFS_BASE__TOKEN__VALUE__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42
#define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17
#define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38
#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17
#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16
#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46
// -------- // --------
#define WUFFS_BASE__TOKEN__VBC__FILLER 0 #define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF
#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1
#define WUFFS_BASE__TOKEN__VBC__STRING 2 #define WUFFS_BASE__TOKEN__VALUE__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3 #define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__LITERAL 4 #define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42
#define WUFFS_BASE__TOKEN__VBC__NUMBER 5 #define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6 #define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38
#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17
#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16
#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0
#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46
// --------
#define WUFFS_BASE__TOKEN__VBC__FILLER 0
#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1
#define WUFFS_BASE__TOKEN__VBC__STRING 2
#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3
#define WUFFS_BASE__TOKEN__VBC__LITERAL 4
#define WUFFS_BASE__TOKEN__VBC__NUMBER 5
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6
#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7 #define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001 #define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004
// COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE. // COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE.
#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006 #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000
#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000 #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000
// -------- // --------
@@ -3413,11 +3469,11 @@ wuffs_base__make_token(uint64_t repr) {
// //
// The lack of any particular bit is conservative: it is valid for all-ASCII // The lack of any particular bit is conservative: it is valid for all-ASCII
// strings, in a single- or multi-token chain, to have none of these bits set. // strings, in a single- or multi-token chain, to have none of these bits set.
#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8 0x00001 #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8 0x00001
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004
#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010 #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020
#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040 #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040
// CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded) // CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded)
@@ -3432,22 +3488,22 @@ wuffs_base__make_token(uint64_t repr) {
// When src is the empty string, multiple conversion algorithms are applicable // When src is the empty string, multiple conversion algorithms are applicable
// (so these bits are not necessarily mutually exclusive), all producing the // (so these bits are not necessarily mutually exclusive), all producing the
// same empty dst string. // same empty dst string.
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000
#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000 #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000
// -------- // --------
#define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001 #define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001
#define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002 #define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002
#define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004 #define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004
#define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008 #define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008
// -------- // --------
@@ -3460,8 +3516,8 @@ wuffs_base__make_token(uint64_t repr) {
// For a source string of "+123" or "-0x9A", only the first two are valid. // For a source string of "+123" or "-0x9A", only the first two are valid.
// //
// For a source string of "123.", only the first one is valid. // For a source string of "123.", only the first one is valid.
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004
#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010 #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010
@@ -3473,11 +3529,15 @@ wuffs_base__make_token(uint64_t repr) {
// "300", which are big-endian, little-endian or text. For binary formats, the // "300", which are big-endian, little-endian or text. For binary formats, the
// token length (after adjusting for FORMAT_IGNORE_ETC) discriminates // token length (after adjusting for FORMAT_IGNORE_ETC) discriminates
// e.g. u16 little-endian vs u32 little-endian. // e.g. u16 little-endian vs u32 little-endian.
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400
#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000 #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000
// --------
// clang-format on
// -------- // --------
@@ -9602,6 +9662,7 @@ extern const char wuffs_jpeg__error__bad_sof_marker[];
extern const char wuffs_jpeg__error__bad_sos_marker[]; extern const char wuffs_jpeg__error__bad_sos_marker[];
extern const char wuffs_jpeg__error__bad_header[]; extern const char wuffs_jpeg__error__bad_header[];
extern const char wuffs_jpeg__error__bad_marker[]; extern const char wuffs_jpeg__error__bad_marker[];
extern const char wuffs_jpeg__error__bad_scan_count[];
extern const char wuffs_jpeg__error__missing_huffman_table[]; extern const char wuffs_jpeg__error__missing_huffman_table[];
extern const char wuffs_jpeg__error__missing_quantization_table[]; extern const char wuffs_jpeg__error__missing_quantization_table[];
extern const char wuffs_jpeg__error__truncated_input[]; extern const char wuffs_jpeg__error__truncated_input[];
@@ -9846,6 +9907,12 @@ struct wuffs_jpeg__decoder__struct {
uint32_t f_bitstream_ri; uint32_t f_bitstream_ri;
uint32_t f_bitstream_wi; uint32_t f_bitstream_wi;
bool f_bitstream_is_closed; bool f_bitstream_is_closed;
bool f_expect_multiple_scans;
bool f_use_lower_quality;
bool f_swizzle_immediately;
wuffs_base__status f_swizzle_immediately_status;
uint32_t f_swizzle_immediately_b_offsets[10];
uint32_t f_swizzle_immediately_c_offsets[5];
uint32_t f_bitstream_padding; uint32_t f_bitstream_padding;
uint16_t f_quant_tables[4][64]; uint16_t f_quant_tables[4][64];
uint16_t f_saved_quant_tables[4][64]; uint16_t f_saved_quant_tables[4][64];
@@ -9881,6 +9948,7 @@ struct wuffs_jpeg__decoder__struct {
uint32_t p_skip_past_the_next_restart_marker; uint32_t p_skip_past_the_next_restart_marker;
uint32_t (*choosy_decode_mcu)( uint32_t (*choosy_decode_mcu)(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -9889,6 +9957,7 @@ struct wuffs_jpeg__decoder__struct {
struct { struct {
uint8_t f_bitstream_buffer[2048]; uint8_t f_bitstream_buffer[2048];
uint16_t f_mcu_blocks[10][64]; uint16_t f_mcu_blocks[10][64];
uint8_t f_swizzle_immediately_buffer[640];
uint8_t f_swizzle_ycck_scratch_buffer_2k[2048]; uint8_t f_swizzle_ycck_scratch_buffer_2k[2048];
uint8_t f_dht_temp_counts[16]; uint8_t f_dht_temp_counts[16];
uint8_t f_dht_temp_bit_lengths[256]; uint8_t f_dht_temp_bit_lengths[256];
@@ -14993,6 +15062,7 @@ struct wuffs_xz__decoder__struct {
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
#include <utility>
namespace wuffs_aux { namespace wuffs_aux {
@@ -15005,6 +15075,8 @@ using IOBuffer = wuffs_base__io_buffer;
// nullptr, since calling free(nullptr) is a no-op. // nullptr, since calling free(nullptr) is a no-op.
using MemOwner = std::unique_ptr<void, decltype(&free)>; using MemOwner = std::unique_ptr<void, decltype(&free)>;
using QuirkKeyValuePair = std::pair<uint32_t, uint64_t>;
namespace sync_io { namespace sync_io {
// -------- // --------
@@ -15187,13 +15259,14 @@ class DecodeCborCallbacks {
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor. // DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
struct DecodeCborArgQuirks { struct DecodeCborArgQuirks {
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeCborArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeCborArgQuirks DefaultValue(); static DecodeCborArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeCbor calls callbacks based on the CBOR-formatted data in input. // DecodeCbor calls callbacks based on the CBOR-formatted data in input.
@@ -15401,13 +15474,14 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
// DecodeImageArgQuirks wraps an optional argument to DecodeImage. // DecodeImageArgQuirks wraps an optional argument to DecodeImage.
struct DecodeImageArgQuirks { struct DecodeImageArgQuirks {
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeImageArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeImageArgQuirks DefaultValue(); static DecodeImageArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeImageArgFlags wraps an optional argument to DecodeImage. // DecodeImageArgFlags wraps an optional argument to DecodeImage.
@@ -15619,13 +15693,14 @@ extern const char DecodeJson_NoMatch[];
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson. // DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
struct DecodeJsonArgQuirks { struct DecodeJsonArgQuirks {
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0); explicit DecodeJsonArgQuirks(const QuirkKeyValuePair* ptr0,
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len); const size_t len0);
// DefaultValue returns an empty slice. // DefaultValue returns an empty slice.
static DecodeJsonArgQuirks DefaultValue(); static DecodeJsonArgQuirks DefaultValue();
wuffs_base__slice_u32 repr; const QuirkKeyValuePair* ptr;
const size_t len;
}; };
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson. // DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
@@ -15835,6 +15910,9 @@ wuffs_private_impl__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {
// ---------------- Numeric Types (Utility) // ---------------- Numeric Types (Utility)
#define wuffs_base__utility__sign_extend_convert_u8_u32(a) \
((uint32_t)(int32_t)(int8_t)(a))
#define wuffs_base__utility__sign_extend_convert_u16_u32(a) \ #define wuffs_base__utility__sign_extend_convert_u16_u32(a) \
((uint32_t)(int32_t)(int16_t)(a)) ((uint32_t)(int32_t)(int16_t)(a))
@@ -16544,8 +16622,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
const wuffs_base__pixel_swizzler* p, const wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
wuffs_base__slice_u8 dst_palette, wuffs_base__slice_u8 dst_palette,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src0,
wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src1,
wuffs_base__slice_u8 src2, wuffs_base__slice_u8 src2,
@@ -28480,8 +28560,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
static void // static void //
wuffs_private_impl__swizzle_ycck__general__triangle_filter( wuffs_private_impl__swizzle_ycck__general__triangle_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -28503,6 +28585,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
uint8_t* scratch_buffer_2k_ptr, uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) { wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) {
if ((x_min_incl != 0) || (y_min_incl != 0)) {
return;
}
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
@@ -28515,7 +28601,7 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
// First row. // First row.
uint32_t h1v2_bias = 1u; uint32_t h1v2_bias = 1u;
wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
dst, width, 0u, // dst, x_max_excl, 0u, //
src_ptr0, src_ptr1, src_ptr2, src_ptr3, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
@@ -28527,10 +28613,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
h1v2_bias = 2u; h1v2_bias = 2u;
// Middle rows. // Middle rows.
bool last_row = height == 2u * half_height_for_2to1; bool last_row = y_max_excl == 2u * half_height_for_2to1;
uint32_t y_max_excl = last_row ? (height - 1u) : height; uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl;
uint32_t y; uint32_t y;
for (y = 1u; y < y_max_excl; y++) { for (y = 1u; y < middle_y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
const uint8_t* src0_minor = const uint8_t* src0_minor =
(inv_v0 != 2u) (inv_v0 != 2u)
@@ -28557,11 +28643,11 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
uint32_t total_src_len3 = 0u; uint32_t total_src_len3 = 0u;
uint32_t x = 0u; uint32_t x = 0u;
while (x < width) { while (x < x_max_excl) {
bool first_column = x == 0u; bool first_column = x == 0u;
uint32_t end = x + 480u; uint32_t end = x + 480u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
@@ -28617,9 +28703,9 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter(
} }
// Last row. // Last row.
if (y_max_excl != height) { if (middle_y_max_excl != y_max_excl) {
wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row(
dst, width, height - 1u, // dst, x_max_excl, middle_y_max_excl, //
src_ptr0, src_ptr1, src_ptr2, src_ptr3, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
@@ -28715,8 +28801,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
static void // static void //
wuffs_private_impl__swizzle_ycc__general__triangle_filter( wuffs_private_impl__swizzle_ycc__general__triangle_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -28734,6 +28822,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
uint8_t* scratch_buffer_2k_ptr, uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
if ((x_min_incl != 0) || (y_min_incl != 0)) {
return;
}
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
@@ -28744,7 +28836,7 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
// First row. // First row.
uint32_t h1v2_bias = 1u; uint32_t h1v2_bias = 1u;
wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
dst, width, 0u, // dst, x_max_excl, 0u, //
src_ptr0, src_ptr1, src_ptr2, // src_ptr0, src_ptr1, src_ptr2, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
@@ -28756,10 +28848,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
h1v2_bias = 2u; h1v2_bias = 2u;
// Middle rows. // Middle rows.
bool last_row = height == 2u * half_height_for_2to1; bool last_row = y_max_excl == 2u * half_height_for_2to1;
uint32_t y_max_excl = last_row ? (height - 1u) : height; uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl;
uint32_t y; uint32_t y;
for (y = 1u; y < y_max_excl; y++) { for (y = 1u; y < middle_y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
const uint8_t* src0_minor = const uint8_t* src0_minor =
(inv_v0 != 2u) (inv_v0 != 2u)
@@ -28780,11 +28872,11 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
uint32_t total_src_len2 = 0u; uint32_t total_src_len2 = 0u;
uint32_t x = 0u; uint32_t x = 0u;
while (x < width) { while (x < x_max_excl) {
bool first_column = x == 0u; bool first_column = x == 0u;
uint32_t end = x + 672u; uint32_t end = x + 672u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
@@ -28829,16 +28921,16 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
} }
// Last row. // Last row.
if (y_max_excl != height) { if (middle_y_max_excl != y_max_excl) {
wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
dst, width, height - 1u, // dst, x_max_excl, middle_y_max_excl, //
src_ptr0, src_ptr1, src_ptr2, // src_ptr0, src_ptr1, src_ptr2, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
inv_v0, inv_v1, inv_v2, // inv_v0, inv_v1, inv_v2, //
half_width_for_2to1, // half_width_for_2to1, //
h1v2_bias, // h1v2_bias, //
scratch_buffer_2k_ptr, // scratch_buffer_2k_ptr, //
upfunc0, upfunc1, upfunc2, conv3func); upfunc0, upfunc1, upfunc2, conv3func);
} }
} }
@@ -28846,8 +28938,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter(
static void // static void //
wuffs_private_impl__swizzle_ycc__general__box_filter( wuffs_private_impl__swizzle_ycc__general__box_filter(
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0, const uint8_t* src_ptr0,
const uint8_t* src_ptr1, const uint8_t* src_ptr1,
const uint8_t* src_ptr2, const uint8_t* src_ptr2,
@@ -28873,41 +28967,44 @@ wuffs_private_impl__swizzle_ycc__general__box_filter(
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
uint32_t y; uint32_t y;
for (y = 0u; y < height; y++) { for (y = y_min_incl; y < y_max_excl; y++) {
const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_major =
const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0);
const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); const uint8_t* src1_major =
src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1);
const uint8_t* src2_major =
src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2);
uint32_t x = 0u; uint32_t x = x_min_incl;
while (x < width) { while (x < x_max_excl) {
uint32_t end = x + 672u; uint32_t end = x + 672u;
if (end > width) { if (end > x_max_excl) {
end = width; end = x_max_excl;
} }
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
const uint8_t* up0 = (*upfunc0)( // const uint8_t* up0 = (*upfunc0)( //
scratch_buffer_2k_ptr + (0u * 672u), // scratch_buffer_2k_ptr + (0u * 672u), //
src0_major + (x / inv_h0), // src0_major + ((x - x_min_incl) / inv_h0), //
src0_major + (x / inv_h0), // src0_major + ((x - x_min_incl) / inv_h0), //
src_len0, // src_len0, //
0u, false, false); 0u, false, false);
const uint8_t* up1 = (*upfunc1)( // const uint8_t* up1 = (*upfunc1)( //
scratch_buffer_2k_ptr + (1u * 672u), // scratch_buffer_2k_ptr + (1u * 672u), //
src1_major + (x / inv_h1), // src1_major + ((x - x_min_incl) / inv_h1), //
src1_major + (x / inv_h1), // src1_major + ((x - x_min_incl) / inv_h1), //
src_len1, // src_len1, //
0u, false, false); 0u, false, false);
const uint8_t* up2 = (*upfunc2)( // const uint8_t* up2 = (*upfunc2)( //
scratch_buffer_2k_ptr + (2u * 672u), // scratch_buffer_2k_ptr + (2u * 672u), //
src2_major + (x / inv_h2), // src2_major + ((x - x_min_incl) / inv_h2), //
src2_major + (x / inv_h2), // src2_major + ((x - x_min_incl) / inv_h2), //
src_len2, // src_len2, //
0u, false, false); 0u, false, false);
(*conv3func)(dst, x, end, y, up0, up1, up2); (*conv3func)(dst, x, end, y, up0, up1, up2);
@@ -28916,6 +29013,100 @@ wuffs_private_impl__swizzle_ycc__general__box_filter(
} }
} }
static void //
wuffs_private_impl__swizzle_ycck__general__box_filter(
wuffs_base__pixel_buffer* dst,
uint32_t x_min_incl,
uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
const uint8_t* src_ptr0,
const uint8_t* src_ptr1,
const uint8_t* src_ptr2,
const uint8_t* src_ptr3,
uint32_t stride0,
uint32_t stride1,
uint32_t stride2,
uint32_t stride3,
uint32_t inv_h0,
uint32_t inv_h1,
uint32_t inv_h2,
uint32_t inv_h3,
uint32_t inv_v0,
uint32_t inv_v1,
uint32_t inv_v2,
uint32_t inv_v3,
uint32_t half_width_for_2to1,
uint32_t half_height_for_2to1,
uint8_t* scratch_buffer_2k_ptr,
wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) {
wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
(*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 =
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
wuffs_private_impl__swizzle_ycc__upsample_func upfunc3 =
(*upfuncs)[(inv_h3 - 1u) & 3u][(inv_v3 - 1u) & 3u];
uint32_t y;
for (y = y_min_incl; y < y_max_excl; y++) {
const uint8_t* src0_major =
src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0);
const uint8_t* src1_major =
src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1);
const uint8_t* src2_major =
src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2);
const uint8_t* src3_major =
src_ptr3 + (((y - y_min_incl) / inv_v3) * (size_t)stride3);
uint32_t x = x_min_incl;
while (x < x_max_excl) {
uint32_t end = x + 480u;
if (end > x_max_excl) {
end = x_max_excl;
}
uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
uint32_t src_len3 = ((end - x) + inv_h3 - 1u) / inv_h3;
const uint8_t* up0 = (*upfunc0)( //
scratch_buffer_2k_ptr + (0u * 480u), //
src0_major + ((x - x_min_incl) / inv_h0), //
src0_major + ((x - x_min_incl) / inv_h0), //
src_len0, //
0u, false, false);
const uint8_t* up1 = (*upfunc1)( //
scratch_buffer_2k_ptr + (1u * 480u), //
src1_major + ((x - x_min_incl) / inv_h1), //
src1_major + ((x - x_min_incl) / inv_h1), //
src_len1, //
0u, false, false);
const uint8_t* up2 = (*upfunc2)( //
scratch_buffer_2k_ptr + (2u * 480u), //
src2_major + ((x - x_min_incl) / inv_h2), //
src2_major + ((x - x_min_incl) / inv_h2), //
src_len2, //
0u, false, false);
const uint8_t* up3 = (*upfunc3)( //
scratch_buffer_2k_ptr + (3u * 480u), //
src3_major + ((x - x_min_incl) / inv_h3), //
src3_major + ((x - x_min_incl) / inv_h3), //
src_len3, //
0u, false, false);
(*conv4func)(dst, x, end, y, up0, up1, up2, up3);
x = end;
}
}
}
// -------- // --------
// wuffs_private_impl__swizzle_flattened_length is like // wuffs_private_impl__swizzle_flattened_length is like
@@ -28940,8 +29131,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
const wuffs_base__pixel_swizzler* p, const wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_buffer* dst, wuffs_base__pixel_buffer* dst,
wuffs_base__slice_u8 dst_palette, wuffs_base__slice_u8 dst_palette,
uint32_t width, uint32_t x_min_incl,
uint32_t height, uint32_t x_max_excl,
uint32_t y_min_incl,
uint32_t y_max_excl,
wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src0,
wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src1,
wuffs_base__slice_u8 src2, wuffs_base__slice_u8 src2,
@@ -28971,13 +29164,18 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
wuffs_base__slice_u8 scratch_buffer_2k) { wuffs_base__slice_u8 scratch_buffer_2k) {
if (!p) { if (!p) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver); return wuffs_base__make_status(wuffs_base__error__bad_receiver);
} else if (!dst || (width > 0xFFFFu) || (height > 0xFFFFu) || // } else if (!dst || //
(4u <= ((unsigned int)h0 - 1u)) || // (x_min_incl > x_max_excl) || //
(4u <= ((unsigned int)h1 - 1u)) || // (x_max_excl > 0xFFFFu) || //
(4u <= ((unsigned int)h2 - 1u)) || // (y_min_incl > y_max_excl) || //
(4u <= ((unsigned int)v0 - 1u)) || // (y_max_excl > 0xFFFFu) || //
(4u <= ((unsigned int)v1 - 1u)) || // (4u <= ((unsigned int)h0 - 1u)) || //
(4u <= ((unsigned int)v2 - 1u)) || // (4u <= ((unsigned int)h1 - 1u)) || //
(4u <= ((unsigned int)h2 - 1u)) || //
(4u <= ((unsigned int)v0 - 1u)) || //
(4u <= ((unsigned int)v1 - 1u)) || //
(4u <= ((unsigned int)v2 - 1u)) || //
(triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) ||
(scratch_buffer_2k.len < 2048u)) { (scratch_buffer_2k.len < 2048u)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument); return wuffs_base__make_status(wuffs_base__error__bad_argument);
} }
@@ -29004,21 +29202,69 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
uint32_t inv_v2 = max_incl_v / v2; uint32_t inv_v2 = max_incl_v / v2;
uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u;
uint32_t half_width_for_2to1 = (width + 1u) / 2u; if (x_min_incl != 0) {
uint32_t half_height_for_2to1 = (height + 1u) / 2u; if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) ||
(x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
}
if (y_min_incl != 0) {
if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) ||
(y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
}
width = wuffs_private_impl__u32__min_of_5( // uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u;
width, // if (inv_h0 == 2) {
width0 * inv_h0, // half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0);
width1 * inv_h1, // }
width2 * inv_h2, // if (inv_h1 == 2) {
wuffs_base__pixel_config__width(&dst->pixcfg)); half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1);
height = wuffs_private_impl__u32__min_of_5( // }
height, // if (inv_h2 == 2) {
height0 * inv_v0, // half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2);
height1 * inv_v1, // }
height2 * inv_v2, // if (inv_h3 == 2) {
wuffs_base__pixel_config__height(&dst->pixcfg)); half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3);
}
uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u;
if (inv_v0 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0);
}
if (inv_v1 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1);
}
if (inv_v2 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2);
}
if (inv_v3 == 2) {
half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3);
}
x_max_excl = wuffs_base__u32__min( //
wuffs_base__pixel_config__width(&dst->pixcfg), //
x_min_incl + wuffs_private_impl__u32__min_of_5( //
x_max_excl - x_min_incl, //
width0 * inv_h0, //
width1 * inv_h1, //
width2 * inv_h2, //
inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF));
y_max_excl = wuffs_base__u32__min( //
wuffs_base__pixel_config__height(&dst->pixcfg), //
y_min_incl + wuffs_private_impl__u32__min_of_5( //
y_max_excl - y_min_incl, //
height0 * inv_v0, //
height1 * inv_v1, //
height2 * inv_v2, //
inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF));
if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) {
return wuffs_base__make_status(NULL);
}
uint32_t width = x_max_excl - x_min_incl;
uint32_t height = y_max_excl - y_min_incl;
if (((h0 * inv_h0) != max_incl_h) || // if (((h0 * inv_h0) != max_incl_h) || //
((h1 * inv_h1) != max_incl_h) || // ((h1 * inv_h1) != max_incl_h) || //
@@ -29119,10 +29365,6 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
// ---- // ----
if ((width <= 0u) || (height <= 0u)) {
return wuffs_base__make_status(NULL);
}
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL;
if (is_rgb_or_cmyk) { if (is_rgb_or_cmyk) {
@@ -29157,28 +29399,58 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
} }
} }
void (*func)(wuffs_base__pixel_buffer * dst, // void (*func3)(wuffs_base__pixel_buffer * dst, //
uint32_t width, // uint32_t x_min_incl, //
uint32_t height, // uint32_t x_max_excl, //
const uint8_t* src_ptr0, // uint32_t y_min_incl, //
const uint8_t* src_ptr1, // uint32_t y_max_excl, //
const uint8_t* src_ptr2, // const uint8_t* src_ptr0, //
uint32_t stride0, // const uint8_t* src_ptr1, //
uint32_t stride1, // const uint8_t* src_ptr2, //
uint32_t stride2, // uint32_t stride0, //
uint32_t inv_h0, // uint32_t stride1, //
uint32_t inv_h1, // uint32_t stride2, //
uint32_t inv_h2, // uint32_t inv_h0, //
uint32_t inv_v0, // uint32_t inv_h1, //
uint32_t inv_v1, // uint32_t inv_h2, //
uint32_t inv_v2, // uint32_t inv_v0, //
uint32_t half_width_for_2to1, // uint32_t inv_v1, //
uint32_t half_height_for_2to1, // uint32_t inv_v2, //
uint8_t* scratch_buffer_2k_ptr, // uint32_t half_width_for_2to1, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4], uint32_t half_height_for_2to1, //
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) = uint8_t* scratch_buffer_2k_ptr, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) =
&wuffs_private_impl__swizzle_ycc__general__box_filter; &wuffs_private_impl__swizzle_ycc__general__box_filter;
void (*func4)(wuffs_base__pixel_buffer * dst, //
uint32_t x_min_incl, //
uint32_t x_max_excl, //
uint32_t y_min_incl, //
uint32_t y_max_excl, //
const uint8_t* src_ptr0, //
const uint8_t* src_ptr1, //
const uint8_t* src_ptr2, //
const uint8_t* src_ptr3, //
uint32_t stride0, //
uint32_t stride1, //
uint32_t stride2, //
uint32_t stride3, //
uint32_t inv_h0, //
uint32_t inv_h1, //
uint32_t inv_h2, //
uint32_t inv_h3, //
uint32_t inv_v0, //
uint32_t inv_v1, //
uint32_t inv_v2, //
uint32_t inv_v3, //
uint32_t half_width_for_2to1, //
uint32_t half_height_for_2to1, //
uint8_t* scratch_buffer_2k_ptr, //
wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) =
&wuffs_private_impl__swizzle_ycck__general__box_filter;
wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4]; wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4];
memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs, memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs,
sizeof upfuncs); sizeof upfuncs);
@@ -29186,8 +29458,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
if (triangle_filter_for_2to1 && if (triangle_filter_for_2to1 &&
(wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) || (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) || wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) ||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2))) { wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) ||
func = &wuffs_private_impl__swizzle_ycc__general__triangle_filter; wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h3, inv_v3))) {
func3 = &wuffs_private_impl__swizzle_ycc__general__triangle_filter;
func4 = &wuffs_private_impl__swizzle_ycck__general__triangle_filter;
upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle; upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle;
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle; upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
@@ -29219,23 +29493,23 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = wuffs_private_impl__swizzle_ycc__convert_4_func conv4func =
is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general
: &wuffs_private_impl__swizzle_ycck__convert_4_general; : &wuffs_private_impl__swizzle_ycck__convert_4_general;
wuffs_private_impl__swizzle_ycck__general__triangle_filter( // (*func4)( //
dst, width, height, // dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
src0.ptr, src1.ptr, src2.ptr, src3.ptr, // src0.ptr, src1.ptr, src2.ptr, src3.ptr, //
stride0, stride1, stride2, stride3, // stride0, stride1, stride2, stride3, //
inv_h0, inv_h1, inv_h2, inv_h3, // inv_h0, inv_h1, inv_h2, inv_h3, //
inv_v0, inv_v1, inv_v2, inv_v3, // inv_v0, inv_v1, inv_v2, inv_v3, //
half_width_for_2to1, half_height_for_2to1, // half_width_for_2to1, half_height_for_2to1, //
scratch_buffer_2k.ptr, &upfuncs, conv4func); scratch_buffer_2k.ptr, &upfuncs, conv4func);
} else { } else {
(*func)( // (*func3)( //
dst, width, height, // dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
src0.ptr, src1.ptr, src2.ptr, // src0.ptr, src1.ptr, src2.ptr, //
stride0, stride1, stride2, // stride0, stride1, stride2, //
inv_h0, inv_h1, inv_h2, // inv_h0, inv_h1, inv_h2, //
inv_v0, inv_v1, inv_v2, // inv_v0, inv_v1, inv_v2, //
half_width_for_2to1, half_height_for_2to1, // half_width_for_2to1, half_height_for_2to1, //
scratch_buffer_2k.ptr, &upfuncs, conv3func); scratch_buffer_2k.ptr, &upfuncs, conv3func);
} }
@@ -30954,6 +31228,7 @@ wuffs_bmp__decoder__do_decode_image_config(
uint32_t v_width = 0; uint32_t v_width = 0;
uint32_t v_height = 0; uint32_t v_height = 0;
uint32_t v_planes = 0; uint32_t v_planes = 0;
uint32_t v_n = 0;
uint32_t v_dst_pixfmt = 0; uint32_t v_dst_pixfmt = 0;
uint32_t v_byte_width = 0; uint32_t v_byte_width = 0;
@@ -31711,7 +31986,8 @@ wuffs_bmp__decoder__do_decode_image_config(
} }
} }
} else if (self->private_impl.f_bitmap_info_len >= 40u) { } else if (self->private_impl.f_bitmap_info_len >= 40u) {
self->private_data.s_do_decode_image_config.scratch = (self->private_impl.f_bitmap_info_len - 40u); v_n = (self->private_impl.f_bitmap_info_len - 40u);
self->private_data.s_do_decode_image_config.scratch = v_n;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(45); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(45);
if (self->private_data.s_do_decode_image_config.scratch > ((uint64_t)(io2_a_src - iop_a_src))) { if (self->private_data.s_do_decode_image_config.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_do_decode_image_config.scratch -= ((uint64_t)(io2_a_src - iop_a_src)); self->private_data.s_do_decode_image_config.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
@@ -43656,6 +43932,7 @@ const char wuffs_jpeg__error__bad_sof_marker[] = "#jpeg: bad SOF marker";
const char wuffs_jpeg__error__bad_sos_marker[] = "#jpeg: bad SOS marker"; const char wuffs_jpeg__error__bad_sos_marker[] = "#jpeg: bad SOS marker";
const char wuffs_jpeg__error__bad_header[] = "#jpeg: bad header"; const char wuffs_jpeg__error__bad_header[] = "#jpeg: bad header";
const char wuffs_jpeg__error__bad_marker[] = "#jpeg: bad marker"; const char wuffs_jpeg__error__bad_marker[] = "#jpeg: bad marker";
const char wuffs_jpeg__error__bad_scan_count[] = "#jpeg: bad scan count";
const char wuffs_jpeg__error__missing_huffman_table[] = "#jpeg: missing Huffman table"; const char wuffs_jpeg__error__missing_huffman_table[] = "#jpeg: missing Huffman table";
const char wuffs_jpeg__error__missing_quantization_table[] = "#jpeg: missing Quantization table"; const char wuffs_jpeg__error__missing_quantization_table[] = "#jpeg: missing Quantization table";
const char wuffs_jpeg__error__truncated_input[] = "#jpeg: truncated input"; const char wuffs_jpeg__error__truncated_input[] = "#jpeg: truncated input";
@@ -44000,6 +44277,7 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status static wuffs_base__status
wuffs_jpeg__decoder__decode_sos( wuffs_jpeg__decoder__decode_sos(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src, wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf); wuffs_base__slice_u8 a_workbuf);
@@ -44082,14 +44360,23 @@ static wuffs_base__status
wuffs_jpeg__decoder__swizzle_gray( wuffs_jpeg__decoder__swizzle_gray(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf); wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1,
uint64_t a_stride);
WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status static wuffs_base__status
wuffs_jpeg__decoder__swizzle_colorful( wuffs_jpeg__decoder__swizzle_colorful(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf); wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1);
WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__GENERATED_C_CODE
static bool static bool
@@ -44110,6 +44397,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu( wuffs_jpeg__decoder__decode_mcu(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44118,6 +44406,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu__choosy_default( wuffs_jpeg__decoder__decode_mcu__choosy_default(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44126,6 +44415,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44134,6 +44424,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44142,6 +44433,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -44150,6 +44442,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my); uint32_t a_my);
@@ -45793,6 +46086,11 @@ wuffs_jpeg__decoder__get_quirk(
return 0; return 0;
} }
if (a_key == 2u) {
if (self->private_impl.f_use_lower_quality) {
return 18446744073709551615u;
}
}
return 0u; return 0u;
} }
@@ -45814,6 +46112,10 @@ wuffs_jpeg__decoder__set_quirk(
: wuffs_base__error__initialize_not_called); : wuffs_base__error__initialize_not_called);
} }
if (a_key == 2u) {
self->private_impl.f_use_lower_quality = (a_value >= 9223372036854775808u);
return wuffs_base__make_status(NULL);
}
return wuffs_base__make_status(wuffs_base__error__unsupported_option); return wuffs_base__make_status(wuffs_base__error__unsupported_option);
} }
@@ -47100,14 +47402,27 @@ wuffs_jpeg__decoder__decode_frame(
if ((v_ddf_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) { if ((v_ddf_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
v_ddf_status = wuffs_base__make_status(wuffs_jpeg__error__truncated_input); v_ddf_status = wuffs_base__make_status(wuffs_jpeg__error__truncated_input);
} }
if (wuffs_base__status__is_error(&v_ddf_status) || (v_scan_count < self->private_impl.f_scan_count)) { if ( ! self->private_impl.f_swizzle_immediately && (wuffs_base__status__is_error(&v_ddf_status) || (v_scan_count < self->private_impl.f_scan_count))) {
if (self->private_impl.f_sof_marker >= 194u) { if (self->private_impl.f_sof_marker >= 194u) {
wuffs_jpeg__decoder__apply_progressive_idct(self, a_workbuf); wuffs_jpeg__decoder__apply_progressive_idct(self, a_workbuf);
} }
if (self->private_impl.f_num_components == 1u) { if (self->private_impl.f_num_components == 1u) {
v_swizzle_status = wuffs_jpeg__decoder__swizzle_gray(self, a_dst, a_workbuf); v_swizzle_status = wuffs_jpeg__decoder__swizzle_gray(self,
a_dst,
a_workbuf,
0u,
4294967295u,
0u,
4294967295u,
((uint64_t)(self->private_impl.f_components_workbuf_widths[0u])));
} else { } else {
v_swizzle_status = wuffs_jpeg__decoder__swizzle_colorful(self, a_dst, a_workbuf); v_swizzle_status = wuffs_jpeg__decoder__swizzle_colorful(self,
a_dst,
a_workbuf,
0u,
4294967295u,
0u,
4294967295u);
} }
if (wuffs_base__status__is_error(&v_ddf_status)) { if (wuffs_base__status__is_error(&v_ddf_status)) {
status = v_ddf_status; status = v_ddf_status;
@@ -47212,9 +47527,14 @@ wuffs_jpeg__decoder__do_decode_frame(
} }
goto ok; goto ok;
} }
self->private_impl.f_swizzle_immediately = false;
if (self->private_impl.f_components_workbuf_offsets[8u] > ((uint64_t)(a_workbuf.len))) { if (self->private_impl.f_components_workbuf_offsets[8u] > ((uint64_t)(a_workbuf.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); if (self->private_impl.f_sof_marker >= 194u) {
goto exit; status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
self->private_impl.f_swizzle_immediately = self->private_impl.f_use_lower_quality;
self->private_impl.f_swizzle_immediately_status = wuffs_base__make_status(NULL);
} else if (self->private_impl.f_components_workbuf_offsets[4u] < self->private_impl.f_components_workbuf_offsets[8u]) { } else if (self->private_impl.f_components_workbuf_offsets[4u] < self->private_impl.f_components_workbuf_offsets[8u]) {
wuffs_private_impl__bulk_memset(a_workbuf.ptr + self->private_impl.f_components_workbuf_offsets[4u], (self->private_impl.f_components_workbuf_offsets[8u] - self->private_impl.f_components_workbuf_offsets[4u]), 0u); wuffs_private_impl__bulk_memset(a_workbuf.ptr + self->private_impl.f_components_workbuf_offsets[4u], (self->private_impl.f_components_workbuf_offsets[8u] - self->private_impl.f_components_workbuf_offsets[4u]), 0u);
} }
@@ -47327,7 +47647,7 @@ wuffs_jpeg__decoder__do_decode_frame(
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
} }
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_jpeg__decoder__decode_sos(self, a_src, a_workbuf); status = wuffs_jpeg__decoder__decode_sos(self, a_dst, a_src, a_workbuf);
if (a_src) { if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri; iop_a_src = a_src->data.ptr + a_src->meta.ri;
} }
@@ -47674,13 +47994,6 @@ wuffs_jpeg__decoder__calculate_huff_tables(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_k += 1u; v_k += 1u;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
v_j += 1u; v_j += 1u;
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -47697,6 +48010,7 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status static wuffs_base__status
wuffs_jpeg__decoder__decode_sos( wuffs_jpeg__decoder__decode_sos(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__io_buffer* a_src, wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL); wuffs_base__status status = wuffs_base__make_status(NULL);
@@ -47714,9 +48028,12 @@ wuffs_jpeg__decoder__decode_sos(
switch (coro_susp_point) { switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_scan_count >= 64u) { if (self->private_impl.f_scan_count >= 32u) {
status = wuffs_base__make_status(wuffs_jpeg__error__unsupported_scan_count); status = wuffs_base__make_status(wuffs_jpeg__error__unsupported_scan_count);
goto exit; goto exit;
} else if ((self->private_impl.f_scan_count > 0u) && ! self->private_impl.f_expect_multiple_scans) {
status = wuffs_base__make_status(wuffs_jpeg__error__bad_scan_count);
goto exit;
} }
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_jpeg__decoder__prepare_scan(self, a_src); status = wuffs_jpeg__decoder__prepare_scan(self, a_src);
@@ -47746,12 +48063,26 @@ wuffs_jpeg__decoder__decode_sos(
wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf); wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf);
} }
while (true) { while (true) {
v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self, a_workbuf, v_mx, v_my); v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self,
a_dst,
a_workbuf,
v_mx,
v_my);
if (v_decode_mcu_result == 0u) { if (v_decode_mcu_result == 0u) {
break; break;
} else if (v_decode_mcu_result != 1u) { } else if (v_decode_mcu_result == 1u) {
} else if (v_decode_mcu_result == 2u) {
status = wuffs_base__make_status(wuffs_jpeg__error__internal_error_inconsistent_decoder_state); status = wuffs_base__make_status(wuffs_jpeg__error__internal_error_inconsistent_decoder_state);
goto exit; goto exit;
} else {
status = self->private_impl.f_swizzle_immediately_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;
} }
while (true) { while (true) {
v_bitstream_length = ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri)); v_bitstream_length = ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri));
@@ -47940,6 +48271,9 @@ wuffs_jpeg__decoder__prepare_scan(
} }
v_i += 1u; v_i += 1u;
} }
if (self->private_impl.f_scan_count == 0u) {
self->private_impl.f_expect_multiple_scans = ((self->private_impl.f_sof_marker >= 194u) || (self->private_impl.f_scan_num_components < self->private_impl.f_num_components));
}
if (self->private_impl.f_sof_marker < 194u) { if (self->private_impl.f_sof_marker < 194u) {
self->private_data.s_prepare_scan.scratch = 3u; self->private_data.s_prepare_scan.scratch = 3u;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -48189,6 +48523,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
uint32_t v_b = 0; uint32_t v_b = 0;
uint32_t v_bx_offset = 0; uint32_t v_bx_offset = 0;
uint32_t v_by_offset = 0; uint32_t v_by_offset = 0;
uint32_t v_sibo = 0;
uint8_t v_ssel = 0; uint8_t v_ssel = 0;
uint8_t v_csel = 0; uint8_t v_csel = 0;
@@ -48201,6 +48536,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
v_h = ((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])); v_h = ((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]]));
v_v = ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]])); v_v = ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]]));
v_hv = (((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])) * ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]]))); v_hv = (((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])) * ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]])));
self->private_impl.f_swizzle_immediately_c_offsets[v_i] = ((uint32_t)(64u * v_total_hv));
v_total_hv += v_hv; v_total_hv += v_hv;
while (v_hv > 0u) { while (v_hv > 0u) {
self->private_impl.f_scan_comps_bx_offset[(v_b & 15u)] = ((uint8_t)((v_bx_offset & 3u))); self->private_impl.f_scan_comps_bx_offset[(v_b & 15u)] = ((uint8_t)((v_bx_offset & 3u)));
@@ -48223,6 +48559,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
return true; return true;
} }
self->private_impl.f_mcu_num_blocks = v_total_hv; self->private_impl.f_mcu_num_blocks = v_total_hv;
self->private_impl.f_swizzle_immediately_c_offsets[self->private_impl.f_scan_num_components] = ((uint32_t)(64u * v_total_hv));
v_b = 0u; v_b = 0u;
while (v_b < self->private_impl.f_mcu_num_blocks) { while (v_b < self->private_impl.f_mcu_num_blocks) {
v_ssel = self->private_impl.f_mcu_blocks_sselector[v_b]; v_ssel = self->private_impl.f_mcu_blocks_sselector[v_b];
@@ -48232,6 +48569,8 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields(
self->private_impl.f_mcu_blocks_my_mul[v_b] = (8u * ((uint32_t)(self->private_impl.f_components_v[v_csel])) * self->private_impl.f_components_workbuf_widths[v_csel]); self->private_impl.f_mcu_blocks_my_mul[v_b] = (8u * ((uint32_t)(self->private_impl.f_components_v[v_csel])) * self->private_impl.f_components_workbuf_widths[v_csel]);
self->private_impl.f_mcu_blocks_dc_hselector[v_b] = ((uint8_t)(0u | self->private_impl.f_scan_comps_td[v_ssel])); self->private_impl.f_mcu_blocks_dc_hselector[v_b] = ((uint8_t)(0u | self->private_impl.f_scan_comps_td[v_ssel]));
self->private_impl.f_mcu_blocks_ac_hselector[v_b] = ((uint8_t)(4u | self->private_impl.f_scan_comps_ta[v_ssel])); self->private_impl.f_mcu_blocks_ac_hselector[v_b] = ((uint8_t)(4u | self->private_impl.f_scan_comps_ta[v_ssel]));
v_sibo = ((uint32_t)(self->private_impl.f_swizzle_immediately_c_offsets[v_csel] + ((8u * ((uint32_t)(self->private_impl.f_scan_comps_bx_offset[v_b]))) + (64u * ((uint32_t)(self->private_impl.f_scan_comps_by_offset[v_b])) * ((uint32_t)(self->private_impl.f_components_h[v_csel]))))));
self->private_impl.f_swizzle_immediately_b_offsets[v_b] = wuffs_base__u32__min(v_sibo, 576u);
v_b += 1u; v_b += 1u;
} }
self->private_impl.f_scan_width_in_mcus = self->private_impl.f_width_in_mcus; self->private_impl.f_scan_width_in_mcus = self->private_impl.f_width_in_mcus;
@@ -48567,15 +48906,21 @@ static wuffs_base__status
wuffs_jpeg__decoder__swizzle_gray( wuffs_jpeg__decoder__swizzle_gray(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1,
uint64_t a_stride) {
wuffs_base__pixel_format v_dst_pixfmt = {0}; wuffs_base__pixel_format v_dst_pixfmt = {0};
uint32_t v_dst_bits_per_pixel = 0; uint32_t v_dst_bits_per_pixel = 0;
uint32_t v_dst_bytes_per_pixel = 0; uint32_t v_dst_bytes_per_pixel = 0;
uint64_t v_dst_length = 0; uint64_t v_x0 = 0;
uint64_t v_x1 = 0;
wuffs_base__table_u8 v_tab = {0}; wuffs_base__table_u8 v_tab = {0};
wuffs_base__slice_u8 v_dst = {0}; wuffs_base__slice_u8 v_dst = {0};
uint32_t v_y = 0; uint32_t v_y = 0;
uint64_t v_stride = 0; uint32_t v_y1 = 0;
v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); 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); v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt);
@@ -48583,18 +48928,24 @@ wuffs_jpeg__decoder__swizzle_gray(
return wuffs_base__make_status(wuffs_base__error__unsupported_option); 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_pixel = (v_dst_bits_per_pixel / 8u);
v_dst_length = ((uint64_t)((v_dst_bytes_per_pixel * self->private_impl.f_width))); v_x0 = ((uint64_t)((v_dst_bytes_per_pixel * wuffs_base__u32__min(a_x0, self->private_impl.f_width))));
v_x1 = ((uint64_t)((v_dst_bytes_per_pixel * wuffs_base__u32__min(a_x1, self->private_impl.f_width))));
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u);
v_y = 0u; v_y = a_y0;
while (v_y < self->private_impl.f_height) { v_y1 = wuffs_base__u32__min(a_y1, self->private_impl.f_height);
while (v_y < v_y1) {
v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y); v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y);
if (v_dst_length < ((uint64_t)(v_dst.len))) { if (v_x1 < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_length); v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_x1);
}
if (v_x0 < ((uint64_t)(v_dst.len))) {
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_x0);
} else {
v_dst = wuffs_base__utility__empty_slice_u8();
} }
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), a_workbuf); wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), a_workbuf);
v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[0u])); if (a_stride <= ((uint64_t)(a_workbuf.len))) {
if (v_stride <= ((uint64_t)(a_workbuf.len))) { a_workbuf = wuffs_base__slice_u8__subslice_i(a_workbuf, a_stride);
a_workbuf = wuffs_base__slice_u8__subslice_i(a_workbuf, v_stride);
} else { } else {
a_workbuf = wuffs_base__utility__empty_slice_u8(); a_workbuf = wuffs_base__utility__empty_slice_u8();
} }
@@ -48610,54 +48961,109 @@ static wuffs_base__status
wuffs_jpeg__decoder__swizzle_colorful( wuffs_jpeg__decoder__swizzle_colorful(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst, wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf,
uint32_t a_x0,
uint32_t a_x1,
uint32_t a_y0,
uint32_t a_y1) {
uint64_t v_i = 0;
uint64_t v_j = 0;
wuffs_base__slice_u8 v_src0 = {0}; wuffs_base__slice_u8 v_src0 = {0};
wuffs_base__slice_u8 v_src1 = {0}; wuffs_base__slice_u8 v_src1 = {0};
wuffs_base__slice_u8 v_src2 = {0}; wuffs_base__slice_u8 v_src2 = {0};
wuffs_base__slice_u8 v_src3 = {0}; wuffs_base__slice_u8 v_src3 = {0};
uint32_t v_width0 = 0;
uint32_t v_width1 = 0;
uint32_t v_width2 = 0;
uint32_t v_width3 = 0;
uint32_t v_height0 = 0;
uint32_t v_height1 = 0;
uint32_t v_height2 = 0;
uint32_t v_height3 = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL); wuffs_base__status v_status = wuffs_base__make_status(NULL);
if ((self->private_impl.f_components_workbuf_offsets[0u] <= self->private_impl.f_components_workbuf_offsets[1u]) && (self->private_impl.f_components_workbuf_offsets[1u] <= ((uint64_t)(a_workbuf.len)))) { if (self->private_impl.f_swizzle_immediately) {
v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[0u]));
self->private_impl.f_components_workbuf_offsets[0u], v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[1u]));
self->private_impl.f_components_workbuf_offsets[1u]); if ((v_i <= v_j) && (v_j <= 640u)) {
} v_src0 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
if ((self->private_impl.f_components_workbuf_offsets[1u] <= self->private_impl.f_components_workbuf_offsets[2u]) && (self->private_impl.f_components_workbuf_offsets[2u] <= ((uint64_t)(a_workbuf.len)))) { v_width0 = (8u * ((uint32_t)(self->private_impl.f_components_h[0u])));
v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_height0 = (8u * ((uint32_t)(self->private_impl.f_components_v[0u])));
self->private_impl.f_components_workbuf_offsets[1u], }
self->private_impl.f_components_workbuf_offsets[2u]); v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[1u]));
} v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[2u]));
if ((self->private_impl.f_components_workbuf_offsets[2u] <= self->private_impl.f_components_workbuf_offsets[3u]) && (self->private_impl.f_components_workbuf_offsets[3u] <= ((uint64_t)(a_workbuf.len)))) { if ((v_i <= v_j) && (v_j <= 640u)) {
v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_src1 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
self->private_impl.f_components_workbuf_offsets[2u], v_width1 = (8u * ((uint32_t)(self->private_impl.f_components_h[1u])));
self->private_impl.f_components_workbuf_offsets[3u]); v_height1 = (8u * ((uint32_t)(self->private_impl.f_components_v[1u])));
} }
if ((self->private_impl.f_components_workbuf_offsets[3u] <= self->private_impl.f_components_workbuf_offsets[4u]) && (self->private_impl.f_components_workbuf_offsets[4u] <= ((uint64_t)(a_workbuf.len)))) { v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[2u]));
v_src3 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[3u]));
self->private_impl.f_components_workbuf_offsets[3u], if ((v_i <= v_j) && (v_j <= 640u)) {
self->private_impl.f_components_workbuf_offsets[4u]); v_src2 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
v_width2 = (8u * ((uint32_t)(self->private_impl.f_components_h[2u])));
v_height2 = (8u * ((uint32_t)(self->private_impl.f_components_v[2u])));
}
v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[3u]));
v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[4u]));
if ((v_i <= v_j) && (v_j <= 640u)) {
v_src3 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j);
v_width3 = (8u * ((uint32_t)(self->private_impl.f_components_h[3u])));
v_height3 = (8u * ((uint32_t)(self->private_impl.f_components_v[3u])));
}
} else {
if ((self->private_impl.f_components_workbuf_offsets[0u] <= self->private_impl.f_components_workbuf_offsets[1u]) && (self->private_impl.f_components_workbuf_offsets[1u] <= ((uint64_t)(a_workbuf.len)))) {
v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[0u],
self->private_impl.f_components_workbuf_offsets[1u]);
v_width0 = self->private_impl.f_components_workbuf_widths[0u];
v_height0 = self->private_impl.f_components_workbuf_heights[0u];
}
if ((self->private_impl.f_components_workbuf_offsets[1u] <= self->private_impl.f_components_workbuf_offsets[2u]) && (self->private_impl.f_components_workbuf_offsets[2u] <= ((uint64_t)(a_workbuf.len)))) {
v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[1u],
self->private_impl.f_components_workbuf_offsets[2u]);
v_width1 = self->private_impl.f_components_workbuf_widths[1u];
v_height1 = self->private_impl.f_components_workbuf_heights[1u];
}
if ((self->private_impl.f_components_workbuf_offsets[2u] <= self->private_impl.f_components_workbuf_offsets[3u]) && (self->private_impl.f_components_workbuf_offsets[3u] <= ((uint64_t)(a_workbuf.len)))) {
v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[2u],
self->private_impl.f_components_workbuf_offsets[3u]);
v_width2 = self->private_impl.f_components_workbuf_widths[2u];
v_height2 = self->private_impl.f_components_workbuf_heights[2u];
}
if ((self->private_impl.f_components_workbuf_offsets[3u] <= self->private_impl.f_components_workbuf_offsets[4u]) && (self->private_impl.f_components_workbuf_offsets[4u] <= ((uint64_t)(a_workbuf.len)))) {
v_src3 = wuffs_base__slice_u8__subslice_ij(a_workbuf,
self->private_impl.f_components_workbuf_offsets[3u],
self->private_impl.f_components_workbuf_offsets[4u]);
v_width3 = self->private_impl.f_components_workbuf_widths[3u];
v_height3 = self->private_impl.f_components_workbuf_heights[3u];
}
} }
v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler, v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler,
a_dst, a_dst,
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
self->private_impl.f_width, (a_x0 & 65535u),
self->private_impl.f_height, wuffs_base__u32__min(a_x1, self->private_impl.f_width),
(a_y0 & 65535u),
wuffs_base__u32__min(a_y1, self->private_impl.f_height),
v_src0, v_src0,
v_src1, v_src1,
v_src2, v_src2,
v_src3, v_src3,
self->private_impl.f_components_workbuf_widths[0u], v_width0,
self->private_impl.f_components_workbuf_widths[1u], v_width1,
self->private_impl.f_components_workbuf_widths[2u], v_width2,
self->private_impl.f_components_workbuf_widths[3u], v_width3,
self->private_impl.f_components_workbuf_heights[0u], v_height0,
self->private_impl.f_components_workbuf_heights[1u], v_height1,
self->private_impl.f_components_workbuf_heights[2u], v_height2,
self->private_impl.f_components_workbuf_heights[3u], v_height3,
self->private_impl.f_components_workbuf_widths[0u], v_width0,
self->private_impl.f_components_workbuf_widths[1u], v_width1,
self->private_impl.f_components_workbuf_widths[2u], v_width2,
self->private_impl.f_components_workbuf_widths[3u], v_width3,
self->private_impl.f_components_h[0u], self->private_impl.f_components_h[0u],
self->private_impl.f_components_h[1u], self->private_impl.f_components_h[1u],
self->private_impl.f_components_h[2u], self->private_impl.f_components_h[2u],
@@ -48667,7 +49073,7 @@ wuffs_jpeg__decoder__swizzle_colorful(
self->private_impl.f_components_v[2u], self->private_impl.f_components_v[2u],
self->private_impl.f_components_v[3u], self->private_impl.f_components_v[3u],
self->private_impl.f_is_rgb_or_cmyk, self->private_impl.f_is_rgb_or_cmyk,
true, ! self->private_impl.f_use_lower_quality,
wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048)); wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048));
return wuffs_private_impl__status__ensure_not_a_suspension(v_status); return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
} }
@@ -48779,6 +49185,7 @@ wuffs_jpeg__decoder__restart_frame(
} }
self->private_impl.f_call_sequence = 40u; self->private_impl.f_call_sequence = 40u;
self->private_impl.f_bitstream_is_closed = false; self->private_impl.f_bitstream_is_closed = false;
self->private_impl.f_expect_multiple_scans = false;
self->private_impl.f_frame_config_io_position = a_io_position; self->private_impl.f_frame_config_io_position = a_io_position;
self->private_impl.f_scan_count = 0u; self->private_impl.f_scan_count = 0u;
self->private_impl.f_restart_interval = self->private_impl.f_saved_restart_interval; self->private_impl.f_restart_interval = self->private_impl.f_saved_restart_interval;
@@ -48877,6 +49284,9 @@ wuffs_jpeg__decoder__workbuf_len(
return wuffs_base__utility__empty_range_ii_u64(); return wuffs_base__utility__empty_range_ii_u64();
} }
if (self->private_impl.f_use_lower_quality && (self->private_impl.f_sof_marker < 194u)) {
return wuffs_base__utility__make_range_ii_u64(0u, self->private_impl.f_components_workbuf_offsets[8u]);
}
return wuffs_base__utility__make_range_ii_u64(self->private_impl.f_components_workbuf_offsets[8u], self->private_impl.f_components_workbuf_offsets[8u]); return wuffs_base__utility__make_range_ii_u64(self->private_impl.f_components_workbuf_offsets[8u], self->private_impl.f_components_workbuf_offsets[8u]);
} }
@@ -49513,16 +49923,18 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu( wuffs_jpeg__decoder__decode_mcu(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
return (*self->private_impl.choosy_decode_mcu)(self, a_workbuf, a_mx, a_my); return (*self->private_impl.choosy_decode_mcu)(self, a_dst, a_workbuf, a_mx, a_my);
} }
WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu__choosy_default( wuffs_jpeg__decoder__decode_mcu__choosy_default(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -49722,11 +50134,47 @@ wuffs_jpeg__decoder__decode_mcu__choosy_default(
if (self->private_impl.f_test_only_interrupt_decode_mcu) { if (self->private_impl.f_test_only_interrupt_decode_mcu) {
goto label__goto_done__break; goto label__goto_done__break;
} }
v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]]; if ( ! self->private_impl.f_swizzle_immediately) {
v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[v_csel])); v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]];
v_offset = (self->private_impl.f_mcu_blocks_offset[v_mcb] + (((uint64_t)(self->private_impl.f_mcu_blocks_mx_mul[v_mcb])) * ((uint64_t)(a_mx))) + (((uint64_t)(self->private_impl.f_mcu_blocks_my_mul[v_mcb])) * ((uint64_t)(a_my)))); v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[v_csel]));
if (v_offset <= ((uint64_t)(a_workbuf.len))) { v_offset = (self->private_impl.f_mcu_blocks_offset[v_mcb] + (((uint64_t)(self->private_impl.f_mcu_blocks_mx_mul[v_mcb])) * ((uint64_t)(a_mx))) + (((uint64_t)(self->private_impl.f_mcu_blocks_my_mul[v_mcb])) * ((uint64_t)(a_my))));
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel]))); if (v_offset <= ((uint64_t)(a_workbuf.len))) {
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel])));
}
} else if (self->private_impl.f_num_components == 1u) {
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__make_slice_u8(self->private_data.f_swizzle_immediately_buffer, 64), 8u, ((uint32_t)(self->private_impl.f_components_tq[v_csel])));
self->private_impl.f_swizzle_immediately_status = wuffs_jpeg__decoder__swizzle_gray(self,
a_dst,
wuffs_base__make_slice_u8(self->private_data.f_swizzle_immediately_buffer, 64),
((a_mx + 0u) * 8u),
((a_mx + 1u) * 8u),
((a_my + 0u) * 8u),
((a_my + 1u) * 8u),
8u);
if ( ! wuffs_base__status__is_ok(&self->private_impl.f_swizzle_immediately_status)) {
v_ret = 3u;
goto label__goto_done__break;
}
break;
} else {
v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]];
v_stride = (8u * ((uint64_t)(self->private_impl.f_components_h[v_csel])));
wuffs_jpeg__decoder__decode_idct(self, wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, self->private_impl.f_swizzle_immediately_b_offsets[v_mcb], 640), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel])));
if (self->private_impl.f_mcu_current_block < self->private_impl.f_mcu_num_blocks) {
continue;
}
self->private_impl.f_swizzle_immediately_status = wuffs_jpeg__decoder__swizzle_colorful(self,
a_dst,
wuffs_base__utility__empty_slice_u8(),
((a_mx + 0u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_h))),
((a_mx + 1u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_h))),
((a_my + 0u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_v))),
((a_my + 1u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_v))));
if ( ! wuffs_base__status__is_ok(&self->private_impl.f_swizzle_immediately_status)) {
v_ret = 3u;
goto label__goto_done__break;
}
break;
} }
} }
self->private_impl.f_mcu_current_block = 0u; self->private_impl.f_mcu_current_block = 0u;
@@ -49755,6 +50203,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -49922,6 +50371,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -50183,6 +50633,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits( wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -50323,6 +50774,7 @@ WUFFS_BASE__GENERATED_C_CODE
static uint32_t static uint32_t
wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit( wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit(
wuffs_jpeg__decoder* self, wuffs_jpeg__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf, wuffs_base__slice_u8 a_workbuf,
uint32_t a_mx, uint32_t a_mx,
uint32_t a_my) { uint32_t a_my) {
@@ -69437,42 +69889,6 @@ WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[5] WUFFS_BASE__POTENTIALLY_UNUSED = {
1612u, 0u, 511u, 1022u, 1533u, 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 static const uint8_t
WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = { WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u, 24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u,
@@ -71023,29 +71439,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71077,29 +71472,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[0u] += v_prev_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[3u] += v_prev_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71129,29 +71503,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_curr_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71162,29 +71515,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_prev_row.ptr[4u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_prev_row.ptr[7u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71195,29 +71527,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_prev_row.ptr[8u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_prev_row.ptr[11u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71228,29 +71539,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += v_prev_row.ptr[0u]; 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]; 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]; 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]; v_curr_row.ptr[7u] += v_prev_row.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71265,29 +71555,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); 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))); 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))); 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))); v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71298,29 +71567,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71331,29 +71579,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71364,29 +71591,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71397,29 +71603,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u))); 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))); 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))); 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))); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71438,29 +71623,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + v_t0) / 2u))); 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))); 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))); 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))); v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + v_t3) / 2u)));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71492,29 +71656,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(v_l0)); 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)); 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)); 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)); v_curr_row.ptr[7u] += ((uint8_t)(v_l3));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71525,29 +71668,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_curr_row.ptr[4u] += ((uint8_t)(v_t0)); 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)); 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)); 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)); v_curr_row.ptr[7u] += ((uint8_t)(v_t3));
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71559,29 +71681,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #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]); 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]); 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]); 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]); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71592,29 +71693,8 @@ wuffs_webp__decoder__apply_transform_predictor(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #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]); 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]); 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]); 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]); 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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71724,9 +71804,9 @@ wuffs_webp__decoder__apply_transform_cross_color(
v_x = 0u; v_x = 0u;
while (v_x < self->private_impl.f_width) { while (v_x < self->private_impl.f_width) {
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) { 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_g2r = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[0u]);
v_g2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[1u]]; v_g2b = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[1u]);
v_r2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[2u]]; v_r2b = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[2u]);
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u); v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
} }
if (((uint64_t)(a_pix.len)) >= 4u) { if (((uint64_t)(a_pix.len)) >= 4u) {
@@ -71737,23 +71817,9 @@ wuffs_webp__decoder__apply_transform_cross_color(
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_r += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2r)) >> 5u))); v_r += ((uint8_t)((((uint32_t)(wuffs_base__utility__sign_extend_convert_u8_u32(v_g) * v_g2r)) >> 5u)));
#if defined(__GNUC__) v_b += ((uint8_t)((((uint32_t)(wuffs_base__utility__sign_extend_convert_u8_u32(v_g) * v_g2b)) >> 5u)));
#pragma GCC diagnostic pop v_b += ((uint8_t)((((uint32_t)(wuffs_base__utility__sign_extend_convert_u8_u32(v_r) * v_r2b)) >> 5u)));
#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__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
#endif #endif
@@ -71790,13 +71856,6 @@ wuffs_webp__decoder__apply_transform_subtract_green(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_p.ptr[0u] += v_g; 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; v_p.ptr[2u] += v_g;
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -71834,6 +71893,26 @@ wuffs_webp__decoder__apply_transform_color_indexing(
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u])); v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u]));
if (v_tile_size_log2 == 0u) { if (v_tile_size_log2 == 0u) {
{
wuffs_base__slice_u8 i_slice_dst = a_pix;
v_dst.ptr = i_slice_dst.ptr;
v_dst.len = 4;
const uint8_t* i_end0_dst = wuffs_private_impl__ptr_u8_plus_len(v_dst.ptr, (((i_slice_dst.len - (size_t)(v_dst.ptr - i_slice_dst.ptr)) / 4) * 4));
while (v_dst.ptr < i_end0_dst) {
v_p = (((uint32_t)(v_dst.ptr[1u])) * 4u);
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.ptr += 4;
}
v_dst.len = 0;
}
return wuffs_base__make_empty_struct();
} }
v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2); v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2);
v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u); v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
@@ -72930,6 +73009,7 @@ wuffs_webp__decoder__decode_transform(
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL); wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0; uint8_t v_c8 = 0;
uint32_t v_transform_type = 0; uint32_t v_transform_type = 0;
uint32_t v_tile_size_log2 = 0; uint32_t v_tile_size_log2 = 0;
@@ -73028,28 +73108,34 @@ wuffs_webp__decoder__decode_transform(
if (status.repr) { if (status.repr) {
goto suspend; 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)))) { while (true) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); 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)))) {
goto exit; 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)); {
} if (a_src) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
status = wuffs_webp__decoder__decode_pixels(self, }
wuffs_base__slice_u8__subslice_ij(a_workbuf, wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])), wuffs_base__slice_u8__subslice_ij(a_workbuf,
((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 + 1u)])),
a_src, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))),
((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), a_src,
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(), ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
0u); wuffs_base__utility__empty_slice_u8(),
if (a_src) { 0u);
iop_a_src = a_src->data.ptr + a_src->meta.ri; v_status = t_2;
} if (a_src) {
if (status.repr) { iop_a_src = a_src->data.ptr + a_src->meta.ri;
goto suspend; }
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
} }
} else if (v_transform_type == 2u) { } else if (v_transform_type == 2u) {
} else { } else {
@@ -73060,8 +73146,8 @@ wuffs_webp__decoder__decode_transform(
status = wuffs_base__make_status(wuffs_base__suspension__short_read); status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend; goto suspend;
} }
uint8_t t_2 = *iop_a_src++; uint8_t t_3 = *iop_a_src++;
v_c8 = t_2; v_c8 = t_3;
} }
if (self->private_impl.f_n_bits >= 8u) { if (self->private_impl.f_n_bits >= 8u) {
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
@@ -73136,29 +73222,8 @@ wuffs_webp__decoder__decode_transform(
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#endif #endif
v_p.ptr[4u] += v_p.ptr[0u]; 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]; 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]; 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]; v_p.ptr[7u] += v_p.ptr[3u];
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@@ -73167,7 +73232,6 @@ wuffs_webp__decoder__decode_transform(
} }
} }
goto ok;
ok: ok:
self->private_impl.p_decode_transform = 0; self->private_impl.p_decode_transform = 0;
goto exit; goto exit;
@@ -73291,6 +73355,7 @@ wuffs_webp__decoder__decode_hg_table(
wuffs_base__slice_u8 a_workbuf) { wuffs_base__slice_u8 a_workbuf) {
wuffs_base__status status = wuffs_base__make_status(NULL); wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint8_t v_c8 = 0; uint8_t v_c8 = 0;
uint32_t v_use_hg_table = 0; uint32_t v_use_hg_table = 0;
uint32_t v_tile_size_log2 = 0; uint32_t v_tile_size_log2 = 0;
@@ -73395,28 +73460,34 @@ wuffs_webp__decoder__decode_hg_table(
if (status.repr) { if (status.repr) {
goto suspend; 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)))) { while (true) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); 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)))) {
goto exit; 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)); {
} if (a_src) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
status = wuffs_webp__decoder__decode_pixels(self, }
wuffs_base__slice_u8__subslice_ij(a_workbuf, wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), wuffs_base__slice_u8__subslice_ij(a_workbuf,
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
a_src, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))),
((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), a_src,
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
wuffs_base__utility__empty_slice_u8(), ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
0u); wuffs_base__utility__empty_slice_u8(),
if (a_src) { 0u);
iop_a_src = a_src->data.ptr + a_src->meta.ri; v_status = t_2;
} if (a_src) {
if (status.repr) { iop_a_src = a_src->data.ptr + a_src->meta.ri;
goto suspend; }
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
} }
self->private_impl.f_overall_n_huffman_groups = 1u; 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)))) { 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)))) {
@@ -77458,15 +77529,13 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input, sync_io::Input& input,
IOBuffer& buffer) {} IOBuffer& buffer) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0) DecodeCborArgQuirks::DecodeCborArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeCborArgQuirks // DecodeCborArgQuirks //
DecodeCborArgQuirks::DefaultValue() { DecodeCborArgQuirks::DefaultValue() {
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32()); return DecodeCborArgQuirks(nullptr, 0);
} }
DecodeCborResult // DecodeCborResult //
@@ -77495,8 +77564,8 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
ret_error_message = "wuffs_aux::DecodeCbor: out of memory"; ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
goto done; goto done;
} }
for (size_t i = 0; i < quirks.repr.len; i++) { for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk(quirks.repr.ptr[i], 1); dec->set_quirk(quirks.ptr[i].first, quirks.ptr[i].second);
} }
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB. // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
@@ -77989,15 +78058,13 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
const char DecodeImage_UnsupportedPixelFormat[] = // const char DecodeImage_UnsupportedPixelFormat[] = //
"wuffs_aux::DecodeImage: unsupported pixel format"; "wuffs_aux::DecodeImage: unsupported pixel format";
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0) DecodeImageArgQuirks::DecodeImageArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeImageArgQuirks // DecodeImageArgQuirks //
DecodeImageArgQuirks::DefaultValue() { DecodeImageArgQuirks::DefaultValue() {
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32()); return DecodeImageArgQuirks(nullptr, 0);
} }
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {} DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
@@ -78095,7 +78162,8 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
DecodeImageCallbacks& callbacks, DecodeImageCallbacks& callbacks,
sync_io::Input& input, sync_io::Input& input,
wuffs_base__io_buffer& io_buf, wuffs_base__io_buffer& io_buf,
wuffs_base__slice_u32 quirks, const QuirkKeyValuePair* quirks_ptr,
const size_t quirks_len,
uint64_t flags, uint64_t flags,
wuffs_base__pixel_blend pixel_blend, wuffs_base__pixel_blend pixel_blend,
wuffs_base__color_u32_argb_premul background_color, wuffs_base__color_u32_argb_premul background_color,
@@ -78178,8 +78246,8 @@ redirect:
} }
// Apply quirks. // Apply quirks.
for (size_t i = 0; i < quirks.len; i++) { for (size_t i = 0; i < quirks_len; i++) {
image_decoder->set_quirk(quirks.ptr[i], 1); image_decoder->set_quirk(quirks_ptr[i].first, quirks_ptr[i].second);
} }
// Apply flags. // Apply flags.
@@ -78406,10 +78474,10 @@ DecodeImage(DecodeImageCallbacks& callbacks,
} }
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr); wuffs_base__image_decoder::unique_ptr image_decoder(nullptr);
DecodeImageResult result = DecodeImageResult result = DecodeImage0(
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr, image_decoder, callbacks, input, *io_buf, quirks.ptr, quirks.len,
flags.repr, pixel_blend.repr, background_color.repr, flags.repr, pixel_blend.repr, background_color.repr,
max_incl_dimension.repr, max_incl_metadata_length.repr); max_incl_dimension.repr, max_incl_metadata_length.repr);
callbacks.Done(result, input, *io_buf, std::move(image_decoder)); callbacks.Done(result, input, *io_buf, std::move(image_decoder));
return result; return result;
} }
@@ -78444,15 +78512,13 @@ const char DecodeJson_BadJsonPointer[] = //
const char DecodeJson_NoMatch[] = // const char DecodeJson_NoMatch[] = //
"wuffs_aux::DecodeJson: no match"; "wuffs_aux::DecodeJson: no match";
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0) DecodeJsonArgQuirks::DecodeJsonArgQuirks(const QuirkKeyValuePair* ptr0,
: repr(repr0) {} const size_t len0)
: ptr(ptr0), len(len0) {}
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
DecodeJsonArgQuirks // DecodeJsonArgQuirks //
DecodeJsonArgQuirks::DefaultValue() { DecodeJsonArgQuirks::DefaultValue() {
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32()); return DecodeJsonArgQuirks(nullptr, 0);
} }
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0) DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
@@ -78797,11 +78863,11 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
goto done; goto done;
} }
bool allow_tilde_n_tilde_r_tilde_t = false; bool allow_tilde_n_tilde_r_tilde_t = false;
for (size_t i = 0; i < quirks.repr.len; i++) { for (size_t i = 0; i < quirks.len; i++) {
dec->set_quirk(quirks.repr.ptr[i], 1); dec->set_quirk(quirks.ptr[i].first, quirks.ptr[i].second);
if (quirks.repr.ptr[i] == if (quirks.ptr[i].first ==
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) { WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
allow_tilde_n_tilde_r_tilde_t = true; allow_tilde_n_tilde_r_tilde_t = (quirks.ptr[i].second != 0);
} }
} }
+6 -1
View File
@@ -46,6 +46,11 @@
// //
// Pass -a (--all-tokens) to print all tokens, including whitespace. // Pass -a (--all-tokens) to print all tokens, including whitespace.
// //
// Pass -i=cbor (--input-format=cbor) to parse CBOR instead of JSON.
//
// Pass -q (--quirks) to enable all of a pre-defined set of various parser
// quirks. For example, allowing JSON comments or JSON "inf" numbers.
//
// If the input or output is larger than the program's buffers (64 MiB and // If the input or output is larger than the program's buffers (64 MiB and
// 131072 tokens by default), there may be multiple valid tokenizations of any // 131072 tokens by default), there may be multiple valid tokenizations of any
// given input. For example, if a source string "abcde" straddles an I/O // given input. For example, if a source string "abcde" straddles an I/O
@@ -418,7 +423,7 @@ compute_exit_code(const char* status_msg) {
size_t n = strnlen(status_msg, 2047); size_t n = strnlen(status_msg, 2047);
if (n >= 2047) { if (n >= 2047) {
status_msg = "main: internal error: error message is too long"; status_msg = "main: internal error: error message is too long";
n = strnlen(status_msg, 2047); n = strlen(status_msg);
} }
fprintf(stderr, "%s\n", status_msg); fprintf(stderr, "%s\n", status_msg);
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly // Return an exit code of 1 for regular (foreseen) errors, e.g. badly
+1 -1
View File
@@ -307,7 +307,7 @@ compute_exit_code(const char* status_msg) {
size_t n = strnlen(status_msg, 2047); size_t n = strnlen(status_msg, 2047);
if (n >= 2047) { if (n >= 2047) {
status_msg = "main: internal error: error message is too long"; status_msg = "main: internal error: error message is too long";
n = strnlen(status_msg, 2047); n = strlen(status_msg);
} }
fprintf(stderr, "%s\n", status_msg); fprintf(stderr, "%s\n", status_msg);
// Return an exit code of 1 for regular (foreseen) errors, e.g. badly // Return an exit code of 1 for regular (foreseen) errors, e.g. badly
+3 -1
View File
@@ -103,6 +103,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
var width : base.u32 var width : base.u32
var height : base.u32 var height : base.u32
var planes : base.u32 var planes : base.u32
var n : base.u32
var dst_pixfmt : base.u32 var dst_pixfmt : base.u32
var byte_width : base.u32 var byte_width : base.u32
@@ -275,7 +276,8 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
} }
} else if this.bitmap_info_len >= 40 { } else if this.bitmap_info_len >= 40 {
// Skip the rest of the BITMAPINFOHEADER. // Skip the rest of the BITMAPINFOHEADER.
args.src.skip_u32?(n: this.bitmap_info_len - 40) n = this.bitmap_info_len - 40
args.src.skip_u32?(n: n)
} else { } else {
return "#unsupported BMP file" return "#unsupported BMP file"
} }
+214 -58
View File
@@ -15,6 +15,7 @@ pub status "#bad SOF marker"
pub status "#bad SOS marker" pub status "#bad SOS marker"
pub status "#bad header" pub status "#bad header"
pub status "#bad marker" pub status "#bad marker"
pub status "#bad scan count"
pub status "#missing Huffman table" pub status "#missing Huffman table"
pub status "#missing Quantization table" pub status "#missing Quantization table"
pub status "#truncated input" pub status "#truncated input"
@@ -278,6 +279,15 @@ pub struct decoder? implements base.image_decoder(
bitstream_is_closed : base.bool, bitstream_is_closed : base.bool,
expect_multiple_scans : base.bool,
use_lower_quality : base.bool,
swizzle_immediately : base.bool,
swizzle_immediately_status : base.status,
swizzle_immediately_b_offsets : array[10] base.u32[..= 576],
swizzle_immediately_c_offsets : array[5] base.u32,
// bitstream_padding is the number (per restart) of implicit zeroes // bitstream_padding is the number (per restart) of implicit zeroes
// remaining at the end of the bitstream. Its initial 12345 value is // remaining at the end of the bitstream. Its initial 12345 value is
// arbitrary. // arbitrary.
@@ -311,6 +321,8 @@ pub struct decoder? implements base.image_decoder(
// Decoding progressive JPEGs can use all of it. // Decoding progressive JPEGs can use all of it.
mcu_blocks : array[10] array[64] base.u16, mcu_blocks : array[10] array[64] base.u16,
swizzle_immediately_buffer : array[640] base.u8,
swizzle_ycck_scratch_buffer_2k : array[2048] base.u8, swizzle_ycck_scratch_buffer_2k : array[2048] base.u8,
// The dht_temp_etc fields are decode_dht temporary values. // The dht_temp_etc fields are decode_dht temporary values.
@@ -326,10 +338,45 @@ pub struct decoder? implements base.image_decoder(
) )
pub func decoder.get_quirk(key: base.u32) base.u64 { pub func decoder.get_quirk(key: base.u32) base.u64 {
if args.key == base.QUIRK_QUALITY {
if this.use_lower_quality {
return 0xFFFF_FFFF_FFFF_FFFF
}
}
return 0 return 0
} }
// If key is base.QUIRK_QUALITY then, when re-interpreting the value as a
// signed i64 value, a negative quirk value opts the decoder in to a slightly
// worse quality but leaner (less memory required) chroma upsampling algorithm.
//
// Negative (in i64 space) means >= 0x8000_0000_0000_0000 (in u64 space).
//
// Specifically, a negative quirk value uses a box filter. A non-negative quirk
// value (including the default value, zero) uses the same triangle filter that
// libjpeg-turbo also uses by default, which requires chroma upsampling on the
// edges of a MCU (Minimum Coded Unit) to remember adjacent MCU's values.
//
// Leaner means that for common (sequential) JPEG images, the range returned by
// decoder.workbuf_len can have a minimum value of zero, meaning that no work
// buffer memory needs to be allocated. Decoding rarer (progressive) JPEGs will
// still require a positive amount of work buffer memory. The exact amount
// required depends on factors like the JPEG image's width, height, component
// count and subsampling ratios.
//
// Regardless of the quirk value, as always, the workbuf_len method returns a
// range, whose min and max can be different. The caller is able to choose
// between providing the minimal amount of work buffer memory (for slightly
// slower decoding) or the maximal amount (for slightly faster decoding).
//
// Callers that never wish to allocate work buffer memory can simply reject
// progressive JPEGs (where workbuf_len().min_incl > 0 despite setting the
// base.QUIRK_QUALITY key to a negative quirk value) as unsupported.
pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
if args.key == base.QUIRK_QUALITY {
this.use_lower_quality = args.value >= 0x8000_0000_0000_0000
return ok
}
return base."#unsupported option" return base."#unsupported option"
} }
@@ -878,15 +925,29 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
ddf_status = "#truncated input" ddf_status = "#truncated input"
} }
if ddf_status.is_error() or (scan_count < this.scan_count) { if (not this.swizzle_immediately) and
(ddf_status.is_error() or (scan_count < this.scan_count)) {
if this.sof_marker >= 0xC2 { if this.sof_marker >= 0xC2 {
this.apply_progressive_idct!(workbuf: args.workbuf) this.apply_progressive_idct!(workbuf: args.workbuf)
} }
if this.num_components == 1 { if this.num_components == 1 {
swizzle_status = this.swizzle_gray!(dst: args.dst, workbuf: args.workbuf) swizzle_status = this.swizzle_gray!(
dst: args.dst,
workbuf: args.workbuf,
x0: 0,
x1: 0xFFFF_FFFF,
y0: 0,
y1: 0xFFFF_FFFF,
stride: this.components_workbuf_widths[0] as base.u64)
} else { } else {
swizzle_status = this.swizzle_colorful!(dst: args.dst, workbuf: args.workbuf) swizzle_status = this.swizzle_colorful!(
dst: args.dst,
workbuf: args.workbuf,
x0: 0,
x1: 0xFFFF_FFFF,
y0: 0,
y1: 0xFFFF_FFFF)
} }
if ddf_status.is_error() { if ddf_status.is_error() {
return ddf_status return ddf_status
@@ -929,9 +990,14 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
// For progressive JPEGs, zero-initialize the saved pre-IDCT blocks. For // For progressive JPEGs, zero-initialize the saved pre-IDCT blocks. For
// sequential JPEGs, this is a no-op, other than checking that args.workbuf // sequential JPEGs, this is a no-op, other than checking that args.workbuf
// is long enough. // is long enough and setting this.swizzle_immediately.
this.swizzle_immediately = false
if this.components_workbuf_offsets[8] > args.workbuf.length() { if this.components_workbuf_offsets[8] > args.workbuf.length() {
return base."#bad workbuf length" if this.sof_marker >= 0xC2 {
return base."#bad workbuf length"
}
this.swizzle_immediately = this.use_lower_quality
this.swizzle_immediately_status = ok
} else if this.components_workbuf_offsets[4] < this.components_workbuf_offsets[8] { } else if this.components_workbuf_offsets[4] < this.components_workbuf_offsets[8] {
args.workbuf[this.components_workbuf_offsets[4] .. this.components_workbuf_offsets[8]].bulk_memset!(byte_value: 0) args.workbuf[this.components_workbuf_offsets[4] .. this.components_workbuf_offsets[8]].bulk_memset!(byte_value: 0)
} }
@@ -1006,7 +1072,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
break break
} else if marker == 0xDA { // SOS (Start Of Scan). } else if marker == 0xDA { // SOS (Start Of Scan).
this.decode_sos?(src: args.src, workbuf: args.workbuf) this.decode_sos?(dst: args.dst, src: args.src, workbuf: args.workbuf)
continue continue
} else if marker == 0xDB { // DQT (Define Quantization Table). } else if marker == 0xDB { // DQT (Define Quantization Table).
@@ -1247,15 +1313,17 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas
return false return false
} }
pri func decoder.decode_sos?(src: base.io_reader, workbuf: slice base.u8) { pri func decoder.decode_sos?(dst: ptr base.pixel_buffer, src: base.io_reader, workbuf: slice base.u8) {
var my : base.u32 var my : base.u32
var mx : base.u32 var mx : base.u32
var decode_mcu_result : base.u32 var decode_mcu_result : base.u32
var bitstream_length : base.u32 var bitstream_length : base.u32
if this.scan_count >= 64 { if this.scan_count >= 32 {
return "#unsupported scan count" return "#unsupported scan count"
} else if (this.scan_count > 0) and (not this.expect_multiple_scans) {
return "#bad scan count"
} }
this.prepare_scan?(src: args.src) this.prepare_scan?(src: args.src)
@@ -1294,11 +1362,15 @@ pri func decoder.decode_sos?(src: base.io_reader, workbuf: slice base.u8) {
inv my < 0x2000, inv my < 0x2000,
inv mx < 0x2000, inv mx < 0x2000,
{ {
decode_mcu_result = this.decode_mcu!(workbuf: args.workbuf, mx: mx, my: my) decode_mcu_result = this.decode_mcu!(dst: args.dst, workbuf: args.workbuf, mx: mx, my: my)
if decode_mcu_result == 0 { if decode_mcu_result == 0 {
break.decode_mcu break.decode_mcu
} else if decode_mcu_result <> 1 { } else if decode_mcu_result == 1 {
// No-op.
} else if decode_mcu_result == 2 {
return "#internal error: inconsistent decoder state" return "#internal error: inconsistent decoder state"
} else {
return this.swizzle_immediately_status
} }
while.fill_bitstream true, while.fill_bitstream true,
@@ -1431,6 +1503,12 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
i += 1 i += 1
} }
if this.scan_count == 0 {
this.expect_multiple_scans =
(this.sof_marker >= 0xC2) or
(this.scan_num_components < this.num_components)
}
if this.sof_marker < 0xC2 { if this.sof_marker < 0xC2 {
// At this point, for sequential (not progressive) JPEGs, we should // At this point, for sequential (not progressive) JPEGs, we should
// check that (Ss, Se, Ah, Al) is (0, 63, 0, 0) but libjpeg treats // check that (Ss, Se, Ah, Al) is (0, 63, 0, 0) but libjpeg treats
@@ -1575,6 +1653,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool {
var b : base.u32 var b : base.u32
var bx_offset : base.u32 var bx_offset : base.u32
var by_offset : base.u32 var by_offset : base.u32
var sibo : base.u32
var ssel : base.u8[..= 3] var ssel : base.u8[..= 3]
var csel : base.u8[..= 3] var csel : base.u8[..= 3]
@@ -1589,6 +1668,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool {
v = this.components_v[this.scan_comps_cselector[i]] as base.u32 v = this.components_v[this.scan_comps_cselector[i]] as base.u32
hv = ((this.components_h[this.scan_comps_cselector[i]] as base.u32) * hv = ((this.components_h[this.scan_comps_cselector[i]] as base.u32) *
(this.components_v[this.scan_comps_cselector[i]] as base.u32)) (this.components_v[this.scan_comps_cselector[i]] as base.u32))
this.swizzle_immediately_c_offsets[i] = 64 ~mod* total_hv
total_hv ~mod+= hv total_hv ~mod+= hv
while hv > 0, while hv > 0,
@@ -1615,6 +1695,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool {
return true return true
} }
this.mcu_num_blocks = total_hv this.mcu_num_blocks = total_hv
this.swizzle_immediately_c_offsets[this.scan_num_components] = 64 ~mod* total_hv
b = 0 b = 0
while b < this.mcu_num_blocks { while b < this.mcu_num_blocks {
@@ -1628,6 +1709,10 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool {
this.mcu_blocks_my_mul[b] = 8 * (this.components_v[csel] as base.u32) * this.components_workbuf_widths[csel] this.mcu_blocks_my_mul[b] = 8 * (this.components_v[csel] as base.u32) * this.components_workbuf_widths[csel]
this.mcu_blocks_dc_hselector[b] = 0 | this.scan_comps_td[ssel] this.mcu_blocks_dc_hselector[b] = 0 | this.scan_comps_td[ssel]
this.mcu_blocks_ac_hselector[b] = 4 | this.scan_comps_ta[ssel] this.mcu_blocks_ac_hselector[b] = 4 | this.scan_comps_ta[ssel]
sibo = this.swizzle_immediately_c_offsets[csel] ~mod+ (
(8 * (this.scan_comps_bx_offset[b] as base.u32)) +
(64 * (this.scan_comps_by_offset[b] as base.u32) * (this.components_h[csel] as base.u32)))
this.swizzle_immediately_b_offsets[b] = sibo.min(no_more_than: 576)
b += 1 b += 1
} }
@@ -1916,15 +2001,16 @@ pri func decoder.apply_progressive_idct!(workbuf: slice base.u8) {
this.mcu_blocks[.. 1].bulk_load_host_endian!(src: stashed_mcu_blocks_0[..]) this.mcu_blocks[.. 1].bulk_load_host_endian!(src: stashed_mcu_blocks_0[..])
} }
pri func decoder.swizzle_gray!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status { pri func decoder.swizzle_gray!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, x0: base.u32, x1: base.u32, y0: base.u32, y1: base.u32, stride: base.u64) base.status {
var dst_pixfmt : base.pixel_format var dst_pixfmt : base.pixel_format
var dst_bits_per_pixel : base.u32[..= 256] var dst_bits_per_pixel : base.u32[..= 256]
var dst_bytes_per_pixel : base.u32[..= 32] var dst_bytes_per_pixel : base.u32[..= 32]
var dst_length : base.u64 var x0 : base.u64
var x1 : base.u64
var tab : table base.u8 var tab : table base.u8
var dst : slice base.u8 var dst : slice base.u8
var y : base.u32 var y : base.u32
var stride : base.u64[..= 0x4_0000] var y1 : base.u32[..= 0xFFFF]
// TODO: the dst_pixfmt variable shouldn't be necessary. We should be able // 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()". // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()".
@@ -1934,79 +2020,143 @@ pri func decoder.swizzle_gray!(dst: ptr base.pixel_buffer, workbuf: slice base.u
return base."#unsupported option" return base."#unsupported option"
} }
dst_bytes_per_pixel = dst_bits_per_pixel / 8 dst_bytes_per_pixel = dst_bits_per_pixel / 8
dst_length = (dst_bytes_per_pixel * this.width) as base.u64 x0 = (dst_bytes_per_pixel * args.x0.min(no_more_than: this.width)) as base.u64
x1 = (dst_bytes_per_pixel * args.x1.min(no_more_than: this.width)) as base.u64
tab = args.dst.plane(p: 0) tab = args.dst.plane(p: 0)
y = 0 y = args.y0
while y < this.height { y1 = args.y1.min(no_more_than: this.height)
assert y < 0xFFFF via "a < b: a < c; c <= b"(c: this.height) while y < y1 {
assert y < 0xFFFF via "a < b: a < c; c <= b"(c: y1)
dst = tab.row_u32(y: y) dst = tab.row_u32(y: y)
if dst_length < dst.length() { if x1 < dst.length() {
dst = dst[.. dst_length] dst = dst[.. x1]
} }
if x0 < dst.length() {
dst = dst[x0 ..]
} else {
dst = this.util.empty_slice_u8()
}
this.swizzler.swizzle_interleaved_from_slice!( this.swizzler.swizzle_interleaved_from_slice!(
dst: dst, dst: dst,
dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]), dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]),
src: args.workbuf) src: args.workbuf)
stride = this.components_workbuf_widths[0] as base.u64
if stride <= args.workbuf.length() { if args.stride <= args.workbuf.length() {
args.workbuf = args.workbuf[stride ..] args.workbuf = args.workbuf[args.stride ..]
} else { } else {
args.workbuf = this.util.empty_slice_u8() args.workbuf = this.util.empty_slice_u8()
} }
y += 1 y += 1
} }
return ok return ok
} }
pri func decoder.swizzle_colorful!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status { pri func decoder.swizzle_colorful!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, x0: base.u32, x1: base.u32, y0: base.u32, y1: base.u32) base.status {
var src0 : slice base.u8 var i : base.u64
var src1 : slice base.u8 var j : base.u64
var src2 : slice base.u8 var src0 : slice base.u8
var src3 : slice base.u8 var src1 : slice base.u8
var status : base.status var src2 : slice base.u8
var src3 : slice base.u8
var width0 : base.u32[..= 0x1_0008]
var width1 : base.u32[..= 0x1_0008]
var width2 : base.u32[..= 0x1_0008]
var width3 : base.u32[..= 0x1_0008]
var height0 : base.u32[..= 0x1_0008]
var height1 : base.u32[..= 0x1_0008]
var height2 : base.u32[..= 0x1_0008]
var height3 : base.u32[..= 0x1_0008]
var status : base.status
if (this.components_workbuf_offsets[0] <= this.components_workbuf_offsets[1]) and if this.swizzle_immediately {
(this.components_workbuf_offsets[1] <= args.workbuf.length()) { i = this.swizzle_immediately_c_offsets[0] as base.u64
src0 = args.workbuf[this.components_workbuf_offsets[0] .. this.components_workbuf_offsets[1]] j = this.swizzle_immediately_c_offsets[1] as base.u64
} if (i <= j) and (j <= 640) {
src0 = this.swizzle_immediately_buffer[i .. j]
width0 = 8 * (this.components_h[0] as base.u32)
height0 = 8 * (this.components_v[0] as base.u32)
}
if (this.components_workbuf_offsets[1] <= this.components_workbuf_offsets[2]) and i = this.swizzle_immediately_c_offsets[1] as base.u64
(this.components_workbuf_offsets[2] <= args.workbuf.length()) { j = this.swizzle_immediately_c_offsets[2] as base.u64
src1 = args.workbuf[this.components_workbuf_offsets[1] .. this.components_workbuf_offsets[2]] if (i <= j) and (j <= 640) {
} src1 = this.swizzle_immediately_buffer[i .. j]
width1 = 8 * (this.components_h[1] as base.u32)
height1 = 8 * (this.components_v[1] as base.u32)
}
if (this.components_workbuf_offsets[2] <= this.components_workbuf_offsets[3]) and i = this.swizzle_immediately_c_offsets[2] as base.u64
(this.components_workbuf_offsets[3] <= args.workbuf.length()) { j = this.swizzle_immediately_c_offsets[3] as base.u64
src2 = args.workbuf[this.components_workbuf_offsets[2] .. this.components_workbuf_offsets[3]] if (i <= j) and (j <= 640) {
} src2 = this.swizzle_immediately_buffer[i .. j]
width2 = 8 * (this.components_h[2] as base.u32)
height2 = 8 * (this.components_v[2] as base.u32)
}
if (this.components_workbuf_offsets[3] <= this.components_workbuf_offsets[4]) and i = this.swizzle_immediately_c_offsets[3] as base.u64
(this.components_workbuf_offsets[4] <= args.workbuf.length()) { j = this.swizzle_immediately_c_offsets[4] as base.u64
src3 = args.workbuf[this.components_workbuf_offsets[3] .. this.components_workbuf_offsets[4]] if (i <= j) and (j <= 640) {
src3 = this.swizzle_immediately_buffer[i .. j]
width3 = 8 * (this.components_h[3] as base.u32)
height3 = 8 * (this.components_v[3] as base.u32)
}
} else {
if (this.components_workbuf_offsets[0] <= this.components_workbuf_offsets[1]) and
(this.components_workbuf_offsets[1] <= args.workbuf.length()) {
src0 = args.workbuf[this.components_workbuf_offsets[0] .. this.components_workbuf_offsets[1]]
width0 = this.components_workbuf_widths[0]
height0 = this.components_workbuf_heights[0]
}
if (this.components_workbuf_offsets[1] <= this.components_workbuf_offsets[2]) and
(this.components_workbuf_offsets[2] <= args.workbuf.length()) {
src1 = args.workbuf[this.components_workbuf_offsets[1] .. this.components_workbuf_offsets[2]]
width1 = this.components_workbuf_widths[1]
height1 = this.components_workbuf_heights[1]
}
if (this.components_workbuf_offsets[2] <= this.components_workbuf_offsets[3]) and
(this.components_workbuf_offsets[3] <= args.workbuf.length()) {
src2 = args.workbuf[this.components_workbuf_offsets[2] .. this.components_workbuf_offsets[3]]
width2 = this.components_workbuf_widths[2]
height2 = this.components_workbuf_heights[2]
}
if (this.components_workbuf_offsets[3] <= this.components_workbuf_offsets[4]) and
(this.components_workbuf_offsets[4] <= args.workbuf.length()) {
src3 = args.workbuf[this.components_workbuf_offsets[3] .. this.components_workbuf_offsets[4]]
width3 = this.components_workbuf_widths[3]
height3 = this.components_workbuf_heights[3]
}
} }
status = this.swizzler.swizzle_ycck!( status = this.swizzler.swizzle_ycck!(
dst: args.dst, dst: args.dst,
dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]), dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]),
width: this.width, x_min_incl: args.x0 & 0xFFFF,
height: this.height, x_max_excl: args.x1.min(no_more_than: this.width),
y_min_incl: args.y0 & 0xFFFF,
y_max_excl: args.y1.min(no_more_than: this.height),
src0: src0, src0: src0,
src1: src1, src1: src1,
src2: src2, src2: src2,
src3: src3, src3: src3,
width0: this.components_workbuf_widths[0], width0: width0,
width1: this.components_workbuf_widths[1], width1: width1,
width2: this.components_workbuf_widths[2], width2: width2,
width3: this.components_workbuf_widths[3], width3: width3,
height0: this.components_workbuf_heights[0], height0: height0,
height1: this.components_workbuf_heights[1], height1: height1,
height2: this.components_workbuf_heights[2], height2: height2,
height3: this.components_workbuf_heights[3], height3: height3,
stride0: this.components_workbuf_widths[0], stride0: width0,
stride1: this.components_workbuf_widths[1], stride1: width1,
stride2: this.components_workbuf_widths[2], stride2: width2,
stride3: this.components_workbuf_widths[3], stride3: width3,
h0: this.components_h[0], h0: this.components_h[0],
h1: this.components_h[1], h1: this.components_h[1],
h2: this.components_h[2], h2: this.components_h[2],
@@ -2016,7 +2166,7 @@ pri func decoder.swizzle_colorful!(dst: ptr base.pixel_buffer, workbuf: slice ba
v2: this.components_v[2], v2: this.components_v[2],
v3: this.components_v[3], v3: this.components_v[3],
is_rgb_or_cmyk: this.is_rgb_or_cmyk, is_rgb_or_cmyk: this.is_rgb_or_cmyk,
triangle_filter_for_2to1: true, triangle_filter_for_2to1: not this.use_lower_quality,
scratch_buffer_2k: this.swizzle_ycck_scratch_buffer_2k[..]) scratch_buffer_2k: this.swizzle_ycck_scratch_buffer_2k[..])
return status return status
} }
@@ -2060,6 +2210,7 @@ pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.sta
this.call_sequence = 0x28 this.call_sequence = 0x28
this.bitstream_is_closed = false this.bitstream_is_closed = false
this.expect_multiple_scans = false
this.frame_config_io_position = args.io_position this.frame_config_io_position = args.io_position
this.scan_count = 0 this.scan_count = 0
this.restart_interval = this.saved_restart_interval this.restart_interval = this.saved_restart_interval
@@ -2107,6 +2258,11 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
} }
pub func decoder.workbuf_len() base.range_ii_u64 { pub func decoder.workbuf_len() base.range_ii_u64 {
if this.use_lower_quality and (this.sof_marker < 0xC2) {
return this.util.make_range_ii_u64(
min_incl: 0,
max_incl: this.components_workbuf_offsets[8])
}
return this.util.make_range_ii_u64( return this.util.make_range_ii_u64(
min_incl: this.components_workbuf_offsets[8], min_incl: this.components_workbuf_offsets[8],
max_incl: this.components_workbuf_offsets[8]) max_incl: this.components_workbuf_offsets[8])
+54 -9
View File
@@ -8,7 +8,7 @@
// //
// SPDX-License-Identifier: Apache-2.0 OR MIT // SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32, pri func decoder.decode_mcu!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32,
choosy, choosy,
{ {
var ret : base.u32 var ret : base.u32
@@ -266,17 +266,62 @@ pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], m
} }
// Apply IDCT. // Apply IDCT.
csel = this.scan_comps_cselector[this.mcu_blocks_sselector[mcb]]
stride = this.components_workbuf_widths[csel] as base.u64 if not this.swizzle_immediately {
offset = this.mcu_blocks_offset[mcb] + csel = this.scan_comps_cselector[this.mcu_blocks_sselector[mcb]]
((this.mcu_blocks_mx_mul[mcb] as base.u64) * (args.mx as base.u64)) + stride = this.components_workbuf_widths[csel] as base.u64
((this.mcu_blocks_my_mul[mcb] as base.u64) * (args.my as base.u64)) offset = this.mcu_blocks_offset[mcb] +
if offset <= args.workbuf.length() { ((this.mcu_blocks_mx_mul[mcb] as base.u64) * (args.mx as base.u64)) +
((this.mcu_blocks_my_mul[mcb] as base.u64) * (args.my as base.u64))
if offset <= args.workbuf.length() {
this.decode_idct!(
dst_buffer: args.workbuf[offset ..],
dst_stride: stride,
q: this.components_tq[csel] as base.u32)
}
} else if this.num_components == 1 {
this.decode_idct!( this.decode_idct!(
dst_buffer: args.workbuf[offset ..], dst_buffer: this.swizzle_immediately_buffer[.. 64],
dst_stride: 8,
q: this.components_tq[csel] as base.u32)
this.swizzle_immediately_status = this.swizzle_gray!(
dst: args.dst,
workbuf: this.swizzle_immediately_buffer[.. 64],
x0: (args.mx + 0) * 8,
x1: (args.mx + 1) * 8,
y0: (args.my + 0) * 8,
y1: (args.my + 1) * 8,
stride: 8)
if not this.swizzle_immediately_status.is_ok() {
ret = 3 // Swizzling failure.
break.goto_done
}
break.block
} else {
csel = this.scan_comps_cselector[this.mcu_blocks_sselector[mcb]]
stride = 8 * (this.components_h[csel] as base.u64)
this.decode_idct!(
dst_buffer: this.swizzle_immediately_buffer[this.swizzle_immediately_b_offsets[mcb] ..],
dst_stride: stride, dst_stride: stride,
q: this.components_tq[csel] as base.u32) q: this.components_tq[csel] as base.u32)
if this.mcu_current_block < this.mcu_num_blocks {
continue.block
}
this.swizzle_immediately_status = this.swizzle_colorful!(
dst: args.dst,
workbuf: this.util.empty_slice_u8(),
x0: (args.mx + 0) * 8 * (this.max_incl_components_h as base.u32),
x1: (args.mx + 1) * 8 * (this.max_incl_components_h as base.u32),
y0: (args.my + 0) * 8 * (this.max_incl_components_v as base.u32),
y1: (args.my + 1) * 8 * (this.max_incl_components_v as base.u32))
if not this.swizzle_immediately_status.is_ok() {
ret = 3 // Swizzling failure.
break.goto_done
}
break.block
} }
}.block }.block
this.mcu_current_block = 0 this.mcu_current_block = 0
@@ -8,7 +8,7 @@
// //
// SPDX-License-Identifier: Apache-2.0 OR MIT // SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_mcu_progressive_ac_high_bits!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { pri func decoder.decode_mcu_progressive_ac_high_bits!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 {
var ret : base.u32 var ret : base.u32
var bits : base.u64 var bits : base.u64
@@ -8,7 +8,7 @@
// //
// SPDX-License-Identifier: Apache-2.0 OR MIT // SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_mcu_progressive_ac_low_bit!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { pri func decoder.decode_mcu_progressive_ac_low_bit!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 {
var ret : base.u32 var ret : base.u32
var bits : base.u64 var bits : base.u64
@@ -8,7 +8,7 @@
// //
// SPDX-License-Identifier: Apache-2.0 OR MIT // SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_mcu_progressive_dc_high_bits!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { pri func decoder.decode_mcu_progressive_dc_high_bits!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 {
var ret : base.u32 var ret : base.u32
var bits : base.u64 var bits : base.u64
@@ -8,7 +8,7 @@
// //
// SPDX-License-Identifier: Apache-2.0 OR MIT // SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_mcu_progressive_dc_low_bit!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { pri func decoder.decode_mcu_progressive_dc_low_bit!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 {
var ret : base.u32 var ret : base.u32
var bits : base.u64 var bits : base.u64
+18 -44
View File
@@ -321,9 +321,9 @@ pri func decoder.apply_transform_cross_color!(pix: slice base.u8, tile_data: ros
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width) assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
if ((x & mask) == 0) and (tile_data.length() >= 4) { if ((x & mask) == 0) and (tile_data.length() >= 4) {
g2r = SIGN_EXTEND_I8_I32[tile_data[0]] g2r = this.util.sign_extend_convert_u8_u32(a: tile_data[0])
g2b = SIGN_EXTEND_I8_I32[tile_data[1]] g2b = this.util.sign_extend_convert_u8_u32(a: tile_data[1])
r2b = SIGN_EXTEND_I8_I32[tile_data[2]] r2b = this.util.sign_extend_convert_u8_u32(a: tile_data[2])
tile_data = tile_data[4 ..] tile_data = tile_data[4 ..]
} }
@@ -331,9 +331,9 @@ pri func decoder.apply_transform_cross_color!(pix: slice base.u8, tile_data: ros
b = args.pix[0] b = args.pix[0]
g = args.pix[1] g = args.pix[1]
r = args.pix[2] r = args.pix[2]
r ~mod+= (((SIGN_EXTEND_I8_I32[g] ~mod* g2r) >> 5) & 0xFF) as base.u8 r ~mod+= (((this.util.sign_extend_convert_u8_u32(a: g) ~mod* g2r) >> 5) & 0xFF) as base.u8
b ~mod+= (((SIGN_EXTEND_I8_I32[g] ~mod* g2b) >> 5) & 0xFF) as base.u8 b ~mod+= (((this.util.sign_extend_convert_u8_u32(a: g) ~mod* g2b) >> 5) & 0xFF) as base.u8
b ~mod+= (((SIGN_EXTEND_I8_I32[r] ~mod* r2b) >> 5) & 0xFF) as base.u8 b ~mod+= (((this.util.sign_extend_convert_u8_u32(a: r) ~mod* r2b) >> 5) & 0xFF) as base.u8
args.pix[0] = b args.pix[0] = b
args.pix[2] = r args.pix[2] = r
args.pix = args.pix[4 ..] args.pix = args.pix[4 ..]
@@ -379,8 +379,18 @@ pri func decoder.apply_transform_color_indexing!(pix: slice base.u8) {
tile_size_log2 = this.transform_tile_size_log2[3] as base.u32 tile_size_log2 = this.transform_tile_size_log2[3] as base.u32
if tile_size_log2 == 0 { if tile_size_log2 == 0 {
// TODO: the code below is correct, but we could possibly simplify the iterate (dst = args.pix)(length: 4, advance: 4, unroll: 1) {
// case where the src and dst pixel counts are 1:1. p = (dst[1] as base.u32) * 4
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
}
return nothing
} }
bits_per_pixel = (8 as base.u32) >> tile_size_log2 bits_per_pixel = (8 as base.u32) >> tile_size_log2
@@ -426,39 +436,3 @@ pri func decoder.apply_transform_color_indexing!(pix: slice base.u8) {
y += 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,
]
+44 -24
View File
@@ -466,6 +466,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
} }
pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) { pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) {
var status : base.status
var c8 : base.u8 var c8 : base.u8
var transform_type : base.u32[..= 3] var transform_type : base.u32[..= 3]
var tile_size_log2 : base.u32[..= 9] var tile_size_log2 : base.u32[..= 9]
@@ -510,19 +511,29 @@ pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8)
this.decode_color_cache_parameters?(src: args.src) this.decode_color_cache_parameters?(src: args.src)
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) 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()) { while true,
return base."#bad workbuf length" inv transform_type < 2,
inv tile_size_log2 >= 2,
{
if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or
((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) {
return base."#bad workbuf length"
}
status =? this.decode_pixels?(
dst: args.workbuf[
(this.workbuf_offset_for_transform[transform_type + 1] as base.u64) ..
(this.workbuf_offset_for_transform[transform_type + 2] as base.u64)],
src: args.src,
width: (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
tile_data: this.util.empty_slice_u8(),
tile_size_log2: 0)
if status.is_ok() {
break
}
yield? status
} }
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. } else if transform_type == 2 { // Subtract Green transform.
// No-op. // No-op.
@@ -620,6 +631,7 @@ pri func decoder.decode_color_cache_parameters?(src: base.io_reader) {
} }
pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) { pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) {
var status : base.status
var c8 : base.u8 var c8 : base.u8
var use_hg_table : base.u32[..= 1] var use_hg_table : base.u32[..= 1]
var tile_size_log2 : base.u32[..= 9] var tile_size_log2 : base.u32[..= 9]
@@ -674,19 +686,27 @@ pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x400
this.decode_color_cache_parameters?(src: args.src) this.decode_color_cache_parameters?(src: args.src)
this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) 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 while true,
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { inv tile_size_log2 >= 2,
return base."#bad workbuf length" {
if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) {
return base."#bad workbuf length"
}
status =? this.decode_pixels?(
dst: args.workbuf[
(this.workbuf_offset_for_transform[0] as base.u64) ..
(this.workbuf_offset_for_transform[1] as base.u64)],
src: args.src,
width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2,
tile_data: this.util.empty_slice_u8(),
tile_size_log2: 0)
if status.is_ok() {
break
}
yield? status
} }
this.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 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 if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or
+24
View File
@@ -0,0 +1,24 @@
#!/bin/bash -eu
# 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 script fetches libwebp's test data suite.
if [ ! -e ../../wuffs-root-directory.txt ]; then
echo "$0 should be run from the Wuffs test/3pdata directory."
exit 1
fi
# Check out a specific commit (from July 2024).
git clone --quiet https://github.com/webmproject/libwebp-test-data.git webpsuite
cd webpsuite
git reset --quiet --hard 260804d686f0491e0326a50eef491829dae09e9e
@@ -0,0 +1,55 @@
# Generated by script/print-nia-checksums.sh
OK. ca4c0038 test/3pdata/webpsuite/bad_palette_index.webp
OK. 6fbda804 test/3pdata/webpsuite/color_cache_bits_11.webp
BAD d338aed8 test/3pdata/webpsuite/dual_transform.webp
OK. 1ef61f19 test/3pdata/webpsuite/grid.bmp
OK. 33b7a1f3 test/3pdata/webpsuite/grid.pgm
OK. f79224e7 test/3pdata/webpsuite/grid.png
OK. 06b07a30 test/3pdata/webpsuite/grid.ppm
OK. fce8fc76 test/3pdata/webpsuite/lossless1.webp
OK. fce8fc76 test/3pdata/webpsuite/lossless2.webp
OK. fce8fc76 test/3pdata/webpsuite/lossless3.webp
OK. 4cbe795c test/3pdata/webpsuite/lossless4.webp
OK. f8e3adf4 test/3pdata/webpsuite/lossless_big_random_alpha.webp
OK. 289af407 test/3pdata/webpsuite/lossless_color_transform.bmp
OK. 7b7c1ae6 test/3pdata/webpsuite/lossless_color_transform.pgm
OK. 289af407 test/3pdata/webpsuite/lossless_color_transform.ppm
OK. 289af407 test/3pdata/webpsuite/lossless_color_transform.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_0.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_1.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_10.webp
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_11.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_12.webp
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_13.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_14.webp
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_15.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_2.webp
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_3.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_4.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_5.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_6.webp
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_7.webp
OK. f79224e7 test/3pdata/webpsuite/lossless_vec_1_8.webp
BAD df11692d test/3pdata/webpsuite/lossless_vec_1_9.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_0.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_1.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_10.webp
BAD 62adeb37 test/3pdata/webpsuite/lossless_vec_2_11.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_12.webp
BAD 62adeb37 test/3pdata/webpsuite/lossless_vec_2_13.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_14.webp
BAD 62adeb37 test/3pdata/webpsuite/lossless_vec_2_15.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_2.webp
BAD 62adeb37 test/3pdata/webpsuite/lossless_vec_2_3.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_4.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_5.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_6.webp
BAD 62adeb37 test/3pdata/webpsuite/lossless_vec_2_7.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_8.webp
BAD 62adeb37 test/3pdata/webpsuite/lossless_vec_2_9.webp
OK. 6957defa test/3pdata/webpsuite/near_lossless_75.webp
OK. 7c80a001 test/3pdata/webpsuite/one_color_no_palette.webp
OK. 6706e719 test/3pdata/webpsuite/peak.bmp
OK. 315bbd77 test/3pdata/webpsuite/peak.pgm
OK. 6706e719 test/3pdata/webpsuite/peak.png
OK. 6706e719 test/3pdata/webpsuite/peak.ppm
+46 -2
View File
@@ -95,6 +95,48 @@ test_wuffs_jpeg_decode_interface() {
"test/data/bricks-color.jpeg", 0, SIZE_MAX, 160, 120, 0xFF012466); "test/data/bricks-color.jpeg", 0, SIZE_MAX, 160, 120, 0xFF012466);
} }
const char* //
test_wuffs_jpeg_decode_lower_quality() {
CHECK_FOCUS(__func__);
wuffs_jpeg__decoder dec;
CHECK_STATUS("initialize",
wuffs_jpeg__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
wuffs_jpeg__decoder__set_quirk(
&dec, WUFFS_BASE__QUIRK_QUALITY,
WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY);
CHECK_STRING(do_test__wuffs_base__image_decoder(
wuffs_jpeg__decoder__upcast_as__wuffs_base__image_decoder(&dec),
"test/data/bricks-color.jpeg", 0, SIZE_MAX, 160, 120, 0xFF012466));
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = g_src_slice_u8,
});
CHECK_STRING(read_file(&src, "test/data/bricks-color.jpeg"));
CHECK_STATUS("initialize", wuffs_jpeg__decoder__initialize(
&dec, sizeof dec, WUFFS_VERSION,
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
CHECK_STATUS("decode_image_config",
wuffs_jpeg__decoder__decode_image_config(&dec, NULL, &src));
for (int q = 0; q < 2; q++) {
if (q) {
wuffs_jpeg__decoder__set_quirk(
&dec, WUFFS_BASE__QUIRK_QUALITY,
WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY);
}
uint64_t m = wuffs_jpeg__decoder__workbuf_len(&dec).min_incl;
if ((q == 0) && (m == 0)) {
RETURN_FAIL("q=%d: have %" PRIu64 ", want non-zero", q, m);
} else if ((q != 0) && (m != 0)) {
RETURN_FAIL("q=%d: have %" PRIu64 ", want zero", q, m);
}
}
return NULL;
}
const char* // const char* //
test_wuffs_jpeg_decode_truncated_input() { test_wuffs_jpeg_decode_truncated_input() {
CHECK_FOCUS(__func__); CHECK_FOCUS(__func__);
@@ -739,8 +781,9 @@ test_wuffs_jpeg_decode_mcu() {
for (int b = 0; b < 6; b++) { for (int b = 0; b < 6; b++) {
const uint32_t mx = 0; const uint32_t mx = 0;
const uint32_t my = 0; const uint32_t my = 0;
if (wuffs_jpeg__decoder__decode_mcu(&dec, wuffs_base__empty_slice_u8(), mx, wuffs_base__pixel_buffer dst = {0};
my)) { if (wuffs_jpeg__decoder__decode_mcu(&dec, &dst,
wuffs_base__empty_slice_u8(), mx, my)) {
RETURN_FAIL("decode_mcu failed"); RETURN_FAIL("decode_mcu failed");
} }
@@ -988,6 +1031,7 @@ proc g_tests[] = {
test_wuffs_jpeg_decode_idct, test_wuffs_jpeg_decode_idct,
test_wuffs_jpeg_decode_mcu, test_wuffs_jpeg_decode_mcu,
test_wuffs_jpeg_decode_interface, test_wuffs_jpeg_decode_interface,
test_wuffs_jpeg_decode_lower_quality,
test_wuffs_jpeg_decode_truncated_input, test_wuffs_jpeg_decode_truncated_input,
#ifdef WUFFS_MIMIC #ifdef WUFFS_MIMIC