diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 81444a6a..d2d4a8cf 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -16438,6 +16438,11 @@ struct wuffs_webp__decoder__struct { uint32_t p_decode_code_length_code_lengths; uint32_t p_build_code_lengths; uint32_t p_decode_pixels_slow; + uint32_t p_do_decode_frame_vp8l; + uint32_t p_decode_transform; + uint32_t p_decode_color_cache_parameters; + uint32_t p_decode_hg_table; + uint32_t p_decode_pixels; uint32_t p_decode_image_config; uint32_t p_do_decode_image_config; uint32_t p_do_decode_image_config_limited; @@ -16447,11 +16452,6 @@ struct wuffs_webp__decoder__struct { uint32_t p_do_decode_frame_config; uint32_t p_decode_frame; uint32_t p_do_decode_frame; - uint32_t p_do_decode_frame_vp8l; - uint32_t p_decode_transform; - uint32_t p_decode_color_cache_parameters; - uint32_t p_decode_hg_table; - uint32_t p_decode_pixels; } private_impl; struct { @@ -16502,6 +16502,16 @@ struct wuffs_webp__decoder__struct { uint32_t v_back_ref_dist_premap_minus_1; uint64_t v_color_cache_p; } s_decode_pixels_slow; + struct { + uint32_t v_width; + } s_do_decode_frame_vp8l; + struct { + uint32_t v_transform_type; + uint32_t v_tile_size_log2; + } s_decode_transform; + struct { + uint32_t v_tile_size_log2; + } s_decode_hg_table; struct { uint64_t scratch; } s_do_decode_image_config; @@ -16518,16 +16528,6 @@ struct wuffs_webp__decoder__struct { uint32_t v_chunk_type; uint64_t scratch; } s_do_decode_frame; - struct { - uint32_t v_width; - } s_do_decode_frame_vp8l; - struct { - uint32_t v_transform_type; - uint32_t v_tile_size_log2; - } s_decode_transform; - struct { - uint32_t v_tile_size_log2; - } s_decode_hg_table; } private_data; #ifdef __cplusplus @@ -87170,49 +87170,6 @@ wuffs_webp__decoder__apply_transform_color_indexing( wuffs_base__slice_u8 a_pix, uint32_t a_width); -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__do_decode_image_config( - wuffs_webp__decoder* self, - wuffs_base__image_config* a_dst, - wuffs_base__io_buffer* a_src); - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__do_decode_image_config_limited( - wuffs_webp__decoder* self, - wuffs_base__image_config* a_dst, - wuffs_base__io_buffer* a_src); - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__do_decode_image_config_limited_vp8l( - wuffs_webp__decoder* self, - wuffs_base__io_buffer* a_src); - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__do_decode_image_config_limited_vp8x( - wuffs_webp__decoder* self, - wuffs_base__io_buffer* a_src); - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__do_decode_frame_config( - wuffs_webp__decoder* self, - wuffs_base__frame_config* a_dst, - wuffs_base__io_buffer* a_src); - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__do_decode_frame( - wuffs_webp__decoder* self, - wuffs_base__pixel_buffer* a_dst, - wuffs_base__io_buffer* a_src, - wuffs_base__pixel_blend a_blend, - wuffs_base__slice_u8 a_workbuf, - wuffs_base__decode_frame_options* a_opts); - WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_webp__decoder__do_decode_frame_vp8l( @@ -87263,6 +87220,49 @@ wuffs_webp__decoder__swizzle( wuffs_base__slice_u8 a_src, wuffs_base__pixel_blend a_blend); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config( + wuffs_webp__decoder* self, + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config_limited( + wuffs_webp__decoder* self, + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config_limited_vp8l( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_image_config_limited_vp8x( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_frame_config( + wuffs_webp__decoder* self, + wuffs_base__frame_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_frame( + wuffs_webp__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__io_buffer* a_src, + wuffs_base__pixel_blend a_blend, + wuffs_base__slice_u8 a_workbuf, + wuffs_base__decode_frame_options* a_opts); + // ---------------- VTables const wuffs_base__image_decoder__func_ptrs @@ -89128,6 +89128,866 @@ wuffs_webp__decoder__apply_transform_color_indexing( return wuffs_base__make_empty_struct(); } +// -------- func webp.decoder.do_decode_frame_vp8l + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__do_decode_frame_vp8l( + wuffs_webp__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__io_buffer* a_src, + wuffs_base__pixel_blend a_blend, + wuffs_base__slice_u8 a_workbuf, + wuffs_base__decode_frame_options* a_opts) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_has_more = 0; + uint32_t v_width = 0; + wuffs_base__slice_u8 v_dst = {0}; + wuffs_base__slice_u8 v_tile_data = {0}; + wuffs_base__status v_status = wuffs_base__make_status(NULL); + wuffs_base__slice_u8 v_pix = {0}; + uint32_t v_which = 0; + uint32_t v_transform_type = 0; + uint64_t v_ti = 0; + uint64_t v_tj = 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; + } + + uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_vp8l; + if (coro_susp_point) { + v_width = self->private_data.s_do_decode_frame_vp8l.v_width; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + self->private_impl.f_seen_transform[0u] = false; + self->private_impl.f_seen_transform[1u] = false; + self->private_impl.f_seen_transform[2u] = false; + self->private_impl.f_seen_transform[3u] = false; + self->private_impl.f_n_transforms = 0u; + while (true) { + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_has_more = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + if (v_has_more == 0u) { + break; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + } + v_width = self->private_impl.f_width; + if (self->private_impl.f_seen_transform[3u]) { + v_width = self->private_impl.f_color_indexing_width; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + self->private_impl.f_overall_color_cache_bits = self->private_impl.f_color_cache_bits; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + self->private_impl.f_color_cache_bits = self->private_impl.f_overall_color_cache_bits; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + while (true) { + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_dst = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); + v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); + { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + wuffs_base__status t_1 = wuffs_webp__decoder__decode_pixels(self, + v_dst, + a_src, + v_width, + self->private_impl.f_height, + v_tile_data, + self->private_impl.f_overall_tile_size_log2); + v_status = t_1; + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + } + if (wuffs_base__status__is_ok(&v_status)) { + break; + } + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); + } + if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); + v_width = self->private_impl.f_width; + if (self->private_impl.f_seen_transform[3u] && (((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) <= ((uint64_t)(v_pix.len)))) { + v_pix = wuffs_base__slice_u8__subslice_i(v_pix, ((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing))); + v_width = self->private_impl.f_color_indexing_width; + } + v_which = self->private_impl.f_n_transforms; + while (v_which > 0u) { + v_which -= 1u; + v_transform_type = ((uint32_t)(self->private_impl.f_transform_type[v_which])); + v_tile_data = wuffs_base__utility__empty_slice_u8(); + if (v_transform_type < 2u) { + v_ti = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])); + v_tj = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])); + if ((v_ti <= v_tj) && (v_tj <= ((uint64_t)(a_workbuf.len)))) { + v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_ti, v_tj); + } + } + if (v_transform_type == 0u) { + wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_width, v_tile_data); + } else if (v_transform_type == 1u) { + wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_width, v_tile_data); + } else if (v_transform_type == 2u) { + wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix); + } else if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) <= ((uint64_t)(a_workbuf.len))) { + v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); + v_width = self->private_impl.f_width; + wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix, v_width); + } + } + v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, a_blend); + if ( ! wuffs_base__status__is_ok(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } + self->private_impl.f_call_sequence = 96u; + + ok: + self->private_impl.p_do_decode_frame_vp8l = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_do_decode_frame_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_do_decode_frame_vp8l.v_width = v_width; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_transform + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_transform( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + wuffs_base__slice_u8 a_workbuf) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + wuffs_base__status v_status = wuffs_base__make_status(NULL); + uint8_t v_c8 = 0; + uint32_t v_transform_type = 0; + uint32_t v_tile_size_log2 = 0; + uint32_t v_width = 0; + wuffs_base__slice_u8 v_p = {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; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_transform; + if (coro_susp_point) { + v_transform_type = self->private_data.s_decode_transform.v_transform_type; + v_tile_size_log2 = self->private_data.s_decode_transform.v_tile_size_log2; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 2u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + if (self->private_impl.f_n_bits >= 2u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_transform_type = (self->private_impl.f_bits & 3u); + self->private_impl.f_bits >>= 2u; + self->private_impl.f_n_bits -= 2u; + if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) { + status = wuffs_base__make_status(wuffs_webp__error__bad_transform); + goto exit; + } + self->private_impl.f_seen_transform[v_transform_type] = true; + self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type)); + self->private_impl.f_n_transforms += 1u; + if (v_transform_type < 2u) { + if (self->private_impl.f_n_bits < 3u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 3u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u); + self->private_impl.f_transform_tile_size_log2[v_transform_type] = ((uint8_t)(v_tile_size_log2)); + self->private_impl.f_bits >>= 3u; + self->private_impl.f_n_bits -= 3u; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + while (true) { + v_width = self->private_impl.f_width; + if (self->private_impl.f_seen_transform[3u]) { + v_width = self->private_impl.f_color_indexing_width; + } + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self, + wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))), + a_src, + ((v_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + wuffs_base__utility__empty_slice_u8(), + 0u); + v_status = t_2; + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + } + if (wuffs_base__status__is_ok(&v_status)) { + break; + } + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5); + } + } else if (v_transform_type == 2u) { + } else { + if (self->private_impl.f_n_bits < 8u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_3 = *iop_a_src++; + v_c8 = t_3; + } + if (self->private_impl.f_n_bits >= 8u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + self->private_impl.f_color_indexing_palette_size = ((self->private_impl.f_bits & 255u) + 1u); + self->private_impl.f_bits >>= 8u; + self->private_impl.f_n_bits -= 8u; + if (self->private_impl.f_color_indexing_palette_size <= 2u) { + self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 7u) / 8u); + self->private_impl.f_transform_tile_size_log2[3u] = 3u; + } else if (self->private_impl.f_color_indexing_palette_size <= 4u) { + self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 3u) / 4u); + self->private_impl.f_transform_tile_size_log2[3u] = 2u; + } else if (self->private_impl.f_color_indexing_palette_size <= 16u) { + self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 1u) / 2u); + self->private_impl.f_transform_tile_size_log2[3u] = 1u; + } else { + self->private_impl.f_color_indexing_width = self->private_impl.f_width; + self->private_impl.f_transform_tile_size_log2[3u] = 0u; + } + if (self->private_impl.f_width >= self->private_impl.f_color_indexing_width) { + self->private_impl.f_workbuf_offset_for_color_indexing = (4u * (self->private_impl.f_width - self->private_impl.f_color_indexing_width) * self->private_impl.f_height); + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + status = wuffs_webp__decoder__decode_pixels(self, + wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)), + a_src, + self->private_impl.f_color_indexing_palette_size, + 1u, + wuffs_base__utility__empty_slice_u8(), + 0u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + wuffs_private_impl__bulk_memset(&self->private_data.f_palette[(4u * self->private_impl.f_color_indexing_palette_size)], (1024u - (4u * self->private_impl.f_color_indexing_palette_size)), 0u); + v_p = wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)); + while (((uint64_t)(v_p.len)) >= 8u) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_p.ptr[4u] += v_p.ptr[0u]; + v_p.ptr[5u] += v_p.ptr[1u]; + v_p.ptr[6u] += v_p.ptr[2u]; + v_p.ptr[7u] += v_p.ptr[3u]; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u); + } + } + + ok: + self->private_impl.p_decode_transform = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_transform = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_transform.v_transform_type = v_transform_type; + self->private_data.s_decode_transform.v_tile_size_log2 = v_tile_size_log2; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_color_cache_parameters + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_color_cache_parameters( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_use_color_cache = 0; + uint32_t v_color_cache_bits = 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; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_color_cache_parameters; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_use_color_cache = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + self->private_impl.f_color_cache_bits = 0u; + if (v_use_color_cache != 0u) { + if (self->private_impl.f_n_bits < 4u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 4u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_color_cache_bits = (self->private_impl.f_bits & 15u); + self->private_impl.f_bits >>= 4u; + self->private_impl.f_n_bits -= 4u; + if ((v_color_cache_bits < 1u) || (11u < v_color_cache_bits)) { + status = wuffs_base__make_status(wuffs_webp__error__bad_color_cache); + goto exit; + } + self->private_impl.f_color_cache_bits = v_color_cache_bits; + } + + goto ok; + ok: + self->private_impl.p_decode_color_cache_parameters = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_color_cache_parameters = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_hg_table + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_hg_table( + wuffs_webp__decoder* self, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + wuffs_base__slice_u8 a_workbuf) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + wuffs_base__status v_status = wuffs_base__make_status(NULL); + uint8_t v_c8 = 0; + uint32_t v_use_hg_table = 0; + uint32_t v_tile_size_log2 = 0; + wuffs_base__slice_u8 v_hg_pixels = {0}; + uint64_t v_n = 0; + wuffs_base__slice_u8 v_p = {0}; + uint32_t v_hg_plus_1 = 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; + } + + uint32_t coro_susp_point = self->private_impl.p_decode_hg_table; + if (coro_susp_point) { + v_tile_size_log2 = self->private_data.s_decode_hg_table.v_tile_size_log2; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + if (self->private_impl.f_n_bits < 1u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c8 = t_0; + } + self->private_impl.f_bits = ((uint32_t)(v_c8)); + self->private_impl.f_n_bits = 8u; + } + v_use_hg_table = (self->private_impl.f_bits & 1u); + self->private_impl.f_bits >>= 1u; + self->private_impl.f_n_bits -= 1u; + if (v_use_hg_table == 0u) { + self->private_impl.f_overall_n_huffman_groups = 1u; + self->private_impl.f_overall_tile_size_log2 = 0u; + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); + if (((uint64_t)(v_hg_pixels.len)) >= 4u) { + v_hg_pixels.ptr[0u] = 0u; + v_hg_pixels.ptr[1u] = 0u; + v_hg_pixels.ptr[2u] = 0u; + v_hg_pixels.ptr[3u] = 0u; + } + status = wuffs_base__make_status(NULL); + goto ok; + } + if (self->private_impl.f_n_bits < 3u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c8 = t_1; + } + if (self->private_impl.f_n_bits >= 3u) { + status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); + goto exit; + } + self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); + self->private_impl.f_n_bits += 8u; + } + v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u); + self->private_impl.f_bits >>= 3u; + self->private_impl.f_n_bits -= 3u; + self->private_impl.f_overall_tile_size_log2 = v_tile_size_log2; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + while (true) { + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self, + wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))), + a_src, + ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), + wuffs_base__utility__empty_slice_u8(), + 0u); + v_status = t_2; + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + } + if (wuffs_base__status__is_ok(&v_status)) { + break; + } + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5); + } + self->private_impl.f_overall_n_huffman_groups = 1u; + if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf, + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), + ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); + v_n = ((uint64_t)((((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * 4u))); + if (v_n > ((uint64_t)(v_hg_pixels.len))) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + v_p = wuffs_base__slice_u8__subslice_j(v_hg_pixels, v_n); + while (((uint64_t)(v_p.len)) >= 4u) { + if (v_p.ptr[2u] != 0u) { + status = wuffs_base__make_status(wuffs_webp__error__unsupported_number_of_huffman_groups); + goto exit; + } + v_hg_plus_1 = (((uint32_t)(v_p.ptr[1u])) + 1u); + if (self->private_impl.f_overall_n_huffman_groups < v_hg_plus_1) { + self->private_impl.f_overall_n_huffman_groups = v_hg_plus_1; + } + v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u); + } + + ok: + self->private_impl.p_decode_hg_table = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_hg_table = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_hg_table.v_tile_size_log2 = v_tile_size_log2; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func webp.decoder.decode_pixels + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__decode_pixels( + wuffs_webp__decoder* self, + wuffs_base__slice_u8 a_dst, + wuffs_base__io_buffer* a_src, + uint32_t a_width, + uint32_t a_height, + wuffs_base__slice_u8 a_tile_data, + uint32_t a_tile_size_log2) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_i = 0; + uint32_t v_n = 0; + + uint32_t coro_susp_point = self->private_impl.p_decode_pixels; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + v_i = 0u; + v_n = (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits); + while (v_i < v_n) { + self->private_data.f_color_cache[v_i] = 0u; + v_i += 1u; + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_webp__decoder__decode_pixels_slow(self, + a_dst, + a_src, + a_width, + a_height, + a_tile_data, + a_tile_size_log2); + if (status.repr) { + goto suspend; + } + + goto ok; + ok: + self->private_impl.p_decode_pixels = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_decode_pixels = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + return status; +} + +// -------- func webp.decoder.swizzle + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_webp__decoder__swizzle( + wuffs_webp__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__slice_u8 a_src, + wuffs_base__pixel_blend a_blend) { + wuffs_base__status v_status = wuffs_base__make_status(NULL); + wuffs_base__pixel_format v_dst_pixfmt = {0}; + uint32_t v_dst_bits_per_pixel = 0; + uint32_t v_dst_bytes_per_pixel = 0; + uint64_t v_dst_bytes_per_row = 0; + wuffs_base__slice_u8 v_dst_palette = {0}; + wuffs_base__table_u8 v_tab = {0}; + uint64_t v_src_bytes_per_row = 0; + wuffs_base__slice_u8 v_dst = {0}; + uint32_t v_y = 0; + + v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler, + wuffs_base__pixel_buffer__pixel_format(a_dst), + wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)), + wuffs_base__utility__make_pixel_format(2164295816u), + wuffs_base__utility__empty_slice_u8(), + a_blend); + if ( ! wuffs_base__status__is_ok(&v_status)) { + return wuffs_private_impl__status__ensure_not_a_suspension(v_status); + } + v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); + v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt); + if ((v_dst_bits_per_pixel & 7u) != 0u) { + return wuffs_base__make_status(wuffs_base__error__unsupported_option); + } + v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u); + v_dst_bytes_per_row = ((uint64_t)((self->private_impl.f_width * v_dst_bytes_per_pixel))); + v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)); + v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); + v_src_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 4u))); + while (v_src_bytes_per_row <= ((uint64_t)(a_src.len))) { + v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y); + if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row); + } + wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(a_src, v_src_bytes_per_row)); + a_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_bytes_per_row); + v_y += 1u; + } + return wuffs_base__make_status(NULL); +} + // -------- func webp.decoder.get_quirk WUFFS_BASE__GENERATED_C_CODE @@ -90384,866 +91244,6 @@ wuffs_webp__decoder__do_decode_frame( return status; } -// -------- func webp.decoder.do_decode_frame_vp8l - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__do_decode_frame_vp8l( - wuffs_webp__decoder* self, - wuffs_base__pixel_buffer* a_dst, - wuffs_base__io_buffer* a_src, - wuffs_base__pixel_blend a_blend, - wuffs_base__slice_u8 a_workbuf, - wuffs_base__decode_frame_options* a_opts) { - wuffs_base__status status = wuffs_base__make_status(NULL); - - uint8_t v_c8 = 0; - uint32_t v_has_more = 0; - uint32_t v_width = 0; - wuffs_base__slice_u8 v_dst = {0}; - wuffs_base__slice_u8 v_tile_data = {0}; - wuffs_base__status v_status = wuffs_base__make_status(NULL); - wuffs_base__slice_u8 v_pix = {0}; - uint32_t v_which = 0; - uint32_t v_transform_type = 0; - uint64_t v_ti = 0; - uint64_t v_tj = 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; - } - - uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_vp8l; - if (coro_susp_point) { - v_width = self->private_data.s_do_decode_frame_vp8l.v_width; - } - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - self->private_impl.f_seen_transform[0u] = false; - self->private_impl.f_seen_transform[1u] = false; - self->private_impl.f_seen_transform[2u] = false; - self->private_impl.f_seen_transform[3u] = false; - self->private_impl.f_n_transforms = 0u; - while (true) { - if (self->private_impl.f_n_bits < 1u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_0 = *iop_a_src++; - v_c8 = t_0; - } - self->private_impl.f_bits = ((uint32_t)(v_c8)); - self->private_impl.f_n_bits = 8u; - } - v_has_more = (self->private_impl.f_bits & 1u); - self->private_impl.f_bits >>= 1u; - self->private_impl.f_n_bits -= 1u; - if (v_has_more == 0u) { - break; - } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - } - v_width = self->private_impl.f_width; - if (self->private_impl.f_seen_transform[3u]) { - v_width = self->private_impl.f_color_indexing_width; - } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - self->private_impl.f_overall_color_cache_bits = self->private_impl.f_color_cache_bits; - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); - status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - self->private_impl.f_color_cache_bits = self->private_impl.f_overall_color_cache_bits; - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); - status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - while (true) { - if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; - } - v_dst = wuffs_base__slice_u8__subslice_ij(a_workbuf, - ((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)), - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); - v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); - { - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - wuffs_base__status t_1 = wuffs_webp__decoder__decode_pixels(self, - v_dst, - a_src, - v_width, - self->private_impl.f_height, - v_tile_data, - self->private_impl.f_overall_tile_size_log2); - v_status = t_1; - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - } - if (wuffs_base__status__is_ok(&v_status)) { - break; - } - status = v_status; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); - } - if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; - } - v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); - v_width = self->private_impl.f_width; - if (self->private_impl.f_seen_transform[3u] && (((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) <= ((uint64_t)(v_pix.len)))) { - v_pix = wuffs_base__slice_u8__subslice_i(v_pix, ((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing))); - v_width = self->private_impl.f_color_indexing_width; - } - v_which = self->private_impl.f_n_transforms; - while (v_which > 0u) { - v_which -= 1u; - v_transform_type = ((uint32_t)(self->private_impl.f_transform_type[v_which])); - v_tile_data = wuffs_base__utility__empty_slice_u8(); - if (v_transform_type < 2u) { - v_ti = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])); - v_tj = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])); - if ((v_ti <= v_tj) && (v_tj <= ((uint64_t)(a_workbuf.len)))) { - v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_ti, v_tj); - } - } - if (v_transform_type == 0u) { - wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_width, v_tile_data); - } else if (v_transform_type == 1u) { - wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_width, v_tile_data); - } else if (v_transform_type == 2u) { - wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix); - } else if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) <= ((uint64_t)(a_workbuf.len))) { - v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))); - v_width = self->private_impl.f_width; - wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix, v_width); - } - } - v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, a_blend); - if ( ! wuffs_base__status__is_ok(&v_status)) { - status = v_status; - if (wuffs_base__status__is_error(&status)) { - goto exit; - } else if (wuffs_base__status__is_suspension(&status)) { - status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); - goto exit; - } - goto ok; - } - self->private_impl.f_call_sequence = 96u; - - ok: - self->private_impl.p_do_decode_frame_vp8l = 0; - goto exit; - } - - goto suspend; - suspend: - self->private_impl.p_do_decode_frame_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - self->private_data.s_do_decode_frame_vp8l.v_width = v_width; - - goto exit; - exit: - if (a_src && a_src->data.ptr) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - - return status; -} - -// -------- func webp.decoder.decode_transform - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__decode_transform( - wuffs_webp__decoder* self, - wuffs_base__io_buffer* a_src, - wuffs_base__slice_u8 a_workbuf) { - wuffs_base__status status = wuffs_base__make_status(NULL); - - wuffs_base__status v_status = wuffs_base__make_status(NULL); - uint8_t v_c8 = 0; - uint32_t v_transform_type = 0; - uint32_t v_tile_size_log2 = 0; - uint32_t v_width = 0; - wuffs_base__slice_u8 v_p = {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; - } - - uint32_t coro_susp_point = self->private_impl.p_decode_transform; - if (coro_susp_point) { - v_transform_type = self->private_data.s_decode_transform.v_transform_type; - v_tile_size_log2 = self->private_data.s_decode_transform.v_tile_size_log2; - } - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - if (self->private_impl.f_n_bits < 2u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_0 = *iop_a_src++; - v_c8 = t_0; - } - if (self->private_impl.f_n_bits >= 2u) { - status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); - goto exit; - } - self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); - self->private_impl.f_n_bits += 8u; - } - v_transform_type = (self->private_impl.f_bits & 3u); - self->private_impl.f_bits >>= 2u; - self->private_impl.f_n_bits -= 2u; - if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) { - status = wuffs_base__make_status(wuffs_webp__error__bad_transform); - goto exit; - } - self->private_impl.f_seen_transform[v_transform_type] = true; - self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type)); - self->private_impl.f_n_transforms += 1u; - if (v_transform_type < 2u) { - if (self->private_impl.f_n_bits < 3u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_1 = *iop_a_src++; - v_c8 = t_1; - } - if (self->private_impl.f_n_bits >= 3u) { - status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); - goto exit; - } - self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); - self->private_impl.f_n_bits += 8u; - } - v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u); - self->private_impl.f_transform_tile_size_log2[v_transform_type] = ((uint8_t)(v_tile_size_log2)); - self->private_impl.f_bits >>= 3u; - self->private_impl.f_n_bits -= 3u; - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); - status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - while (true) { - v_width = self->private_impl.f_width; - if (self->private_impl.f_seen_transform[3u]) { - v_width = self->private_impl.f_color_indexing_width; - } - if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; - } - { - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self, - wuffs_base__slice_u8__subslice_ij(a_workbuf, - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])), - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))), - a_src, - ((v_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), - ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), - wuffs_base__utility__empty_slice_u8(), - 0u); - v_status = t_2; - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - } - if (wuffs_base__status__is_ok(&v_status)) { - break; - } - status = v_status; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5); - } - } else if (v_transform_type == 2u) { - } else { - if (self->private_impl.f_n_bits < 8u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_3 = *iop_a_src++; - v_c8 = t_3; - } - if (self->private_impl.f_n_bits >= 8u) { - status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); - goto exit; - } - self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); - self->private_impl.f_n_bits += 8u; - } - self->private_impl.f_color_indexing_palette_size = ((self->private_impl.f_bits & 255u) + 1u); - self->private_impl.f_bits >>= 8u; - self->private_impl.f_n_bits -= 8u; - if (self->private_impl.f_color_indexing_palette_size <= 2u) { - self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 7u) / 8u); - self->private_impl.f_transform_tile_size_log2[3u] = 3u; - } else if (self->private_impl.f_color_indexing_palette_size <= 4u) { - self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 3u) / 4u); - self->private_impl.f_transform_tile_size_log2[3u] = 2u; - } else if (self->private_impl.f_color_indexing_palette_size <= 16u) { - self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 1u) / 2u); - self->private_impl.f_transform_tile_size_log2[3u] = 1u; - } else { - self->private_impl.f_color_indexing_width = self->private_impl.f_width; - self->private_impl.f_transform_tile_size_log2[3u] = 0u; - } - if (self->private_impl.f_width >= self->private_impl.f_color_indexing_width) { - self->private_impl.f_workbuf_offset_for_color_indexing = (4u * (self->private_impl.f_width - self->private_impl.f_color_indexing_width) * self->private_impl.f_height); - } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); - status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); - status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); - status = wuffs_webp__decoder__decode_pixels(self, - wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)), - a_src, - self->private_impl.f_color_indexing_palette_size, - 1u, - wuffs_base__utility__empty_slice_u8(), - 0u); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - wuffs_private_impl__bulk_memset(&self->private_data.f_palette[(4u * self->private_impl.f_color_indexing_palette_size)], (1024u - (4u * self->private_impl.f_color_indexing_palette_size)), 0u); - v_p = wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)); - while (((uint64_t)(v_p.len)) >= 8u) { -#if defined(__GNUC__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - v_p.ptr[4u] += v_p.ptr[0u]; - v_p.ptr[5u] += v_p.ptr[1u]; - v_p.ptr[6u] += v_p.ptr[2u]; - v_p.ptr[7u] += v_p.ptr[3u]; -#if defined(__GNUC__) -#pragma GCC diagnostic pop -#endif - v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u); - } - } - - ok: - self->private_impl.p_decode_transform = 0; - goto exit; - } - - goto suspend; - suspend: - self->private_impl.p_decode_transform = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - self->private_data.s_decode_transform.v_transform_type = v_transform_type; - self->private_data.s_decode_transform.v_tile_size_log2 = v_tile_size_log2; - - goto exit; - exit: - if (a_src && a_src->data.ptr) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - - return status; -} - -// -------- func webp.decoder.decode_color_cache_parameters - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__decode_color_cache_parameters( - wuffs_webp__decoder* self, - wuffs_base__io_buffer* a_src) { - wuffs_base__status status = wuffs_base__make_status(NULL); - - uint8_t v_c8 = 0; - uint32_t v_use_color_cache = 0; - uint32_t v_color_cache_bits = 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; - } - - uint32_t coro_susp_point = self->private_impl.p_decode_color_cache_parameters; - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - if (self->private_impl.f_n_bits < 1u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_0 = *iop_a_src++; - v_c8 = t_0; - } - self->private_impl.f_bits = ((uint32_t)(v_c8)); - self->private_impl.f_n_bits = 8u; - } - v_use_color_cache = (self->private_impl.f_bits & 1u); - self->private_impl.f_bits >>= 1u; - self->private_impl.f_n_bits -= 1u; - self->private_impl.f_color_cache_bits = 0u; - if (v_use_color_cache != 0u) { - if (self->private_impl.f_n_bits < 4u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_1 = *iop_a_src++; - v_c8 = t_1; - } - if (self->private_impl.f_n_bits >= 4u) { - status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); - goto exit; - } - self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); - self->private_impl.f_n_bits += 8u; - } - v_color_cache_bits = (self->private_impl.f_bits & 15u); - self->private_impl.f_bits >>= 4u; - self->private_impl.f_n_bits -= 4u; - if ((v_color_cache_bits < 1u) || (11u < v_color_cache_bits)) { - status = wuffs_base__make_status(wuffs_webp__error__bad_color_cache); - goto exit; - } - self->private_impl.f_color_cache_bits = v_color_cache_bits; - } - - goto ok; - ok: - self->private_impl.p_decode_color_cache_parameters = 0; - goto exit; - } - - goto suspend; - suspend: - self->private_impl.p_decode_color_cache_parameters = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - - goto exit; - exit: - if (a_src && a_src->data.ptr) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - - return status; -} - -// -------- func webp.decoder.decode_hg_table - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__decode_hg_table( - wuffs_webp__decoder* self, - wuffs_base__io_buffer* a_src, - uint32_t a_width, - wuffs_base__slice_u8 a_workbuf) { - wuffs_base__status status = wuffs_base__make_status(NULL); - - wuffs_base__status v_status = wuffs_base__make_status(NULL); - uint8_t v_c8 = 0; - uint32_t v_use_hg_table = 0; - uint32_t v_tile_size_log2 = 0; - wuffs_base__slice_u8 v_hg_pixels = {0}; - uint64_t v_n = 0; - wuffs_base__slice_u8 v_p = {0}; - uint32_t v_hg_plus_1 = 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; - } - - uint32_t coro_susp_point = self->private_impl.p_decode_hg_table; - if (coro_susp_point) { - v_tile_size_log2 = self->private_data.s_decode_hg_table.v_tile_size_log2; - } - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - if (self->private_impl.f_n_bits < 1u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_0 = *iop_a_src++; - v_c8 = t_0; - } - self->private_impl.f_bits = ((uint32_t)(v_c8)); - self->private_impl.f_n_bits = 8u; - } - v_use_hg_table = (self->private_impl.f_bits & 1u); - self->private_impl.f_bits >>= 1u; - self->private_impl.f_n_bits -= 1u; - if (v_use_hg_table == 0u) { - self->private_impl.f_overall_n_huffman_groups = 1u; - self->private_impl.f_overall_tile_size_log2 = 0u; - if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; - } - v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf, - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); - if (((uint64_t)(v_hg_pixels.len)) >= 4u) { - v_hg_pixels.ptr[0u] = 0u; - v_hg_pixels.ptr[1u] = 0u; - v_hg_pixels.ptr[2u] = 0u; - v_hg_pixels.ptr[3u] = 0u; - } - status = wuffs_base__make_status(NULL); - goto ok; - } - if (self->private_impl.f_n_bits < 3u) { - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - uint8_t t_1 = *iop_a_src++; - v_c8 = t_1; - } - if (self->private_impl.f_n_bits >= 3u) { - status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits); - goto exit; - } - self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits); - self->private_impl.f_n_bits += 8u; - } - v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u); - self->private_impl.f_bits >>= 3u; - self->private_impl.f_n_bits -= 3u; - self->private_impl.f_overall_tile_size_log2 = v_tile_size_log2; - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); - status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u); - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - if (status.repr) { - goto suspend; - } - while (true) { - if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; - } - { - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - wuffs_base__status t_2 = wuffs_webp__decoder__decode_pixels(self, - wuffs_base__slice_u8__subslice_ij(a_workbuf, - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))), - a_src, - ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), - ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2), - wuffs_base__utility__empty_slice_u8(), - 0u); - v_status = t_2; - if (a_src) { - iop_a_src = a_src->data.ptr + a_src->meta.ri; - } - } - if (wuffs_base__status__is_ok(&v_status)) { - break; - } - status = v_status; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5); - } - self->private_impl.f_overall_n_huffman_groups = 1u; - if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; - } - v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf, - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])), - ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))); - v_n = ((uint64_t)((((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * 4u))); - if (v_n > ((uint64_t)(v_hg_pixels.len))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; - } - v_p = wuffs_base__slice_u8__subslice_j(v_hg_pixels, v_n); - while (((uint64_t)(v_p.len)) >= 4u) { - if (v_p.ptr[2u] != 0u) { - status = wuffs_base__make_status(wuffs_webp__error__unsupported_number_of_huffman_groups); - goto exit; - } - v_hg_plus_1 = (((uint32_t)(v_p.ptr[1u])) + 1u); - if (self->private_impl.f_overall_n_huffman_groups < v_hg_plus_1) { - self->private_impl.f_overall_n_huffman_groups = v_hg_plus_1; - } - v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u); - } - - ok: - self->private_impl.p_decode_hg_table = 0; - goto exit; - } - - goto suspend; - suspend: - self->private_impl.p_decode_hg_table = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - self->private_data.s_decode_hg_table.v_tile_size_log2 = v_tile_size_log2; - - goto exit; - exit: - if (a_src && a_src->data.ptr) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - - return status; -} - -// -------- func webp.decoder.decode_pixels - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__decode_pixels( - wuffs_webp__decoder* self, - wuffs_base__slice_u8 a_dst, - wuffs_base__io_buffer* a_src, - uint32_t a_width, - uint32_t a_height, - wuffs_base__slice_u8 a_tile_data, - uint32_t a_tile_size_log2) { - wuffs_base__status status = wuffs_base__make_status(NULL); - - uint32_t v_i = 0; - uint32_t v_n = 0; - - uint32_t coro_susp_point = self->private_impl.p_decode_pixels; - switch (coro_susp_point) { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - - v_i = 0u; - v_n = (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits); - while (v_i < v_n) { - self->private_data.f_color_cache[v_i] = 0u; - v_i += 1u; - } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - status = wuffs_webp__decoder__decode_pixels_slow(self, - a_dst, - a_src, - a_width, - a_height, - a_tile_data, - a_tile_size_log2); - if (status.repr) { - goto suspend; - } - - goto ok; - ok: - self->private_impl.p_decode_pixels = 0; - goto exit; - } - - goto suspend; - suspend: - self->private_impl.p_decode_pixels = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - - goto exit; - exit: - return status; -} - -// -------- func webp.decoder.swizzle - -WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__status -wuffs_webp__decoder__swizzle( - wuffs_webp__decoder* self, - wuffs_base__pixel_buffer* a_dst, - wuffs_base__slice_u8 a_src, - wuffs_base__pixel_blend a_blend) { - wuffs_base__status v_status = wuffs_base__make_status(NULL); - wuffs_base__pixel_format v_dst_pixfmt = {0}; - uint32_t v_dst_bits_per_pixel = 0; - uint32_t v_dst_bytes_per_pixel = 0; - uint64_t v_dst_bytes_per_row = 0; - wuffs_base__slice_u8 v_dst_palette = {0}; - wuffs_base__table_u8 v_tab = {0}; - uint64_t v_src_bytes_per_row = 0; - wuffs_base__slice_u8 v_dst = {0}; - uint32_t v_y = 0; - - v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler, - wuffs_base__pixel_buffer__pixel_format(a_dst), - wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)), - wuffs_base__utility__make_pixel_format(2164295816u), - wuffs_base__utility__empty_slice_u8(), - a_blend); - if ( ! wuffs_base__status__is_ok(&v_status)) { - return wuffs_private_impl__status__ensure_not_a_suspension(v_status); - } - v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); - v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt); - if ((v_dst_bits_per_pixel & 7u) != 0u) { - return wuffs_base__make_status(wuffs_base__error__unsupported_option); - } - v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u); - v_dst_bytes_per_row = ((uint64_t)((self->private_impl.f_width * v_dst_bytes_per_pixel))); - v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)); - v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); - v_src_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 4u))); - while (v_src_bytes_per_row <= ((uint64_t)(a_src.len))) { - v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y); - if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) { - v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row); - } - wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(a_src, v_src_bytes_per_row)); - a_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_bytes_per_row); - v_y += 1u; - } - return wuffs_base__make_status(NULL); -} - // -------- func webp.decoder.frame_dirty_rect WUFFS_BASE__GENERATED_C_CODE diff --git a/std/webp/decode_vp8l.wuffs b/std/webp/decode_vp8l.wuffs new file mode 100644 index 00000000..c0b9f605 --- /dev/null +++ b/std/webp/decode_vp8l.wuffs @@ -0,0 +1,480 @@ +// Copyright 2026 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +pri func decoder.do_decode_frame_vp8l?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) { + var c8 : base.u8 + var has_more : base.u32[..= 1] + var width : base.u32[..= 0x4000] + var dst : slice base.u8 + var tile_data : roslice base.u8 + var status : base.status + var pix : slice base.u8 + var which : base.u32[..= 4] + var transform_type : base.u32[..= 3] + var ti : base.u64 + var tj : base.u64 + + this.seen_transform[0] = false + this.seen_transform[1] = false + this.seen_transform[2] = false + this.seen_transform[3] = false + this.n_transforms = 0 + + while true { + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + has_more = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + if has_more == 0 { + break + } + this.decode_transform?(src: args.src, workbuf: args.workbuf) + } + + width = this.width + if this.seen_transform[3] { + width = this.color_indexing_width + } + + this.decode_color_cache_parameters?(src: args.src) + this.overall_color_cache_bits = this.color_cache_bits + this.decode_hg_table?(src: args.src, width: width, workbuf: args.workbuf) + this.color_cache_bits = this.overall_color_cache_bits + this.decode_huffman_groups?(src: args.src, n_huffman_groups: this.overall_n_huffman_groups) + + while true { + if ((this.workbuf_offset_for_color_indexing as base.u64) > (this.workbuf_offset_for_transform[0] as base.u64)) or + ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + assert (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_offset_for_transform[1] as base.u64) + + dst = args.workbuf[ + (this.workbuf_offset_for_color_indexing as base.u64) .. + (this.workbuf_offset_for_transform[0] as base.u64)] + tile_data = args.workbuf[ + (this.workbuf_offset_for_transform[0] as base.u64) .. + (this.workbuf_offset_for_transform[1] as base.u64)] + status =? this.decode_pixels?( + dst: dst, + src: args.src, + width: width, + height: this.height, + tile_data: tile_data, + tile_size_log2: this.overall_tile_size_log2) + if status.is_ok() { + break + } + yield? status + } + + if (this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length() { + return base."#bad workbuf length" + } + pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)] + width = this.width + if this.seen_transform[3] and + ((this.workbuf_offset_for_color_indexing as base.u64) <= pix.length()) { + pix = pix[this.workbuf_offset_for_color_indexing as base.u64 ..] + width = this.color_indexing_width + } + + which = this.n_transforms + while which > 0 { + which -= 1 + transform_type = this.transform_type[which] as base.u32 + + tile_data = this.util.empty_slice_u8() + if transform_type < 2 { + ti = this.workbuf_offset_for_transform[transform_type + 1] as base.u64 + tj = this.workbuf_offset_for_transform[transform_type + 2] as base.u64 + if (ti <= tj) and (tj <= args.workbuf.length()) { + tile_data = args.workbuf[ti .. tj] + } + } + + if transform_type == 0 { + this.apply_transform_predictor!(pix: pix, width: width, tile_data: tile_data) + } else if transform_type == 1 { + this.apply_transform_cross_color!(pix: pix, width: width, tile_data: tile_data) + } else if transform_type == 2 { + this.apply_transform_subtract_green!(pix: pix) + } else if (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() { + pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)] + width = this.width + this.apply_transform_color_indexing!(pix: pix, width: width) + } + } + + status = this.swizzle!( + dst: args.dst, + src: pix, + blend: args.blend) + if not status.is_ok() { + return status + } + + this.call_sequence = 0x60 +} + +pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) { + var status : base.status + var c8 : base.u8 + var transform_type : base.u32[..= 3] + var tile_size_log2 : base.u32[..= 9] + var width : base.u32[..= 0x4000] + var p : slice base.u8 + + if this.n_bits < 2 { + c8 = args.src.read_u8?() + if this.n_bits >= 2 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 2 + } + transform_type = this.bits & 3 + this.bits >>= 2 + this.n_bits -= 2 + + if this.seen_transform[transform_type] or (this.n_transforms >= 4) { + return "#bad transform" + } + this.seen_transform[transform_type] = true + this.transform_type[this.n_transforms] = transform_type as base.u8 + this.n_transforms += 1 + + if transform_type < 2 { // Predictor, Cross Color transform. + if this.n_bits < 3 { + c8 = args.src.read_u8?() + if this.n_bits >= 3 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 3 + } + tile_size_log2 = (this.bits & 7) + 2 + this.transform_tile_size_log2[transform_type] = tile_size_log2 as base.u8 + this.bits >>= 3 + this.n_bits -= 3 + + this.decode_color_cache_parameters?(src: args.src) + this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) + + while true, + inv transform_type < 2, + inv tile_size_log2 >= 2, + { + width = this.width + if this.seen_transform[3] { + width = this.color_indexing_width + } + + if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or + ((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + status =? this.decode_pixels?( + dst: args.workbuf[ + (this.workbuf_offset_for_transform[transform_type + 1] as base.u64) .. + (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)], + src: args.src, + width: (width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + tile_data: this.util.empty_slice_u8(), + tile_size_log2: 0) + if status.is_ok() { + break + } + yield? status + } + + } else if transform_type == 2 { // Subtract Green transform. + // No-op. + + } else { // Color Indexing transform. + if this.n_bits < 8 { + c8 = args.src.read_u8?() + if this.n_bits >= 8 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 8 + } + this.color_indexing_palette_size = (this.bits & 0xFF) + 1 + this.bits >>= 8 + this.n_bits -= 8 + + if this.color_indexing_palette_size <= 2 { + this.color_indexing_width = (this.width + 7) / 8 + this.transform_tile_size_log2[3] = 3 + } else if this.color_indexing_palette_size <= 4 { + this.color_indexing_width = (this.width + 3) / 4 + this.transform_tile_size_log2[3] = 2 + } else if this.color_indexing_palette_size <= 16 { + this.color_indexing_width = (this.width + 1) / 2 + this.transform_tile_size_log2[3] = 1 + } else { + this.color_indexing_width = this.width + this.transform_tile_size_log2[3] = 0 + } + + if this.width >= this.color_indexing_width { + this.workbuf_offset_for_color_indexing = 4 * (this.width - this.color_indexing_width) * this.height + } + + this.decode_color_cache_parameters?(src: args.src) + this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) + + this.decode_pixels?( + dst: this.palette[.. 4 * this.color_indexing_palette_size], + src: args.src, + width: this.color_indexing_palette_size, + height: 1, + tile_data: this.util.empty_slice_u8(), + tile_size_log2: 0) + this.palette[4 * this.color_indexing_palette_size .. 1024].bulk_memset!(byte_value: 0) + + p = this.palette[.. 4 * this.color_indexing_palette_size] + while p.length() >= 8 { + p[4] ~mod+= p[0] + p[5] ~mod+= p[1] + p[6] ~mod+= p[2] + p[7] ~mod+= p[3] + p = p[4 ..] + } + } +} + +pri func decoder.decode_color_cache_parameters?(src: base.io_reader) { + var c8 : base.u8 + var use_color_cache : base.u32[..= 1] + var color_cache_bits : base.u32[..= 15] + + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + use_color_cache = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + this.color_cache_bits = 0 + if use_color_cache <> 0 { + if this.n_bits < 4 { + c8 = args.src.read_u8?() + if this.n_bits >= 4 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 4 + } + color_cache_bits = this.bits & 15 + this.bits >>= 4 + this.n_bits -= 4 + + if (color_cache_bits < 1) or (11 < color_cache_bits) { + return "#bad color cache" + } + this.color_cache_bits = color_cache_bits + } +} + +pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) { + var status : base.status + var c8 : base.u8 + var use_hg_table : base.u32[..= 1] + var tile_size_log2 : base.u32[..= 9] + var hg_pixels : slice base.u8 + var n : base.u64 + var p : roslice base.u8 + var hg_plus_1 : base.u32[..= 256] + + if this.n_bits < 1 { + c8 = args.src.read_u8?() + this.bits = (c8 as base.u32) + this.n_bits = 8 + assert this.n_bits >= 1 + } + use_hg_table = this.bits & 1 + this.bits >>= 1 + this.n_bits -= 1 + + if use_hg_table == 0 { + this.overall_n_huffman_groups = 1 + this.overall_tile_size_log2 = 0 + if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + hg_pixels = args.workbuf[ + this.workbuf_offset_for_transform[0] as base.u64 .. + this.workbuf_offset_for_transform[1] as base.u64] + if hg_pixels.length() >= 4 { + hg_pixels[0] = 0x00 + hg_pixels[1] = 0x00 + hg_pixels[2] = 0x00 + hg_pixels[3] = 0x00 + } + return ok + } + + if this.n_bits < 3 { + c8 = args.src.read_u8?() + if this.n_bits >= 3 { + return "#internal error: inconsistent n_bits" + } + this.bits |= (c8 as base.u32) << this.n_bits + this.n_bits += 8 + assert this.n_bits >= 3 + } + tile_size_log2 = (this.bits & 7) + 2 + this.bits >>= 3 + this.n_bits -= 3 + + this.overall_tile_size_log2 = tile_size_log2 + + this.decode_color_cache_parameters?(src: args.src) + this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) + while true, + inv tile_size_log2 >= 2, + { + if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + status =? this.decode_pixels?( + dst: args.workbuf[ + (this.workbuf_offset_for_transform[0] as base.u64) .. + (this.workbuf_offset_for_transform[1] as base.u64)], + src: args.src, + width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, + tile_data: this.util.empty_slice_u8(), + tile_size_log2: 0) + if status.is_ok() { + break + } + yield? status + } + + this.overall_n_huffman_groups = 1 + if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or + ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { + return base."#bad workbuf length" + } + hg_pixels = args.workbuf[ + this.workbuf_offset_for_transform[0] as base.u64 .. + this.workbuf_offset_for_transform[1] as base.u64] + n = (((args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) * + ((this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) * + 4) as base.u64 + if n > hg_pixels.length() { + return base."#bad workbuf length" + } + p = hg_pixels[.. n] + while p.length() >= 4 { + if p[2] <> 0 { + return "#unsupported number of Huffman groups" + } + hg_plus_1 = (p[1] as base.u32) + 1 + if this.overall_n_huffman_groups < hg_plus_1 { + this.overall_n_huffman_groups = hg_plus_1 + } + p = p[4 ..] + } +} + +pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) { + var i : base.u32 + var n : base.u32[..= 2048] + + i = 0 + n = (1 as base.u32) << this.color_cache_bits + while i < n { + assert i < 2048 via "a < b: a < c; c <= b"(c: n) + this.color_cache[i] = 0 + i += 1 + } + + this.decode_pixels_slow?( + dst: args.dst, + src: args.src, + width: args.width, + height: args.height, + tile_data: args.tile_data, + tile_size_log2: args.tile_size_log2) +} + +pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: roslice base.u8, blend: base.pixel_blend) base.status { + var status : base.status + var dst_pixfmt : base.pixel_format + var dst_bits_per_pixel : base.u32[..= 256] + var dst_bytes_per_pixel : base.u32[..= 32] + var dst_bytes_per_row : base.u64 + var dst_palette : slice base.u8 + var tab : table base.u8 + var src_bytes_per_row : base.u64 + var dst : slice base.u8 + var y : base.u32 + + status = this.swizzler.prepare!( + dst_pixfmt: args.dst.pixel_format(), + dst_palette: args.dst.palette_or_else(fallback: this.palette[..]), + src_pixfmt: this.util.make_pixel_format(repr: base.PIXEL_FORMAT__BGRA_NONPREMUL), + src_palette: this.util.empty_slice_u8(), + blend: args.blend) + if not status.is_ok() { + return status + } + + // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able + // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()". + dst_pixfmt = args.dst.pixel_format() + dst_bits_per_pixel = dst_pixfmt.bits_per_pixel() + if (dst_bits_per_pixel & 7) <> 0 { + return base."#unsupported option" + } + dst_bytes_per_pixel = dst_bits_per_pixel / 8 + dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64 + dst_palette = args.dst.palette_or_else(fallback: this.palette[..]) + tab = args.dst.plane(p: 0) + src_bytes_per_row = (this.width * 4) as base.u64 + + while src_bytes_per_row <= args.src.length() { + dst = tab.row_u32(y: y) + if dst_bytes_per_row < dst.length() { + dst = dst[.. dst_bytes_per_row] + } + + this.swizzler.swizzle_interleaved_from_slice!( + dst: dst, + dst_palette: dst_palette, + src: args.src[.. src_bytes_per_row]) + + args.src = args.src[src_bytes_per_row ..] + y ~mod+= 1 + } + + return ok +} diff --git a/std/webp/decode_webp.wuffs b/std/webp/decode_webp.wuffs index 187bad3f..6e5a38e7 100644 --- a/std/webp/decode_webp.wuffs +++ b/std/webp/decode_webp.wuffs @@ -603,477 +603,6 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade } } -pri func decoder.do_decode_frame_vp8l?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) { - var c8 : base.u8 - var has_more : base.u32[..= 1] - var width : base.u32[..= 0x4000] - var dst : slice base.u8 - var tile_data : roslice base.u8 - var status : base.status - var pix : slice base.u8 - var which : base.u32[..= 4] - var transform_type : base.u32[..= 3] - var ti : base.u64 - var tj : base.u64 - - this.seen_transform[0] = false - this.seen_transform[1] = false - this.seen_transform[2] = false - this.seen_transform[3] = false - this.n_transforms = 0 - - while true { - if this.n_bits < 1 { - c8 = args.src.read_u8?() - this.bits = (c8 as base.u32) - this.n_bits = 8 - assert this.n_bits >= 1 - } - has_more = this.bits & 1 - this.bits >>= 1 - this.n_bits -= 1 - - if has_more == 0 { - break - } - this.decode_transform?(src: args.src, workbuf: args.workbuf) - } - - width = this.width - if this.seen_transform[3] { - width = this.color_indexing_width - } - - this.decode_color_cache_parameters?(src: args.src) - this.overall_color_cache_bits = this.color_cache_bits - this.decode_hg_table?(src: args.src, width: width, workbuf: args.workbuf) - this.color_cache_bits = this.overall_color_cache_bits - this.decode_huffman_groups?(src: args.src, n_huffman_groups: this.overall_n_huffman_groups) - - while true { - if ((this.workbuf_offset_for_color_indexing as base.u64) > (this.workbuf_offset_for_transform[0] as base.u64)) or - ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or - ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { - return base."#bad workbuf length" - } - assert (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_offset_for_transform[1] as base.u64) - - dst = args.workbuf[ - (this.workbuf_offset_for_color_indexing as base.u64) .. - (this.workbuf_offset_for_transform[0] as base.u64)] - tile_data = args.workbuf[ - (this.workbuf_offset_for_transform[0] as base.u64) .. - (this.workbuf_offset_for_transform[1] as base.u64)] - status =? this.decode_pixels?( - dst: dst, - src: args.src, - width: width, - height: this.height, - tile_data: tile_data, - tile_size_log2: this.overall_tile_size_log2) - if status.is_ok() { - break - } - yield? status - } - - if (this.workbuf_offset_for_transform[0] as base.u64) > args.workbuf.length() { - return base."#bad workbuf length" - } - pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)] - width = this.width - if this.seen_transform[3] and - ((this.workbuf_offset_for_color_indexing as base.u64) <= pix.length()) { - pix = pix[this.workbuf_offset_for_color_indexing as base.u64 ..] - width = this.color_indexing_width - } - - which = this.n_transforms - while which > 0 { - which -= 1 - transform_type = this.transform_type[which] as base.u32 - - tile_data = this.util.empty_slice_u8() - if transform_type < 2 { - ti = this.workbuf_offset_for_transform[transform_type + 1] as base.u64 - tj = this.workbuf_offset_for_transform[transform_type + 2] as base.u64 - if (ti <= tj) and (tj <= args.workbuf.length()) { - tile_data = args.workbuf[ti .. tj] - } - } - - if transform_type == 0 { - this.apply_transform_predictor!(pix: pix, width: width, tile_data: tile_data) - } else if transform_type == 1 { - this.apply_transform_cross_color!(pix: pix, width: width, tile_data: tile_data) - } else if transform_type == 2 { - this.apply_transform_subtract_green!(pix: pix) - } else if (this.workbuf_offset_for_transform[0] as base.u64) <= args.workbuf.length() { - pix = args.workbuf[.. (this.workbuf_offset_for_transform[0] as base.u64)] - width = this.width - this.apply_transform_color_indexing!(pix: pix, width: width) - } - } - - status = this.swizzle!( - dst: args.dst, - src: pix, - blend: args.blend) - if not status.is_ok() { - return status - } - - this.call_sequence = 0x60 -} - -pri func decoder.decode_transform?(src: base.io_reader, workbuf: slice base.u8) { - var status : base.status - var c8 : base.u8 - var transform_type : base.u32[..= 3] - var tile_size_log2 : base.u32[..= 9] - var width : base.u32[..= 0x4000] - var p : slice base.u8 - - if this.n_bits < 2 { - c8 = args.src.read_u8?() - if this.n_bits >= 2 { - return "#internal error: inconsistent n_bits" - } - this.bits |= (c8 as base.u32) << this.n_bits - this.n_bits += 8 - assert this.n_bits >= 2 - } - transform_type = this.bits & 3 - this.bits >>= 2 - this.n_bits -= 2 - - if this.seen_transform[transform_type] or (this.n_transforms >= 4) { - return "#bad transform" - } - this.seen_transform[transform_type] = true - this.transform_type[this.n_transforms] = transform_type as base.u8 - this.n_transforms += 1 - - if transform_type < 2 { // Predictor, Cross Color transform. - if this.n_bits < 3 { - c8 = args.src.read_u8?() - if this.n_bits >= 3 { - return "#internal error: inconsistent n_bits" - } - this.bits |= (c8 as base.u32) << this.n_bits - this.n_bits += 8 - assert this.n_bits >= 3 - } - tile_size_log2 = (this.bits & 7) + 2 - this.transform_tile_size_log2[transform_type] = tile_size_log2 as base.u8 - this.bits >>= 3 - this.n_bits -= 3 - - this.decode_color_cache_parameters?(src: args.src) - this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) - - while true, - inv transform_type < 2, - inv tile_size_log2 >= 2, - { - width = this.width - if this.seen_transform[3] { - width = this.color_indexing_width - } - - if ((this.workbuf_offset_for_transform[transform_type + 1] as base.u64) > (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)) or - ((this.workbuf_offset_for_transform[transform_type + 2] as base.u64) > args.workbuf.length()) { - return base."#bad workbuf length" - } - status =? this.decode_pixels?( - dst: args.workbuf[ - (this.workbuf_offset_for_transform[transform_type + 1] as base.u64) .. - (this.workbuf_offset_for_transform[transform_type + 2] as base.u64)], - src: args.src, - width: (width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, - height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, - tile_data: this.util.empty_slice_u8(), - tile_size_log2: 0) - if status.is_ok() { - break - } - yield? status - } - - } else if transform_type == 2 { // Subtract Green transform. - // No-op. - - } else { // Color Indexing transform. - if this.n_bits < 8 { - c8 = args.src.read_u8?() - if this.n_bits >= 8 { - return "#internal error: inconsistent n_bits" - } - this.bits |= (c8 as base.u32) << this.n_bits - this.n_bits += 8 - assert this.n_bits >= 8 - } - this.color_indexing_palette_size = (this.bits & 0xFF) + 1 - this.bits >>= 8 - this.n_bits -= 8 - - if this.color_indexing_palette_size <= 2 { - this.color_indexing_width = (this.width + 7) / 8 - this.transform_tile_size_log2[3] = 3 - } else if this.color_indexing_palette_size <= 4 { - this.color_indexing_width = (this.width + 3) / 4 - this.transform_tile_size_log2[3] = 2 - } else if this.color_indexing_palette_size <= 16 { - this.color_indexing_width = (this.width + 1) / 2 - this.transform_tile_size_log2[3] = 1 - } else { - this.color_indexing_width = this.width - this.transform_tile_size_log2[3] = 0 - } - - if this.width >= this.color_indexing_width { - this.workbuf_offset_for_color_indexing = 4 * (this.width - this.color_indexing_width) * this.height - } - - this.decode_color_cache_parameters?(src: args.src) - this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) - - this.decode_pixels?( - dst: this.palette[.. 4 * this.color_indexing_palette_size], - src: args.src, - width: this.color_indexing_palette_size, - height: 1, - tile_data: this.util.empty_slice_u8(), - tile_size_log2: 0) - this.palette[4 * this.color_indexing_palette_size .. 1024].bulk_memset!(byte_value: 0) - - p = this.palette[.. 4 * this.color_indexing_palette_size] - while p.length() >= 8 { - p[4] ~mod+= p[0] - p[5] ~mod+= p[1] - p[6] ~mod+= p[2] - p[7] ~mod+= p[3] - p = p[4 ..] - } - } -} - -pri func decoder.decode_color_cache_parameters?(src: base.io_reader) { - var c8 : base.u8 - var use_color_cache : base.u32[..= 1] - var color_cache_bits : base.u32[..= 15] - - if this.n_bits < 1 { - c8 = args.src.read_u8?() - this.bits = (c8 as base.u32) - this.n_bits = 8 - assert this.n_bits >= 1 - } - use_color_cache = this.bits & 1 - this.bits >>= 1 - this.n_bits -= 1 - - this.color_cache_bits = 0 - if use_color_cache <> 0 { - if this.n_bits < 4 { - c8 = args.src.read_u8?() - if this.n_bits >= 4 { - return "#internal error: inconsistent n_bits" - } - this.bits |= (c8 as base.u32) << this.n_bits - this.n_bits += 8 - assert this.n_bits >= 4 - } - color_cache_bits = this.bits & 15 - this.bits >>= 4 - this.n_bits -= 4 - - if (color_cache_bits < 1) or (11 < color_cache_bits) { - return "#bad color cache" - } - this.color_cache_bits = color_cache_bits - } -} - -pri func decoder.decode_hg_table?(src: base.io_reader, width: base.u32[..= 0x4000], workbuf: slice base.u8) { - var status : base.status - var c8 : base.u8 - var use_hg_table : base.u32[..= 1] - var tile_size_log2 : base.u32[..= 9] - var hg_pixels : slice base.u8 - var n : base.u64 - var p : roslice base.u8 - var hg_plus_1 : base.u32[..= 256] - - if this.n_bits < 1 { - c8 = args.src.read_u8?() - this.bits = (c8 as base.u32) - this.n_bits = 8 - assert this.n_bits >= 1 - } - use_hg_table = this.bits & 1 - this.bits >>= 1 - this.n_bits -= 1 - - if use_hg_table == 0 { - this.overall_n_huffman_groups = 1 - this.overall_tile_size_log2 = 0 - if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or - ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { - return base."#bad workbuf length" - } - hg_pixels = args.workbuf[ - this.workbuf_offset_for_transform[0] as base.u64 .. - this.workbuf_offset_for_transform[1] as base.u64] - if hg_pixels.length() >= 4 { - hg_pixels[0] = 0x00 - hg_pixels[1] = 0x00 - hg_pixels[2] = 0x00 - hg_pixels[3] = 0x00 - } - return ok - } - - if this.n_bits < 3 { - c8 = args.src.read_u8?() - if this.n_bits >= 3 { - return "#internal error: inconsistent n_bits" - } - this.bits |= (c8 as base.u32) << this.n_bits - this.n_bits += 8 - assert this.n_bits >= 3 - } - tile_size_log2 = (this.bits & 7) + 2 - this.bits >>= 3 - this.n_bits -= 3 - - this.overall_tile_size_log2 = tile_size_log2 - - this.decode_color_cache_parameters?(src: args.src) - this.decode_huffman_groups?(src: args.src, n_huffman_groups: 1) - while true, - inv tile_size_log2 >= 2, - { - if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or - ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { - return base."#bad workbuf length" - } - status =? this.decode_pixels?( - dst: args.workbuf[ - (this.workbuf_offset_for_transform[0] as base.u64) .. - (this.workbuf_offset_for_transform[1] as base.u64)], - src: args.src, - width: (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, - height: (this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2, - tile_data: this.util.empty_slice_u8(), - tile_size_log2: 0) - if status.is_ok() { - break - } - yield? status - } - - this.overall_n_huffman_groups = 1 - if ((this.workbuf_offset_for_transform[0] as base.u64) > (this.workbuf_offset_for_transform[1] as base.u64)) or - ((this.workbuf_offset_for_transform[1] as base.u64) > args.workbuf.length()) { - return base."#bad workbuf length" - } - hg_pixels = args.workbuf[ - this.workbuf_offset_for_transform[0] as base.u64 .. - this.workbuf_offset_for_transform[1] as base.u64] - n = (((args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) * - ((this.height + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2) * - 4) as base.u64 - if n > hg_pixels.length() { - return base."#bad workbuf length" - } - p = hg_pixels[.. n] - while p.length() >= 4 { - if p[2] <> 0 { - return "#unsupported number of Huffman groups" - } - hg_plus_1 = (p[1] as base.u32) + 1 - if this.overall_n_huffman_groups < hg_plus_1 { - this.overall_n_huffman_groups = hg_plus_1 - } - p = p[4 ..] - } -} - -pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) { - var i : base.u32 - var n : base.u32[..= 2048] - - i = 0 - n = (1 as base.u32) << this.color_cache_bits - while i < n { - assert i < 2048 via "a < b: a < c; c <= b"(c: n) - this.color_cache[i] = 0 - i += 1 - } - - this.decode_pixels_slow?( - dst: args.dst, - src: args.src, - width: args.width, - height: args.height, - tile_data: args.tile_data, - tile_size_log2: args.tile_size_log2) -} - -pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: roslice base.u8, blend: base.pixel_blend) base.status { - var status : base.status - var dst_pixfmt : base.pixel_format - var dst_bits_per_pixel : base.u32[..= 256] - var dst_bytes_per_pixel : base.u32[..= 32] - var dst_bytes_per_row : base.u64 - var dst_palette : slice base.u8 - var tab : table base.u8 - var src_bytes_per_row : base.u64 - var dst : slice base.u8 - var y : base.u32 - - status = this.swizzler.prepare!( - dst_pixfmt: args.dst.pixel_format(), - dst_palette: args.dst.palette_or_else(fallback: this.palette[..]), - src_pixfmt: this.util.make_pixel_format(repr: base.PIXEL_FORMAT__BGRA_NONPREMUL), - src_palette: this.util.empty_slice_u8(), - blend: args.blend) - if not status.is_ok() { - return status - } - - // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able - // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()". - dst_pixfmt = args.dst.pixel_format() - dst_bits_per_pixel = dst_pixfmt.bits_per_pixel() - if (dst_bits_per_pixel & 7) <> 0 { - return base."#unsupported option" - } - dst_bytes_per_pixel = dst_bits_per_pixel / 8 - dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64 - dst_palette = args.dst.palette_or_else(fallback: this.palette[..]) - tab = args.dst.plane(p: 0) - src_bytes_per_row = (this.width * 4) as base.u64 - - while src_bytes_per_row <= args.src.length() { - dst = tab.row_u32(y: y) - if dst_bytes_per_row < dst.length() { - dst = dst[.. dst_bytes_per_row] - } - - this.swizzler.swizzle_interleaved_from_slice!( - dst: dst, - dst_palette: dst_palette, - src: args.src[.. src_bytes_per_row]) - - args.src = args.src[src_bytes_per_row ..] - y ~mod+= 1 - } - - return ok -} - pub func decoder.frame_dirty_rect() base.rect_ie_u32 { if this.variant == 0x01 { return this.vp8.frame_dirty_rect()