From b0429923fc13eb08757f5344d1f2751e9a7ee3bd Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 22 Dec 2018 15:03:00 +1100 Subject: [PATCH] wuffs gen -version=0.2.0-alpha.24 --- release/c/wuffs-v0.2.h | 745 ++++++++++++++++++++++++----------------- 1 file changed, 437 insertions(+), 308 deletions(-) diff --git a/release/c/wuffs-v0.2.h b/release/c/wuffs-v0.2.h index c2bf7a3f..59eab82c 100644 --- a/release/c/wuffs-v0.2.h +++ b/release/c/wuffs-v0.2.h @@ -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-08 UTC, -// based on revision 45ab79b451deda28a0898c51987bb03b37c1076f. +// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-12-22 UTC, +// based on revision 179f7afb9b0782d2f89367de81b7a0bb26b87e5b. #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.23" -#define WUFFS_VERSION_STRING "0.2.0-alpha.23" +#define WUFFS_VERSION_EXTENSION "alpha.24" +#define WUFFS_VERSION_STRING "0.2.0-alpha.24" // Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have // static storage. The motivation is discussed in the "ALLOW STATIC @@ -1225,8 +1225,8 @@ typedef uint32_t wuffs_base__color_u32_argb_premul; // image frame's pixel data. Its bits: // - bit 31 is reserved. // - bits 30 .. 28 encodes color (and channel order, in terms of memory). -// - bits 27 .. 26 are reserved. -// - bits 25 .. 24 encodes transparency. +// - bit 27 is reserved. +// - bits 26 .. 24 encodes transparency. // - bits 23 .. 21 are reserved. // - bit 20 indicates big-endian/MSB-first (as opposed to little/LSB). // - bit 19 indicates floating point (as opposed to integer). @@ -1277,11 +1277,17 @@ typedef uint32_t wuffs_base__color_u32_argb_premul; // little-endian, 0xAARRGGBB. // // When the color field (3 bits) encodes multiple options, the transparency -// field (2 bits) distinguishes them: +// field (3 bits) distinguishes them: // - 0 means fully opaque, no extra channels // - 1 means fully opaque, one extra channel (X or K, padding or black). -// - 2 means one extra alpha channel, other channels are non-premultiplied. -// - 3 means one extra alpha channel, other channels are premultiplied. +// - 5 means one extra alpha channel, other channels are non-premultiplied. +// - 6 means one extra alpha channel, other channels are premultiplied. +// - 7 means one extra alpha channel, binary alpha. +// - all other values are reserved. +// +// Binary alpha means that if a color is not completely opaque, it is +// completely transparent black. As a source pixel format, it can therefore be +// treated as either non-premultiplied or premultiplied. // // The zero wuffs_base__pixel_format value is an invalid pixel format, as it is // invalid to combine the zero color (alpha only) with the zero transparency. @@ -1297,7 +1303,7 @@ typedef uint32_t wuffs_base__color_u32_argb_premul; // - 14 means a bit depth of 48. // - 15 means a bit depth of 64. // -// For example, wuffs_base__pixel_format 0x5210BBBB is a natural format for +// For example, wuffs_base__pixel_format 0x5510BBBB is a natural format for // decoding a PNG image - network byte order (also known as big-endian), // packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor // with alpha (RGBA). In memory order: @@ -1343,36 +1349,44 @@ typedef uint32_t wuffs_base__pixel_format; #define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base__pixel_format)0x10000008) #define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \ - ((wuffs_base__pixel_format)0x12000008) + ((wuffs_base__pixel_format)0x15000008) #define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \ - ((wuffs_base__pixel_format)0x13000008) + ((wuffs_base__pixel_format)0x16000008) #define WUFFS_BASE__PIXEL_FORMAT__YCBCR ((wuffs_base__pixel_format)0x20020888) #define WUFFS_BASE__PIXEL_FORMAT__YCBCRK ((wuffs_base__pixel_format)0x21038888) #define WUFFS_BASE__PIXEL_FORMAT__YCBCRA_NONPREMUL \ - ((wuffs_base__pixel_format)0x22038888) + ((wuffs_base__pixel_format)0x25038888) #define WUFFS_BASE__PIXEL_FORMAT__YCOCG ((wuffs_base__pixel_format)0x30020888) #define WUFFS_BASE__PIXEL_FORMAT__YCOCGK ((wuffs_base__pixel_format)0x31038888) #define WUFFS_BASE__PIXEL_FORMAT__YCOCGA_NONPREMUL \ - ((wuffs_base__pixel_format)0x32038888) + ((wuffs_base__pixel_format)0x35038888) #define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL \ - ((wuffs_base__pixel_format)0x42040008) + ((wuffs_base__pixel_format)0x45040008) +#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL \ + ((wuffs_base__pixel_format)0x46040008) +#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY \ + ((wuffs_base__pixel_format)0x47040008) #define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x40000888) #define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x41008888) #define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \ - ((wuffs_base__pixel_format)0x42008888) + ((wuffs_base__pixel_format)0x45008888) #define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \ - ((wuffs_base__pixel_format)0x43008888) + ((wuffs_base__pixel_format)0x46008888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY \ + ((wuffs_base__pixel_format)0x47008888) #define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x50000888) #define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x51008888) #define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL \ - ((wuffs_base__pixel_format)0x52008888) + ((wuffs_base__pixel_format)0x55008888) #define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \ - ((wuffs_base__pixel_format)0x53008888) + ((wuffs_base__pixel_format)0x56008888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY \ + ((wuffs_base__pixel_format)0x57008888) #define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x60020888) #define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x61038888) @@ -1582,10 +1596,16 @@ wuffs_base__pixel_config__pixbuf_len(wuffs_base__pixel_config* c) { uint64_t bytes_per_pixel = 0; switch (wuffs_base__pixel_config__pixel_format(c)) { case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: bytes_per_pixel = 1; break; case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: bytes_per_pixel = 4; break; default: @@ -2049,10 +2069,16 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b, uint64_t bytes_per_pixel = 0; switch (wuffs_base__pixel_config__pixel_format(pixcfg)) { case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: bytes_per_pixel = 1; break; case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: bytes_per_pixel = 4; break; default: @@ -2565,6 +2591,9 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, wuffs_base__io_writer a_dst, wuffs_base__io_reader a_src); +WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 // +wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self); + // ---------------- Struct Definitions // These structs' fields, and the sizeof them, are private implementation @@ -2600,6 +2629,7 @@ struct wuffs_lzw__decoder__struct { 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; @@ -2607,8 +2637,7 @@ struct wuffs_lzw__decoder__struct { struct { uint32_t coro_susp_point; uint32_t v_i; - uint32_t v_j; - } c_flush[1]; + } c_auto_flush[1]; } private_impl; #ifdef __cplusplus @@ -2629,6 +2658,11 @@ struct wuffs_lzw__decoder__struct { return wuffs_lzw__decoder__decode(this, a_dst, a_src); } + inline wuffs_base__slice_u8 // + flush() { + return wuffs_lzw__decoder__flush(this); + } + #endif // __cplusplus }; // struct wuffs_lzw__decoder__struct @@ -2758,9 +2792,9 @@ struct wuffs_gif__decoder__struct { uint32_t f_dst_x; uint32_t f_dst_y; wuffs_base__range_ie_u32 f_dirty_y; - uint32_t f_uncompressed_ri; - uint32_t f_uncompressed_wi; - uint8_t f_uncompressed[4096]; + uint64_t f_compressed_ri; + uint64_t f_compressed_wi; + uint8_t f_compressed[4096]; uint8_t f_palettes[2][1024]; uint8_t f_dst_palette[1024]; wuffs_base__pixel_swizzler f_swizzler; @@ -2822,6 +2856,7 @@ struct wuffs_gif__decoder__struct { uint32_t v_num_palette_entries; uint32_t v_i; uint64_t v_block_size; + wuffs_base__status v_z; uint64_t scratch; } c_decode_id_part1[1]; } private_impl; @@ -3560,7 +3595,7 @@ wuffs_base__range_ie_u64__get_max_excl(const wuffs_base__range_ie_u64* r) { return r->max_excl; } -// ---------------- Utility +// ---------------- Ranges and Rects (Utility) static inline wuffs_base__range_ii_u32 // wuffs_base__utility__make_range_ii_u32(const wuffs_base__utility* ignored, @@ -3677,20 +3712,20 @@ wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { } static inline uint32_t // -wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr, - uint8_t* start, - uint8_t* end, +wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_iop_w, + uint8_t* io0_w, + uint8_t* io1_w, uint32_t length, uint32_t distance) { if (!distance) { return 0; } - uint8_t* ptr = *ptr_ptr; - if ((size_t)(ptr - start) < (size_t)(distance)) { + uint8_t* p = *ptr_iop_w; + if ((size_t)(p - io0_w) < (size_t)(distance)) { return 0; } - start = ptr - distance; - size_t n = end - ptr; + uint8_t* q = p - distance; + size_t n = io1_w - p; if ((size_t)(length) > n) { length = n; } else { @@ -3707,14 +3742,14 @@ wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr, // Alternatively, or additionally, have a sloppy_copy_n_from_history method // that copies 8 bytes at a time, possibly writing more than length bytes? for (; n >= 3; n -= 3) { - *ptr++ = *start++; - *ptr++ = *start++; - *ptr++ = *start++; + *p++ = *q++; + *p++ = *q++; + *p++ = *q++; } for (; n; n--) { - *ptr++ = *start++; + *p++ = *q++; } - *ptr_ptr = ptr; + *ptr_iop_w = p; return length; } @@ -3722,94 +3757,114 @@ wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr, // wuffs_base__io_writer__copy_n_from_history function above, but has stronger // pre-conditions. The caller needs to prove that: // - distance > 0 -// - distance <= (*ptr_ptr - start) -// - length <= (end - *ptr_ptr) +// - distance <= (*ptr_iop_w - io0_w) +// - length <= (io1_w - *ptr_iop_w) static inline uint32_t // -wuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr, - uint8_t* start, - uint8_t* end, +wuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_iop_w, + uint8_t* io0_w, + uint8_t* io1_w, uint32_t length, uint32_t distance) { - uint8_t* ptr = *ptr_ptr; - start = ptr - distance; + uint8_t* p = *ptr_iop_w; + uint8_t* q = p - distance; uint32_t n = length; for (; n >= 3; n -= 3) { - *ptr++ = *start++; - *ptr++ = *start++; - *ptr++ = *start++; + *p++ = *q++; + *p++ = *q++; + *p++ = *q++; } for (; n; n--) { - *ptr++ = *start++; + *p++ = *q++; } - *ptr_ptr = ptr; + *ptr_iop_w = p; return length; } static inline uint32_t // -wuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, +wuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_iop_w, + uint8_t* io1_w, uint32_t length, - uint8_t** ptr_ioptr_r, - uint8_t* iobounds1_r) { - uint8_t* ioptr_w = *ptr_ioptr_w; + uint8_t** ptr_iop_r, + uint8_t* io1_r) { + uint8_t* iop_w = *ptr_iop_w; size_t n = length; - if (n > ((size_t)(iobounds1_w - ioptr_w))) { - n = iobounds1_w - ioptr_w; + if (n > ((size_t)(io1_w - iop_w))) { + n = io1_w - iop_w; } - uint8_t* ioptr_r = *ptr_ioptr_r; - if (n > ((size_t)(iobounds1_r - ioptr_r))) { - n = iobounds1_r - ioptr_r; + uint8_t* iop_r = *ptr_iop_r; + if (n > ((size_t)(io1_r - iop_r))) { + n = io1_r - iop_r; } if (n > 0) { - memmove(ioptr_w, ioptr_r, n); - *ptr_ioptr_w += n; - *ptr_ioptr_r += n; + memmove(iop_w, iop_r, n); + *ptr_iop_w += n; + *ptr_iop_r += n; } return n; } static inline uint64_t // -wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, +wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w, + uint8_t* io1_w, wuffs_base__slice_u8 src) { - uint8_t* ioptr_w = *ptr_ioptr_w; + uint8_t* iop_w = *ptr_iop_w; size_t n = src.len; - if (n > ((size_t)(iobounds1_w - ioptr_w))) { - n = iobounds1_w - ioptr_w; + if (n > ((size_t)(io1_w - iop_w))) { + n = io1_w - iop_w; } if (n > 0) { - memmove(ioptr_w, src.ptr, n); - *ptr_ioptr_w += n; + memmove(iop_w, src.ptr, n); + *ptr_iop_w += n; } return n; } static inline uint32_t // -wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, +wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_iop_w, + uint8_t* io1_w, uint32_t length, wuffs_base__slice_u8 src) { - uint8_t* ioptr_w = *ptr_ioptr_w; + uint8_t* iop_w = *ptr_iop_w; size_t n = src.len; if (n > length) { n = length; } - if (n > ((size_t)(iobounds1_w - ioptr_w))) { - n = iobounds1_w - ioptr_w; + if (n > ((size_t)(io1_w - iop_w))) { + n = io1_w - iop_w; } if (n > 0) { - memmove(ioptr_w, src.ptr, n); - *ptr_ioptr_w += n; + memmove(iop_w, src.ptr, n); + *ptr_iop_w += n; } return n; } +static inline wuffs_base__empty_struct // +wuffs_base__io_reader__set(wuffs_base__io_reader* o, + wuffs_base__io_buffer* b, + uint8_t** ptr_iop_r, + uint8_t** ptr_io1_r, + wuffs_base__slice_u8 data) { + b->data = data; + b->meta.wi = data.len; + b->meta.ri = 0; + b->meta.pos = 0; + b->meta.closed = false; + + o->private_impl.buf = b; + o->private_impl.mark = data.ptr; + o->private_impl.limit = data.ptr + data.len; + *ptr_iop_r = data.ptr; + *ptr_io1_r = data.ptr + data.len; + return ((wuffs_base__empty_struct){}); +} + static inline wuffs_base__empty_struct // wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o, - uint8_t* ioptr_r, + uint8_t* iop_r, uint64_t limit) { - if (o && (((size_t)(o->private_impl.limit - ioptr_r)) > limit)) { - o->private_impl.limit = ioptr_r + limit; + if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) { + o->private_impl.limit = iop_r + limit; } return ((wuffs_base__empty_struct){}); } @@ -3820,24 +3875,36 @@ wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) { return ((wuffs_base__empty_struct){}); } +static inline wuffs_base__slice_u8 // +wuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) { + if (n <= ((size_t)(io1_r - *ptr_iop_r))) { + uint8_t* p = *ptr_iop_r; + *ptr_iop_r += n; + return ((wuffs_base__slice_u8){ + .ptr = p, + .len = n, + }); + } + return ((wuffs_base__slice_u8){}); +} + static inline wuffs_base__empty_struct // wuffs_base__io_writer__set(wuffs_base__io_writer* o, wuffs_base__io_buffer* b, - uint8_t** ioptr1_ptr, - uint8_t** ioptr2_ptr, - wuffs_base__slice_u8 s) { - b->data.ptr = s.ptr; - b->data.len = s.len; + uint8_t** ptr_iop_w, + uint8_t** ptr_io1_w, + wuffs_base__slice_u8 data) { + b->data = data; b->meta.wi = 0; b->meta.ri = 0; b->meta.pos = 0; b->meta.closed = false; o->private_impl.buf = b; - o->private_impl.mark = s.ptr; - o->private_impl.limit = s.ptr + s.len; - *ioptr1_ptr = s.ptr; - *ioptr2_ptr = s.ptr + s.len; + o->private_impl.mark = data.ptr; + o->private_impl.limit = data.ptr + data.len; + *ptr_iop_w = data.ptr; + *ptr_io1_w = data.ptr + data.len; return ((wuffs_base__empty_struct){}); } @@ -3847,6 +3914,18 @@ wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) { return ((wuffs_base__empty_struct){}); } +// ---------------- I/O (Utility) + +static inline wuffs_base__io_reader // +wuffs_base__utility__null_io_reader(const wuffs_base__utility* ignored) { + return ((wuffs_base__io_reader){}); +} + +static inline wuffs_base__io_writer // +wuffs_base__utility__null_io_writer(const wuffs_base__utility* ignored) { + return ((wuffs_base__io_writer){}); +} + // ---------------- Memory Allocation // ---------------- Images @@ -3995,9 +4074,11 @@ wuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p, wuffs_base__slice_u8 src) = NULL; switch (src_format) { - case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: switch (dst_format) { case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) != 1024) { break; @@ -4005,6 +4086,8 @@ wuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p, func = wuffs_base__pixel_swizzler__copy_1_1; break; case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) != 1024) { break; @@ -4012,6 +4095,8 @@ wuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p, func = wuffs_base__pixel_swizzler__copy_4_1; break; case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette, src_palette) != 1024) { break; @@ -6446,20 +6531,11 @@ label_0_continue:; v_n_copied = 0; while (true) { if (((uint64_t)((v_dist_minus_1 + 1))) > - ((uint64_t)(((wuffs_base__slice_u8){ - .ptr = a_dst.private_impl.mark, - .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), - }) - .len))) { + ((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)( - ((wuffs_base__slice_u8){ - .ptr = a_dst.private_impl.mark, - .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), - }) - .len))))); + v_hdist = + ((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) - + ((uint64_t)(iop_a_dst - a_dst.private_impl.mark))))); if (v_length > v_hdist) { v_length -= v_hdist; v_hlen = v_hdist; @@ -6498,12 +6574,7 @@ label_0_continue:; goto label_0_continue; } if (((uint64_t)((v_dist_minus_1 + 1))) > - ((uint64_t)( - ((wuffs_base__slice_u8){ - .ptr = a_dst.private_impl.mark, - .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), - }) - .len))) { + ((uint64_t)(iop_a_dst - a_dst.private_impl.mark))) { status = wuffs_deflate__error__internal_error_inconsistent_distance; goto exit; } @@ -6859,21 +6930,11 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self, v_n_copied = 0; while (true) { if (((uint64_t)((v_dist_minus_1 + 1))) > - ((uint64_t)( - ((wuffs_base__slice_u8){ - .ptr = a_dst.private_impl.mark, - .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), - }) - .len))) { + ((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)( - ((wuffs_base__slice_u8){ - .ptr = a_dst.private_impl.mark, - .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), - }) - .len))))); + v_hdist = + ((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) - + ((uint64_t)(iop_a_dst - a_dst.private_impl.mark))))); if (v_length > v_hdist) { v_length -= v_hdist; v_hlen = v_hdist; @@ -7012,8 +7073,8 @@ const char* wuffs_lzw__error__internal_error_inconsistent_i_o = // ---------------- Private Function Prototypes static wuffs_base__status // -wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, - wuffs_base__io_writer a_dst); +wuffs_lzw__decoder__auto_flush(wuffs_lzw__decoder* self, + wuffs_base__io_writer a_dst); // ---------------- Initializer Implementations @@ -7086,6 +7147,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, 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; @@ -7122,6 +7184,7 @@ 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_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; @@ -7133,6 +7196,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, v_lm1_b = 0; v_lm1_a = 0; } else { + v_bad = false; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -7146,6 +7210,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, 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; @@ -7169,14 +7234,15 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, 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); + 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); } - 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); @@ -7274,8 +7340,8 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, v_prev_code = v_code; } } else { - status = wuffs_lzw__error__bad_code; - goto exit; + v_bad = true; + goto label_1_break; } if (v_j > 4095) { while (v_n_bits >= 8) { @@ -7290,7 +7356,7 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, 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__flush(self, a_dst); + status = wuffs_lzw__decoder__auto_flush(self, a_dst); if (status) { goto suspend; } @@ -7298,24 +7364,27 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, } } 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; - } + 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)); + } + if (v_j > 0) { self->private_impl.f_flush_j = v_j; WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); - status = wuffs_lzw__decoder__flush(self, a_dst); + 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: @@ -7332,6 +7401,7 @@ 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_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; @@ -7349,15 +7419,14 @@ exit: return status; } -// -------- func lzw.decoder.flush +// -------- func lzw.decoder.auto_flush static wuffs_base__status // -wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, - wuffs_base__io_writer a_dst) { +wuffs_lzw__decoder__auto_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; @@ -7381,10 +7450,9 @@ wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, io1_a_dst = a_dst.private_impl.limit; } - uint32_t coro_susp_point = self->private_impl.c_flush[0].coro_susp_point; + uint32_t coro_susp_point = self->private_impl.c_auto_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_i = self->private_impl.c_auto_flush[0].v_i; v_s = ((wuffs_base__slice_u8){}); v_n = 0; } else { @@ -7394,9 +7462,8 @@ wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; v_i = 0; - v_j = self->private_impl.f_flush_j; - while (true) { - if (v_i > v_j) { + while (self->private_impl.f_flush_j > 0) { + if (v_i > self->private_impl.f_flush_j) { status = wuffs_lzw__error__internal_error_inconsistent_i_o; goto exit; } @@ -7405,7 +7472,7 @@ wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, .ptr = self->private_impl.f_output, .len = 8199, }), - v_i, v_j); + v_i, self->private_impl.f_flush_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; @@ -7418,15 +7485,14 @@ wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self, goto ok; ok: - self->private_impl.c_flush[0].coro_susp_point = 0; + self->private_impl.c_auto_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_auto_flush[0].coro_susp_point = coro_susp_point; + self->private_impl.c_auto_flush[0].v_i = v_i; goto exit; exit: @@ -7438,6 +7504,28 @@ exit: return status; } +// -------- func lzw.decoder.flush + +WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 // +wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self) { + if (!self) { + return ((wuffs_base__slice_u8){}); + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + return ((wuffs_base__slice_u8){}); + } + + 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; + return v_s; +} + #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__LZW) #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) @@ -7519,11 +7607,13 @@ 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); + wuffs_base__io_reader a_src, + wuffs_base__slice_u8 a_workbuf); static wuffs_base__status // wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self, - wuffs_base__pixel_buffer* a_pb); + wuffs_base__pixel_buffer* a_pb, + wuffs_base__slice_u8 a_src); // ---------------- Initializer Implementations @@ -7621,7 +7711,7 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self, (self->private_impl.f_frame_rect_y1 == self->private_impl.f_height)); if (a_dst != NULL) { wuffs_base__image_config__initialize( - a_dst, 1107558408, 0, self->private_impl.f_width, + a_dst, 1191444488, 0, self->private_impl.f_width, self->private_impl.f_height, ((uint64_t)(self->private_impl.f_width)), ((uint64_t)(self->private_impl.f_width)), self->private_impl.f_frame_config_io_position, v_ffio); @@ -7986,11 +8076,6 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - if (((uint64_t)(a_workbuf.len)) < - ((uint64_t)(self->private_impl.f_width))) { - status = wuffs_base__error__bad_workbuf_length; - goto exit; - } if (self->private_impl.f_call_sequence != 2) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); status = wuffs_gif__decoder__decode_frame_config(self, NULL, a_src); @@ -7999,7 +8084,7 @@ 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); + status = wuffs_gif__decoder__decode_id_part1(self, a_dst, a_src, a_workbuf); if (status) { goto suspend; } @@ -9174,7 +9259,8 @@ 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__io_reader a_src, + wuffs_base__slice_u8 a_workbuf) { wuffs_base__status status = NULL; uint8_t v_flags; @@ -9184,14 +9270,17 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, wuffs_base__slice_u8 v_dst_palette; uint8_t v_lw; uint64_t v_block_size; - wuffs_base__io_writer v_w; - wuffs_base__io_buffer u_w; - uint8_t* iop_v_w = NULL; - uint8_t* io1_v_w = NULL; - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(u_w); - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iop_v_w); - WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_v_w); + 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* iop_a_src = NULL; uint8_t* io0_a_src = NULL; @@ -9221,11 +9310,16 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, 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_w = ((wuffs_base__io_writer){}); - v_z = NULL; + 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_w = ((wuffs_base__io_writer){}); + 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; @@ -9334,7 +9428,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, wuffs_base__pixel_swizzler__initialize( &self->private_impl.f_swizzler, wuffs_base__pixel_buffer__pixel_format(a_dst), v_dst_palette, - 1107558408, + 1191444488, ((wuffs_base__slice_u8){ .ptr = self->private_impl .f_palettes[self->private_impl.f_which_palette], @@ -9364,109 +9458,163 @@ 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; - while (true) { - if (((uint64_t)(io1_a_src - iop_a_src)) == 0) { - if (self->private_impl.f_uncompressed_ri != - self->private_impl.f_uncompressed_wi) { - status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); - if (status) { - goto exit; - } - } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { + status = wuffs_base__suspension__short_read; + goto suspend; } - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); - 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_3 = *iop_a_src++; + v_block_size = t_3; + } + label_0_continue:; + while (v_block_size > 0) { + while (((uint64_t)(io1_a_src - iop_a_src)) == 0) { + status = wuffs_base__suspension__short_read; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); } - if (v_block_size == 0) { - goto label_0_break; + if (self->private_impl.f_compressed_ri == + self->private_impl.f_compressed_wi) { + self->private_impl.f_compressed_ri = 0; + self->private_impl.f_compressed_wi = 0; } - self->private_impl.f_previous_lzw_decode_ended_abruptly = true; - label_1_continue:; - while (true) { - v_w = ((wuffs_base__io_writer){}); - { - wuffs_base__io_reader o_0_a_src = a_src; - wuffs_base__io_writer o_0_v_w = v_w; - uint8_t* o_0_iop_v_w = iop_v_w; - uint8_t* o_0_io1_v_w = io1_v_w; - wuffs_base__io_writer__set( - &v_w, &u_w, &iop_v_w, &io1_v_w, - wuffs_base__slice_u8__subslice_i( - ((wuffs_base__slice_u8){ - .ptr = self->private_impl.f_uncompressed, - .len = 4096, - }), - self->private_impl.f_uncompressed_wi)); - wuffs_base__io_reader__set_limit(&a_src, iop_a_src, v_block_size); - wuffs_base__io_reader__set_mark(&a_src, iop_a_src); - { - u_w.meta.wi = iop_v_w - u_w.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; - } - wuffs_base__status t_4 = wuffs_lzw__decoder__decode( - &self->private_impl.f_lzw, v_w, a_src); - iop_v_w = u_w.data.ptr + u_w.meta.wi; - if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->data.ptr + - a_src.private_impl.buf->meta.ri; - } - v_z = t_4; - } - self->private_impl.f_uncompressed_wi = - (4096 - ((uint32_t)(wuffs_base__u64__min( - ((uint64_t)(io1_v_w - iop_v_w)), 4096)))); - wuffs_base__u64__sat_sub_indirect( - &v_block_size, - ((uint64_t)( - ((wuffs_base__slice_u8){ - .ptr = a_src.private_impl.mark, - .len = (size_t)(iop_a_src - a_src.private_impl.mark), - }) - .len))); - v_w = o_0_v_w; - iop_v_w = o_0_iop_v_w; - io1_v_w = o_0_io1_v_w; - a_src = o_0_a_src; - } - if ((v_block_size == 0) && - (v_z == wuffs_base__suspension__short_read)) { + while (self->private_impl.f_compressed_wi <= 3841) { + v_n_compressed = wuffs_base__u64__min( + v_block_size, ((uint64_t)(io1_a_src - iop_a_src))); + if (v_n_compressed <= 0) { goto label_1_break; } - if (self->private_impl.f_uncompressed_ri != - self->private_impl.f_uncompressed_wi) { - status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); + v_compressed = + wuffs_base__io_reader__take(&iop_a_src, io1_a_src, v_n_compressed); + wuffs_base__slice_u8__copy_from_slice( + wuffs_base__slice_u8__subslice_i( + ((wuffs_base__slice_u8){ + .ptr = self->private_impl.f_compressed, + .len = 4096, + }), + self->private_impl.f_compressed_wi), + v_compressed); + wuffs_base__u64__sat_add_indirect(&self->private_impl.f_compressed_wi, + v_n_compressed); + wuffs_base__u64__sat_sub_indirect(&v_block_size, v_n_compressed); + if (v_block_size > 0) { + goto label_1_break; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { + status = wuffs_base__suspension__short_read; + goto suspend; + } + uint64_t t_4 = *iop_a_src++; + v_block_size = t_4; + } + } + label_1_break:; + if (((uint64_t)(self->private_impl.f_width)) < + ((uint64_t)(a_workbuf.len))) { + a_workbuf = wuffs_base__slice_u8__subslice_j( + a_workbuf, ((uint64_t)(self->private_impl.f_width))); + } else if (((uint64_t)(self->private_impl.f_width)) > + ((uint64_t)(a_workbuf.len))) { + status = wuffs_base__error__bad_workbuf_length; + goto exit; + } + 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)) { + status = wuffs_gif__error__internal_error_inconsistent_ri_wi; + goto exit; + } + { + wuffs_base__io_reader o_0_v_r = v_r; + uint8_t* o_0_iop_v_r = iop_v_r; + uint8_t* o_0_io1_v_r = io1_v_r; + wuffs_base__io_reader__set( + &v_r, &u_r, &iop_v_r, &io1_v_r, + wuffs_base__slice_u8__subslice_ij( + ((wuffs_base__slice_u8){ + .ptr = self->private_impl.f_compressed, + .len = 4096, + }), + self->private_impl.f_compressed_ri, + self->private_impl.f_compressed_wi)); + { + u_r.meta.ri = iop_v_r - u_r.data.ptr; + wuffs_base__status t_5 = 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_5; + } + wuffs_base__u64__sat_add_indirect( + &self->private_impl.f_compressed_ri, + ((uint64_t)(iop_v_r - v_r.private_impl.mark))); + v_r = o_0_v_r; + iop_v_r = o_0_iop_v_r; + io1_v_r = o_0_io1_v_r; + } + 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) { goto exit; } } if (wuffs_base__status__is_ok(v_z)) { self->private_impl.f_previous_lzw_decode_ended_abruptly = false; - goto label_1_break; - } - if (v_z == wuffs_base__suspension__short_write) { - goto label_1_continue; + if (v_block_size > 0) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + self->private_impl.c_decode_id_part1[0].scratch = + ((uint32_t)(v_block_size)); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + if (self->private_impl.c_decode_id_part1[0].scratch > + ((uint64_t)(io1_a_src - iop_a_src))) { + self->private_impl.c_decode_id_part1[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(10); + if (a_src.private_impl.buf) { + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; + } + 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 + + a_src.private_impl.buf->meta.ri; + } + if (status) { + goto suspend; + } + } + goto label_0_break; + } else if (v_z == wuffs_base__suspension__short_read) { + goto label_0_continue; + } else if (v_z == wuffs_base__suspension__short_write) { + goto label_2_continue; } status = v_z; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); + 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; } - label_1_break:; } label_0_break:; - if (self->private_impl.f_uncompressed_ri != - self->private_impl.f_uncompressed_wi) { - status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); - if (status) { - goto exit; - } - } + self->private_impl.f_compressed_ri = 0; + self->private_impl.f_compressed_wi = 0; goto ok; ok: @@ -9481,6 +9629,7 @@ suspend: 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_z = v_z; goto exit; exit: @@ -9496,40 +9645,35 @@ exit: static wuffs_base__status // wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self, - wuffs_base__pixel_buffer* a_pb) { + 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; - uint32_t v_n; - uint32_t v_new_ri; + 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; - uint64_t v_n64; v_dst = ((wuffs_base__slice_u8){}); v_src = ((wuffs_base__slice_u8){}); v_n = 0; - v_new_ri = 0; + v_src_ri = 0; v_bytes_per_pixel = 1; v_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_pb); - if ((v_pixfmt == 1107331208) || (v_pixfmt == 1375766664)) { + if ((v_pixfmt == 1157662856) || (v_pixfmt == 1426098312) || + (v_pixfmt == 1174440072) || (v_pixfmt == 1442875528) || + (v_pixfmt == 1191217288) || (v_pixfmt == 1459652744)) { v_bytes_per_pixel = 4; } v_tab = wuffs_base__pixel_buffer__plane(a_pb, 0); label_0_continue:; - while (self->private_impl.f_uncompressed_wi > - self->private_impl.f_uncompressed_ri) { - v_src = wuffs_base__slice_u8__subslice_ij( - ((wuffs_base__slice_u8){ - .ptr = self->private_impl.f_uncompressed, - .len = 4096, - }), - self->private_impl.f_uncompressed_ri, - self->private_impl.f_uncompressed_wi); + 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; @@ -9545,19 +9689,16 @@ label_0_continue:; } else { v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_i); } - v_n64 = wuffs_base__pixel_swizzler__swizzle_packed( + v_n = wuffs_base__pixel_swizzler__swizzle_packed( &self->private_impl.f_swizzler, v_dst, ((wuffs_base__slice_u8){ .ptr = self->private_impl.f_dst_palette, .len = 1024, }), v_src); - v_n = ((uint32_t)((v_n64 & 4294967295))); - v_new_ri = - wuffs_base__u32__sat_add(self->private_impl.f_uncompressed_ri, v_n); - self->private_impl.f_uncompressed_ri = - wuffs_base__u32__min(v_new_ri, 4096); - wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_n); + wuffs_base__u64__sat_add_indirect(&v_src_ri, v_n); + wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, + ((uint32_t)((v_n & 4294967295)))); self->private_impl.f_dirty_y = wuffs_base__range_ie_u32__unite( &self->private_impl.f_dirty_y, wuffs_base__utility__make_range_ie_u32( @@ -9580,21 +9721,18 @@ label_0_continue:; } goto label_0_continue; } - if (self->private_impl.f_uncompressed_wi == - self->private_impl.f_uncompressed_ri) { + if (((uint64_t)(a_src.len)) == v_src_ri) { goto label_0_break; - } else if (self->private_impl.f_uncompressed_wi < - self->private_impl.f_uncompressed_ri) { + } else if (((uint64_t)(a_src.len)) < v_src_ri) { status = wuffs_gif__error__internal_error_inconsistent_ri_wi; goto exit; } - v_n = (self->private_impl.f_frame_rect_x1 - self->private_impl.f_dst_x); - v_n = wuffs_base__u32__min(v_n, (self->private_impl.f_uncompressed_wi - - self->private_impl.f_uncompressed_ri)); - v_new_ri = - wuffs_base__u32__sat_add(self->private_impl.f_uncompressed_ri, v_n); - self->private_impl.f_uncompressed_ri = wuffs_base__u32__min(v_new_ri, 4096); - wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_n); + 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)); + wuffs_base__u64__sat_add_indirect(&v_src_ri, v_n); + wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, + ((uint32_t)((v_n & 4294967295)))); if (self->private_impl.f_frame_rect_x1 <= self->private_impl.f_dst_x) { self->private_impl.f_dst_x = self->private_impl.f_frame_rect_x0; wuffs_base__u32__sat_add_indirect( @@ -9611,16 +9749,13 @@ label_0_continue:; } goto label_0_continue; } - if (self->private_impl.f_uncompressed_ri != - self->private_impl.f_uncompressed_wi) { + if (v_src_ri != ((uint64_t)(a_src.len))) { status = wuffs_gif__error__internal_error_inconsistent_ri_wi; goto exit; } goto label_0_break; } label_0_break:; - self->private_impl.f_uncompressed_ri = 0; - self->private_impl.f_uncompressed_wi = 0; goto exit; exit: return status; @@ -9966,13 +10101,7 @@ wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), })); v_decoded_length_got += ((uint32_t)( - (((uint64_t)( - ((wuffs_base__slice_u8){ - .ptr = a_dst.private_impl.mark, - .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), - }) - .len)) & - 4294967295))); + (((uint64_t)(iop_a_dst - a_dst.private_impl.mark)) & 4294967295))); } if (wuffs_base__status__is_ok(v_z)) { goto label_2_break;