From 00e6e716723fbf568ddc06dabdb2c5066d21eaf4 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 7 Jul 2024 22:13:50 +1000 Subject: [PATCH] std/webp: implement VP8 Lossless --- release/c/wuffs-unsupported-snapshot.c | 3797 ++++++++++++++++++- std/webp/decode_huffman.wuffs | 531 +++ std/webp/decode_pixels_slow.wuffs | 308 ++ std/webp/decode_transform.wuffs | 464 +++ std/webp/decode_webp.wuffs | 685 +++- test/3pdata/nia-checksums-of-blinksuite.txt | 32 +- test/c/std/webp.c | 16 +- test/nia-checksums-of-data.txt | 28 +- 8 files changed, 5778 insertions(+), 83 deletions(-) create mode 100644 std/webp/decode_huffman.wuffs create mode 100644 std/webp/decode_pixels_slow.wuffs create mode 100644 std/webp/decode_transform.wuffs diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 97dbee01..af4b9b14 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -13742,7 +13742,18 @@ struct wuffs_wbmp__decoder__struct { // ---------------- Status Codes +extern const char wuffs_webp__error__bad_huffman_code_over_subscribed[]; +extern const char wuffs_webp__error__bad_huffman_code_under_subscribed[]; +extern const char wuffs_webp__error__bad_huffman_code[]; +extern const char wuffs_webp__error__bad_back_reference[]; +extern const char wuffs_webp__error__bad_color_cache[]; +extern const char wuffs_webp__error__bad_header[]; +extern const char wuffs_webp__error__bad_transform[]; +extern const char wuffs_webp__error__short_chunk[]; extern const char wuffs_webp__error__truncated_input[]; +extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[]; +extern const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[]; +extern const char wuffs_webp__error__unsupported_webp_file[]; // ---------------- Public Consts @@ -13915,15 +13926,117 @@ struct wuffs_webp__decoder__struct { uint32_t f_width; uint32_t f_height; uint8_t f_call_sequence; + uint8_t f_code_length_code_lengths[19]; + bool f_sub_chunk_has_padding; uint64_t f_frame_config_io_position; + uint32_t f_riff_chunk_length; + uint32_t f_sub_chunk_length; + uint32_t f_bits; + uint32_t f_n_bits; + bool f_seen_transform[4]; + uint8_t f_transform_type[4]; + uint8_t f_transform_tile_size_log2[4]; + uint32_t f_n_transforms; + uint32_t f_color_cache_bits; + uint32_t f_overall_color_cache_bits; + uint32_t f_overall_tile_size_log2; + uint32_t f_overall_n_huffman_groups; + uint32_t f_ht_n_symbols; + uint32_t f_ht_code_lengths_remaining; + uint32_t f_color_indexing_palette_size; + uint32_t f_color_indexing_width; + uint32_t f_workbuf_offset_for_transform[4]; + uint32_t f_workbuf_offset_for_color_indexing; wuffs_base__pixel_swizzler f_swizzler; + uint32_t p_decode_huffman_groups; + uint32_t p_decode_huffman_tree; + uint32_t p_decode_huffman_tree_simple; + uint32_t p_decode_code_length_code_lengths; + uint32_t p_build_code_lengths; + uint32_t p_decode_pixels_slow; uint32_t p_decode_image_config; + uint32_t p_do_decode_image_config; + uint32_t p_do_decode_image_config_limited; + uint32_t p_do_decode_image_config_limited_vp8l; uint32_t p_decode_frame_config; uint32_t p_do_decode_frame_config; uint32_t p_decode_frame; + uint32_t p_do_decode_frame; + uint32_t p_decode_transform; + uint32_t p_decode_color_cache_parameters; + uint32_t p_decode_hg_table; + uint32_t p_decode_pixels; } private_impl; + struct { + uint8_t f_palette[1024]; + uint32_t f_color_cache[2048]; + uint16_t f_codes[2328]; + uint16_t f_code_lengths[2328]; + uint16_t f_code_lengths_huffman_nodes[37]; + uint16_t f_huffman_nodes[256][6267]; + + struct { + uint32_t v_hg; + uint32_t v_ht; + } s_decode_huffman_groups; + struct { + uint32_t v_use_second_symbol; + uint32_t v_first_symbol_n_bits; + uint32_t v_symbol0; + uint32_t v_base_offset; + } s_decode_huffman_tree_simple; + struct { + uint32_t v_n_codes; + uint32_t v_i; + } s_decode_code_length_code_lengths; + struct { + uint32_t v_length_n_bits; + uint16_t v_prev_code_length; + uint32_t v_s; + uint32_t v_s_max; + uint16_t v_node; + uint16_t v_repeat_value; + uint32_t v_repeat_n_bits; + } s_build_code_lengths; + struct { + uint64_t v_p; + uint64_t v_p_max; + uint32_t v_tile_size_log2; + uint32_t v_width_in_tiles; + uint32_t v_x; + uint32_t v_y; + uint32_t v_hg; + uint16_t v_node; + uint32_t v_color; + uint32_t v_back_ref_len_n_bits; + uint32_t v_back_ref_len_minus_1; + uint32_t v_back_ref_dist_n_bits; + uint32_t v_back_ref_dist_premap_minus_1; + uint64_t v_color_cache_p; + } s_decode_pixels_slow; + struct { + uint64_t scratch; + } s_do_decode_image_config; + struct { + uint64_t scratch; + } s_do_decode_image_config_limited; + struct { + uint64_t scratch; + } s_do_decode_image_config_limited_vp8l; + struct { + uint32_t v_width; + } s_do_decode_frame; + struct { + uint32_t v_transform_type; + uint32_t v_tile_size_log2; + } s_decode_transform; + struct { + uint32_t v_tile_size_log2; + } s_decode_hg_table; + } private_data; + #ifdef __cplusplus #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) using unique_ptr = std::unique_ptr; @@ -69161,14 +69274,212 @@ wuffs_wbmp__decoder__workbuf_len( // ---------------- Status Codes Implementations +const char wuffs_webp__error__bad_huffman_code_over_subscribed[] = "#webp: bad Huffman code (over-subscribed)"; +const char wuffs_webp__error__bad_huffman_code_under_subscribed[] = "#webp: bad Huffman code (under-subscribed)"; +const char wuffs_webp__error__bad_huffman_code[] = "#webp: bad Huffman code"; +const char wuffs_webp__error__bad_back_reference[] = "#webp: bad back-reference"; +const char wuffs_webp__error__bad_color_cache[] = "#webp: bad color cache"; +const char wuffs_webp__error__bad_header[] = "#webp: bad header"; +const char wuffs_webp__error__bad_transform[] = "#webp: bad transform"; +const char wuffs_webp__error__short_chunk[] = "#webp: short chunk"; const char wuffs_webp__error__truncated_input[] = "#webp: truncated input"; +const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups"; +const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[] = "#webp: unsupported transform after color indexing transform"; +const char wuffs_webp__error__unsupported_webp_file[] = "#webp: unsupported WebP file"; +const char wuffs_webp__error__internal_error_inconsistent_huffman_code[] = "#webp: internal error: inconsistent Huffman code"; +const char wuffs_webp__error__internal_error_inconsistent_dst_buffer[] = "#webp: internal error: inconsistent dst buffer"; +const char wuffs_webp__error__internal_error_inconsistent_n_bits[] = "#webp: internal error: inconsistent n_bits"; // ---------------- Private Consts +static const uint8_t +WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[19] WUFFS_BASE__POTENTIALLY_UNUSED = { + 17u, 18u, 0u, 1u, 2u, 3u, 4u, 5u, + 16u, 6u, 7u, 8u, 9u, 10u, 11u, 12u, + 13u, 14u, 15u, +}; + +static const uint8_t +WUFFS_WEBP__REPEAT_N_BITS[4] WUFFS_BASE__POTENTIALLY_UNUSED = { + 2u, 3u, 7u, 0u, +}; + +static const uint8_t +WUFFS_WEBP__REPEAT_COUNTS[4] WUFFS_BASE__POTENTIALLY_UNUSED = { + 3u, 3u, 11u, 0u, +}; + +static const uint16_t +WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[5] WUFFS_BASE__POTENTIALLY_UNUSED = { + 1612u, 0u, 511u, 1022u, 1533u, +}; + +static const uint32_t +WUFFS_WEBP__SIGN_EXTEND_I8_I32[256] WUFFS_BASE__POTENTIALLY_UNUSED = { + 0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, + 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u, + 16u, 17u, 18u, 19u, 20u, 21u, 22u, 23u, + 24u, 25u, 26u, 27u, 28u, 29u, 30u, 31u, + 32u, 33u, 34u, 35u, 36u, 37u, 38u, 39u, + 40u, 41u, 42u, 43u, 44u, 45u, 46u, 47u, + 48u, 49u, 50u, 51u, 52u, 53u, 54u, 55u, + 56u, 57u, 58u, 59u, 60u, 61u, 62u, 63u, + 64u, 65u, 66u, 67u, 68u, 69u, 70u, 71u, + 72u, 73u, 74u, 75u, 76u, 77u, 78u, 79u, + 80u, 81u, 82u, 83u, 84u, 85u, 86u, 87u, + 88u, 89u, 90u, 91u, 92u, 93u, 94u, 95u, + 96u, 97u, 98u, 99u, 100u, 101u, 102u, 103u, + 104u, 105u, 106u, 107u, 108u, 109u, 110u, 111u, + 112u, 113u, 114u, 115u, 116u, 117u, 118u, 119u, + 120u, 121u, 122u, 123u, 124u, 125u, 126u, 127u, + 4294967168u, 4294967169u, 4294967170u, 4294967171u, 4294967172u, 4294967173u, 4294967174u, 4294967175u, + 4294967176u, 4294967177u, 4294967178u, 4294967179u, 4294967180u, 4294967181u, 4294967182u, 4294967183u, + 4294967184u, 4294967185u, 4294967186u, 4294967187u, 4294967188u, 4294967189u, 4294967190u, 4294967191u, + 4294967192u, 4294967193u, 4294967194u, 4294967195u, 4294967196u, 4294967197u, 4294967198u, 4294967199u, + 4294967200u, 4294967201u, 4294967202u, 4294967203u, 4294967204u, 4294967205u, 4294967206u, 4294967207u, + 4294967208u, 4294967209u, 4294967210u, 4294967211u, 4294967212u, 4294967213u, 4294967214u, 4294967215u, + 4294967216u, 4294967217u, 4294967218u, 4294967219u, 4294967220u, 4294967221u, 4294967222u, 4294967223u, + 4294967224u, 4294967225u, 4294967226u, 4294967227u, 4294967228u, 4294967229u, 4294967230u, 4294967231u, + 4294967232u, 4294967233u, 4294967234u, 4294967235u, 4294967236u, 4294967237u, 4294967238u, 4294967239u, + 4294967240u, 4294967241u, 4294967242u, 4294967243u, 4294967244u, 4294967245u, 4294967246u, 4294967247u, + 4294967248u, 4294967249u, 4294967250u, 4294967251u, 4294967252u, 4294967253u, 4294967254u, 4294967255u, + 4294967256u, 4294967257u, 4294967258u, 4294967259u, 4294967260u, 4294967261u, 4294967262u, 4294967263u, + 4294967264u, 4294967265u, 4294967266u, 4294967267u, 4294967268u, 4294967269u, 4294967270u, 4294967271u, + 4294967272u, 4294967273u, 4294967274u, 4294967275u, 4294967276u, 4294967277u, 4294967278u, 4294967279u, + 4294967280u, 4294967281u, 4294967282u, 4294967283u, 4294967284u, 4294967285u, 4294967286u, 4294967287u, + 4294967288u, 4294967289u, 4294967290u, 4294967291u, 4294967292u, 4294967293u, 4294967294u, 4294967295u, +}; + +static const uint8_t +WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = { + 24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u, + 22u, 26u, 38u, 42u, 56u, 5u, 55u, 57u, + 21u, 27u, 54u, 58u, 37u, 43u, 72u, 4u, + 71u, 73u, 20u, 28u, 53u, 59u, 70u, 74u, + 36u, 44u, 88u, 69u, 75u, 52u, 60u, 3u, + 87u, 89u, 19u, 29u, 86u, 90u, 35u, 45u, + 68u, 76u, 85u, 91u, 51u, 61u, 104u, 2u, + 103u, 105u, 18u, 30u, 102u, 106u, 34u, 46u, + 84u, 92u, 67u, 77u, 101u, 107u, 50u, 62u, + 120u, 1u, 119u, 121u, 83u, 93u, 17u, 31u, + 100u, 108u, 66u, 78u, 118u, 122u, 33u, 47u, + 117u, 123u, 49u, 63u, 99u, 109u, 82u, 94u, + 0u, 116u, 124u, 65u, 79u, 16u, 32u, 98u, + 110u, 48u, 115u, 125u, 81u, 95u, 64u, 114u, + 126u, 97u, 111u, 80u, 113u, 127u, 96u, 112u, +}; + // ---------------- Private Initializer Prototypes // ---------------- Private Function Prototypes +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_huffman_groups( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_n_huffman_groups); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_huffman_tree( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_hg, + uint32_t a_ht); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_huffman_tree_simple( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_hg, + uint32_t a_ht); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_code_length_code_lengths( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__build_code_lengths_huffman_nodes( + wuffs_webp__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__build_huffman_nodes( + wuffs_webp__decoder* self, + uint32_t a_hg, + uint32_t a_ht); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__build_code_lengths( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_pixels_slow( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_dst, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + uint32_t a_height, + wuffs_base__slice_u8 a_tile_data, + uint32_t a_tile_size_log2); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_predictor( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix, + wuffs_base__slice_u8 a_tile_data); + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_webp__decoder__absolute_difference( + const wuffs_webp__decoder* self, + uint32_t a_a, + uint32_t a_b); + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_webp__decoder__mode12( + const wuffs_webp__decoder* self, + uint8_t a_l, + uint8_t a_t, + uint8_t a_tl); + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_webp__decoder__mode13( + const wuffs_webp__decoder* self, + uint8_t a_l, + uint8_t a_t, + uint8_t a_tl); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_cross_color( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix, + wuffs_base__slice_u8 a_tile_data); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_subtract_green( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_color_indexing( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_webp__decoder__do_decode_image_config( @@ -69176,6 +69487,18 @@ wuffs_webp__decoder__do_decode_image_config( wuffs_base__image_config* a_dst, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config_limited( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config_limited_vp8l( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_webp__decoder__do_decode_frame_config( @@ -69193,6 +69516,46 @@ wuffs_webp__decoder__do_decode_frame( wuffs_base__slice_u8 a_workbuf, wuffs_base__decode_frame_options* a_opts); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_transform( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_color_cache_parameters( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_hg_table( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + wuffs_base__slice_u8 a_workbuf); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_pixels( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_dst, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + uint32_t a_height, + wuffs_base__slice_u8 a_tile_data, + uint32_t a_tile_size_log2); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__swizzle( + wuffs_webp__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__slice_u8 a_src, + wuffs_base__pixel_blend a_blend); + // ---------------- VTables const wuffs_base__image_decoder__func_ptrs @@ -69302,6 +69665,2089 @@ sizeof__wuffs_webp__decoder(void) { // ---------------- Function Implementations +// -------- func webp.decoder.decode_huffman_groups + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_huffman_groups( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_n_huffman_groups) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_hg = 0; + uint32_t v_ht = 0; + + uint32_t coro_susp_point = self->private_impl.p_decode_huffman_groups; + if (coro_susp_point) { + v_hg = self->private_data.s_decode_huffman_groups.v_hg; + v_ht = self->private_data.s_decode_huffman_groups.v_ht; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + v_hg = 0u; + while (v_hg < a_n_huffman_groups) { + v_ht = 0u; + while (v_ht < 5u) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_webp__decoder__decode_huffman_tree(self, a_src, v_hg, v_ht); + if (status.repr) { + goto suspend; + } + v_ht += 1u; + } + v_hg += 1u; + } + + goto ok; + ok: + self->private_impl.p_decode_huffman_groups = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_huffman_groups = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_huffman_groups.v_hg = v_hg; + self->private_data.s_decode_huffman_groups.v_ht = v_ht; + + goto exit; + exit: + return status; +} + +// -------- func webp.decoder.decode_huffman_tree + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_huffman_tree( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_hg, + uint32_t a_ht) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_use_simple = 0; + wuffs_base__status v_status = wuffs_base__make_status(NULL); + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (a_ht >= 4u) { + self->private_impl.f_ht_n_symbols = 40u; + } else if (a_ht > 0u) { + self->private_impl.f_ht_n_symbols = 256u; + } else if (self->private_impl.f_color_cache_bits == 0u) { + self->private_impl.f_ht_n_symbols = 280u; + } else { + self->private_impl.f_ht_n_symbols = (280u + (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits)); + } + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_use_simple = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + if (v_use_simple != 0u) { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + status = wuffs_webp__decoder__decode_huffman_tree_simple(self, a_src, a_hg, a_ht); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + } else { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_webp__decoder__decode_code_length_code_lengths(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + v_status = wuffs_webp__decoder__build_code_lengths_huffman_nodes(self); + if ( ! wuffs_base__status__is_ok(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_webp__decoder__build_code_lengths(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + v_status = wuffs_webp__decoder__build_huffman_nodes(self, a_hg, a_ht); + if ( ! wuffs_base__status__is_ok(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } + } + + ok: + self->private_impl.p_decode_huffman_tree = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_huffman_tree = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_huffman_tree_simple + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_huffman_tree_simple( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_hg, + uint32_t a_ht) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_use_second_symbol = 0; + uint32_t v_first_symbol_n_bits = 0; + uint32_t v_symbol0 = 0; + uint32_t v_symbol1 = 0; + uint32_t v_base_offset = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree_simple; + if (coro_susp_point) { + v_use_second_symbol = self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol; + v_first_symbol_n_bits = self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits; + v_symbol0 = self->private_data.s_decode_huffman_tree_simple.v_symbol0; + v_base_offset = self->private_data.s_decode_huffman_tree_simple.v_base_offset; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 2u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + if (self->private_impl.f_n_bits >= 2u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_use_second_symbol = (self->private_impl.f_bits & 1u); + v_first_symbol_n_bits = ((((self->private_impl.f_bits & 2u) >> 1u) * 7u) + 1u); + self->private_impl.f_bits >>= 2u; + self->private_impl.f_n_bits -= 2u; + if (self->private_impl.f_n_bits < v_first_symbol_n_bits) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= v_first_symbol_n_bits) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_symbol0 = (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_first_symbol_n_bits) - 1u)); + self->private_impl.f_bits >>= v_first_symbol_n_bits; + self->private_impl.f_n_bits -= v_first_symbol_n_bits; + v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht])); + if (v_use_second_symbol != 0u) { + if (self->private_impl.f_n_bits < 8u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_2 = *iop_a_src++; + v_c8 = t_2; + } + if (self->private_impl.f_n_bits >= 8u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_symbol1 = (self->private_impl.f_bits & 255u); + self->private_impl.f_bits >>= 8u; + self->private_impl.f_n_bits -= 8u; + self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 0u)] = ((uint16_t)((v_base_offset + 1u))); + self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 1u)] = ((uint16_t)((v_symbol0 | 32768u))); + self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 2u)] = ((uint16_t)((v_symbol1 | 32768u))); + } else { + self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_symbol0 | 32768u))); + } + + goto ok; + ok: + self->private_impl.p_decode_huffman_tree_simple = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_huffman_tree_simple = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol = v_use_second_symbol; + self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits = v_first_symbol_n_bits; + self->private_data.s_decode_huffman_tree_simple.v_symbol0 = v_symbol0; + self->private_data.s_decode_huffman_tree_simple.v_base_offset = v_base_offset; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_code_length_code_lengths + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_code_length_code_lengths( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_n_codes = 0; + uint32_t v_i = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_code_length_code_lengths; + if (coro_susp_point) { + v_n_codes = self->private_data.s_decode_code_length_code_lengths.v_n_codes; + v_i = self->private_data.s_decode_code_length_code_lengths.v_i; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 4u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + if (self->private_impl.f_n_bits >= 4u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_n_codes = ((self->private_impl.f_bits & 15u) + 4u); + self->private_impl.f_bits >>= 4u; + self->private_impl.f_n_bits -= 4u; + v_i = 0u; + while (v_i < v_n_codes) { + if (self->private_impl.f_n_bits < 3u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 3u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = ((uint8_t)((self->private_impl.f_bits & 7u))); + self->private_impl.f_bits >>= 3u; + self->private_impl.f_n_bits -= 3u; + v_i += 1u; + } + while (v_i < 19u) { + self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = 0u; + v_i += 1u; + } + + goto ok; + ok: + self->private_impl.p_decode_code_length_code_lengths = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_code_length_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_code_length_code_lengths.v_n_codes = v_n_codes; + self->private_data.s_decode_code_length_code_lengths.v_i = v_i; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.build_code_lengths_huffman_nodes + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__build_code_lengths_huffman_nodes( + wuffs_webp__decoder* self) { + uint32_t v_code_bits = 0; + uint32_t v_code_len = 0; + uint32_t v_symbol = 0; + uint32_t v_histogram[8] = {0}; + uint32_t v_n_used_symbols = 0; + uint32_t v_last_used_symbol = 0; + uint32_t v_subscription_weight = 0; + uint32_t v_subscription_total = 0; + uint32_t v_curr_code = 0; + uint32_t v_next_codes[9] = {0}; + uint32_t v_n_branches = 0; + uint32_t v_h = 0; + uint32_t v_children = 0; + uint16_t v_node = 0; + + v_symbol = 0u; + while (v_symbol < 19u) { + v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol])); + if (v_code_len != 0u) { + v_histogram[v_code_len] += 1u; + v_n_used_symbols += 1u; + v_last_used_symbol = v_symbol; + } + v_symbol += 1u; + } + if (v_n_used_symbols < 1u) { + return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code); + } else if (v_n_used_symbols == 1u) { + self->private_data.f_code_lengths_huffman_nodes[0u] = ((uint16_t)((v_last_used_symbol | 32768u))); + return wuffs_base__make_status(NULL); + } + v_subscription_weight = 16384u; + v_code_len = 1u; + while (true) { + v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u)); + v_next_codes[(v_code_len + 1u)] = v_curr_code; + v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len])); + v_subscription_weight >>= 1u; + if (v_code_len >= 7u) { + break; + } + v_code_len += 1u; + } + if (v_subscription_total > 32768u) { + return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed); + } else if (v_subscription_total < 32768u) { + return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed); + } + self->private_data.f_code_lengths_huffman_nodes[0u] = 0u; + v_symbol = 0u; + while (v_symbol < 19u) { + v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol])); + if (v_code_len > 0u) { + v_code_bits = v_next_codes[v_code_len]; + v_next_codes[v_code_len] += 1u; + v_code_bits <<= (32u - v_code_len); + v_h = 0u; + while (v_code_len > 0u) { + v_node = self->private_data.f_code_lengths_huffman_nodes[v_h]; + if (v_node == 0u) { + v_children = ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches)))); + v_children = wuffs_base__u32__min(v_children, 35u); + self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)(v_children)); + self->private_data.f_code_lengths_huffman_nodes[(v_children + 0u)] = 0u; + self->private_data.f_code_lengths_huffman_nodes[(v_children + 1u)] = 0u; + v_h = (v_children + (v_code_bits >> 31u)); + v_n_branches += 1u; + } else { + v_children = ((uint32_t)(v_node)); + v_h = (wuffs_base__u32__min(v_children, 35u) + (v_code_bits >> 31u)); + } + v_code_bits <<= 1u; + v_code_len -= 1u; + } + self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)((v_symbol | 32768u))); + } + v_symbol += 1u; + } + return wuffs_base__make_status(NULL); +} + +// -------- func webp.decoder.build_huffman_nodes + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__build_huffman_nodes( + wuffs_webp__decoder* self, + uint32_t a_hg, + uint32_t a_ht) { + uint32_t v_base_offset = 0; + uint32_t v_code_bits = 0; + uint32_t v_code_len = 0; + uint32_t v_symbol = 0; + uint32_t v_histogram[16] = {0}; + uint32_t v_n_used_symbols = 0; + uint32_t v_last_used_symbol = 0; + uint32_t v_subscription_weight = 0; + uint32_t v_subscription_total = 0; + uint32_t v_curr_code = 0; + uint32_t v_next_codes[17] = {0}; + uint32_t v_n_branches = 0; + uint32_t v_h = 0; + uint32_t v_children = 0; + uint16_t v_node = 0; + + v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht])); + v_symbol = 0u; + while (v_symbol < self->private_impl.f_ht_n_symbols) { + v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u)))); + if (v_code_len != 0u) { + v_histogram[v_code_len] += 1u; + v_n_used_symbols += 1u; + v_last_used_symbol = v_symbol; + } + v_symbol += 1u; + } + if (v_n_used_symbols < 1u) { + return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code); + } else if (v_n_used_symbols == 1u) { + self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_last_used_symbol | 32768u))); + return wuffs_base__make_status(NULL); + } + v_subscription_weight = 16384u; + v_code_len = 1u; + while (true) { + v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u)); + v_next_codes[(v_code_len + 1u)] = v_curr_code; + v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len])); + v_subscription_weight >>= 1u; + if (v_code_len >= 15u) { + break; + } + v_code_len += 1u; + } + if (v_subscription_total > 32768u) { + return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed); + } else if (v_subscription_total < 32768u) { + return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed); + } + self->private_data.f_huffman_nodes[a_hg][v_base_offset] = 0u; + v_symbol = 0u; + while (v_symbol < self->private_impl.f_ht_n_symbols) { + v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u)))); + if (v_code_len != 0u) { + v_code_bits = v_next_codes[v_code_len]; + v_next_codes[v_code_len] += 1u; + v_code_bits <<= (32u - v_code_len); + v_h = v_base_offset; + while (v_code_len > 0u) { + v_node = self->private_data.f_huffman_nodes[a_hg][v_h]; + if (v_node == 0u) { + v_children = ((uint32_t)(v_base_offset + ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches)))))); + v_children = wuffs_base__u32__min(v_children, 6265u); + self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)(v_children)); + self->private_data.f_huffman_nodes[a_hg][(v_children + 0u)] = 0u; + self->private_data.f_huffman_nodes[a_hg][(v_children + 1u)] = 0u; + v_h = (v_children + (v_code_bits >> 31u)); + v_n_branches += 1u; + } else { + v_children = ((uint32_t)(v_node)); + v_h = (wuffs_base__u32__min(v_children, 6265u) + (v_code_bits >> 31u)); + } + v_code_bits <<= 1u; + v_code_len -= 1u; + } + self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)((v_symbol | 32768u))); + } + v_symbol += 1u; + } + return wuffs_base__make_status(NULL); +} + +// -------- func webp.decoder.build_code_lengths + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__build_code_lengths( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_use_length = 0; + uint32_t v_length_n_bits = 0; + uint32_t v_length = 0; + uint16_t v_prev_code_length = 0; + uint32_t v_h = 0; + uint32_t v_s = 0; + uint32_t v_s_max = 0; + uint16_t v_node = 0; + uint32_t v_symbol = 0; + uint16_t v_repeat_value = 0; + uint32_t v_repeat_n_bits = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_build_code_lengths; + if (coro_susp_point) { + v_length_n_bits = self->private_data.s_build_code_lengths.v_length_n_bits; + v_prev_code_length = self->private_data.s_build_code_lengths.v_prev_code_length; + v_s = self->private_data.s_build_code_lengths.v_s; + v_s_max = self->private_data.s_build_code_lengths.v_s_max; + v_node = self->private_data.s_build_code_lengths.v_node; + v_repeat_value = self->private_data.s_build_code_lengths.v_repeat_value; + v_repeat_n_bits = self->private_data.s_build_code_lengths.v_repeat_n_bits; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_use_length = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + self->private_impl.f_ht_code_lengths_remaining = self->private_impl.f_ht_n_symbols; + if (v_use_length != 0u) { + if (self->private_impl.f_n_bits < 3u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 3u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_length_n_bits = (((self->private_impl.f_bits & 7u) * 2u) + 2u); + self->private_impl.f_bits >>= 3u; + self->private_impl.f_n_bits -= 3u; + while (self->private_impl.f_n_bits < v_length_n_bits) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_2 = *iop_a_src++; + v_c8 = t_2; + } + if (self->private_impl.f_n_bits >= v_length_n_bits) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_length = ((self->private_impl.f_bits & ((((uint32_t)(1u)) << v_length_n_bits) - 1u)) + 2u); + self->private_impl.f_bits >>= v_length_n_bits; + self->private_impl.f_n_bits -= v_length_n_bits; + if (v_length > self->private_impl.f_ht_n_symbols) { + status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code); + goto exit; + } + self->private_impl.f_ht_code_lengths_remaining = v_length; + } + v_prev_code_length = 8u; + while (v_s < self->private_impl.f_ht_n_symbols) { + if (self->private_impl.f_ht_code_lengths_remaining <= 0u) { + while (v_s < self->private_impl.f_ht_n_symbols) { + self->private_data.f_code_lengths[v_s] = 0u; + v_s += 1u; + } + break; + } + self->private_impl.f_ht_code_lengths_remaining -= 1u; + v_h = 0u; + while (true) { + v_node = self->private_data.f_code_lengths_huffman_nodes[v_h]; + if (v_node >= 32768u) { + break; + } else if (v_node > 35u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code); + goto exit; + } + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_3 = *iop_a_src++; + v_c8 = t_3; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u)); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + } + v_symbol = ((uint32_t)(((uint16_t)(v_node & 32767u)))); + if (v_symbol == 0u) { + self->private_data.f_code_lengths[v_s] = 0u; + v_s += 1u; + continue; + } else if (v_symbol < 16u) { + v_prev_code_length = ((uint16_t)(v_symbol)); + self->private_data.f_code_lengths[v_s] = v_prev_code_length; + v_s += 1u; + continue; + } else if (v_symbol == 16u) { + v_repeat_value = v_prev_code_length; + } else { + v_repeat_value = 0u; + } + v_repeat_n_bits = ((uint32_t)(WUFFS_WEBP__REPEAT_N_BITS[(v_symbol & 3u)])); + v_s_max = ((uint32_t)(((uint32_t)(WUFFS_WEBP__REPEAT_COUNTS[(v_symbol & 3u)])) + v_s)); + if (self->private_impl.f_n_bits < v_repeat_n_bits) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_4 = *iop_a_src++; + v_c8 = t_4; + } + if (self->private_impl.f_n_bits >= v_repeat_n_bits) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_s_max += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_repeat_n_bits) - 1u)); + self->private_impl.f_bits >>= v_repeat_n_bits; + self->private_impl.f_n_bits -= v_repeat_n_bits; + if (v_s_max > self->private_impl.f_ht_n_symbols) { + status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code); + goto exit; + } + while (v_s < v_s_max) { + self->private_data.f_code_lengths[v_s] = v_repeat_value; + v_s += 1u; + } + } + + goto ok; + ok: + self->private_impl.p_build_code_lengths = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_build_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_build_code_lengths.v_length_n_bits = v_length_n_bits; + self->private_data.s_build_code_lengths.v_prev_code_length = v_prev_code_length; + self->private_data.s_build_code_lengths.v_s = v_s; + self->private_data.s_build_code_lengths.v_s_max = v_s_max; + self->private_data.s_build_code_lengths.v_node = v_node; + self->private_data.s_build_code_lengths.v_repeat_value = v_repeat_value; + self->private_data.s_build_code_lengths.v_repeat_n_bits = v_repeat_n_bits; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_pixels_slow + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_pixels_slow( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_dst, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + uint32_t a_height, + wuffs_base__slice_u8 a_tile_data, + uint32_t a_tile_size_log2) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint64_t v_p = 0; + uint64_t v_p_max = 0; + uint32_t v_tile_size_log2 = 0; + uint32_t v_width_in_tiles = 0; + uint32_t v_x = 0; + uint32_t v_y = 0; + uint32_t v_i = 0; + uint32_t v_hg = 0; + uint32_t v_h = 0; + uint16_t v_node = 0; + uint32_t v_pixel_g = 0; + uint32_t v_color = 0; + wuffs_base__slice_u8 v_dst_pixel = {0}; + uint32_t v_back_ref_len_n_bits = 0; + uint32_t v_back_ref_len_minus_1 = 0; + uint32_t v_back_ref_dist_n_bits = 0; + uint32_t v_back_ref_dist_sym = 0; + uint32_t v_back_ref_dist_premap_minus_1 = 0; + uint32_t v_back_ref_dist_minus_1 = 0; + uint32_t v_dm = 0; + uint32_t v_dx = 0; + uint32_t v_dy = 0; + uint64_t v_p_end = 0; + uint64_t v_dist4 = 0; + uint64_t v_q = 0; + wuffs_base__slice_u8 v_color_cache_pixels = {0}; + uint64_t v_color_cache_p = 0; + uint32_t v_color_cache_shift = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_pixels_slow; + if (coro_susp_point) { + v_p = self->private_data.s_decode_pixels_slow.v_p; + v_p_max = self->private_data.s_decode_pixels_slow.v_p_max; + v_tile_size_log2 = self->private_data.s_decode_pixels_slow.v_tile_size_log2; + v_width_in_tiles = self->private_data.s_decode_pixels_slow.v_width_in_tiles; + v_x = self->private_data.s_decode_pixels_slow.v_x; + v_y = self->private_data.s_decode_pixels_slow.v_y; + v_hg = self->private_data.s_decode_pixels_slow.v_hg; + v_node = self->private_data.s_decode_pixels_slow.v_node; + v_color = self->private_data.s_decode_pixels_slow.v_color; + v_back_ref_len_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits; + v_back_ref_len_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1; + v_back_ref_dist_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits; + v_back_ref_dist_premap_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1; + v_color_cache_p = self->private_data.s_decode_pixels_slow.v_color_cache_p; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + v_p_max = ((uint64_t)((4u * a_width * a_height))); + if (((uint64_t)(a_dst.len)) < v_p_max) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer); + goto exit; + } + if (a_tile_size_log2 != 0u) { + v_tile_size_log2 = a_tile_size_log2; + v_width_in_tiles = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2); + } else { + v_tile_size_log2 = 31u; + v_width_in_tiles = 1u; + } + while (v_p < v_p_max) { + v_i = ((uint32_t)(((uint32_t)(((uint32_t)(((uint32_t)((v_y >> v_tile_size_log2) * v_width_in_tiles)) + (v_x >> v_tile_size_log2))) * 4u)) + 1u)); + if (((uint64_t)(v_i)) < ((uint64_t)(a_tile_data.len))) { + v_hg = ((uint32_t)(a_tile_data.ptr[((uint64_t)(v_i))])); + } + v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[0u])); + while (true) { + v_node = self->private_data.f_huffman_nodes[v_hg][v_h]; + if (v_node >= 32768u) { + break; + } else if (v_node > 6265u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code); + goto exit; + } + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u)); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + } + v_pixel_g = ((uint32_t)(((uint16_t)(v_node & 32767u)))); + if (v_pixel_g < 256u) { + v_color = (v_pixel_g << 8u); + v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[1u])); + while (true) { + v_node = self->private_data.f_huffman_nodes[v_hg][v_h]; + if (v_node >= 32768u) { + break; + } + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u)); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + } + v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 16u); + v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[2u])); + while (true) { + v_node = self->private_data.f_huffman_nodes[v_hg][v_h]; + if (v_node >= 32768u) { + break; + } + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_2 = *iop_a_src++; + v_c8 = t_2; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u)); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + } + v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 0u); + v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[3u])); + while (true) { + v_node = self->private_data.f_huffman_nodes[v_hg][v_h]; + if (v_node >= 32768u) { + break; + } + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_3 = *iop_a_src++; + v_c8 = t_3; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u)); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + } + v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 24u); + } else if (v_pixel_g < 280u) { + if (v_pixel_g < 260u) { + v_back_ref_len_minus_1 = (v_pixel_g - 256u); + } else { + v_back_ref_len_n_bits = ((v_pixel_g - 258u) >> 1u); + v_back_ref_len_minus_1 = ((((uint32_t)(2u)) + (v_pixel_g & 1u)) << v_back_ref_len_n_bits); + while (self->private_impl.f_n_bits < v_back_ref_len_n_bits) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_4 = *iop_a_src++; + v_c8 = t_4; + } + if (self->private_impl.f_n_bits >= v_back_ref_len_n_bits) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_back_ref_len_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_len_n_bits) - 1u)); + self->private_impl.f_bits >>= v_back_ref_len_n_bits; + self->private_impl.f_n_bits -= v_back_ref_len_n_bits; + } + v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[4u])); + while (true) { + v_node = self->private_data.f_huffman_nodes[v_hg][v_h]; + if (v_node >= 32768u) { + break; + } + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_5 = *iop_a_src++; + v_c8 = t_5; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u)); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + } + v_back_ref_dist_sym = ((uint32_t)(((uint16_t)(v_node & 32767u)))); + if (v_back_ref_dist_sym < 4u) { + v_back_ref_dist_premap_minus_1 = v_back_ref_dist_sym; + } else if (v_back_ref_dist_sym < 40u) { + v_back_ref_dist_n_bits = ((v_back_ref_dist_sym - 2u) >> 1u); + v_back_ref_dist_premap_minus_1 = ((((uint32_t)(2u)) + (v_back_ref_dist_sym & 1u)) << v_back_ref_dist_n_bits); + while (self->private_impl.f_n_bits < v_back_ref_dist_n_bits) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_6 = *iop_a_src++; + v_c8 = t_6; + } + if (self->private_impl.f_n_bits >= v_back_ref_dist_n_bits) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_back_ref_dist_premap_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_dist_n_bits) - 1u)); + self->private_impl.f_bits >>= v_back_ref_dist_n_bits; + self->private_impl.f_n_bits -= v_back_ref_dist_n_bits; + } + if (v_back_ref_dist_premap_minus_1 >= 120u) { + v_back_ref_dist_minus_1 = (v_back_ref_dist_premap_minus_1 - 120u); + } else { + v_dm = ((uint32_t)(WUFFS_WEBP__DISTANCE_MAP[v_back_ref_dist_premap_minus_1])); + v_dy = (v_dm >> 4u); + v_dx = ((uint32_t)(7u - (v_dm & 15u))); + v_back_ref_dist_minus_1 = ((uint32_t)((a_width * v_dy) + v_dx)); + } + v_p_end = (v_p + ((uint64_t)(((v_back_ref_len_minus_1 + 1u) * 4u)))); + v_dist4 = ((((uint64_t)(v_back_ref_dist_minus_1)) * 4u) + 4u); + if ((v_p_end > v_p_max) || (v_p_end > ((uint64_t)(a_dst.len))) || (v_p < v_dist4)) { + status = wuffs_base__make_status(wuffs_webp__error__bad_back_reference); + goto exit; + } + v_q = (v_p - v_dist4); + while ((v_q < v_p) && (v_p < v_p_end)) { + a_dst.ptr[v_p] = a_dst.ptr[v_q]; + v_p += 1u; + v_q += 1u; + } + v_x += (v_back_ref_len_minus_1 + 1u); + while (v_x >= a_width) { + v_x -= a_width; + v_y += 1u; + } + continue; + } else { + if ((v_color_cache_p > v_p) || (v_p > ((uint64_t)(a_dst.len)))) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer); + goto exit; + } + v_color_cache_pixels = wuffs_base__slice_u8__subslice_ij(a_dst, v_color_cache_p, v_p); + v_color_cache_p = v_p; + v_color_cache_shift = ((32u - self->private_impl.f_color_cache_bits) & 31u); + while (((uint64_t)(v_color_cache_pixels.len)) >= 4u) { + v_color = wuffs_base__peek_u32le__no_bounds_check(v_color_cache_pixels.ptr); + self->private_data.f_color_cache[((((uint32_t)(v_color * 506832829u)) >> v_color_cache_shift) & 2047u)] = v_color; + v_color_cache_pixels = wuffs_base__slice_u8__subslice_i(v_color_cache_pixels, 4u); + } + v_color = self->private_data.f_color_cache[((v_pixel_g - 280u) & 2047u)]; + } + if (v_p > ((uint64_t)(a_dst.len))) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer); + goto exit; + } + v_dst_pixel = wuffs_base__slice_u8__subslice_i(a_dst, v_p); + if (((uint64_t)(v_dst_pixel.len)) < 4u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer); + goto exit; + } + wuffs_base__poke_u32le__no_bounds_check(v_dst_pixel.ptr, v_color); + v_p += 4u; + v_x += 1u; + if (v_x == a_width) { + v_x = 0u; + v_y += 1u; + } + } + + goto ok; + ok: + self->private_impl.p_decode_pixels_slow = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_pixels_slow = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_pixels_slow.v_p = v_p; + self->private_data.s_decode_pixels_slow.v_p_max = v_p_max; + self->private_data.s_decode_pixels_slow.v_tile_size_log2 = v_tile_size_log2; + self->private_data.s_decode_pixels_slow.v_width_in_tiles = v_width_in_tiles; + self->private_data.s_decode_pixels_slow.v_x = v_x; + self->private_data.s_decode_pixels_slow.v_y = v_y; + self->private_data.s_decode_pixels_slow.v_hg = v_hg; + self->private_data.s_decode_pixels_slow.v_node = v_node; + self->private_data.s_decode_pixels_slow.v_color = v_color; + self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits = v_back_ref_len_n_bits; + self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1 = v_back_ref_len_minus_1; + self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits = v_back_ref_dist_n_bits; + self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1 = v_back_ref_dist_premap_minus_1; + self->private_data.s_decode_pixels_slow.v_color_cache_p = v_color_cache_p; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.apply_transform_predictor + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_predictor( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix, + wuffs_base__slice_u8 a_tile_data) { + uint64_t v_w4 = 0; + wuffs_base__slice_u8 v_prev_row = {0}; + wuffs_base__slice_u8 v_curr_row = {0}; + uint32_t v_tile_size_log2 = 0; + uint32_t v_tiles_per_row = 0; + uint32_t v_mask = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint64_t v_t = 0; + wuffs_base__slice_u8 v_tile_data = {0}; + uint8_t v_mode = 0; + uint32_t v_l0 = 0; + uint32_t v_l1 = 0; + uint32_t v_l2 = 0; + uint32_t v_l3 = 0; + uint32_t v_c0 = 0; + uint32_t v_c1 = 0; + uint32_t v_c2 = 0; + uint32_t v_c3 = 0; + uint32_t v_t0 = 0; + uint32_t v_t1 = 0; + uint32_t v_t2 = 0; + uint32_t v_t3 = 0; + uint32_t v_sum_l = 0; + uint32_t v_sum_t = 0; + + if ((self->private_impl.f_width <= 0u) || (self->private_impl.f_height <= 0u)) { + return wuffs_base__make_empty_struct(); + } + v_w4 = ((uint64_t)((self->private_impl.f_width * 4u))); + v_curr_row = wuffs_base__utility__empty_slice_u8(); + if (v_w4 <= ((uint64_t)(a_pix.len))) { + v_curr_row = wuffs_base__slice_u8__subslice_j(a_pix, v_w4); + } + if (((uint64_t)(v_curr_row.len)) >= 4u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[3u] += 255u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } + while (((uint64_t)(v_curr_row.len)) >= 8u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += v_curr_row.ptr[0u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += v_curr_row.ptr[1u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += v_curr_row.ptr[2u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += v_curr_row.ptr[3u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u); + } + v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[0u])); + v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2); + v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u); + v_y = 1u; + while (v_y < self->private_impl.f_height) { + v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row))); + v_tile_data = wuffs_base__utility__empty_slice_u8(); + if (v_t <= ((uint64_t)(a_tile_data.len))) { + v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t); + if (((uint64_t)(v_tile_data.len)) >= 4u) { + v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u)); + v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u); + } + } + if (v_w4 <= ((uint64_t)(a_pix.len))) { + v_prev_row = a_pix; + a_pix = wuffs_base__slice_u8__subslice_i(a_pix, v_w4); + v_curr_row = a_pix; + } + if ((((uint64_t)(v_prev_row.len)) >= 4u) && (((uint64_t)(v_curr_row.len)) >= 4u)) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[0u] += v_prev_row.ptr[0u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[1u] += v_prev_row.ptr[1u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[2u] += v_prev_row.ptr[2u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[3u] += v_prev_row.ptr[3u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } + v_x = 1u; + while (v_x < self->private_impl.f_width) { + if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) { + v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u)); + v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u); + } + if ((((uint64_t)(v_prev_row.len)) < 12u) || (((uint64_t)(v_curr_row.len)) < 8u)) { + break; + } + if (v_mode == 0u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += 255u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 1u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += v_curr_row.ptr[0u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += v_curr_row.ptr[1u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += v_curr_row.ptr[2u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += v_curr_row.ptr[3u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 2u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += v_prev_row.ptr[4u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += v_prev_row.ptr[5u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += v_prev_row.ptr[6u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += v_prev_row.ptr[7u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 3u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += v_prev_row.ptr[8u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += v_prev_row.ptr[9u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += v_prev_row.ptr[10u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += v_prev_row.ptr[11u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 4u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += v_prev_row.ptr[0u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += v_prev_row.ptr[1u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += v_prev_row.ptr[2u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += v_prev_row.ptr[3u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 5u) { + v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u); + v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u); + v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u); + v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u); +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 6u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 7u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 8u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 9u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 10u) { + v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u); + v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u); + v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u); + v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u); + v_t0 = ((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u); + v_t1 = ((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u); + v_t2 = ((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u); + v_t3 = ((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u); +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + v_t0) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + v_t1) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + v_t2) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + v_t3) / 2u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 11u) { + v_l0 = ((uint32_t)(v_curr_row.ptr[0u])); + v_l1 = ((uint32_t)(v_curr_row.ptr[1u])); + v_l2 = ((uint32_t)(v_curr_row.ptr[2u])); + v_l3 = ((uint32_t)(v_curr_row.ptr[3u])); + v_c0 = ((uint32_t)(v_prev_row.ptr[0u])); + v_c1 = ((uint32_t)(v_prev_row.ptr[1u])); + v_c2 = ((uint32_t)(v_prev_row.ptr[2u])); + v_c3 = ((uint32_t)(v_prev_row.ptr[3u])); + v_t0 = ((uint32_t)(v_prev_row.ptr[4u])); + v_t1 = ((uint32_t)(v_prev_row.ptr[5u])); + v_t2 = ((uint32_t)(v_prev_row.ptr[6u])); + v_t3 = ((uint32_t)(v_prev_row.ptr[7u])); + v_sum_l = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_t0) + + wuffs_webp__decoder__absolute_difference(self, v_c1, v_t1) + + wuffs_webp__decoder__absolute_difference(self, v_c2, v_t2) + + wuffs_webp__decoder__absolute_difference(self, v_c3, v_t3)); + v_sum_t = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_l0) + + wuffs_webp__decoder__absolute_difference(self, v_c1, v_l1) + + wuffs_webp__decoder__absolute_difference(self, v_c2, v_l2) + + wuffs_webp__decoder__absolute_difference(self, v_c3, v_l3)); + if (v_sum_l < v_sum_t) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(v_l0)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(v_l1)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(v_l2)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(v_l3)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += ((uint8_t)(v_t0)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += ((uint8_t)(v_t1)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += ((uint8_t)(v_t2)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += ((uint8_t)(v_t3)); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } + } else if (v_mode == 12u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else if (v_mode == 13u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[4u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[5u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[6u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_curr_row.ptr[7u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } + v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u); + v_prev_row = wuffs_base__slice_u8__subslice_i(v_prev_row, 4u); + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func webp.decoder.absolute_difference + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_webp__decoder__absolute_difference( + const wuffs_webp__decoder* self, + uint32_t a_a, + uint32_t a_b) { + if (a_a < a_b) { + return (a_b - a_a); + } + return (a_a - a_b); +} + +// -------- func webp.decoder.mode12 + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_webp__decoder__mode12( + const wuffs_webp__decoder* self, + uint8_t a_l, + uint8_t a_t, + uint8_t a_tl) { + uint32_t v_v = 0; + + v_v = ((uint32_t)((((uint32_t)(a_l)) + ((uint32_t)(a_t))) - ((uint32_t)(a_tl)))); + if (v_v < 256u) { + return ((uint8_t)(v_v)); + } else if (v_v < 512u) { + return 255u; + } + return 0u; +} + +// -------- func webp.decoder.mode13 + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_webp__decoder__mode13( + const wuffs_webp__decoder* self, + uint8_t a_l, + uint8_t a_t, + uint8_t a_tl) { + uint32_t v_x = 0; + uint32_t v_y = 0; + uint32_t v_z = 0; + uint32_t v_v = 0; + + v_x = ((((uint32_t)(a_l)) + ((uint32_t)(a_t))) / 2u); + v_y = ((uint32_t)(a_tl)); + v_z = ((uint32_t)(v_x - v_y)); + v_v = ((uint32_t)(v_x + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_z + (v_z >> 31u))), 1u))); + if (v_v < 256u) { + return ((uint8_t)(v_v)); + } else if (v_v < 512u) { + return 255u; + } + return 0u; +} + +// -------- func webp.decoder.apply_transform_cross_color + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_cross_color( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix, + wuffs_base__slice_u8 a_tile_data) { + uint32_t v_tile_size_log2 = 0; + uint32_t v_tiles_per_row = 0; + uint32_t v_mask = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint64_t v_t = 0; + wuffs_base__slice_u8 v_tile_data = {0}; + uint32_t v_g2r = 0; + uint32_t v_g2b = 0; + uint32_t v_r2b = 0; + uint8_t v_b = 0; + uint8_t v_g = 0; + uint8_t v_r = 0; + + v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[1u])); + v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2); + v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u); + v_y = 0u; + while (v_y < self->private_impl.f_height) { + v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row))); + v_tile_data = wuffs_base__utility__empty_slice_u8(); + if (v_t <= ((uint64_t)(a_tile_data.len))) { + v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t); + } + v_x = 0u; + while (v_x < self->private_impl.f_width) { + if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) { + v_g2r = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[0u]]; + v_g2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[1u]]; + v_r2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[2u]]; + v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u); + } + if (((uint64_t)(a_pix.len)) >= 4u) { + v_b = a_pix.ptr[0u]; + v_g = a_pix.ptr[1u]; + v_r = a_pix.ptr[2u]; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_r += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2r)) >> 5u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2b)) >> 5u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_r] * v_r2b)) >> 5u))); +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + a_pix.ptr[0u] = v_b; + a_pix.ptr[2u] = v_r; + a_pix = wuffs_base__slice_u8__subslice_i(a_pix, 4u); + } + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func webp.decoder.apply_transform_subtract_green + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_subtract_green( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix) { + wuffs_base__slice_u8 v_p = {0}; + uint8_t v_g = 0; + + { + wuffs_base__slice_u8 i_slice_p = a_pix; + v_p.ptr = i_slice_p.ptr; + v_p.len = 4; + const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 4) * 4)); + while (v_p.ptr < i_end0_p) { + v_g = v_p.ptr[1u]; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_p.ptr[0u] += v_g; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_p.ptr[2u] += v_g; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + v_p.ptr += 4; + } + v_p.len = 0; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func webp.decoder.apply_transform_color_indexing + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_webp__decoder__apply_transform_color_indexing( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_pix) { + uint32_t v_tile_size_log2 = 0; + uint32_t v_bits_per_pixel = 0; + uint32_t v_x_mask = 0; + uint32_t v_s_mask = 0; + uint64_t v_src_index = 0; + uint32_t v_y = 0; + uint64_t v_di = 0; + uint64_t v_dj = 0; + wuffs_base__slice_u8 v_dst = {0}; + uint32_t v_x = 0; + uint32_t v_s = 0; + uint32_t v_p = 0; + uint8_t v_p0 = 0; + uint8_t v_p1 = 0; + uint8_t v_p2 = 0; + uint8_t v_p3 = 0; + + v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u])); + if (v_tile_size_log2 == 0u) { + } + v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2); + v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u); + v_s_mask = ((((uint32_t)(1u)) << v_bits_per_pixel) - 1u); + v_src_index = ((uint64_t)((self->private_impl.f_workbuf_offset_for_color_indexing + 1u))); + v_y = 0u; + while (v_y < self->private_impl.f_height) { + v_di = ((uint64_t)((4u * (v_y + 0u) * self->private_impl.f_width))); + v_dj = ((uint64_t)((4u * (v_y + 1u) * self->private_impl.f_width))); + if ((v_di > v_dj) || (v_dj > ((uint64_t)(a_pix.len)))) { + break; + } + v_dst = wuffs_base__slice_u8__subslice_ij(a_pix, v_di, v_dj); + v_x = 0u; + while (((uint64_t)(v_dst.len)) >= 4u) { + if (((v_x & v_x_mask) == 0u) && (v_src_index < ((uint64_t)(a_pix.len)))) { + v_s = ((uint32_t)(a_pix.ptr[v_src_index])); + v_src_index += 4u; + } + v_p = ((v_s & v_s_mask) * 4u); + v_s >>= v_bits_per_pixel; + v_p0 = self->private_data.f_palette[(v_p + 0u)]; + v_p1 = self->private_data.f_palette[(v_p + 1u)]; + v_p2 = self->private_data.f_palette[(v_p + 2u)]; + v_p3 = self->private_data.f_palette[(v_p + 3u)]; + v_dst.ptr[0u] = v_p0; + v_dst.ptr[1u] = v_p1; + v_dst.ptr[2u] = v_p2; + v_dst.ptr[3u] = v_p3; + v_dst = wuffs_base__slice_u8__subslice_i(v_dst, 4u); + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + // -------- func webp.decoder.get_quirk WUFFS_BASE__GENERATED_C_CODE @@ -69417,29 +71863,478 @@ wuffs_webp__decoder__do_decode_image_config( wuffs_base__io_buffer* a_src) { wuffs_base__status status = wuffs_base__make_status(NULL); - if (self->private_impl.f_call_sequence != 0u) { - status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence); + uint32_t v_c32 = 0; + uint64_t v_r_mark = 0; + wuffs_base__status v_status = wuffs_base__make_status(NULL); + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_call_sequence != 0u) { + status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + uint32_t t_0; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { + t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src); + iop_a_src += 4; + } else { + self->private_data.s_do_decode_image_config.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + while (true) { + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch; + uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56)); + *scratch <<= 8; + *scratch >>= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0; + if (num_bits_0 == 24) { + t_0 = ((uint32_t)(*scratch)); + break; + } + num_bits_0 += 8u; + *scratch |= ((uint64_t)(num_bits_0)) << 56; + } + } + v_c32 = t_0; + } + if (v_c32 != 1179011410u) { + status = wuffs_base__make_status(wuffs_webp__error__bad_header); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + uint32_t t_1; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { + t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src); + iop_a_src += 4; + } else { + self->private_data.s_do_decode_image_config.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + while (true) { + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch; + uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56)); + *scratch <<= 8; + *scratch >>= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1; + if (num_bits_1 == 24) { + t_1 = ((uint32_t)(*scratch)); + break; + } + num_bits_1 += 8u; + *scratch |= ((uint64_t)(num_bits_1)) << 56; + } + } + self->private_impl.f_riff_chunk_length = t_1; + } + if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) { + status = wuffs_base__make_status(wuffs_webp__error__bad_header); + goto exit; + } + while (true) { + { + const bool o_0_closed_a_src = a_src->meta.closed; + const uint8_t* o_0_io2_a_src = io2_a_src; + wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src, + ((uint64_t)(self->private_impl.f_riff_chunk_length))); + if (a_src) { + size_t n = ((size_t)(io2_a_src - a_src->data.ptr)); + a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n); + a_src->meta.wi = n; + } + v_r_mark = ((uint64_t)(iop_a_src - io0_a_src)); + { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_src); + v_status = t_2; + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + } + wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_riff_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src)))))); + io2_a_src = o_0_io2_a_src; + if (a_src) { + a_src->meta.closed = o_0_closed_a_src; + a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr)); + } + } + if (wuffs_base__status__is_ok(&v_status)) { + break; + } else if ( ! wuffs_base__status__is_suspension(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_riff_chunk_length == 0u)) { + status = wuffs_base__make_status(wuffs_webp__error__short_chunk); + goto exit; + } + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5); + } + self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))); + if (a_dst != NULL) { + wuffs_base__image_config__set( + a_dst, + self->private_impl.f_pixfmt, + 0u, + self->private_impl.f_width, + self->private_impl.f_height, + self->private_impl.f_frame_config_io_position, + false); + } + self->private_impl.f_call_sequence = 32u; + + ok: + self->private_impl.p_do_decode_image_config = 0; goto exit; } - self->private_impl.f_pixfmt = 2164295816u; - self->private_impl.f_width = 160u; - self->private_impl.f_height = 120u; - if (a_dst != NULL) { - wuffs_base__image_config__set( - a_dst, - self->private_impl.f_pixfmt, - 0u, - self->private_impl.f_width, - self->private_impl.f_height, - self->private_impl.f_frame_config_io_position, - false); - } - self->private_impl.f_call_sequence = 32u; - goto ok; - ok: + goto suspend; + suspend: + self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + goto exit; exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.do_decode_image_config_limited + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config_limited( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_c32 = 0; + uint64_t v_r_mark = 0; + wuffs_base__status v_status = wuffs_base__make_status(NULL); + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + uint32_t t_0; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { + t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src); + iop_a_src += 4; + } else { + self->private_data.s_do_decode_image_config_limited.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + while (true) { + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch; + uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56)); + *scratch <<= 8; + *scratch >>= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0; + if (num_bits_0 == 24) { + t_0 = ((uint32_t)(*scratch)); + break; + } + num_bits_0 += 8u; + *scratch |= ((uint64_t)(num_bits_0)) << 56; + } + } + v_c32 = t_0; + } + if (v_c32 != 1346520407u) { + status = wuffs_base__make_status(wuffs_webp__error__bad_header); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + uint32_t t_1; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { + t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src); + iop_a_src += 4; + } else { + self->private_data.s_do_decode_image_config_limited.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + while (true) { + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch; + uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56)); + *scratch <<= 8; + *scratch >>= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1; + if (num_bits_1 == 24) { + t_1 = ((uint32_t)(*scratch)); + break; + } + num_bits_1 += 8u; + *scratch |= ((uint64_t)(num_bits_1)) << 56; + } + } + v_c32 = t_1; + } + if (v_c32 == 540561494u) { + status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file); + goto exit; + } else if (v_c32 == 1278758998u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + uint32_t t_2; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { + t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src); + iop_a_src += 4; + } else { + self->private_data.s_do_decode_image_config_limited.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + while (true) { + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch; + uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56)); + *scratch <<= 8; + *scratch >>= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2; + if (num_bits_2 == 24) { + t_2 = ((uint32_t)(*scratch)); + break; + } + num_bits_2 += 8u; + *scratch |= ((uint64_t)(num_bits_2)) << 56; + } + } + self->private_impl.f_sub_chunk_length = t_2; + } + if (self->private_impl.f_sub_chunk_length < 4u) { + status = wuffs_base__make_status(wuffs_webp__error__bad_header); + goto exit; + } + self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u); + while (true) { + { + const bool o_0_closed_a_src = a_src->meta.closed; + const uint8_t* o_0_io2_a_src = io2_a_src; + wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src, + ((uint64_t)(self->private_impl.f_sub_chunk_length))); + if (a_src) { + size_t n = ((size_t)(io2_a_src - a_src->data.ptr)); + a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n); + a_src->meta.wi = n; + } + v_r_mark = ((uint64_t)(iop_a_src - io0_a_src)); + { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + wuffs_base__status t_3 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src); + v_status = t_3; + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + } + wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src)))))); + io2_a_src = o_0_io2_a_src; + if (a_src) { + a_src->meta.closed = o_0_closed_a_src; + a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr)); + } + } + if (wuffs_base__status__is_ok(&v_status)) { + break; + } else if ( ! wuffs_base__status__is_suspension(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) { + status = wuffs_base__make_status(wuffs_webp__error__short_chunk); + goto exit; + } + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7); + } + } else if (v_c32 == 1480085590u) { + status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file); + goto exit; + } else { + status = wuffs_base__make_status(wuffs_webp__error__bad_header); + goto exit; + } + + ok: + self->private_impl.p_do_decode_image_config_limited = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.do_decode_image_config_limited_vp8l + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config_limited_vp8l( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_c32 = 0; + uint32_t v_transform_size = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint32_t t_0 = *iop_a_src++; + v_c32 = t_0; + } + if (v_c32 != 47u) { + status = wuffs_base__make_status(wuffs_webp__error__bad_header); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + uint32_t t_1; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { + t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src); + iop_a_src += 4; + } else { + self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + while (true) { + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch; + uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56)); + *scratch <<= 8; + *scratch >>= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1; + if (num_bits_1 == 24) { + t_1 = ((uint32_t)(*scratch)); + break; + } + num_bits_1 += 8u; + *scratch |= ((uint64_t)(num_bits_1)) << 56; + } + } + v_c32 = t_1; + } + self->private_impl.f_width = ((v_c32 & 16383u) + 1u); + v_c32 >>= 14u; + self->private_impl.f_height = ((v_c32 & 16383u) + 1u); + v_c32 >>= 14u; + self->private_impl.f_pixfmt = 2415954056u; + if ((v_c32 & 1u) != 0u) { + self->private_impl.f_pixfmt = 2164295816u; + } + v_c32 >>= 1u; + if (v_c32 != 0u) { + status = wuffs_base__make_status(wuffs_webp__error__bad_header); + goto exit; + } + v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u)); + self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (0u * v_transform_size)); + self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (1u * v_transform_size)); + self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size)); + self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size)); + + goto ok; + ok: + self->private_impl.p_do_decode_image_config_limited_vp8l = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + return status; } @@ -69683,15 +72578,873 @@ wuffs_webp__decoder__do_decode_frame( wuffs_base__decode_frame_options* a_opts) { wuffs_base__status status = wuffs_base__make_status(NULL); - self->private_impl.f_call_sequence = 96u; + uint8_t v_c8 = 0; + uint32_t v_has_more = 0; + uint32_t v_width = 0; + wuffs_base__slice_u8 v_dst = {0}; + wuffs_base__slice_u8 v_tile_data = {0}; + wuffs_base__status v_status = wuffs_base__make_status(NULL); + wuffs_base__slice_u8 v_pix = {0}; + uint32_t v_which = 0; + uint32_t v_transform_type = 0; + uint64_t v_ti = 0; + uint64_t v_tj = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_do_decode_frame; + if (coro_susp_point) { + v_width = self->private_data.s_do_decode_frame.v_width; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_call_sequence == 64u) { + } else if (self->private_impl.f_call_sequence < 64u) { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + } else { + status = wuffs_base__make_status(wuffs_base__note__end_of_data); + goto ok; + } + self->private_impl.f_seen_transform[0u] = false; + self->private_impl.f_seen_transform[1u] = false; + self->private_impl.f_seen_transform[2u] = false; + self->private_impl.f_seen_transform[3u] = false; + self->private_impl.f_n_transforms = 0u; + while (true) { + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_has_more = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + if (v_has_more == 0u) { + break; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + } + v_width = self->private_impl.f_width; + if (self->private_impl.f_seen_transform[3u]) { + v_width = self->private_impl.f_color_indexing_width; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + self->private_impl.f_overall_color_cache_bits = self->private_impl.f_color_cache_bits; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + self->private_impl.f_color_cache_bits = self->private_impl.f_overall_color_cache_bits; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + while (true) { + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) || + (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || + (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len))) || + (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_dst = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); + v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); + { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + wuffs_base__status t_1 = wuffs_webp__decoder__decode_pixels(self, + v_dst, + a_src, + v_width, + self->private_impl.f_height, + v_tile_data, + self->private_impl.f_overall_tile_size_log2); + v_status = t_1; + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + } + if (wuffs_base__status__is_ok(&v_status)) { + break; + } + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7); + } + if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); + v_which = self->private_impl.f_n_transforms; + while (v_which > 0u) { + v_which -= 1u; + v_transform_type = ((uint32_t)(self->private_impl.f_transform_type[v_which])); + v_tile_data = wuffs_base__utility__empty_slice_u8(); + if (v_transform_type < 2u) { + v_ti = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])); + v_tj = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])); + if ((v_ti <= v_tj) && (v_tj <= ((uint64_t)(a_workbuf.len)))) { + v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_ti, v_tj); + } + } + if (v_transform_type == 0u) { + wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_tile_data); + } else if (v_transform_type == 1u) { + wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_tile_data); + } else if (v_transform_type == 2u) { + wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix); + } else { + wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix); + v_width = self->private_impl.f_width; + } + } + v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, a_blend); + if ( ! wuffs_base__status__is_ok(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } + self->private_impl.f_call_sequence = 96u; + + ok: + self->private_impl.p_do_decode_frame = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_do_decode_frame.v_width = v_width; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_transform + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_transform( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_transform_type = 0; + uint32_t v_tile_size_log2 = 0; + wuffs_base__slice_u8 v_p = {0}; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_transform; + if (coro_susp_point) { + v_transform_type = self->private_data.s_decode_transform.v_transform_type; + v_tile_size_log2 = self->private_data.s_decode_transform.v_tile_size_log2; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 2u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + if (self->private_impl.f_n_bits >= 2u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_transform_type = (self->private_impl.f_bits & 3u); + self->private_impl.f_bits >>= 2u; + self->private_impl.f_n_bits -= 2u; + if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) { + status = wuffs_base__make_status(wuffs_webp__error__bad_transform); + goto exit; + } else if (self->private_impl.f_seen_transform[3u]) { + status = wuffs_base__make_status(wuffs_webp__error__unsupported_transform_after_color_indexing_transform); + goto exit; + } + self->private_impl.f_seen_transform[v_transform_type] = true; + self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type)); + self->private_impl.f_n_transforms += 1u; + if (v_transform_type < 2u) { + if (self->private_impl.f_n_bits < 3u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 3u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u); + self->private_impl.f_transform_tile_size_log2[v_transform_type] = ((uint8_t)(v_tile_size_log2)); + self->private_impl.f_bits >>= 3u; + self->private_impl.f_n_bits -= 3u; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + status = wuffs_webp__decoder__decode_pixels(self, + wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))), + a_src, + ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + wuffs_base__utility__empty_slice_u8(), + 0u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + } else if (v_transform_type == 2u) { + } else { + if (self->private_impl.f_n_bits < 8u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_2 = *iop_a_src++; + v_c8 = t_2; + } + if (self->private_impl.f_n_bits >= 8u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + self->private_impl.f_color_indexing_palette_size = ((self->private_impl.f_bits & 255u) + 1u); + self->private_impl.f_bits >>= 8u; + self->private_impl.f_n_bits -= 8u; + if (self->private_impl.f_color_indexing_palette_size <= 2u) { + self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 7u) / 8u); + self->private_impl.f_transform_tile_size_log2[3u] = 3u; + } else if (self->private_impl.f_color_indexing_palette_size <= 4u) { + self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 3u) / 4u); + self->private_impl.f_transform_tile_size_log2[3u] = 2u; + } else if (self->private_impl.f_color_indexing_palette_size <= 16u) { + self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 1u) / 2u); + self->private_impl.f_transform_tile_size_log2[3u] = 1u; + } else { + self->private_impl.f_color_indexing_width = self->private_impl.f_width; + self->private_impl.f_transform_tile_size_log2[3u] = 0u; + } + if (self->private_impl.f_width >= self->private_impl.f_color_indexing_width) { + self->private_impl.f_workbuf_offset_for_color_indexing = (4u * (self->private_impl.f_width - self->private_impl.f_color_indexing_width) * self->private_impl.f_height); + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + status = wuffs_webp__decoder__decode_pixels(self, + wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)), + a_src, + self->private_impl.f_color_indexing_palette_size, + 1u, + wuffs_base__utility__empty_slice_u8(), + 0u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + wuffs_private_impl__bulk_memset(&self->private_data.f_palette[(4u * self->private_impl.f_color_indexing_palette_size)], (1024u - (4u * self->private_impl.f_color_indexing_palette_size)), 0u); + v_p = wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)); + while (((uint64_t)(v_p.len)) >= 8u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_p.ptr[4u] += v_p.ptr[0u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_p.ptr[5u] += v_p.ptr[1u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_p.ptr[6u] += v_p.ptr[2u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_p.ptr[7u] += v_p.ptr[3u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u); + } + } + + goto ok; + ok: + self->private_impl.p_decode_transform = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_transform = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_transform.v_transform_type = v_transform_type; + self->private_data.s_decode_transform.v_tile_size_log2 = v_tile_size_log2; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_color_cache_parameters + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_color_cache_parameters( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_use_color_cache = 0; + uint32_t v_color_cache_bits = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_color_cache_parameters; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_use_color_cache = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + self->private_impl.f_color_cache_bits = 0u; + if (v_use_color_cache != 0u) { + if (self->private_impl.f_n_bits < 4u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 4u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_color_cache_bits = (self->private_impl.f_bits & 15u); + self->private_impl.f_bits >>= 4u; + self->private_impl.f_n_bits -= 4u; + if ((v_color_cache_bits < 1u) || (11u < v_color_cache_bits)) { + status = wuffs_base__make_status(wuffs_webp__error__bad_color_cache); + goto exit; + } + self->private_impl.f_color_cache_bits = v_color_cache_bits; + } + + goto ok; + ok: + self->private_impl.p_decode_color_cache_parameters = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_color_cache_parameters = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_hg_table + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_hg_table( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + wuffs_base__slice_u8 a_workbuf) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_use_hg_table = 0; + uint32_t v_tile_size_log2 = 0; + wuffs_base__slice_u8 v_hg_pixels = {0}; + uint64_t v_n = 0; + wuffs_base__slice_u8 v_p = {0}; + uint32_t v_hg_plus_1 = 0; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_hg_table; + if (coro_susp_point) { + v_tile_size_log2 = self->private_data.s_decode_hg_table.v_tile_size_log2; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_use_hg_table = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + if (v_use_hg_table == 0u) { + self->private_impl.f_overall_n_huffman_groups = 1u; + self->private_impl.f_overall_tile_size_log2 = 0u; + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); + if (((uint64_t)(v_hg_pixels.len)) >= 4u) { + v_hg_pixels.ptr[0u] = 0u; + v_hg_pixels.ptr[1u] = 0u; + v_hg_pixels.ptr[2u] = 0u; + v_hg_pixels.ptr[3u] = 0u; + } + status = wuffs_base__make_status(NULL); + goto ok; + } + if (self->private_impl.f_n_bits < 3u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 3u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u); + self->private_impl.f_bits >>= 3u; + self->private_impl.f_n_bits -= 3u; + self->private_impl.f_overall_tile_size_log2 = v_tile_size_log2; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + status = wuffs_webp__decoder__decode_pixels(self, + wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))), + a_src, + ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + wuffs_base__utility__empty_slice_u8(), + 0u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + self->private_impl.f_overall_n_huffman_groups = 1u; + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); + v_n = ((uint64_t)((((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * 4u))); + if (v_n > ((uint64_t)(v_hg_pixels.len))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_p = wuffs_base__slice_u8__subslice_j(v_hg_pixels, v_n); + while (((uint64_t)(v_p.len)) >= 4u) { + if (v_p.ptr[2u] != 0u) { + status = wuffs_base__make_status(wuffs_webp__error__unsupported_number_of_huffman_groups); + goto exit; + } + v_hg_plus_1 = (((uint32_t)(v_p.ptr[1u])) + 1u); + if (self->private_impl.f_overall_n_huffman_groups < v_hg_plus_1) { + self->private_impl.f_overall_n_huffman_groups = v_hg_plus_1; + } + v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u); + } + + ok: + self->private_impl.p_decode_hg_table = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_hg_table = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_hg_table.v_tile_size_log2 = v_tile_size_log2; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_pixels + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_pixels( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_dst, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + uint32_t a_height, + wuffs_base__slice_u8 a_tile_data, + uint32_t a_tile_size_log2) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_i = 0; + uint32_t v_n = 0; + + uint32_t coro_susp_point = self->private_impl.p_decode_pixels; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + v_i = 0u; + v_n = (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits); + while (v_i < v_n) { + self->private_data.f_color_cache[v_i] = 0u; + v_i += 1u; + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_webp__decoder__decode_pixels_slow(self, + a_dst, + a_src, + a_width, + a_height, + a_tile_data, + a_tile_size_log2); + if (status.repr) { + goto suspend; + } + + goto ok; + ok: + self->private_impl.p_decode_pixels = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_pixels = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - goto ok; - ok: goto exit; exit: return status; } +// -------- func webp.decoder.swizzle + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__swizzle( + wuffs_webp__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__slice_u8 a_src, + wuffs_base__pixel_blend a_blend) { + wuffs_base__status v_status = wuffs_base__make_status(NULL); + wuffs_base__pixel_format v_dst_pixfmt = {0}; + uint32_t v_dst_bits_per_pixel = 0; + uint32_t v_dst_bytes_per_pixel = 0; + uint64_t v_dst_bytes_per_row = 0; + wuffs_base__slice_u8 v_dst_palette = {0}; + wuffs_base__table_u8 v_tab = {0}; + uint64_t v_src_bytes_per_row = 0; + wuffs_base__slice_u8 v_dst = {0}; + uint32_t v_y = 0; + + v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler, + wuffs_base__pixel_buffer__pixel_format(a_dst), + wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)), + wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt), + wuffs_base__utility__empty_slice_u8(), + a_blend); + if ( ! wuffs_base__status__is_ok(&v_status)) { + return wuffs_private_impl__status__ensure_not_a_suspension(v_status); + } + v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); + v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt); + if ((v_dst_bits_per_pixel & 7u) != 0u) { + return wuffs_base__make_status(wuffs_base__error__unsupported_option); + } + v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u); + v_dst_bytes_per_row = ((uint64_t)((self->private_impl.f_width * v_dst_bytes_per_pixel))); + v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)); + v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); + v_src_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 4u))); + while (v_src_bytes_per_row <= ((uint64_t)(a_src.len))) { + v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y); + if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row); + } + wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(a_src, v_src_bytes_per_row)); + a_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_bytes_per_row); + v_y += 1u; + } + return wuffs_base__make_status(NULL); +} + // -------- func webp.decoder.frame_dirty_rect WUFFS_BASE__GENERATED_C_CODE @@ -69866,7 +73619,7 @@ wuffs_webp__decoder__workbuf_len( return wuffs_base__utility__empty_range_ii_u64(); } - return wuffs_base__utility__make_range_ii_u64(0u, 0u); + return wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u]))); } #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP) diff --git a/std/webp/decode_huffman.wuffs b/std/webp/decode_huffman.wuffs new file mode 100644 index 00000000..2832a714 --- /dev/null +++ b/std/webp/decode_huffman.wuffs @@ -0,0 +1,531 @@ +// Copyright 2024 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +pri func decoder.decode_huffman_groups?(src: base.io_reader, n_huffman_groups: base.u32[..= 256]) { + var hg : base.u32 + var ht : base.u32 + + hg = 0 + while hg < args.n_huffman_groups { + assert hg < 256 via "a < b: a < c; c <= b"(c: args.n_huffman_groups) + ht = 0 + while ht < 5, + inv hg < 256, + { + this.decode_huffman_tree?(src: args.src, hg: hg, ht: ht) + ht += 1 + } endwhile + hg += 1 + } endwhile +} + +pri func decoder.decode_huffman_tree?(src: base.io_reader, hg: base.u32[..= 255], ht: base.u32[..= 4]) { + var c8 : base.u8 + var use_simple : base.u32[..= 1] + var status : base.status + + if args.ht >= 4 { + this.ht_n_symbols = 40 + } else if args.ht > 0 { + this.ht_n_symbols = 256 + } else if this.color_cache_bits == 0 { + this.ht_n_symbols = 280 + } else { + this.ht_n_symbols = 280 + ((1 as base.u32) << this.color_cache_bits) + } + + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + use_simple = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + if use_simple <> 0 { + this.decode_huffman_tree_simple?(src: args.src, hg: args.hg, ht: args.ht) + + } else { + this.decode_code_length_code_lengths?(src: args.src) + + status = this.build_code_lengths_huffman_nodes!() + if not status.is_ok() { + return status + } + + this.build_code_lengths?(src: args.src) + + status = this.build_huffman_nodes!(hg: args.hg, ht: args.ht) + if not status.is_ok() { + return status + } + } +} + +pri func decoder.decode_huffman_tree_simple?(src: base.io_reader, hg: base.u32[..= 255], ht: base.u32[..= 4]) { + var c8 : base.u8 + var use_second_symbol : base.u32[..= 1] + var first_symbol_n_bits : base.u32[..= 8] + var symbol0 : base.u32[..= 0xFF] + var symbol1 : base.u32[..= 0xFF] + var base_offset : base.u32[..= 0x064C] + + if this.n_bits < 2 { + c8 = args.src.read_u8?() + if this.n_bits >= 2 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 2 + } + use_second_symbol = this.bits & 1 + first_symbol_n_bits = (((this.bits & 2) >> 1) * 7) + 1 + this.bits >>= 2 + this.n_bits -= 2 + + if this.n_bits < first_symbol_n_bits { + c8 = args.src.read_u8?() + if this.n_bits >= first_symbol_n_bits { + return "#internal error: inconsistent n_bits" + } + assert this.n_bits < 8 via "a < b: a < c; c <= b"(c: first_symbol_n_bits) + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 8 + assert first_symbol_n_bits <= this.n_bits via "a <= b: a <= c; c <= b"(c: 8) + assert this.n_bits >= first_symbol_n_bits via "a >= b: b <= a"() + } + symbol0 = this.bits & (((1 as base.u32) << first_symbol_n_bits) - 1) + this.bits >>= first_symbol_n_bits + this.n_bits -= first_symbol_n_bits + + base_offset = HUFFMAN_TABLE_BASE_OFFSETS[args.ht] as base.u32 + + if use_second_symbol <> 0 { + if this.n_bits < 8 { + c8 = args.src.read_u8?() + if this.n_bits >= 8 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 8 + } + symbol1 = this.bits & 0xFF + this.bits >>= 8 + this.n_bits -= 8 + + this.huffman_nodes[args.hg][base_offset + 0] = (base_offset + 1) as base.u16 + this.huffman_nodes[args.hg][base_offset + 1] = (symbol0 | 0x8000) as base.u16 + this.huffman_nodes[args.hg][base_offset + 2] = (symbol1 | 0x8000) as base.u16 + + } else { + this.huffman_nodes[args.hg][base_offset] = (symbol0 | 0x8000) as base.u16 + } +} + +pri func decoder.decode_code_length_code_lengths?(src: base.io_reader) { + var c8 : base.u8 + var n_codes : base.u32[..= 19] + var i : base.u32 + + if this.n_bits < 4 { + c8 = args.src.read_u8?() + if this.n_bits >= 4 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 4 + } + n_codes = (this.bits & 15) + 4 + this.bits >>= 4 + this.n_bits -= 4 + + i = 0 + while i < n_codes { + assert i < 19 via "a < b: a < c; c <= b"(c: n_codes) + + if this.n_bits < 3 { + c8 = args.src.read_u8?() + if this.n_bits >= 3 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 3 + } + this.code_length_code_lengths[CODE_LENGTH_CODE_ORDER[i]] = (this.bits & 7) as base.u8 + this.bits >>= 3 + this.n_bits -= 3 + + i += 1 + } endwhile + while i < 19 { + this.code_length_code_lengths[CODE_LENGTH_CODE_ORDER[i]] = 0 + i += 1 + } endwhile +} + +pri func decoder.build_code_lengths_huffman_nodes!() base.status { + var code_bits : base.u32 + var code_len : base.u32[..= 7] // The "code length code length". + var symbol : base.u32[..= 19] // The "code length or 16, 17, 18". + + var histogram : array[8] base.u32 + var n_used_symbols : base.u32 + var last_used_symbol : base.u32[..= 18] + + var subscription_weight : base.u32[..= 0x8000] + var subscription_total : base.u32 + var curr_code : base.u32 + var next_codes : array[9] base.u32 + + var n_branches : base.u32 + var h : base.u32[..= 36] + var children : base.u32 + var node : base.u16 + + symbol = 0 + while symbol < 19 { + code_len = this.code_length_code_lengths[symbol] as base.u32 + if code_len <> 0 { + histogram[code_len] ~mod+= 1 + n_used_symbols ~mod+= 1 + last_used_symbol = symbol + } + symbol += 1 + } endwhile + + if n_used_symbols < 1 { + return "#bad Huffman code" + } else if n_used_symbols == 1 { + this.code_lengths_huffman_nodes[0] = (last_used_symbol | 0x8000) as base.u16 + return ok + } + + subscription_weight = 1 << 14 + code_len = 1 + while true { + curr_code = (curr_code ~mod+ histogram[code_len]) ~mod<< 1 + next_codes[code_len + 1] = curr_code + subscription_total ~mod+= subscription_weight ~mod* histogram[code_len] + subscription_weight >>= 1 + if code_len >= 7 { + break + } + code_len += 1 + } endwhile + + if subscription_total > (1 << 15) { + return "#bad Huffman code (over-subscribed)" + } else if subscription_total < (1 << 15) { + return "#bad Huffman code (under-subscribed)" + } + + this.code_lengths_huffman_nodes[0] = 0 + symbol = 0 + while symbol < 19 { + code_len = this.code_length_code_lengths[symbol] as base.u32 + if code_len > 0 { + code_bits = next_codes[code_len] + next_codes[code_len] ~mod+= 1 + + // Insert {symbol, code_bits, code_len} into the node tree. + code_bits ~mod<<= 32 - code_len + h = 0 + while code_len > 0, + inv symbol < 19, + { + node = this.code_lengths_huffman_nodes[h] + if node == 0 { + children = 1 ~mod+ (2 ~mod* n_branches) + children = children.min(no_more_than: 35) + this.code_lengths_huffman_nodes[h] = children as base.u16 + this.code_lengths_huffman_nodes[children + 0] = 0 + this.code_lengths_huffman_nodes[children + 1] = 0 + h = children + (code_bits >> 31) + n_branches ~mod+= 1 + } else { + children = node as base.u32 + h = children.min(no_more_than: 35) + (code_bits >> 31) + } + code_bits ~mod<<= 1 + code_len -= 1 + } endwhile + this.code_lengths_huffman_nodes[h] = (symbol | 0x8000) as base.u16 + } + symbol += 1 + } endwhile + return ok +} + +pri func decoder.build_huffman_nodes!(hg: base.u32[..= 255], ht: base.u32[..= 4]) base.status { + var base_offset : base.u32[..= 0x064C] + + var code_bits : base.u32 + var code_len : base.u32[..= 15] + var symbol : base.u32[..= 2328] + + var histogram : array[16] base.u32 + var n_used_symbols : base.u32 + var last_used_symbol : base.u32[..= 2328] + + var subscription_weight : base.u32[..= 0x8000] + var subscription_total : base.u32 + var curr_code : base.u32 + var next_codes : array[17] base.u32 + + var n_branches : base.u32 + var h : base.u32[..= 0x187A] + var children : base.u32 + var node : base.u16 + + base_offset = HUFFMAN_TABLE_BASE_OFFSETS[args.ht] as base.u32 + + symbol = 0 + while symbol < this.ht_n_symbols { + assert symbol < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols) + code_len = (this.code_lengths[symbol] & 15) as base.u32 + if code_len <> 0 { + histogram[code_len] ~mod+= 1 + n_used_symbols ~mod+= 1 + last_used_symbol = symbol + } + symbol += 1 + } endwhile + + if n_used_symbols < 1 { + return "#bad Huffman code" + } else if n_used_symbols == 1 { + this.huffman_nodes[args.hg][base_offset] = (last_used_symbol | 0x8000) as base.u16 + return ok + } + + subscription_weight = 1 << 14 + code_len = 1 + while true { + curr_code = (curr_code ~mod+ histogram[code_len]) ~mod<< 1 + next_codes[code_len + 1] = curr_code + subscription_total ~mod+= subscription_weight ~mod* histogram[code_len] + subscription_weight >>= 1 + if code_len >= 15 { + break + } + code_len += 1 + } endwhile + + if subscription_total > (1 << 15) { + return "#bad Huffman code (over-subscribed)" + } else if subscription_total < (1 << 15) { + return "#bad Huffman code (under-subscribed)" + } + + this.huffman_nodes[args.hg][base_offset] = 0 + symbol = 0 + while symbol < this.ht_n_symbols { + assert symbol < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols) + code_len = (this.code_lengths[symbol] & 15) as base.u32 + if code_len <> 0 { + code_bits = next_codes[code_len] + next_codes[code_len] ~mod+= 1 + + // Insert {symbol, code_bits, code_len} into the node tree. + code_bits ~mod<<= 32 - code_len + h = base_offset + while code_len > 0, + inv symbol < 2328, + { + node = this.huffman_nodes[args.hg][h] + if node == 0 { + children = base_offset ~mod+ (1 ~mod+ (2 ~mod* n_branches)) + children = children.min(no_more_than: 0x1879) + this.huffman_nodes[args.hg][h] = children as base.u16 + this.huffman_nodes[args.hg][children + 0] = 0 + this.huffman_nodes[args.hg][children + 1] = 0 + h = children + (code_bits >> 31) + n_branches ~mod+= 1 + } else { + children = node as base.u32 + h = children.min(no_more_than: 0x1879) + (code_bits >> 31) + } + code_bits ~mod<<= 1 + code_len -= 1 + } endwhile + this.huffman_nodes[args.hg][h] = (symbol | 0x8000) as base.u16 + } + symbol += 1 + } endwhile + return ok +} + +pri func decoder.build_code_lengths?(src: base.io_reader) { + var c8 : base.u8 + var use_length : base.u32[..= 1] + var length_n_bits : base.u32[..= 16] + var length : base.u32[..= 65537] + var prev_code_length : base.u16[..= 15] + var h : base.u32[..= 36] + var s : base.u32[..= 2328] + var s_max : base.u32 + var node : base.u16 + var symbol : base.u32[..= 0x7FFF] + var repeat_value : base.u16[..= 15] + var repeat_n_bits : base.u32[..= 7] + + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + use_length = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + this.ht_code_lengths_remaining = this.ht_n_symbols + if use_length <> 0 { + if this.n_bits < 3 { + c8 = args.src.read_u8?() + if this.n_bits >= 3 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 3 + } + length_n_bits = ((this.bits & 7) * 2) + 2 + this.bits >>= 3 + this.n_bits -= 3 + + while this.n_bits < length_n_bits, + post this.n_bits >= length_n_bits, + { + c8 = args.src.read_u8?() + if this.n_bits >= length_n_bits { + return "#internal error: inconsistent n_bits" + } + assert this.n_bits < 16 via "a < b: a < c; c <= b"(c: length_n_bits) + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + } endwhile + length = (this.bits & (((1 as base.u32) << length_n_bits) - 1)) + 2 + this.bits >>= length_n_bits + this.n_bits -= length_n_bits + + if length > this.ht_n_symbols { + return "#bad Huffman code" + } + this.ht_code_lengths_remaining = length + } + + prev_code_length = 8 + while s < this.ht_n_symbols { + assert s < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols) + + if this.ht_code_lengths_remaining <= 0 { + while s < this.ht_n_symbols { + assert s < 2328 via "a < b: a < c; c <= b"(c: this.ht_n_symbols) + this.code_lengths[s] = 0 + s += 1 + } endwhile + break + } + this.ht_code_lengths_remaining -= 1 + + h = 0 + while true, + inv s < 2328, + { + node = this.code_lengths_huffman_nodes[h] + if node >= 0x8000 { + break + } else if node > 35 { + return "#internal error: inconsistent Huffman code" + } + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + h = (node as base.u32) + (this.bits & 1) + this.bits >>= 1 + this.n_bits -= 1 + } endwhile + + symbol = (node & 0x7FFF) as base.u32 + if symbol == 0 { + this.code_lengths[s] = 0 + s += 1 + continue + } else if symbol < 16 { + prev_code_length = symbol as base.u16 + this.code_lengths[s] = prev_code_length + s += 1 + continue + } else if symbol == 16 { + repeat_value = prev_code_length + } else { + repeat_value = 0 + } + + repeat_n_bits = REPEAT_N_BITS[symbol & 3] as base.u32 + s_max = (REPEAT_COUNTS[symbol & 3] as base.u32) ~mod+ s + + if this.n_bits < repeat_n_bits { + c8 = args.src.read_u8?() + if this.n_bits >= repeat_n_bits { + return "#internal error: inconsistent n_bits" + } + assert this.n_bits < 7 via "a < b: a < c; c <= b"(c: repeat_n_bits) + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 8 + assert repeat_n_bits <= this.n_bits via "a <= b: a <= c; c <= b"(c: 8) + assert this.n_bits >= repeat_n_bits via "a >= b: b <= a"() + } + s_max ~mod+= this.bits & (((1 as base.u32) << repeat_n_bits) - 1) + this.bits >>= repeat_n_bits + this.n_bits -= repeat_n_bits + + if s_max > this.ht_n_symbols { + return "#bad Huffman code" + } + assert s_max <= 2328 via "a <= b: a <= c; c <= b"(c: this.ht_n_symbols) + while s < s_max, + inv s_max <= 2328, + { + assert s < 2328 via "a < b: a < c; c <= b"(c: s_max) + this.code_lengths[s] = repeat_value + s += 1 + } endwhile + } endwhile +} + +pri const CODE_LENGTH_CODE_ORDER : roarray[19] base.u8[..= 18] = [ + 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, +] + +pri const REPEAT_N_BITS : roarray[4] base.u8[..= 7] = [2, 3, 7, 0] + +pri const REPEAT_COUNTS : roarray[4] base.u8[..= 11] = [3, 3, 11, 0] + +// See the decoder.huffman_nodes comment re five (5) Huffman trees. +pri const HUFFMAN_TABLE_BASE_OFFSETS : roarray[5] base.u16[..= 0x064C] = [ + 0x064C, + 0x0000, + 0x01FF, + 0x03FE, + 0x05FD, +] diff --git a/std/webp/decode_pixels_slow.wuffs b/std/webp/decode_pixels_slow.wuffs new file mode 100644 index 00000000..5c3c8c4a --- /dev/null +++ b/std/webp/decode_pixels_slow.wuffs @@ -0,0 +1,308 @@ +// Copyright 2024 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +pri func decoder.decode_pixels_slow?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) { + var c8 : base.u8 + + var p : base.u64 + var p_max : base.u64[..= 0x4000_0000] + + var tile_size_log2 : base.u32[..= 31] + var width_in_tiles : base.u32[..= 0x20FF] + + var x : base.u32 + var y : base.u32 + var i : base.u32 + + var hg : base.u32[..= 0xFF] + var h : base.u32[..= 0x187A] + var node : base.u16 + + var pixel_g : base.u32[..= 0x7FFF] + var color : base.u32 // u32 0xAARR_GGBB, non-premultiplied alpha. + var dst_pixel : slice base.u8 + + var back_ref_len_n_bits : base.u32[..= 11] + var back_ref_len_minus_1 : base.u32[..= 0x1FFF] // 0x1FFF = 8191. + var back_ref_dist_n_bits : base.u32[..= 18] + var back_ref_dist_sym : base.u32[..= 0x7FFF] + var back_ref_dist_premap_minus_1 : base.u32[..= 0xF_FFFF] // 0xF_FFFF = 1048575. + var back_ref_dist_minus_1 : base.u32 + + var dm : base.u32[..= 0xFF] + var dx : base.u32 + var dy : base.u32 + + var p_end : base.u64[..= 0x4000_8000] + var dist4 : base.u64 + var q : base.u64 + + var color_cache_pixels : slice base.u8 + var color_cache_p : base.u64 + var color_cache_shift : base.u32[..= 31] + + p_max = (4 * args.width * args.height) as base.u64 + if args.dst.length() < p_max { + return "#internal error: inconsistent dst buffer" + } + + if args.tile_size_log2 <> 0 { + tile_size_log2 = args.tile_size_log2 + width_in_tiles = (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2 + } else { + tile_size_log2 = 31 + width_in_tiles = 1 + } + + while p < p_max { + // The "~mod+ 1" selects the green pixel of the BGRA 4-byte group. + i = ((((y >> tile_size_log2) ~mod* width_in_tiles) ~mod+ (x >> tile_size_log2)) ~mod* 4) ~mod+ 1 + if (i as base.u64) < args.tile_data.length() { + hg = args.tile_data[i as base.u64] as base.u32 + } + + // Decode the Green+etc symbol. + h = HUFFMAN_TABLE_BASE_OFFSETS[0] as base.u32 + while true, + inv p < p_max, + { + node = this.huffman_nodes[hg][h] + if node >= 0x8000 { + break + } else if node > 0x1879 { + return "#internal error: inconsistent Huffman code" + } + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + h = (node as base.u32) + (this.bits & 1) + this.bits >>= 1 + this.n_bits -= 1 + } endwhile + pixel_g = (node & 0x7FFF) as base.u32 + + if pixel_g < 0x100 { // Literal pixel. + color = pixel_g << 8 + + // Decode the Red symbol. + h = HUFFMAN_TABLE_BASE_OFFSETS[1] as base.u32 + while true, + inv p < p_max, + { + node = this.huffman_nodes[hg][h] + if node >= 0x8000 { + break + } + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + h = ((node as base.u32) & 0xFFF) + (this.bits & 1) + this.bits >>= 1 + this.n_bits -= 1 + } endwhile + color |= ((node & 0xFF) as base.u32) << 16 + + // Decode the Blue symbol. + h = HUFFMAN_TABLE_BASE_OFFSETS[2] as base.u32 + while true, + inv p < p_max, + { + node = this.huffman_nodes[hg][h] + if node >= 0x8000 { + break + } + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + h = ((node as base.u32) & 0xFFF) + (this.bits & 1) + this.bits >>= 1 + this.n_bits -= 1 + } endwhile + color |= ((node & 0xFF) as base.u32) << 0 + + // Decode the Alpha symbol. + h = HUFFMAN_TABLE_BASE_OFFSETS[3] as base.u32 + while true, + inv p < p_max, + { + node = this.huffman_nodes[hg][h] + if node >= 0x8000 { + break + } + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + h = ((node as base.u32) & 0xFFF) + (this.bits & 1) + this.bits >>= 1 + this.n_bits -= 1 + } endwhile + color |= ((node & 0xFF) as base.u32) << 24 + + } else if pixel_g < 0x118 { // Back-ref pixel. + // Decode the back-ref length. + if pixel_g < 0x104 { + back_ref_len_minus_1 = pixel_g - 0x100 + } else { + back_ref_len_n_bits = (pixel_g - 0x102) >> 1 + back_ref_len_minus_1 = ((2 as base.u32) + (pixel_g & 1)) << back_ref_len_n_bits + assert back_ref_len_minus_1 <= 6144 + while this.n_bits < back_ref_len_n_bits, + inv p < p_max, + inv back_ref_len_minus_1 <= 6144, + post this.n_bits >= back_ref_len_n_bits, + { + c8 = args.src.read_u8?() + if this.n_bits >= back_ref_len_n_bits { + return "#internal error: inconsistent n_bits" + } + assert this.n_bits < 12 via "a < b: a < c; c <= b"(c: back_ref_len_n_bits) + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + } endwhile + back_ref_len_minus_1 += this.bits & (((1 as base.u32) << back_ref_len_n_bits) - 1) + this.bits >>= back_ref_len_n_bits + this.n_bits -= back_ref_len_n_bits + } + + // Decode the back-ref distance. + + h = HUFFMAN_TABLE_BASE_OFFSETS[4] as base.u32 + while true, + inv p < p_max, + { + node = this.huffman_nodes[hg][h] + if node >= 0x8000 { + break + } + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + h = ((node as base.u32) & 0xFFF) + (this.bits & 1) + this.bits >>= 1 + this.n_bits -= 1 + } endwhile + back_ref_dist_sym = (node & 0x7FFF) as base.u32 + + if back_ref_dist_sym < 4 { + back_ref_dist_premap_minus_1 = back_ref_dist_sym + } else if back_ref_dist_sym < 40 { + back_ref_dist_n_bits = (back_ref_dist_sym - 2) >> 1 + back_ref_dist_premap_minus_1 = ((2 as base.u32) + (back_ref_dist_sym & 1)) << back_ref_dist_n_bits + assert back_ref_dist_premap_minus_1 <= 786432 + while this.n_bits < back_ref_dist_n_bits, + inv p < p_max, + inv back_ref_dist_premap_minus_1 <= 786432, + post this.n_bits >= back_ref_dist_n_bits, + { + c8 = args.src.read_u8?() + if this.n_bits >= back_ref_dist_n_bits { + return "#internal error: inconsistent n_bits" + } + assert this.n_bits < 24 via "a < b: a < c; c <= b"(c: back_ref_dist_n_bits) + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + } endwhile + back_ref_dist_premap_minus_1 += this.bits & (((1 as base.u32) << back_ref_dist_n_bits) - 1) + this.bits >>= back_ref_dist_n_bits + this.n_bits -= back_ref_dist_n_bits + } + + if back_ref_dist_premap_minus_1 >= 120 { + back_ref_dist_minus_1 = back_ref_dist_premap_minus_1 - 120 + } else { + dm = DISTANCE_MAP[back_ref_dist_premap_minus_1] as base.u32 + dy = dm >> 4 + dx = 7 ~mod- (dm & 15) + back_ref_dist_minus_1 = (args.width * dy) ~mod+ dx + } + + // Apply the (back_ref_len_minus_1, back_ref_dist_minus_1) pair. + assert p < 0x4000_0000 via "a < b: a < c; c <= b"(c: p_max) + p_end = p + (((back_ref_len_minus_1 + 1) * 4) as base.u64) + dist4 = ((back_ref_dist_minus_1 as base.u64) * 4) + 4 + if (p_end > p_max) or (p_end > args.dst.length()) or (p < dist4) { + return "#bad back-reference" + } + q = p - dist4 + while (q < p) and (p < p_end), + inv p_end <= args.dst.length(), + { + assert q < p_end via "a < b: a < c; c < b"(c: p) + assert p < 0x4000_8000 via "a < b: a < c; c <= b"(c: p_end) + assert q < 0x4000_8000 via "a < b: a < c; c <= b"(c: p_end) + assert p < args.dst.length() via "a < b: a < c; c <= b"(c: p_end) + assert q < args.dst.length() via "a < b: a < c; c <= b"(c: p_end) + args.dst[p] = args.dst[q] + p += 1 + q += 1 + } endwhile + + // Update (x, y). + x ~mod+= back_ref_len_minus_1 + 1 + while x >= args.width { + x -= args.width + y ~mod+= 1 + } endwhile + continue + + } else { // Color cache pixel. + // Insert previous pixels into this.color_cache. + if (color_cache_p > p) or (p > args.dst.length()) { + return "#internal error: inconsistent dst buffer" + } + color_cache_pixels = args.dst[color_cache_p .. p] + color_cache_p = p + color_cache_shift = (32 - this.color_cache_bits) & 31 + while color_cache_pixels.length() >= 4, + inv pixel_g >= 0x118, + { + color = color_cache_pixels.peek_u32le() + this.color_cache[((color ~mod* 0x1E35_A7BD) >> color_cache_shift) & 2047] = color + color_cache_pixels = color_cache_pixels[4 ..] + } endwhile + + // Look up this.color_cache. + color = this.color_cache[(pixel_g - 0x118) & 2047] + } + + // Set the dst pixel to the color. + if p > args.dst.length() { + return "#internal error: inconsistent dst buffer" + } + dst_pixel = args.dst[p ..] + if dst_pixel.length() < 4 { + return "#internal error: inconsistent dst buffer" + } + dst_pixel.poke_u32le!(a: color) + p ~mod+= 4 + + // Update (x, y). + x ~mod+= 1 + if x == args.width { + x = 0 + y ~mod+= 1 + } + } endwhile +} diff --git a/std/webp/decode_transform.wuffs b/std/webp/decode_transform.wuffs new file mode 100644 index 00000000..4869bd91 --- /dev/null +++ b/std/webp/decode_transform.wuffs @@ -0,0 +1,464 @@ +// Copyright 2024 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +pri func decoder.apply_transform_predictor!(pix: slice base.u8, tile_data: roslice base.u8) { + var w4 : base.u64[..= 0x1_0000] + var prev_row : roslice base.u8 + var curr_row : slice base.u8 + + var tile_size_log2 : base.u32[..= 9] + var tiles_per_row : base.u32[..= 16895] + var mask : base.u32 + var y : base.u32[..= 0x4000] + var x : base.u32[..= 0x4000] + var t : base.u64 + var tile_data : roslice base.u8 + var mode : base.u8[..= 0x0F] + + var l0 : base.u32[..= 0xFF] + var l1 : base.u32[..= 0xFF] + var l2 : base.u32[..= 0xFF] + var l3 : base.u32[..= 0xFF] + var c0 : base.u32[..= 0xFF] + var c1 : base.u32[..= 0xFF] + var c2 : base.u32[..= 0xFF] + var c3 : base.u32[..= 0xFF] + var t0 : base.u32[..= 0xFF] + var t1 : base.u32[..= 0xFF] + var t2 : base.u32[..= 0xFF] + var t3 : base.u32[..= 0xFF] + var sum_l : base.u32 + var sum_t : base.u32 + + if (this.width <= 0) or (this.height <= 0) { + return nothing + } + + w4 = (this.width * 4) as base.u64 + curr_row = this.util.empty_slice_u8() + if w4 <= args.pix.length() { + curr_row = args.pix[.. w4] + } + + // The first pixel's predictor is mode 0 (opaque black). + if curr_row.length() >= 4 { + curr_row[3] ~mod+= 0xFF + } + + // The rest of the first row's predictor is mode 1 (L). + while curr_row.length() >= 8 { + curr_row[4] ~mod+= curr_row[0] + curr_row[5] ~mod+= curr_row[1] + curr_row[6] ~mod+= curr_row[2] + curr_row[7] ~mod+= curr_row[3] + curr_row = curr_row[4 ..] + } endwhile + + tile_size_log2 = this.transform_tile_size_log2[0] as base.u32 + tiles_per_row = (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2 + mask = ((1 as base.u32) << tile_size_log2) - 1 + + y = 1 + while y < this.height { + assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height) + + t = (4 * (y >> tile_size_log2) * tiles_per_row) as base.u64 + tile_data = this.util.empty_slice_u8() + if t <= args.tile_data.length() { + tile_data = args.tile_data[t ..] + if tile_data.length() >= 4 { + mode = tile_data[1] & 0x0F + tile_data = tile_data[4 ..] + } + } + + if w4 <= args.pix.length() { + prev_row = args.pix + args.pix = args.pix[w4 ..] + curr_row = args.pix + } + + // The first column's predictor is mode 2 (T). + if (prev_row.length() >= 4) and (curr_row.length() >= 4) { + curr_row[0] ~mod+= prev_row[0] + curr_row[1] ~mod+= prev_row[1] + curr_row[2] ~mod+= prev_row[2] + curr_row[3] ~mod+= prev_row[3] + } + + x = 1 + while x < this.width, + inv y < 0x4000, + { + assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width) + + if ((x & mask) == 0) and (tile_data.length() >= 4) { + mode = tile_data[1] & 0x0F + tile_data = tile_data[4 ..] + } + + if (prev_row.length() < 12) or (curr_row.length() < 8) { + break + } + + if mode == 0 { // Opaque black. + curr_row[7] ~mod+= 0xFF + + } else if mode == 1 { // L + curr_row[4] ~mod+= curr_row[0] + curr_row[5] ~mod+= curr_row[1] + curr_row[6] ~mod+= curr_row[2] + curr_row[7] ~mod+= curr_row[3] + + } else if mode == 2 { // T + curr_row[4] ~mod+= prev_row[4] + curr_row[5] ~mod+= prev_row[5] + curr_row[6] ~mod+= prev_row[6] + curr_row[7] ~mod+= prev_row[7] + + } else if mode == 3 { // TR + curr_row[4] ~mod+= prev_row[8] + curr_row[5] ~mod+= prev_row[9] + curr_row[6] ~mod+= prev_row[10] + curr_row[7] ~mod+= prev_row[11] + + } else if mode == 4 { // TL + curr_row[4] ~mod+= prev_row[0] + curr_row[5] ~mod+= prev_row[1] + curr_row[6] ~mod+= prev_row[2] + curr_row[7] ~mod+= prev_row[3] + + } else if mode == 5 { // Average2(Average2(L, TR), T). + l0 = ((curr_row[0] as base.u32) + (prev_row[8] as base.u32)) / 2 + l1 = ((curr_row[1] as base.u32) + (prev_row[9] as base.u32)) / 2 + l2 = ((curr_row[2] as base.u32) + (prev_row[10] as base.u32)) / 2 + l3 = ((curr_row[3] as base.u32) + (prev_row[11] as base.u32)) / 2 + curr_row[4] ~mod+= ((l0 + (prev_row[4] as base.u32)) / 2) as base.u8 + curr_row[5] ~mod+= ((l1 + (prev_row[5] as base.u32)) / 2) as base.u8 + curr_row[6] ~mod+= ((l2 + (prev_row[6] as base.u32)) / 2) as base.u8 + curr_row[7] ~mod+= ((l3 + (prev_row[7] as base.u32)) / 2) as base.u8 + + } else if mode == 6 { // Average2(L, TL). + curr_row[4] ~mod+= (((curr_row[0] as base.u32) + (prev_row[0] as base.u32)) / 2) as base.u8 + curr_row[5] ~mod+= (((curr_row[1] as base.u32) + (prev_row[1] as base.u32)) / 2) as base.u8 + curr_row[6] ~mod+= (((curr_row[2] as base.u32) + (prev_row[2] as base.u32)) / 2) as base.u8 + curr_row[7] ~mod+= (((curr_row[3] as base.u32) + (prev_row[3] as base.u32)) / 2) as base.u8 + + } else if mode == 7 { // Average2(L, T). + curr_row[4] ~mod+= (((curr_row[0] as base.u32) + (prev_row[4] as base.u32)) / 2) as base.u8 + curr_row[5] ~mod+= (((curr_row[1] as base.u32) + (prev_row[5] as base.u32)) / 2) as base.u8 + curr_row[6] ~mod+= (((curr_row[2] as base.u32) + (prev_row[6] as base.u32)) / 2) as base.u8 + curr_row[7] ~mod+= (((curr_row[3] as base.u32) + (prev_row[7] as base.u32)) / 2) as base.u8 + + } else if mode == 8 { // Average2(TL, T). + curr_row[4] ~mod+= (((prev_row[0] as base.u32) + (prev_row[4] as base.u32)) / 2) as base.u8 + curr_row[5] ~mod+= (((prev_row[1] as base.u32) + (prev_row[5] as base.u32)) / 2) as base.u8 + curr_row[6] ~mod+= (((prev_row[2] as base.u32) + (prev_row[6] as base.u32)) / 2) as base.u8 + curr_row[7] ~mod+= (((prev_row[3] as base.u32) + (prev_row[7] as base.u32)) / 2) as base.u8 + + } else if mode == 9 { // Average2(T, TR). + curr_row[4] ~mod+= (((prev_row[4] as base.u32) + (prev_row[8] as base.u32)) / 2) as base.u8 + curr_row[5] ~mod+= (((prev_row[5] as base.u32) + (prev_row[9] as base.u32)) / 2) as base.u8 + curr_row[6] ~mod+= (((prev_row[6] as base.u32) + (prev_row[10] as base.u32)) / 2) as base.u8 + curr_row[7] ~mod+= (((prev_row[7] as base.u32) + (prev_row[11] as base.u32)) / 2) as base.u8 + + } else if mode == 10 { // Average2(Average2(L, TL), Average2(T, TR)). + l0 = ((curr_row[0] as base.u32) + (prev_row[0] as base.u32)) / 2 + l1 = ((curr_row[1] as base.u32) + (prev_row[1] as base.u32)) / 2 + l2 = ((curr_row[2] as base.u32) + (prev_row[2] as base.u32)) / 2 + l3 = ((curr_row[3] as base.u32) + (prev_row[3] as base.u32)) / 2 + t0 = ((prev_row[4] as base.u32) + (prev_row[8] as base.u32)) / 2 + t1 = ((prev_row[5] as base.u32) + (prev_row[9] as base.u32)) / 2 + t2 = ((prev_row[6] as base.u32) + (prev_row[10] as base.u32)) / 2 + t3 = ((prev_row[7] as base.u32) + (prev_row[11] as base.u32)) / 2 + curr_row[4] ~mod+= ((l0 + t0) / 2) as base.u8 + curr_row[5] ~mod+= ((l1 + t1) / 2) as base.u8 + curr_row[6] ~mod+= ((l2 + t2) / 2) as base.u8 + curr_row[7] ~mod+= ((l3 + t3) / 2) as base.u8 + + } else if mode == 11 { // Select(L, T, TL). + l0 = curr_row[0] as base.u32 + l1 = curr_row[1] as base.u32 + l2 = curr_row[2] as base.u32 + l3 = curr_row[3] as base.u32 + c0 = prev_row[0] as base.u32 + c1 = prev_row[1] as base.u32 + c2 = prev_row[2] as base.u32 + c3 = prev_row[3] as base.u32 + t0 = prev_row[4] as base.u32 + t1 = prev_row[5] as base.u32 + t2 = prev_row[6] as base.u32 + t3 = prev_row[7] as base.u32 + sum_l = this.absolute_difference(a: c0, b: t0) + + this.absolute_difference(a: c1, b: t1) + + this.absolute_difference(a: c2, b: t2) + + this.absolute_difference(a: c3, b: t3) + sum_t = this.absolute_difference(a: c0, b: l0) + + this.absolute_difference(a: c1, b: l1) + + this.absolute_difference(a: c2, b: l2) + + this.absolute_difference(a: c3, b: l3) + if sum_l < sum_t { + curr_row[4] ~mod+= l0 as base.u8 + curr_row[5] ~mod+= l1 as base.u8 + curr_row[6] ~mod+= l2 as base.u8 + curr_row[7] ~mod+= l3 as base.u8 + } else { + curr_row[4] ~mod+= t0 as base.u8 + curr_row[5] ~mod+= t1 as base.u8 + curr_row[6] ~mod+= t2 as base.u8 + curr_row[7] ~mod+= t3 as base.u8 + } + + } else if mode == 12 { // ClampAddSubtractFull(L, T, TL). + curr_row[4] ~mod+= this.mode12(l: curr_row[0], t: prev_row[4], tl: prev_row[0]) + curr_row[5] ~mod+= this.mode12(l: curr_row[1], t: prev_row[5], tl: prev_row[1]) + curr_row[6] ~mod+= this.mode12(l: curr_row[2], t: prev_row[6], tl: prev_row[2]) + curr_row[7] ~mod+= this.mode12(l: curr_row[3], t: prev_row[7], tl: prev_row[3]) + + } else if mode == 13 { // ClampAddSubtractHalf(Average2(L, T), TL). + curr_row[4] ~mod+= this.mode13(l: curr_row[0], t: prev_row[4], tl: prev_row[0]) + curr_row[5] ~mod+= this.mode13(l: curr_row[1], t: prev_row[5], tl: prev_row[1]) + curr_row[6] ~mod+= this.mode13(l: curr_row[2], t: prev_row[6], tl: prev_row[2]) + curr_row[7] ~mod+= this.mode13(l: curr_row[3], t: prev_row[7], tl: prev_row[3]) + } + + curr_row = curr_row[4 ..] + prev_row = prev_row[4 ..] + x += 1 + } endwhile + + y += 1 + } endwhile +} + +pri func decoder.absolute_difference(a: base.u32[..= 0xFF], b: base.u32[..= 0xFF]) base.u32[..= 0xFF] { + if args.a < args.b { + assert args.b > args.a via "a > b: b < a"() + return args.b - args.a + } + return args.a - args.b +} + +pri func decoder.mode12(l: base.u8, t: base.u8, tl: base.u8) base.u8 { + var v : base.u32 + + v = ((args.l as base.u32) + (args.t as base.u32)) ~mod- (args.tl as base.u32) + + // Return clamp(v), where v is a signed i32. + if v < 256 { + return v as base.u8 + } else if v < 512 { + return 255 + } + return 0 +} + +pri func decoder.mode13(l: base.u8, t: base.u8, tl: base.u8) base.u8 { + var x : base.u32[..= 0xFF] + var y : base.u32[..= 0xFF] + var z : base.u32 + var v : base.u32 + + x = ((args.l as base.u32) + (args.t as base.u32)) / 2 + y = args.tl as base.u32 + + // Calculate "v = x + ((x - y) / 2)" but using signed (i32) arithmetic + // instead of unsigned (u32) arithmetic. + z = x ~mod- y + v = x ~mod+ this.util.sign_extend_rshift_u32(a: z ~mod+ (z >> 31), n: 1) + + // Return clamp(v), where v is a signed i32. + if v < 256 { + return v as base.u8 + } else if v < 512 { + return 255 + } + return 0 +} + +pri func decoder.apply_transform_cross_color!(pix: slice base.u8, tile_data: roslice base.u8) { + var tile_size_log2 : base.u32[..= 9] + var tiles_per_row : base.u32[..= 16895] + var mask : base.u32 + var y : base.u32[..= 0x4000] + var x : base.u32[..= 0x4000] + var t : base.u64 + var tile_data : roslice base.u8 + + var g2r : base.u32 + var g2b : base.u32 + var r2b : base.u32 + + var b : base.u8 + var g : base.u8 + var r : base.u8 + + tile_size_log2 = this.transform_tile_size_log2[1] as base.u32 + tiles_per_row = (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2 + mask = ((1 as base.u32) << tile_size_log2) - 1 + + y = 0 + while y < this.height { + assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height) + + t = (4 * (y >> tile_size_log2) * tiles_per_row) as base.u64 + tile_data = this.util.empty_slice_u8() + if t <= args.tile_data.length() { + tile_data = args.tile_data[t ..] + } + + x = 0 + while x < this.width, + inv y < 0x4000, + { + assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width) + + if ((x & mask) == 0) and (tile_data.length() >= 4) { + g2r = SIGN_EXTEND_I8_I32[tile_data[0]] + g2b = SIGN_EXTEND_I8_I32[tile_data[1]] + r2b = SIGN_EXTEND_I8_I32[tile_data[2]] + tile_data = tile_data[4 ..] + } + + if args.pix.length() >= 4 { + b = args.pix[0] + g = args.pix[1] + r = args.pix[2] + r ~mod+= (((SIGN_EXTEND_I8_I32[g] ~mod* g2r) >> 5) & 0xFF) as base.u8 + b ~mod+= (((SIGN_EXTEND_I8_I32[g] ~mod* g2b) >> 5) & 0xFF) as base.u8 + b ~mod+= (((SIGN_EXTEND_I8_I32[r] ~mod* r2b) >> 5) & 0xFF) as base.u8 + args.pix[0] = b + args.pix[2] = r + args.pix = args.pix[4 ..] + } + + x += 1 + } endwhile + + y += 1 + } endwhile +} + +pri func decoder.apply_transform_subtract_green!(pix: slice base.u8) { + var p : slice base.u8 + var g : base.u8 + + iterate (p = args.pix)(length: 4, advance: 4, unroll: 1) { + g = p[1] + p[0] ~mod+= g + p[2] ~mod+= g + } +} + +pri func decoder.apply_transform_color_indexing!(pix: slice base.u8) { + var tile_size_log2 : base.u32[..= 9] + var bits_per_pixel : base.u32[..= 8] + var x_mask : base.u32 + var s_mask : base.u32[..= 0xFF] + var src_index : base.u64 + + var y : base.u32[..= 0x4000] + var di : base.u64 + var dj : base.u64 + var dst : slice base.u8 + var x : base.u32 + var s : base.u32[..= 0xFF] + + var p : base.u32[..= 0x3FC] + var p0 : base.u8 + var p1 : base.u8 + var p2 : base.u8 + var p3 : base.u8 + + tile_size_log2 = this.transform_tile_size_log2[3] as base.u32 + if tile_size_log2 == 0 { + // TODO: the code below is correct, but we could possibly simplify the + // case where the src and dst pixel counts are 1:1. + } + + bits_per_pixel = (8 as base.u32) >> tile_size_log2 + x_mask = ((1 as base.u32) << tile_size_log2) - 1 + s_mask = ((1 as base.u32) << bits_per_pixel) - 1 + + // The "+ 1" selects the green pixel of the BGRA 4-byte group. + src_index = (this.workbuf_offset_for_color_indexing + 1) as base.u64 + + y = 0 + while y < this.height { + assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height) + + di = (4 * (y + 0) * this.width) as base.u64 + dj = (4 * (y + 1) * this.width) as base.u64 + if (di > dj) or (dj > args.pix.length()) { + break + } + dst = args.pix[di .. dj] + + x = 0 + while dst.length() >= 4, + inv y < 0x4000, + { + if ((x & x_mask) == 0) and (src_index < args.pix.length()) { + s = args.pix[src_index] as base.u32 + src_index ~mod+= 4 + } + p = (s & s_mask) * 4 + s >>= bits_per_pixel + p0 = this.palette[p + 0] + p1 = this.palette[p + 1] + p2 = this.palette[p + 2] + p3 = this.palette[p + 3] + dst[0] = p0 + dst[1] = p1 + dst[2] = p2 + dst[3] = p3 + dst = dst[4 ..] + x ~mod+= 1 + } endwhile + + y += 1 + } endwhile +} + +// 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, +] diff --git a/std/webp/decode_webp.wuffs b/std/webp/decode_webp.wuffs index 99481fc4..9cb9aa7b 100644 --- a/std/webp/decode_webp.wuffs +++ b/std/webp/decode_webp.wuffs @@ -10,23 +10,131 @@ use "std/vp8" +pub status "#bad Huffman code (over-subscribed)" +pub status "#bad Huffman code (under-subscribed)" +pub status "#bad Huffman code" +pub status "#bad back-reference" +pub status "#bad color cache" +pub status "#bad header" +pub status "#bad transform" +pub status "#short chunk" pub status "#truncated input" +pub status "#unsupported number of Huffman groups" +pub status "#unsupported transform after color indexing transform" +pub status "#unsupported WebP file" + +pri status "#internal error: inconsistent Huffman code" +pri status "#internal error: inconsistent dst buffer" +pri status "#internal error: inconsistent n_bits" pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pub struct decoder? implements base.image_decoder( pixfmt : base.u32, - width : base.u32[..= 0xFF_FFFF], - height : base.u32[..= 0xFF_FFFF], + width : base.u32[..= 0x4000], + height : base.u32[..= 0x4000], // The call sequence state machine is discussed in // (/doc/std/image-decoders-call-sequence.md). call_sequence : base.u8, + code_length_code_lengths : array[19] base.u8[..= 7], + + sub_chunk_has_padding : base.bool, + frame_config_io_position : base.u64, + riff_chunk_length : base.u32, + sub_chunk_length : base.u32, + + bits : base.u32, + n_bits : base.u32[..= 31], + + seen_transform : array[4] base.bool, + transform_type : array[4] base.u8[..= 3], + transform_tile_size_log2 : array[4] base.u8[..= 9], + n_transforms : base.u32[..= 4], + + color_cache_bits : base.u32[..= 11], + overall_color_cache_bits : base.u32[..= 11], + overall_tile_size_log2 : base.u32[..= 9], + overall_n_huffman_groups : base.u32[..= 256], + + ht_n_symbols : base.u32[..= 2328], + ht_code_lengths_remaining : base.u32, + + color_indexing_palette_size : base.u32[..= 256], + color_indexing_width : base.u32[..= 0x4000], + + // The 0th element is for the Meta (Huffman Group) selectors. + // The 1st element is for the Predictor transform. + // The 2nd element is for the Cross Color transform. + // The 3rd element is overall workbuf length. + workbuf_offset_for_transform : array[4] base.u32[..= 0x4C00_0000], + + // If the Color Indexing transform is present then workbuf[i .. j] + // holds the pre-transformed pixel data (the Green component of the + // pixel's bgra data holds color indexes) and workbuf[0 .. j] holds the + // post-transformed data: + // + // - i is workbuf_offset_for_color_indexing + // - j is workbuf_offset_for_transform[0] + // + // i is calculated as: + // + // - if there are 8 bits per color index then i is 0. + // - if there are 4 bits per color index then i is j*1/2, roughly. + // - if there are 2 bits per color index then i is j*3/4, roughly. + // - if there are 1 bits per color index then i is j*7/8, roughly. + // + // The two slices (workbuf[i .. j] and workbuf[0 .. j]) overlap. + // apply_transform_color_indexing modifies the pixel buffer in-place. + workbuf_offset_for_color_indexing : base.u32[..= 0x4000_0000], + swizzler : base.pixel_swizzler, util : base.utility, +) + ( + palette : array[4 * 256] base.u8, + color_cache : array[2048] base.u32, + + codes : array[2328] base.u16, + code_lengths : array[2328] base.u16, + + // Each node is a base.u16 whose bit patterns are: + // + // - 0000_0000_0000_0000 Invalid. + // - 0CCC_CCCC_CCCC_CCCC Branch node (children_offset is CCC). + // - 1SSS_SSSS_SSSS_SSSS Leaf node (symbol is SSS, it may be zero). + code_lengths_huffman_nodes : array[37] base.u16, + + // A Huffman group has five (5) Huffman trees. + // + // Start .. End Size + // 0x064C .. 0x187B 0x122F (1) Green, back-ref length, color cache. + // 0x0000 .. 0x01FF 0x01FF (2) Red. + // 0x01FF .. 0x03FE 0x01FF (3) Blue. + // 0x03FE .. 0x05FD 0x01FF (4) Alpha. + // 0x05FD .. 0x064C 0x004F (5) Back-ref distance. + // + // The Green+etc tree is last (in terms of start offset) because it's + // by far the largest (worst case) and its color cache component has + // variable length. + // + // 0x122F = 4655 = ((2 * 2328) - 1) and the same 2328 turns up in func + // decoder.decode_huffman_tree. + // + // 2328 is (256 + 24 + 2048), combining 256 Green values, 24 back-ref + // lengths and up to 2048 = (1 << 11) color cache keys. + // + // 0x01FF = 511 = ((2 * 256) - 1) is for 256 Red (Blue, Alpha) values. + // + // 0x004F = 79 = ((2 * 40) - 1) is for 40 back-ref distances. + // + // 0x187B = 6267 and (0x187B * sizeof(u16)) = 12534. Overall, this + // field takes 0x30_F600 = 3_208704 bytes of memory. + // + // The base.u16's bits are the same as for code_lengths_huffman_nodes. + huffman_nodes : array[256] array[0x187B] base.u16, ) pub func decoder.get_quirk(key: base.u32) base.u64 { @@ -50,13 +158,42 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_ } pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) { + var c32 : base.u32 + var r_mark : base.u64 + var status : base.status + if this.call_sequence <> 0x00 { return base."#bad call sequence" } - this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL - this.width = 160 - this.height = 120 + c32 = args.src.read_u32le?() + if c32 <> 'RIFF'le { + return "#bad header" + } + this.riff_chunk_length = args.src.read_u32le?() + if (this.riff_chunk_length & 1) <> 0 { + return "#bad header" + } + + while true { + io_limit (io: args.src, limit: this.riff_chunk_length as base.u64) { + r_mark = args.src.mark() + status =? this.do_decode_image_config_limited?(src: args.src) + this.riff_chunk_length ~sat-= + (args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32 + } + + if status.is_ok() { + break + } else if not status.is_suspension() { + return status + } else if (status == base."$short read") and (this.riff_chunk_length == 0) { + return "#short chunk" + } + yield? status + } endwhile + + this.frame_config_io_position = args.src.position() if args.dst <> nullptr { args.dst.set!( @@ -71,6 +208,82 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base. this.call_sequence = 0x20 } +pri func decoder.do_decode_image_config_limited?(src: base.io_reader) { + var c32 : base.u32 + var r_mark : base.u64 + var status : base.status + + c32 = args.src.read_u32le?() + if c32 <> 'WEBP'le { + return "#bad header" + } + + c32 = args.src.read_u32le?() + if c32 == 'VP8 'le { + return "#unsupported WebP file" + + } else if c32 == 'VP8L'le { + this.sub_chunk_length = args.src.read_u32le?() + if this.sub_chunk_length < 4 { + return "#bad header" + } + this.sub_chunk_has_padding = (this.sub_chunk_length & 1) <> 0 + + while true { + io_limit (io: args.src, limit: this.sub_chunk_length as base.u64) { + r_mark = args.src.mark() + status =? this.do_decode_image_config_limited_vp8l?(src: args.src) + this.sub_chunk_length ~sat-= + (args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32 + } + + if status.is_ok() { + break + } else if not status.is_suspension() { + return status + } else if (status == base."$short read") and (this.sub_chunk_length == 0) { + return "#short chunk" + } + yield? status + } endwhile + + } else if c32 == 'VP8X'le { + return "#unsupported WebP file" + + } else { + return "#bad header" + } +} + +pri func decoder.do_decode_image_config_limited_vp8l?(src: base.io_reader) { + var c32 : base.u32 + var transform_size : base.u32[..= 0x400_0000] + + c32 = args.src.read_u8_as_u32?() + if c32 <> 0x2F { + return "#bad header" + } + c32 = args.src.read_u32le?() + this.width = (c32 & 0x3FFF) + 1 + c32 >>= 14 + this.height = (c32 & 0x3FFF) + 1 + c32 >>= 14 + this.pixfmt = base.PIXEL_FORMAT__BGRX + if (c32 & 1) <> 0 { + this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL + } + c32 >>= 1 + if c32 <> 0 { + return "#bad header" + } + + transform_size = 4 * ((this.width + 3) >> 2) * ((this.height + 3) >> 2) + this.workbuf_offset_for_transform[0] = (4 * this.width * this.height) + (0 * transform_size) + this.workbuf_offset_for_transform[1] = (4 * this.width * this.height) + (1 * transform_size) + this.workbuf_offset_for_transform[2] = (4 * this.width * this.height) + (2 * transform_size) + this.workbuf_offset_for_transform[3] = (4 * this.width * this.height) + (3 * transform_size) +} + pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) { var status : base.status @@ -130,9 +343,452 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, } pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) { + var c8 : base.u8 + var has_more : base.u32[..= 1] + var width : base.u32[..= 0x4000] + var dst : slice base.u8 + var tile_data : roslice base.u8 + var status : base.status + var pix : slice base.u8 + var which : base.u32[..= 4] + var transform_type : base.u32[..= 3] + var ti : base.u64 + var tj : base.u64 + + if this.call_sequence == 0x40 { + // No-op. + } else if this.call_sequence < 0x40 { + this.do_decode_frame_config?(dst: nullptr, src: args.src) + } else { + return base."@end of data" + } + + this.seen_transform[0] = false + this.seen_transform[1] = false + this.seen_transform[2] = false + this.seen_transform[3] = false + this.n_transforms = 0 + + while true { + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + has_more = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + if has_more == 0 { + break + } + this.decode_transform?(src: args.src, workbuf: args.workbuf) + } endwhile + + width = this.width + if this.seen_transform[3] { + width = this.color_indexing_width + } + + this.decode_color_cache_parameters?(src: args.src) + this.overall_color_cache_bits = this.color_cache_bits + this.decode_hg_table?(src: args.src, width: width, workbuf: args.workbuf) + this.color_cache_bits = this.overall_color_cache_bits + this.decode_huffman_groups?(src: args.src, n_huffman_groups: this.overall_n_huffman_groups) + + while true { + if ((this.workbuf_offset_for_color_indexing as base.u64) > (this.workbuf_offset_for_transform[0] as base.u64)) or + ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) or + ((this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + dst = args.workbuf[ + (this.workbuf_offset_for_color_indexing as base.u64) .. + (this.workbuf_offset_for_transform[0] as base.u64)] + tile_data = args.workbuf[ + (this.workbuf_offset_for_transform[0] as base.u64) .. + (this.workbuf_offset_for_transform[1] as base.u64)] + status =? this.decode_pixels?( + dst: dst, + src: args.src, + width: width, + height: this.height, + tile_data: tile_data, + tile_size_log2: this.overall_tile_size_log2) + if status.is_ok() { + break + } + yield? status + } endwhile + + if (this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length() { + return base."#bad workbuf length" + } + pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)] + + which = this.n_transforms + while which > 0 { + which -= 1 + transform_type = this.transform_type[which] as base.u32 + + tile_data = this.util.empty_slice_u8() + if transform_type < 2 { + ti = this.workbuf_offset_for_transform[transform_type + 1] as base.u64 + tj = this.workbuf_offset_for_transform[transform_type + 2] as base.u64 + if (ti <= tj) and (tj <= args.workbuf.length()) { + tile_data = args.workbuf[ti .. tj] + } + } + + if transform_type == 0 { + this.apply_transform_predictor!(pix: pix, tile_data: tile_data) + } else if transform_type == 1 { + this.apply_transform_cross_color!(pix: pix, tile_data: tile_data) + } else if transform_type == 2 { + this.apply_transform_subtract_green!(pix: pix) + } else { + this.apply_transform_color_indexing!(pix: pix) + width = this.width + } + } endwhile + + status = this.swizzle!( + dst: args.dst, + src: pix, + blend: args.blend) + if not status.is_ok() { + return status + } + this.call_sequence = 0x60 } +pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) { + var c8 : base.u8 + var transform_type : base.u32[..= 3] + var tile_size_log2 : base.u32[..= 9] + var p : slice base.u8 + + if this.n_bits < 2 { + c8 = args.src.read_u8?() + if this.n_bits >= 2 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 2 + } + transform_type = this.bits & 3 + this.bits >>= 2 + this.n_bits -= 2 + + if this.seen_transform[transform_type] or (this.n_transforms >= 4) { + return "#bad transform" + } else if this.seen_transform[3] { + return "#unsupported transform after color indexing transform" + } + this.seen_transform[transform_type] = true + this.transform_type[this.n_transforms] = transform_type as base.u8 + this.n_transforms += 1 + + if transform_type < 2 { // Predictor, Cross Color transform. + if this.n_bits < 3 { + c8 = args.src.read_u8?() + if this.n_bits >= 3 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 3 + } + tile_size_log2 = (this.bits & 7) + 2 + this.transform_tile_size_log2[transform_type] = tile_size_log2 as base.u8 + this.bits >>= 3 + this.n_bits -= 3 + + this.decode_color_cache_parameters?(src: args.src) + this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) + if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or + ((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + this.decode_pixels?( + dst: args.workbuf[ + (this.workbuf_offset_for_transform[transform_type + 1] as base.u64) .. + (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)], + src: args.src, + width: (this.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + tile_data: this.util.empty_slice_u8(), + tile_size_log2: 0) + + } else if transform_type == 2 { // Subtract Green transform. + // No-op. + + } else { // Color Indexing transform. + if this.n_bits < 8 { + c8 = args.src.read_u8?() + if this.n_bits >= 8 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 8 + } + this.color_indexing_palette_size = (this.bits & 0xFF) + 1 + this.bits >>= 8 + this.n_bits -= 8 + + if this.color_indexing_palette_size <= 2 { + this.color_indexing_width = (this.width + 7) / 8 + this.transform_tile_size_log2[3] = 3 + } else if this.color_indexing_palette_size <= 4 { + this.color_indexing_width = (this.width + 3) / 4 + this.transform_tile_size_log2[3] = 2 + } else if this.color_indexing_palette_size <= 16 { + this.color_indexing_width = (this.width + 1) / 2 + this.transform_tile_size_log2[3] = 1 + } else { + this.color_indexing_width = this.width + this.transform_tile_size_log2[3] = 0 + } + + if this.width >= this.color_indexing_width { + this.workbuf_offset_for_color_indexing = 4 * (this.width - this.color_indexing_width) * this.height + } + + this.decode_color_cache_parameters?(src: args.src) + this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) + + this.decode_pixels?( + dst: this.palette[.. 4 * this.color_indexing_palette_size], + src: args.src, + width: this.color_indexing_palette_size, + height: 1, + tile_data: this.util.empty_slice_u8(), + tile_size_log2: 0) + this.palette[4 * this.color_indexing_palette_size .. 1024].bulk_memset!(byte_value: 0) + + p = this.palette[.. 4 * this.color_indexing_palette_size] + while p.length() >= 8 { + p[4] ~mod+= p[0] + p[5] ~mod+= p[1] + p[6] ~mod+= p[2] + p[7] ~mod+= p[3] + p = p[4 ..] + } endwhile + } +} + +pri func decoder.decode_color_cache_parameters?(src: base.io_reader) { + var c8 : base.u8 + var use_color_cache : base.u32[..= 1] + var color_cache_bits : base.u32[..= 15] + + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + use_color_cache = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + this.color_cache_bits = 0 + if use_color_cache <> 0 { + if this.n_bits < 4 { + c8 = args.src.read_u8?() + if this.n_bits >= 4 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 4 + } + color_cache_bits = this.bits & 15 + this.bits >>= 4 + this.n_bits -= 4 + + if (color_cache_bits < 1) or (11 < color_cache_bits) { + return "#bad color cache" + } + this.color_cache_bits = color_cache_bits + } +} + +pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) { + var c8 : base.u8 + var use_hg_table : base.u32[..= 1] + var tile_size_log2 : base.u32[..= 9] + var hg_pixels : slice base.u8 + var n : base.u64 + var p : roslice base.u8 + var hg_plus_1 : base.u32[..= 256] + + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + use_hg_table = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + if use_hg_table == 0 { + this.overall_n_huffman_groups = 1 + this.overall_tile_size_log2 = 0 + if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + hg_pixels = args.workbuf[ + this.workbuf_offset_for_transform[0] as base.u64 .. + this.workbuf_offset_for_transform[1] as base.u64] + if hg_pixels.length() >= 4 { + hg_pixels[0] = 0x00 + hg_pixels[1] = 0x00 + hg_pixels[2] = 0x00 + hg_pixels[3] = 0x00 + } + return ok + } + + if this.n_bits < 3 { + c8 = args.src.read_u8?() + if this.n_bits >= 3 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 3 + } + tile_size_log2 = (this.bits & 7) + 2 + this.bits >>= 3 + this.n_bits -= 3 + + this.overall_tile_size_log2 = tile_size_log2 + + this.decode_color_cache_parameters?(src: args.src) + this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) + if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + this.decode_pixels?( + dst: args.workbuf[ + (this.workbuf_offset_for_transform[0] as base.u64) .. + (this.workbuf_offset_for_transform[1] as base.u64)], + src: args.src, + width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + tile_data: this.util.empty_slice_u8(), + tile_size_log2: 0) + + this.overall_n_huffman_groups = 1 + if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + hg_pixels = args.workbuf[ + this.workbuf_offset_for_transform[0] as base.u64 .. + this.workbuf_offset_for_transform[1] as base.u64] + n = (((args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) * + ((this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) * + 4) as base.u64 + if n > hg_pixels.length() { + return base."#bad workbuf length" + } + p = hg_pixels[.. n] + while p.length() >= 4 { + if p[2] <> 0 { + return "#unsupported number of Huffman groups" + } + hg_plus_1 = (p[1] as base.u32) + 1 + if this.overall_n_huffman_groups < hg_plus_1 { + this.overall_n_huffman_groups = hg_plus_1 + } + p = p[4 ..] + } endwhile +} + +pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) { + var i : base.u32 + var n : base.u32[..= 2048] + + i = 0 + n = (1 as base.u32) << this.color_cache_bits + while i < n { + assert i < 2048 via "a < b: a < c; c <= b"(c: n) + this.color_cache[i] = 0 + i += 1 + } endwhile + + this.decode_pixels_slow?( + dst: args.dst, + src: args.src, + width: args.width, + height: args.height, + tile_data: args.tile_data, + tile_size_log2: args.tile_size_log2) +} + +pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: roslice base.u8, blend: base.pixel_blend) base.status { + var status : base.status + var dst_pixfmt : base.pixel_format + var dst_bits_per_pixel : base.u32[..= 256] + var dst_bytes_per_pixel : base.u32[..= 32] + var dst_bytes_per_row : base.u64 + var dst_palette : slice base.u8 + var tab : table base.u8 + var src_bytes_per_row : base.u64 + var dst : slice base.u8 + var y : base.u32 + + status = this.swizzler.prepare!( + dst_pixfmt: args.dst.pixel_format(), + dst_palette: args.dst.palette_or_else(fallback: this.palette[..]), + src_pixfmt: this.util.make_pixel_format(repr: this.pixfmt), + src_palette: this.util.empty_slice_u8(), + blend: args.blend) + if not status.is_ok() { + return status + } + + // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able + // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()". + dst_pixfmt = args.dst.pixel_format() + dst_bits_per_pixel = dst_pixfmt.bits_per_pixel() + if (dst_bits_per_pixel & 7) <> 0 { + return base."#unsupported option" + } + dst_bytes_per_pixel = dst_bits_per_pixel / 8 + dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64 + dst_palette = args.dst.palette_or_else(fallback: this.palette[..]) + tab = args.dst.plane(p: 0) + src_bytes_per_row = (this.width * 4) as base.u64 + + while.outer src_bytes_per_row <= args.src.length() { + dst = tab.row_u32(y: y) + if dst_bytes_per_row < dst.length() { + dst = dst[.. dst_bytes_per_row] + } + + this.swizzler.swizzle_interleaved_from_slice!( + dst: dst, + dst_palette: dst_palette, + src: args.src[.. src_bytes_per_row]) + + args.src = args.src[src_bytes_per_row ..] + y ~mod+= 1 + } endwhile.outer + + return ok +} + pub func decoder.frame_dirty_rect() base.rect_ie_u32 { return this.util.make_rect_ie_u32( min_incl_x: 0, @@ -179,5 +835,22 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform } pub func decoder.workbuf_len() base.range_ii_u64 { - return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0) + return this.util.make_range_ii_u64( + min_incl: this.workbuf_offset_for_transform[3] as base.u64, + max_incl: this.workbuf_offset_for_transform[3] as base.u64) } + +pri const DISTANCE_MAP : roarray[120] base.u8 = [ + 0x18, 0x07, 0x17, 0x19, 0x28, 0x06, 0x27, 0x29, 0x16, 0x1A, + 0x26, 0x2A, 0x38, 0x05, 0x37, 0x39, 0x15, 0x1B, 0x36, 0x3A, + 0x25, 0x2B, 0x48, 0x04, 0x47, 0x49, 0x14, 0x1C, 0x35, 0x3B, + 0x46, 0x4A, 0x24, 0x2C, 0x58, 0x45, 0x4B, 0x34, 0x3C, 0x03, + 0x57, 0x59, 0x13, 0x1D, 0x56, 0x5A, 0x23, 0x2D, 0x44, 0x4C, + 0x55, 0x5B, 0x33, 0x3D, 0x68, 0x02, 0x67, 0x69, 0x12, 0x1E, + 0x66, 0x6A, 0x22, 0x2E, 0x54, 0x5C, 0x43, 0x4D, 0x65, 0x6B, + 0x32, 0x3E, 0x78, 0x01, 0x77, 0x79, 0x53, 0x5D, 0x11, 0x1F, + 0x64, 0x6C, 0x42, 0x4E, 0x76, 0x7A, 0x21, 0x2F, 0x75, 0x7B, + 0x31, 0x3F, 0x63, 0x6D, 0x52, 0x5E, 0x00, 0x74, 0x7C, 0x41, + 0x4F, 0x10, 0x20, 0x62, 0x6E, 0x30, 0x73, 0x7D, 0x51, 0x5F, + 0x40, 0x72, 0x7E, 0x61, 0x6F, 0x50, 0x71, 0x7F, 0x60, 0x70, +] diff --git a/test/3pdata/nia-checksums-of-blinksuite.txt b/test/3pdata/nia-checksums-of-blinksuite.txt index b9d79f3d..45e97828 100644 --- a/test/3pdata/nia-checksums-of-blinksuite.txt +++ b/test/3pdata/nia-checksums-of-blinksuite.txt @@ -30,7 +30,6 @@ OK. d9f8441c test/3pdata/blinksuite/blue-10.png OK. 267741e0 test/3pdata/blinksuite/blue-100.png OK. 89449c01 test/3pdata/blinksuite/blue-wheel-srgb-color-profile.jpg OK. 8fce70a9 test/3pdata/blinksuite/blue-wheel-srgb-color-profile.png -OK. 2ef5fd5d test/3pdata/blinksuite/blue-wheel-srgb-color-profile.webp OK. 2d7bad9f test/3pdata/blinksuite/border-image-srgb-color-profile.png OK. 9ca73f21 test/3pdata/blinksuite/border-image.png OK. 277600f9 test/3pdata/blinksuite/boston.gif @@ -43,8 +42,6 @@ OK. 5ec78d7c test/3pdata/blinksuite/color-checker-adobe-color-profile.png OK. b3389858 test/3pdata/blinksuite/color-checker-srgb-color-profile.png OK. 10721531 test/3pdata/blinksuite/count-down-color-test.gif OK. 1abc4dc6 test/3pdata/blinksuite/count-down-color-test.png -OK. 2ef5fd5d test/3pdata/blinksuite/count-down-color-test.webp -OK. 2ef5fd5d test/3pdata/blinksuite/crbug.364830.webp OK. 24ab1efd test/3pdata/blinksuite/crbug779261.gif OK. ae034abe test/3pdata/blinksuite/crbug807324.png OK. 4f50fdb0 test/3pdata/blinksuite/crbug827754.png @@ -69,7 +66,6 @@ OK. d97ce4e8 test/3pdata/blinksuite/cs-uma-ycbcr-other.jpg OK. a2a940bc test/3pdata/blinksuite/cs-uma-ycck.jpg OK. b6000be6 test/3pdata/blinksuite/dice.png BAD 1023c20a test/3pdata/blinksuite/empty-frame.png -OK. 2ef5fd5d test/3pdata/blinksuite/flip.webp OK. eff36075 test/3pdata/blinksuite/flowchart.jpg OK. 20ff1df8 test/3pdata/blinksuite/full2loop.gif OK. dc814e29 test/3pdata/blinksuite/gif-loop-count.gif @@ -93,14 +89,8 @@ OK. 95641cb9 test/3pdata/blinksuite/icc-v2-gbr-420-height-not-whole-mcu.jpg OK. 93f21c2a test/3pdata/blinksuite/icc-v2-gbr-420-width-not-whole-mcu.jpg OK. f37cea44 test/3pdata/blinksuite/icc-v2-gbr-422-whole-mcus.jpg OK. 1de5a906 test/3pdata/blinksuite/icc-v2-gbr.jpg -OK. 2ef5fd5d test/3pdata/blinksuite/invalid-animated-webp.webp -OK. 2ef5fd5d test/3pdata/blinksuite/invalid-animated-webp2.webp -OK. 2ef5fd5d test/3pdata/blinksuite/invalid-animated-webp3.webp -OK. 2ef5fd5d test/3pdata/blinksuite/invalid-animated-webp4.webp -OK. 2ef5fd5d test/3pdata/blinksuite/invalid_vp8_vp8x.webp OK. 0da5f37e test/3pdata/blinksuite/jpeg-height-exif-orientation.jpg OK. 4409dca6 test/3pdata/blinksuite/large-gif-checkerboard.gif -OK. 2ef5fd5d test/3pdata/blinksuite/large.webp BAD 2f310e57 test/3pdata/blinksuite/missing-eoi.jpg OK. 72bbe2b6 test/3pdata/blinksuite/motion-jpeg-single-frame.jpg OK. 0268284a test/3pdata/blinksuite/mu.png @@ -171,7 +161,7 @@ OK. bfebcca4 test/3pdata/blinksuite/rgb-jpeg-red.jpg OK. 6ed3c2e7 test/3pdata/blinksuite/rgb-jpeg-with-adobe-marker-only.jpg OK. cfb6f39d test/3pdata/blinksuite/rgb-png-with-cmyk-color-profile.png OK. a3454fb7 test/3pdata/blinksuite/short-app-extension-string.gif -OK. 2ef5fd5d test/3pdata/blinksuite/size-failure.b186640109.webp +OK. 7c80a001 test/3pdata/blinksuite/size-failure.b186640109.webp BAD 2398258b test/3pdata/blinksuite/size-failure.gif OK. 5c4b1a8b test/3pdata/blinksuite/small-square-with-colorspin-profile.jpg OK. 44dc95b9 test/3pdata/blinksuite/sprite_all_fragments_same.png @@ -179,25 +169,7 @@ OK. 9a7e5ec7 test/3pdata/blinksuite/sprite_alternate_fragments_same.png OK. 1b1f5f96 test/3pdata/blinksuite/stripes-large.png OK. 6b85cdb9 test/3pdata/blinksuite/stripes-small.png OK. 16c2c0fe test/3pdata/blinksuite/test-load.jpg -OK. 2ef5fd5d test/3pdata/blinksuite/test.webp -OK. 2ef5fd5d test/3pdata/blinksuite/test2.webp -OK. 2ef5fd5d test/3pdata/blinksuite/test3.webp -OK. 2ef5fd5d test/3pdata/blinksuite/truncated.webp -OK. 2ef5fd5d test/3pdata/blinksuite/truncated2.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-icc-xmp.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-large.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-no-blend.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-opaque.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-semitransparent1.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-semitransparent2.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-semitransparent3.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated-semitransparent4.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-animated.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-color-no-profile-lossy.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-color-profile-crash.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-color-profile-lossless.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-color-profile-lossy-alpha.webp -OK. 2ef5fd5d test/3pdata/blinksuite/webp-color-profile-lossy.webp +OK. 19d3a207 test/3pdata/blinksuite/test3.webp BAD ed67a9a5 test/3pdata/blinksuite/wrong-block-length.gif OK. 577c5c4c test/3pdata/blinksuite/ycbcr-420-fast-int-progressive.jpg OK. bf4cd8e2 test/3pdata/blinksuite/ycbcr-420-float-progressive.jpg diff --git a/test/c/std/webp.c b/test/c/std/webp.c index 6af503bf..1000da02 100644 --- a/test/c/std/webp.c +++ b/test/c/std/webp.c @@ -64,6 +64,8 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // No mimic library. #endif +static wuffs_webp__decoder g_webp_decoder; + // ---------------- WebP Tests const char* // @@ -74,12 +76,12 @@ wuffs_webp_decode(uint64_t* n_bytes_out, uint32_t* quirks_ptr, size_t quirks_len, wuffs_base__io_buffer* src) { - wuffs_webp__decoder dec; + wuffs_webp__decoder* dec = &g_webp_decoder; CHECK_STATUS("initialize", - wuffs_webp__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION, + wuffs_webp__decoder__initialize(dec, sizeof *dec, WUFFS_VERSION, wuffs_initialize_flags)); return do_run__wuffs_base__image_decoder( - wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(&dec), + wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(dec), n_bytes_out, dst, pixfmt, quirks_ptr, quirks_len, src); } @@ -88,15 +90,15 @@ wuffs_webp_decode(uint64_t* n_bytes_out, const char* // test_wuffs_webp_decode_interface() { CHECK_FOCUS(__func__); - wuffs_webp__decoder dec; + wuffs_webp__decoder* dec = &g_webp_decoder; CHECK_STATUS("initialize", wuffs_webp__decoder__initialize( - &dec, sizeof dec, WUFFS_VERSION, + dec, sizeof *dec, WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); return do_test__wuffs_base__image_decoder( - wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(&dec), + wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(dec), "test/data/bricks-color.lossless.webp", 0, SIZE_MAX, 160, 120, - 0x00000000); + 0xFF022460); } // ---------------- Mimic Tests diff --git a/test/nia-checksums-of-data.txt b/test/nia-checksums-of-data.txt index c013a49f..8c56438f 100644 --- a/test/nia-checksums-of-data.txt +++ b/test/nia-checksums-of-data.txt @@ -26,26 +26,24 @@ OK. e08a7cc8 test/data/artificial-png/exif.png OK. e08a7cc8 test/data/artificial-png/key-value-pairs.png OK. 076cb375 test/data/bricks-color.bmp OK. 72a1f9cc test/data/bricks-color.jpeg -OK. 2ef5fd5d test/data/bricks-color.lossless.webp -OK. 2ef5fd5d test/data/bricks-color.lossy.webp +OK. 076cb375 test/data/bricks-color.lossless.webp OK. 076cb375 test/data/bricks-color.png OK. 076cb375 test/data/bricks-color.tga OK. f36c2e80 test/data/bricks-dither.bmp OK. f36c2e80 test/data/bricks-dither.gif -OK. 2ef5fd5d test/data/bricks-dither.lossless.webp +OK. f36c2e80 test/data/bricks-dither.lossless.webp OK. f36c2e80 test/data/bricks-dither.no-ancillary.png OK. f36c2e80 test/data/bricks-dither.png OK. c2bce675 test/data/bricks-gray.bmp OK. c2bce675 test/data/bricks-gray.gif OK. 3a2478ad test/data/bricks-gray.jpeg -OK. 2ef5fd5d test/data/bricks-gray.lossless.webp -OK. 2ef5fd5d test/data/bricks-gray.lossy.webp +OK. c2bce675 test/data/bricks-gray.lossless.webp OK. c2bce675 test/data/bricks-gray.no-ancillary.png OK. c2bce675 test/data/bricks-gray.png OK. c2bce675 test/data/bricks-gray.tga OK. 7aebfe6c test/data/bricks-nodither.bmp OK. 7aebfe6c test/data/bricks-nodither.gif -OK. 2ef5fd5d test/data/bricks-nodither.lossless.webp +OK. 7aebfe6c test/data/bricks-nodither.lossless.webp OK. 7aebfe6c test/data/bricks-nodither.png OK. 7aebfe6c test/data/bricks-nodither.tga OK. ae2e547d test/data/bricks-nodither.wbmp @@ -56,27 +54,23 @@ OK. 3014b4c0 test/data/gifplayer-muybridge.gif OK. 030f5a48 test/data/harvesters.bmp OK. c18b3d5a test/data/harvesters.gif OK. f217df74 test/data/harvesters.jpeg -OK. 2ef5fd5d test/data/harvesters.lossless.webp -OK. 2ef5fd5d test/data/harvesters.lossy.webp +OK. 030f5a48 test/data/harvesters.lossless.webp OK. 030f5a48 test/data/harvesters.png OK. e776c90f test/data/hat.bmp OK. 6dcba6a4 test/data/hat.gif OK. 2298f3ca test/data/hat.jpeg -OK. 2ef5fd5d test/data/hat.lossless.webp -OK. 2ef5fd5d test/data/hat.lossy.webp +OK. e776c90f test/data/hat.lossless.webp OK. e776c90f test/data/hat.png OK. d30bfe5d test/data/hat.wbmp OK. 33a44f22 test/data/hibiscus.primitive.bmp OK. 25e212b3 test/data/hibiscus.primitive.gif OK. 9624fa44 test/data/hibiscus.primitive.jpeg -OK. 2ef5fd5d test/data/hibiscus.primitive.lossless.webp -OK. 2ef5fd5d test/data/hibiscus.primitive.lossy.webp +OK. 33a44f22 test/data/hibiscus.primitive.lossless.webp OK. 33a44f22 test/data/hibiscus.primitive.png OK. 60040742 test/data/hibiscus.regular.bmp OK. b727da8b test/data/hibiscus.regular.gif OK. 41e39405 test/data/hibiscus.regular.jpeg -OK. 2ef5fd5d test/data/hibiscus.regular.lossless.webp -OK. 2ef5fd5d test/data/hibiscus.regular.lossy.webp +OK. 60040742 test/data/hibiscus.regular.lossless.webp OK. 60040742 test/data/hibiscus.regular.png OK. dcbb225a test/data/hippopotamus.bmp OK. ed4b78fc test/data/hippopotamus.interlaced.gif @@ -84,8 +78,7 @@ OK. dcbb225a test/data/hippopotamus.interlaced.png BAD c3c4bd65 test/data/hippopotamus.interlaced.truncated.gif BAD 7c6a771b test/data/hippopotamus.interlaced.truncated.png OK. 96bdbbb3 test/data/hippopotamus.jpeg -OK. 2ef5fd5d test/data/hippopotamus.lossless.webp -OK. 2ef5fd5d test/data/hippopotamus.lossy.webp +OK. dcbb225a test/data/hippopotamus.lossless.webp OK. d3bbed27 test/data/hippopotamus.masked-with-muybridge.gif OK. 7e6acf01 test/data/hippopotamus.masked-with-muybridge.png OK. dcbb225a test/data/hippopotamus.nie @@ -130,8 +123,7 @@ OK. d42a13cd test/data/peacock.s2x2-420.jpeg OK. bf7e8c96 test/data/pjw-thumbnail.bmp OK. bf7e8c96 test/data/pjw-thumbnail.gif OK. 7c67a37f test/data/pjw-thumbnail.jpeg -OK. 2ef5fd5d test/data/pjw-thumbnail.lossless.webp -OK. 2ef5fd5d test/data/pjw-thumbnail.lossy.webp +OK. bf7e8c96 test/data/pjw-thumbnail.lossless.webp OK. bf7e8c96 test/data/pjw-thumbnail.png OK. 38cb4cbf test/data/red-blue-gradient.dcip3d65-no-chrm-no-gama.png OK. 38cb4cbf test/data/red-blue-gradient.gamma1dot0.png