From 34bf05c5c6b459786334f91cb522e41de33875a6 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 29 Dec 2018 14:43:01 +1100 Subject: [PATCH] wuffs gen -version=0.2.0-alpha.26 --- release/c/wuffs-v0.2.c | 1518 +++++++++++++++++++--------------------- 1 file changed, 724 insertions(+), 794 deletions(-) diff --git a/release/c/wuffs-v0.2.c b/release/c/wuffs-v0.2.c index a99b9578..6ec84078 100644 --- a/release/c/wuffs-v0.2.c +++ b/release/c/wuffs-v0.2.c @@ -49,14 +49,14 @@ extern "C" { // work-in-progress version, not a release version, and has no backwards or // forwards compatibility guarantees. // -// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-12-22 UTC, -// based on revision 39a01cdc6452a62716a69e52a61a88ef6db4e398. +// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-12-29 UTC, +// based on revision 314b1209edcd2c7d02a10064fc299ec6a22b3ea2. #define WUFFS_VERSION ((uint64_t)0x0000000000020000) #define WUFFS_VERSION_MAJOR ((uint64_t)0x00000000) #define WUFFS_VERSION_MINOR ((uint64_t)0x0002) #define WUFFS_VERSION_PATCH ((uint64_t)0x0000) -#define WUFFS_VERSION_EXTENSION "alpha.25" -#define WUFFS_VERSION_STRING "0.2.0-alpha.25" +#define WUFFS_VERSION_EXTENSION "alpha.26" +#define WUFFS_VERSION_STRING "0.2.0-alpha.26" // Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have // static storage. The motivation is discussed in the "ALLOW STATIC @@ -2614,8 +2614,18 @@ struct wuffs_lzw__decoder__struct { struct { uint32_t magic; + uint32_t f_lw; uint32_t f_literal_width; - uint32_t f_flush_j; + uint32_t f_clear_code; + uint32_t f_end_code; + uint32_t f_save_code; + uint32_t f_prev_code; + uint32_t f_width; + uint32_t f_bits; + uint32_t f_n_bits; + uint32_t f_output_ri; + uint32_t f_output_wi; + uint32_t f_read_from_return_value; uint8_t f_suffixes[4096][8]; uint16_t f_prefixes[4096]; uint16_t f_lm1s[4096]; @@ -2623,21 +2633,10 @@ struct wuffs_lzw__decoder__struct { struct { uint32_t coro_susp_point; - uint32_t v_literal_width; - uint32_t v_clear_code; - uint32_t v_end_code; - uint32_t v_save_code; - uint32_t v_prev_code; - uint32_t v_width; - bool v_bad; - uint32_t v_j; - uint32_t v_bits; - uint32_t v_n_bits; } c_decode[1]; struct { uint32_t coro_susp_point; - uint32_t v_i; - } c_auto_flush[1]; + } c_write_to[1]; } private_impl; #ifdef __cplusplus @@ -2855,11 +2854,15 @@ struct wuffs_gif__decoder__struct { uint32_t coro_susp_point; uint32_t v_num_palette_entries; uint32_t v_i; - uint64_t v_block_size; - bool v_need_block_size; - wuffs_base__status v_z; uint64_t scratch; } c_decode_id_part1[1]; + struct { + uint32_t coro_susp_point; + uint64_t v_block_size; + bool v_need_block_size; + wuffs_base__status v_lzw_status; + uint64_t scratch; + } c_decode_id_part2[1]; } private_impl; #ifdef __cplusplus @@ -4020,19 +4023,37 @@ wuffs_base__pixel_swizzler__copy_4_1(wuffs_base__slice_u8 dst, uint8_t* s = src.ptr; size_t n = len; - while (n--) { - uint8_t* p = dst_palette.ptr + ((size_t)(*s) * 4); - uint8_t b0 = p[0]; - uint8_t b1 = p[1]; - uint8_t b2 = p[2]; - uint8_t b3 = p[3]; - d[0] = b0; - d[1] = b1; - d[2] = b2; - d[3] = b3; - s += 1; - d += 4; + const int N = 4; + + while (n >= N) { + wuffs_base__store_u32le( + d + (0 * 4), + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4))); + wuffs_base__store_u32le( + d + (1 * 4), + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4))); + wuffs_base__store_u32le( + d + (2 * 4), + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4))); + wuffs_base__store_u32le( + d + (3 * 4), + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4))); + + s += 1 * N; + d += 4 * N; + n -= 1 * N; } + + while (n >= 1) { + wuffs_base__store_u32le( + d + (0 * 4), + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4))); + + s += 1 * 1; + d += 4 * 1; + n -= 1 * 1; + } + return len; } @@ -4186,9 +4207,10 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, return 0; } - uint32_t v_s1; - uint32_t v_s2; - wuffs_base__slice_u8 v_remaining; + uint32_t v_s1 = 0; + uint32_t v_s2 = 0; + wuffs_base__slice_u8 v_remaining = {}; + wuffs_base__slice_u8 v_p = {}; if (!self->private_impl.f_started) { self->private_impl.f_started = true; @@ -4197,14 +4219,14 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, v_s1 = ((self->private_impl.f_state) & 0xFFFF); v_s2 = ((self->private_impl.f_state) >> (32 - (16))); while (((uint64_t)(a_x.len)) > 0) { - v_remaining = ((wuffs_base__slice_u8){}); + v_remaining = wuffs_base__slice_u8__subslice_j(a_x, 0); if (((uint64_t)(a_x.len)) > 5552) { v_remaining = wuffs_base__slice_u8__subslice_i(a_x, 5552); a_x = wuffs_base__slice_u8__subslice_j(a_x, 5552); } { wuffs_base__slice_u8 i_slice_p = a_x; - wuffs_base__slice_u8 v_p = i_slice_p; + v_p = i_slice_p; v_p.len = 1; uint8_t* i_end0_p = i_slice_p.ptr + (i_slice_p.len / 8) * 8; while (v_p.ptr < i_end0_p) { @@ -5027,12 +5049,13 @@ wuffs_crc32__ieee_hasher__update(wuffs_crc32__ieee_hasher* self, return 0; } - uint32_t v_s; + uint32_t v_s = 0; + wuffs_base__slice_u8 v_p = {}; v_s = (4294967295 ^ self->private_impl.f_state); { wuffs_base__slice_u8 i_slice_p = a_x; - wuffs_base__slice_u8 v_p = i_slice_p; + v_p = i_slice_p; v_p.len = 16; uint8_t* i_end0_p = i_slice_p.ptr + (i_slice_p.len / 32) * 32; while (v_p.ptr < i_end0_p) { @@ -5285,10 +5308,10 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, } wuffs_base__status status = NULL; - wuffs_base__status v_z; - wuffs_base__slice_u8 v_written; - uint64_t v_n_copied; - uint32_t v_already_full; + wuffs_base__status v_status = NULL; + wuffs_base__slice_u8 v_written = {}; + uint64_t v_n_copied = 0; + uint32_t v_already_full = 0; uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst = NULL; @@ -5312,12 +5335,6 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode[0].coro_susp_point; if (coro_susp_point) { - v_z = NULL; - v_written = ((wuffs_base__slice_u8){}); - v_n_copied = 0; - v_already_full = 0; - } else { - v_written = ((wuffs_base__slice_u8){}); } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -5335,10 +5352,10 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, iop_a_dst = a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; } - v_z = t_0; + v_status = t_0; } - if (!wuffs_base__status__is_suspension(v_z)) { - status = v_z; + 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)) { @@ -5389,7 +5406,7 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self, ((uint32_t)((v_n_copied & 32767))) + v_already_full); } } - status = v_z; + status = v_status; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); } @@ -5424,9 +5441,10 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint32_t v_final; - uint32_t v_b0; - uint32_t v_type; + uint32_t v_final = 0; + uint32_t v_b0 = 0; + uint32_t v_type = 0; + wuffs_base__status v_status = NULL; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -5449,14 +5467,10 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, self->private_impl.c_decode_blocks[0].coro_susp_point; if (coro_susp_point) { v_final = self->private_impl.c_decode_blocks[0].v_final; - v_b0 = 0; - v_type = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - v_final = 0; label_0_continue:; while (v_final == 0) { while (self->private_impl.f_n_bits < 3) { @@ -5477,11 +5491,11 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, self->private_impl.f_bits >>= 3; self->private_impl.f_n_bits -= 3; if (v_type == 0) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); status = wuffs_deflate__decoder__decode_uncompressed(self, a_dst, a_src); if (a_src.private_impl.buf) { @@ -5493,16 +5507,23 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, } goto label_0_continue; } else if (v_type == 1) { - status = wuffs_deflate__decoder__init_fixed_huffman(self); - if (status) { - goto exit; + v_status = wuffs_deflate__decoder__init_fixed_huffman(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__error__cannot_return_a_suspension; + goto exit; + } + goto ok; } } else if (v_type == 2) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); status = wuffs_deflate__decoder__init_dynamic_huffman(self, a_src); if (a_src.private_impl.buf) { iop_a_src = a_src.private_impl.buf->data.ptr + @@ -5520,22 +5541,24 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self, a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } - status = wuffs_deflate__decoder__decode_huffman_fast(self, a_dst, a_src); + v_status = + wuffs_deflate__decoder__decode_huffman_fast(self, a_dst, a_src); if (a_src.private_impl.buf) { iop_a_src = a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } - if (status) { + if (wuffs_base__status__is_error(v_status)) { + status = v_status; goto exit; } if (self->private_impl.f_end_of_block) { goto label_0_continue; } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); status = wuffs_deflate__decoder__decode_huffman_slow(self, a_dst, a_src); if (a_src.private_impl.buf) { iop_a_src = @@ -5581,8 +5604,8 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint32_t v_length; - uint32_t v_n_copied; + uint32_t v_length = 0; + uint32_t v_n_copied = 0; uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst = NULL; @@ -5624,8 +5647,6 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self, self->private_impl.c_decode_uncompressed[0].coro_susp_point; if (coro_susp_point) { v_length = self->private_impl.c_decode_uncompressed[0].v_length; - v_n_copied = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -5718,11 +5739,9 @@ exit: static wuffs_base__status // wuffs_deflate__decoder__init_fixed_huffman(wuffs_deflate__decoder* self) { - wuffs_base__status status = NULL; + uint32_t v_i = 0; + wuffs_base__status v_status = NULL; - uint32_t v_i; - - v_i = 0; while (v_i < 144) { self->private_impl.f_code_lengths[v_i] = 8; v_i += 1; @@ -5743,17 +5762,15 @@ wuffs_deflate__decoder__init_fixed_huffman(wuffs_deflate__decoder* self) { self->private_impl.f_code_lengths[v_i] = 5; v_i += 1; } - status = wuffs_deflate__decoder__init_huff(self, 0, 0, 288, 257); - if (status) { - goto exit; + v_status = wuffs_deflate__decoder__init_huff(self, 0, 0, 288, 257); + if (wuffs_base__status__is_error(v_status)) { + return v_status; } - status = wuffs_deflate__decoder__init_huff(self, 1, 288, 320, 0); - if (status) { - goto exit; + v_status = wuffs_deflate__decoder__init_huff(self, 1, 288, 320, 0); + if (wuffs_base__status__is_error(v_status)) { + return v_status; } - goto exit; -exit: - return status; + return NULL; } // -------- func deflate.decoder.init_dynamic_huffman @@ -5763,22 +5780,23 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint32_t v_bits; - uint32_t v_n_bits; - uint32_t v_b0; - uint32_t v_n_lit; - uint32_t v_n_dist; - uint32_t v_n_clen; - uint32_t v_i; - uint32_t v_b1; - uint32_t v_mask; - uint32_t v_table_entry; - uint32_t v_table_entry_n_bits; - uint32_t v_b2; - uint32_t v_n_extra_bits; - uint8_t v_rep_symbol; - uint32_t v_rep_count; - uint32_t v_b3; + uint32_t v_bits = 0; + uint32_t v_n_bits = 0; + uint32_t v_b0 = 0; + uint32_t v_n_lit = 0; + uint32_t v_n_dist = 0; + uint32_t v_n_clen = 0; + uint32_t v_i = 0; + uint32_t v_b1 = 0; + wuffs_base__status v_status = NULL; + uint32_t v_mask = 0; + uint32_t v_table_entry = 0; + uint32_t v_table_entry_n_bits = 0; + uint32_t v_b2 = 0; + uint32_t v_n_extra_bits = 0; + uint8_t v_rep_symbol = 0; + uint32_t v_rep_count = 0; + uint32_t v_b3 = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -5802,22 +5820,16 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, if (coro_susp_point) { v_bits = self->private_impl.c_init_dynamic_huffman[0].v_bits; v_n_bits = self->private_impl.c_init_dynamic_huffman[0].v_n_bits; - v_b0 = 0; v_n_lit = self->private_impl.c_init_dynamic_huffman[0].v_n_lit; v_n_dist = self->private_impl.c_init_dynamic_huffman[0].v_n_dist; v_n_clen = self->private_impl.c_init_dynamic_huffman[0].v_n_clen; v_i = self->private_impl.c_init_dynamic_huffman[0].v_i; - v_b1 = 0; v_mask = self->private_impl.c_init_dynamic_huffman[0].v_mask; v_table_entry = self->private_impl.c_init_dynamic_huffman[0].v_table_entry; - v_table_entry_n_bits = 0; - v_b2 = 0; v_n_extra_bits = self->private_impl.c_init_dynamic_huffman[0].v_n_extra_bits; v_rep_symbol = self->private_impl.c_init_dynamic_huffman[0].v_rep_symbol; v_rep_count = self->private_impl.c_init_dynamic_huffman[0].v_rep_count; - v_b3 = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -5877,15 +5889,15 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, self->private_impl.f_code_lengths[wuffs_deflate__code_order[v_i]] = 0; v_i += 1; } - status = wuffs_deflate__decoder__init_huff(self, 0, 0, 19, 4095); - if (status) { + v_status = wuffs_deflate__decoder__init_huff(self, 0, 0, 19, 4095); + if (wuffs_base__status__is_error(v_status)) { + status = v_status; goto exit; } v_mask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1); v_i = 0; label_0_continue:; while (v_i < (v_n_lit + v_n_dist)) { - v_table_entry = 0; while (true) { v_table_entry = self->private_impl.f_huffs[0][(v_bits & v_mask)]; v_table_entry_n_bits = (v_table_entry & 15); @@ -5976,13 +5988,15 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self, status = wuffs_deflate__error__missing_end_of_block_code; goto exit; } - status = wuffs_deflate__decoder__init_huff(self, 0, 0, v_n_lit, 257); - if (status) { + v_status = wuffs_deflate__decoder__init_huff(self, 0, 0, v_n_lit, 257); + if (wuffs_base__status__is_error(v_status)) { + status = v_status; goto exit; } - status = wuffs_deflate__decoder__init_huff(self, 1, v_n_lit, - (v_n_lit + v_n_dist), 0); - if (status) { + v_status = wuffs_deflate__decoder__init_huff(self, 1, v_n_lit, + (v_n_lit + v_n_dist), 0); + if (wuffs_base__status__is_error(v_status)) { + status = v_status; goto exit; } self->private_impl.f_bits = v_bits; @@ -6028,101 +6042,79 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self, uint32_t a_n_codes0, uint32_t a_n_codes1, uint32_t a_base_symbol) { - wuffs_base__status status = NULL; + uint16_t v_counts[16] = {}; + uint32_t v_i = 0; + uint32_t v_remaining = 0; + uint16_t v_offsets[16] = {}; + uint32_t v_n_symbols = 0; + uint32_t v_count = 0; + uint16_t v_symbols[320] = {}; + uint32_t v_min_cl = 0; + uint32_t v_max_cl = 0; + uint32_t v_initial_high_bits = 0; + uint32_t v_prev_cl = 0; + uint32_t v_prev_redirect_key = 0; + uint32_t v_top = 0; + uint32_t v_next_top = 0; + uint32_t v_code = 0; + uint32_t v_key = 0; + uint32_t v_value = 0; + uint32_t v_cl = 0; + uint32_t v_redirect_key = 0; + uint32_t v_j = 0; + uint32_t v_reversed_key = 0; + uint32_t v_symbol = 0; + uint32_t v_high_bits = 0; + uint32_t v_delta = 0; - uint16_t v_counts[16]; - uint32_t v_i; - uint32_t v_remaining; - uint16_t v_offsets[16]; - uint32_t v_n_symbols; - uint32_t v_count; - uint16_t v_symbols[320]; - uint32_t v_min_cl; - uint32_t v_max_cl; - uint32_t v_initial_high_bits; - uint32_t v_prev_cl; - uint32_t v_prev_redirect_key; - uint32_t v_top; - uint32_t v_next_top; - uint32_t v_code; - uint32_t v_key; - uint32_t v_value; - uint32_t v_cl; - uint32_t v_tmp; - uint32_t v_redirect_key; - uint32_t v_j; - uint32_t v_reversed_key; - uint32_t v_symbol; - uint32_t v_high_bits; - uint32_t v_delta; - - memset(v_counts, 0, sizeof(v_counts)); v_i = a_n_codes0; while (v_i < a_n_codes1) { if (v_counts[self->private_impl.f_code_lengths[v_i]] >= 320) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_counts[self->private_impl.f_code_lengths[v_i]] += 1; v_i += 1; } if ((((uint32_t)(v_counts[0])) + a_n_codes0) == a_n_codes1) { - status = wuffs_deflate__error__no_huffman_codes; - goto exit; + return wuffs_deflate__error__no_huffman_codes; } v_remaining = 1; v_i = 1; while (v_i <= 15) { if (v_remaining > 1073741824) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_remaining <<= 1; if (v_remaining < ((uint32_t)(v_counts[v_i]))) { - status = wuffs_deflate__error__bad_huffman_code_over_subscribed; - goto exit; + return wuffs_deflate__error__bad_huffman_code_over_subscribed; } v_remaining -= ((uint32_t)(v_counts[v_i])); v_i += 1; } if (v_remaining != 0) { - status = wuffs_deflate__error__bad_huffman_code_under_subscribed; - goto exit; + return wuffs_deflate__error__bad_huffman_code_under_subscribed; } - memset(v_offsets, 0, sizeof(v_offsets)); - v_n_symbols = 0; v_i = 1; while (v_i <= 15) { v_offsets[v_i] = ((uint16_t)(v_n_symbols)); v_count = ((uint32_t)(v_counts[v_i])); if (v_n_symbols > (320 - v_count)) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_n_symbols = (v_n_symbols + v_count); v_i += 1; } if (v_n_symbols > 288) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } - memset(v_symbols, 0, sizeof(v_symbols)); v_i = a_n_codes0; while (v_i < a_n_codes1) { if (v_i < a_n_codes0) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } if (self->private_impl.f_code_lengths[v_i] != 0) { if (v_offsets[self->private_impl.f_code_lengths[v_i]] >= 320) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_symbols[v_offsets[self->private_impl.f_code_lengths[v_i]]] = ((uint16_t)((v_i - a_n_codes0))); @@ -6136,8 +6128,7 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self, goto label_0_break; } if (v_min_cl >= 9) { - status = wuffs_deflate__error__bad_huffman_minimum_code_length; - goto exit; + return wuffs_deflate__error__bad_huffman_minimum_code_length; } v_min_cl += 1; } @@ -6148,8 +6139,7 @@ label_0_break:; goto label_1_break; } if (v_max_cl <= 1) { - status = wuffs_deflate__error__no_huffman_codes; - goto exit; + return wuffs_deflate__error__no_huffman_codes; } v_max_cl -= 1; } @@ -6162,14 +6152,10 @@ label_1_break:; v_i = 0; if ((v_n_symbols != ((uint32_t)(v_offsets[v_max_cl]))) || (v_n_symbols != ((uint32_t)(v_offsets[15])))) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } if ((a_n_codes0 + ((uint32_t)(v_symbols[0]))) >= 320) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_initial_high_bits = 512; if (v_max_cl < 9) { @@ -6185,27 +6171,22 @@ label_1_break:; v_value = 0; while (true) { if ((a_n_codes0 + ((uint32_t)(v_symbols[v_i]))) >= 320) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_cl = ((uint32_t)(self->private_impl.f_code_lengths[( a_n_codes0 + ((uint32_t)(v_symbols[v_i])))])); if (v_cl > v_prev_cl) { v_code <<= (v_cl - v_prev_cl); if (v_code >= 32768) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } } v_prev_cl = v_cl; v_key = v_code; if (v_cl > 9) { - v_tmp = (v_cl - 9); - v_cl = v_tmp; - v_redirect_key = ((v_key >> v_tmp) & 511); - v_key = ((v_key)&WUFFS_BASE__LOW_BITS_MASK__U32(v_tmp)); + v_cl -= 9; + v_redirect_key = ((v_key >> v_cl) & 511); + v_key = ((v_key)&WUFFS_BASE__LOW_BITS_MASK__U32(v_cl)); if (v_prev_redirect_key != v_redirect_key) { v_prev_redirect_key = v_redirect_key; v_remaining = (((uint32_t)(1)) << v_cl); @@ -6216,39 +6197,31 @@ label_1_break:; } v_remaining -= ((uint32_t)(v_counts[v_j])); if (v_remaining > 1073741824) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_remaining <<= 1; v_j += 1; } label_2_break:; if ((v_j <= 9) || (15 < v_j)) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } - v_tmp = (v_j - 9); - v_initial_high_bits = (((uint32_t)(1)) << v_tmp); + v_j -= 9; + v_initial_high_bits = (((uint32_t)(1)) << v_j); v_top = v_next_top; - if ((v_top + (((uint32_t)(1)) << v_tmp)) > 1234) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + if ((v_top + (((uint32_t)(1)) << v_j)) > 1234) { + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } - v_next_top = (v_top + (((uint32_t)(1)) << v_tmp)); + v_next_top = (v_top + (((uint32_t)(1)) << v_j)); v_redirect_key = (((uint32_t)(wuffs_deflate__reverse8[(v_redirect_key >> 1)])) | ((v_redirect_key & 1) << 8)); self->private_impl.f_huffs[a_which][v_redirect_key] = - (268435465 | (v_top << 8) | (v_tmp << 4)); + (268435465 | (v_top << 8) | (v_j << 4)); } } if ((v_key >= 512) || (v_counts[v_prev_cl] <= 0)) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_counts[v_prev_cl] -= 1; v_reversed_key = (((uint32_t)(wuffs_deflate__reverse8[(v_key >> 1)])) | @@ -6267,18 +6240,14 @@ label_1_break:; v_value = (wuffs_deflate__dcode_magic_numbers[(v_symbol & 31)] | v_cl); } } else { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } v_high_bits = v_initial_high_bits; v_delta = (((uint32_t)(1)) << v_cl); while (v_high_bits >= v_delta) { v_high_bits -= v_delta; if ((v_top + ((v_high_bits | v_reversed_key) & 511)) >= 1234) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } self->private_impl .f_huffs[a_which][(v_top + ((v_high_bits | v_reversed_key) & 511))] = @@ -6290,15 +6259,11 @@ label_1_break:; } v_code += 1; if (v_code >= 32768) { - status = - wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; - goto exit; + return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state; } } label_3_break:; - goto exit; -exit: - return status; + return NULL; } // -------- func deflate.decoder.decode_huffman_fast @@ -6309,19 +6274,19 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint32_t v_bits; - uint32_t v_n_bits; - uint32_t v_table_entry; - uint32_t v_table_entry_n_bits; - uint32_t v_lmask; - uint32_t v_dmask; - uint32_t v_redir_top; - uint32_t v_redir_mask; - uint32_t v_length; - uint32_t v_dist_minus_1; - uint32_t v_n_copied; - uint32_t v_hlen; - uint32_t v_hdist; + uint32_t v_bits = 0; + uint32_t v_n_bits = 0; + uint32_t v_table_entry = 0; + uint32_t v_table_entry_n_bits = 0; + uint32_t v_lmask = 0; + uint32_t v_dmask = 0; + uint32_t v_redir_top = 0; + uint32_t v_redir_mask = 0; + uint32_t v_length = 0; + uint32_t v_dist_minus_1 = 0; + uint32_t v_n_copied = 0; + uint32_t v_hlen = 0; + uint32_t v_hdist = 0; uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst = NULL; @@ -6366,8 +6331,6 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self, } v_bits = self->private_impl.f_bits; v_n_bits = self->private_impl.f_n_bits; - v_table_entry = 0; - v_table_entry_n_bits = 0; v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1); v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1); label_0_continue:; @@ -6626,25 +6589,25 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint32_t v_bits; - uint32_t v_n_bits; - uint32_t v_table_entry; - uint32_t v_table_entry_n_bits; - uint32_t v_lmask; - uint32_t v_dmask; - uint32_t v_b0; - uint32_t v_redir_top; - uint32_t v_redir_mask; - uint32_t v_b1; - uint32_t v_length; - uint32_t v_b2; - uint32_t v_b3; - uint32_t v_b4; - uint32_t v_dist_minus_1; - uint32_t v_b5; - uint32_t v_n_copied; - uint32_t v_hlen; - uint32_t v_hdist; + uint32_t v_bits = 0; + uint32_t v_n_bits = 0; + uint32_t v_table_entry = 0; + uint32_t v_table_entry_n_bits = 0; + uint32_t v_lmask = 0; + uint32_t v_dmask = 0; + uint32_t v_b0 = 0; + uint32_t v_redir_top = 0; + uint32_t v_redir_mask = 0; + uint32_t v_b1 = 0; + uint32_t v_length = 0; + uint32_t v_b2 = 0; + uint32_t v_b3 = 0; + uint32_t v_b4 = 0; + uint32_t v_dist_minus_1 = 0; + uint32_t v_b5 = 0; + uint32_t v_n_copied = 0; + uint32_t v_hlen = 0; + uint32_t v_hdist = 0; uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst = NULL; @@ -6692,20 +6655,12 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, self->private_impl.c_decode_huffman_slow[0].v_table_entry_n_bits; v_lmask = self->private_impl.c_decode_huffman_slow[0].v_lmask; v_dmask = self->private_impl.c_decode_huffman_slow[0].v_dmask; - v_b0 = 0; v_redir_top = self->private_impl.c_decode_huffman_slow[0].v_redir_top; v_redir_mask = self->private_impl.c_decode_huffman_slow[0].v_redir_mask; - v_b1 = 0; v_length = self->private_impl.c_decode_huffman_slow[0].v_length; - v_b2 = 0; - v_b3 = 0; - v_b4 = 0; v_dist_minus_1 = self->private_impl.c_decode_huffman_slow[0].v_dist_minus_1; - v_b5 = 0; - v_n_copied = 0; v_hlen = self->private_impl.c_decode_huffman_slow[0].v_hlen; v_hdist = self->private_impl.c_decode_huffman_slow[0].v_hdist; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -6717,8 +6672,6 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, } v_bits = self->private_impl.f_bits; v_n_bits = self->private_impl.f_n_bits; - v_table_entry = 0; - v_table_entry_n_bits = 0; v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1); v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1); label_0_continue:; @@ -6928,11 +6881,9 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, v_bits >>= v_table_entry_n_bits; v_n_bits -= v_table_entry_n_bits; } - v_n_copied = 0; while (true) { if (((uint64_t)((v_dist_minus_1 + 1))) > ((uint64_t)(iop_a_dst - a_dst.private_impl.mark))) { - v_hlen = 0; v_hdist = ((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) - ((uint64_t)(iop_a_dst - a_dst.private_impl.mark))))); @@ -7073,9 +7024,13 @@ const char* wuffs_lzw__error__internal_error_inconsistent_i_o = // ---------------- Private Function Prototypes +static wuffs_base__empty_struct // +wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, + wuffs_base__io_reader a_src); + static wuffs_base__status // -wuffs_lzw__decoder__auto_flush(wuffs_lzw__decoder* self, - wuffs_base__io_writer a_dst); +wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, + wuffs_base__io_writer a_dst); // ---------------- Initializer Implementations @@ -7122,7 +7077,7 @@ wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) { return ((wuffs_base__empty_struct){}); } - self->private_impl.f_literal_width = a_lw; + self->private_impl.f_lw = a_lw; return ((wuffs_base__empty_struct){}); } @@ -7142,23 +7097,99 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, } wuffs_base__status status = NULL; - uint32_t v_literal_width; - uint32_t v_clear_code; - uint32_t v_end_code; - uint32_t v_save_code; - uint32_t v_prev_code; - uint32_t v_width; - bool v_bad; - uint32_t v_j; - uint32_t v_bits; - uint32_t v_n_bits; - uint32_t v_code; - uint32_t v_c; - uint32_t v_o; - uint32_t v_steps; - uint8_t v_first_byte; - uint16_t v_lm1_b; - uint16_t v_lm1_a; + uint32_t v_i = 0; + + uint32_t coro_susp_point = self->private_impl.c_decode[0].coro_susp_point; + if (coro_susp_point) { + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + self->private_impl.f_literal_width = 8; + if (self->private_impl.f_lw >= 2) { + self->private_impl.f_literal_width = self->private_impl.f_lw; + } + self->private_impl.f_clear_code = + (((uint32_t)(1)) << self->private_impl.f_literal_width); + self->private_impl.f_end_code = (self->private_impl.f_clear_code + 1); + self->private_impl.f_save_code = self->private_impl.f_end_code; + self->private_impl.f_prev_code = self->private_impl.f_end_code; + self->private_impl.f_width = (self->private_impl.f_literal_width + 1); + self->private_impl.f_bits = 0; + self->private_impl.f_n_bits = 0; + self->private_impl.f_output_ri = 0; + self->private_impl.f_output_wi = 0; + v_i = 0; + while (v_i < self->private_impl.f_clear_code) { + self->private_impl.f_lm1s[v_i] = 0; + self->private_impl.f_suffixes[v_i][0] = ((uint8_t)(v_i)); + v_i += 1; + } + label_0_continue:; + while (true) { + wuffs_lzw__decoder__read_from(self, a_src); + if (self->private_impl.f_output_wi > 0) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_lzw__decoder__write_to(self, a_dst); + if (status) { + goto suspend; + } + } + if (self->private_impl.f_read_from_return_value == 0) { + goto label_0_break; + } else if (self->private_impl.f_read_from_return_value == 1) { + goto label_0_continue; + } else if (self->private_impl.f_read_from_return_value == 2) { + status = wuffs_base__suspension__short_read; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); + } else if (self->private_impl.f_read_from_return_value == 3) { + status = wuffs_lzw__error__bad_code; + goto exit; + } else { + status = wuffs_lzw__error__internal_error_inconsistent_i_o; + goto exit; + } + } + label_0_break:; + + goto ok; + ok: + self->private_impl.c_decode[0].coro_susp_point = 0; + goto exit; + } + + goto suspend; +suspend: + self->private_impl.c_decode[0].coro_susp_point = coro_susp_point; + + goto exit; +exit: + if (wuffs_base__status__is_error(status)) { + self->private_impl.magic = WUFFS_BASE__DISABLED; + } + return status; +} + +// -------- func lzw.decoder.read_from + +static wuffs_base__empty_struct // +wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, + wuffs_base__io_reader a_src) { + uint32_t v_clear_code = 0; + uint32_t v_end_code = 0; + uint32_t v_save_code = 0; + uint32_t v_prev_code = 0; + uint32_t v_width = 0; + uint32_t v_bits = 0; + uint32_t v_n_bits = 0; + uint32_t v_output_wi = 0; + uint32_t v_code = 0; + uint32_t v_c = 0; + uint32_t v_o = 0; + uint32_t v_steps = 0; + uint8_t v_first_byte = 0; + uint16_t v_lm1_b = 0; + uint16_t v_lm1_a = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -7177,259 +7208,176 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, io1_a_src = a_src.private_impl.limit; } - uint32_t coro_susp_point = self->private_impl.c_decode[0].coro_susp_point; - if (coro_susp_point) { - v_literal_width = self->private_impl.c_decode[0].v_literal_width; - v_clear_code = self->private_impl.c_decode[0].v_clear_code; - v_end_code = self->private_impl.c_decode[0].v_end_code; - v_save_code = self->private_impl.c_decode[0].v_save_code; - v_prev_code = self->private_impl.c_decode[0].v_prev_code; - v_width = self->private_impl.c_decode[0].v_width; - v_bad = self->private_impl.c_decode[0].v_bad; - v_j = self->private_impl.c_decode[0].v_j; - v_bits = self->private_impl.c_decode[0].v_bits; - v_n_bits = self->private_impl.c_decode[0].v_n_bits; - v_code = 0; - v_c = 0; - v_o = 0; - v_steps = 0; - v_first_byte = 0; - v_lm1_b = 0; - v_lm1_a = 0; - } else { - v_bad = false; - } - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - v_literal_width = 8; - if (self->private_impl.f_literal_width >= 2) { - v_literal_width = self->private_impl.f_literal_width; - } - v_clear_code = (((uint32_t)(1)) << v_literal_width); - v_end_code = (v_clear_code + 1); - v_save_code = v_end_code; - v_prev_code = v_end_code; - v_width = (v_literal_width + 1); - v_bad = 0; - v_j = 0; - while (v_j < v_clear_code) { - self->private_impl.f_lm1s[v_j] = 0; - self->private_impl.f_suffixes[v_j][0] = ((uint8_t)(v_j)); - v_j += 1; - } - v_j = 0; - v_bits = 0; - v_n_bits = 0; - while (true) { - if (v_n_bits < v_width) { - if (((uint64_t)(io1_a_src - iop_a_src)) >= 4) { - v_bits |= - (((uint32_t)(wuffs_base__load_u32le(iop_a_src))) << v_n_bits); - (iop_a_src += ((31 - v_n_bits) >> 3), - wuffs_base__return_empty_struct()); - v_n_bits |= 24; + v_clear_code = self->private_impl.f_clear_code; + v_end_code = self->private_impl.f_end_code; + v_save_code = self->private_impl.f_save_code; + v_prev_code = self->private_impl.f_prev_code; + v_width = self->private_impl.f_width; + v_bits = self->private_impl.f_bits; + v_n_bits = self->private_impl.f_n_bits; + v_output_wi = self->private_impl.f_output_wi; + while (true) { + if (v_n_bits < v_width) { + if (((uint64_t)(io1_a_src - iop_a_src)) >= 4) { + v_bits |= (wuffs_base__load_u32le(iop_a_src) << v_n_bits); + (iop_a_src += ((31 - v_n_bits) >> 3), + wuffs_base__return_empty_struct()); + v_n_bits |= 24; + } else if (((uint64_t)(io1_a_src - iop_a_src)) <= 0) { + self->private_impl.f_read_from_return_value = 2; + goto label_0_break; + } else { + v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + (iop_a_src += 1, wuffs_base__return_empty_struct()); + v_n_bits += 8; + if (v_n_bits >= v_width) { + } else if (((uint64_t)(io1_a_src - iop_a_src)) <= 0) { + self->private_impl.f_read_from_return_value = 2; + goto label_0_break; } else { - while (true) { - while (((uint64_t)(io1_a_src - iop_a_src)) <= 0) { - if (v_j > 0) { - self->private_impl.f_flush_j = v_j; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - status = wuffs_lzw__decoder__auto_flush(self, a_dst); - if (status) { - goto suspend; - } - v_j = 0; - } else { - status = wuffs_base__suspension__short_read; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); - } - } - v_bits |= - (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); - (iop_a_src += 1, wuffs_base__return_empty_struct()); - v_n_bits += 8; - if (v_n_bits >= v_width) { - goto label_0_break; - } + v_bits |= + (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + (iop_a_src += 1, wuffs_base__return_empty_struct()); + v_n_bits += 8; + if (v_n_bits < v_width) { + self->private_impl.f_read_from_return_value = 4; + goto label_0_break; } - label_0_break:; } } - v_code = ((v_bits)&WUFFS_BASE__LOW_BITS_MASK__U32(v_width)); - v_bits >>= v_width; - v_n_bits -= v_width; - if (v_code < v_clear_code) { - self->private_impl.f_output[v_j] = ((uint8_t)(v_code)); - v_j = ((v_j + 1) & 8191); - if (v_save_code <= 4095) { - v_lm1_a = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095); - self->private_impl.f_lm1s[v_save_code] = v_lm1_a; - if ((v_lm1_a % 8) != 0) { - self->private_impl.f_prefixes[v_save_code] = - self->private_impl.f_prefixes[v_prev_code]; - memcpy(self->private_impl.f_suffixes[v_save_code], - self->private_impl.f_suffixes[v_prev_code], - sizeof(self->private_impl.f_suffixes[v_save_code])); - self->private_impl.f_suffixes[v_save_code][(v_lm1_a % 8)] = - ((uint8_t)(v_code)); - } else { - self->private_impl.f_prefixes[v_save_code] = - ((uint16_t)(v_prev_code)); - self->private_impl.f_suffixes[v_save_code][0] = ((uint8_t)(v_code)); - } - v_save_code += 1; - if ((v_save_code == (((uint32_t)(1)) << v_width)) && (v_width < 12)) { - v_width += 1; - } - v_prev_code = v_code; + } + v_code = ((v_bits)&WUFFS_BASE__LOW_BITS_MASK__U32(v_width)); + v_bits >>= v_width; + v_n_bits -= v_width; + if (v_code < v_clear_code) { + self->private_impl.f_output[v_output_wi] = ((uint8_t)(v_code)); + v_output_wi = ((v_output_wi + 1) & 8191); + if (v_save_code <= 4095) { + v_lm1_a = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095); + self->private_impl.f_lm1s[v_save_code] = v_lm1_a; + if ((v_lm1_a % 8) != 0) { + self->private_impl.f_prefixes[v_save_code] = + self->private_impl.f_prefixes[v_prev_code]; + memcpy(self->private_impl.f_suffixes[v_save_code], + self->private_impl.f_suffixes[v_prev_code], + sizeof(self->private_impl.f_suffixes[v_save_code])); + self->private_impl.f_suffixes[v_save_code][(v_lm1_a % 8)] = + ((uint8_t)(v_code)); + } else { + self->private_impl.f_prefixes[v_save_code] = + ((uint16_t)(v_prev_code)); + self->private_impl.f_suffixes[v_save_code][0] = ((uint8_t)(v_code)); } - } else if (v_code <= v_end_code) { - if (v_code == v_end_code) { + v_save_code += 1; + if ((v_save_code == (((uint32_t)(1)) << v_width)) && (v_width < 12)) { + v_width += 1; + } + v_prev_code = v_code; + } + } else if (v_code <= v_end_code) { + if (v_code == v_end_code) { + self->private_impl.f_read_from_return_value = 0; + goto label_0_break; + } + v_save_code = v_end_code; + v_prev_code = v_end_code; + v_width = (self->private_impl.f_literal_width + 1); + } else if (v_code <= v_save_code) { + v_c = v_code; + if (v_code == v_save_code) { + v_c = v_prev_code; + } + v_o = ((v_output_wi + + (((uint32_t)(self->private_impl.f_lm1s[v_c])) & 4294967288)) & + 8191); + v_output_wi = + ((v_output_wi + 1 + ((uint32_t)(self->private_impl.f_lm1s[v_c]))) & + 8191); + v_steps = (((uint32_t)(self->private_impl.f_lm1s[v_c])) >> 3); + while (true) { + memcpy((self->private_impl.f_output) + (v_o), + (self->private_impl.f_suffixes[v_c]), 8); + if (v_steps <= 0) { goto label_1_break; } - v_save_code = v_end_code; - v_prev_code = v_end_code; - v_width = (v_literal_width + 1); - } else if (v_code <= v_save_code) { - v_c = v_code; - if (v_code == v_save_code) { - v_c = v_prev_code; - } - v_o = ((v_j + - (((uint32_t)(self->private_impl.f_lm1s[v_c])) & 4294967288)) & - 8191); - v_j = ((v_j + 1 + ((uint32_t)(self->private_impl.f_lm1s[v_c]))) & 8191); - v_steps = (((uint32_t)(self->private_impl.f_lm1s[v_c])) >> 3); - while (true) { - memcpy((self->private_impl.f_output) + (v_o), - (self->private_impl.f_suffixes[v_c]), 8); - if (v_steps <= 0) { - goto label_2_break; - } - v_steps -= 1; - v_o = ((v_o - 8) & 8191); - v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c])); - } - label_2_break:; - v_first_byte = self->private_impl.f_suffixes[v_c][0]; - if (v_code == v_save_code) { - self->private_impl.f_output[v_j] = v_first_byte; - v_j = ((v_j + 1) & 8191); - } - if (v_save_code <= 4095) { - v_lm1_b = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095); - self->private_impl.f_lm1s[v_save_code] = v_lm1_b; - if ((v_lm1_b % 8) != 0) { - self->private_impl.f_prefixes[v_save_code] = - self->private_impl.f_prefixes[v_prev_code]; - memcpy(self->private_impl.f_suffixes[v_save_code], - self->private_impl.f_suffixes[v_prev_code], - sizeof(self->private_impl.f_suffixes[v_save_code])); - self->private_impl.f_suffixes[v_save_code][(v_lm1_b % 8)] = - v_first_byte; - } else { - self->private_impl.f_prefixes[v_save_code] = - ((uint16_t)(v_prev_code)); - self->private_impl.f_suffixes[v_save_code][0] = - ((uint8_t)(v_first_byte)); - } - v_save_code += 1; - if ((v_save_code == (((uint32_t)(1)) << v_width)) && (v_width < 12)) { - v_width += 1; - } - v_prev_code = v_code; - } - } else { - v_bad = true; - goto label_1_break; + v_steps -= 1; + v_o = ((v_o - 8) & 8191); + v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c])); } - if (v_j > 4095) { - while (v_n_bits >= 8) { - v_n_bits -= 8; - if (iop_a_src > io0_a_src) { - (iop_a_src--, wuffs_base__return_empty_struct()); - } else { - status = wuffs_lzw__error__internal_error_inconsistent_i_o; - goto exit; - } - } - v_bits = ((v_bits)&WUFFS_BASE__LOW_BITS_MASK__U32(v_n_bits)); - self->private_impl.f_flush_j = v_j; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - status = wuffs_lzw__decoder__auto_flush(self, a_dst); - if (status) { - goto suspend; - } - v_j = 0; + label_1_break:; + v_first_byte = self->private_impl.f_suffixes[v_c][0]; + if (v_code == v_save_code) { + self->private_impl.f_output[v_output_wi] = v_first_byte; + v_output_wi = ((v_output_wi + 1) & 8191); } + if (v_save_code <= 4095) { + v_lm1_b = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095); + self->private_impl.f_lm1s[v_save_code] = v_lm1_b; + if ((v_lm1_b % 8) != 0) { + self->private_impl.f_prefixes[v_save_code] = + self->private_impl.f_prefixes[v_prev_code]; + memcpy(self->private_impl.f_suffixes[v_save_code], + self->private_impl.f_suffixes[v_prev_code], + sizeof(self->private_impl.f_suffixes[v_save_code])); + self->private_impl.f_suffixes[v_save_code][(v_lm1_b % 8)] = + v_first_byte; + } else { + self->private_impl.f_prefixes[v_save_code] = + ((uint16_t)(v_prev_code)); + self->private_impl.f_suffixes[v_save_code][0] = + ((uint8_t)(v_first_byte)); + } + v_save_code += 1; + if ((v_save_code == (((uint32_t)(1)) << v_width)) && (v_width < 12)) { + v_width += 1; + } + v_prev_code = v_code; + } + } else { + self->private_impl.f_read_from_return_value = 3; + goto label_0_break; } - label_1_break:; + if (v_output_wi > 4095) { + self->private_impl.f_read_from_return_value = 1; + goto label_0_break; + } + } +label_0_break:; + if (self->private_impl.f_read_from_return_value != 2) { while (v_n_bits >= 8) { v_n_bits -= 8; if (iop_a_src > io0_a_src) { (iop_a_src--, wuffs_base__return_empty_struct()); } else { - status = wuffs_lzw__error__internal_error_inconsistent_i_o; - goto exit; + self->private_impl.f_read_from_return_value = 4; + goto label_2_break; } } - if (v_j > 0) { - self->private_impl.f_flush_j = v_j; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); - status = wuffs_lzw__decoder__auto_flush(self, a_dst); - if (status) { - goto suspend; - } - } - if (v_bad) { - status = wuffs_lzw__error__bad_code; - goto exit; - } - - goto ok; - ok: - self->private_impl.c_decode[0].coro_susp_point = 0; - goto exit; + label_2_break:; } - - goto suspend; -suspend: - self->private_impl.c_decode[0].coro_susp_point = coro_susp_point; - self->private_impl.c_decode[0].v_literal_width = v_literal_width; - self->private_impl.c_decode[0].v_clear_code = v_clear_code; - self->private_impl.c_decode[0].v_end_code = v_end_code; - self->private_impl.c_decode[0].v_save_code = v_save_code; - self->private_impl.c_decode[0].v_prev_code = v_prev_code; - self->private_impl.c_decode[0].v_width = v_width; - self->private_impl.c_decode[0].v_bad = v_bad; - self->private_impl.c_decode[0].v_j = v_j; - self->private_impl.c_decode[0].v_bits = v_bits; - self->private_impl.c_decode[0].v_n_bits = v_n_bits; - - goto exit; -exit: + self->private_impl.f_save_code = v_save_code; + self->private_impl.f_prev_code = v_prev_code; + self->private_impl.f_width = v_width; + self->private_impl.f_bits = v_bits; + self->private_impl.f_n_bits = v_n_bits; + self->private_impl.f_output_wi = v_output_wi; if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } - if (wuffs_base__status__is_error(status)) { - self->private_impl.magic = WUFFS_BASE__DISABLED; - } - return status; + return ((wuffs_base__empty_struct){}); } -// -------- func lzw.decoder.auto_flush +// -------- func lzw.decoder.write_to static wuffs_base__status // -wuffs_lzw__decoder__auto_flush(wuffs_lzw__decoder* self, - wuffs_base__io_writer a_dst) { +wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, + wuffs_base__io_writer a_dst) { wuffs_base__status status = NULL; - uint32_t v_i; - wuffs_base__slice_u8 v_s; - uint64_t v_n; + wuffs_base__slice_u8 v_s = {}; + uint64_t v_n = 0; uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst = NULL; @@ -7451,20 +7399,14 @@ wuffs_lzw__decoder__auto_flush(wuffs_lzw__decoder* self, io1_a_dst = a_dst.private_impl.limit; } - uint32_t coro_susp_point = self->private_impl.c_auto_flush[0].coro_susp_point; + uint32_t coro_susp_point = self->private_impl.c_write_to[0].coro_susp_point; if (coro_susp_point) { - v_i = self->private_impl.c_auto_flush[0].v_i; - v_s = ((wuffs_base__slice_u8){}); - v_n = 0; - } else { - v_s = ((wuffs_base__slice_u8){}); } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - v_i = 0; - while (self->private_impl.f_flush_j > 0) { - if (v_i > self->private_impl.f_flush_j) { + while (self->private_impl.f_output_wi > 0) { + if (self->private_impl.f_output_ri > self->private_impl.f_output_wi) { status = wuffs_lzw__error__internal_error_inconsistent_i_o; goto exit; } @@ -7473,27 +7415,30 @@ wuffs_lzw__decoder__auto_flush(wuffs_lzw__decoder* self, .ptr = self->private_impl.f_output, .len = 8199, }), - v_i, self->private_impl.f_flush_j); + self->private_impl.f_output_ri, self->private_impl.f_output_wi); v_n = wuffs_base__io_writer__copy_from_slice(&iop_a_dst, io1_a_dst, v_s); if (v_n == ((uint64_t)(v_s.len))) { + self->private_impl.f_output_ri = 0; + self->private_impl.f_output_wi = 0; status = NULL; goto ok; } - v_i = ((v_i + ((uint32_t)((v_n & 8191)))) & 8191); + self->private_impl.f_output_ri = + ((self->private_impl.f_output_ri + ((uint32_t)((v_n & 4294967295)))) & + 8191); status = wuffs_base__suspension__short_write; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); } goto ok; ok: - self->private_impl.c_auto_flush[0].coro_susp_point = 0; + self->private_impl.c_write_to[0].coro_susp_point = 0; goto exit; } goto suspend; suspend: - self->private_impl.c_auto_flush[0].coro_susp_point = coro_susp_point; - self->private_impl.c_auto_flush[0].v_i = v_i; + self->private_impl.c_write_to[0].coro_susp_point = coro_susp_point; goto exit; exit: @@ -7516,14 +7461,18 @@ wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self) { return ((wuffs_base__slice_u8){}); } - wuffs_base__slice_u8 v_s; + wuffs_base__slice_u8 v_s = {}; - v_s = wuffs_base__slice_u8__subslice_j(((wuffs_base__slice_u8){ - .ptr = self->private_impl.f_output, - .len = 8199, - }), - self->private_impl.f_flush_j); - self->private_impl.f_flush_j = 0; + if (self->private_impl.f_output_ri <= self->private_impl.f_output_wi) { + v_s = wuffs_base__slice_u8__subslice_ij( + ((wuffs_base__slice_u8){ + .ptr = self->private_impl.f_output, + .len = 8199, + }), + self->private_impl.f_output_ri, self->private_impl.f_output_wi); + } + self->private_impl.f_output_ri = 0; + self->private_impl.f_output_wi = 0; return v_s; } @@ -7607,6 +7556,11 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, static wuffs_base__status // wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__io_reader a_src); + +static wuffs_base__status // +wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, wuffs_base__pixel_buffer* a_dst, wuffs_base__io_reader a_src, wuffs_base__slice_u8 a_workbuf); @@ -7670,14 +7624,11 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self, } wuffs_base__status status = NULL; - bool v_ffio; + bool v_ffio = false; uint32_t coro_susp_point = self->private_impl.c_decode_image_config[0].coro_susp_point; if (coro_susp_point) { - v_ffio = false; - } else { - v_ffio = false; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -7830,11 +7781,9 @@ wuffs_gif__decoder__restart_frame(wuffs_gif__decoder* self, ? wuffs_base__error__disabled_by_previous_error : wuffs_base__error__check_wuffs_version_missing; } - wuffs_base__status status = NULL; if (self->private_impl.f_call_sequence == 0) { - status = wuffs_base__error__bad_call_sequence; - goto exit; + return wuffs_base__error__bad_call_sequence; } self->private_impl.f_end_of_data = false; self->private_impl.f_restarted = true; @@ -7842,12 +7791,7 @@ wuffs_gif__decoder__restart_frame(wuffs_gif__decoder* self, self->private_impl.f_num_decoded_frame_configs_value = a_index; self->private_impl.f_num_decoded_frames_value = a_index; wuffs_gif__decoder__reset_gc(self); - goto exit; -exit: - if (wuffs_base__status__is_error(status)) { - self->private_impl.magic = WUFFS_BASE__DISABLED; - } - return status; + return NULL; } // -------- func gif.decoder.decode_frame_config @@ -7866,13 +7810,11 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self, } wuffs_base__status status = NULL; - uint8_t v_blend; + uint8_t v_blend = 0; uint32_t coro_susp_point = self->private_impl.c_decode_frame_config[0].coro_susp_point; if (coro_susp_point) { - v_blend = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -7954,7 +7896,7 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_flags; + uint8_t v_flags = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -7975,8 +7917,6 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_skip_frame[0].coro_susp_point; if (coro_susp_point) { - v_flags = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -7991,10 +7931,9 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self, v_flags = t_0; } if ((v_flags & 128) != 0) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); self->private_impl.c_skip_frame[0].scratch = (((uint32_t)(3)) << (1 + (v_flags & 7))); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (self->private_impl.c_skip_frame[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { self->private_impl.c_skip_frame[0].scratch -= io1_a_src - iop_a_src; @@ -8004,17 +7943,17 @@ wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self, } iop_a_src += self->private_impl.c_skip_frame[0].scratch; } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; goto suspend; } iop_a_src++; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); status = wuffs_gif__decoder__skip_blocks(self, a_src); if (a_src.private_impl.buf) { iop_a_src = @@ -8072,7 +8011,6 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode_frame[0].coro_susp_point; if (coro_susp_point) { - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -8085,7 +8023,12 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, } } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - status = wuffs_gif__decoder__decode_id_part1(self, a_dst, a_src, a_workbuf); + status = wuffs_gif__decoder__decode_id_part1(self, a_dst, a_src); + if (status) { + goto suspend; + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_gif__decoder__decode_id_part2(self, a_dst, a_src, a_workbuf); if (status) { goto suspend; } @@ -8131,7 +8074,7 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_block_type; + uint8_t v_block_type = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -8153,8 +8096,6 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode_up_to_id_part1[0].coro_susp_point; if (coro_susp_point) { - v_block_type = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -8188,11 +8129,11 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, v_block_type = t_0; } if (v_block_type == 33) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); status = wuffs_gif__decoder__decode_extension(self, a_src); if (a_src.private_impl.buf) { iop_a_src = a_src.private_impl.buf->data.ptr + @@ -8202,11 +8143,11 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, goto suspend; } } else if (v_block_type == 44) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); status = wuffs_gif__decoder__decode_id_part0(self, a_src); if (a_src.private_impl.buf) { iop_a_src = a_src.private_impl.buf->data.ptr + @@ -8254,8 +8195,8 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_c[6]; - uint32_t v_i; + uint8_t v_c[6] = {}; + uint32_t v_i = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -8279,13 +8220,10 @@ wuffs_gif__decoder__decode_header(wuffs_gif__decoder* self, if (coro_susp_point) { memcpy(v_c, self->private_impl.c_decode_header[0].v_c, sizeof(v_c)); v_i = self->private_impl.c_decode_header[0].v_i; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - memset(v_c, 0, sizeof(v_c)); - v_i = 0; while (v_i < 6) { { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); @@ -8333,10 +8271,10 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_flags; - uint32_t v_num_palette_entries; - uint32_t v_i; - uint32_t v_argb; + uint8_t v_flags = 0; + uint32_t v_num_palette_entries = 0; + uint32_t v_i = 0; + uint32_t v_argb = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -8361,8 +8299,6 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, v_num_palette_entries = self->private_impl.c_decode_lsd[0].v_num_palette_entries; v_i = self->private_impl.c_decode_lsd[0].v_i; - v_argb = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -8371,7 +8307,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { - t_0 = wuffs_base__load_u16le(iop_a_src); + t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); iop_a_src += 2; } else { self->private_impl.c_decode_lsd[0].scratch = 0; @@ -8387,7 +8323,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, *scratch >>= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0; if (num_bits_0 == 8) { - t_0 = *scratch; + t_0 = ((uint32_t)(*scratch)); break; } num_bits_0 += 8; @@ -8400,7 +8336,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint32_t t_1; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { - t_1 = wuffs_base__load_u16le(iop_a_src); + t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); iop_a_src += 2; } else { self->private_impl.c_decode_lsd[0].scratch = 0; @@ -8416,7 +8352,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, *scratch >>= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1; if (num_bits_1 == 8) { - t_1 = *scratch; + t_1 = ((uint32_t)(*scratch)); break; } num_bits_1 += 8; @@ -8434,9 +8370,8 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, uint8_t t_2 = *iop_a_src++; v_flags = t_2; } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); self->private_impl.c_decode_lsd[0].scratch = 2; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); if (self->private_impl.c_decode_lsd[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { self->private_impl.c_decode_lsd[0].scratch -= io1_a_src - iop_a_src; @@ -8450,14 +8385,14 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, v_i = 0; while (v_i < v_num_palette_entries) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); uint32_t t_3; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 3)) { - t_3 = wuffs_base__load_u24be(iop_a_src); + t_3 = ((uint32_t)(wuffs_base__load_u24be(iop_a_src))); iop_a_src += 3; } else { self->private_impl.c_decode_lsd[0].scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; @@ -8469,7 +8404,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, *scratch <<= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3); if (num_bits_3 == 16) { - t_3 = *scratch >> (64 - 24); + t_3 = ((uint32_t)(*scratch >> 40)); break; } num_bits_3 += 8; @@ -8529,7 +8464,7 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_label; + uint8_t v_label = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -8551,8 +8486,6 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode_extension[0].coro_susp_point; if (coro_susp_point) { - v_label = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -8567,11 +8500,11 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, v_label = t_0; } if (v_label == 249) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); status = wuffs_gif__decoder__decode_gc(self, a_src); if (a_src.private_impl.buf) { iop_a_src = @@ -8583,11 +8516,11 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, status = NULL; goto ok; } else if (v_label == 255) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); status = wuffs_gif__decoder__decode_ae(self, a_src); if (a_src.private_impl.buf) { iop_a_src = @@ -8599,11 +8532,11 @@ wuffs_gif__decoder__decode_extension(wuffs_gif__decoder* self, status = NULL; goto ok; } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); status = wuffs_gif__decoder__skip_blocks(self, a_src); if (a_src.private_impl.buf) { iop_a_src = @@ -8640,7 +8573,7 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_block_size; + uint8_t v_block_size = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -8662,8 +8595,6 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_skip_blocks[0].coro_susp_point; if (coro_susp_point) { - v_block_size = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -8682,9 +8613,8 @@ wuffs_gif__decoder__skip_blocks(wuffs_gif__decoder* self, status = NULL; goto ok; } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); self->private_impl.c_skip_blocks[0].scratch = ((uint32_t)(v_block_size)); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (self->private_impl.c_skip_blocks[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { self->private_impl.c_skip_blocks[0].scratch -= io1_a_src - iop_a_src; @@ -8722,10 +8652,10 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_c; - uint8_t v_block_size; - bool v_not_animexts; - bool v_not_netscape; + uint8_t v_c = 0; + uint8_t v_block_size = 0; + bool v_not_animexts = false; + bool v_not_netscape = false; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -8746,19 +8676,14 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode_ae[0].coro_susp_point; if (coro_susp_point) { - v_c = 0; v_block_size = self->private_impl.c_decode_ae[0].v_block_size; v_not_animexts = self->private_impl.c_decode_ae[0].v_not_animexts; v_not_netscape = self->private_impl.c_decode_ae[0].v_not_netscape; - } else { - v_not_animexts = false; - v_not_netscape = false; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; while (true) { - v_c = 0; { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { @@ -8773,9 +8698,8 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, goto ok; } if (v_block_size != 11) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); self->private_impl.c_decode_ae[0].scratch = ((uint32_t)(v_block_size)); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); if (self->private_impl.c_decode_ae[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src; @@ -8786,12 +8710,12 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, iop_a_src += self->private_impl.c_decode_ae[0].scratch; goto label_0_break; } - v_not_animexts = 0; - v_not_netscape = 0; + v_not_animexts = false; + v_not_netscape = false; v_block_size = 0; while (v_block_size < 11) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; goto suspend; @@ -8809,7 +8733,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, goto label_0_break; } { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; goto suspend; @@ -8818,8 +8742,29 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, v_block_size = t_2; } if (v_block_size != 3) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); self->private_impl.c_decode_ae[0].scratch = ((uint32_t)(v_block_size)); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + if (self->private_impl.c_decode_ae[0].scratch > + ((uint64_t)(io1_a_src - iop_a_src))) { + self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src; + iop_a_src = io1_a_src; + status = wuffs_base__suspension__short_read; + goto suspend; + } + iop_a_src += self->private_impl.c_decode_ae[0].scratch; + goto label_0_break; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { + status = wuffs_base__suspension__short_read; + goto suspend; + } + uint8_t t_3 = *iop_a_src++; + v_c = t_3; + } + if (v_c != 1) { + self->private_impl.c_decode_ae[0].scratch = 2; WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); if (self->private_impl.c_decode_ae[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { @@ -8833,36 +8778,13 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, } { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { - status = wuffs_base__suspension__short_read; - goto suspend; - } - uint8_t t_3 = *iop_a_src++; - v_c = t_3; - } - if (v_c != 1) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); - self->private_impl.c_decode_ae[0].scratch = 2; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); - if (self->private_impl.c_decode_ae[0].scratch > - ((uint64_t)(io1_a_src - iop_a_src))) { - self->private_impl.c_decode_ae[0].scratch -= io1_a_src - iop_a_src; - iop_a_src = io1_a_src; - status = wuffs_base__suspension__short_read; - goto suspend; - } - iop_a_src += self->private_impl.c_decode_ae[0].scratch; - goto label_0_break; - } - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); uint32_t t_4; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { - t_4 = wuffs_base__load_u16le(iop_a_src); + t_4 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); iop_a_src += 2; } else { self->private_impl.c_decode_ae[0].scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; @@ -8874,7 +8796,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, *scratch >>= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_4; if (num_bits_4 == 8) { - t_4 = *scratch; + t_4 = ((uint32_t)(*scratch)); break; } num_bits_4 += 8; @@ -8891,11 +8813,11 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, goto label_0_break; } label_0_break:; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); status = wuffs_gif__decoder__skip_blocks(self, a_src); if (a_src.private_impl.buf) { iop_a_src = @@ -8935,9 +8857,9 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self, wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_c; - uint8_t v_flags; - uint16_t v_gc_duration_centiseconds; + uint8_t v_c = 0; + uint8_t v_flags = 0; + uint16_t v_gc_duration_centiseconds = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -8958,10 +8880,6 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode_gc[0].coro_susp_point; if (coro_susp_point) { - v_c = 0; - v_flags = 0; - v_gc_duration_centiseconds = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -9103,7 +9021,6 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode_id_part0[0].coro_susp_point; if (coro_susp_point) { - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -9112,7 +9029,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { - t_0 = wuffs_base__load_u16le(iop_a_src); + t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); iop_a_src += 2; } else { self->private_impl.c_decode_id_part0[0].scratch = 0; @@ -9128,7 +9045,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, *scratch >>= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0; if (num_bits_0 == 8) { - t_0 = *scratch; + t_0 = ((uint32_t)(*scratch)); break; } num_bits_0 += 8; @@ -9141,7 +9058,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint32_t t_1; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { - t_1 = wuffs_base__load_u16le(iop_a_src); + t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); iop_a_src += 2; } else { self->private_impl.c_decode_id_part0[0].scratch = 0; @@ -9157,7 +9074,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, *scratch >>= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1; if (num_bits_1 == 8) { - t_1 = *scratch; + t_1 = ((uint32_t)(*scratch)); break; } num_bits_1 += 8; @@ -9170,7 +9087,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); uint32_t t_2; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { - t_2 = wuffs_base__load_u16le(iop_a_src); + t_2 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); iop_a_src += 2; } else { self->private_impl.c_decode_id_part0[0].scratch = 0; @@ -9186,7 +9103,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, *scratch >>= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2; if (num_bits_2 == 8) { - t_2 = *scratch; + t_2 = ((uint32_t)(*scratch)); break; } num_bits_2 += 8; @@ -9200,7 +9117,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); uint32_t t_3; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { - t_3 = wuffs_base__load_u16le(iop_a_src); + t_3 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); iop_a_src += 2; } else { self->private_impl.c_decode_id_part0[0].scratch = 0; @@ -9216,7 +9133,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, *scratch >>= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_3; if (num_bits_3 == 8) { - t_3 = *scratch; + t_3 = ((uint32_t)(*scratch)); break; } num_bits_3 += 8; @@ -9260,29 +9177,15 @@ exit: static wuffs_base__status // wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, wuffs_base__pixel_buffer* a_dst, - wuffs_base__io_reader a_src, - wuffs_base__slice_u8 a_workbuf) { + wuffs_base__io_reader a_src) { wuffs_base__status status = NULL; - uint8_t v_flags; - uint32_t v_num_palette_entries; - uint32_t v_i; - uint32_t v_argb; - wuffs_base__slice_u8 v_dst_palette; - uint8_t v_lw; - uint64_t v_block_size; - bool v_need_block_size; - uint64_t v_n_compressed; - wuffs_base__slice_u8 v_compressed; - wuffs_base__io_reader v_r; - wuffs_base__io_buffer u_r; - uint8_t* iop_v_r = NULL; - uint8_t* io1_v_r = NULL; - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(u_r); - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iop_v_r); - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_v_r); - wuffs_base__status v_z; - wuffs_base__slice_u8 v_uncompressed; + uint8_t v_flags = 0; + uint32_t v_num_palette_entries = 0; + uint32_t v_i = 0; + uint32_t v_argb = 0; + wuffs_base__slice_u8 v_dst_palette = {}; + uint8_t v_lw = 0; uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -9304,27 +9207,9 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode_id_part1[0].coro_susp_point; if (coro_susp_point) { - v_flags = 0; v_num_palette_entries = self->private_impl.c_decode_id_part1[0].v_num_palette_entries; v_i = self->private_impl.c_decode_id_part1[0].v_i; - v_argb = 0; - v_dst_palette = ((wuffs_base__slice_u8){}); - v_lw = 0; - v_block_size = self->private_impl.c_decode_id_part1[0].v_block_size; - v_need_block_size = - self->private_impl.c_decode_id_part1[0].v_need_block_size; - v_n_compressed = 0; - v_compressed = ((wuffs_base__slice_u8){}); - v_r = ((wuffs_base__io_reader){}); - v_z = self->private_impl.c_decode_id_part1[0].v_z; - v_uncompressed = ((wuffs_base__slice_u8){}); - } else { - v_dst_palette = ((wuffs_base__slice_u8){}); - v_need_block_size = false; - v_compressed = ((wuffs_base__slice_u8){}); - v_r = ((wuffs_base__io_reader){}); - v_uncompressed = ((wuffs_base__slice_u8){}); } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -9352,7 +9237,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); uint32_t t_1; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 3)) { - t_1 = wuffs_base__load_u24be(iop_a_src); + t_1 = ((uint32_t)(wuffs_base__load_u24be(iop_a_src))); iop_a_src += 3; } else { self->private_impl.c_decode_id_part1[0].scratch = 0; @@ -9369,7 +9254,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, *scratch <<= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1); if (num_bits_1 == 16) { - t_1 = *scratch >> (64 - 24); + t_1 = ((uint32_t)(*scratch >> 40)); break; } num_bits_1 += 8; @@ -9463,20 +9348,95 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw, ((uint32_t)(v_lw))); self->private_impl.f_previous_lzw_decode_ended_abruptly = true; - v_block_size = 0; + + goto ok; + ok: + self->private_impl.c_decode_id_part1[0].coro_susp_point = 0; + goto exit; + } + + goto suspend; +suspend: + self->private_impl.c_decode_id_part1[0].coro_susp_point = coro_susp_point; + self->private_impl.c_decode_id_part1[0].v_num_palette_entries = + v_num_palette_entries; + self->private_impl.c_decode_id_part1[0].v_i = v_i; + + goto exit; +exit: + if (a_src.private_impl.buf) { + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; + } + + return status; +} + +// -------- func gif.decoder.decode_id_part2 + +static wuffs_base__status // +wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__io_reader a_src, + wuffs_base__slice_u8 a_workbuf) { + wuffs_base__status status = NULL; + + uint64_t v_block_size = 0; + bool v_need_block_size = false; + uint64_t v_n_compressed = 0; + wuffs_base__slice_u8 v_compressed = {}; + wuffs_base__io_reader v_r = {}; + wuffs_base__io_buffer u_r = {}; + uint8_t* iop_v_r = NULL; + uint8_t* io1_v_r = NULL; + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(u_r); + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iop_v_r); + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_v_r); + wuffs_base__status v_lzw_status = NULL; + wuffs_base__status v_copy_status = NULL; + wuffs_base__slice_u8 v_uncompressed = {}; + + uint8_t* iop_a_src = NULL; + uint8_t* io0_a_src = NULL; + uint8_t* io1_a_src = NULL; + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_src); + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_src); + if (a_src.private_impl.buf) { + iop_a_src = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; + if (!a_src.private_impl.mark) { + a_src.private_impl.mark = iop_a_src; + a_src.private_impl.limit = + a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.wi; + } + io0_a_src = a_src.private_impl.mark; + io1_a_src = a_src.private_impl.limit; + } + + uint32_t coro_susp_point = + self->private_impl.c_decode_id_part2[0].coro_susp_point; + if (coro_susp_point) { + v_block_size = self->private_impl.c_decode_id_part2[0].v_block_size; + v_need_block_size = + self->private_impl.c_decode_id_part2[0].v_need_block_size; + v_lzw_status = self->private_impl.c_decode_id_part2[0].v_lzw_status; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + v_need_block_size = true; label_0_continue:; while (true) { if (v_need_block_size) { v_need_block_size = false; { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; goto suspend; } - uint64_t t_3 = *iop_a_src++; - v_block_size = t_3; + uint64_t t_0 = *iop_a_src++; + v_block_size = t_0; } } if (v_block_size == 0) { @@ -9484,7 +9444,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, } while (((uint64_t)(io1_a_src - iop_a_src)) == 0) { status = wuffs_base__suspension__short_read; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); } if (self->private_impl.f_compressed_ri == self->private_impl.f_compressed_wi) { @@ -9517,7 +9477,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, v_need_block_size = true; goto label_1_break; } - v_block_size = wuffs_base__load_u8be(iop_a_src); + v_block_size = ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); (iop_a_src += 1, wuffs_base__return_empty_struct()); } label_1_break:; @@ -9532,7 +9492,6 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, } label_2_continue:; while (true) { - v_r = ((wuffs_base__io_reader){}); if ((self->private_impl.f_compressed_ri > self->private_impl.f_compressed_wi) || (self->private_impl.f_compressed_wi > 4096)) { @@ -9554,12 +9513,12 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, self->private_impl.f_compressed_wi)); { u_r.meta.ri = iop_v_r - u_r.data.ptr; - wuffs_base__status t_4 = wuffs_lzw__decoder__decode( + wuffs_base__status t_1 = wuffs_lzw__decoder__decode( &self->private_impl.f_lzw, wuffs_base__utility__null_io_writer(&self->private_impl.f_util), v_r); iop_v_r = u_r.data.ptr + u_r.meta.ri; - v_z = t_4; + v_lzw_status = t_1; } wuffs_base__u64__sat_add_indirect( &self->private_impl.f_compressed_ri, @@ -9570,33 +9529,33 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, } v_uncompressed = wuffs_lzw__decoder__flush(&self->private_impl.f_lzw); if (((uint64_t)(v_uncompressed.len)) > 0) { - status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst, - v_uncompressed); - if (status) { + v_copy_status = wuffs_gif__decoder__copy_to_image_buffer( + self, a_dst, v_uncompressed); + if (wuffs_base__status__is_error(v_copy_status)) { + status = v_copy_status; goto exit; } } - if (wuffs_base__status__is_ok(v_z)) { + if (wuffs_base__status__is_ok(v_lzw_status)) { self->private_impl.f_previous_lzw_decode_ended_abruptly = false; if (v_need_block_size || (v_block_size > 0)) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); - self->private_impl.c_decode_id_part1[0].scratch = + self->private_impl.c_decode_id_part2[0].scratch = ((uint32_t)(v_block_size)); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); - if (self->private_impl.c_decode_id_part1[0].scratch > + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (self->private_impl.c_decode_id_part2[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { - self->private_impl.c_decode_id_part1[0].scratch -= + self->private_impl.c_decode_id_part2[0].scratch -= io1_a_src - iop_a_src; iop_a_src = io1_a_src; status = wuffs_base__suspension__short_read; goto suspend; } - iop_a_src += self->private_impl.c_decode_id_part1[0].scratch; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + iop_a_src += self->private_impl.c_decode_id_part2[0].scratch; if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); status = wuffs_gif__decoder__skip_blocks(self, a_src); if (a_src.private_impl.buf) { iop_a_src = a_src.private_impl.buf->data.ptr + @@ -9607,12 +9566,12 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, } } goto label_0_break; - } else if (v_z == wuffs_base__suspension__short_read) { + } else if (v_lzw_status == wuffs_base__suspension__short_read) { goto label_0_continue; - } else if (v_z == wuffs_base__suspension__short_write) { + } else if (v_lzw_status == wuffs_base__suspension__short_write) { goto label_2_continue; } - status = v_z; + status = v_lzw_status; if (wuffs_base__status__is_error(status)) { goto exit; } else if (wuffs_base__status__is_suspension(status)) { @@ -9628,19 +9587,16 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, goto ok; ok: - self->private_impl.c_decode_id_part1[0].coro_susp_point = 0; + self->private_impl.c_decode_id_part2[0].coro_susp_point = 0; goto exit; } goto suspend; suspend: - self->private_impl.c_decode_id_part1[0].coro_susp_point = coro_susp_point; - self->private_impl.c_decode_id_part1[0].v_num_palette_entries = - v_num_palette_entries; - self->private_impl.c_decode_id_part1[0].v_i = v_i; - self->private_impl.c_decode_id_part1[0].v_block_size = v_block_size; - self->private_impl.c_decode_id_part1[0].v_need_block_size = v_need_block_size; - self->private_impl.c_decode_id_part1[0].v_z = v_z; + self->private_impl.c_decode_id_part2[0].coro_susp_point = coro_susp_point; + self->private_impl.c_decode_id_part2[0].v_block_size = v_block_size; + self->private_impl.c_decode_id_part2[0].v_need_block_size = v_need_block_size; + self->private_impl.c_decode_id_part2[0].v_lzw_status = v_lzw_status; goto exit; exit: @@ -9658,22 +9614,16 @@ static wuffs_base__status // wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self, wuffs_base__pixel_buffer* a_pb, wuffs_base__slice_u8 a_src) { - wuffs_base__status status = NULL; + wuffs_base__slice_u8 v_dst = {}; + wuffs_base__slice_u8 v_src = {}; + uint64_t v_n = 0; + uint64_t v_src_ri = 0; + uint32_t v_bytes_per_pixel = 0; + uint32_t v_pixfmt = 0; + wuffs_base__table_u8 v_tab = {}; + uint64_t v_i = 0; + uint64_t v_j = 0; - wuffs_base__slice_u8 v_dst; - wuffs_base__slice_u8 v_src; - uint64_t v_n; - uint64_t v_src_ri; - uint32_t v_bytes_per_pixel; - uint32_t v_pixfmt; - wuffs_base__table_u8 v_tab; - uint64_t v_i; - uint64_t v_j; - - v_dst = ((wuffs_base__slice_u8){}); - v_src = ((wuffs_base__slice_u8){}); - v_n = 0; - v_src_ri = 0; v_bytes_per_pixel = 1; v_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_pb); if ((v_pixfmt == 1157662856) || (v_pixfmt == 1426098312) || @@ -9686,8 +9636,7 @@ label_0_continue:; while (v_src_ri < ((uint64_t)(a_src.len))) { v_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_ri); if (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) { - status = wuffs_gif__error__too_much_pixel_data; - goto exit; + return wuffs_gif__error__too_much_pixel_data; } v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y); v_i = (((uint64_t)(self->private_impl.f_dst_x)) * @@ -9735,8 +9684,7 @@ label_0_continue:; if (((uint64_t)(a_src.len)) == v_src_ri) { goto label_0_break; } else if (((uint64_t)(a_src.len)) < v_src_ri) { - status = wuffs_gif__error__internal_error_inconsistent_ri_wi; - goto exit; + return wuffs_gif__error__internal_error_inconsistent_ri_wi; } v_n = ((uint64_t)( (self->private_impl.f_frame_rect_x1 - self->private_impl.f_dst_x))); @@ -9761,15 +9709,12 @@ label_0_continue:; goto label_0_continue; } if (v_src_ri != ((uint64_t)(a_src.len))) { - status = wuffs_gif__error__internal_error_inconsistent_ri_wi; - goto exit; + return wuffs_gif__error__internal_error_inconsistent_ri_wi; } goto label_0_break; } label_0_break:; - goto exit; -exit: - return status; + return NULL; } #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) @@ -9867,14 +9812,14 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, } wuffs_base__status status = NULL; - uint8_t v_c; - uint8_t v_flags; - uint16_t v_xlen; - uint32_t v_checksum_got; - uint32_t v_decoded_length_got; - wuffs_base__status v_z; - uint32_t v_checksum_want; - uint32_t v_decoded_length_want; + uint8_t v_c = 0; + uint8_t v_flags = 0; + uint16_t v_xlen = 0; + uint32_t v_checksum_got = 0; + uint32_t v_decoded_length_got = 0; + wuffs_base__status v_status = NULL; + uint32_t v_checksum_want = 0; + uint32_t v_decoded_length_want = 0; uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst = NULL; @@ -9914,15 +9859,10 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode[0].coro_susp_point; if (coro_susp_point) { - v_c = 0; v_flags = self->private_impl.c_decode[0].v_flags; - v_xlen = 0; v_checksum_got = self->private_impl.c_decode[0].v_checksum_got; v_decoded_length_got = self->private_impl.c_decode[0].v_decoded_length_got; - v_z = NULL; v_checksum_want = self->private_impl.c_decode[0].v_checksum_want; - v_decoded_length_want = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -9975,9 +9915,8 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, uint8_t t_3 = *iop_a_src++; v_flags = t_3; } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); self->private_impl.c_decode[0].scratch = 6; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); if (self->private_impl.c_decode[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src; @@ -9988,14 +9927,14 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, iop_a_src += self->private_impl.c_decode[0].scratch; if ((v_flags & 4) != 0) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); uint16_t t_4; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 2)) { t_4 = wuffs_base__load_u16le(iop_a_src); iop_a_src += 2; } else { self->private_impl.c_decode[0].scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; @@ -10016,9 +9955,8 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, } v_xlen = t_4; } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); self->private_impl.c_decode[0].scratch = ((uint32_t)(v_xlen)); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); if (self->private_impl.c_decode[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src; @@ -10031,7 +9969,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, if ((v_flags & 8) != 0) { while (true) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; goto suspend; @@ -10048,7 +9986,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, if ((v_flags & 16) != 0) { while (true) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; goto suspend; @@ -10063,9 +10001,8 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, label_1_break:; } if ((v_flags & 2) != 0) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); self->private_impl.c_decode[0].scratch = 2; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); if (self->private_impl.c_decode[0].scratch > ((uint64_t)(io1_a_src - iop_a_src))) { self->private_impl.c_decode[0].scratch -= io1_a_src - iop_a_src; @@ -10079,8 +10016,6 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, status = wuffs_gzip__error__bad_encoding_flags; goto exit; } - v_checksum_got = 0; - v_decoded_length_got = 0; while (true) { wuffs_base__io_writer__set_mark(&a_dst, iop_a_dst); { @@ -10102,7 +10037,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, iop_a_src = a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } - v_z = t_7; + v_status = t_7; } if (!self->private_impl.f_ignore_checksum) { v_checksum_got = wuffs_crc32__ieee_hasher__update( @@ -10114,22 +10049,22 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, v_decoded_length_got += ((uint32_t)( (((uint64_t)(iop_a_dst - a_dst.private_impl.mark)) & 4294967295))); } - if (wuffs_base__status__is_ok(v_z)) { + if (wuffs_base__status__is_ok(v_status)) { goto label_2_break; } - status = v_z; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(15); + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(12); } label_2_break:; { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); uint32_t t_8; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 4)) { t_8 = wuffs_base__load_u32le(iop_a_src); iop_a_src += 4; } else { self->private_impl.c_decode[0].scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(17); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; @@ -10151,14 +10086,14 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, v_checksum_want = t_8; } { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(18); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); uint32_t t_9; if (WUFFS_BASE__LIKELY(io1_a_src - iop_a_src >= 4)) { t_9 = wuffs_base__load_u32le(iop_a_src); iop_a_src += 4; } else { self->private_impl.c_decode[0].scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(19); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { status = wuffs_base__suspension__short_read; @@ -10316,10 +10251,10 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, } wuffs_base__status status = NULL; - uint16_t v_x; - uint32_t v_checksum_got; - wuffs_base__status v_z; - uint32_t v_checksum_want; + uint16_t v_x = 0; + uint32_t v_checksum_got = 0; + wuffs_base__status v_status = NULL; + uint32_t v_checksum_want = 0; uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst = NULL; @@ -10359,11 +10294,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, uint32_t coro_susp_point = self->private_impl.c_decode[0].coro_susp_point; if (coro_susp_point) { - v_x = 0; v_checksum_got = self->private_impl.c_decode[0].v_checksum_got; - v_z = NULL; - v_checksum_want = 0; - } else { } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -10388,7 +10319,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, *scratch <<= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0); if (num_bits_0 == 8) { - t_0 = *scratch >> (64 - 16); + t_0 = *scratch >> 48; break; } num_bits_0 += 8; @@ -10413,7 +10344,6 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, status = wuffs_zlib__error__bad_parity_check; goto exit; } - v_checksum_got = 0; while (true) { wuffs_base__io_writer__set_mark(&a_dst, iop_a_dst); { @@ -10435,7 +10365,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, iop_a_src = a_src.private_impl.buf->data.ptr + a_src.private_impl.buf->meta.ri; } - v_z = t_1; + v_status = t_1; } if (!self->private_impl.f_ignore_checksum) { v_checksum_got = wuffs_adler32__hasher__update( @@ -10445,10 +10375,10 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), })); } - if (wuffs_base__status__is_ok(v_z)) { + if (wuffs_base__status__is_ok(v_status)) { goto label_0_break; } - status = v_z; + status = v_status; WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); } label_0_break:; @@ -10472,7 +10402,7 @@ wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, *scratch <<= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2); if (num_bits_2 == 24) { - t_2 = *scratch >> (64 - 32); + t_2 = *scratch >> 32; break; } num_bits_2 += 8;