From 8e42e01d3c4a9a95b608d9589d1b55a139e5ea63 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Wed, 4 Oct 2023 18:45:18 +1100 Subject: [PATCH] std/gif: remove the std/lzw dependency MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit name old speed new speed delta wuffs_gif_decode_1k_bw/clang11 683MB/s ± 0% 682MB/s ± 0% ~ (p=0.690 n=5+5) wuffs_gif_decode_1k_color_full_init/clang11 168MB/s ± 0% 184MB/s ± 0% +10.01% (p=0.008 n=5+5) wuffs_gif_decode_1k_color_part_init/clang11 204MB/s ± 0% 230MB/s ± 0% +12.77% (p=0.008 n=5+5) wuffs_gif_decode_10k_bgra/clang11 746MB/s ± 0% 819MB/s ± 0% +9.90% (p=0.008 n=5+5) wuffs_gif_decode_10k_indexed/clang11 200MB/s ± 0% 218MB/s ± 0% +8.97% (p=0.008 n=5+5) wuffs_gif_decode_20k/clang11 246MB/s ± 0% 257MB/s ± 0% +4.33% (p=0.008 n=5+5) wuffs_gif_decode_100k_artificial/clang11 543MB/s ± 0% 562MB/s ± 0% +3.44% (p=0.008 n=5+5) wuffs_gif_decode_100k_realistic/clang11 210MB/s ± 0% 220MB/s ± 0% +4.90% (p=0.008 n=5+5) wuffs_gif_decode_1000k_full_init/clang11 214MB/s ± 0% 224MB/s ± 0% +4.96% (p=0.008 n=5+5) wuffs_gif_decode_1000k_part_init/clang11 214MB/s ± 0% 224MB/s ± 0% +4.98% (p=0.008 n=5+5) wuffs_gif_decode_anim_screencap/clang11 1.24GB/s ± 0% 1.29GB/s ± 0% +3.85% (p=0.008 n=5+5) wuffs_gif_decode_1k_bw/gcc10 649MB/s ± 0% 588MB/s ± 0% -9.42% (p=0.008 n=5+5) wuffs_gif_decode_1k_color_full_init/gcc10 167MB/s ± 0% 198MB/s ± 0% +18.57% (p=0.008 n=5+5) wuffs_gif_decode_1k_color_part_init/gcc10 195MB/s ± 0% 251MB/s ± 0% +28.64% (p=0.008 n=5+5) wuffs_gif_decode_10k_bgra/gcc10 753MB/s ± 0% 871MB/s ± 0% +15.64% (p=0.008 n=5+5) wuffs_gif_decode_10k_indexed/gcc10 199MB/s ± 0% 233MB/s ± 0% +16.86% (p=0.008 n=5+5) wuffs_gif_decode_20k/gcc10 258MB/s ± 0% 265MB/s ± 0% +2.93% (p=0.008 n=5+5) wuffs_gif_decode_100k_artificial/gcc10 560MB/s ± 0% 561MB/s ± 0% +0.19% (p=0.008 n=5+5) wuffs_gif_decode_100k_realistic/gcc10 221MB/s ± 0% 227MB/s ± 0% +2.65% (p=0.008 n=5+5) wuffs_gif_decode_1000k_full_init/gcc10 227MB/s ± 0% 232MB/s ± 0% +2.29% (p=0.008 n=5+5) wuffs_gif_decode_1000k_part_init/gcc10 227MB/s ± 0% 232MB/s ± 0% +2.28% (p=0.008 n=5+5) wuffs_gif_decode_anim_screencap/gcc10 1.29GB/s ± 0% 1.28GB/s ± 0% -0.22% (p=0.008 n=5+5) --- doc/changelog.md | 2 + doc/std/README.md | 2 +- example/convert-to-nia/convert-to-nia.c | 1 - example/gifplayer/gifplayer.c | 1 - example/imageviewer/imageviewer.cc | 1 - example/sdl-imageviewer/sdl-imageviewer.cc | 1 - fuzz/c/std/gif_fuzzer.c | 1 - lang/check/type.go | 4 +- release/c/wuffs-unsupported-snapshot.c | 311 ++++++++++++++++++--- script/manual-test-truncated-input.cc | 1 - script/print-average-pixel.cc | 1 - script/print-image-metadata.cc | 1 - std/gif/common_consts.wuffs | 5 +- std/gif/decode_gif.wuffs | 79 ++++-- std/gif/decode_lzw.wuffs | 264 +++++++++++++++++ std/lzw/decode_lzw.wuffs | 4 + test/c/std/gif.c | 23 +- 17 files changed, 600 insertions(+), 102 deletions(-) create mode 100644 std/gif/decode_lzw.wuffs diff --git a/doc/changelog.md b/doc/changelog.md index 654b409a..89500702 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -13,7 +13,9 @@ - Changed `lzw.set_literal_width` to `lzw.set_quirk`. - Changed `set_quirk_enabled!(quirk: u32, enabled: bool)` to `set_quirk!(key: u32, value: u64) status`. +- Deprecate `std/lzw.decoder.flush`. - Halve the sizeof `wuffs_foo__bar::unique_ptr`. +- Remove the `std/gif -> std/lzw` dependency. - Set image decoder pixel width and height inclusive maximum to `0xFF_FFFF`, down from `0x7FFF_FFFF`. diff --git a/doc/std/README.md b/doc/std/README.md index 58466bf6..01d63e0b 100644 --- a/doc/std/README.md +++ b/doc/std/README.md @@ -51,7 +51,7 @@ to enable. - `CBOR: BASE` - `CRC32: BASE` - `DEFLATE: BASE` -- `GIF: BASE, LZW` +- `GIF: BASE` - `GZIP: BASE, CRC32, DEFLATE` - `JPEG: BASE` - `JSON: BASE` diff --git a/example/convert-to-nia/convert-to-nia.c b/example/convert-to-nia/convert-to-nia.c index 0de1fb9a..f90d4887 100644 --- a/example/convert-to-nia/convert-to-nia.c +++ b/example/convert-to-nia/convert-to-nia.c @@ -66,7 +66,6 @@ https://skia-review.googlesource.com/c/skia/+/290618 #define WUFFS_CONFIG__MODULE__DEFLATE #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__JPEG -#define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__NETPBM #define WUFFS_CONFIG__MODULE__NIE #define WUFFS_CONFIG__MODULE__PNG diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index 997c9a5a..0317ff8c 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -90,7 +90,6 @@ micros_since_start(struct timespec* now) { // code simply isn't compiled. #define WUFFS_CONFIG__MODULES #define WUFFS_CONFIG__MODULE__BASE -#define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__GIF // If building this program in an environment that doesn't easily accommodate diff --git a/example/imageviewer/imageviewer.cc b/example/imageviewer/imageviewer.cc index 66d34d8f..fe91b42c 100644 --- a/example/imageviewer/imageviewer.cc +++ b/example/imageviewer/imageviewer.cc @@ -80,7 +80,6 @@ The Escape key quits. #define WUFFS_CONFIG__MODULE__DEFLATE #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__JPEG -#define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__NETPBM #define WUFFS_CONFIG__MODULE__NIE #define WUFFS_CONFIG__MODULE__PNG diff --git a/example/sdl-imageviewer/sdl-imageviewer.cc b/example/sdl-imageviewer/sdl-imageviewer.cc index 02e045c4..be92759b 100644 --- a/example/sdl-imageviewer/sdl-imageviewer.cc +++ b/example/sdl-imageviewer/sdl-imageviewer.cc @@ -78,7 +78,6 @@ isn't otherwise doing anything. #define WUFFS_CONFIG__MODULE__DEFLATE #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__JPEG -#define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__NETPBM #define WUFFS_CONFIG__MODULE__NIE #define WUFFS_CONFIG__MODULE__PNG diff --git a/fuzz/c/std/gif_fuzzer.c b/fuzz/c/std/gif_fuzzer.c index 8026a965..515f83a8 100644 --- a/fuzz/c/std/gif_fuzzer.c +++ b/fuzz/c/std/gif_fuzzer.c @@ -64,7 +64,6 @@ It should print "PASS", amongst other information, and exit(0). #define WUFFS_CONFIG__MODULES #define WUFFS_CONFIG__MODULE__BASE #define WUFFS_CONFIG__MODULE__GIF -#define WUFFS_CONFIG__MODULE__LZW // If building this program in an environment that doesn't easily accommodate // relative includes, you can use the script/inline-c-relative-includes.go diff --git a/lang/check/type.go b/lang/check/type.go index 87975f38..52c4b253 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -240,7 +240,9 @@ func (q *checker) tcheckStatement(n *a.Node) error { return fmt.Errorf("check: cannot return %q (of type %q) as type %q", value.Str(q.tm), rTyp.Str(q.tm), lTyp.Str(q.tm)) } - if rTyp.IsEitherSliceType() { + if rTyp.IsEitherSliceType() || rTyp.IsPointerType() { + // TODO: just reject all "return x" when x has slice or pointer + // type, after removing the (deprecated) lzw.decoder.flush! method. ok := false if value.Operator() != t.IDDotDot { // No-op. diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 5e2f92f8..45f12461 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -8280,6 +8280,7 @@ struct wuffs_lzw__decoder__struct { // ---------------- Status Codes +extern const char wuffs_gif__error__bad_lzw_code[]; extern const char wuffs_gif__error__bad_extension_label[]; extern const char wuffs_gif__error__bad_frame_size[]; extern const char wuffs_gif__error__bad_graphic_control[]; @@ -8478,8 +8479,8 @@ struct wuffs_gif__decoder__struct { uint64_t f_metadata_io_position; bool f_quirks[7]; bool f_delayed_num_decoded_frames; - bool f_previous_lzw_decode_ended_abruptly; bool f_seen_header; + bool f_ignored_but_affects_benchmarks; bool f_has_global_palette; uint8_t f_interlace; bool f_seen_num_animation_loops_value; @@ -8503,6 +8504,19 @@ struct wuffs_gif__decoder__struct { uint64_t f_compressed_ri; uint64_t f_compressed_wi; wuffs_base__pixel_swizzler f_swizzler; + uint32_t f_lzw_pending_literal_width_plus_one; + uint32_t f_lzw_literal_width; + uint32_t f_lzw_clear_code; + uint32_t f_lzw_end_code; + uint32_t f_lzw_save_code; + uint32_t f_lzw_prev_code; + uint32_t f_lzw_width; + uint32_t f_lzw_bits; + uint32_t f_lzw_n_bits; + uint32_t f_lzw_output_ri; + uint32_t f_lzw_output_wi; + uint32_t f_lzw_read_from_return_value; + uint16_t f_lzw_prefixes[4096]; uint32_t p_decode_image_config[1]; uint32_t p_do_decode_image_config[1]; @@ -8529,7 +8543,9 @@ struct wuffs_gif__decoder__struct { uint8_t f_compressed[4096]; uint8_t f_palettes[2][1024]; uint8_t f_dst_palette[1024]; - wuffs_lzw__decoder f_lzw; + uint8_t f_lzw_suffixes[4096][8]; + uint16_t f_lzw_lm1s[4096]; + uint8_t f_lzw_output[8199]; struct { uint32_t v_background_color; @@ -35590,6 +35606,7 @@ wuffs_lzw__decoder__flush( // ---------------- Status Codes Implementations +const char wuffs_gif__error__bad_lzw_code[] = "#gif: bad LZW code"; const char wuffs_gif__error__bad_extension_label[] = "#gif: bad extension label"; const char wuffs_gif__error__bad_frame_size[] = "#gif: bad frame size"; const char wuffs_gif__error__bad_graphic_control[] = "#gif: bad graphic control"; @@ -35597,7 +35614,7 @@ const char wuffs_gif__error__bad_header[] = "#gif: bad header"; const char wuffs_gif__error__bad_literal_width[] = "#gif: bad literal width"; const char wuffs_gif__error__bad_palette[] = "#gif: bad palette"; const char wuffs_gif__error__truncated_input[] = "#gif: truncated input"; -const char wuffs_gif__error__internal_error_inconsistent_ri_wi[] = "#gif: internal error: inconsistent ri/wi"; +const char wuffs_gif__error__internal_error_inconsistent_i_o[] = "#gif: internal error: inconsistent I/O"; // ---------------- Private Consts @@ -35762,6 +35779,17 @@ wuffs_gif__decoder__copy_to_image_buffer( wuffs_base__pixel_buffer* a_pb, wuffs_base__slice_u8 a_src); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_gif__decoder__lzw_init( + wuffs_gif__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_gif__decoder__lzw_read_from( + wuffs_gif__decoder* self, + wuffs_base__io_buffer* a_src); + // ---------------- VTables const wuffs_base__image_decoder__func_ptrs @@ -35841,13 +35869,6 @@ wuffs_gif__decoder__initialize( } } - { - wuffs_base__status z = wuffs_lzw__decoder__initialize( - &self->private_data.f_lzw, sizeof(self->private_data.f_lzw), WUFFS_VERSION, options); - if (z.repr) { - return z; - } - } self->private_impl.magic = WUFFS_BASE__MAGIC; self->private_impl.vtable_for__wuffs_base__image_decoder.vtable_name = wuffs_base__image_decoder__vtable_name; @@ -38058,9 +38079,7 @@ wuffs_gif__decoder__decode_id_part1( } goto ok; } - if (self->private_impl.f_previous_lzw_decode_ended_abruptly) { - wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw, - sizeof (wuffs_lzw__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); + if (self->private_impl.f_ignored_but_affects_benchmarks) { } { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); @@ -38075,8 +38094,8 @@ wuffs_gif__decoder__decode_id_part1( status = wuffs_base__make_status(wuffs_gif__error__bad_literal_width); goto exit; } - wuffs_lzw__decoder__set_quirk(&self->private_data.f_lzw, 1348378624u, ((uint64_t)((1u + v_lw)))); - self->private_impl.f_previous_lzw_decode_ended_abruptly = true; + self->private_impl.f_lzw_pending_literal_width_plus_one = ((uint32_t)((1u + v_lw))); + self->private_impl.f_ignored_but_affects_benchmarks = true; ok: self->private_impl.p_decode_id_part1[0] = 0; @@ -38108,8 +38127,6 @@ wuffs_gif__decoder__decode_id_part2( wuffs_base__pixel_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__slice_u8 a_workbuf) { - wuffs_base__io_buffer empty_io_buffer = wuffs_base__empty_io_buffer(); - wuffs_base__status status = wuffs_base__make_status(NULL); uint64_t v_block_size = 0; @@ -38123,9 +38140,7 @@ wuffs_gif__decoder__decode_id_part2( const uint8_t* io1_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; const uint8_t* io2_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; uint64_t v_mark = 0; - wuffs_base__status v_lzw_status = wuffs_base__make_status(NULL); wuffs_base__status v_copy_status = wuffs_base__make_status(NULL); - wuffs_base__slice_u8 v_uncompressed = {0}; const uint8_t* iop_a_src = NULL; const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; @@ -38146,6 +38161,7 @@ wuffs_gif__decoder__decode_id_part2( switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + wuffs_gif__decoder__lzw_init(self); v_need_block_size = true; label__outer__continue:; while (true) { @@ -38193,7 +38209,7 @@ wuffs_gif__decoder__decode_id_part2( } while (true) { if ((self->private_impl.f_compressed_ri > self->private_impl.f_compressed_wi) || (self->private_impl.f_compressed_wi > 4096u)) { - status = wuffs_base__make_status(wuffs_gif__error__internal_error_inconsistent_ri_wi); + status = wuffs_base__make_status(wuffs_gif__error__internal_error_inconsistent_i_o); goto exit; } { @@ -38213,12 +38229,9 @@ wuffs_gif__decoder__decode_id_part2( self->private_impl.f_compressed_wi), 0u); v_mark = ((uint64_t)(iop_v_r - io0_v_r)); - { - u_r.meta.ri = ((size_t)(iop_v_r - u_r.data.ptr)); - wuffs_base__status t_1 = wuffs_lzw__decoder__transform_io(&self->private_data.f_lzw, &empty_io_buffer, v_r, wuffs_base__utility__empty_slice_u8()); - v_lzw_status = t_1; - iop_v_r = u_r.data.ptr + u_r.meta.ri; - } + u_r.meta.ri = ((size_t)(iop_v_r - u_r.data.ptr)); + wuffs_gif__decoder__lzw_read_from(self, v_r); + iop_v_r = u_r.data.ptr + u_r.meta.ri; wuffs_base__u64__sat_add_indirect(&self->private_impl.f_compressed_ri, wuffs_base__io__count_since(v_mark, ((uint64_t)(iop_v_r - io0_v_r)))); v_r = o_0_v_r; iop_v_r = o_0_iop_v_r; @@ -38226,16 +38239,19 @@ wuffs_gif__decoder__decode_id_part2( io1_v_r = o_0_io1_v_r; io2_v_r = o_0_io2_v_r; } - v_uncompressed = wuffs_lzw__decoder__flush(&self->private_data.f_lzw); - if (((uint64_t)(v_uncompressed.len)) > 0u) { - v_copy_status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst, v_uncompressed); + if (self->private_impl.f_lzw_output_ri < self->private_impl.f_lzw_output_wi) { + v_copy_status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst, wuffs_base__make_slice_u8_ij(self->private_data.f_lzw_output, + self->private_impl.f_lzw_output_ri, + self->private_impl.f_lzw_output_wi)); if (wuffs_base__status__is_error(&v_copy_status)) { status = v_copy_status; goto exit; } + self->private_impl.f_lzw_output_ri = 0u; + self->private_impl.f_lzw_output_wi = 0u; } - if (wuffs_base__status__is_ok(&v_lzw_status)) { - self->private_impl.f_previous_lzw_decode_ended_abruptly = false; + if (self->private_impl.f_lzw_read_from_return_value == 0u) { + self->private_impl.f_ignored_but_affects_benchmarks = false; if (v_need_block_size || (v_block_size > 0u)) { self->private_data.s_decode_id_part2[0].scratch = ((uint32_t)(v_block_size)); WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); @@ -38259,10 +38275,10 @@ wuffs_gif__decoder__decode_id_part2( } } goto label__outer__break; - } else if (v_lzw_status.repr == wuffs_base__suspension__short_read) { - goto label__outer__continue; - } else if (v_lzw_status.repr == wuffs_base__suspension__short_write) { + } else if (self->private_impl.f_lzw_read_from_return_value == 1u) { continue; + } else if (self->private_impl.f_lzw_read_from_return_value == 2u) { + goto label__outer__continue; } else if (self->private_impl.f_quirks[3u] && (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) && (self->private_impl.f_interlace == 0u)) { if (v_need_block_size || (v_block_size > 0u)) { self->private_data.s_decode_id_part2[0].scratch = ((uint32_t)(v_block_size)); @@ -38287,15 +38303,15 @@ wuffs_gif__decoder__decode_id_part2( } } goto label__outer__break; - } - status = v_lzw_status; - if (wuffs_base__status__is_error(&status)) { + } else if (self->private_impl.f_lzw_read_from_return_value == 3u) { + status = wuffs_base__make_status(wuffs_gif__error__truncated_input); goto exit; - } else if (wuffs_base__status__is_suspension(&status)) { - status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + } else if (self->private_impl.f_lzw_read_from_return_value == 4u) { + status = wuffs_base__make_status(wuffs_gif__error__bad_lzw_code); goto exit; } - goto ok; + status = wuffs_base__make_status(wuffs_gif__error__internal_error_inconsistent_i_o); + goto exit; } } label__outer__break:; @@ -38420,7 +38436,7 @@ wuffs_gif__decoder__copy_to_image_buffer( if (((uint64_t)(a_src.len)) == v_src_ri) { break; } else if (((uint64_t)(a_src.len)) < v_src_ri) { - return wuffs_base__make_status(wuffs_gif__error__internal_error_inconsistent_ri_wi); + return wuffs_base__make_status(wuffs_gif__error__internal_error_inconsistent_i_o); } v_n = ((uint64_t)((self->private_impl.f_frame_rect_x1 - self->private_impl.f_dst_x))); v_n = wuffs_base__u64__min(v_n, (((uint64_t)(a_src.len)) - v_src_ri)); @@ -38443,13 +38459,224 @@ wuffs_gif__decoder__copy_to_image_buffer( continue; } if (v_src_ri != ((uint64_t)(a_src.len))) { - return wuffs_base__make_status(wuffs_gif__error__internal_error_inconsistent_ri_wi); + return wuffs_base__make_status(wuffs_gif__error__internal_error_inconsistent_i_o); } break; } return wuffs_base__make_status(NULL); } +// -------- func gif.decoder.lzw_init + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_gif__decoder__lzw_init( + wuffs_gif__decoder* self) { + uint32_t v_i = 0; + + self->private_impl.f_lzw_literal_width = 8u; + if (self->private_impl.f_lzw_pending_literal_width_plus_one > 0u) { + self->private_impl.f_lzw_literal_width = (self->private_impl.f_lzw_pending_literal_width_plus_one - 1u); + } + self->private_impl.f_lzw_clear_code = (((uint32_t)(1u)) << self->private_impl.f_lzw_literal_width); + self->private_impl.f_lzw_end_code = (self->private_impl.f_lzw_clear_code + 1u); + self->private_impl.f_lzw_save_code = self->private_impl.f_lzw_end_code; + self->private_impl.f_lzw_prev_code = self->private_impl.f_lzw_end_code; + self->private_impl.f_lzw_width = (self->private_impl.f_lzw_literal_width + 1u); + self->private_impl.f_lzw_bits = 0u; + self->private_impl.f_lzw_n_bits = 0u; + self->private_impl.f_lzw_output_ri = 0u; + self->private_impl.f_lzw_output_wi = 0u; + v_i = 0u; + while (v_i < self->private_impl.f_lzw_clear_code) { + self->private_data.f_lzw_lm1s[v_i] = 0u; + self->private_data.f_lzw_suffixes[v_i][0u] = ((uint8_t)(v_i)); + v_i += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func gif.decoder.lzw_read_from + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_gif__decoder__lzw_read_from( + wuffs_gif__decoder* self, + wuffs_base__io_buffer* 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; + + const uint8_t* iop_a_src = NULL; + const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src && a_src->data.ptr) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + + v_clear_code = self->private_impl.f_lzw_clear_code; + v_end_code = self->private_impl.f_lzw_end_code; + v_save_code = self->private_impl.f_lzw_save_code; + v_prev_code = self->private_impl.f_lzw_prev_code; + v_width = self->private_impl.f_lzw_width; + v_bits = self->private_impl.f_lzw_bits; + v_n_bits = self->private_impl.f_lzw_n_bits; + v_output_wi = self->private_impl.f_lzw_output_wi; + while (true) { + if (v_n_bits < v_width) { + if (((uint64_t)(io2_a_src - iop_a_src)) >= 4u) { + v_bits |= ((uint32_t)(wuffs_base__peek_u32le__no_bounds_check(iop_a_src) << v_n_bits)); + iop_a_src += ((31u - v_n_bits) >> 3u); + v_n_bits |= 24u; + } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0u) { + if (a_src && a_src->meta.closed) { + self->private_impl.f_lzw_read_from_return_value = 3u; + } else { + self->private_impl.f_lzw_read_from_return_value = 2u; + } + break; + } else { + v_bits |= (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) << v_n_bits); + iop_a_src += 1u; + v_n_bits += 8u; + if (v_n_bits >= v_width) { + } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0u) { + if (a_src && a_src->meta.closed) { + self->private_impl.f_lzw_read_from_return_value = 3u; + } else { + self->private_impl.f_lzw_read_from_return_value = 2u; + } + break; + } else { + v_bits |= (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) << v_n_bits); + iop_a_src += 1u; + v_n_bits += 8u; + if (v_n_bits < v_width) { + self->private_impl.f_lzw_read_from_return_value = 5u; + 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_data.f_lzw_output[v_output_wi] = ((uint8_t)(v_code)); + v_output_wi = ((v_output_wi + 1u) & 8191u); + if (v_save_code <= 4095u) { + v_lm1_a = (((uint16_t)(self->private_data.f_lzw_lm1s[v_prev_code] + 1u)) & 4095u); + self->private_data.f_lzw_lm1s[v_save_code] = v_lm1_a; + if ((v_lm1_a % 8u) != 0u) { + self->private_impl.f_lzw_prefixes[v_save_code] = self->private_impl.f_lzw_prefixes[v_prev_code]; + memcpy(self->private_data.f_lzw_suffixes[v_save_code],self->private_data.f_lzw_suffixes[v_prev_code], sizeof(self->private_data.f_lzw_suffixes[v_save_code])); + self->private_data.f_lzw_suffixes[v_save_code][(v_lm1_a % 8u)] = ((uint8_t)(v_code)); + } else { + self->private_impl.f_lzw_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); + self->private_data.f_lzw_suffixes[v_save_code][0u] = ((uint8_t)(v_code)); + } + v_save_code += 1u; + if (v_width < 12u) { + v_width += (1u & (v_save_code >> v_width)); + } + v_prev_code = v_code; + } + } else if (v_code <= v_end_code) { + if (v_code == v_end_code) { + self->private_impl.f_lzw_read_from_return_value = 0u; + break; + } + v_save_code = v_end_code; + v_prev_code = v_end_code; + v_width = (self->private_impl.f_lzw_literal_width + 1u); + } 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_data.f_lzw_lm1s[v_c])) & 4294967288u)) & 8191u); + v_output_wi = ((v_output_wi + 1u + ((uint32_t)(self->private_data.f_lzw_lm1s[v_c]))) & 8191u); + v_steps = (((uint32_t)(self->private_data.f_lzw_lm1s[v_c])) >> 3u); + while (true) { + memcpy((self->private_data.f_lzw_output)+(v_o), (self->private_data.f_lzw_suffixes[v_c]), 8u); + if (v_steps <= 0u) { + break; + } + v_steps -= 1u; + v_o = (((uint32_t)(v_o - 8u)) & 8191u); + v_c = ((uint32_t)(self->private_impl.f_lzw_prefixes[v_c])); + } + v_first_byte = self->private_data.f_lzw_suffixes[v_c][0u]; + if (v_code == v_save_code) { + self->private_data.f_lzw_output[v_output_wi] = v_first_byte; + v_output_wi = ((v_output_wi + 1u) & 8191u); + } + if (v_save_code <= 4095u) { + v_lm1_b = (((uint16_t)(self->private_data.f_lzw_lm1s[v_prev_code] + 1u)) & 4095u); + self->private_data.f_lzw_lm1s[v_save_code] = v_lm1_b; + if ((v_lm1_b % 8u) != 0u) { + self->private_impl.f_lzw_prefixes[v_save_code] = self->private_impl.f_lzw_prefixes[v_prev_code]; + memcpy(self->private_data.f_lzw_suffixes[v_save_code],self->private_data.f_lzw_suffixes[v_prev_code], sizeof(self->private_data.f_lzw_suffixes[v_save_code])); + self->private_data.f_lzw_suffixes[v_save_code][(v_lm1_b % 8u)] = v_first_byte; + } else { + self->private_impl.f_lzw_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); + self->private_data.f_lzw_suffixes[v_save_code][0u] = ((uint8_t)(v_first_byte)); + } + v_save_code += 1u; + if (v_width < 12u) { + v_width += (1u & (v_save_code >> v_width)); + } + v_prev_code = v_code; + } + } else { + self->private_impl.f_lzw_read_from_return_value = 4u; + break; + } + if (v_output_wi > 4095u) { + self->private_impl.f_lzw_read_from_return_value = 1u; + break; + } + } + if (self->private_impl.f_lzw_read_from_return_value != 2u) { + while (v_n_bits >= 8u) { + v_n_bits -= 8u; + if (iop_a_src > io1_a_src) { + iop_a_src--; + } else { + self->private_impl.f_lzw_read_from_return_value = 5u; + break; + } + } + } + self->private_impl.f_lzw_save_code = v_save_code; + self->private_impl.f_lzw_prev_code = v_prev_code; + self->private_impl.f_lzw_width = v_width; + self->private_impl.f_lzw_bits = v_bits; + self->private_impl.f_lzw_n_bits = v_n_bits; + self->private_impl.f_lzw_output_wi = v_output_wi; + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return wuffs_base__make_empty_struct(); +} + #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GZIP) diff --git a/script/manual-test-truncated-input.cc b/script/manual-test-truncated-input.cc index 962f3314..6c31d19d 100644 --- a/script/manual-test-truncated-input.cc +++ b/script/manual-test-truncated-input.cc @@ -66,7 +66,6 @@ #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__GZIP #define WUFFS_CONFIG__MODULE__JPEG -#define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__NETPBM #define WUFFS_CONFIG__MODULE__NIE #define WUFFS_CONFIG__MODULE__PNG diff --git a/script/print-average-pixel.cc b/script/print-average-pixel.cc index 3f29fec3..35e5878d 100644 --- a/script/print-average-pixel.cc +++ b/script/print-average-pixel.cc @@ -58,7 +58,6 @@ to use the wuffs_aux C++ API to decode an image and iterate over its pixels. #define WUFFS_CONFIG__MODULE__DEFLATE #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__JPEG -#define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__NETPBM #define WUFFS_CONFIG__MODULE__NIE #define WUFFS_CONFIG__MODULE__PNG diff --git a/script/print-image-metadata.cc b/script/print-image-metadata.cc index 56bebac4..d6835121 100644 --- a/script/print-image-metadata.cc +++ b/script/print-image-metadata.cc @@ -54,7 +54,6 @@ print-image-metadata prints images' metadata. #define WUFFS_CONFIG__MODULE__DEFLATE #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__JPEG -#define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__NETPBM #define WUFFS_CONFIG__MODULE__NIE #define WUFFS_CONFIG__MODULE__PNG diff --git a/std/gif/common_consts.wuffs b/std/gif/common_consts.wuffs index 8e3af006..3121dfa1 100644 --- a/std/gif/common_consts.wuffs +++ b/std/gif/common_consts.wuffs @@ -12,8 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. +// TODO: remove this no-longer-used `use` line. That affects the topological +// sort of std/etc packages, which makes a large diff for the generated C code. use "std/lzw" +pub status "#bad LZW code" pub status "#bad extension label" pub status "#bad frame size" pub status "#bad graphic control" @@ -22,7 +25,7 @@ pub status "#bad literal width" pub status "#bad palette" pub status "#truncated input" -pri status "#internal error: inconsistent ri/wi" +pri status "#internal error: inconsistent I/O" pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs index 0131bef0..bebcb069 100644 --- a/std/gif/decode_gif.wuffs +++ b/std/gif/decode_gif.wuffs @@ -35,9 +35,13 @@ pub struct decoder? implements base.image_decoder( quirks : array[QUIRKS_COUNT] base.bool, - delayed_num_decoded_frames : base.bool, - previous_lzw_decode_ended_abruptly : base.bool, - seen_header : base.bool, + delayed_num_decoded_frames : base.bool, + seen_header : base.bool, + + // This field used to be called "previous_lzw_decode_ended_abruptly". + // It's no longer used, but removing it changes the subsequent field + // offsets, which can worsen the benchmarks. + ignored_but_affects_benchmarks : base.bool, has_global_palette : base.bool, @@ -79,6 +83,20 @@ pub struct decoder? implements base.image_decoder( swizzler : base.pixel_swizzler, + lzw_pending_literal_width_plus_one : base.u32[..= 9], + lzw_literal_width : base.u32[..= 8], + lzw_clear_code : base.u32[..= 256], + lzw_end_code : base.u32[..= 257], + lzw_save_code : base.u32[..= 4096], + lzw_prev_code : base.u32[..= 4095], + lzw_width : base.u32[..= 12], + lzw_bits : base.u32, + lzw_n_bits : base.u32[..= 31], + lzw_output_ri : base.u32[..= 8191], + lzw_output_wi : base.u32[..= 8191], + lzw_read_from_return_value : base.u32, + lzw_prefixes : array[4096] base.u16[..= 4095], + util : base.utility, ) + ( compressed : array[4096] base.u8, @@ -88,7 +106,9 @@ pub struct decoder? implements base.image_decoder( // dst_palette is the swizzled color table. dst_palette : array[4 * 256] base.u8, - lzw : lzw.decoder, + lzw_suffixes : array[4096] array[8] base.u8, + lzw_lm1s : array[4096] base.u16, + lzw_output : array[8192 + 7] base.u8, ) pub func decoder.get_quirk(key: base.u32) base.u64 { @@ -905,8 +925,8 @@ pri func decoder.decode_id_part1?(dst: ptr base.pixel_buffer, src: base.io_reade // code (i.e. returning the "ok" status code), the LZW decoder is stuck in // a coroutine-in-progress lzw_decoder.decode call, still waiting for that // end code. To cancel that coroutine, we reset the LZW decoder. - if this.previous_lzw_decode_ended_abruptly { - this.lzw.reset!() + if this.ignored_but_affects_benchmarks { + // No-op. This used to be "this.lzw.reset!()". } // Process the LZW literal width. The spec says that "images which have one @@ -916,9 +936,9 @@ pri func decoder.decode_id_part1?(dst: ptr base.pixel_buffer, src: base.io_reade if lw > 8 { return "#bad literal width" } - this.lzw.set_quirk!(key: lzw.QUIRK_LITERAL_WIDTH_PLUS_ONE, value: (1 + lw) as base.u64) + this.lzw_pending_literal_width_plus_one = (1 + lw) as base.u32 - this.previous_lzw_decode_ended_abruptly = true + this.ignored_but_affects_benchmarks = true } pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reader, workbuf: slice base.u8) { @@ -928,10 +948,9 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade var n_compressed : base.u64 var r : base.io_reader var mark : base.u64 - var lzw_status : base.status var copy_status : base.status - var uncompressed : roslice base.u8 + this.lzw_init!() need_block_size = true while.outer true { if need_block_size { @@ -972,50 +991,56 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade while.inner true { if (this.compressed_ri > this.compressed_wi) or (this.compressed_wi > 4096) { - return "#internal error: inconsistent ri/wi" + return "#internal error: inconsistent I/O" } io_bind (io: r, data: this.compressed[this.compressed_ri .. this.compressed_wi], history_position: 0) { mark = r.mark() - lzw_status =? this.lzw.transform_io?( - dst: this.util.empty_io_writer(), src: r, workbuf: this.util.empty_slice_u8()) + this.lzw_read_from!(src: r) this.compressed_ri ~sat+= r.count_since(mark: mark) } - uncompressed = this.lzw.flush!() - if uncompressed.length() > 0 { - copy_status = this.copy_to_image_buffer!(pb: args.dst, src: uncompressed) + if this.lzw_output_ri < this.lzw_output_wi { + copy_status = this.copy_to_image_buffer!( + pb: args.dst, src: this.lzw_output[this.lzw_output_ri .. this.lzw_output_wi]) if copy_status.is_error() { return copy_status } + this.lzw_output_ri = 0 + this.lzw_output_wi = 0 } - if lzw_status.is_ok() { - this.previous_lzw_decode_ended_abruptly = false + if this.lzw_read_from_return_value == 0 { + this.ignored_but_affects_benchmarks = false // Skip any trailing blocks. if need_block_size or (block_size > 0) { args.src.skip_u32?(n: block_size as base.u32) this.skip_blocks?(src: args.src) } - break.outer - } else if lzw_status == base."$short read" { - continue.outer - } else if lzw_status == base."$short write" { + } else if this.lzw_read_from_return_value == 1 { + // This is an LZW flush. continue.inner + } else if this.lzw_read_from_return_value == 2 { + // This is an LZW "$short read" equivalent. + continue.outer } else if this.quirks[QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA - QUIRKS_BASE] and (this.dst_y >= this.frame_rect_y1) and (this.interlace == 0) { // It's invalid LZW-compressed data, but we still have a full // frame and have opted in to QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, - // so treat it like the lzw_status.is_ok() case, other than not - // clearing this.previous_lzw_decode_ended_abruptly. + // so treat it like the OK case, other than not clearing + // this.ignored_but_affects_benchmarks. if need_block_size or (block_size > 0) { args.src.skip_u32?(n: block_size as base.u32) this.skip_blocks?(src: args.src) } break.outer + } else if this.lzw_read_from_return_value == 3 { + return "#truncated input" + } else if this.lzw_read_from_return_value == 4 { + return "#bad LZW code" } - return lzw_status + return "#internal error: inconsistent I/O" } endwhile.inner } endwhile.outer @@ -1137,7 +1162,7 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: roslice b if args.src.length() == src_ri { break } else if args.src.length() < src_ri { - return "#internal error: inconsistent ri/wi" + return "#internal error: inconsistent I/O" } // Second, skip over src for that part of the frame rect that is @@ -1161,7 +1186,7 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: roslice b } if src_ri <> args.src.length() { - return "#internal error: inconsistent ri/wi" + return "#internal error: inconsistent I/O" } break } endwhile diff --git a/std/gif/decode_lzw.wuffs b/std/gif/decode_lzw.wuffs new file mode 100644 index 00000000..7c836d3b --- /dev/null +++ b/std/gif/decode_lzw.wuffs @@ -0,0 +1,264 @@ +// Copyright 2023 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// -------- + +// This file (in std/gif) is a fork of std/lzw/decode_lzw.wuffs, inlined so +// that the gif 'caller' can take the this.lzw_output[this.lzw_output_ri .. +// this.lzw_output_wi] slice directly. Wuffs version 0.3 provided this as the +// lzw.decoder.flush!() method, but we'd like to deprecate (and eventually +// remove) methods that return anything pointer-y (including slices). +// +// It also changes the ? methods to ! methods, so that the LZW-decoder does not +// need a "this.lzw.reset!()" call in case of a recoverable error. + +pri func decoder.lzw_init!() { + var i : base.u32[..= 8191] + + this.lzw_literal_width = 8 + if this.lzw_pending_literal_width_plus_one > 0 { + this.lzw_literal_width = this.lzw_pending_literal_width_plus_one - 1 + } + this.lzw_clear_code = (1 as base.u32) << this.lzw_literal_width + this.lzw_end_code = this.lzw_clear_code + 1 + this.lzw_save_code = this.lzw_end_code + this.lzw_prev_code = this.lzw_end_code + this.lzw_width = this.lzw_literal_width + 1 + this.lzw_bits = 0 + this.lzw_n_bits = 0 + this.lzw_output_ri = 0 + this.lzw_output_wi = 0 + i = 0 + while i < this.lzw_clear_code { + assert i < 256 via "a < b: a < c; c <= b"(c: this.lzw_clear_code) + this.lzw_lm1s[i] = 0 + this.lzw_suffixes[i][0] = i as base.u8 + i += 1 + } endwhile +} + +pri func decoder.lzw_read_from!(src: base.io_reader) { + var clear_code : base.u32[..= 256] + var end_code : base.u32[..= 257] + + var save_code : base.u32[..= 4096] + var prev_code : base.u32[..= 4095] + var width : base.u32[..= 12] + var bits : base.u32 + var n_bits : base.u32[..= 31] + var output_wi : base.u32[..= 8191] + + var code : base.u32[..= 4095] + var c : base.u32[..= 4095] + var o : base.u32[..= 8191] + var steps : base.u32 + var first_byte : base.u8 + var lm1_b : base.u16[..= 4095] + var lm1_a : base.u16[..= 4095] + + clear_code = this.lzw_clear_code + end_code = this.lzw_end_code + + save_code = this.lzw_save_code + prev_code = this.lzw_prev_code + width = this.lzw_width + bits = this.lzw_bits + n_bits = this.lzw_n_bits + output_wi = this.lzw_output_wi + + while true { + if n_bits < width { + assert n_bits < 12 via "a < b: a < c; c <= b"(c: width) + if args.src.length() >= 4 { + // Read 4 bytes, using the "Variant 4" technique of + // https://fgiesen.wordpress.com/2018/02/20/reading-bits-in-far-too-many-ways-part-2/ + bits |= args.src.peek_u32le() ~mod<< n_bits + args.src.skip_u32_fast!(actual: (31 - n_bits) >> 3, worst_case: 3) + n_bits |= 24 + assert width <= n_bits via "a <= b: a <= c; c <= b"(c: 12) + assert n_bits >= width via "a >= b: b <= a"() + } else if args.src.length() <= 0 { + if args.src.is_closed() { + this.lzw_read_from_return_value = 3 + } else { + this.lzw_read_from_return_value = 2 + } + break + } else { + bits |= args.src.peek_u8_as_u32() << n_bits + args.src.skip_u32_fast!(actual: 1, worst_case: 1) + n_bits += 8 + if n_bits >= width { + // No-op. + } else if args.src.length() <= 0 { + if args.src.is_closed() { + this.lzw_read_from_return_value = 3 + } else { + this.lzw_read_from_return_value = 2 + } + break + } else { + bits |= args.src.peek_u8_as_u32() << n_bits + args.src.skip_u32_fast!(actual: 1, worst_case: 1) + n_bits += 8 + assert width <= n_bits via "a <= b: a <= c; c <= b"(c: 12) + assert n_bits >= width via "a >= b: b <= a"() + + // This if condition is always false, but for some unknown + // reason, removing it worsens the benchmarks slightly. + if n_bits < width { + this.lzw_read_from_return_value = 5 + break + } + } + } + } + + code = bits.low_bits(n: width) + bits >>= width + n_bits -= width + + if code < clear_code { + assert code < 256 via "a < b: a < c; c <= b"(c: clear_code) + this.lzw_output[output_wi] = code as base.u8 + output_wi = (output_wi + 1) & 8191 + if save_code <= 4095 { + lm1_a = (this.lzw_lm1s[prev_code] ~mod+ 1) & 4095 + this.lzw_lm1s[save_code] = lm1_a + + if (lm1_a % 8) <> 0 { + this.lzw_prefixes[save_code] = this.lzw_prefixes[prev_code] + this.lzw_suffixes[save_code] = this.lzw_suffixes[prev_code] + this.lzw_suffixes[save_code][lm1_a % 8] = code as base.u8 + } else { + this.lzw_prefixes[save_code] = prev_code as base.u16 + this.lzw_suffixes[save_code][0] = code as base.u8 + } + + save_code += 1 + if width < 12 { + width += 1 & (save_code >> width) + } + prev_code = code + } + + } else if code <= end_code { + if code == end_code { + this.lzw_read_from_return_value = 0 + break + } + save_code = end_code + prev_code = end_code + width = this.lzw_literal_width + 1 + + } else if code <= save_code { + c = code + if code == save_code { + c = prev_code + } + + // Letting old_wi and new_wi denote the values of output_wi before + // and after these two lines of code, the decoded bytes will be + // written to output[old_wi:new_wi]. They will be written + // back-to-front, 8 bytes at a time, starting by writing + // output[o:o + 8], which will contain output[new_wi - 1]. + // + // In the special case that code == save_code, the decoded bytes + // contain an extra copy (at the end) of the first byte, and will + // be written to output[old_wi:new_wi + 1]. + o = (output_wi + ((this.lzw_lm1s[c] as base.u32) & 0xFFFF_FFF8)) & 8191 + output_wi = (output_wi + 1 + (this.lzw_lm1s[c] as base.u32)) & 8191 + + steps = (this.lzw_lm1s[c] as base.u32) >> 3 + while true { + assert o <= (o + 8) via "a <= (a + b): 0 <= b"(b: 8) + + // The final "8" is redundant semantically, but helps the + // wuffs-c code generator recognize that both slices have the + // same constant length, and hence produce efficient C code. + this.lzw_output[o .. o + 8].copy_from_slice!(s: this.lzw_suffixes[c][.. 8]) + + if steps <= 0 { + break + } + steps -= 1 + + // This line is essentially "o -= 8". The "& 8191" is a no-op + // in practice, but is necessary for the overflow checker. + o = (o ~mod- 8) & 8191 + c = this.lzw_prefixes[c] as base.u32 + } endwhile + first_byte = this.lzw_suffixes[c][0] + + if code == save_code { + this.lzw_output[output_wi] = first_byte + output_wi = (output_wi + 1) & 8191 + } + + if save_code <= 4095 { + lm1_b = (this.lzw_lm1s[prev_code] ~mod+ 1) & 4095 + this.lzw_lm1s[save_code] = lm1_b + + if (lm1_b % 8) <> 0 { + this.lzw_prefixes[save_code] = this.lzw_prefixes[prev_code] + this.lzw_suffixes[save_code] = this.lzw_suffixes[prev_code] + this.lzw_suffixes[save_code][lm1_b % 8] = first_byte + } else { + this.lzw_prefixes[save_code] = prev_code as base.u16 + this.lzw_suffixes[save_code][0] = first_byte as base.u8 + } + + save_code += 1 + if width < 12 { + width += 1 & (save_code >> width) + } + prev_code = code + } + + } else { + this.lzw_read_from_return_value = 4 + break + } + + // Flush the output if it could be too full to contain the entire + // decoding of the next code. The longest possible decoding is slightly + // less than 4096 and output's length is 8192, so a conservative + // threshold is ensuring that output_wi <= 4095. + if output_wi > 4095 { + this.lzw_read_from_return_value = 1 + break + } + } endwhile + + // Rewind args.src, if we're not in "$short read" and we've read too many + // bits. + if this.lzw_read_from_return_value <> 2 { + while n_bits >= 8 { + n_bits -= 8 + if args.src.can_undo_byte() { + args.src.undo_byte!() + } else { + this.lzw_read_from_return_value = 5 + break + } + } endwhile + } + + this.lzw_save_code = save_code + this.lzw_prev_code = prev_code + this.lzw_width = width + this.lzw_bits = bits + this.lzw_n_bits = n_bits + this.lzw_output_wi = output_wi +} diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs index 3112f9b0..75f75e67 100644 --- a/std/lzw/decode_lzw.wuffs +++ b/std/lzw/decode_lzw.wuffs @@ -375,6 +375,10 @@ pri func decoder.write_to?(dst: base.io_writer) { } endwhile } +// Deprecated. Use transform_io and an io_writer instead. +// +// We'd like to deprecate (and eventually remove) methods that return anything +// pointer-y (including slices). pub func decoder.flush!() roslice base.u8 { var ri : base.u32[..= 8191] var wi : base.u32[..= 8191] diff --git a/test/c/std/gif.c b/test/c/std/gif.c index fe184826..92bcc05a 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -57,7 +57,6 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the #define WUFFS_CONFIG__MODULES #define WUFFS_CONFIG__MODULE__BASE #define WUFFS_CONFIG__MODULE__GIF -#define WUFFS_CONFIG__MODULE__LZW // If building this program in an environment that doesn't easily accommodate // relative includes, you can use the script/inline-c-relative-includes.go @@ -148,25 +147,6 @@ test_basic_status_is_error() { return NULL; } -const char* // -test_basic_sub_struct_initializer() { - CHECK_FOCUS(__func__); - wuffs_gif__decoder dec; - CHECK_STATUS("initialize", - wuffs_gif__decoder__initialize( - &dec, sizeof dec, WUFFS_VERSION, - WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); - if (dec.private_impl.magic != WUFFS_BASE__MAGIC) { - RETURN_FAIL("outer magic: have %" PRIu32 ", want %" PRIu32 "", - dec.private_impl.magic, WUFFS_BASE__MAGIC); - } - if (dec.private_data.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) { - RETURN_FAIL("inner magic: have %" PRIu32 ", want %" PRIu32, - dec.private_data.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC); - } - return NULL; -} - // ---------------- GIF Tests const char* // @@ -1637,7 +1617,7 @@ test_wuffs_gif_decode_pixel_data_too_much_sans_quirk() { CHECK_STRING(read_file( &src, "test/data/artificial-gif/pixel-data-too-much-bad-lzw.gif")); CHECK_STRING(do_test_wuffs_gif_decode_expecting( - src, 0, wuffs_lzw__error__bad_code, false)); + src, 0, wuffs_gif__error__bad_lzw_code, false)); src.meta = wuffs_base__empty_io_buffer_meta(); CHECK_STRING(read_file( @@ -2351,7 +2331,6 @@ proc g_tests[] = { test_basic_bad_wuffs_version, test_basic_initialize_not_called, test_basic_status_is_error, - test_basic_sub_struct_initializer, test_wuffs_gif_call_interleaved, test_wuffs_gif_call_sequence,