mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 08:38:14 +01:00
std/vp8: implement loop filters
This commit, part of a series, is inspired by pull request PR #168 by Damian Kaczmarek (with AI assistance), with some modifications. Updates PR #168
This commit is contained in:
1 parent
487922dab4
commit
7b69762670
5 files changed
+1385
-11
No files matched your search
@@ -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();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,554 @@
|
||||
// Copyright 2026 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
// --------
|
||||
|
||||
// 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
|
||||
}
|
||||
@@ -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)]
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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 {
|
||||
|
||||
Reference in new issue
Block a user