diff --git a/internal/cgen/base/fundamental-private.h b/internal/cgen/base/fundamental-private.h index 204e56cb..475af99a 100644 --- a/internal/cgen/base/fundamental-private.h +++ b/internal/cgen/base/fundamental-private.h @@ -191,6 +191,9 @@ wuffs_private_impl__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { #define wuffs_base__utility__sign_extend_convert_u32_u64(a) \ ((uint64_t)(int64_t)(int32_t)(a)) +#define wuffs_base__utility__sign_extend_rshift_u16(a, n) \ + ((uint16_t)(((int16_t)(a)) >> (n))) + #define wuffs_base__utility__sign_extend_rshift_u32(a, n) \ ((uint32_t)(((int32_t)(a)) >> (n))) diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index 01e72cbe..a4a99e17 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -409,6 +409,7 @@ var funcsOther = [...]string{ "utility.sign_extend_convert_u16_u32(a: u16) u32", "utility.sign_extend_convert_u16_u64(a: u16) u64", "utility.sign_extend_convert_u32_u64(a: u32) u64", + "utility.sign_extend_rshift_u16(a: u16, n: u16[..= 15]) u16", "utility.sign_extend_rshift_u32(a: u32, n: u32[..= 31]) u32", "utility.sign_extend_rshift_u64(a: u64, n: u32[..= 63]) u64", diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 30f100b9..0cbf9d6f 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -15532,6 +15532,8 @@ struct wuffs_vp8__decoder__struct { uint16_t f_dequants[4][3][2]; uint32_t f_prob_skip; uint8_t f_mb_subblock_modes[16]; + uint32_t f_mb_dc_nz; + uint32_t f_mb_ac_nz; uint8_t f_yuv_cache[26][32]; uint32_t f_dst_x; uint32_t f_dst_y; @@ -18294,6 +18296,9 @@ wuffs_private_impl__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { #define wuffs_base__utility__sign_extend_convert_u32_u64(a) \ ((uint64_t)(int64_t)(int32_t)(a)) +#define wuffs_base__utility__sign_extend_rshift_u16(a, n) \ + ((uint16_t)(((int16_t)(a)) >> (n))) + #define wuffs_base__utility__sign_extend_rshift_u32(a, n) \ ((uint32_t)(((int32_t)(a)) >> (n))) @@ -81895,6 +81900,27 @@ wuffs_vp8__decoder__decode_other_partition_lengths( wuffs_vp8__decoder* self, wuffs_base__slice_u8 a_workbuf); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__inverse_dct_dc_only( + wuffs_vp8__decoder* self, + uint32_t a_cachex, + uint32_t a_cachey, + uint32_t a_b); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__inverse_dct_full( + wuffs_vp8__decoder* self, + uint32_t a_cachex, + uint32_t a_cachey, + uint32_t a_b); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__inverse_wht( + wuffs_vp8__decoder* self); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_vp8__decoder__decode_macroblocks( @@ -81937,6 +81963,14 @@ wuffs_vp8__decoder__decode_one_subblock_mode( uint8_t a_top_mode, uint8_t a_left_mode); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__copy_from_yuv_cache( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mbx, + uint32_t a_mby); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__empty_struct wuffs_vp8__decoder__predict_y4( @@ -82221,10 +82255,14 @@ wuffs_vp8__decoder__decode_coefficients( uint32_t v_bc = 0; uint32_t v_by = 0; uint32_t v_bx = 0; + uint32_t v_b = 0; uint32_t v_plane = 0; uint32_t v_lnz = 0; uint32_t v_tnz = 0; + uint32_t v_bit = 0; + self->private_impl.f_mb_dc_nz = 0u; + self->private_impl.f_mb_ac_nz = 0u; wuffs_vp8__decoder__initialize_mb_coeffs(self); v_plane = 3u; if (a_luma_mode < 4u) { @@ -82241,6 +82279,7 @@ wuffs_vp8__decoder__decode_coefficients( (v_lnz + v_tnz)); self->private_data.f_mb_states_top[a_mbx] |= (v_lnz << 23u); self->private_data.f_mb_states_left |= (v_lnz << 23u); + wuffs_vp8__decoder__inverse_wht(self); v_plane = 0u; } v_by = 0u; @@ -82251,13 +82290,20 @@ wuffs_vp8__decoder__decode_coefficients( while (v_bx < 4u) { v_tnz = (1u & (self->private_data.f_mb_states_top[a_mbx] >> (24u + v_bx))); self->private_data.f_mb_states_top[a_mbx] &= (4294967295u ^ (((uint32_t)(1u)) << (24u + v_bx))); + v_b = ((4u * v_by) + v_bx); v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self, a_workbuf, a_mby, a_seg, - ((4u * v_by) + v_bx), + v_b, v_plane, (v_lnz + v_tnz)); + v_bit = 0u; + if (self->private_data.f_mb_coeffs[v_b][0u] != 0u) { + v_bit = 1u; + } + self->private_impl.f_mb_dc_nz |= (v_bit << v_b); + self->private_impl.f_mb_ac_nz |= (v_lnz << v_b); self->private_data.f_mb_states_top[a_mbx] |= (v_lnz << (24u + v_bx)); v_bx += 1u; } @@ -82274,17 +82320,24 @@ wuffs_vp8__decoder__decode_coefficients( while (v_bx < 2u) { v_tnz = (1u & (self->private_data.f_mb_states_top[a_mbx] >> (28u + v_bc + v_bx))); self->private_data.f_mb_states_top[a_mbx] &= (4294967295u ^ (((uint32_t)(1u)) << (28u + v_bc + v_bx))); + v_b = ((2u * v_bc) + + (2u * v_by) + + v_bx + + 16u); v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self, a_workbuf, a_mby, a_seg, - ((2u * v_bc) + - (2u * v_by) + - v_bx + - 16u), + v_b, 2u, (v_lnz + v_tnz)); self->private_data.f_mb_states_top[a_mbx] |= (v_lnz << (28u + v_bc + v_bx)); + v_bit = 0u; + if (self->private_data.f_mb_coeffs[v_b][0u] != 0u) { + v_bit = 1u; + } + self->private_impl.f_mb_dc_nz |= (v_bit << v_b); + self->private_impl.f_mb_ac_nz |= (v_lnz << v_b); v_bx += 1u; } self->private_data.f_mb_states_left |= (v_lnz << (28u + v_bc + v_by)); @@ -82784,6 +82837,378 @@ wuffs_vp8__decoder__decode_other_partition_lengths( return wuffs_base__make_status(NULL); } +// -------- func vp8.decoder.inverse_dct_dc_only + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__inverse_dct_dc_only( + wuffs_vp8__decoder* self, + uint32_t a_cachex, + uint32_t a_cachey, + uint32_t a_b) { + uint16_t v_dc = 0; + uint32_t v_i = 0; + + v_dc = wuffs_base__utility__sign_extend_rshift_u16(((uint16_t)(self->private_data.f_mb_coeffs[a_b][0u] + 4u)), 3u); + v_i = 0u; + while (v_i < 16u) { + self->private_impl.f_yuv_cache[(a_cachey + (v_i >> 2u))][(a_cachex + (v_i & 3u))] = WUFFS_VP8__CLAMP[((uint16_t)(1023u & ((uint16_t)(v_dc + ((uint16_t)(self->private_impl.f_yuv_cache[(a_cachey + (v_i >> 2u))][(a_cachex + (v_i & 3u))]))))))]; + v_i += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.inverse_dct_full + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__inverse_dct_full( + wuffs_vp8__decoder* self, + uint32_t a_cachex, + uint32_t a_cachey, + uint32_t a_b) { + uint32_t v_a00 = 0; + uint32_t v_a01 = 0; + uint32_t v_a02 = 0; + uint32_t v_a03 = 0; + uint32_t v_a10 = 0; + uint32_t v_a11 = 0; + uint32_t v_a12 = 0; + uint32_t v_a13 = 0; + uint32_t v_a20 = 0; + uint32_t v_a21 = 0; + uint32_t v_a22 = 0; + uint32_t v_a23 = 0; + uint32_t v_a30 = 0; + uint32_t v_a31 = 0; + uint32_t v_a32 = 0; + uint32_t v_a33 = 0; + uint32_t v_b00 = 0; + uint32_t v_b01 = 0; + uint32_t v_b02 = 0; + uint32_t v_b03 = 0; + uint32_t v_b10 = 0; + uint32_t v_b11 = 0; + uint32_t v_b12 = 0; + uint32_t v_b13 = 0; + uint32_t v_b20 = 0; + uint32_t v_b21 = 0; + uint32_t v_b22 = 0; + uint32_t v_b23 = 0; + uint32_t v_b30 = 0; + uint32_t v_b31 = 0; + uint32_t v_b32 = 0; + uint32_t v_b33 = 0; + uint32_t v_m00 = 0; + uint32_t v_m01 = 0; + uint32_t v_m02 = 0; + uint32_t v_m03 = 0; + uint32_t v_m10 = 0; + uint32_t v_m11 = 0; + uint32_t v_m12 = 0; + uint32_t v_m13 = 0; + uint32_t v_m20 = 0; + uint32_t v_m21 = 0; + uint32_t v_m22 = 0; + uint32_t v_m23 = 0; + uint32_t v_m30 = 0; + uint32_t v_m31 = 0; + uint32_t v_m32 = 0; + uint32_t v_m33 = 0; + uint32_t v_dc0 = 0; + uint32_t v_dc1 = 0; + uint32_t v_dc2 = 0; + uint32_t v_dc3 = 0; + uint32_t v_p00 = 0; + uint32_t v_p01 = 0; + uint32_t v_p02 = 0; + uint32_t v_p03 = 0; + uint32_t v_p10 = 0; + uint32_t v_p11 = 0; + uint32_t v_p12 = 0; + uint32_t v_p13 = 0; + uint32_t v_p20 = 0; + uint32_t v_p21 = 0; + uint32_t v_p22 = 0; + uint32_t v_p23 = 0; + uint32_t v_p30 = 0; + uint32_t v_p31 = 0; + uint32_t v_p32 = 0; + uint32_t v_p33 = 0; + uint32_t v_q00 = 0; + uint32_t v_q01 = 0; + uint32_t v_q02 = 0; + uint32_t v_q03 = 0; + uint32_t v_q10 = 0; + uint32_t v_q11 = 0; + uint32_t v_q12 = 0; + uint32_t v_q13 = 0; + uint32_t v_q20 = 0; + uint32_t v_q21 = 0; + uint32_t v_q22 = 0; + uint32_t v_q23 = 0; + uint32_t v_q30 = 0; + uint32_t v_q31 = 0; + uint32_t v_q32 = 0; + uint32_t v_q33 = 0; + + v_a00 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][0u]); + v_a01 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][4u]); + v_a02 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][8u]); + v_a03 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][12u]); + v_b00 = ((uint32_t)(v_a00 + v_a02)); + v_b01 = ((uint32_t)(v_a00 - v_a02)); + v_b02 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a01 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a03 * 85627u)), 16u))); + v_b03 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a01 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a03 * 35468u)), 16u))); + v_m00 = ((uint32_t)(v_b00 + v_b03)); + v_m01 = ((uint32_t)(v_b01 + v_b02)); + v_m02 = ((uint32_t)(v_b01 - v_b02)); + v_m03 = ((uint32_t)(v_b00 - v_b03)); + v_a10 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][1u]); + v_a11 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][5u]); + v_a12 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][9u]); + v_a13 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][13u]); + v_b10 = ((uint32_t)(v_a10 + v_a12)); + v_b11 = ((uint32_t)(v_a10 - v_a12)); + v_b12 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a11 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a13 * 85627u)), 16u))); + v_b13 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a11 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a13 * 35468u)), 16u))); + v_m10 = ((uint32_t)(v_b10 + v_b13)); + v_m11 = ((uint32_t)(v_b11 + v_b12)); + v_m12 = ((uint32_t)(v_b11 - v_b12)); + v_m13 = ((uint32_t)(v_b10 - v_b13)); + v_a20 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][2u]); + v_a21 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][6u]); + v_a22 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][10u]); + v_a23 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][14u]); + v_b20 = ((uint32_t)(v_a20 + v_a22)); + v_b21 = ((uint32_t)(v_a20 - v_a22)); + v_b22 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a21 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a23 * 85627u)), 16u))); + v_b23 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a21 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a23 * 35468u)), 16u))); + v_m20 = ((uint32_t)(v_b20 + v_b23)); + v_m21 = ((uint32_t)(v_b21 + v_b22)); + v_m22 = ((uint32_t)(v_b21 - v_b22)); + v_m23 = ((uint32_t)(v_b20 - v_b23)); + v_a30 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][3u]); + v_a31 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][7u]); + v_a32 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][11u]); + v_a33 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[a_b][15u]); + v_b30 = ((uint32_t)(v_a30 + v_a32)); + v_b31 = ((uint32_t)(v_a30 - v_a32)); + v_b32 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a31 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a33 * 85627u)), 16u))); + v_b33 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a31 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a33 * 35468u)), 16u))); + v_m30 = ((uint32_t)(v_b30 + v_b33)); + v_m31 = ((uint32_t)(v_b31 + v_b32)); + v_m32 = ((uint32_t)(v_b31 - v_b32)); + v_m33 = ((uint32_t)(v_b30 - v_b33)); + v_dc0 = ((uint32_t)(v_m00 + 4u)); + v_p00 = ((uint32_t)(v_dc0 + v_m20)); + v_p01 = ((uint32_t)(v_dc0 - v_m20)); + v_p02 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m10 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m30 * 85627u)), 16u))); + v_p03 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m10 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m30 * 35468u)), 16u))); + v_q00 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p00 + v_p03)), 3u); + v_q01 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p01 + v_p02)), 3u); + v_q02 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p01 - v_p02)), 3u); + v_q03 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p00 - v_p03)), 3u); + self->private_impl.f_yuv_cache[a_cachey][a_cachex] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[a_cachey][a_cachex])) + v_q00)))]; + self->private_impl.f_yuv_cache[a_cachey][(a_cachex + 1u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[a_cachey][(a_cachex + 1u)])) + v_q01)))]; + self->private_impl.f_yuv_cache[a_cachey][(a_cachex + 2u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[a_cachey][(a_cachex + 2u)])) + v_q02)))]; + self->private_impl.f_yuv_cache[a_cachey][(a_cachex + 3u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[a_cachey][(a_cachex + 3u)])) + v_q03)))]; + v_dc1 = ((uint32_t)(v_m01 + 4u)); + v_p10 = ((uint32_t)(v_dc1 + v_m21)); + v_p11 = ((uint32_t)(v_dc1 - v_m21)); + v_p12 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m11 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m31 * 85627u)), 16u))); + v_p13 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m11 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m31 * 35468u)), 16u))); + v_q10 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p10 + v_p13)), 3u); + v_q11 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p11 + v_p12)), 3u); + v_q12 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p11 - v_p12)), 3u); + v_q13 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p10 - v_p13)), 3u); + self->private_impl.f_yuv_cache[(a_cachey + 1u)][a_cachex] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 1u)][a_cachex])) + v_q10)))]; + self->private_impl.f_yuv_cache[(a_cachey + 1u)][(a_cachex + 1u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 1u)][(a_cachex + 1u)])) + v_q11)))]; + self->private_impl.f_yuv_cache[(a_cachey + 1u)][(a_cachex + 2u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 1u)][(a_cachex + 2u)])) + v_q12)))]; + self->private_impl.f_yuv_cache[(a_cachey + 1u)][(a_cachex + 3u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 1u)][(a_cachex + 3u)])) + v_q13)))]; + v_dc2 = ((uint32_t)(v_m02 + 4u)); + v_p20 = ((uint32_t)(v_dc2 + v_m22)); + v_p21 = ((uint32_t)(v_dc2 - v_m22)); + v_p22 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m12 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m32 * 85627u)), 16u))); + v_p23 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m12 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m32 * 35468u)), 16u))); + v_q20 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p20 + v_p23)), 3u); + v_q21 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p21 + v_p22)), 3u); + v_q22 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p21 - v_p22)), 3u); + v_q23 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p20 - v_p23)), 3u); + self->private_impl.f_yuv_cache[(a_cachey + 2u)][a_cachex] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 2u)][a_cachex])) + v_q20)))]; + self->private_impl.f_yuv_cache[(a_cachey + 2u)][(a_cachex + 1u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 2u)][(a_cachex + 1u)])) + v_q21)))]; + self->private_impl.f_yuv_cache[(a_cachey + 2u)][(a_cachex + 2u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 2u)][(a_cachex + 2u)])) + v_q22)))]; + self->private_impl.f_yuv_cache[(a_cachey + 2u)][(a_cachex + 3u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 2u)][(a_cachex + 3u)])) + v_q23)))]; + v_dc3 = ((uint32_t)(v_m03 + 4u)); + v_p30 = ((uint32_t)(v_dc3 + v_m23)); + v_p31 = ((uint32_t)(v_dc3 - v_m23)); + v_p32 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m13 * 35468u)), 16u) - wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m33 * 85627u)), 16u))); + v_p33 = ((uint32_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m13 * 85627u)), 16u) + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_m33 * 35468u)), 16u))); + v_q30 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p30 + v_p33)), 3u); + v_q31 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p31 + v_p32)), 3u); + v_q32 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p31 - v_p32)), 3u); + v_q33 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p30 - v_p33)), 3u); + self->private_impl.f_yuv_cache[(a_cachey + 3u)][a_cachex] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 3u)][a_cachex])) + v_q30)))]; + self->private_impl.f_yuv_cache[(a_cachey + 3u)][(a_cachex + 1u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 3u)][(a_cachex + 1u)])) + v_q31)))]; + self->private_impl.f_yuv_cache[(a_cachey + 3u)][(a_cachex + 2u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 3u)][(a_cachex + 2u)])) + v_q32)))]; + self->private_impl.f_yuv_cache[(a_cachey + 3u)][(a_cachex + 3u)] = WUFFS_VP8__CLAMP[(1023u & ((uint32_t)(((uint32_t)(self->private_impl.f_yuv_cache[(a_cachey + 3u)][(a_cachex + 3u)])) + v_q33)))]; + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.inverse_wht + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__inverse_wht( + wuffs_vp8__decoder* self) { + uint32_t v_a00 = 0; + uint32_t v_a01 = 0; + uint32_t v_a02 = 0; + uint32_t v_a03 = 0; + uint32_t v_a10 = 0; + uint32_t v_a11 = 0; + uint32_t v_a12 = 0; + uint32_t v_a13 = 0; + uint32_t v_a20 = 0; + uint32_t v_a21 = 0; + uint32_t v_a22 = 0; + uint32_t v_a23 = 0; + uint32_t v_a30 = 0; + uint32_t v_a31 = 0; + uint32_t v_a32 = 0; + uint32_t v_a33 = 0; + uint32_t v_b00 = 0; + uint32_t v_b01 = 0; + uint32_t v_b02 = 0; + uint32_t v_b03 = 0; + uint32_t v_b10 = 0; + uint32_t v_b11 = 0; + uint32_t v_b12 = 0; + uint32_t v_b13 = 0; + uint32_t v_b20 = 0; + uint32_t v_b21 = 0; + uint32_t v_b22 = 0; + uint32_t v_b23 = 0; + uint32_t v_b30 = 0; + uint32_t v_b31 = 0; + uint32_t v_b32 = 0; + uint32_t v_b33 = 0; + uint32_t v_m00 = 0; + uint32_t v_m01 = 0; + uint32_t v_m02 = 0; + uint32_t v_m03 = 0; + uint32_t v_m10 = 0; + uint32_t v_m11 = 0; + uint32_t v_m12 = 0; + uint32_t v_m13 = 0; + uint32_t v_m20 = 0; + uint32_t v_m21 = 0; + uint32_t v_m22 = 0; + uint32_t v_m23 = 0; + uint32_t v_m30 = 0; + uint32_t v_m31 = 0; + uint32_t v_m32 = 0; + uint32_t v_m33 = 0; + uint32_t v_p00 = 0; + uint32_t v_p01 = 0; + uint32_t v_p02 = 0; + uint32_t v_p03 = 0; + uint32_t v_p10 = 0; + uint32_t v_p11 = 0; + uint32_t v_p12 = 0; + uint32_t v_p13 = 0; + uint32_t v_p20 = 0; + uint32_t v_p21 = 0; + uint32_t v_p22 = 0; + uint32_t v_p23 = 0; + uint32_t v_p30 = 0; + uint32_t v_p31 = 0; + uint32_t v_p32 = 0; + uint32_t v_p33 = 0; + + v_a00 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][0u]); + v_a01 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][4u]); + v_a02 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][8u]); + v_a03 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][12u]); + v_b00 = ((uint32_t)(v_a00 + v_a03)); + v_b01 = ((uint32_t)(v_a01 + v_a02)); + v_b02 = ((uint32_t)(v_a01 - v_a02)); + v_b03 = ((uint32_t)(v_a00 - v_a03)); + v_m00 = ((uint32_t)(v_b00 + v_b01)); + v_m01 = ((uint32_t)(v_b03 + v_b02)); + v_m02 = ((uint32_t)(v_b00 - v_b01)); + v_m03 = ((uint32_t)(v_b03 - v_b02)); + v_a10 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][1u]); + v_a11 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][5u]); + v_a12 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][9u]); + v_a13 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][13u]); + v_b10 = ((uint32_t)(v_a10 + v_a13)); + v_b11 = ((uint32_t)(v_a11 + v_a12)); + v_b12 = ((uint32_t)(v_a11 - v_a12)); + v_b13 = ((uint32_t)(v_a10 - v_a13)); + v_m10 = ((uint32_t)(v_b10 + v_b11)); + v_m11 = ((uint32_t)(v_b13 + v_b12)); + v_m12 = ((uint32_t)(v_b10 - v_b11)); + v_m13 = ((uint32_t)(v_b13 - v_b12)); + v_a20 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][2u]); + v_a21 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][6u]); + v_a22 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][10u]); + v_a23 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][14u]); + v_b20 = ((uint32_t)(v_a20 + v_a23)); + v_b21 = ((uint32_t)(v_a21 + v_a22)); + v_b22 = ((uint32_t)(v_a21 - v_a22)); + v_b23 = ((uint32_t)(v_a20 - v_a23)); + v_m20 = ((uint32_t)(v_b20 + v_b21)); + v_m21 = ((uint32_t)(v_b23 + v_b22)); + v_m22 = ((uint32_t)(v_b20 - v_b21)); + v_m23 = ((uint32_t)(v_b23 - v_b22)); + v_a30 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][3u]); + v_a31 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][7u]); + v_a32 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][11u]); + v_a33 = wuffs_base__utility__sign_extend_convert_u16_u32(self->private_data.f_mb_coeffs[24u][15u]); + v_b30 = ((uint32_t)(v_a30 + v_a33)); + v_b31 = ((uint32_t)(v_a31 + v_a32)); + v_b32 = ((uint32_t)(v_a31 - v_a32)); + v_b33 = ((uint32_t)(v_a30 - v_a33)); + v_m30 = ((uint32_t)(v_b30 + v_b31)); + v_m31 = ((uint32_t)(v_b33 + v_b32)); + v_m32 = ((uint32_t)(v_b30 - v_b31)); + v_m33 = ((uint32_t)(v_b33 - v_b32)); + v_p00 = ((uint32_t)(((uint32_t)(v_m00 + v_m30)) + 3u)); + v_p01 = ((uint32_t)(v_m10 + v_m20)); + v_p02 = ((uint32_t)(v_m10 - v_m20)); + v_p03 = ((uint32_t)(((uint32_t)(v_m00 - v_m30)) + 3u)); + self->private_data.f_mb_coeffs[0u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p00 + v_p01)), 3u))); + self->private_data.f_mb_coeffs[1u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p03 + v_p02)), 3u))); + self->private_data.f_mb_coeffs[2u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p00 - v_p01)), 3u))); + self->private_data.f_mb_coeffs[3u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p03 - v_p02)), 3u))); + v_p10 = ((uint32_t)(((uint32_t)(v_m01 + v_m31)) + 3u)); + v_p11 = ((uint32_t)(v_m11 + v_m21)); + v_p12 = ((uint32_t)(v_m11 - v_m21)); + v_p13 = ((uint32_t)(((uint32_t)(v_m01 - v_m31)) + 3u)); + self->private_data.f_mb_coeffs[4u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p10 + v_p11)), 3u))); + self->private_data.f_mb_coeffs[5u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p13 + v_p12)), 3u))); + self->private_data.f_mb_coeffs[6u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p10 - v_p11)), 3u))); + self->private_data.f_mb_coeffs[7u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p13 - v_p12)), 3u))); + v_p20 = ((uint32_t)(((uint32_t)(v_m02 + v_m32)) + 3u)); + v_p21 = ((uint32_t)(v_m12 + v_m22)); + v_p22 = ((uint32_t)(v_m12 - v_m22)); + v_p23 = ((uint32_t)(((uint32_t)(v_m02 - v_m32)) + 3u)); + self->private_data.f_mb_coeffs[8u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p20 + v_p21)), 3u))); + self->private_data.f_mb_coeffs[9u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p23 + v_p22)), 3u))); + self->private_data.f_mb_coeffs[10u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p20 - v_p21)), 3u))); + self->private_data.f_mb_coeffs[11u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p23 - v_p22)), 3u))); + v_p30 = ((uint32_t)(((uint32_t)(v_m03 + v_m33)) + 3u)); + v_p31 = ((uint32_t)(v_m13 + v_m23)); + v_p32 = ((uint32_t)(v_m13 - v_m23)); + v_p33 = ((uint32_t)(((uint32_t)(v_m03 - v_m33)) + 3u)); + self->private_data.f_mb_coeffs[12u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p30 + v_p31)), 3u))); + self->private_data.f_mb_coeffs[13u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p33 + v_p32)), 3u))); + self->private_data.f_mb_coeffs[14u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p30 - v_p31)), 3u))); + self->private_data.f_mb_coeffs[15u][0u] = ((uint16_t)(wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_p33 - v_p32)), 3u))); + return wuffs_base__make_empty_struct(); +} + // -------- func vp8.decoder.decode_macroblocks WUFFS_BASE__GENERATED_C_CODE @@ -82849,6 +83274,8 @@ wuffs_vp8__decoder__decode_one_macroblock( if (v_skip) { self->private_data.f_mb_states_left &= 65535u; self->private_data.f_mb_states_top[a_mbx] &= 65535u; + self->private_impl.f_mb_dc_nz = 0u; + self->private_impl.f_mb_ac_nz = 0u; } else { wuffs_vp8__decoder__decode_coefficients(self, a_workbuf, @@ -82863,6 +83290,7 @@ wuffs_vp8__decoder__decode_one_macroblock( a_mby, v_luma_mode, v_chroma_mode); + wuffs_vp8__decoder__copy_from_yuv_cache(self, a_workbuf, a_mbx, a_mby); return wuffs_base__make_empty_struct(); } @@ -83011,6 +83439,52 @@ wuffs_vp8__decoder__decode_one_subblock_mode( return 9u; } +// -------- func vp8.decoder.copy_from_yuv_cache + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__copy_from_yuv_cache( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mbx, + uint32_t a_mby) { + uint64_t v_w = 0; + uint32_t v_i = 0; + wuffs_base__slice_u8 v_dst = {0}; + + v_w = ((uint64_t)((((a_mby * self->private_impl.f_workbuf_yuv_y_stride) + a_mbx) * 16u))); + v_i = 0u; + while (v_i < 16u) { + if (v_w < ((uint64_t)(a_workbuf.len))) { + v_dst = wuffs_base__slice_u8__subslice_i(a_workbuf, v_w); + wuffs_private_impl__slice_u8__copy_from_slice(v_dst, wuffs_base__make_slice_u8_ij(self->private_impl.f_yuv_cache[(v_i + 1u)], 8, 24)); + } + v_w += ((uint64_t)(self->private_impl.f_workbuf_yuv_y_stride)); + v_i += 1u; + } + v_w = (((uint64_t)((((a_mby * self->private_impl.f_workbuf_yuv_uv_stride) + a_mbx) * 8u))) + self->private_impl.f_workbuf_yuv_y_end); + v_i = 0u; + while (v_i < 8u) { + if (v_w < ((uint64_t)(a_workbuf.len))) { + v_dst = wuffs_base__slice_u8__subslice_i(a_workbuf, v_w); + wuffs_private_impl__slice_u8__copy_from_slice(v_dst, wuffs_base__make_slice_u8_ij(self->private_impl.f_yuv_cache[(v_i + 18u)], 8, 16)); + } + v_w += ((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)); + v_i += 1u; + } + v_w = (((uint64_t)((((a_mby * self->private_impl.f_workbuf_yuv_uv_stride) + a_mbx) * 8u))) + self->private_impl.f_workbuf_yuv_u_end); + v_i = 0u; + while (v_i < 8u) { + if (v_w < ((uint64_t)(a_workbuf.len))) { + v_dst = wuffs_base__slice_u8__subslice_i(a_workbuf, v_w); + wuffs_private_impl__slice_u8__copy_from_slice(v_dst, wuffs_base__make_slice_u8_ij(self->private_impl.f_yuv_cache[(v_i + 18u)], 24, 32)); + } + v_w += ((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)); + v_i += 1u; + } + return wuffs_base__make_empty_struct(); +} + // -------- func vp8.decoder.predict_y4 WUFFS_BASE__GENERATED_C_CODE @@ -83728,21 +84202,55 @@ wuffs_vp8__decoder__reconstruct( uint32_t a_chroma_mode) { uint32_t v_mode = 0; uint32_t v_b = 0; + uint32_t v_mask = 0; wuffs_vp8__decoder__prepare_yuv_cache(self, a_workbuf, a_mbx, a_mby); if (a_luma_mode < 4u) { v_mode = wuffs_vp8__decoder__substitute_dc_top_left(self, a_luma_mode, a_mbx, a_mby); wuffs_vp8__decoder__predict_y16(self, v_mode); - } else { - v_b = 0u; - while (v_b < 16u) { + } + v_b = 0u; + while (v_b < 16u) { + if (a_luma_mode >= 4u) { wuffs_vp8__decoder__predict_y4(self, v_b); - v_b += 1u; } + v_mask = (((uint32_t)(1u)) << v_b); + if ((self->private_impl.f_mb_ac_nz & v_mask) != 0u) { + wuffs_vp8__decoder__inverse_dct_full(self, (((v_b & 3u) * 4u) + 8u), ((v_b & 12u) + 1u), v_b); + } else if ((self->private_impl.f_mb_dc_nz & v_mask) != 0u) { + wuffs_vp8__decoder__inverse_dct_dc_only(self, (((v_b & 3u) * 4u) + 8u), ((v_b & 12u) + 1u), v_b); + } + v_b += 1u; } v_mode = wuffs_vp8__decoder__substitute_dc_top_left(self, a_chroma_mode, a_mbx, a_mby); wuffs_vp8__decoder__predict_uv8(self, 0u, v_mode); + if ((self->private_impl.f_mb_ac_nz & 983040u) != 0u) { + v_b = 0u; + while (v_b < 4u) { + wuffs_vp8__decoder__inverse_dct_full(self, (((v_b & 1u) * 4u) + 8u), (((v_b & 2u) * 2u) + 18u), (v_b + 16u)); + v_b += 1u; + } + } else if ((self->private_impl.f_mb_dc_nz & 983040u) != 0u) { + v_b = 0u; + while (v_b < 4u) { + wuffs_vp8__decoder__inverse_dct_dc_only(self, (((v_b & 1u) * 4u) + 8u), (((v_b & 2u) * 2u) + 18u), (v_b + 16u)); + v_b += 1u; + } + } wuffs_vp8__decoder__predict_uv8(self, 1u, v_mode); + if ((self->private_impl.f_mb_ac_nz & 15728640u) != 0u) { + v_b = 0u; + while (v_b < 4u) { + wuffs_vp8__decoder__inverse_dct_full(self, (((v_b & 1u) * 4u) + 24u), (((v_b & 2u) * 2u) + 18u), (v_b + 20u)); + v_b += 1u; + } + } else if ((self->private_impl.f_mb_dc_nz & 15728640u) != 0u) { + v_b = 0u; + while (v_b < 4u) { + wuffs_vp8__decoder__inverse_dct_dc_only(self, (((v_b & 1u) * 4u) + 24u), (((v_b & 2u) * 2u) + 18u), (v_b + 20u)); + v_b += 1u; + } + } return wuffs_base__make_empty_struct(); } diff --git a/std/vp8/decode_coefficients.wuffs b/std/vp8/decode_coefficients.wuffs index 42512e24..a730d55f 100644 --- a/std/vp8/decode_coefficients.wuffs +++ b/std/vp8/decode_coefficients.wuffs @@ -17,10 +17,14 @@ pri func decoder.decode_coefficients!( var bc : base.u32 var by : base.u32 var bx : base.u32 + var b : base.u32[..= 23] var plane : base.u32[..= 3] var lnz : base.u32[..= 1] var tnz : base.u32[..= 1] + var bit : base.u32[..= 1] + this.mb_dc_nz = 0 + this.mb_ac_nz = 0 this.initialize_mb_coeffs!() // Handle "intra16x16 prediction". @@ -42,6 +46,8 @@ pri func decoder.decode_coefficients!( this.mb_states_top[args.mbx] |= lnz << 23 this.mb_states_left |= lnz << 23 + + this.inverse_wht!() plane = 0 // Plane 0: Y beginning at coefficient 1. } @@ -59,18 +65,28 @@ pri func decoder.decode_coefficients!( tnz = 1 & (this.mb_states_top[args.mbx] >> (24 + bx)) this.mb_states_top[args.mbx] &= 0xFFFF_FFFF ^ ((1 as base.u32) << (24 + bx)) + b = (4 * by) + bx + lnz = this.decode_block_coefficients!( workbuf: args.workbuf, mby: args.mby, seg: args.seg, - b: (4 * by) + bx, + b: b, plane: plane, context: lnz + tnz) + bit = 0 + if this.mb_coeffs[b][0] <> 0 { + bit = 1 + } + this.mb_dc_nz |= bit << b + this.mb_ac_nz |= lnz << b this.mb_states_top[args.mbx] |= lnz << (24 + bx) + bx += 1 } this.mb_states_left |= lnz << (24 + by) + by += 1 } @@ -93,18 +109,27 @@ pri func decoder.decode_coefficients!( tnz = 1 & (this.mb_states_top[args.mbx] >> (28 + bc + bx)) this.mb_states_top[args.mbx] &= 0xFFFF_FFFF ^ ((1 as base.u32) << (28 + bc + bx)) + b = (2 * bc) + (2 * by) + bx + 16 lnz = this.decode_block_coefficients!( workbuf: args.workbuf, mby: args.mby, seg: args.seg, - b: (2 * bc) + (2 * by) + bx + 16, + b: b, plane: 2, // Plane 2: U or V. context: lnz + tnz) this.mb_states_top[args.mbx] |= lnz << (28 + bc + bx) + bit = 0 + if this.mb_coeffs[b][0] <> 0 { + bit = 1 + } + this.mb_dc_nz |= bit << b + this.mb_ac_nz |= lnz << b + bx += 1 } this.mb_states_left |= lnz << (28 + bc + by) + by += 1 } bc += 2 diff --git a/std/vp8/decode_idct_default.wuffs b/std/vp8/decode_idct_default.wuffs new file mode 100644 index 00000000..65c31e20 --- /dev/null +++ b/std/vp8/decode_idct_default.wuffs @@ -0,0 +1,486 @@ +// 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.inverse_dct_dc_only!( + cachex: base.u32[..= 28], + cachey: base.u32[..= 22], + b: base.u32[..= 23]) { + var dc : base.u16 + var i : base.u32 + + dc = this.util.sign_extend_rshift_u16(a: this.mb_coeffs[args.b][0] ~mod+ 4, n: 3) + + i = 0 + while i < 16 { + this.yuv_cache[args.cachey + (i >> 2)][args.cachex + (i & 3)] = CLAMP[1023 & (dc ~mod+ + (this.yuv_cache[args.cachey + (i >> 2)][args.cachex + (i & 3)] as base.u16))] + i += 1 + } +} + +pri func decoder.inverse_dct_full!( + cachex: base.u32[..= 28], + cachey: base.u32[..= 22], + b: base.u32[..= 23]) { + var a00 : base.u32 + var a01 : base.u32 + var a02 : base.u32 + var a03 : base.u32 + var a10 : base.u32 + var a11 : base.u32 + var a12 : base.u32 + var a13 : base.u32 + var a20 : base.u32 + var a21 : base.u32 + var a22 : base.u32 + var a23 : base.u32 + var a30 : base.u32 + var a31 : base.u32 + var a32 : base.u32 + var a33 : base.u32 + + var b00 : base.u32 + var b01 : base.u32 + var b02 : base.u32 + var b03 : base.u32 + var b10 : base.u32 + var b11 : base.u32 + var b12 : base.u32 + var b13 : base.u32 + var b20 : base.u32 + var b21 : base.u32 + var b22 : base.u32 + var b23 : base.u32 + var b30 : base.u32 + var b31 : base.u32 + var b32 : base.u32 + var b33 : base.u32 + + var m00 : base.u32 + var m01 : base.u32 + var m02 : base.u32 + var m03 : base.u32 + var m10 : base.u32 + var m11 : base.u32 + var m12 : base.u32 + var m13 : base.u32 + var m20 : base.u32 + var m21 : base.u32 + var m22 : base.u32 + var m23 : base.u32 + var m30 : base.u32 + var m31 : base.u32 + var m32 : base.u32 + var m33 : base.u32 + + var dc0 : base.u32 + var dc1 : base.u32 + var dc2 : base.u32 + var dc3 : base.u32 + + var p00 : base.u32 + var p01 : base.u32 + var p02 : base.u32 + var p03 : base.u32 + var p10 : base.u32 + var p11 : base.u32 + var p12 : base.u32 + var p13 : base.u32 + var p20 : base.u32 + var p21 : base.u32 + var p22 : base.u32 + var p23 : base.u32 + var p30 : base.u32 + var p31 : base.u32 + var p32 : base.u32 + var p33 : base.u32 + + var q00 : base.u32 + var q01 : base.u32 + var q02 : base.u32 + var q03 : base.u32 + var q10 : base.u32 + var q11 : base.u32 + var q12 : base.u32 + var q13 : base.u32 + var q20 : base.u32 + var q21 : base.u32 + var q22 : base.u32 + var q23 : base.u32 + var q30 : base.u32 + var q31 : base.u32 + var q32 : base.u32 + var q33 : base.u32 + + // 85627 is approximately 65536 * cos(pi/8) * sqrt(2). + // 35468 is approximately 65536 * sin(pi/8) * sqrt(2). + + // -------- + + a00 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x0]) + a01 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x4]) + a02 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x8]) + a03 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0xC]) + + b00 = a00 ~mod+ a02 + b01 = a00 ~mod- a02 + b02 = this.util.sign_extend_rshift_u32(a: a01 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: a03 ~mod* 85627, n: 16) + b03 = this.util.sign_extend_rshift_u32(a: a01 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: a03 ~mod* 35468, n: 16) + + m00 = b00 ~mod+ b03 + m01 = b01 ~mod+ b02 + m02 = b01 ~mod- b02 + m03 = b00 ~mod- b03 + + // ---- + + a10 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x1]) + a11 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x5]) + a12 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x9]) + a13 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0xD]) + + b10 = a10 ~mod+ a12 + b11 = a10 ~mod- a12 + b12 = this.util.sign_extend_rshift_u32(a: a11 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: a13 ~mod* 85627, n: 16) + b13 = this.util.sign_extend_rshift_u32(a: a11 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: a13 ~mod* 35468, n: 16) + + m10 = b10 ~mod+ b13 + m11 = b11 ~mod+ b12 + m12 = b11 ~mod- b12 + m13 = b10 ~mod- b13 + + // ---- + + a20 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x2]) + a21 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x6]) + a22 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0xA]) + a23 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0xE]) + + b20 = a20 ~mod+ a22 + b21 = a20 ~mod- a22 + b22 = this.util.sign_extend_rshift_u32(a: a21 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: a23 ~mod* 85627, n: 16) + b23 = this.util.sign_extend_rshift_u32(a: a21 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: a23 ~mod* 35468, n: 16) + + m20 = b20 ~mod+ b23 + m21 = b21 ~mod+ b22 + m22 = b21 ~mod- b22 + m23 = b20 ~mod- b23 + + // ---- + + a30 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x3]) + a31 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0x7]) + a32 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0xB]) + a33 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[args.b][0xF]) + + b30 = a30 ~mod+ a32 + b31 = a30 ~mod- a32 + b32 = this.util.sign_extend_rshift_u32(a: a31 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: a33 ~mod* 85627, n: 16) + b33 = this.util.sign_extend_rshift_u32(a: a31 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: a33 ~mod* 35468, n: 16) + + m30 = b30 ~mod+ b33 + m31 = b31 ~mod+ b32 + m32 = b31 ~mod- b32 + m33 = b30 ~mod- b33 + + // -------- + + dc0 = m00 ~mod+ 4 + + p00 = dc0 ~mod+ m20 + p01 = dc0 ~mod- m20 + p02 = this.util.sign_extend_rshift_u32(a: m10 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: m30 ~mod* 85627, n: 16) + p03 = this.util.sign_extend_rshift_u32(a: m10 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: m30 ~mod* 35468, n: 16) + + q00 = this.util.sign_extend_rshift_u32(a: p00 ~mod+ p03, n: 3) + q01 = this.util.sign_extend_rshift_u32(a: p01 ~mod+ p02, n: 3) + q02 = this.util.sign_extend_rshift_u32(a: p01 ~mod- p02, n: 3) + q03 = this.util.sign_extend_rshift_u32(a: p00 ~mod- p03, n: 3) + + this.yuv_cache[args.cachey + 0][args.cachex + 0] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 0][args.cachex + 0] as base.u32) ~mod+ q00)] + this.yuv_cache[args.cachey + 0][args.cachex + 1] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 0][args.cachex + 1] as base.u32) ~mod+ q01)] + this.yuv_cache[args.cachey + 0][args.cachex + 2] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 0][args.cachex + 2] as base.u32) ~mod+ q02)] + this.yuv_cache[args.cachey + 0][args.cachex + 3] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 0][args.cachex + 3] as base.u32) ~mod+ q03)] + + // ---- + + dc1 = m01 ~mod+ 4 + + p10 = dc1 ~mod+ m21 + p11 = dc1 ~mod- m21 + p12 = this.util.sign_extend_rshift_u32(a: m11 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: m31 ~mod* 85627, n: 16) + p13 = this.util.sign_extend_rshift_u32(a: m11 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: m31 ~mod* 35468, n: 16) + + q10 = this.util.sign_extend_rshift_u32(a: p10 ~mod+ p13, n: 3) + q11 = this.util.sign_extend_rshift_u32(a: p11 ~mod+ p12, n: 3) + q12 = this.util.sign_extend_rshift_u32(a: p11 ~mod- p12, n: 3) + q13 = this.util.sign_extend_rshift_u32(a: p10 ~mod- p13, n: 3) + + this.yuv_cache[args.cachey + 1][args.cachex + 0] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 1][args.cachex + 0] as base.u32) ~mod+ q10)] + this.yuv_cache[args.cachey + 1][args.cachex + 1] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 1][args.cachex + 1] as base.u32) ~mod+ q11)] + this.yuv_cache[args.cachey + 1][args.cachex + 2] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 1][args.cachex + 2] as base.u32) ~mod+ q12)] + this.yuv_cache[args.cachey + 1][args.cachex + 3] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 1][args.cachex + 3] as base.u32) ~mod+ q13)] + + // ---- + + dc2 = m02 ~mod+ 4 + + p20 = dc2 ~mod+ m22 + p21 = dc2 ~mod- m22 + p22 = this.util.sign_extend_rshift_u32(a: m12 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: m32 ~mod* 85627, n: 16) + p23 = this.util.sign_extend_rshift_u32(a: m12 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: m32 ~mod* 35468, n: 16) + + q20 = this.util.sign_extend_rshift_u32(a: p20 ~mod+ p23, n: 3) + q21 = this.util.sign_extend_rshift_u32(a: p21 ~mod+ p22, n: 3) + q22 = this.util.sign_extend_rshift_u32(a: p21 ~mod- p22, n: 3) + q23 = this.util.sign_extend_rshift_u32(a: p20 ~mod- p23, n: 3) + + this.yuv_cache[args.cachey + 2][args.cachex + 0] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 2][args.cachex + 0] as base.u32) ~mod+ q20)] + this.yuv_cache[args.cachey + 2][args.cachex + 1] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 2][args.cachex + 1] as base.u32) ~mod+ q21)] + this.yuv_cache[args.cachey + 2][args.cachex + 2] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 2][args.cachex + 2] as base.u32) ~mod+ q22)] + this.yuv_cache[args.cachey + 2][args.cachex + 3] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 2][args.cachex + 3] as base.u32) ~mod+ q23)] + + // ---- + + dc3 = m03 ~mod+ 4 + + p30 = dc3 ~mod+ m23 + p31 = dc3 ~mod- m23 + p32 = this.util.sign_extend_rshift_u32(a: m13 ~mod* 35468, n: 16) ~mod- + this.util.sign_extend_rshift_u32(a: m33 ~mod* 85627, n: 16) + p33 = this.util.sign_extend_rshift_u32(a: m13 ~mod* 85627, n: 16) ~mod+ + this.util.sign_extend_rshift_u32(a: m33 ~mod* 35468, n: 16) + + q30 = this.util.sign_extend_rshift_u32(a: p30 ~mod+ p33, n: 3) + q31 = this.util.sign_extend_rshift_u32(a: p31 ~mod+ p32, n: 3) + q32 = this.util.sign_extend_rshift_u32(a: p31 ~mod- p32, n: 3) + q33 = this.util.sign_extend_rshift_u32(a: p30 ~mod- p33, n: 3) + + this.yuv_cache[args.cachey + 3][args.cachex + 0] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 3][args.cachex + 0] as base.u32) ~mod+ q30)] + this.yuv_cache[args.cachey + 3][args.cachex + 1] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 3][args.cachex + 1] as base.u32) ~mod+ q31)] + this.yuv_cache[args.cachey + 3][args.cachex + 2] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 3][args.cachex + 2] as base.u32) ~mod+ q32)] + this.yuv_cache[args.cachey + 3][args.cachex + 3] = CLAMP[1023 & (( + this.yuv_cache[args.cachey + 3][args.cachex + 3] as base.u32) ~mod+ q33)] +} + +pri func decoder.inverse_wht!() { + var a00 : base.u32 + var a01 : base.u32 + var a02 : base.u32 + var a03 : base.u32 + var a10 : base.u32 + var a11 : base.u32 + var a12 : base.u32 + var a13 : base.u32 + var a20 : base.u32 + var a21 : base.u32 + var a22 : base.u32 + var a23 : base.u32 + var a30 : base.u32 + var a31 : base.u32 + var a32 : base.u32 + var a33 : base.u32 + + var b00 : base.u32 + var b01 : base.u32 + var b02 : base.u32 + var b03 : base.u32 + var b10 : base.u32 + var b11 : base.u32 + var b12 : base.u32 + var b13 : base.u32 + var b20 : base.u32 + var b21 : base.u32 + var b22 : base.u32 + var b23 : base.u32 + var b30 : base.u32 + var b31 : base.u32 + var b32 : base.u32 + var b33 : base.u32 + + var m00 : base.u32 + var m01 : base.u32 + var m02 : base.u32 + var m03 : base.u32 + var m10 : base.u32 + var m11 : base.u32 + var m12 : base.u32 + var m13 : base.u32 + var m20 : base.u32 + var m21 : base.u32 + var m22 : base.u32 + var m23 : base.u32 + var m30 : base.u32 + var m31 : base.u32 + var m32 : base.u32 + var m33 : base.u32 + + var p00 : base.u32 + var p01 : base.u32 + var p02 : base.u32 + var p03 : base.u32 + var p10 : base.u32 + var p11 : base.u32 + var p12 : base.u32 + var p13 : base.u32 + var p20 : base.u32 + var p21 : base.u32 + var p22 : base.u32 + var p23 : base.u32 + var p30 : base.u32 + var p31 : base.u32 + var p32 : base.u32 + var p33 : base.u32 + + // -------- + + a00 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x0]) + a01 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x4]) + a02 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x8]) + a03 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0xC]) + + b00 = a00 ~mod+ a03 + b01 = a01 ~mod+ a02 + b02 = a01 ~mod- a02 + b03 = a00 ~mod- a03 + + m00 = b00 ~mod+ b01 + m01 = b03 ~mod+ b02 + m02 = b00 ~mod- b01 + m03 = b03 ~mod- b02 + + // ---- + + a10 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x1]) + a11 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x5]) + a12 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x9]) + a13 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0xD]) + + b10 = a10 ~mod+ a13 + b11 = a11 ~mod+ a12 + b12 = a11 ~mod- a12 + b13 = a10 ~mod- a13 + + m10 = b10 ~mod+ b11 + m11 = b13 ~mod+ b12 + m12 = b10 ~mod- b11 + m13 = b13 ~mod- b12 + + // ---- + + a20 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x2]) + a21 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x6]) + a22 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0xA]) + a23 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0xE]) + + b20 = a20 ~mod+ a23 + b21 = a21 ~mod+ a22 + b22 = a21 ~mod- a22 + b23 = a20 ~mod- a23 + + m20 = b20 ~mod+ b21 + m21 = b23 ~mod+ b22 + m22 = b20 ~mod- b21 + m23 = b23 ~mod- b22 + + // ---- + + a30 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x3]) + a31 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0x7]) + a32 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0xB]) + a33 = this.util.sign_extend_convert_u16_u32(a: this.mb_coeffs[24][0xF]) + + b30 = a30 ~mod+ a33 + b31 = a31 ~mod+ a32 + b32 = a31 ~mod- a32 + b33 = a30 ~mod- a33 + + m30 = b30 ~mod+ b31 + m31 = b33 ~mod+ b32 + m32 = b30 ~mod- b31 + m33 = b33 ~mod- b32 + + // -------- + + p00 = (m00 ~mod+ m30) ~mod+ 3 + p01 = (m10 ~mod+ m20) + p02 = (m10 ~mod- m20) + p03 = (m00 ~mod- m30) ~mod+ 3 + + this.mb_coeffs[0x0][0] = (this.util.sign_extend_rshift_u32(a: p00 ~mod+ p01, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0x1][0] = (this.util.sign_extend_rshift_u32(a: p03 ~mod+ p02, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0x2][0] = (this.util.sign_extend_rshift_u32(a: p00 ~mod- p01, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0x3][0] = (this.util.sign_extend_rshift_u32(a: p03 ~mod- p02, n: 3) & 0xFFFF) as base.u16 + + // ---- + + p10 = (m01 ~mod+ m31) ~mod+ 3 + p11 = (m11 ~mod+ m21) + p12 = (m11 ~mod- m21) + p13 = (m01 ~mod- m31) ~mod+ 3 + + this.mb_coeffs[0x4][0] = (this.util.sign_extend_rshift_u32(a: p10 ~mod+ p11, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0x5][0] = (this.util.sign_extend_rshift_u32(a: p13 ~mod+ p12, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0x6][0] = (this.util.sign_extend_rshift_u32(a: p10 ~mod- p11, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0x7][0] = (this.util.sign_extend_rshift_u32(a: p13 ~mod- p12, n: 3) & 0xFFFF) as base.u16 + + // ---- + + p20 = (m02 ~mod+ m32) ~mod+ 3 + p21 = (m12 ~mod+ m22) + p22 = (m12 ~mod- m22) + p23 = (m02 ~mod- m32) ~mod+ 3 + + this.mb_coeffs[0x8][0] = (this.util.sign_extend_rshift_u32(a: p20 ~mod+ p21, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0x9][0] = (this.util.sign_extend_rshift_u32(a: p23 ~mod+ p22, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0xA][0] = (this.util.sign_extend_rshift_u32(a: p20 ~mod- p21, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0xB][0] = (this.util.sign_extend_rshift_u32(a: p23 ~mod- p22, n: 3) & 0xFFFF) as base.u16 + + // ---- + + p30 = (m03 ~mod+ m33) ~mod+ 3 + p31 = (m13 ~mod+ m23) + p32 = (m13 ~mod- m23) + p33 = (m03 ~mod- m33) ~mod+ 3 + + this.mb_coeffs[0xC][0] = (this.util.sign_extend_rshift_u32(a: p30 ~mod+ p31, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0xD][0] = (this.util.sign_extend_rshift_u32(a: p33 ~mod+ p32, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0xE][0] = (this.util.sign_extend_rshift_u32(a: p30 ~mod- p31, n: 3) & 0xFFFF) as base.u16 + this.mb_coeffs[0xF][0] = (this.util.sign_extend_rshift_u32(a: p33 ~mod- p32, n: 3) & 0xFFFF) as base.u16 +} diff --git a/std/vp8/decode_macroblocks.wuffs b/std/vp8/decode_macroblocks.wuffs index 7fbb4340..fa719c30 100644 --- a/std/vp8/decode_macroblocks.wuffs +++ b/std/vp8/decode_macroblocks.wuffs @@ -78,6 +78,8 @@ pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[.. // Clear the HNZC bits. this.mb_states_left &= 0x0000_FFFF this.mb_states_top[args.mbx] &= 0x0000_FFFF + this.mb_dc_nz = 0 + this.mb_ac_nz = 0 } else { this.decode_coefficients!( @@ -88,6 +90,9 @@ pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[.. this.reconstruct!( workbuf: args.workbuf, mbx: args.mbx, mby: args.mby, luma_mode: luma_mode, chroma_mode: chroma_mode) + + this.copy_from_yuv_cache!( + workbuf: args.workbuf, mbx: args.mbx, mby: args.mby) } // RFC 6386 Section 11.2. Luma Modes. @@ -257,3 +262,45 @@ pri func decoder.decode_one_subblock_mode!( return 9 // 9=B_HU_PRED. } + +pri func decoder.copy_from_yuv_cache!( + workbuf: slice base.u8, + mbx: base.u32[..= 0x3FF], + mby: base.u32[..= 0x3FF]) { + var w : base.u64 + var i : base.u32 + var dst : slice base.u8 + + w = ((((args.mby * this.workbuf_yuv_y_stride) + args.mbx) * 16) as base.u64) + 0 + i = 0 + while i < 16 { + if w < args.workbuf.length() { + dst = args.workbuf[w ..] + dst.copy_from_slice!(s: this.yuv_cache[i + 0x01][0x08 .. 0x18]) + } + w ~mod+= this.workbuf_yuv_y_stride as base.u64 + i += 1 + } + + w = ((((args.mby * this.workbuf_yuv_uv_stride) + args.mbx) * 8) as base.u64) + this.workbuf_yuv_y_end + i = 0 + while i < 8 { + if w < args.workbuf.length() { + dst = args.workbuf[w ..] + dst.copy_from_slice!(s: this.yuv_cache[i + 0x12][0x08 .. 0x10]) + } + w ~mod+= this.workbuf_yuv_uv_stride as base.u64 + i += 1 + } + + w = ((((args.mby * this.workbuf_yuv_uv_stride) + args.mbx) * 8) as base.u64) + this.workbuf_yuv_u_end + i = 0 + while i < 8 { + if w < args.workbuf.length() { + dst = args.workbuf[w ..] + dst.copy_from_slice!(s: this.yuv_cache[i + 0x12][0x18 .. 0x20]) + } + w ~mod+= this.workbuf_yuv_uv_stride as base.u64 + i += 1 + } +} diff --git a/std/vp8/decode_reconstruct.wuffs b/std/vp8/decode_reconstruct.wuffs index fbaa8a99..d433261e 100644 --- a/std/vp8/decode_reconstruct.wuffs +++ b/std/vp8/decode_reconstruct.wuffs @@ -16,26 +16,81 @@ pri func decoder.reconstruct!( chroma_mode: base.u32[..= 3]) { var mode : base.u32[..= 12] var b : base.u32 + var mask : base.u32 this.prepare_yuv_cache!(workbuf: args.workbuf, mbx: args.mbx, mby: args.mby) if args.luma_mode < 4 { mode = this.substitute_dc_top_left(mode: args.luma_mode, mbx: args.mbx, mby: args.mby) this.predict_y16!(mode: mode) + } - } else { - b = 0 - while b < 16 { + b = 0 + while b < 16 { + if args.luma_mode >= 4 { this.predict_y4!(b: b) - b += 1 } + + mask = (1 as base.u32) << (b + 0x00) + if (this.mb_ac_nz & mask) <> 0 { + this.inverse_dct_full!( + cachex: ((b & 0x3) * 4) + 0x08, + cachey: ((b & 0xC) * 1) + 0x01, + b: (b + 0x00)) + } else if (this.mb_dc_nz & mask) <> 0 { + this.inverse_dct_dc_only!( + cachex: ((b & 0x3) * 4) + 0x08, + cachey: ((b & 0xC) * 1) + 0x01, + b: (b + 0x00)) + } + b += 1 } mode = this.substitute_dc_top_left(mode: args.chroma_mode, mbx: args.mbx, mby: args.mby) this.predict_uv8!(b: 0, mode: mode) + if (this.mb_ac_nz & 0x0F_0000) <> 0 { + b = 0 + while b < 4 { + this.inverse_dct_full!( + cachex: ((b & 0x1) * 4) + 0x08, + cachey: ((b & 0x2) * 2) + 0x12, + b: (b + 0x10)) + b += 1 + } + } else if (this.mb_dc_nz & 0x0F_0000) <> 0 { + b = 0 + while b < 4 { + this.inverse_dct_dc_only!( + cachex: ((b & 0x1) * 4) + 0x08, + cachey: ((b & 0x2) * 2) + 0x12, + b: (b + 0x10)) + b += 1 + } + } + this.predict_uv8!(b: 1, mode: mode) + + if (this.mb_ac_nz & 0xF0_0000) <> 0 { + b = 0 + while b < 4 { + this.inverse_dct_full!( + cachex: ((b & 0x1) * 4) + 0x18, + cachey: ((b & 0x2) * 2) + 0x12, + b: (b + 0x14)) + b += 1 + } + } else if (this.mb_dc_nz & 0xF0_0000) <> 0 { + b = 0 + while b < 4 { + this.inverse_dct_dc_only!( + cachex: ((b & 0x1) * 4) + 0x18, + cachey: ((b & 0x2) * 2) + 0x12, + b: (b + 0x14)) + b += 1 + } + } } pri func decoder.substitute_dc_top_left( diff --git a/std/vp8/decode_vp8.wuffs b/std/vp8/decode_vp8.wuffs index a374bb36..4faaa964 100644 --- a/std/vp8/decode_vp8.wuffs +++ b/std/vp8/decode_vp8.wuffs @@ -100,6 +100,17 @@ pub struct decoder? implements base.image_decoder( mb_subblock_modes : array[16] base.u8[..= 9], + // Two u32 values whose bits are packed like this: + // + // - 24 ..= 31 are unused. + // - 20 ..= 23 are chroma (V) HZNC bits. + // - 16 ..= 19 are chroma (U) HZNC bits. + // - 0 ..= 15 are luma (Y) HNZC bits. + // + // HNZC stands for has-non-zero-coefficients. + mb_dc_nz : base.u32, + mb_ac_nz : base.u32, + yuv_cache : array[26] array[32] base.u8, dst_x : base.u32, diff --git a/test/c/std/vp8.c b/test/c/std/vp8.c index bcd3a4f1..f18ff70e 100644 --- a/test/c/std/vp8.c +++ b/test/c/std/vp8.c @@ -126,6 +126,102 @@ initialize_decoder_test_state(wuffs_vp8__decoder* dec) { dec->private_impl.f_yuv_cache[0x19][0x07] = 0x62; } +const char* // +test_wuffs_vp8_decode_inverse_dct_full() { + CHECK_FOCUS(__func__); + + wuffs_vp8__decoder dec = {0}; + + // Initialize the coefficients to the digits of phi. + + dec.private_data.f_mb_coeffs[0][0x00] = 0x16; + dec.private_data.f_mb_coeffs[0][0x01] = 0x18; + dec.private_data.f_mb_coeffs[0][0x02] = 0x03; + dec.private_data.f_mb_coeffs[0][0x03] = 0x39; + dec.private_data.f_mb_coeffs[0][0x04] = 0x88; + dec.private_data.f_mb_coeffs[0][0x05] = 0x74; + dec.private_data.f_mb_coeffs[0][0x06] = 0x98; + dec.private_data.f_mb_coeffs[0][0x07] = 0x94; + dec.private_data.f_mb_coeffs[0][0x08] = 0x84; + dec.private_data.f_mb_coeffs[0][0x09] = 0x82; + dec.private_data.f_mb_coeffs[0][0x0A] = 0x04; + dec.private_data.f_mb_coeffs[0][0x0B] = 0x58; + dec.private_data.f_mb_coeffs[0][0x0C] = 0x68; + dec.private_data.f_mb_coeffs[0][0x0D] = 0x43; + dec.private_data.f_mb_coeffs[0][0x0E] = 0x36; + dec.private_data.f_mb_coeffs[0][0x0F] = 0x56; + + memset(dec.private_impl.f_yuv_cache, 0xC0, + sizeof(dec.private_impl.f_yuv_cache)); + + const uint32_t w0 = 0xFFACFBBC; + const uint32_t w1 = 0x92ABA8C6; + const uint32_t w2 = 0xABB6C1C6; + const uint32_t w3 = 0x8FDFC5A7; + + wuffs_vp8__decoder__inverse_dct_full(&dec, 8, 1, 0); + + uint32_t h0 = wuffs_base__peek_u32be__no_bounds_check( + &dec.private_impl.f_yuv_cache[1][8]); + uint32_t h1 = wuffs_base__peek_u32be__no_bounds_check( + &dec.private_impl.f_yuv_cache[2][8]); + uint32_t h2 = wuffs_base__peek_u32be__no_bounds_check( + &dec.private_impl.f_yuv_cache[3][8]); + uint32_t h3 = wuffs_base__peek_u32be__no_bounds_check( + &dec.private_impl.f_yuv_cache[4][8]); + + if ((h0 != w0) || (h1 != w1) || (h2 != w2) || (h3 != w3)) { + RETURN_FAIL( + "\nhave %08" PRIX32 " %08" PRIX32 " %08" PRIX32 " %08" PRIX32 // + "\nwant %08" PRIX32 " %08" PRIX32 " %08" PRIX32 " %08" PRIX32, // + h0, h1, h2, h3, w0, w1, w2, w3); + } + return NULL; +} + +const char* // +test_wuffs_vp8_decode_inverse_wht() { + CHECK_FOCUS(__func__); + + wuffs_vp8__decoder dec = {0}; + + // Initialize the coefficients to the digits of phi. + + dec.private_data.f_mb_coeffs[24][0x00] = 0x16; + dec.private_data.f_mb_coeffs[24][0x01] = 0x18; + dec.private_data.f_mb_coeffs[24][0x02] = 0x03; + dec.private_data.f_mb_coeffs[24][0x03] = 0x39; + dec.private_data.f_mb_coeffs[24][0x04] = 0x88; + dec.private_data.f_mb_coeffs[24][0x05] = 0x74; + dec.private_data.f_mb_coeffs[24][0x06] = 0x98; + dec.private_data.f_mb_coeffs[24][0x07] = 0x94; + dec.private_data.f_mb_coeffs[24][0x08] = 0x84; + dec.private_data.f_mb_coeffs[24][0x09] = 0x82; + dec.private_data.f_mb_coeffs[24][0x0A] = 0x04; + dec.private_data.f_mb_coeffs[24][0x0B] = 0x58; + dec.private_data.f_mb_coeffs[24][0x0C] = 0x68; + dec.private_data.f_mb_coeffs[24][0x0D] = 0x43; + dec.private_data.f_mb_coeffs[24][0x0E] = 0x36; + dec.private_data.f_mb_coeffs[24][0x0F] = 0x56; + + const uint32_t wants[16] = { + 0x00A5, 0x0011, 0x001C, 0xFFF2, 0xFFFF, 0xFFDF, 0xFFF5, 0x0006, + 0xFFC3, 0xFFF3, 0x0002, 0x0001, 0xFFCE, 0x0016, 0x0007, 0xFFEB, + }; + + wuffs_vp8__decoder__inverse_wht(&dec); + + for (int b = 0; b < 16; b++) { + uint16_t have = dec.private_data.f_mb_coeffs[b][0]; + uint16_t want = wants[b]; + if (have != want) { + RETURN_FAIL("b=0x%02X: have 0x%04X, want 0x%04X", b, have, want); + } + } + + return NULL; +} + const char* // test_wuffs_vp8_decode_predict_uv8() { CHECK_FOCUS(__func__); @@ -380,6 +476,8 @@ test_wuffs_vp8_decode_predict_y4() { proc g_tests[] = { + test_wuffs_vp8_decode_inverse_dct_full, + test_wuffs_vp8_decode_inverse_wht, test_wuffs_vp8_decode_predict_uv8, test_wuffs_vp8_decode_predict_y16, test_wuffs_vp8_decode_predict_y4,