From 3f612e72142130abdbafb1f217812c601a62f3f8 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Mon, 1 Jun 2026 16:07:24 +1000 Subject: [PATCH] std/vp8: parse the prediction modes 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 --- release/c/wuffs-unsupported-snapshot.c | 614 +++++++++++++++++++++++++ std/vp8/common_consts.wuffs | 136 ++++++ std/vp8/decode_macroblocks.wuffs | 252 ++++++++++ std/vp8/decode_vp8.wuffs | 9 + 4 files changed, 1011 insertions(+) create mode 100644 std/vp8/decode_macroblocks.wuffs diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index b915ec3b..6930981b 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -15530,6 +15530,9 @@ struct wuffs_vp8__decoder__struct { uint32_t f_quant_uvdc_delta; uint32_t f_quant_uvac_delta; uint32_t f_prob_skip; + uint8_t f_mb_subblock_modes[16]; + uint8_t f_mb_left_modes[4]; + uint8_t f_mb_top_modes[1024][4]; uint32_t f_dst_x; uint32_t f_dst_y; wuffs_base__pixel_swizzler f_swizzler; @@ -80964,6 +80967,342 @@ WUFFS_VP8__RENORM_RANGE_M1[256] WUFFS_BASE__POTENTIALLY_UNUSED = { 248u, 249u, 250u, 251u, 252u, 253u, 254u, 254u, }; +static const uint8_t +WUFFS_VP8__SUBBLOCK_MODE_PROBS[10][10][9] WUFFS_BASE__POTENTIALLY_UNUSED = { + { + { + 231u, 120u, 48u, 89u, 115u, 113u, 120u, 152u, + 112u, + }, { + 152u, 179u, 64u, 126u, 170u, 118u, 46u, 70u, + 95u, + }, { + 175u, 69u, 143u, 80u, 85u, 82u, 72u, 155u, + 103u, + }, { + 56u, 58u, 10u, 171u, 218u, 189u, 17u, 13u, + 152u, + }, { + 114u, 26u, 17u, 163u, 44u, 195u, 21u, 10u, + 173u, + }, { + 121u, 24u, 80u, 195u, 26u, 62u, 44u, 64u, + 85u, + }, { + 144u, 71u, 10u, 38u, 171u, 213u, 144u, 34u, + 26u, + }, { + 170u, 46u, 55u, 19u, 136u, 160u, 33u, 206u, + 71u, + }, + { + 63u, 20u, 8u, 114u, 114u, 208u, 12u, 9u, + 226u, + }, { + 81u, 40u, 11u, 96u, 182u, 84u, 29u, 16u, + 36u, + }, + }, { + { + 134u, 183u, 89u, 137u, 98u, 101u, 106u, 165u, + 148u, + }, { + 72u, 187u, 100u, 130u, 157u, 111u, 32u, 75u, + 80u, + }, { + 66u, 102u, 167u, 99u, 74u, 62u, 40u, 234u, + 128u, + }, { + 41u, 53u, 9u, 178u, 241u, 141u, 26u, 8u, + 107u, + }, { + 74u, 43u, 26u, 146u, 73u, 166u, 49u, 23u, + 157u, + }, { + 65u, 38u, 105u, 160u, 51u, 52u, 31u, 115u, + 128u, + }, { + 104u, 79u, 12u, 27u, 217u, 255u, 87u, 17u, + 7u, + }, { + 87u, 68u, 71u, 44u, 114u, 51u, 15u, 186u, + 23u, + }, + { + 47u, 41u, 14u, 110u, 182u, 183u, 21u, 17u, + 194u, + }, { + 66u, 45u, 25u, 102u, 197u, 189u, 23u, 18u, + 22u, + }, + }, { + { + 88u, 88u, 147u, 150u, 42u, 46u, 45u, 196u, + 205u, + }, { + 43u, 97u, 183u, 117u, 85u, 38u, 35u, 179u, + 61u, + }, { + 39u, 53u, 200u, 87u, 26u, 21u, 43u, 232u, + 171u, + }, { + 56u, 34u, 51u, 104u, 114u, 102u, 29u, 93u, + 77u, + }, { + 39u, 28u, 85u, 171u, 58u, 165u, 90u, 98u, + 64u, + }, { + 34u, 22u, 116u, 206u, 23u, 34u, 43u, 166u, + 73u, + }, { + 107u, 54u, 32u, 26u, 51u, 1u, 81u, 43u, + 31u, + }, { + 68u, 25u, 106u, 22u, 64u, 171u, 36u, 225u, + 114u, + }, + { + 34u, 19u, 21u, 102u, 132u, 188u, 16u, 76u, + 124u, + }, { + 62u, 18u, 78u, 95u, 85u, 57u, 50u, 48u, + 51u, + }, + }, { + { + 193u, 101u, 35u, 159u, 215u, 111u, 89u, 46u, + 111u, + }, { + 60u, 148u, 31u, 172u, 219u, 228u, 21u, 18u, + 111u, + }, { + 112u, 113u, 77u, 85u, 179u, 255u, 38u, 120u, + 114u, + }, { + 40u, 42u, 1u, 196u, 245u, 209u, 10u, 25u, + 109u, + }, { + 88u, 43u, 29u, 140u, 166u, 213u, 37u, 43u, + 154u, + }, { + 61u, 63u, 30u, 155u, 67u, 45u, 68u, 1u, + 209u, + }, { + 100u, 80u, 8u, 43u, 154u, 1u, 51u, 26u, + 71u, + }, { + 142u, 78u, 78u, 16u, 255u, 128u, 34u, 197u, + 171u, + }, + { + 41u, 40u, 5u, 102u, 211u, 183u, 4u, 1u, + 221u, + }, { + 51u, 50u, 17u, 168u, 209u, 192u, 23u, 25u, + 82u, + }, + }, { + { + 138u, 31u, 36u, 171u, 27u, 166u, 38u, 44u, + 229u, + }, { + 67u, 87u, 58u, 169u, 82u, 115u, 26u, 59u, + 179u, + }, { + 63u, 59u, 90u, 180u, 59u, 166u, 93u, 73u, + 154u, + }, { + 40u, 40u, 21u, 116u, 143u, 209u, 34u, 39u, + 175u, + }, { + 47u, 15u, 16u, 183u, 34u, 223u, 49u, 45u, + 183u, + }, { + 46u, 17u, 33u, 183u, 6u, 98u, 15u, 32u, + 183u, + }, { + 57u, 46u, 22u, 24u, 128u, 1u, 54u, 17u, + 37u, + }, { + 65u, 32u, 73u, 115u, 28u, 128u, 23u, 128u, + 205u, + }, + { + 40u, 3u, 9u, 115u, 51u, 192u, 18u, 6u, + 223u, + }, { + 87u, 37u, 9u, 115u, 59u, 77u, 64u, 21u, + 47u, + }, + }, { + { + 104u, 55u, 44u, 218u, 9u, 54u, 53u, 130u, + 226u, + }, { + 64u, 90u, 70u, 205u, 40u, 41u, 23u, 26u, + 57u, + }, { + 54u, 57u, 112u, 184u, 5u, 41u, 38u, 166u, + 213u, + }, { + 30u, 34u, 26u, 133u, 152u, 116u, 10u, 32u, + 134u, + }, { + 39u, 19u, 53u, 221u, 26u, 114u, 32u, 73u, + 255u, + }, { + 31u, 9u, 65u, 234u, 2u, 15u, 1u, 118u, + 73u, + }, { + 75u, 32u, 12u, 51u, 192u, 255u, 160u, 43u, + 51u, + }, { + 88u, 31u, 35u, 67u, 102u, 85u, 55u, 186u, + 85u, + }, + { + 56u, 21u, 23u, 111u, 59u, 205u, 45u, 37u, + 192u, + }, { + 55u, 38u, 70u, 124u, 73u, 102u, 1u, 34u, + 98u, + }, + }, { + { + 125u, 98u, 42u, 88u, 104u, 85u, 117u, 175u, + 82u, + }, { + 95u, 84u, 53u, 89u, 128u, 100u, 113u, 101u, + 45u, + }, { + 75u, 79u, 123u, 47u, 51u, 128u, 81u, 171u, + 1u, + }, { + 57u, 17u, 5u, 71u, 102u, 57u, 53u, 41u, + 49u, + }, { + 38u, 33u, 13u, 121u, 57u, 73u, 26u, 1u, + 85u, + }, { + 41u, 10u, 67u, 138u, 77u, 110u, 90u, 47u, + 114u, + }, { + 115u, 21u, 2u, 10u, 102u, 255u, 166u, 23u, + 6u, + }, { + 101u, 29u, 16u, 10u, 85u, 128u, 101u, 196u, + 26u, + }, + { + 57u, 18u, 10u, 102u, 102u, 213u, 34u, 20u, + 43u, + }, { + 117u, 20u, 15u, 36u, 163u, 128u, 68u, 1u, + 26u, + }, + }, { + { + 102u, 61u, 71u, 37u, 34u, 53u, 31u, 243u, + 192u, + }, { + 69u, 60u, 71u, 38u, 73u, 119u, 28u, 222u, + 37u, + }, { + 68u, 45u, 128u, 34u, 1u, 47u, 11u, 245u, + 171u, + }, { + 62u, 17u, 19u, 70u, 146u, 85u, 55u, 62u, + 70u, + }, { + 37u, 43u, 37u, 154u, 100u, 163u, 85u, 160u, + 1u, + }, { + 63u, 9u, 92u, 136u, 28u, 64u, 32u, 201u, + 85u, + }, { + 75u, 15u, 9u, 9u, 64u, 255u, 184u, 119u, + 16u, + }, { + 86u, 6u, 28u, 5u, 64u, 255u, 25u, 248u, + 1u, + }, + { + 56u, 8u, 17u, 132u, 137u, 255u, 55u, 116u, + 128u, + }, { + 58u, 15u, 20u, 82u, 135u, 57u, 26u, 121u, + 40u, + }, + }, + { + { + 164u, 50u, 31u, 137u, 154u, 133u, 25u, 35u, + 218u, + }, { + 51u, 103u, 44u, 131u, 131u, 123u, 31u, 6u, + 158u, + }, { + 86u, 40u, 64u, 135u, 148u, 224u, 45u, 183u, + 128u, + }, { + 22u, 26u, 17u, 131u, 240u, 154u, 14u, 1u, + 209u, + }, { + 45u, 16u, 21u, 91u, 64u, 222u, 7u, 1u, + 197u, + }, { + 56u, 21u, 39u, 155u, 60u, 138u, 23u, 102u, + 213u, + }, { + 83u, 12u, 13u, 54u, 192u, 255u, 68u, 47u, + 28u, + }, { + 85u, 26u, 85u, 85u, 128u, 128u, 32u, 146u, + 171u, + }, + { + 18u, 11u, 7u, 63u, 144u, 171u, 4u, 4u, + 246u, + }, { + 35u, 27u, 10u, 146u, 174u, 171u, 12u, 26u, + 128u, + }, + }, { + { + 190u, 80u, 35u, 99u, 180u, 80u, 126u, 54u, + 45u, + }, { + 85u, 126u, 47u, 87u, 176u, 51u, 41u, 20u, + 32u, + }, { + 101u, 75u, 128u, 139u, 118u, 146u, 116u, 128u, + 85u, + }, { + 56u, 41u, 15u, 176u, 236u, 85u, 37u, 9u, + 62u, + }, { + 71u, 30u, 17u, 119u, 118u, 255u, 17u, 18u, + 138u, + }, { + 101u, 38u, 60u, 138u, 55u, 70u, 43u, 26u, + 142u, + }, { + 146u, 36u, 19u, 30u, 171u, 255u, 97u, 27u, + 20u, + }, { + 138u, 45u, 61u, 62u, 219u, 1u, 81u, 188u, + 64u, + }, + { + 32u, 41u, 20u, 117u, 151u, 142u, 20u, 21u, + 163u, + }, { + 112u, 19u, 12u, 61u, 195u, 128u, 48u, 4u, + 24u, + }, + }, +}; + static const uint8_t WUFFS_VP8__COEFF_UPDATE_PROBS[1056] WUFFS_BASE__POTENTIALLY_UNUSED = { 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, @@ -81301,6 +81640,48 @@ wuffs_vp8__decoder__decode_other_partition_lengths( wuffs_vp8__decoder* self, wuffs_base__slice_u8 a_workbuf); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_vp8__decoder__decode_macroblocks( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__decode_one_macroblock( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mbx, + uint32_t a_mby); + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__decode_luma_mode( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf); + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__decode_chroma_mode( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__decode_subblock_modes( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mbx, + uint32_t a_luma_mode); + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_vp8__decoder__decode_one_subblock_mode( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint8_t a_top_mode, + uint8_t a_left_mode); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_vp8__decoder__do_decode_image_config( @@ -81814,6 +82195,228 @@ wuffs_vp8__decoder__decode_other_partition_lengths( return wuffs_base__make_status(NULL); } +// -------- func vp8.decoder.decode_macroblocks + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_vp8__decoder__decode_macroblocks( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf) { + uint32_t v_mby = 0; + uint32_t v_mbx = 0; + + v_mbx = 0u; + while (v_mbx < self->private_impl.f_mbw) { + self->private_impl.f_mb_top_modes[v_mbx][0u] = 0u; + self->private_impl.f_mb_top_modes[v_mbx][1u] = 0u; + self->private_impl.f_mb_top_modes[v_mbx][2u] = 0u; + self->private_impl.f_mb_top_modes[v_mbx][3u] = 0u; + v_mbx += 1u; + } + v_mby = 0u; + while (v_mby < self->private_impl.f_mbh) { + self->private_impl.f_mb_left_modes[0u] = 0u; + self->private_impl.f_mb_left_modes[1u] = 0u; + self->private_impl.f_mb_left_modes[2u] = 0u; + self->private_impl.f_mb_left_modes[3u] = 0u; + v_mbx = 0u; + while (v_mbx < self->private_impl.f_mbw) { + wuffs_vp8__decoder__decode_one_macroblock(self, a_workbuf, v_mbx, v_mby); + v_mbx += 1u; + } + v_mby += 1u; + } + return wuffs_base__make_status(NULL); +} + +// -------- func vp8.decoder.decode_one_macroblock + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__decode_one_macroblock( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mbx, + uint32_t a_mby) { + uint32_t v_v1 = 0; + uint32_t v_seg = 0; + bool v_skip = false; + uint32_t v_luma_mode = 0; + uint32_t v_chroma_mode = 0; + + v_seg = 0u; + if (self->private_impl.f_seg_update_map) { + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(self->private_impl.f_seg_probs[0u]))); + if (v_v1 == 0u) { + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(self->private_impl.f_seg_probs[1u]))); + v_seg = v_v1; + } else { + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(self->private_impl.f_seg_probs[2u]))); + v_seg = (v_v1 + 2u); + } + } + v_skip = false; + 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_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) { + } + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.decode_luma_mode + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__decode_luma_mode( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf) { + uint32_t v_v1 = 0; + + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, 145u); + if (v_v1 == 0u) { + return 4u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, 156u); + if (v_v1 == 0u) { + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, 163u); + return (2u * v_v1); + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, 128u); + return (3u - (2u * v_v1)); +} + +// -------- func vp8.decoder.decode_chroma_mode + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_vp8__decoder__decode_chroma_mode( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf) { + uint32_t v_v1 = 0; + + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, 142u); + if (v_v1 == 0u) { + return 0u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, 114u); + if (v_v1 == 0u) { + return 2u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, 183u); + return (3u - (2u * v_v1)); +} + +// -------- func vp8.decoder.decode_subblock_modes + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_vp8__decoder__decode_subblock_modes( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_mbx, + uint32_t a_luma_mode) { + uint32_t v_i = 0; + uint8_t v_top_mode = 0; + uint8_t v_left_mode = 0; + uint8_t v_mode = 0; + + if (a_luma_mode < 4u) { + self->private_impl.f_mb_top_modes[a_mbx][0u] = v_mode; + self->private_impl.f_mb_top_modes[a_mbx][1u] = v_mode; + self->private_impl.f_mb_top_modes[a_mbx][2u] = v_mode; + self->private_impl.f_mb_top_modes[a_mbx][3u] = v_mode; + self->private_impl.f_mb_left_modes[0u] = v_mode; + self->private_impl.f_mb_left_modes[1u] = v_mode; + self->private_impl.f_mb_left_modes[2u] = v_mode; + self->private_impl.f_mb_left_modes[3u] = v_mode; + return wuffs_base__make_empty_struct(); + } + v_i = 0u; + while (v_i < 16u) { + if (v_i < 4u) { + v_top_mode = self->private_impl.f_mb_top_modes[a_mbx][v_i]; + } else { + v_top_mode = self->private_impl.f_mb_subblock_modes[(v_i - 4u)]; + } + if ((v_i & 3u) == 0u) { + v_left_mode = self->private_impl.f_mb_left_modes[(v_i >> 2u)]; + } else { + v_left_mode = self->private_impl.f_mb_subblock_modes[(((uint32_t)(v_i + 15u)) & 15u)]; + } + v_mode = wuffs_vp8__decoder__decode_one_subblock_mode(self, a_workbuf, v_top_mode, v_left_mode); + self->private_impl.f_mb_subblock_modes[v_i] = v_mode; + v_i += 1u; + } + self->private_impl.f_mb_top_modes[a_mbx][0u] = self->private_impl.f_mb_subblock_modes[12u]; + self->private_impl.f_mb_top_modes[a_mbx][1u] = self->private_impl.f_mb_subblock_modes[13u]; + self->private_impl.f_mb_top_modes[a_mbx][2u] = self->private_impl.f_mb_subblock_modes[14u]; + self->private_impl.f_mb_top_modes[a_mbx][3u] = self->private_impl.f_mb_subblock_modes[15u]; + self->private_impl.f_mb_left_modes[0u] = self->private_impl.f_mb_subblock_modes[3u]; + self->private_impl.f_mb_left_modes[1u] = self->private_impl.f_mb_subblock_modes[7u]; + self->private_impl.f_mb_left_modes[2u] = self->private_impl.f_mb_subblock_modes[11u]; + self->private_impl.f_mb_left_modes[3u] = self->private_impl.f_mb_subblock_modes[15u]; + return wuffs_base__make_empty_struct(); +} + +// -------- func vp8.decoder.decode_one_subblock_mode + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_vp8__decoder__decode_one_subblock_mode( + wuffs_vp8__decoder* self, + wuffs_base__slice_u8 a_workbuf, + uint8_t a_top_mode, + uint8_t a_left_mode) { + uint32_t v_v1 = 0; + uint8_t v_tm = 0; + uint8_t v_lm = 0; + + v_tm = a_top_mode; + v_lm = a_left_mode; + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][0u]))); + if (v_v1 == 0u) { + return 0u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][1u]))); + if (v_v1 == 0u) { + return 1u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][2u]))); + if (v_v1 == 0u) { + return 2u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][3u]))); + if (v_v1 == 0u) { + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][4u]))); + if (v_v1 == 0u) { + return 3u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][5u]))); + if (v_v1 == 0u) { + return 4u; + } + return 5u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][6u]))); + if (v_v1 == 0u) { + return 6u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][7u]))); + if (v_v1 == 0u) { + return 7u; + } + v_v1 = wuffs_vp8__decoder__read_bit(self, a_workbuf, 0u, ((uint32_t)(WUFFS_VP8__SUBBLOCK_MODE_PROBS[v_tm][v_lm][8u]))); + if (v_v1 == 0u) { + return 8u; + } + return 9u; +} + // -------- func vp8.decoder.get_quirk WUFFS_BASE__GENERATED_C_CODE @@ -82411,6 +83014,17 @@ wuffs_vp8__decoder__do_decode_frame( } goto ok; } + v_status = wuffs_vp8__decoder__decode_macroblocks(self, a_workbuf); + if ( ! wuffs_base__status__is_ok(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } self->private_impl.f_dst_x = 0u; self->private_impl.f_dst_y = 0u; v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler, diff --git a/std/vp8/common_consts.wuffs b/std/vp8/common_consts.wuffs index 008215d8..648ec508 100644 --- a/std/vp8/common_consts.wuffs +++ b/std/vp8/common_consts.wuffs @@ -107,6 +107,142 @@ pri const RENORM_RANGE_M1 : roarray[256] base.u8[127 ..= 254] = [ 254, ] +// RFC 6386 Section 11.5. Subblock Mode Probability Table. +// +// Note that the specification (the RFC) differs from the implementation +// (libwebp's src/dec/tree_dec.c). The mode enumeration, ranging in 0 ..= 9, +// has been re-ordered. This implementation follows libwebp. +// +// Here's the sequence of SUBBLOCK_MODE_PROBS[m][0][0] values: +// +// 231, 134, 88, 193, 125, 138, 104, 102, 164, 190. RFC's kf_bmode_prob. +// 231, 134, 88, 193, 138, 104, 125, 102, 164, 190. libwebp's kBModesProba. +// ^^^ ^^^ ^^^ Note the difference. +// +// +// A libwebp commit message from 2010 says "lot of cosmetics" and "use HE and +// VE naming for prediction mode instead of H and V" but it also does this +// re-ordering. It has this diff: +// +// VP8PredFunc VP8PredLuma4[11] = { +// - DC4, TM4, V4, H4, LD4, RD4, VR4, VL4, HD4, HU4 +// + DC4, TM4, VE4, HE4, RD4, VR4, LD4, VL4, HD4, HU4 +// }; +// ^^^ ^^^ ^^^ Note the difference. +// +// https://chromium.googlesource.com/webm/libwebp/+/f67b5939ad92e608b546b291b29bca1db3b54772%5E%21 +pri const SUBBLOCK_MODE_PROBS : roarray[10] roarray[10] roarray[9] base.u8[1 ..=] = [[ + [231, 120, 48, 89, 115, 113, 120, 152, 112], + [152, 179, 64, 126, 170, 118, 46, 70, 95], + [175, 69, 143, 80, 85, 82, 72, 155, 103], + [56, 58, 10, 171, 218, 189, 17, 13, 152], + [114, 26, 17, 163, 44, 195, 21, 10, 173], + [121, 24, 80, 195, 26, 62, 44, 64, 85], + [144, 71, 10, 38, 171, 213, 144, 34, 26], + [170, 46, 55, 19, 136, 160, 33, 206, 71], + [63, 20, 8, 114, 114, 208, 12, 9, 226], + [81, 40, 11, 96, 182, 84, 29, 16, 36], +],[ + [134, 183, 89, 137, 98, 101, 106, 165, 148], + [72, 187, 100, 130, 157, 111, 32, 75, 80], + [66, 102, 167, 99, 74, 62, 40, 234, 128], + [41, 53, 9, 178, 241, 141, 26, 8, 107], + [74, 43, 26, 146, 73, 166, 49, 23, 157], + [65, 38, 105, 160, 51, 52, 31, 115, 128], + [104, 79, 12, 27, 217, 255, 87, 17, 7], + [87, 68, 71, 44, 114, 51, 15, 186, 23], + [47, 41, 14, 110, 182, 183, 21, 17, 194], + [66, 45, 25, 102, 197, 189, 23, 18, 22], +],[ + [88, 88, 147, 150, 42, 46, 45, 196, 205], + [43, 97, 183, 117, 85, 38, 35, 179, 61], + [39, 53, 200, 87, 26, 21, 43, 232, 171], + [56, 34, 51, 104, 114, 102, 29, 93, 77], + [39, 28, 85, 171, 58, 165, 90, 98, 64], + [34, 22, 116, 206, 23, 34, 43, 166, 73], + [107, 54, 32, 26, 51, 1, 81, 43, 31], + [68, 25, 106, 22, 64, 171, 36, 225, 114], + [34, 19, 21, 102, 132, 188, 16, 76, 124], + [62, 18, 78, 95, 85, 57, 50, 48, 51], +],[ + [193, 101, 35, 159, 215, 111, 89, 46, 111], + [60, 148, 31, 172, 219, 228, 21, 18, 111], + [112, 113, 77, 85, 179, 255, 38, 120, 114], + [40, 42, 1, 196, 245, 209, 10, 25, 109], + [88, 43, 29, 140, 166, 213, 37, 43, 154], + [61, 63, 30, 155, 67, 45, 68, 1, 209], + [100, 80, 8, 43, 154, 1, 51, 26, 71], + [142, 78, 78, 16, 255, 128, 34, 197, 171], + [41, 40, 5, 102, 211, 183, 4, 1, 221], + [51, 50, 17, 168, 209, 192, 23, 25, 82], +],[ + [138, 31, 36, 171, 27, 166, 38, 44, 229], + [67, 87, 58, 169, 82, 115, 26, 59, 179], + [63, 59, 90, 180, 59, 166, 93, 73, 154], + [40, 40, 21, 116, 143, 209, 34, 39, 175], + [47, 15, 16, 183, 34, 223, 49, 45, 183], + [46, 17, 33, 183, 6, 98, 15, 32, 183], + [57, 46, 22, 24, 128, 1, 54, 17, 37], + [65, 32, 73, 115, 28, 128, 23, 128, 205], + [40, 3, 9, 115, 51, 192, 18, 6, 223], + [87, 37, 9, 115, 59, 77, 64, 21, 47], +],[ + [104, 55, 44, 218, 9, 54, 53, 130, 226], + [64, 90, 70, 205, 40, 41, 23, 26, 57], + [54, 57, 112, 184, 5, 41, 38, 166, 213], + [30, 34, 26, 133, 152, 116, 10, 32, 134], + [39, 19, 53, 221, 26, 114, 32, 73, 255], + [31, 9, 65, 234, 2, 15, 1, 118, 73], + [75, 32, 12, 51, 192, 255, 160, 43, 51], + [88, 31, 35, 67, 102, 85, 55, 186, 85], + [56, 21, 23, 111, 59, 205, 45, 37, 192], + [55, 38, 70, 124, 73, 102, 1, 34, 98], +],[ + [125, 98, 42, 88, 104, 85, 117, 175, 82], + [95, 84, 53, 89, 128, 100, 113, 101, 45], + [75, 79, 123, 47, 51, 128, 81, 171, 1], + [57, 17, 5, 71, 102, 57, 53, 41, 49], + [38, 33, 13, 121, 57, 73, 26, 1, 85], + [41, 10, 67, 138, 77, 110, 90, 47, 114], + [115, 21, 2, 10, 102, 255, 166, 23, 6], + [101, 29, 16, 10, 85, 128, 101, 196, 26], + [57, 18, 10, 102, 102, 213, 34, 20, 43], + [117, 20, 15, 36, 163, 128, 68, 1, 26], +],[ + [102, 61, 71, 37, 34, 53, 31, 243, 192], + [69, 60, 71, 38, 73, 119, 28, 222, 37], + [68, 45, 128, 34, 1, 47, 11, 245, 171], + [62, 17, 19, 70, 146, 85, 55, 62, 70], + [37, 43, 37, 154, 100, 163, 85, 160, 1], + [63, 9, 92, 136, 28, 64, 32, 201, 85], + [75, 15, 9, 9, 64, 255, 184, 119, 16], + [86, 6, 28, 5, 64, 255, 25, 248, 1], + [56, 8, 17, 132, 137, 255, 55, 116, 128], + [58, 15, 20, 82, 135, 57, 26, 121, 40], +],[ + [164, 50, 31, 137, 154, 133, 25, 35, 218], + [51, 103, 44, 131, 131, 123, 31, 6, 158], + [86, 40, 64, 135, 148, 224, 45, 183, 128], + [22, 26, 17, 131, 240, 154, 14, 1, 209], + [45, 16, 21, 91, 64, 222, 7, 1, 197], + [56, 21, 39, 155, 60, 138, 23, 102, 213], + [83, 12, 13, 54, 192, 255, 68, 47, 28], + [85, 26, 85, 85, 128, 128, 32, 146, 171], + [18, 11, 7, 63, 144, 171, 4, 4, 246], + [35, 27, 10, 146, 174, 171, 12, 26, 128], +],[ + [190, 80, 35, 99, 180, 80, 126, 54, 45], + [85, 126, 47, 87, 176, 51, 41, 20, 32], + [101, 75, 128, 139, 118, 146, 116, 128, 85], + [56, 41, 15, 176, 236, 85, 37, 9, 62], + [71, 30, 17, 119, 118, 255, 17, 18, 138], + [101, 38, 60, 138, 55, 70, 43, 26, 142], + [146, 36, 19, 30, 171, 255, 97, 27, 20], + [138, 45, 61, 62, 219, 1, 81, 188, 64], + [32, 41, 20, 117, 151, 142, 20, 21, 163], + [112, 19, 12, 61, 195, 128, 48, 4, 24], +]] + // RFC 6386 Section 13.4. Token Probability Updates. // // 1056 is (4 planes, 8 bands, 3 contexts, 11 tokens) flattened. diff --git a/std/vp8/decode_macroblocks.wuffs b/std/vp8/decode_macroblocks.wuffs new file mode 100644 index 00000000..0fb2149a --- /dev/null +++ b/std/vp8/decode_macroblocks.wuffs @@ -0,0 +1,252 @@ +// Copyright 2026 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +pri func decoder.decode_macroblocks!(workbuf: slice base.u8) base.status { + var mby : base.u32 + var mbx : base.u32 + + mbx = 0 + while mbx < this.mbw { + assert mbx < 0x400 via "a < b: a < c; c <= b"(c: this.mbw) + + this.mb_top_modes[mbx][0] = 0 + this.mb_top_modes[mbx][1] = 0 + this.mb_top_modes[mbx][2] = 0 + this.mb_top_modes[mbx][3] = 0 + + mbx += 1 + } + + mby = 0 + while mby < this.mbh { + assert mby < 0x400 via "a < b: a < c; c <= b"(c: this.mbh) + + this.mb_left_modes[0] = 0 + this.mb_left_modes[1] = 0 + this.mb_left_modes[2] = 0 + this.mb_left_modes[3] = 0 + + mbx = 0 + while mbx < this.mbw, + inv mby < 0x400, + { + assert mbx < 0x400 via "a < b: a < c; c <= b"(c: this.mbw) + + this.decode_one_macroblock!(workbuf: args.workbuf, mbx: mbx, mby: mby) + + mbx += 1 + } + + mby += 1 + } + return ok +} + +pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[..= 0x3FF], mby: base.u32[..= 0x3FF]) { + var v1 : base.u32[..= 1] + + var seg : base.u32[..= 3] + var skip : base.bool + var luma_mode : base.u32[..= 4] + var chroma_mode : base.u32[..= 3] + + seg = 0 + if this.seg_update_map { + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.seg_probs[0] as base.u32) + if v1 == 0 { + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.seg_probs[1] as base.u32) + seg = v1 + } else { + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.seg_probs[2] as base.u32) + seg = v1 + 2 + } + } + + skip = false + if (this.prob_skip & 0x100) <> 0 { + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.prob_skip & 0xFF) + skip = v1 <> 0 + } + + luma_mode = this.decode_luma_mode!(workbuf: args.workbuf) + this.decode_subblock_modes!(workbuf: args.workbuf, mbx: args.mbx, luma_mode: luma_mode) + + chroma_mode = this.decode_chroma_mode!(workbuf: args.workbuf) + + if skip { + // TODO. + } else { + } +} + +// RFC 6386 Section 11.2. Luma Modes. +// +// 0 = B_DC_PRED = predict DC using row above and column to the left. +// 1 = B_TM_PRED = propagate second differences a la "True Motion". +// 2 = B_VE_PRED = predict rows using row above. +// 3 = B_HE_PRED = predict columns using column to the left. +// 4 = B_PRED = each Y subblock is independently predicted. +// +// The RFC gives an enum in (DC_PRED, V_PRED, H_PRED, TM_PRED, B_PRED) order +// but the libwebp implementation uses a different one, (B_DC_PRED, B_TM_PRED, +// B_VE_PRED, B_HE_PRED, B_PRED). Modulo the B_ prefixes, it's DC,V,H,TM versus +// DC,TM,VE,HE. At some point, the internal enum values were re-assigned after +// the RFC was written. +// +// libwebp also uses B_PRED=10 instead of the RFC's B_PRED=4. We use 4. +pri func decoder.decode_luma_mode!(workbuf: slice base.u8) base.u32[..= 4] { + var v1 : base.u32[..= 1] + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 145) + if v1 == 0 { + return 4 // 4=B_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 156) + if v1 == 0 { + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 163) + return 2 * v1 // 0=B_DC_PRED or 2=B_VE_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128) + return 3 - (2 * v1) // 3=B_HE_PRED or 1=B_TM_PRED. +} + +// RFC 6386 Section 11.4. Chroma Modes. +// +// 0 = B_DC_PRED, etc, the same as the Luma Modes, except there's no B_PRED. +pri func decoder.decode_chroma_mode!(workbuf: slice base.u8) base.u32[..= 3] { + var v1 : base.u32[..= 1] + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 142) + if v1 == 0 { + return 0 // 0=B_DC_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 114) + if v1 == 0 { + return 2 // 2=B_VE_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 183) + return 3 - (2 * v1) // 3=B_HE_PRED or 1=B_TM_PRED. +} + +// RFC 6386 Section 11.2. Luma Modes. +pri func decoder.decode_subblock_modes!( + workbuf: slice base.u8, + mbx: base.u32[..= 0x3FF], + luma_mode: base.u32[..= 4]) { + var i : base.u32 + var top_mode : base.u8[..= 9] + var left_mode : base.u8[..= 9] + var mode : base.u8[..= 9] + + if args.luma_mode < 4 { + this.mb_top_modes[args.mbx][0] = mode + this.mb_top_modes[args.mbx][1] = mode + this.mb_top_modes[args.mbx][2] = mode + this.mb_top_modes[args.mbx][3] = mode + this.mb_left_modes[0] = mode + this.mb_left_modes[1] = mode + this.mb_left_modes[2] = mode + this.mb_left_modes[3] = mode + return nothing + } + + i = 0 + while i < 16 { + if i < 4 { + top_mode = this.mb_top_modes[args.mbx][i] + } else { + top_mode = this.mb_subblock_modes[i - 4] + } + + if (i & 3) == 0 { + left_mode = this.mb_left_modes[i >> 2] + } else { + left_mode = this.mb_subblock_modes[(i ~mod+ 15) & 15] + } + + mode = this.decode_one_subblock_mode!(workbuf: args.workbuf, top_mode: top_mode, left_mode: left_mode) + this.mb_subblock_modes[i] = mode + + i += 1 + } + + this.mb_top_modes[args.mbx][0] = this.mb_subblock_modes[0xC] + this.mb_top_modes[args.mbx][1] = this.mb_subblock_modes[0xD] + this.mb_top_modes[args.mbx][2] = this.mb_subblock_modes[0xE] + this.mb_top_modes[args.mbx][3] = this.mb_subblock_modes[0xF] + this.mb_left_modes[0] = this.mb_subblock_modes[0x3] + this.mb_left_modes[1] = this.mb_subblock_modes[0x7] + this.mb_left_modes[2] = this.mb_subblock_modes[0xB] + this.mb_left_modes[3] = this.mb_subblock_modes[0xF] +} + +// RFC 6386 Section 11.3. Subblock Mode Contexts. +pri func decoder.decode_one_subblock_mode!( + workbuf: slice base.u8, + top_mode: base.u8[..= 9], + left_mode: base.u8[..= 9]) base.u8[..= 9] { + var v1 : base.u32[..= 1] + var tm : base.u8[..= 9] + var lm : base.u8[..= 9] + + tm = args.top_mode + lm = args.left_mode + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][0] as base.u32) + if v1 == 0 { + return 0 // 0=B_DC_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][1] as base.u32) + if v1 == 0 { + return 1 // 1=B_TM_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][2] as base.u32) + if v1 == 0 { + return 2 // 2=B_VE_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][3] as base.u32) + if v1 == 0 { + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][4] as base.u32) + if v1 == 0 { + return 3 // 3=B_HE_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][5] as base.u32) + if v1 == 0 { + return 4 // 4=B_RD_PRED. + } + + return 5 // 5=B_VR_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][6] as base.u32) + if v1 == 0 { + return 6 // 6=B_LD_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][7] as base.u32) + if v1 == 0 { + return 7 // 7=B_VL_PRED. + } + + v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][8] as base.u32) + if v1 == 0 { + return 8 // 8=B_HD_PRED. + } + + return 9 // 9=B_HU_PRED. +} diff --git a/std/vp8/decode_vp8.wuffs b/std/vp8/decode_vp8.wuffs index 7a727873..fafc64fe 100644 --- a/std/vp8/decode_vp8.wuffs +++ b/std/vp8/decode_vp8.wuffs @@ -92,6 +92,10 @@ pub struct decoder? implements base.image_decoder( // hold in the 0x100 bit) and prob_skip_false (in the low 8 bits). prob_skip : base.u32[..= 0x1FF], + mb_subblock_modes : array[16] base.u8[..= 9], + mb_left_modes : array[4] base.u8[..= 9], + mb_top_modes : array[0x400] array[4] base.u8[..= 9], + dst_x : base.u32, dst_y : base.u32, @@ -294,6 +298,11 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade return status } + status = this.decode_macroblocks!(workbuf: args.workbuf) + if not status.is_ok() { + return status + } + this.dst_x = 0 this.dst_y = 0