diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 078281f2..c0448ec2 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -2622,6 +2622,7 @@ struct wuffs_lzw__decoder__struct { 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]; @@ -2634,7 +2635,6 @@ struct wuffs_lzw__decoder__struct { } c_decode[1]; struct { uint32_t coro_susp_point; - uint32_t v_i; } c_write_to[1]; } private_impl; @@ -7116,6 +7116,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, 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) { @@ -7374,7 +7375,6 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, wuffs_base__io_writer a_dst) { wuffs_base__status status = NULL; - uint32_t v_i = 0; wuffs_base__slice_u8 v_s = {}; uint64_t v_n = 0; @@ -7400,13 +7400,12 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, 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_write_to[0].v_i; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; while (self->private_impl.f_output_wi > 0) { - if (v_i > self->private_impl.f_output_wi) { + if (self->private_impl.f_output_ri > self->private_impl.f_output_wi) { status = wuffs_lzw__error__internal_error_inconsistent_i_o; goto exit; } @@ -7415,14 +7414,17 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, .ptr = self->private_impl.f_output, .len = 8199, }), - v_i, self->private_impl.f_output_wi); + 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); } @@ -7436,7 +7438,6 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, goto suspend; suspend: self->private_impl.c_write_to[0].coro_susp_point = coro_susp_point; - self->private_impl.c_write_to[0].v_i = v_i; goto exit; exit: @@ -7461,11 +7462,15 @@ wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self) { 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_output_wi); + 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; } diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs index 18a01464..b46fd9b6 100644 --- a/std/lzw/decode_lzw.wuffs +++ b/std/lzw/decode_lzw.wuffs @@ -33,6 +33,7 @@ pub struct decoder?( width base.u32[..12], bits base.u32, n_bits base.u32[..31], + output_ri base.u32[..8191], output_wi base.u32[..8191], // read_from return value. The read_from method effectively returns a @@ -48,8 +49,8 @@ pub struct decoder?( // table in this decoder. See std/lzw/README.md for more detail. lm1s array[4096] base.u16[..4095], - // output[:output_wi] is the buffered output, connecting read_from with - // write_to and flush. + // output[output_ri:output_wi] is the buffered output, connecting read_from + // with write_to and flush. output array[8192 + 7] base.u8, ) @@ -72,6 +73,7 @@ pub func decoder.decode?(dst base.io_writer, src base.io_reader) { this.width = this.literal_width + 1 this.bits = 0 this.n_bits = 0 + this.output_ri = 0 this.output_wi = 0 i = 0 while i < this.clear_code { @@ -310,33 +312,32 @@ pri func decoder.read_from!(src base.io_reader) { } pri func decoder.write_to?(dst base.io_writer) { - var i base.u32[..8191] var s slice base.u8 var n base.u64 while this.output_wi > 0 { - if i > this.output_wi { + if this.output_ri > this.output_wi { return "?internal error: inconsistent I/O" } - s = this.output[i:this.output_wi] + s = this.output[this.output_ri:this.output_wi] n = args.dst.copy_from_slice!(s:s) if n == s.length() { + this.output_ri = 0 this.output_wi = 0 return ok } - i = (i + ((n & 8191) as base.u32)) & 8191 + this.output_ri = (this.output_ri ~mod+ ((n & 0xFFFFFFFF) as base.u32)) & 8191 yield base."$short write" } } -// TODO: enforce that flush is only valid to call if decode was always passed a -// 0-length dst base.io_writer? The (non-obvious) hard part is to enforce that -// without regressing benchmarks. - pub func decoder.flush!() slice base.u8 { var s slice base.u8 - s = this.output[:this.output_wi] + if this.output_ri <= this.output_wi { + s = this.output[this.output_ri:this.output_wi] + } + this.output_ri = 0 this.output_wi = 0 return s }