From b5c47e273f7f8862bcf04976453d0ec81e6e6650 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 21 Oct 2018 16:12:50 +1100 Subject: [PATCH] wuffs gen -version=0.2.0-alpha.22 --- release/c/wuffs-v0.2.h | 354 ++++++++++++++++++++++++++++++----------- 1 file changed, 259 insertions(+), 95 deletions(-) diff --git a/release/c/wuffs-v0.2.h b/release/c/wuffs-v0.2.h index a7e971fa..471c3035 100644 --- a/release/c/wuffs-v0.2.h +++ b/release/c/wuffs-v0.2.h @@ -65,14 +65,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-10-13 UTC, -// based on revision 7be9c392832d440c5cb44f76b7faa39ae10c6c9a. +// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-10-21 UTC, +// based on revision 479326cbadac8240564d5b4a7a0ca859bb767ba4. #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.21" -#define WUFFS_VERSION_STRING "0.2.0-alpha.21" +#define WUFFS_VERSION_EXTENSION "alpha.22" +#define WUFFS_VERSION_STRING "0.2.0-alpha.22" // Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have // static storage. The motivation is discussed in the "ALLOW STATIC @@ -2516,7 +2516,6 @@ extern "C" { // ---------------- Status Codes extern const char* wuffs_lzw__error__bad_code; -extern const char* wuffs_lzw__error__cyclical_prefix_chain; // ---------------- Public Consts @@ -2570,9 +2569,11 @@ struct wuffs_lzw__decoder__struct { uint32_t magic; uint32_t f_literal_width; - uint8_t f_stack[4096]; - uint8_t f_suffixes[4096]; + uint32_t f_flush_j; + uint8_t f_suffixes[4096][8]; uint16_t f_prefixes[4096]; + uint16_t f_lm1s[4096]; + uint8_t f_output[8199]; struct { uint32_t coro_susp_point; @@ -2582,13 +2583,23 @@ struct wuffs_lzw__decoder__struct { uint32_t v_save_code; uint32_t v_prev_code; uint32_t v_width; + uint32_t v_j; uint32_t v_bits; uint32_t v_n_bits; uint32_t v_code; - uint32_t v_s; + uint16_t v_lm1_a; uint32_t v_c; - uint64_t v_n_copied; + uint32_t v_o; + uint32_t v_steps; + uint8_t v_first_byte; + uint16_t v_lm1_b; } c_decode[1]; + struct { + uint32_t coro_susp_point; + uint32_t v_i; + uint32_t v_j; + uint64_t v_n; + } c_flush[1]; } private_impl; #ifdef __cplusplus @@ -9414,8 +9425,8 @@ exit: // ---------------- Status Codes Implementations const char* wuffs_lzw__error__bad_code = "?lzw: bad code"; -const char* wuffs_lzw__error__cyclical_prefix_chain = - "?lzw: cyclical prefix chain"; +const char* wuffs_lzw__error__internal_error_inconsistent_i_o = + "?lzw: internal error: inconsistent I/O"; // ---------------- Private Consts @@ -9423,6 +9434,10 @@ const char* wuffs_lzw__error__cyclical_prefix_chain = // ---------------- Private Function Prototypes +static wuffs_base__status // +wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, + wuffs_base__io_writer a_dst); + // ---------------- Initializer Implementations wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT // @@ -9493,33 +9508,17 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, uint32_t v_save_code; uint32_t v_prev_code; uint32_t v_width; + uint32_t v_j; uint32_t v_bits; uint32_t v_n_bits; uint32_t v_code; - uint32_t v_s; + uint16_t v_lm1_a; uint32_t v_c; - wuffs_base__slice_u8 v_expansion; - uint64_t v_n_copied; + uint32_t v_o; + uint32_t v_steps; + uint8_t v_first_byte; + uint16_t v_lm1_b; - uint8_t* iop_a_dst = NULL; - uint8_t* io0_a_dst = NULL; - uint8_t* io1_a_dst = NULL; - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); - if (a_dst.private_impl.buf) { - iop_a_dst = - a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; - if (!a_dst.private_impl.mark) { - a_dst.private_impl.mark = iop_a_dst; - a_dst.private_impl.limit = - a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; - } - if (a_dst.private_impl.buf->meta.closed) { - a_dst.private_impl.limit = iop_a_dst; - } - io0_a_dst = a_dst.private_impl.mark; - io1_a_dst = a_dst.private_impl.limit; - } uint8_t* iop_a_src = NULL; uint8_t* io0_a_src = NULL; uint8_t* io1_a_src = NULL; @@ -9545,15 +9544,17 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, 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_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 = self->private_impl.c_decode[0].v_code; - v_s = self->private_impl.c_decode[0].v_s; + v_lm1_a = self->private_impl.c_decode[0].v_lm1_a; v_c = self->private_impl.c_decode[0].v_c; - v_expansion = ((wuffs_base__slice_u8){}); - v_n_copied = self->private_impl.c_decode[0].v_n_copied; + v_o = self->private_impl.c_decode[0].v_o; + v_steps = self->private_impl.c_decode[0].v_steps; + v_first_byte = self->private_impl.c_decode[0].v_first_byte; + v_lm1_b = self->private_impl.c_decode[0].v_lm1_b; } else { - v_expansion = ((wuffs_base__slice_u8){}); } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -9565,37 +9566,72 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, 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 = 0; + v_prev_code = v_end_code; v_width = (v_literal_width + 1); + 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) { - while (v_n_bits < v_width) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { - status = wuffs_base__suspension__short_read; - goto suspend; + 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; + } 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__flush(self, a_dst); + if (status) { + goto suspend; + } + v_j = 0; + } + 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; + } } - uint8_t t_0 = *iop_a_src++; - v_bits |= (((uint32_t)(t_0)) << v_n_bits); + label_0_break:; } - v_n_bits += 8; } v_code = ((v_bits) & ((1 << (v_width)) - 1)); v_bits >>= v_width; v_n_bits -= v_width; if (v_code < v_clear_code) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (iop_a_dst == io1_a_dst) { - status = wuffs_base__suspension__short_write; - goto suspend; - } - *iop_a_dst++ = ((uint8_t)(v_code)); + self->private_impl.f_output[v_j] = ((uint8_t)(v_code)); + v_j = ((v_j + 1) & 8191); if (v_save_code <= 4095) { - self->private_impl.f_suffixes[v_save_code] = ((uint8_t)(v_code)); - self->private_impl.f_prefixes[v_save_code] = - ((uint16_t)(v_prev_code)); + 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], 8); + 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; @@ -9604,53 +9640,53 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, } } else if (v_code <= v_end_code) { if (v_code == v_end_code) { - status = NULL; - goto ok; + goto label_1_break; } v_save_code = v_end_code; - v_prev_code = 0; + v_prev_code = v_end_code; v_width = (v_literal_width + 1); } else if (v_code <= v_save_code) { - v_s = 4095; v_c = v_code; if (v_code == v_save_code) { - v_s -= 1; v_c = v_prev_code; } - while (v_c >= v_clear_code) { - self->private_impl.f_stack[v_s] = self->private_impl.f_suffixes[v_c]; - if (v_s == 0) { - status = wuffs_lzw__error__cyclical_prefix_chain; - goto exit; + 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]) + (0), 8); + if (v_steps <= 0) { + goto label_2_break; } - v_s -= 1; + v_steps -= 1; + v_o = ((v_o - 8) & 8191); v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c])); } - self->private_impl.f_stack[v_s] = ((uint8_t)(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_stack[4095] = ((uint8_t)(v_c)); + self->private_impl.f_output[v_j] = v_first_byte; + v_j = ((v_j + 1) & 8191); } - while (true) { - v_expansion = wuffs_base__slice_u8__subslice_i( - ((wuffs_base__slice_u8){ - .ptr = self->private_impl.f_stack, - .len = 4096, - }), - v_s); - v_n_copied = wuffs_base__io_writer__copy_from_slice( - &iop_a_dst, io1_a_dst, v_expansion); - if (v_n_copied == ((uint64_t)(v_expansion.len))) { - goto label_0_break; - } - v_s = ((v_s + ((uint32_t)((v_n_copied & 4095)))) & 4095); - status = wuffs_base__suspension__short_write; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); - } - label_0_break:; if (v_save_code <= 4095) { - self->private_impl.f_suffixes[v_save_code] = ((uint8_t)(v_c)); - self->private_impl.f_prefixes[v_save_code] = - ((uint16_t)(v_prev_code)); + 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], 8); + 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; @@ -9661,6 +9697,44 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, status = wuffs_lzw__error__bad_code; goto exit; } + 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) & ((1 << (v_n_bits)) - 1)); + self->private_impl.f_flush_j = v_j; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_lzw__decoder__flush(self, a_dst); + if (status) { + goto suspend; + } + v_j = 0; + } + } + label_1_break:; + if (v_j > 0) { + 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) & ((1 << (v_n_bits)) - 1)); + self->private_impl.f_flush_j = v_j; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_lzw__decoder__flush(self, a_dst); + if (status) { + goto suspend; + } } goto ok; @@ -9678,19 +9752,19 @@ suspend: 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_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; self->private_impl.c_decode[0].v_code = v_code; - self->private_impl.c_decode[0].v_s = v_s; + self->private_impl.c_decode[0].v_lm1_a = v_lm1_a; self->private_impl.c_decode[0].v_c = v_c; - self->private_impl.c_decode[0].v_n_copied = v_n_copied; + self->private_impl.c_decode[0].v_o = v_o; + self->private_impl.c_decode[0].v_steps = v_steps; + self->private_impl.c_decode[0].v_first_byte = v_first_byte; + self->private_impl.c_decode[0].v_lm1_b = v_lm1_b; goto exit; exit: - if (a_dst.private_impl.buf) { - a_dst.private_impl.buf->meta.wi = - iop_a_dst - a_dst.private_impl.buf->data.ptr; - } if (a_src.private_impl.buf) { a_src.private_impl.buf->meta.ri = iop_a_src - a_src.private_impl.buf->data.ptr; @@ -9702,6 +9776,96 @@ exit: return status; } +// -------- func lzw.decoder.flush + +static wuffs_base__status // +wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, + wuffs_base__io_writer a_dst) { + wuffs_base__status status = NULL; + + uint32_t v_i; + uint32_t v_j; + wuffs_base__slice_u8 v_s; + uint64_t v_n; + + uint8_t* iop_a_dst = NULL; + uint8_t* io0_a_dst = NULL; + uint8_t* io1_a_dst = NULL; + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io0_a_dst); + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_a_dst); + if (a_dst.private_impl.buf) { + iop_a_dst = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; + if (!a_dst.private_impl.mark) { + a_dst.private_impl.mark = iop_a_dst; + a_dst.private_impl.limit = + a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->data.len; + } + if (a_dst.private_impl.buf->meta.closed) { + a_dst.private_impl.limit = iop_a_dst; + } + io0_a_dst = a_dst.private_impl.mark; + io1_a_dst = a_dst.private_impl.limit; + } + + uint32_t coro_susp_point = self->private_impl.c_flush[0].coro_susp_point; + if (coro_susp_point) { + v_i = self->private_impl.c_flush[0].v_i; + v_j = self->private_impl.c_flush[0].v_j; + v_s = ((wuffs_base__slice_u8){}); + v_n = self->private_impl.c_flush[0].v_n; + } else { + v_s = ((wuffs_base__slice_u8){}); + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + v_i = 0; + v_j = self->private_impl.f_flush_j; + while (true) { + if (v_i > v_j) { + status = wuffs_lzw__error__internal_error_inconsistent_i_o; + goto exit; + } + v_s = wuffs_base__slice_u8__subslice_ij( + ((wuffs_base__slice_u8){ + .ptr = self->private_impl.f_output, + .len = 8199, + }), + v_i, v_j); + 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))) { + status = NULL; + goto ok; + } + v_i = ((v_i + ((uint32_t)((v_n & 8191)))) & 8191); + status = wuffs_base__suspension__short_write; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); + } + + goto ok; + ok: + self->private_impl.c_flush[0].coro_susp_point = 0; + goto exit; + } + + goto suspend; +suspend: + self->private_impl.c_flush[0].coro_susp_point = coro_susp_point; + self->private_impl.c_flush[0].v_i = v_i; + self->private_impl.c_flush[0].v_j = v_j; + self->private_impl.c_flush[0].v_n = v_n; + + goto exit; +exit: + if (a_dst.private_impl.buf) { + a_dst.private_impl.buf->meta.wi = + iop_a_dst - a_dst.private_impl.buf->data.ptr; + } + + return status; +} + #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ZLIB)