diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index ee0c46a2..912a4fad 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -15529,6 +15529,7 @@ struct wuffs_vp8__decoder__struct { uint32_t f_quant_y2ac_delta; uint32_t f_quant_uvdc_delta; uint32_t f_quant_uvac_delta; + uint32_t f_loop_filters[8]; uint16_t f_dequants[4][3][2]; uint32_t f_prob_skip; uint8_t f_mb_subblock_modes[16]; @@ -15553,6 +15554,7 @@ struct wuffs_vp8__decoder__struct { uint16_t f_mb_coeffs[25][16]; uint32_t f_mb_states_left; uint32_t f_mb_states_top[1024]; + uint8_t f_mb_filters[2][1024]; struct { uint64_t v_i; @@ -81852,6 +81854,67 @@ wuffs_vp8__decoder__decode_large_value( uint32_t a_part, uint32_t a_prob_base); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_simple( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mby); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_normal( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mby); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_2( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint64_t a_w, + uint32_t a_filter_bits, + uint32_t a_i_step, + uint32_t a_j_step); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_246( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint64_t a_w, + uint32_t a_filter_bits, + uint32_t a_i_step, + uint32_t a_j_step, + uint32_t a_n, + bool a_inner); + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__abs_diff( + const wuffs_vp8__decoder* self, + uint32_t a_a, + uint32_t a_b); + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__clip_m16_p15( + const wuffs_vp8__decoder* self, + uint32_t a_a); + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__clip_m128_p127( + const wuffs_vp8__decoder* self, + uint32_t a_a); + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_vp8__decoder__clip_255_u8( + const wuffs_vp8__decoder* self, + uint32_t a_a); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_vp8__decoder__copy_partitions_to_workbuf( @@ -81883,6 +81946,11 @@ wuffs_vp8__decoder__decode_coeff_probs( wuffs_vp8__decoder* self, wuffs_base__slice_u8 a_workbuf); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__calculate_loop_filters( + wuffs_vp8__decoder* self); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__empty_struct wuffs_vp8__decoder__calculate_dequants( @@ -82498,6 +82566,542 @@ wuffs_vp8__decoder__decode_large_value( return ((v_value & 2047u) + (((uint32_t)(8u)) << v_category) + 3u); } +// -------- func vp8.decoder.filter_simple + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_simple( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mby) { + uint32_t v_mbx = 0; + uint32_t v_filter_index = 0; + uint32_t v_filter_bits = 0; + uint64_t v_wy = 0; + + v_mbx = 0u; + while (v_mbx < self->private_impl.f_mbw) { + v_filter_index = ((uint32_t)(self->private_data.f_mb_filters[(a_mby & 1u)][v_mbx])); + v_filter_bits = self->private_impl.f_loop_filters[(v_filter_index & 7u)]; + if (v_filter_bits == 0u) { + v_mbx += 1u; + continue; + } + v_filter_bits |= ((v_filter_index & 8u) << 28u); + v_wy = ((uint64_t)((((a_mby * self->private_impl.f_workbuf_yuv_y_stride) + v_mbx) * 16u))); + if (v_mbx > 0u) { + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + v_wy, + ((uint32_t)(v_filter_bits + 4u)), + self->private_impl.f_workbuf_yuv_y_stride, + 1u); + } + if (v_filter_bits >= 2147483648u) { + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + (v_wy + 4u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_y_stride, + 1u); + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + (v_wy + 8u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_y_stride, + 1u); + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + (v_wy + 12u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_y_stride, + 1u); + } + if (a_mby > 0u) { + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + v_wy, + ((uint32_t)(v_filter_bits + 4u)), + 1u, + self->private_impl.f_workbuf_yuv_y_stride); + } + if (v_filter_bits >= 2147483648u) { + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + (v_wy + ((uint64_t)((4u * self->private_impl.f_workbuf_yuv_y_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_y_stride); + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + (v_wy + ((uint64_t)((8u * self->private_impl.f_workbuf_yuv_y_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_y_stride); + wuffs_vp8__decoder__filter_2(self, + a_workbuf, + (v_wy + ((uint64_t)((12u * self->private_impl.f_workbuf_yuv_y_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_y_stride); + } + v_mbx += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.filter_normal + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_normal( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mby) { + uint32_t v_mbx = 0; + uint32_t v_filter_index = 0; + uint32_t v_filter_bits = 0; + uint64_t v_wy = 0; + uint64_t v_wu = 0; + uint64_t v_wv = 0; + + v_mbx = 0u; + while (v_mbx < self->private_impl.f_mbw) { + v_filter_index = ((uint32_t)(self->private_data.f_mb_filters[(a_mby & 1u)][v_mbx])); + v_filter_bits = self->private_impl.f_loop_filters[(v_filter_index & 7u)]; + if (v_filter_bits == 0u) { + v_mbx += 1u; + continue; + } + v_filter_bits |= ((v_filter_index & 8u) << 28u); + v_wy = ((uint64_t)((((a_mby * self->private_impl.f_workbuf_yuv_y_stride) + v_mbx) * 16u))); + v_wu = (((uint64_t)((((a_mby * self->private_impl.f_workbuf_yuv_uv_stride) + v_mbx) * 8u))) + self->private_impl.f_workbuf_yuv_y_end); + v_wv = (((uint64_t)((((a_mby * self->private_impl.f_workbuf_yuv_uv_stride) + v_mbx) * 8u))) + self->private_impl.f_workbuf_yuv_u_end); + if (v_mbx > 0u) { + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + v_wy, + ((uint32_t)(v_filter_bits + 4u)), + self->private_impl.f_workbuf_yuv_y_stride, + 1u, + 16u, + false); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + v_wu, + ((uint32_t)(v_filter_bits + 4u)), + self->private_impl.f_workbuf_yuv_uv_stride, + 1u, + 8u, + false); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + v_wv, + ((uint32_t)(v_filter_bits + 4u)), + self->private_impl.f_workbuf_yuv_uv_stride, + 1u, + 8u, + false); + } + if (v_filter_bits >= 2147483648u) { + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wy + 4u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_y_stride, + 1u, + 16u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wy + 8u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_y_stride, + 1u, + 16u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wy + 12u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_y_stride, + 1u, + 16u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wu + 4u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_uv_stride, + 1u, + 8u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wv + 4u), + v_filter_bits, + self->private_impl.f_workbuf_yuv_uv_stride, + 1u, + 8u, + true); + } + if (a_mby > 0u) { + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + v_wy, + ((uint32_t)(v_filter_bits + 4u)), + 1u, + self->private_impl.f_workbuf_yuv_y_stride, + 16u, + false); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + v_wu, + ((uint32_t)(v_filter_bits + 4u)), + 1u, + self->private_impl.f_workbuf_yuv_uv_stride, + 8u, + false); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + v_wv, + ((uint32_t)(v_filter_bits + 4u)), + 1u, + self->private_impl.f_workbuf_yuv_uv_stride, + 8u, + false); + } + if (v_filter_bits >= 2147483648u) { + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wy + ((uint64_t)((4u * self->private_impl.f_workbuf_yuv_y_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_y_stride, + 16u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wy + ((uint64_t)((8u * self->private_impl.f_workbuf_yuv_y_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_y_stride, + 16u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wy + ((uint64_t)((12u * self->private_impl.f_workbuf_yuv_y_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_y_stride, + 16u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wu + ((uint64_t)((4u * self->private_impl.f_workbuf_yuv_uv_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_uv_stride, + 8u, + true); + wuffs_vp8__decoder__filter_246(self, + a_workbuf, + (v_wv + ((uint64_t)((4u * self->private_impl.f_workbuf_yuv_uv_stride)))), + v_filter_bits, + 1u, + self->private_impl.f_workbuf_yuv_uv_stride, + 8u, + true); + } + v_mbx += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.filter_2 + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_2( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint64_t a_w, + uint32_t a_filter_bits, + uint32_t a_i_step, + uint32_t a_j_step) { + uint32_t v_n = 0; + uint32_t v_level = 0; + uint64_t v_o = 0; + uint32_t v_p1 = 0; + uint32_t v_p0 = 0; + uint32_t v_q0 = 0; + uint32_t v_q1 = 0; + uint32_t v_d0 = 0; + uint32_t v_d1 = 0; + uint32_t v_a = 0; + uint32_t v_a1 = 0; + uint32_t v_a2 = 0; + + v_level = (a_filter_bits & 255u); + v_n = 16u; + while (v_n > 0u) { + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 2u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_p1 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_p0 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 0u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_q0 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_q1 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + do { + v_d0 = wuffs_vp8__decoder__abs_diff(self, v_p0, v_q0); + v_d1 = wuffs_vp8__decoder__abs_diff(self, v_p1, v_q1); + if (((uint32_t)(((uint32_t)(v_d0 << 1u)) + (v_d1 >> 1u))) > v_level) { + break; + } + v_a = ((uint32_t)(((uint32_t)(3u * ((uint32_t)(v_q0 - v_p0)))) + wuffs_vp8__decoder__clip_m128_p127(self, ((uint32_t)(v_p1 - v_q1))))); + v_a1 = wuffs_vp8__decoder__clip_m16_p15(self, wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a + 4u)), 3u)); + v_a2 = wuffs_vp8__decoder__clip_m16_p15(self, wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a + 3u)), 3u)); + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_p0 + v_a2))); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 0u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_q0 - v_a1))); + } + } while (0); + a_w += ((uint64_t)(a_i_step)); + v_n -= 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.filter_246 + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__filter_246( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint64_t a_w, + uint32_t a_filter_bits, + uint32_t a_i_step, + uint32_t a_j_step, + uint32_t a_n, + bool a_inner) { + uint32_t v_level = 0; + uint32_t v_ilevel = 0; + uint32_t v_hlevel = 0; + uint64_t v_o = 0; + uint32_t v_p3 = 0; + uint32_t v_p2 = 0; + uint32_t v_p1 = 0; + uint32_t v_p0 = 0; + uint32_t v_q0 = 0; + uint32_t v_q1 = 0; + uint32_t v_q2 = 0; + uint32_t v_q3 = 0; + uint32_t v_d0 = 0; + uint32_t v_d1 = 0; + uint32_t v_a = 0; + uint32_t v_a1 = 0; + uint32_t v_a2 = 0; + uint32_t v_a3 = 0; + + v_level = (a_filter_bits & 255u); + v_ilevel = ((a_filter_bits >> 8u) & 255u); + v_hlevel = ((a_filter_bits >> 16u) & 255u); + while (a_n > 0u) { + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 4u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_p3 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 3u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_p2 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 2u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_p1 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_p0 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 0u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_q0 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_q1 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 2u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_q2 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 3u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + v_q3 = ((uint32_t)(a_workbuf.ptr[v_o])); + } + do { + v_d0 = wuffs_vp8__decoder__abs_diff(self, v_p0, v_q0); + v_d1 = wuffs_vp8__decoder__abs_diff(self, v_p1, v_q1); + if (((uint32_t)(((uint32_t)(v_d0 << 1u)) + (v_d1 >> 1u))) > v_level) { + break; + } + v_d0 = wuffs_vp8__decoder__abs_diff(self, v_p1, v_p0); + v_d1 = wuffs_vp8__decoder__abs_diff(self, v_q0, v_q1); + if ((v_d0 > v_ilevel) || + (v_d1 > v_ilevel) || + (wuffs_vp8__decoder__abs_diff(self, v_p3, v_p2) > v_ilevel) || + (wuffs_vp8__decoder__abs_diff(self, v_p2, v_p1) > v_ilevel) || + (wuffs_vp8__decoder__abs_diff(self, v_q1, v_q2) > v_ilevel) || + (wuffs_vp8__decoder__abs_diff(self, v_q2, v_q3) > v_ilevel)) { + break; + } + if ((v_d0 > v_hlevel) || (v_d1 > v_hlevel)) { + v_a = ((uint32_t)(((uint32_t)(3u * ((uint32_t)(v_q0 - v_p0)))) + wuffs_vp8__decoder__clip_m128_p127(self, ((uint32_t)(v_p1 - v_q1))))); + v_a1 = wuffs_vp8__decoder__clip_m16_p15(self, wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a + 4u)), 3u)); + v_a2 = wuffs_vp8__decoder__clip_m16_p15(self, wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a + 3u)), 3u)); + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_p0 + v_a2))); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 0u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_q0 - v_a1))); + } + } else if (a_inner) { + v_a = ((uint32_t)(3u * ((uint32_t)(v_q0 - v_p0)))); + v_a1 = wuffs_vp8__decoder__clip_m16_p15(self, wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a + 4u)), 3u)); + v_a2 = wuffs_vp8__decoder__clip_m16_p15(self, wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a + 3u)), 3u)); + v_a3 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_a1 + 1u)), 1u); + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 2u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_p1 + v_a3))); + } + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_p0 + v_a2))); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 0u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_q0 - v_a1))); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_q1 - v_a3))); + } + } else { + v_a = ((uint32_t)(((uint32_t)(3u * ((uint32_t)(v_q0 - v_p0)))) + wuffs_vp8__decoder__clip_m128_p127(self, ((uint32_t)(v_p1 - v_q1))))); + v_a = wuffs_vp8__decoder__clip_m128_p127(self, v_a); + v_a1 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(((uint32_t)(v_a * 27u)) + 63u)), 7u); + v_a2 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(((uint32_t)(v_a * 18u)) + 63u)), 7u); + v_a3 = wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(((uint32_t)(v_a * 9u)) + 63u)), 7u); + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 3u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_p2 + v_a3))); + } + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 2u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_p1 + v_a2))); + } + v_o = ((uint64_t)(a_w - ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_p0 + v_a1))); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 0u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_q0 - v_a1))); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 1u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_q1 - v_a2))); + } + v_o = ((uint64_t)(a_w + ((uint64_t)(((uint64_t)(a_j_step)) * 2u)))); + if (v_o < ((uint64_t)(a_workbuf.len))) { + a_workbuf.ptr[v_o] = wuffs_vp8__decoder__clip_255_u8(self, ((uint32_t)(v_q2 - v_a3))); + } + } + } while (0); + a_w += ((uint64_t)(a_i_step)); + a_n -= 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.abs_diff + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__abs_diff( + const wuffs_vp8__decoder* self, + uint32_t a_a, + uint32_t a_b) { + uint32_t v_c = 0; + + v_c = ((uint32_t)(a_a - a_b)); + if (v_c < 2147483648u) { + return v_c; + } + return ((uint32_t)(0u - v_c)); +} + +// -------- func vp8.decoder.clip_m16_p15 + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__clip_m16_p15( + const wuffs_vp8__decoder* self, + uint32_t a_a) { + if (((uint32_t)(a_a + 16u)) <= 32u) { + return a_a; + } else if (a_a < 2147483648u) { + return 15u; + } + return 4294967280u; +} + +// -------- func vp8.decoder.clip_m128_p127 + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__clip_m128_p127( + const wuffs_vp8__decoder* self, + uint32_t a_a) { + if (((uint32_t)(a_a + 128u)) <= 255u) { + return a_a; + } else if (a_a < 2147483648u) { + return 127u; + } + return 4294967168u; +} + +// -------- func vp8.decoder.clip_255_u8 + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_vp8__decoder__clip_255_u8( + const wuffs_vp8__decoder* self, + uint32_t a_a) { + if (a_a <= 255u) { + return ((uint8_t)(a_a)); + } else if (a_a < 2147483648u) { + return 255u; + } + return 0u; +} + // -------- func vp8.decoder.copy_partitions_to_workbuf WUFFS_BASE__GENERATED_C_CODE @@ -82592,6 +83196,7 @@ wuffs_vp8__decoder__decode_first_partition( } wuffs_vp8__decoder__decode_segment_header(self, a_workbuf); wuffs_vp8__decoder__decode_filter_header(self, a_workbuf); + wuffs_vp8__decoder__calculate_loop_filters(self); v_v32 = wuffs_vp8__decoder__read_unsigned(self, a_workbuf, 0u, 2u); self->private_impl.f_num_other_partitions_m1 = ((((uint32_t)(1u)) << (v_v32 & 3u)) - 1u); v_v32 = wuffs_vp8__decoder__read_unsigned(self, a_workbuf, 0u, 7u); @@ -82731,6 +83336,73 @@ wuffs_vp8__decoder__decode_coeff_probs( return wuffs_base__make_empty_struct(); } +// -------- func vp8.decoder.calculate_loop_filters + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__calculate_loop_filters( + wuffs_vp8__decoder* self) { + uint32_t v_seg = 0; + uint32_t v_inner = 0; + uint32_t v_level = 0; + uint32_t v_ilevel = 0; + uint32_t v_hlevel = 0; + + v_seg = 0u; + while (v_seg < 4u) { + v_inner = 0u; + while (v_inner < 2u) { + v_level = ((uint32_t)(self->private_impl.f_filt_level)); + if ( ! self->private_impl.f_seg_enabled) { + } else if ( ! self->private_impl.f_filt_deltas_enabled) { + v_level = wuffs_base__utility__sign_extend_convert_u8_u32(self->private_impl.f_seg_strengths[v_seg]); + } else { + v_level = ((uint32_t)(((uint32_t)(v_level)) + wuffs_base__utility__sign_extend_convert_u8_u32(self->private_impl.f_seg_strengths[v_seg]))); + } + if (self->private_impl.f_filt_deltas_enabled) { + v_level = ((uint32_t)(((uint32_t)(v_level)) + wuffs_base__utility__sign_extend_convert_u8_u32(self->private_impl.f_filt_deltas[0u][0u]))); + if (v_inner != 0u) { + v_level = ((uint32_t)(((uint32_t)(v_level)) + wuffs_base__utility__sign_extend_convert_u8_u32(self->private_impl.f_filt_deltas[1u][0u]))); + } + } + if (v_level >= 2147483648u) { + self->private_impl.f_loop_filters[((2u * v_seg) + v_inner)] = 0u; + v_inner += 1u; + continue; + } else if (v_level > 63u) { + v_level = 63u; + } + v_ilevel = v_level; + if (self->private_impl.f_filt_sharpness > 0u) { + if (self->private_impl.f_filt_sharpness <= 4u) { + v_ilevel >>= 1u; + } else { + v_ilevel >>= 2u; + } + v_ilevel = wuffs_base__u32__max(v_ilevel, ((uint32_t)(((uint8_t)(9u - self->private_impl.f_filt_sharpness))))); + } + if ((v_ilevel < 1u) || (2147483648u <= v_ilevel)) { + v_ilevel = 1u; + } + if (v_level < 15u) { + v_hlevel = 0u; + } else if (v_level < 40u) { + v_hlevel = 1u; + } else { + v_hlevel = 2u; + } + v_level = ((uint32_t)(((uint32_t)(2u * v_level)) + v_ilevel)); + self->private_impl.f_loop_filters[((2u * v_seg) + v_inner)] = (v_level | + ((uint32_t)(v_ilevel << 8u)) | + ((uint32_t)(v_hlevel << 16u)) | + (v_inner << 31u)); + v_inner += 1u; + } + v_seg += 1u; + } + return wuffs_base__make_empty_struct(); +} + // -------- func vp8.decoder.calculate_dequants WUFFS_BASE__GENERATED_C_CODE @@ -83232,8 +83904,20 @@ wuffs_vp8__decoder__decode_macroblocks( wuffs_vp8__decoder__decode_one_macroblock(self, a_workbuf, v_mbx, v_mby); v_mbx += 1u; } + if ((v_mby <= 0u) || (self->private_impl.f_filt_level <= 0u)) { + } else if (self->private_impl.f_filt_simple) { + wuffs_vp8__decoder__filter_simple(self, a_workbuf, (v_mby - 1u)); + } else { + wuffs_vp8__decoder__filter_normal(self, a_workbuf, (v_mby - 1u)); + } v_mby += 1u; } + if ((self->private_impl.f_mbh <= 0u) || (self->private_impl.f_filt_level <= 0u)) { + } else if (self->private_impl.f_filt_simple) { + wuffs_vp8__decoder__filter_simple(self, a_workbuf, (self->private_impl.f_mbh - 1u)); + } else { + wuffs_vp8__decoder__filter_normal(self, a_workbuf, (self->private_impl.f_mbh - 1u)); + } return wuffs_base__make_status(NULL); } @@ -83248,7 +83932,7 @@ wuffs_vp8__decoder__decode_one_macroblock( uint32_t a_mby) { uint32_t v_v1 = 0; uint32_t v_seg = 0; - bool v_skip = false; + uint32_t v_skip = 0; uint32_t v_luma_mode = 0; uint32_t v_chroma_mode = 0; @@ -83263,15 +83947,14 @@ wuffs_vp8__decoder__decode_one_macroblock( v_seg = (v_v1 + 2u); } } - v_skip = false; + v_skip = 0u; if ((self->private_impl.f_prob_skip & 256u) != 0u) { - v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, (self->private_impl.f_prob_skip & 255u)); - v_skip = (v_v1 != 0u); + v_skip = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, (self->private_impl.f_prob_skip & 255u)); } v_luma_mode = wuffs_vp8__decoder__decode_luma_mode(self, a_workbuf); wuffs_vp8__decoder__decode_subblock_modes(self, a_workbuf, a_mbx, v_luma_mode); v_chroma_mode = wuffs_vp8__decoder__decode_chroma_mode(self, a_workbuf); - if (v_skip) { + if (v_skip != 0u) { 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; @@ -83291,6 +83974,7 @@ wuffs_vp8__decoder__decode_one_macroblock( v_luma_mode, v_chroma_mode); wuffs_vp8__decoder__copy_from_yuv_cache(self, a_workbuf, a_mbx, a_mby); + self->private_data.f_mb_filters[(a_mby & 1u)][a_mbx] = ((uint8_t)((((1u ^ v_skip) << 3u) | (v_seg << 1u) | (v_luma_mode >> 2u)))); return wuffs_base__make_empty_struct(); } diff --git a/std/vp8/decode_filter_default.wuffs b/std/vp8/decode_filter_default.wuffs new file mode 100644 index 00000000..c7de7f8a --- /dev/null +++ b/std/vp8/decode_filter_default.wuffs @@ -0,0 +1,554 @@ +// 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 + +// -------- + +// RFC 6386 Section 15.2 Simple Filter. +pri func decoder.filter_simple!(workbuf: slice base.u8, mby: base.u32[..= 0x3FF]) { + var mbx : base.u32 + var filter_index : base.u32 + var filter_bits : base.u32 + var wy : base.u64 + + mbx = 0 + while mbx < this.mbw { + assert mbx < 0x400 via "a < b: a < c; c <= b"(c: this.mbw) + + filter_index = this.mb_filters[args.mby & 1][mbx] as base.u32 + filter_bits = this.loop_filters[filter_index & 7] + if filter_bits == 0 { + mbx += 1 + continue + } + // "decode_one_macroblock's (not skip)" also triggers inner filters. + filter_bits |= (filter_index & 8) << 28 + + wy = ((((args.mby * this.workbuf_yuv_y_stride) + mbx) * 16) as base.u64) + 0 + + // Inter-filter horizontally, together with the adjacent macroblock. + if mbx > 0 { + this.filter_2!( + workbuf: args.workbuf, + w: wy + 0x0, + filter_bits: filter_bits ~mod+ 4, + i_step: this.workbuf_yuv_y_stride, + j_step: 1) + } + + // Intra-filter (inner) horizontally, within this macroblock. + if filter_bits >= 0x8000_0000 { + this.filter_2!( + workbuf: args.workbuf, + w: wy + 0x4, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_y_stride, + j_step: 1) + this.filter_2!( + workbuf: args.workbuf, + w: wy + 0x8, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_y_stride, + j_step: 1) + this.filter_2!( + workbuf: args.workbuf, + w: wy + 0xC, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_y_stride, + j_step: 1) + } + + // Inter-filter vertically, together with the adjacent macroblock. + if args.mby > 0 { + this.filter_2!( + workbuf: args.workbuf, + w: wy, + filter_bits: filter_bits ~mod+ 4, + i_step: 1, + j_step: this.workbuf_yuv_y_stride) + } + + // Intra-filter (inner) vertically, within this macroblock. + if filter_bits >= 0x8000_0000 { + this.filter_2!( + workbuf: args.workbuf, + w: wy + ((0x4 * this.workbuf_yuv_y_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_y_stride) + this.filter_2!( + workbuf: args.workbuf, + w: wy + ((0x8 * this.workbuf_yuv_y_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_y_stride) + this.filter_2!( + workbuf: args.workbuf, + w: wy + ((0xC * this.workbuf_yuv_y_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_y_stride) + } + + mbx += 1 + } +} + +// RFC 6386 Section 15.3 Normal Filter. +pri func decoder.filter_normal!(workbuf: slice base.u8, mby: base.u32[..= 0x3FF]) { + var mbx : base.u32 + var filter_index : base.u32 + var filter_bits : base.u32 + var wy : base.u64 + var wu : base.u64 + var wv : base.u64 + + mbx = 0 + while mbx < this.mbw { + assert mbx < 0x400 via "a < b: a < c; c <= b"(c: this.mbw) + + filter_index = this.mb_filters[args.mby & 1][mbx] as base.u32 + filter_bits = this.loop_filters[filter_index & 7] + if filter_bits == 0 { + mbx += 1 + continue + } + // "decode_one_macroblock's (not skip)" also triggers inner filters. + filter_bits |= (filter_index & 8) << 28 + + wy = ((((args.mby * this.workbuf_yuv_y_stride) + mbx) * 16) as base.u64) + 0 + wu = ((((args.mby * this.workbuf_yuv_uv_stride) + mbx) * 8) as base.u64) + this.workbuf_yuv_y_end + wv = ((((args.mby * this.workbuf_yuv_uv_stride) + mbx) * 8) as base.u64) + this.workbuf_yuv_u_end + + // Inter-filter horizontally, together with the adjacent macroblock. + if mbx > 0 { + this.filter_246!( + workbuf: args.workbuf, + w: wy + 0x0, + filter_bits: filter_bits ~mod+ 4, + i_step: this.workbuf_yuv_y_stride, + j_step: 1, + n: 16, + inner: false) + this.filter_246!( + workbuf: args.workbuf, + w: wu + 0x0, + filter_bits: filter_bits ~mod+ 4, + i_step: this.workbuf_yuv_uv_stride, + j_step: 1, + n: 8, + inner: false) + this.filter_246!( + workbuf: args.workbuf, + w: wv + 0x0, + filter_bits: filter_bits ~mod+ 4, + i_step: this.workbuf_yuv_uv_stride, + j_step: 1, + n: 8, + inner: false) + } + + // Intra-filter (inner) horizontally, within this macroblock. + if filter_bits >= 0x8000_0000 { + this.filter_246!( + workbuf: args.workbuf, + w: wy + 0x4, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_y_stride, + j_step: 1, + n: 16, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wy + 0x8, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_y_stride, + j_step: 1, + n: 16, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wy + 0xC, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_y_stride, + j_step: 1, + n: 16, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wu + 0x4, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_uv_stride, + j_step: 1, + n: 8, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wv + 0x4, + filter_bits: filter_bits, + i_step: this.workbuf_yuv_uv_stride, + j_step: 1, + n: 8, + inner: true) + } + + // Inter-filter vertically, together with the adjacent macroblock. + if args.mby > 0 { + this.filter_246!( + workbuf: args.workbuf, + w: wy, + filter_bits: filter_bits ~mod+ 4, + i_step: 1, + j_step: this.workbuf_yuv_y_stride, + n: 16, + inner: false) + this.filter_246!( + workbuf: args.workbuf, + w: wu, + filter_bits: filter_bits ~mod+ 4, + i_step: 1, + j_step: this.workbuf_yuv_uv_stride, + n: 8, + inner: false) + this.filter_246!( + workbuf: args.workbuf, + w: wv, + filter_bits: filter_bits ~mod+ 4, + i_step: 1, + j_step: this.workbuf_yuv_uv_stride, + n: 8, + inner: false) + } + + // Intra-filter (inner) vertically, within this macroblock. + if filter_bits >= 0x8000_0000 { + this.filter_246!( + workbuf: args.workbuf, + w: wy + ((0x4 * this.workbuf_yuv_y_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_y_stride, + n: 16, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wy + ((0x8 * this.workbuf_yuv_y_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_y_stride, + n: 16, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wy + ((0xC * this.workbuf_yuv_y_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_y_stride, + n: 16, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wu + ((0x4 * this.workbuf_yuv_uv_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_uv_stride, + n: 8, + inner: true) + this.filter_246!( + workbuf: args.workbuf, + w: wv + ((0x4 * this.workbuf_yuv_uv_stride) as base.u64), + filter_bits: filter_bits, + i_step: 1, + j_step: this.workbuf_yuv_uv_stride, + n: 8, + inner: true) + } + + mbx += 1 + } +} + +pri func decoder.filter_2!( + workbuf: slice base.u8, + w: base.u64, + filter_bits: base.u32, + i_step: base.u32, + j_step: base.u32) { + var n : base.u32 + + var level : base.u32 + + var o : base.u64 + var p1 : base.u32 + var p0 : base.u32 + var q0 : base.u32 + var q1 : base.u32 + + var d0 : base.u32 + var d1 : base.u32 + + var a : base.u32 + var a1 : base.u32 + var a2 : base.u32 + + level = (args.filter_bits >> 0x00) & 0xFF + + n = 16 + while n > 0 { + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 2) + if o < args.workbuf.length() { + p1 = args.workbuf[o] as base.u32 + } + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + p0 = args.workbuf[o] as base.u32 + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 0) + if o < args.workbuf.length() { + q0 = args.workbuf[o] as base.u32 + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + q1 = args.workbuf[o] as base.u32 + } + + while.goto_increment_and_continue true, + inv n > 0, + {{ + + d0 = this.abs_diff(a: p0, b: q0) + d1 = this.abs_diff(a: p1, b: q1) + if ((d0 ~mod<< 1) ~mod+ (d1 >> 1)) > level { + break.goto_increment_and_continue + } + + a = (3 ~mod* (q0 ~mod- p0)) ~mod+ this.clip_m128_p127(a: p1 ~mod- q1) + a1 = this.clip_m16_p15(a: this.util.sign_extend_rshift_u32(a: a ~mod+ 4, n: 3)) + a2 = this.clip_m16_p15(a: this.util.sign_extend_rshift_u32(a: a ~mod+ 3, n: 3)) + + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: p0 ~mod+ a2) + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 0) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: q0 ~mod- a1) + } + + break.goto_increment_and_continue + }}.goto_increment_and_continue + + args.w ~mod+= args.i_step as base.u64 + n -= 1 + } +} + +pri func decoder.filter_246!( + workbuf: slice base.u8, + w: base.u64, + filter_bits: base.u32, + i_step: base.u32, + j_step: base.u32, + n: base.u32, + inner: base.bool) { + var level : base.u32 + var ilevel : base.u32 + var hlevel : base.u32 + + var o : base.u64 + var p3 : base.u32 + var p2 : base.u32 + var p1 : base.u32 + var p0 : base.u32 + var q0 : base.u32 + var q1 : base.u32 + var q2 : base.u32 + var q3 : base.u32 + + var d0 : base.u32 + var d1 : base.u32 + + var a : base.u32 + var a1 : base.u32 + var a2 : base.u32 + var a3 : base.u32 + + level = (args.filter_bits >> 0x00) & 0xFF + ilevel = (args.filter_bits >> 0x08) & 0xFF + hlevel = (args.filter_bits >> 0x10) & 0xFF + + while args.n > 0 { + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 4) + if o < args.workbuf.length() { + p3 = args.workbuf[o] as base.u32 + } + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 3) + if o < args.workbuf.length() { + p2 = args.workbuf[o] as base.u32 + } + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 2) + if o < args.workbuf.length() { + p1 = args.workbuf[o] as base.u32 + } + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + p0 = args.workbuf[o] as base.u32 + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 0) + if o < args.workbuf.length() { + q0 = args.workbuf[o] as base.u32 + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + q1 = args.workbuf[o] as base.u32 + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 2) + if o < args.workbuf.length() { + q2 = args.workbuf[o] as base.u32 + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 3) + if o < args.workbuf.length() { + q3 = args.workbuf[o] as base.u32 + } + + while.goto_increment_and_continue true, + inv args.n > 0, + {{ + + d0 = this.abs_diff(a: p0, b: q0) + d1 = this.abs_diff(a: p1, b: q1) + if ((d0 ~mod<< 1) ~mod+ (d1 >> 1)) > level { + break.goto_increment_and_continue + } + + d0 = this.abs_diff(a: p1, b: p0) + d1 = this.abs_diff(a: q0, b: q1) + if (d0 > ilevel) or (d1 > ilevel) or + (this.abs_diff(a: p3, b: p2) > ilevel) or + (this.abs_diff(a: p2, b: p1) > ilevel) or + (this.abs_diff(a: q1, b: q2) > ilevel) or + (this.abs_diff(a: q2, b: q3) > ilevel) { + break.goto_increment_and_continue + } + + if (d0 > hlevel) or (d1 > hlevel) { + a = (3 ~mod* (q0 ~mod- p0)) ~mod+ this.clip_m128_p127(a: p1 ~mod- q1) + a1 = this.clip_m16_p15(a: this.util.sign_extend_rshift_u32(a: a ~mod+ 4, n: 3)) + a2 = this.clip_m16_p15(a: this.util.sign_extend_rshift_u32(a: a ~mod+ 3, n: 3)) + + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: p0 ~mod+ a2) + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 0) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: q0 ~mod- a1) + } + + } else if args.inner { + a = 3 ~mod* (q0 ~mod- p0) + a1 = this.clip_m16_p15(a: this.util.sign_extend_rshift_u32(a: a ~mod+ 4, n: 3)) + a2 = this.clip_m16_p15(a: this.util.sign_extend_rshift_u32(a: a ~mod+ 3, n: 3)) + a3 = this.util.sign_extend_rshift_u32(a: a1 ~mod+ 1, n: 1) + + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 2) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: p1 ~mod+ a3) + } + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: p0 ~mod+ a2) + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 0) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: q0 ~mod- a1) + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: q1 ~mod- a3) + } + + } else { + a = (3 ~mod* (q0 ~mod- p0)) ~mod+ this.clip_m128_p127(a: p1 ~mod- q1) + a = this.clip_m128_p127(a: a) + a1 = this.util.sign_extend_rshift_u32(a: (a ~mod* 0x1B) ~mod+ 63, n: 7) + a2 = this.util.sign_extend_rshift_u32(a: (a ~mod* 0x12) ~mod+ 63, n: 7) + a3 = this.util.sign_extend_rshift_u32(a: (a ~mod* 0x09) ~mod+ 63, n: 7) + + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 3) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: p2 ~mod+ a3) + } + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 2) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: p1 ~mod+ a2) + } + o = args.w ~mod- ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: p0 ~mod+ a1) + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 0) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: q0 ~mod- a1) + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 1) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: q1 ~mod- a2) + } + o = args.w ~mod+ ((args.j_step as base.u64) ~mod* 2) + if o < args.workbuf.length() { + args.workbuf[o] = this.clip_255_u8(a: q2 ~mod- a3) + } + } + + break.goto_increment_and_continue + }}.goto_increment_and_continue + + args.w ~mod+= args.i_step as base.u64 + args.n -= 1 + } + +} + +pri func decoder.abs_diff(a: base.u32, b: base.u32) base.u32 { + var c : base.u32 + + c = args.a ~mod- args.b + if c < 0x8000_0000 { + return c + } + return 0 ~mod- c +} + +pri func decoder.clip_m16_p15(a: base.u32) base.u32 { + if (args.a ~mod+ 0x10) <= 0x20 { + return args.a + } else if args.a < 0x8000_0000 { + return 0x0F + } + return 0xFFFF_FFF0 +} + +pri func decoder.clip_m128_p127(a: base.u32) base.u32 { + if (args.a ~mod+ 0x80) <= 0xFF { + return args.a + } else if args.a < 0x8000_0000 { + return 0x7F + } + return 0xFFFF_FF80 +} + +pri func decoder.clip_255_u8(a: base.u32) base.u8 { + if args.a <= 255 { + return args.a as base.u8 + } else if args.a < 0x8000_0000 { + return 255 + } + return 0 +} diff --git a/std/vp8/decode_first_partition.wuffs b/std/vp8/decode_first_partition.wuffs index 6a151961..08a36760 100644 --- a/std/vp8/decode_first_partition.wuffs +++ b/std/vp8/decode_first_partition.wuffs @@ -61,6 +61,7 @@ pri func decoder.decode_first_partition!(workbuf: roslice base.u8) base.status { // RFC 6386 Section 9.4. Loop Filter Type and Levels. this.decode_filter_header!(workbuf: args.workbuf) + this.calculate_loop_filters!() // RFC 6386 Section 9.5. Token Partition and Partition Data Offsets. v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 2) @@ -204,6 +205,84 @@ pri func decoder.decode_coeff_probs!(workbuf: roslice base.u8) { } } +pri func decoder.calculate_loop_filters!() { + var seg : base.u32 + var inner : base.u32 + var level : base.u32 + var ilevel : base.u32 + var hlevel : base.u32 + + seg = 0 + while seg < 4 { + inner = 0 + while inner < 2, + inv seg < 4, + { + level = this.filt_level as base.u32 + if not this.seg_enabled { + // No-op. + } else if not this.filt_deltas_enabled { + level = this.util.sign_extend_convert_u8_u32(a: this.seg_strengths[seg]) + } else { + // The (level as base.u32) is redundant, equivalent to level, but + // avoids a -Werror=sign-conversion false positive with gcc 12.2.0. + level = (level as base.u32) ~mod+ + this.util.sign_extend_convert_u8_u32(a: this.seg_strengths[seg]) + } + + // Yes, filt_deltas[*][0], not filt_deltas[*][seg]. + if this.filt_deltas_enabled { + level = (level as base.u32) ~mod+ + this.util.sign_extend_convert_u8_u32(a: this.filt_deltas[0][0]) + if inner <> 0 { + level = (level as base.u32) ~mod+ + this.util.sign_extend_convert_u8_u32(a: this.filt_deltas[1][0]) + } + } + + if level >= 0x8000_0000 { + this.loop_filters[(2 * seg) + inner] = 0 + inner += 1 + continue + + } else if level > 63 { + level = 63 + } + + ilevel = level + if this.filt_sharpness > 0 { + if this.filt_sharpness <= 4 { + ilevel >>= 1 + } else { + ilevel >>= 2 + } + ilevel = ilevel.max(no_less_than: (9 - this.filt_sharpness) as base.u32) + } + if (ilevel < 1) or (0x8000_0000 <= ilevel) { + ilevel = 1 + } + + // If we ever want to support (this.is_key_frame == false), note + // that the hlevel thresholds are a little different then. + if level < 15 { + hlevel = 0 + } else if level < 40 { + hlevel = 1 + } else { + hlevel = 2 + } + + level = (2 ~mod* level) ~mod+ ilevel + + this.loop_filters[(2 * seg) + inner] = + level | (ilevel ~mod<< 8) | (hlevel ~mod<< 16) | (inner << 31) + + inner += 1 + } + seg += 1 + } +} + pri func decoder.calculate_dequants!() { var seg : base.u32 var q : base.u32 @@ -218,7 +297,8 @@ pri func decoder.calculate_dequants!() { } else { // The (q as base.u32) is redundant, equivalent to q, but avoids a // -Werror=sign-conversion false positive with gcc 12.2.0. - q = (q as base.u32) ~mod+ this.util.sign_extend_convert_u8_u32(a: this.seg_quants[seg]) + q = (q as base.u32) ~mod+ + this.util.sign_extend_convert_u8_u32(a: this.seg_quants[seg]) } this.dequants[seg][0][0] = DEQUANTS[0][this.clip_127(a: q ~mod+ this.quant_ydc_delta)] diff --git a/std/vp8/decode_macroblocks.wuffs b/std/vp8/decode_macroblocks.wuffs index fa719c30..230f3515 100644 --- a/std/vp8/decode_macroblocks.wuffs +++ b/std/vp8/decode_macroblocks.wuffs @@ -38,8 +38,25 @@ pri func decoder.decode_macroblocks!(workbuf: slice base.u8) base.status { mbx += 1 } + if (mby <= 0) or (this.filt_level <= 0) { + // No-op. + } else if this.filt_simple { + this.filter_simple!(workbuf: args.workbuf, mby: mby - 1) + } else { + this.filter_normal!(workbuf: args.workbuf, mby: mby - 1) + } + mby += 1 } + + if (this.mbh <= 0) or (this.filt_level <= 0) { + // No-op. + } else if this.filt_simple { + this.filter_simple!(workbuf: args.workbuf, mby: this.mbh - 1) + } else { + this.filter_normal!(workbuf: args.workbuf, mby: this.mbh - 1) + } + return ok } @@ -47,7 +64,7 @@ pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[.. var v1 : base.u32[..= 1] var seg : base.u32[..= 3] - var skip : base.bool + var skip : base.u32[..= 1] var luma_mode : base.u32[..= 4] var chroma_mode : base.u32[..= 3] @@ -63,10 +80,9 @@ pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[.. } } - skip = false + skip = 0 if (this.prob_skip & 0x100) <> 0 { - v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.prob_skip & 0xFF) - skip = v1 <> 0 + skip = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.prob_skip & 0xFF) } luma_mode = this.decode_luma_mode!(workbuf: args.workbuf) @@ -74,7 +90,7 @@ pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[.. chroma_mode = this.decode_chroma_mode!(workbuf: args.workbuf) - if skip { + if skip <> 0 { // Clear the HNZC bits. this.mb_states_left &= 0x0000_FFFF this.mb_states_top[args.mbx] &= 0x0000_FFFF @@ -93,6 +109,9 @@ pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[.. this.copy_from_yuv_cache!( workbuf: args.workbuf, mbx: args.mbx, mby: args.mby) + + this.mb_filters[args.mby & 1][args.mbx] = + (((1 ^ skip) << 3) | (seg << 1) | (luma_mode >> 2)) as base.u8 } // RFC 6386 Section 11.2. Luma Modes. diff --git a/std/vp8/decode_vp8.wuffs b/std/vp8/decode_vp8.wuffs index 4faaa964..0890e4c2 100644 --- a/std/vp8/decode_vp8.wuffs +++ b/std/vp8/decode_vp8.wuffs @@ -88,6 +88,27 @@ pub struct decoder? implements base.image_decoder( quant_uvdc_delta : base.u32, quant_uvac_delta : base.u32, + // Look-up tables derived from the loop filter parameters. + // + // The array is indexed by ((2 * segment) + inner), where segment is in + // [0 ..= 3] and inner is in [0 ..= 1]. The inner bit is per any of the + // three equivalent conditions below (C is libwebp, Go is + // golang.org/x/image/vp8, Wuffs is this code): + // + // - what C calls "is_i4x4 == false" / "is_i4x4 == true". + // - what Go calls "usePredY16 == true" / "usePredY16 == false". + // - what Wuffs calls "luma_mode < 4" / "luma_mode >= 4". + // + // The u32 bits are packed like this (unless level == 0, in which case + // the high 24 bits are unused and also all-zero): + // + // - 31 is "is_i4x4", also known as "inner". + // - 24 ..= 30 are unused. + // - 16 ..= 23 are hlevel (high edge variance level). + // - 8 ..= 15 are ilevel (inner level). + // - 0 ..= 7 are level. + loop_filters : array[8] base.u32, + // Look-up tables derived from the dequantization parameters. // // The first index is the segment. The second index is Y/Y2/UV. The @@ -140,6 +161,22 @@ pub struct decoder? implements base.image_decoder( // The mb_states_top array is indexed by mbx. mb_states_left : base.u32, mb_states_top : array[0x400] base.u32, + + // Macroblock filter parameters. + // + // The first index is (mby & 1). As we decode rows (and columns) of + // macroblocks, the filter parameters are decoded at the time of the + // R'th row but are applied (to row R) at the time of the (R+1)'th row. + // + // The second index is mbx. + // + // The u8 bits are packed like this: + // + // - 4 ..= 7 are unused + // - 3 is decode_one_macroblock's (not skip). + // - 0 ..= 2 are an index into loop_filters. + // + mb_filters : array[2] array[0x400] base.u8, ) pub func decoder.get_quirk(key: base.u32) base.u64 {