std/vp8: decode VP8X ALPH chunk

This commit is contained in:
Nigel Tao committed 2026-07-29 15:58:52 +10:00
1 parent 2a97911e02
commit e7f6c79752
14 files changed
+1246 -154

No files matched your search

+1
View File
@@ -73,4 +73,5 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
// ---------------- Images (Utility)
#define wuffs_base__utility__make_pixel_blend wuffs_base__make_pixel_blend
#define wuffs_base__utility__make_pixel_format wuffs_base__make_pixel_format
+5
View File
@@ -482,6 +482,11 @@ typedef uint8_t wuffs_base__pixel_blend;
#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
static inline wuffs_base__pixel_blend //
wuffs_base__make_pixel_blend(uint8_t repr) {
return repr;
}
// --------
// wuffs_base__pixel_alpha_transparency is a pixel format's alpha channel
+6
View File
@@ -115,6 +115,11 @@ var Consts = [...]struct {
// ----
{t.IDU8, "0", "PIXEL_BLEND__SRC"},
{t.IDU8, "1", "PIXEL_BLEND__SRC_OVER"},
// ----
{t.IDU32, "0x02000008", "PIXEL_FORMAT__A"},
{t.IDU32, "0x20000008", "PIXEL_FORMAT__Y"},
@@ -408,6 +413,7 @@ var funcsOther = [...]string{
"utility.i64_divide(a: u64, b: u64[1 ..=]) u64",
"utility.make_bitvec256(e00: u64, e01: u64, e02: u64, e03: u64) bitvec256",
"utility.make_optional_u63(has_value: bool, value: u64[..= 0x7FFF_FFFF_FFFF_FFFF]) optional_u63",
"utility.make_pixel_blend(repr: u8) pixel_blend",
"utility.make_pixel_format(repr: u32) pixel_format",
"utility.make_range_ii_u32(min_incl: u32, max_incl: u32) range_ii_u32",
"utility.make_range_ie_u32(min_incl: u32, max_excl: u32) range_ie_u32",
+619 -79
View File
@@ -4826,6 +4826,11 @@ typedef uint8_t wuffs_base__pixel_blend;
#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
static inline wuffs_base__pixel_blend //
wuffs_base__make_pixel_blend(uint8_t repr) {
return repr;
}
// --------
// wuffs_base__pixel_alpha_transparency is a pixel format's alpha channel
@@ -15467,9 +15472,11 @@ extern const char wuffs_vp8__error__unsupported_vp8_file[];
// ---------------- Public Consts
#define WUFFS_VP8__QUIRK_WIDTH_AND_HEIGHT 1836840960u
#define WUFFS_VP8__QUIRK_HAS_ALPHA_SIDE_CHANNEL 1836840960u
#define WUFFS_VP8__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 553648127u
#define WUFFS_VP8__QUIRK_WIDTH_AND_HEIGHT 1836840961u
#define WUFFS_VP8__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 822050816u
// ---------------- Struct Declarations
@@ -15640,6 +15647,7 @@ struct wuffs_vp8__decoder__struct {
uint32_t f_mbh;
uint8_t f_call_sequence;
bool f_is_key_frame;
bool f_quirk_has_alpha_side_channel;
uint64_t f_frame_config_io_position;
uint64_t f_quirk_source_length;
uint64_t f_quirk_width_and_height;
@@ -16411,9 +16419,11 @@ struct wuffs_webp__decoder__struct {
bool f_sub_chunk_has_padding;
uint8_t f_variant;
uint8_t f_vp8x_header_flags;
uint8_t f_vp8x_alph_flags;
uint64_t f_frame_config_io_position;
uint32_t f_riff_chunk_length;
uint32_t f_sub_chunk_length;
uint32_t f_sub_chunk_type;
uint32_t f_bits;
uint32_t f_n_bits;
bool f_seen_transform[4];
@@ -16432,6 +16442,8 @@ struct wuffs_webp__decoder__struct {
uint32_t f_workbuf_offset_for_color_indexing;
wuffs_base__pixel_swizzler f_swizzler;
uint32_t p_decode_alph;
uint32_t p_decode_alph_limited;
uint32_t p_decode_huffman_groups;
uint32_t p_decode_huffman_tree;
uint32_t p_decode_huffman_tree_simple;
@@ -16525,7 +16537,6 @@ struct wuffs_webp__decoder__struct {
uint64_t scratch;
} s_do_decode_image_config_limited_vp8x;
struct {
uint32_t v_chunk_type;
uint64_t scratch;
} s_do_decode_frame;
} private_data;
@@ -19197,6 +19208,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
// ---------------- Images (Utility)
#define wuffs_base__utility__make_pixel_blend wuffs_base__make_pixel_blend
#define wuffs_base__utility__make_pixel_format wuffs_base__make_pixel_format
// ---------------- String Conversions
@@ -82052,7 +82064,6 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_vp8__decoder__decode_macroblocks(
wuffs_vp8__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
@@ -83956,11 +83967,9 @@ WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_vp8__decoder__decode_macroblocks(
wuffs_vp8__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf) {
uint32_t v_mby = 0;
uint32_t v_mbx = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
v_mbx = 0u;
while (v_mbx < self->private_impl.f_mbw) {
@@ -83992,10 +84001,6 @@ wuffs_vp8__decoder__decode_macroblocks(
} else {
wuffs_vp8__decoder__filter_normal(self, a_workbuf, (self->private_impl.f_mbh - 1u));
}
v_status = wuffs_vp8__decoder__swizzle(self, a_dst, a_workbuf);
if ( ! wuffs_base__status__is_ok(&v_status)) {
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
}
}
return wuffs_base__make_status(NULL);
}
@@ -85222,6 +85227,10 @@ wuffs_vp8__decoder__get_quirk(
if (a_key == 3u) {
return self->private_impl.f_quirk_source_length;
} else if (a_key == 1836840960u) {
if (self->private_impl.f_quirk_has_alpha_side_channel) {
return 1u;
}
} else if (a_key == 1836840961u) {
return self->private_impl.f_quirk_width_and_height;
}
return 0u;
@@ -85265,6 +85274,9 @@ wuffs_vp8__decoder__set_quirk(
}
return wuffs_base__make_status(NULL);
} else if (a_key == 1836840960u) {
self->private_impl.f_quirk_has_alpha_side_channel = (a_value != 0u);
return wuffs_base__make_status(NULL);
} else if (a_key == 1836840961u) {
v_w = ((uint32_t)(a_value));
v_h = ((uint32_t)(a_value));
if ((v_w < 1u) ||
@@ -85727,37 +85739,61 @@ wuffs_vp8__decoder__decode_frame(
self->private_impl.active_coroutine = 0;
wuffs_base__status status = wuffs_base__make_status(NULL);
uint64_t v_wh = 0;
uint64_t v_wb_len = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
wuffs_base__slice_u8 v_trimmed = {0};
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
v_trimmed = a_workbuf;
if (self->private_impl.f_quirk_has_alpha_side_channel) {
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
if (v_wh > ((uint64_t)(a_workbuf.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
}
v_trimmed = wuffs_base__slice_u8__subslice_i(a_workbuf, v_wh);
}
v_wb_len = (self->private_impl.f_workbuf_yuv_v_end + ((uint64_t)(self->private_impl.f_partitioned_data_length)) + 8u);
if (v_wb_len > ((uint64_t)(a_workbuf.len))) {
if (v_wb_len > ((uint64_t)(v_trimmed.len))) {
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
goto exit;
} else {
a_workbuf = wuffs_base__slice_u8__subslice_j(a_workbuf, v_wb_len);
v_trimmed = wuffs_base__slice_u8__subslice_j(v_trimmed, v_wb_len);
}
{
wuffs_base__status t_0 = wuffs_vp8__decoder__do_decode_frame(self,
a_dst,
a_src,
a_blend,
a_workbuf,
v_trimmed,
a_opts);
v_status = t_0;
}
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
status = wuffs_base__make_status(wuffs_vp8__error__truncated_input);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
v_status = wuffs_vp8__decoder__swizzle(self, a_dst, v_trimmed);
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;
}
ok:
self->private_impl.p_decode_frame = 0;
@@ -85859,7 +85895,7 @@ wuffs_vp8__decoder__do_decode_frame(
}
goto ok;
}
v_status = wuffs_vp8__decoder__decode_macroblocks(self, a_dst, a_workbuf);
v_status = wuffs_vp8__decoder__decode_macroblocks(self, a_workbuf);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
@@ -86060,10 +86096,14 @@ wuffs_vp8__decoder__workbuf_len(
return wuffs_base__utility__empty_range_ii_u64();
}
uint64_t v_wh = 0;
uint64_t v_wb_len = 0;
if (self->private_impl.f_quirk_has_alpha_side_channel) {
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
}
v_wb_len = (self->private_impl.f_workbuf_yuv_v_end + ((uint64_t)(self->private_impl.f_partitioned_data_length)) + 8u);
return wuffs_base__utility__make_range_ii_u64(v_wb_len, v_wb_len);
return wuffs_base__utility__make_range_ii_u64((v_wh + v_wb_len), (v_wh + v_wb_len));
}
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8)
@@ -87060,6 +87100,44 @@ WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
// ---------------- Private Function Prototypes
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph_limited(
wuffs_webp__decoder* self,
wuffs_base__io_buffer* a_src,
wuffs_base__slice_u8 a_workbuf);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__compact_alph(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_horizontal(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_vertical(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_gradient(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_huffman_groups(
@@ -87263,6 +87341,13 @@ wuffs_webp__decoder__do_decode_frame(
wuffs_base__slice_u8 a_workbuf,
wuffs_base__decode_frame_options* a_opts);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_alph_chunk(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf);
// ---------------- VTables
const wuffs_base__image_decoder__func_ptrs
@@ -87379,6 +87464,375 @@ sizeof__wuffs_webp__decoder(void) {
// ---------------- Function Implementations
// -------- func webp.decoder.decode_alph
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph(
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);
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
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_alph;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_0 = wuffs_webp__decoder__decode_alph_limited(self, a_src, a_workbuf);
v_status = t_0;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&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;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
}
ok:
self->private_impl.p_decode_alph = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_alph = 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_alph_limited
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_webp__decoder__decode_alph_limited(
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);
uint64_t v_n = 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_alph_limited;
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
{
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++;
self->private_impl.f_vp8x_alph_flags = t_0;
}
if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 3u)) == 0u) {
wuffs_private_impl__io_reader__limited_copy_u32_to_slice(
&iop_a_src, io2_a_src,(self->private_impl.f_width * self->private_impl.f_height), a_workbuf);
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 3u)) == 1u) {
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__do_decode_frame_vp8l(self,
NULL,
a_src,
wuffs_base__utility__make_pixel_blend(0u),
a_workbuf,
NULL);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
v_n = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height * 4u)));
if (v_n <= ((uint64_t)(a_workbuf.len))) {
wuffs_webp__decoder__compact_alph(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
}
} else {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
self->private_impl.f_vp8x_alph_flags |= 2u;
v_n = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
if (v_n <= ((uint64_t)(a_workbuf.len))) {
if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 4u) {
wuffs_webp__decoder__filter_alph_horizontal(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 8u) {
wuffs_webp__decoder__filter_alph_vertical(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 12u) {
wuffs_webp__decoder__filter_alph_gradient(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
}
}
goto ok;
ok:
self->private_impl.p_decode_alph_limited = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_decode_alph_limited = 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.compact_alph
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__compact_alph(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint64_t v_i = 0;
uint64_t v_j = 0;
if (((uint64_t)(a_s.len)) > 1073741824u) {
return wuffs_base__make_empty_struct();
}
v_i = 0u;
v_j = 1u;
while ((v_i < ((uint64_t)(a_s.len))) && (v_j < ((uint64_t)(a_s.len)))) {
a_s.ptr[v_i] = a_s.ptr[v_j];
v_i += 1u;
v_j += 4u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.filter_alph_horizontal
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_horizontal(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_i = 0;
uint8_t v_pred = 0;
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_pred = 0u;
if (v_y > 0u) {
v_i = ((uint64_t)(((v_y - 1u) * self->private_impl.f_width)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_pred = a_s.ptr[v_i];
}
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
a_s.ptr[v_i] += v_pred;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_pred = a_s.ptr[v_i];
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.filter_alph_vertical
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_vertical(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_i = 0;
uint8_t v_pred = 0;
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_pred = 0u;
if (v_x > 0u) {
v_i = ((uint64_t)((v_x - 1u)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_pred = a_s.ptr[v_i];
}
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
a_s.ptr[v_i] += v_pred;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_pred = a_s.ptr[v_i];
v_y += 1u;
}
v_x += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.filter_alph_gradient
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__filter_alph_gradient(
wuffs_webp__decoder* self,
wuffs_base__slice_u8 a_s) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint64_t v_i = 0;
uint8_t v_pred = 0;
uint32_t v_grad = 0;
uint8_t v_l = 0;
uint8_t v_t = 0;
uint8_t v_tl = 0;
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_i = ((uint64_t)(v_x));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
a_s.ptr[v_i] += v_pred;
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
v_pred = a_s.ptr[v_i];
v_x += 1u;
}
v_y = 1u;
while (v_y < self->private_impl.f_height) {
v_i = ((uint64_t)(((v_y - 1u) * self->private_impl.f_width)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_t = a_s.ptr[v_i];
v_tl = v_t;
v_l = v_t;
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_i = ((uint64_t)((((v_y - 1u) * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_t = a_s.ptr[v_i];
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
if (v_i >= ((uint64_t)(a_s.len))) {
break;
}
v_grad = ((uint32_t)(((uint32_t)(((uint32_t)(v_l)) + ((uint32_t)(v_t)))) - ((uint32_t)(v_tl))));
if (v_grad > 2147483647u) {
v_grad = 0u;
} else if (v_grad > 255u) {
v_grad = 255u;
}
v_l = ((uint8_t)(a_s.ptr[v_i] + ((uint8_t)(v_grad))));
a_s.ptr[v_i] = v_l;
v_tl = v_t;
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.decode_huffman_groups
WUFFS_BASE__GENERATED_C_CODE
@@ -89957,6 +90411,9 @@ wuffs_webp__decoder__swizzle(
wuffs_base__slice_u8 v_dst = {0};
uint32_t v_y = 0;
if (a_dst == NULL) {
return wuffs_base__make_status(NULL);
}
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)),
@@ -90400,10 +90857,6 @@ wuffs_webp__decoder__do_decode_image_config_limited(
}
self->private_impl.f_sub_chunk_length = t_2;
}
if (self->private_impl.f_sub_chunk_length < 4u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
goto exit;
}
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
if (self->private_impl.f_variant == 1u) {
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
@@ -90742,7 +91195,7 @@ wuffs_webp__decoder__do_decode_image_config_limited_vp8x(
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + v_transform_size);
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
v_status = wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 1836840960u, (((uint64_t)(self->private_impl.f_width)) | (((uint64_t)(self->private_impl.f_height)) << 32u)));
v_status = wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 1836840961u, (((uint64_t)(self->private_impl.f_width)) | (((uint64_t)(self->private_impl.f_height)) << 32u)));
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
@@ -91014,8 +91467,8 @@ wuffs_webp__decoder__do_decode_frame(
wuffs_base__decode_frame_options* a_opts) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_chunk_type = 0;
uint32_t v_chunk_length = 0;
uint64_t v_r_mark = 0;
wuffs_base__status v_status = wuffs_base__make_status(NULL);
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -91029,9 +91482,6 @@ wuffs_webp__decoder__do_decode_frame(
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
if (coro_susp_point) {
v_chunk_type = self->private_data.s_do_decode_frame.v_chunk_type;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -91080,7 +91530,7 @@ wuffs_webp__decoder__do_decode_frame(
*scratch |= ((uint64_t)(num_bits_0)) << 56;
}
}
v_chunk_type = t_0;
self->private_impl.f_sub_chunk_type = t_0;
}
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -91109,9 +91559,14 @@ wuffs_webp__decoder__do_decode_frame(
*scratch |= ((uint64_t)(num_bits_1)) << 56;
}
}
v_chunk_length = t_1;
self->private_impl.f_sub_chunk_length = t_1;
}
if (v_chunk_type == 1346585417u) {
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
if (self->private_impl.f_sub_chunk_length > 2147483647u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
}
if (self->private_impl.f_sub_chunk_type == 1346585417u) {
if (self->private_impl.f_variant > 4u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
@@ -91120,7 +91575,7 @@ wuffs_webp__decoder__do_decode_frame(
goto exit;
}
self->private_impl.f_variant = 8u;
} else if (v_chunk_type == 1296649793u) {
} else if (self->private_impl.f_sub_chunk_type == 1296649793u) {
if (self->private_impl.f_variant > 8u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
@@ -91129,7 +91584,7 @@ wuffs_webp__decoder__do_decode_frame(
goto exit;
}
self->private_impl.f_variant = 16u;
} else if (v_chunk_type == 1179471425u) {
} else if (self->private_impl.f_sub_chunk_type == 1179471425u) {
if (self->private_impl.f_variant > 16u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
@@ -91138,7 +91593,7 @@ wuffs_webp__decoder__do_decode_frame(
goto exit;
}
self->private_impl.f_variant = 32u;
} else if (v_chunk_type == 1213221953u) {
} else if (self->private_impl.f_sub_chunk_type == 1213221953u) {
if (self->private_impl.f_variant > 32u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
goto exit;
@@ -91147,40 +91602,46 @@ wuffs_webp__decoder__do_decode_frame(
goto exit;
}
self->private_impl.f_variant = 64u;
} else if (v_chunk_type == 540561494u) {
if (((uint64_t)(v_chunk_length)) > 8388608u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
status = wuffs_webp__decoder__decode_alph(self, a_src, a_workbuf);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 1836840960u, 1u);
} else if (self->private_impl.f_sub_chunk_type == 540561494u) {
if (((uint64_t)(self->private_impl.f_sub_chunk_length)) > 8388608u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_vp8x_vp8_chunk_length);
goto exit;
}
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(v_chunk_length)) << 1u) | 1u));
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
self->private_impl.f_variant = 129u;
break;
} else if (v_chunk_type == 1278758998u) {
} else if (self->private_impl.f_sub_chunk_type == 1278758998u) {
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 16u)) != 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_alph_vp8l_combination);
goto exit;
}
self->private_impl.f_variant = 130u;
break;
} else if (v_chunk_type == 542133592u) {
} else if (self->private_impl.f_sub_chunk_type == 542133592u) {
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 4u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
} else if (v_chunk_type == 1179211845u) {
} else if (self->private_impl.f_sub_chunk_type == 1179211845u) {
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 8u)) == 0u) {
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
goto exit;
}
}
if (v_chunk_length > 2147483647u) {
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
goto exit;
} else if ((v_chunk_length & 1u) != 0u) {
v_chunk_length += 1u;
}
self->private_data.s_do_decode_frame.scratch = v_chunk_length;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
self->private_data.s_do_decode_frame.scratch = self->private_impl.f_sub_chunk_length;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
if (self->private_data.s_do_decode_frame.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
self->private_data.s_do_decode_frame.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
iop_a_src = io2_a_src;
@@ -91188,41 +91649,87 @@ wuffs_webp__decoder__do_decode_frame(
goto suspend;
}
iop_a_src += self->private_data.s_do_decode_frame.scratch;
if (self->private_impl.f_sub_chunk_has_padding) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
goto suspend;
}
iop_a_src++;
}
}
if (((uint8_t)(self->private_impl.f_variant & 1u)) != 0u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
while (true) {
{
const bool o_0_closed_a_src = a_src->meta.closed;
const uint8_t* o_0_io2_a_src = io2_a_src;
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
((uint64_t)(self->private_impl.f_sub_chunk_length)));
if (a_src) {
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
a_src->meta.wi = n;
}
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
if (((uint8_t)(self->private_impl.f_variant & 1u)) != 0u) {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_2 = wuffs_vp8__decoder__decode_frame(&self->private_data.f_vp8,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_2;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
} else {
{
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
wuffs_base__status t_3 = wuffs_webp__decoder__do_decode_frame_vp8l(self,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
v_status = t_3;
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
}
}
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
io2_a_src = o_0_io2_a_src;
if (a_src) {
a_src->meta.closed = o_0_closed_a_src;
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
}
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
status = wuffs_vp8__decoder__decode_frame(&self->private_data.f_vp8,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
} else {
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__do_decode_frame_vp8l(self,
a_dst,
a_src,
a_blend,
a_workbuf,
a_opts);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
if (wuffs_base__status__is_ok(&v_status)) {
break;
} else if ( ! wuffs_base__status__is_suspension(&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;
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
goto exit;
}
status = v_status;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
}
if (self->private_impl.f_vp8x_alph_flags != 0u) {
wuffs_webp__decoder__apply_alph_chunk(self, a_dst, a_workbuf);
}
ok:
@@ -91233,7 +91740,6 @@ wuffs_webp__decoder__do_decode_frame(
goto suspend;
suspend:
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_do_decode_frame.v_chunk_type = v_chunk_type;
goto exit;
exit:
@@ -91244,6 +91750,40 @@ wuffs_webp__decoder__do_decode_frame(
return status;
}
// -------- func webp.decoder.apply_alph_chunk
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_webp__decoder__apply_alph_chunk(
wuffs_webp__decoder* self,
wuffs_base__pixel_buffer* a_dst,
wuffs_base__slice_u8 a_workbuf) {
uint32_t v_y = 0;
uint32_t v_x = 0;
wuffs_base__table_u8 v_tab = {0};
wuffs_base__slice_u8 v_row = {0};
uint64_t v_d = 0;
uint64_t v_s = 0;
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u);
v_y = 0u;
while (v_y < self->private_impl.f_height) {
v_row = wuffs_private_impl__table_u8__row_u32(v_tab, v_y);
v_x = 0u;
while (v_x < self->private_impl.f_width) {
v_d = ((uint64_t)(((v_x * 4u) + 3u)));
v_s = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
if ((v_d >= ((uint64_t)(v_row.len))) || (v_s >= ((uint64_t)(a_workbuf.len)))) {
break;
}
v_row.ptr[v_d] = a_workbuf.ptr[v_s];
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func webp.decoder.frame_dirty_rect
WUFFS_BASE__GENERATED_C_CODE
+4 -9
View File
@@ -8,10 +8,9 @@
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
pri func decoder.decode_macroblocks!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status {
var mby : base.u32
var mbx : base.u32
var status : base.status
pri func decoder.decode_macroblocks!(workbuf: slice base.u8) base.status {
var mby : base.u32
var mbx : base.u32
mbx = 0
while mbx < this.mbw {
@@ -55,7 +54,7 @@ pri func decoder.decode_macroblocks!(dst: ptr base.pixel_buffer, workbuf: slice
mby += 1
}
// Filter the final row, already in args.workbuf, and swizzle to args.dst.
// Filter the final row, already in args.workbuf.
if this.mbh > 0 {
if this.filt_level <= 0 {
// No-op.
@@ -65,10 +64,6 @@ pri func decoder.decode_macroblocks!(dst: ptr base.pixel_buffer, workbuf: slice
this.filter_normal!(workbuf: args.workbuf, mby: this.mbh - 1)
}
status = this.swizzle!(dst: args.dst, workbuf: args.workbuf)
if not status.is_ok() {
return status
}
}
return ok
+6 -1
View File
@@ -18,6 +18,11 @@ pri const QUIRKS_BASE : base.u32 = 0x6D7B_F800
// --------
// When this quirk is enabled, the workbuf starts with (width × height) alpha
// samples, decoded out-of-band (from the VP8 decoder's perspective, they are
// typically decoded in-band from the surrounding WebP decoder's perspective).
pub const QUIRK_HAS_ALPHA_SIDE_CHANNEL : base.u32 = 0x6D7B_F800 | 0x00
// Gives the image width and height out-of-band, in the u64 quirk value. The
// low 32 bits are the width and the high 32 bits are the height. Both
// dimensions should range within 0x0001 ..= 0x3FFF.
@@ -35,4 +40,4 @@ pri const QUIRKS_BASE : base.u32 = 0x6D7B_F800
//
// This quirk mechanism lets the outer webp decoder tell the inner vp8 decoder
// those dimensions, after parsing the VP8X chunk but before ALPH or VP8.
pub const QUIRK_WIDTH_AND_HEIGHT : base.u32 = 0x6D7B_F800 | 0x00
pub const QUIRK_WIDTH_AND_HEIGHT : base.u32 = 0x6D7B_F800 | 0x01
+58 -13
View File
@@ -17,7 +17,7 @@ pub status "#truncated input"
pub status "#unsupported QUIRK_SOURCE_LENGTH"
pub status "#unsupported VP8 file"
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0x20FF_FFFF
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0x30FF_8000
pub struct decoder? implements base.image_decoder(
width : base.u32[..= 0x3FFF],
@@ -33,6 +33,8 @@ pub struct decoder? implements base.image_decoder(
is_key_frame : base.bool,
quirk_has_alpha_side_channel : base.bool,
frame_config_io_position : base.u64,
// This uses the same representation as an wuffs_base__optional_u63:
@@ -46,6 +48,9 @@ pub struct decoder? implements base.image_decoder(
// args.workbuf strides and offsets.
//
// The foobar_end offsets are measured after any "prefix trimmed work
// buffer" adjustment (if QUIRK_HAS_ALPHA_SIDE_CHANNEL is enabled).
//
// The workbuf holds the YUV buffers (after decoding from the source
// bytes but before converting YUV to RGBX) and then also a copy of
// most of the source bytes themselves - the "at least 2, up to 9"
@@ -209,6 +214,10 @@ pub struct decoder? implements base.image_decoder(
pub func decoder.get_quirk(key: base.u32) base.u64 {
if args.key == base.QUIRK_SOURCE_LENGTH {
return this.quirk_source_length
} else if args.key == QUIRK_HAS_ALPHA_SIDE_CHANNEL {
if this.quirk_has_alpha_side_channel {
return 1
}
} else if args.key == QUIRK_WIDTH_AND_HEIGHT {
return this.quirk_width_and_height
}
@@ -236,6 +245,10 @@ pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
}
return ok
} else if args.key == QUIRK_HAS_ALPHA_SIDE_CHANNEL {
this.quirk_has_alpha_side_channel = args.value <> 0
return ok
} else if args.key == QUIRK_WIDTH_AND_HEIGHT {
w = (args.value & 0xFFFF_FFFF) as base.u32
h = (args.value & 0xFFFF_FFFF) as base.u32
@@ -381,23 +394,50 @@ pri func decoder.do_decode_frame_config?(dst: nptr base.frame_config, src: base.
}
pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
var wh : base.u64[..= 0xFFF_8001]
var wb_len : base.u64[..= DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE]
var status : base.status
// The args.workbuf, with a "prefix trimmed work buffer" adjustment, if
// QUIRK_HAS_ALPHA_SIDE_CHANNEL is enabled, in which case the first (width
// × height) bytes of args.workbuf hold alpha samples that are e.g. part of
// WebP, not part of VP8 per se.
//
// The prefix isn't used when decoding VP8 to YCbCr, but the final swizzle
// to the destination pixel buffer should combine YCbCr and Alpha.
var trimmed : slice base.u8
while true {
wb_len = this.workbuf_yuv_v_end + (this.partitioned_data_length as base.u64) + 8
if wb_len > args.workbuf.length() {
return base."#bad workbuf length"
} else {
args.workbuf = args.workbuf[.. wb_len]
trimmed = args.workbuf
if this.quirk_has_alpha_side_channel {
wh = (this.width * this.height) as base.u64
if wh > args.workbuf.length() {
return base."#bad workbuf length"
}
trimmed = args.workbuf[wh ..]
}
status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
if (status == base."$short read") and args.src.is_closed() {
wb_len = this.workbuf_yuv_v_end + (this.partitioned_data_length as base.u64) + 8
if wb_len > trimmed.length() {
return base."#bad workbuf length"
} else {
trimmed = trimmed[.. wb_len]
}
status =? this.do_decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: trimmed, opts: args.opts)
if status.is_ok() {
break
} else if (status == base."$short read") and args.src.is_closed() {
return "#truncated input"
}
yield? status
}
// TODO: trimmed should be args.workbuf.
status = this.swizzle!(dst: args.dst, workbuf: trimmed)
if not status.is_ok() {
return status
}
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
@@ -444,7 +484,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
return status
}
status = this.decode_macroblocks!(dst: args.dst, workbuf: args.workbuf)
status = this.decode_macroblocks!(workbuf: args.workbuf)
if not status.is_ok() {
return status
}
@@ -490,7 +530,7 @@ pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.sta
}
pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
// No-op. VP8 doesn't support metadata (but WEBP does).
// No-op. VP8 doesn't support metadata (but WebP does).
}
pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
@@ -498,10 +538,15 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
}
pub func decoder.workbuf_len() base.range_ii_u64 {
var wb_len : base.u64[..= DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE]
var wh : base.u64[..= 0xFFF_8001]
var wb_len : base.u64[..= DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE - 0xFFF_8001]
if this.quirk_has_alpha_side_channel {
wh = (this.width * this.height) as base.u64
}
wb_len = this.workbuf_yuv_v_end + (this.partitioned_data_length as base.u64) + 8
return this.util.make_range_ii_u64(
min_incl: wb_len,
max_incl: wb_len)
min_incl: wh + wb_len,
max_incl: wh + wb_len)
}
+242
View File
@@ -0,0 +1,242 @@
// Copyright 2026 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, 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.decode_alph?(src: base.io_reader, workbuf: slice base.u8) {
var r_mark : base.u64
var status : base.status
while true {
io_limit (io: args.src, limit: this.sub_chunk_length as base.u64) {
r_mark = args.src.mark()
status =? this.decode_alph_limited?(src: args.src, workbuf: args.workbuf)
this.sub_chunk_length ~sat-=
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
}
if status.is_ok() {
break
} else if not status.is_suspension() {
return status
} else if (status == base."$short read") and (this.sub_chunk_length == 0) {
return "#short chunk"
}
yield? status
}
}
pri func decoder.decode_alph_limited?(src: base.io_reader, workbuf: slice base.u8) {
var n : base.u64
this.vp8x_alph_flags = args.src.read_u8?()
if (this.vp8x_alph_flags & 3) == 0 {
args.src.limited_copy_u32_to_slice!(up_to: this.width * this.height, s: args.workbuf)
} else if (this.vp8x_alph_flags & 3) == 1 {
this.do_decode_frame_vp8l?(
dst: nullptr,
src: args.src,
blend: this.util.make_pixel_blend(repr: base.PIXEL_BLEND__SRC),
workbuf: args.workbuf,
opts: nullptr)
n = (this.width * this.height * 4) as base.u64
if n <= args.workbuf.length() {
this.compact_alph!(s: args.workbuf[.. n])
}
} else {
return "#bad VP8X chunk"
}
this.vp8x_alph_flags |= 2
n = (this.width * this.height) as base.u64
if n <= args.workbuf.length() {
if (this.vp8x_alph_flags & 0x0C) == 0x04 {
this.filter_alph_horizontal!(s: args.workbuf[.. n])
} else if (this.vp8x_alph_flags & 0x0C) == 0x08 {
this.filter_alph_vertical!(s: args.workbuf[.. n])
} else if (this.vp8x_alph_flags & 0x0C) == 0x0C {
this.filter_alph_gradient!(s: args.workbuf[.. n])
}
}
}
pri func decoder.compact_alph!(s: slice base.u8) {
var i : base.u64[..= 0x4000_0004]
var j : base.u64[..= 0x4000_0004]
if args.s.length() > 0x4000_0000 {
return nothing
}
i = 0
j = 1
while (i < args.s.length()) and (j < args.s.length()),
inv args.s.length() <= 0x4000_0000,
{
assert i <= 0x4000_0000 via "a <= b: a <= c; c <= b"(c: args.s.length())
assert j <= 0x4000_0000 via "a <= b: a <= c; c <= b"(c: args.s.length())
args.s[i] = args.s[j]
i += 1
j += 4
}
}
// libwebp calls this HorizontalUnfilter_C.
pri func decoder.filter_alph_horizontal!(s: slice base.u8) {
var y : base.u32
var x : base.u32
var i : base.u64
var pred : base.u8
y = 0
while y < this.height {
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
pred = 0
if y > 0 {
i = ((y - 1) * this.width) as base.u64
if i >= args.s.length() {
break
}
pred = args.s[i]
}
x = 0
while x < this.width,
inv y < 0x4000,
{
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
i = ((y * this.width) + x) as base.u64
if i >= args.s.length() {
break
}
args.s[i] ~mod+= pred
pred = args.s[i]
x += 1
}
y += 1
}
}
// libwebp calls this VerticalUnfilter_C.
pri func decoder.filter_alph_vertical!(s: slice base.u8) {
var y : base.u32
var x : base.u32
var i : base.u64
var pred : base.u8
x = 0
while x < this.width {
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
pred = 0
if x > 0 {
i = (x - 1) as base.u64
if i >= args.s.length() {
break
}
pred = args.s[i]
}
y = 0
while y < this.height,
inv x < 0x4000,
{
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
i = ((y * this.width) + x) as base.u64
if i >= args.s.length() {
break
}
args.s[i] ~mod+= pred
pred = args.s[i]
y += 1
}
x += 1
}
}
// libwebp calls this GradientUnfilter_C.
pri func decoder.filter_alph_gradient!(s: slice base.u8) {
var y : base.u32
var x : base.u32
var i : base.u64
var pred : base.u8
var grad : base.u32
var l : base.u8 // Left sample.
var t : base.u8 // Top sample.
var tl : base.u8 // Top-Left sample.
// First row.
x = 0
while x < this.width {
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
i = x as base.u64
if i >= args.s.length() {
break
}
args.s[i] ~mod+= pred
pred = args.s[i]
x += 1
}
// Other rows.
y = 1
while y < this.height,
inv y >= 1,
{
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
i = (((y - 1) * this.width) + 0) as base.u64
if i >= args.s.length() {
break
}
t = args.s[i]
tl = t
l = t
x = 0
while x < this.width,
inv y >= 1,
inv y < 0x4000,
{
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
i = (((y - 1) * this.width) + x) as base.u64
if i >= args.s.length() {
break
}
t = args.s[i]
i = ((y * this.width) + x) as base.u64
if i >= args.s.length() {
break
}
grad = ((l as base.u32) ~mod+ (t as base.u32)) ~mod- (tl as base.u32)
if grad > 0x7FFF_FFFF {
grad = 0x00
} else if grad > 0xFF {
grad = 0xFF
}
l = args.s[i] ~mod+ ((grad & 0xFF) as base.u8)
args.s[i] = l
tl = t
x += 1
}
y += 1
}
}
+6 -2
View File
@@ -8,7 +8,7 @@
//
// 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) {
pri func decoder.do_decode_frame_vp8l?(dst: nptr 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]
@@ -426,7 +426,7 @@ pri func decoder.decode_pixels?(dst: slice base.u8, src: base.io_reader, width:
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 {
pri func decoder.swizzle!(dst: nptr 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]
@@ -438,6 +438,10 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: roslice base.u8, blen
var dst : slice base.u8
var y : base.u32
if args.dst == nullptr {
return ok
}
status = this.swizzler.prepare!(
dst_pixfmt: args.dst.pixel_format(),
dst_palette: args.dst.palette_or_else(fallback: this.palette[..]),
+92 -26
View File
@@ -133,10 +133,18 @@ pub struct decoder? implements base.image_decoder(
// ICCP_FLAG = 0x00000020,
vp8x_header_flags : base.u8,
// The "Rsv| P | F | C" bits from
// https://developers.google.com/speed/webp/docs/riff_container#alpha
//
// We also re-purpose the otherwise-unused 0x02 bit to mean that we
// have seen the ALPH chunk.
vp8x_alph_flags : base.u8,
frame_config_io_position : base.u64,
riff_chunk_length : base.u32,
sub_chunk_length : base.u32,
sub_chunk_type : base.u32,
bits : base.u32,
n_bits : base.u32[..= 31],
@@ -323,9 +331,6 @@ pri func decoder.do_decode_image_config_limited?(dst: nptr base.image_config, sr
}
this.sub_chunk_length = args.src.read_u32le?()
if this.sub_chunk_length < 4 {
return "#bad header"
}
this.sub_chunk_has_padding = (this.sub_chunk_length & 1) <> 0
if this.variant == 0x01 {
@@ -513,8 +518,8 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
}
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
var chunk_type : base.u32
var chunk_length : base.u32
var r_mark : base.u64
var status : base.status
if this.call_sequence == 0x40 {
// No-op.
@@ -525,10 +530,14 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
while (this.variant & 0x03) == 0 {
chunk_type = args.src.read_u32le?()
chunk_length = args.src.read_u32le?()
this.sub_chunk_type = args.src.read_u32le?()
this.sub_chunk_length = args.src.read_u32le?()
this.sub_chunk_has_padding = (this.sub_chunk_length & 1) <> 0
if this.sub_chunk_length > 0x7FFF_FFFF {
return "#unsupported WebP file"
}
if chunk_type == 'ICCP'le {
if this.sub_chunk_type == 'ICCP'le {
if this.variant > 0x04 {
return "#bad chunk order"
} else if (this.vp8x_header_flags & 0x20) == 0 {
@@ -536,7 +545,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
this.variant = 0x08
} else if chunk_type == 'ANIM'le {
} else if this.sub_chunk_type == 'ANIM'le {
if this.variant > 0x08 {
return "#bad chunk order"
} else if (this.vp8x_header_flags & 0x02) == 0 {
@@ -544,7 +553,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
this.variant = 0x10
} else if chunk_type == 'ANMF'le {
} else if this.sub_chunk_type == 'ANMF'le {
if this.variant > 0x10 {
return "#bad chunk order"
} else if (this.vp8x_header_flags & 0x02) == 0 {
@@ -552,54 +561,111 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
}
this.variant = 0x20
} else if chunk_type == 'ALPH'le {
} else if this.sub_chunk_type == 'ALPH'le {
if this.variant > 0x20 {
return "#bad chunk order"
} else if (this.vp8x_header_flags & 0x10) == 0 {
return "#bad VP8X chunk"
}
this.variant = 0x40
this.decode_alph?(src: args.src, workbuf: args.workbuf)
this.vp8.set_quirk!(
key: vp8.QUIRK_HAS_ALPHA_SIDE_CHANNEL,
value: 1)
} else if chunk_type == 'VP8 'le {
if (chunk_length as base.u64) > VP8X_MAX_INCL_VP8_CHUNK_LENGTH_DEFAULT {
} else if this.sub_chunk_type == 'VP8 'le {
if (this.sub_chunk_length as base.u64) > VP8X_MAX_INCL_VP8_CHUNK_LENGTH_DEFAULT {
return "#unsupported VP8X/VP8 chunk length"
}
this.vp8.set_quirk!(
key: base.QUIRK_SOURCE_LENGTH,
value: ((chunk_length as base.u64) << 1) | 1)
value: ((this.sub_chunk_length as base.u64) << 1) | 1)
this.variant = 0x81
break
} else if chunk_type == 'VP8L'le {
} else if this.sub_chunk_type == 'VP8L'le {
if (this.vp8x_header_flags & 0x10) <> 0 {
return "#bad ALPH+VP8L combination"
}
this.variant = 0x82
break
} else if chunk_type == 'XMP 'le {
} else if this.sub_chunk_type == 'XMP 'le {
if (this.vp8x_header_flags & 0x04) == 0 {
return "#bad VP8X chunk"
}
} else if chunk_type == 'EXIF'le {
} else if this.sub_chunk_type == 'EXIF'le {
if (this.vp8x_header_flags & 0x08) == 0 {
return "#bad VP8X chunk"
}
}
if chunk_length > 0x7FFF_FFFF {
return "#unsupported WebP file"
} else if (chunk_length & 1) <> 0 {
chunk_length += 1
args.src.skip_u32?(n: this.sub_chunk_length)
if this.sub_chunk_has_padding {
args.src.skip_u32?(n: 1)
}
args.src.skip_u32?(n: chunk_length)
}
if (this.variant & 0x01) <> 0 {
this.vp8.decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
} else {
this.do_decode_frame_vp8l?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
while true {
io_limit (io: args.src, limit: this.sub_chunk_length as base.u64) {
r_mark = args.src.mark()
if (this.variant & 0x01) <> 0 {
status =? this.vp8.decode_frame?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
} else {
status =? this.do_decode_frame_vp8l?(dst: args.dst, src: args.src, blend: args.blend, workbuf: args.workbuf, opts: args.opts)
}
this.sub_chunk_length ~sat-=
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
}
if status.is_ok() {
break
} else if not status.is_suspension() {
return status
} else if (status == base."$short read") and (this.sub_chunk_length == 0) {
return "#short chunk"
}
yield? status
}
if this.vp8x_alph_flags <> 0 {
this.apply_alph_chunk!(dst: args.dst, workbuf: args.workbuf)
}
}
// TODO: don't assume PIXEL_BLEND__SRC and PIXEL_FORMAT__BGRA_NONPREMUL.
pri func decoder.apply_alph_chunk!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) {
var y : base.u32
var x : base.u32
var tab : table base.u8
var row : slice base.u8
var d : base.u64
var s : base.u64
tab = args.dst.plane(p: 0)
y = 0
while y < this.height {
assert y < 0x4000 via "a < b: a < c; c <= b"(c: this.height)
row = tab.row_u32(y: y)
x = 0
while x < this.width,
inv y < 0x4000,
{
assert x < 0x4000 via "a < b: a < c; c <= b"(c: this.width)
d = ((x * 4) + 3) as base.u64
s = ((y * this.width) + x) as base.u64
if (d >= row.length()) or (s >= args.workbuf.length()) {
break
}
row[d] = args.workbuf[s]
x += 1
}
y += 1
}
}
+4 -4
View File
@@ -44,7 +44,7 @@ OK. b3389858 test/3pdata/blinksuite/color-checker-srgb-color-profile.png
OK. 10721531 test/3pdata/blinksuite/count-down-color-test.gif
OK. 1abc4dc6 test/3pdata/blinksuite/count-down-color-test.png
BAD d663b0e6 test/3pdata/blinksuite/count-down-color-test.webp
OK. 83ea9bce test/3pdata/blinksuite/crbug.364830.webp
OK. 18fbe8ca test/3pdata/blinksuite/crbug.364830.webp
OK. 24ab1efd test/3pdata/blinksuite/crbug779261.gif
OK. ae034abe test/3pdata/blinksuite/crbug807324.png
OK. 4f50fdb0 test/3pdata/blinksuite/crbug827754.png
@@ -180,9 +180,9 @@ OK. 1b1f5f96 test/3pdata/blinksuite/stripes-large.png
OK. 6b85cdb9 test/3pdata/blinksuite/stripes-small.png
OK. 16c2c0fe test/3pdata/blinksuite/test-load.jpg
OK. 6fbda804 test/3pdata/blinksuite/test.webp
OK. b7690880 test/3pdata/blinksuite/test2.webp
OK. eb16e76c test/3pdata/blinksuite/test2.webp
OK. 19d3a207 test/3pdata/blinksuite/test3.webp
OK. 17bda738 test/3pdata/blinksuite/truncated.webp
OK. 22cc757c test/3pdata/blinksuite/truncated.webp
BAD 1dfa35c6 test/3pdata/blinksuite/truncated2.webp
BAD b16eb1a2 test/3pdata/blinksuite/webp-animated-icc-xmp.webp
BAD 45030792 test/3pdata/blinksuite/webp-animated-large.webp
@@ -196,7 +196,7 @@ BAD ae7f1fcf test/3pdata/blinksuite/webp-animated.webp
OK. eb191e45 test/3pdata/blinksuite/webp-color-no-profile-lossy.webp
OK. 60116c2c test/3pdata/blinksuite/webp-color-profile-crash.webp
BAD f234aa8a test/3pdata/blinksuite/webp-color-profile-lossless.webp
OK. b861d3c2 test/3pdata/blinksuite/webp-color-profile-lossy-alpha.webp
OK. db8c197f test/3pdata/blinksuite/webp-color-profile-lossy-alpha.webp
OK. 684e3635 test/3pdata/blinksuite/webp-color-profile-lossy.webp
BAD ed67a9a5 test/3pdata/blinksuite/wrong-block-length.gif
OK. 577c5c4c test/3pdata/blinksuite/ycbcr-420-fast-int-progressive.jpg
+18 -18
View File
@@ -1,19 +1,19 @@
# Generated by script/print-nia-checksums.sh
OK. 651f0caa test/3pdata/webpsuite/alpha_color_cache.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_0_method_0.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_0_method_1.webp
OK. 28779e98 test/3pdata/webpsuite/alpha_filter_1.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_1_method_0.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_1_method_1.webp
OK. 28779e98 test/3pdata/webpsuite/alpha_filter_2.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_2_method_0.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_2_method_1.webp
OK. 28779e98 test/3pdata/webpsuite/alpha_filter_3.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_3_method_0.webp
OK. 935f9fe1 test/3pdata/webpsuite/alpha_filter_3_method_1.webp
OK. 28779e98 test/3pdata/webpsuite/alpha_no_compression.webp
OK. a92322d0 test/3pdata/webpsuite/alpha_color_cache.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_0_method_0.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_0_method_1.webp
OK. d955c04f test/3pdata/webpsuite/alpha_filter_1.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_1_method_0.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_1_method_1.webp
OK. d955c04f test/3pdata/webpsuite/alpha_filter_2.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_2_method_0.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_2_method_1.webp
OK. d955c04f test/3pdata/webpsuite/alpha_filter_3.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_3_method_0.webp
OK. 1e7a17bc test/3pdata/webpsuite/alpha_filter_3_method_1.webp
OK. d955c04f test/3pdata/webpsuite/alpha_no_compression.webp
OK. 0ecfd841 test/3pdata/webpsuite/bad_palette_index.webp
OK. 4cb35952 test/3pdata/webpsuite/big_endian_bug_393.webp
OK. 79f9ca4a test/3pdata/webpsuite/big_endian_bug_393.webp
OK. 3dd065ab test/3pdata/webpsuite/bryce.webp
OK. 7794c8b2 test/3pdata/webpsuite/bug3.webp
OK. 6fbda804 test/3pdata/webpsuite/color_cache_bits_11.webp
@@ -63,10 +63,10 @@ OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_6.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_7.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_8.webp
OK. 6706e719 test/3pdata/webpsuite/lossless_vec_2_9.webp
OK. f553cdb9 test/3pdata/webpsuite/lossy_alpha1.webp
OK. 2707a535 test/3pdata/webpsuite/lossy_alpha2.webp
OK. be4ce0da test/3pdata/webpsuite/lossy_alpha3.webp
OK. 5dce2606 test/3pdata/webpsuite/lossy_alpha4.webp
OK. a62056d3 test/3pdata/webpsuite/lossy_alpha1.webp
OK. 7d50b493 test/3pdata/webpsuite/lossy_alpha2.webp
OK. 3a84e899 test/3pdata/webpsuite/lossy_alpha3.webp
OK. a9d10d15 test/3pdata/webpsuite/lossy_alpha4.webp
OK. ac62b1e6 test/3pdata/webpsuite/lossy_extreme_probabilities.webp
OK. 84ff1fbf test/3pdata/webpsuite/lossy_q0_f100.webp
OK. 6957defa test/3pdata/webpsuite/near_lossless_75.webp
+184 -1
View File
@@ -125,7 +125,7 @@ test_wuffs_webp_decode_interface_vp8x_alpha_lossy() {
return do_test__wuffs_base__image_decoder(
wuffs_webp__decoder__upcast_as__wuffs_base__image_decoder(dec),
"test/data/hippopotamus.masked-with-muybridge.lossy.webp", 0, SIZE_MAX,
36, 28, 0xFFF5F5F5); // TODO: apply the alpha channel.
36, 28, 0x7DF5F5F5); // TODO: should be 0x7D787878, because PREMUL.
}
const char* //
@@ -221,6 +221,188 @@ test_wuffs_webp_decode_many_small_reads() {
return NULL;
}
const char* //
test_wuffs_webp_decode_filter_alph() {
CHECK_FOCUS(__func__);
const int width = 41;
const int height = 6;
// src is arbitrary bytes, a subset of a noise texture.
const uint8_t src[1][246] = {
{
0x3C, 0xD4, 0xB6, 0x77, 0x64, 0xAB, 0xEF, 0x03, 0x7D, 0x2F, 0xC0,
0x24, 0x79, 0x3E, 0x87, 0x9A, 0x36, 0x7F, 0xBC, 0xF0, 0x42, 0xAF,
0x2D, 0x63, 0x22, 0xC3, 0x4E, 0x33, 0xE9, 0x67, 0x9C, 0x01, 0xA9,
0x23, 0x50, 0xDD, 0x36, 0x26, 0x4B, 0x94, 0xDC,
0x14, 0xFB, 0x47, 0x5F, 0xF2, 0x13, 0x53, 0xE7, 0xD7, 0x28, 0x8A,
0x07, 0xC6, 0x54, 0xE5, 0xB5, 0x0E, 0x78, 0xAE, 0x14, 0x84, 0xC0,
0x20, 0x7D, 0x95, 0xEA, 0x06, 0x8A, 0xFA, 0xC3, 0x70, 0x5C, 0xA6,
0x88, 0xCC, 0x09, 0xBA, 0xA6, 0x68, 0x1E, 0xB3,
0x5A, 0xA5, 0x68, 0xFD, 0x18, 0x90, 0x70, 0x3A, 0xF0, 0x5F, 0xCA,
0x44, 0x2B, 0x58, 0x12, 0xBD, 0x43, 0x61, 0xB0, 0x9D, 0x0E, 0x3F,
0xEC, 0xB6, 0x36, 0x6E, 0x94, 0xDE, 0x2F, 0xCE, 0x77, 0x92, 0x11,
0xE2, 0x37, 0x81, 0xA0, 0x46, 0xCD, 0xDF, 0xA3,
0x05, 0x97, 0xDC, 0x73, 0xE4, 0x35, 0x6D, 0xF2, 0xC7, 0x1D, 0x56,
0x7B, 0xCE, 0x2A, 0x17, 0x54, 0xE9, 0x21, 0x7E, 0x4E, 0xEB, 0x3B,
0xF9, 0x47, 0xCA, 0x75, 0xB9, 0xD9, 0x0B, 0x5A, 0x27, 0x8A, 0x4D,
0xF5, 0x1F, 0xB7, 0x8E, 0xD0, 0xA4, 0x28, 0x81,
0xD9, 0x32, 0xE4, 0xA3, 0x8F, 0x65, 0xD8, 0x9B, 0x42, 0xB2, 0x04,
0x8B, 0x19, 0xBE, 0x9B, 0x00, 0x51, 0x22, 0x31, 0xF6, 0x7C, 0xBF,
0x1A, 0x6C, 0xB0, 0x3C, 0x63, 0x0A, 0xF9, 0x53, 0x15, 0x93, 0x67,
0xB8, 0x4B, 0x01, 0xF4, 0x82, 0xBE, 0x11, 0xFD,
0x61, 0xC4, 0xA4, 0x57, 0x6D, 0x2C, 0xDD, 0xED, 0xB1, 0x92, 0x63,
0xA8, 0xE2, 0x35, 0xC8, 0x7F, 0xD5, 0x9D, 0x49, 0x85, 0xAE, 0xE2,
0x41, 0x0C, 0xFE, 0x76, 0xC5, 0x20, 0x45, 0xAC, 0x30, 0xCB, 0x73,
0x24, 0xEF, 0xDA, 0x80, 0xAB, 0x5E, 0x89, 0x6E,
},
};
const uint8_t wants[3][246] = {
{
0x3C, 0x10, 0xC6, 0x3D, 0xA1, 0x4C, 0x3B, 0x3E, 0xBB, 0xEA, 0xAA,
0xCE, 0x47, 0x85, 0x0C, 0xA6, 0xDC, 0x5B, 0x17, 0x07, 0x49, 0xF8,
0x25, 0x88, 0xAA, 0x6D, 0xBB, 0xEE, 0xD7, 0x3E, 0xDA, 0xDB, 0x84,
0xA7, 0xF7, 0xD4, 0x0A, 0x30, 0x7B, 0x0F, 0xEB,
0x50, 0x4B, 0x92, 0xF1, 0xE3, 0xF6, 0x49, 0x30, 0x07, 0x2F, 0xB9,
0xC0, 0x86, 0xDA, 0xBF, 0x74, 0x82, 0xFA, 0xA8, 0xBC, 0x40, 0x00,
0x20, 0x9D, 0x32, 0x1C, 0x22, 0xAC, 0xA6, 0x69, 0xD9, 0x35, 0xDB,
0x63, 0x2F, 0x38, 0xF2, 0x98, 0x00, 0x1E, 0xD1,
0xAA, 0x4F, 0xB7, 0xB4, 0xCC, 0x5C, 0xCC, 0x06, 0xF6, 0x55, 0x1F,
0x63, 0x8E, 0xE6, 0xF8, 0xB5, 0xF8, 0x59, 0x09, 0xA6, 0xB4, 0xF3,
0xDF, 0x95, 0xCB, 0x39, 0xCD, 0xAB, 0xDA, 0xA8, 0x1F, 0xB1, 0xC2,
0xA4, 0xDB, 0x5C, 0xFC, 0x42, 0x0F, 0xEE, 0x91,
0xAF, 0x46, 0x22, 0x95, 0x79, 0xAE, 0x1B, 0x0D, 0xD4, 0xF1, 0x47,
0xC2, 0x90, 0xBA, 0xD1, 0x25, 0x0E, 0x2F, 0xAD, 0xFB, 0xE6, 0x21,
0x1A, 0x61, 0x2B, 0xA0, 0x59, 0x32, 0x3D, 0x97, 0xBE, 0x48, 0x95,
0x8A, 0xA9, 0x60, 0xEE, 0xBE, 0x62, 0x8A, 0x0B,
0x88, 0xBA, 0x9E, 0x41, 0xD0, 0x35, 0x0D, 0xA8, 0xEA, 0x9C, 0xA0,
0x2B, 0x44, 0x02, 0x9D, 0x9D, 0xEE, 0x10, 0x41, 0x37, 0xB3, 0x72,
0x8C, 0xF8, 0xA8, 0xE4, 0x47, 0x51, 0x4A, 0x9D, 0xB2, 0x45, 0xAC,
0x64, 0xAF, 0xB0, 0xA4, 0x26, 0xE4, 0xF5, 0xF2,
0xE9, 0xAD, 0x51, 0xA8, 0x15, 0x41, 0x1E, 0x0B, 0xBC, 0x4E, 0xB1,
0x59, 0x3B, 0x70, 0x38, 0xB7, 0x8C, 0x29, 0x72, 0xF7, 0xA5, 0x87,
0xC8, 0xD4, 0xD2, 0x48, 0x0D, 0x2D, 0x72, 0x1E, 0x4E, 0x19, 0x8C,
0xB0, 0x9F, 0x79, 0xF9, 0xA4, 0x02, 0x8B, 0xF9,
},
{
0x3C, 0x10, 0xC6, 0x3D, 0xA1, 0x4C, 0x3B, 0x3E, 0xBB, 0xEA, 0xAA,
0xCE, 0x47, 0x85, 0x0C, 0xA6, 0xDC, 0x5B, 0x17, 0x07, 0x49, 0xF8,
0x25, 0x88, 0xAA, 0x6D, 0xBB, 0xEE, 0xD7, 0x3E, 0xDA, 0xDB, 0x84,
0xA7, 0xF7, 0xD4, 0x0A, 0x30, 0x7B, 0x0F, 0xEB,
0x50, 0x0B, 0x0D, 0x9C, 0x93, 0x5F, 0x8E, 0x25, 0x92, 0x12, 0x34,
0xD5, 0x0D, 0xD9, 0xF1, 0x5B, 0xEA, 0xD3, 0xC5, 0x1B, 0xCD, 0xB8,
0x45, 0x05, 0x3F, 0x57, 0xC1, 0x78, 0xD1, 0x01, 0x4A, 0x37, 0x2A,
0x2F, 0xC3, 0xDD, 0xC4, 0xD6, 0xE3, 0x2D, 0x9E,
0xAA, 0xB0, 0x75, 0x99, 0xAB, 0xEF, 0xFE, 0x5F, 0x82, 0x71, 0xFE,
0x19, 0x38, 0x31, 0x03, 0x18, 0x2D, 0x34, 0x75, 0xB8, 0xDB, 0xF7,
0x31, 0xBB, 0x75, 0xC5, 0x55, 0x56, 0x00, 0xCF, 0xC1, 0xC9, 0x3B,
0x11, 0xFA, 0x5E, 0x64, 0x1C, 0xB0, 0x0C, 0x41,
0xAF, 0x47, 0x51, 0x0C, 0x8F, 0x24, 0x6B, 0x51, 0x49, 0x8E, 0x54,
0x94, 0x06, 0x5B, 0x1A, 0x6C, 0x16, 0x55, 0xF3, 0x06, 0xC6, 0x32,
0x2A, 0x02, 0x3F, 0x3A, 0x0E, 0x2F, 0x0B, 0x29, 0xE8, 0x53, 0x88,
0x06, 0x19, 0x15, 0xF2, 0xEC, 0x54, 0x34, 0xC2,
0x88, 0x79, 0x35, 0xAF, 0x1E, 0x89, 0x43, 0xEC, 0x8B, 0x40, 0x58,
0x1F, 0x1F, 0x19, 0xB5, 0x6C, 0x67, 0x77, 0x24, 0xFC, 0x42, 0xF1,
0x44, 0x6E, 0xEF, 0x76, 0x71, 0x39, 0x04, 0x7C, 0xFD, 0xE6, 0xEF,
0xBE, 0x64, 0x16, 0xE6, 0x6E, 0x12, 0x45, 0xBF,
0xE9, 0x3D, 0xD9, 0x06, 0x8B, 0xB5, 0x20, 0xD9, 0x3C, 0xD2, 0xBB,
0xC7, 0x01, 0x4E, 0x7D, 0xEB, 0x3C, 0x14, 0x6D, 0x81, 0xF0, 0xD3,
0x85, 0x7A, 0xED, 0xEC, 0x36, 0x59, 0x49, 0x28, 0x2D, 0xB1, 0x62,
0xE2, 0x53, 0xF0, 0x66, 0x19, 0x70, 0xCE, 0x2D,
},
{
0x3C, 0x10, 0xC6, 0x3D, 0xA1, 0x4C, 0x3B, 0x3E, 0xBB, 0xEA, 0xAA,
0xCE, 0x47, 0x85, 0x0C, 0xA6, 0xDC, 0x5B, 0x17, 0x07, 0x49, 0xF8,
0x25, 0x88, 0xAA, 0x6D, 0xBB, 0xEE, 0xD7, 0x3E, 0xDA, 0xDB, 0x84,
0xA7, 0xF7, 0xD4, 0x0A, 0x30, 0x7B, 0x0F, 0xEB,
0x50, 0x1F, 0x1C, 0x5F, 0xB5, 0x73, 0xB5, 0x9F, 0xD6, 0x27, 0x8A,
0xB5, 0xF4, 0x53, 0xE5, 0xB4, 0xF8, 0xEF, 0x59, 0x5D, 0x23, 0x92,
0x20, 0x00, 0xB7, 0x64, 0xB8, 0x75, 0x58, 0xC3, 0x6F, 0xCC, 0x1B,
0xC6, 0xCB, 0xB1, 0xBA, 0x86, 0x39, 0x1E, 0xAD,
0xAA, 0x1E, 0x83, 0xC3, 0x17, 0x90, 0x42, 0x66, 0x8D, 0x5F, 0x8C,
0xFB, 0x2A, 0x58, 0xFC, 0x88, 0x0F, 0x67, 0xB0, 0x51, 0x25, 0xD3,
0x4D, 0xE3, 0x35, 0x6E, 0x56, 0xF1, 0x03, 0x3C, 0x77, 0x66, 0x11,
0x9E, 0xDA, 0x41, 0xEA, 0xFC, 0x7C, 0x40, 0x72,
0xAF, 0xBA, 0xDB, 0x72, 0xE4, 0x34, 0x6D, 0x83, 0x71, 0x60, 0xE3,
0x7A, 0xCE, 0x26, 0xE1, 0xC1, 0x31, 0xAA, 0x71, 0x60, 0x1F, 0x08,
0xF9, 0x46, 0xCA, 0x74, 0x15, 0x89, 0x0B, 0x9E, 0x00, 0x8A, 0x82,
0xF4, 0x1E, 0xB7, 0x8D, 0x6F, 0xA4, 0x90, 0x43,
0x88, 0xC5, 0xCA, 0x04, 0x05, 0x65, 0x76, 0x27, 0x57, 0xF8, 0x03,
0x8B, 0xF8, 0x0E, 0x64, 0x44, 0x51, 0xEC, 0xE4, 0xC9, 0x04, 0xBF,
0x19, 0x6C, 0xA0, 0x86, 0x8A, 0x08, 0xF9, 0x52, 0x15, 0x32, 0x91,
0xB7, 0x4B, 0xE5, 0xAF, 0x13, 0x06, 0x11, 0xFD,
0xE9, 0xC3, 0x6C, 0x57, 0xC5, 0x2B, 0x19, 0xED, 0xB0, 0x91, 0x63,
0x93, 0xE1, 0x35, 0x53, 0xB2, 0x94, 0x9C, 0xDD, 0x47, 0xAE, 0xE1,
0x7C, 0xDB, 0xFD, 0x59, 0x22, 0x20, 0x44, 0xAC, 0x9F, 0x87, 0x59,
0xA3, 0x26, 0x9A, 0xE4, 0xF3, 0x44, 0xD8, 0x6D,
},
};
wuffs_webp__decoder dec = {0};
dec.private_impl.f_width = width;
dec.private_impl.f_height = height;
for (int filter = 0; filter < 3; filter++) {
uint8_t buf[246];
memcpy(&buf[0], &src[0][0], 246);
wuffs_base__slice_u8 s = wuffs_base__make_slice_u8(&buf[0], 246);
switch (filter) {
case 0:
wuffs_webp__decoder__filter_alph_horizontal(&dec, s);
break;
case 1:
wuffs_webp__decoder__filter_alph_vertical(&dec, s);
break;
case 2:
wuffs_webp__decoder__filter_alph_gradient(&dec, s);
break;
}
if (0 == memcmp(&buf[0], &wants[filter][0], 246)) {
continue;
}
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int i = (y * width) + x;
int have = buf[i];
int want = wants[filter][i];
if (have != want) {
RETURN_FAIL("filter=%d, y=%d, x=%d: have 0x%02X, want 0x%02X", filter,
y, x, have, want);
}
}
}
return "unreachable";
}
return NULL;
}
// ---------------- Mimic Tests
#ifdef WUFFS_MIMIC
@@ -532,6 +714,7 @@ bench_mimic_webp_lossy_decode_image_4002k_24bpp() {
proc g_tests[] = {
test_wuffs_webp_decode_filter_alph,
test_wuffs_webp_decode_interface_lossless,
test_wuffs_webp_decode_interface_lossy,
test_wuffs_webp_decode_interface_vp8x_alpha_lossy,
+1 -1
View File
@@ -134,7 +134,7 @@ OK. 56cf6ae1 test/data/hippopotamus.lossy.webp
OK. 2535637e test/data/hippopotamus.masked-with-muybridge.etc2.bgra-binary.pkm
OK. 720180ee test/data/hippopotamus.masked-with-muybridge.etc2.bgra-nonpremul.pkm
OK. d3bbed27 test/data/hippopotamus.masked-with-muybridge.gif
OK. c41410be test/data/hippopotamus.masked-with-muybridge.lossy.webp
OK. 1d8cd8b2 test/data/hippopotamus.masked-with-muybridge.lossy.webp
OK. 7e6acf01 test/data/hippopotamus.masked-with-muybridge.png
OK. dcbb225a test/data/hippopotamus.nie
OK. 57d9a4dd test/data/hippopotamus.pgm