// 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_states_top[mbx] = 0 mbx += 1 } mby = 0 while mby < this.mbh { assert mby < 0x400 via "a < b: a < c; c <= b"(c: this.mbh) this.mb_states_left = 0 // Decode this row, using this.mb_coeffs and this.yuv_cache before // ultimately writing to args.workbuf. 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 } // Filter the previous row, already in args.workbuf. if mby > 0 { if 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 } // Filter the final row, already in args.workbuf. if this.mbh > 0 { if 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 } 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.u32[..= 1] var mask : base.u32 var luma_mode : base.u32[..= 4] var chroma_mode : base.u32[..= 3] // RFC 6386 Section 10. Segment-Based Feature Adjustments. 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 = 0 if (this.prob_skip & 0x100) <> 0 { skip = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.prob_skip & 0xFF) } 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 <> 0 { // Clear the HNZC bits. mask = 0x0000_FFFF if luma_mode >= 4 { mask = 0x0080_FFFF } this.mb_states_left &= mask this.mb_states_top[args.mbx] &= mask this.mb_dc_nz = 0 this.mb_ac_nz = 0 } else { skip = this.decode_coefficients!( workbuf: args.workbuf, mbx: args.mbx, mby: args.mby, seg: seg, luma_mode: luma_mode) } this.reconstruct!( workbuf: args.workbuf, mbx: args.mbx, mby: args.mby, luma_mode: luma_mode, chroma_mode: chroma_mode) this.copy_from_yuv_cache!( workbuf: args.workbuf, mbx: args.mbx, mby: args.mby) 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. // // 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. // // Returning (as luma_mode) at least 4 (equivalently, returning B_PRED) means // that we use "intra4x4 prediction" (as opposed to "intra16x16 prediction"). // (luma_mode >= 4) here is equivalent to libwebp's "is_i4x4 == true" and // golang.org/x/image/vp8's "usePredY16 == false". // // 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. is_i4x4 == true. usePredY16 == false. } // Otherwise, is_i4x4 == false. usePredY16 == true. 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_states_top[args.mbx] = (this.mb_states_top[args.mbx] & 0xFFFF_0000) | ((args.luma_mode as base.u32) * 0x1111) this.mb_states_left = (this.mb_states_left & 0xFFFF_0000) | ((args.luma_mode as base.u32) * 0x1111) return nothing } i = 0 while i < 16 { if i < 4 { top_mode = CLAMP_NO_MORE_THAN_9[15 & (this.mb_states_top[args.mbx] >> (i * 4))] } else { top_mode = this.mb_subblock_modes[i - 4] } if (i & 3) == 0 { left_mode = CLAMP_NO_MORE_THAN_9[15 & (this.mb_states_left >> (i & 12))] } 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_states_top[args.mbx] = (this.mb_states_top[args.mbx] & 0xFFFF_0000) | ((this.mb_subblock_modes[0xC] as base.u32) << 0x0) | ((this.mb_subblock_modes[0xD] as base.u32) << 0x4) | ((this.mb_subblock_modes[0xE] as base.u32) << 0x8) | ((this.mb_subblock_modes[0xF] as base.u32) << 0xC) this.mb_states_left = (this.mb_states_left & 0xFFFF_0000) | ((this.mb_subblock_modes[0x3] as base.u32) << 0x0) | ((this.mb_subblock_modes[0x7] as base.u32) << 0x4) | ((this.mb_subblock_modes[0xB] as base.u32) << 0x8) | ((this.mb_subblock_modes[0xF] as base.u32) << 0xC) } // 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. } pri func decoder.copy_from_yuv_cache!( workbuf: slice base.u8, mbx: base.u32[..= 0x3FF], mby: base.u32[..= 0x3FF]) { var w : base.u64 var i : base.u32 var dst : slice base.u8 w = ((((args.mby * this.workbuf_yuv_y_stride) + args.mbx) * 16) as base.u64) + 0 i = 0 while i < 16 { if w < args.workbuf.length() { dst = args.workbuf[w ..] dst.copy_from_slice!(s: this.yuv_cache[i + 0x01][0x08 .. 0x18]) } w ~mod+= this.workbuf_yuv_y_stride as base.u64 i += 1 } w = ((((args.mby * this.workbuf_yuv_uv_stride) + args.mbx) * 8) as base.u64) + this.workbuf_yuv_y_end i = 0 while i < 8 { if w < args.workbuf.length() { dst = args.workbuf[w ..] dst.copy_from_slice!(s: this.yuv_cache[i + 0x12][0x08 .. 0x10]) } w ~mod+= this.workbuf_yuv_uv_stride as base.u64 i += 1 } w = ((((args.mby * this.workbuf_yuv_uv_stride) + args.mbx) * 8) as base.u64) + this.workbuf_yuv_u_end i = 0 while i < 8 { if w < args.workbuf.length() { dst = args.workbuf[w ..] dst.copy_from_slice!(s: this.yuv_cache[i + 0x12][0x18 .. 0x20]) } w ~mod+= this.workbuf_yuv_uv_stride as base.u64 i += 1 } } pri func decoder.swizzle!( dst: ptr base.pixel_buffer, blend: base.pixel_blend, workbuf: slice base.u8) base.status { var wh : base.u64[..= 0xFFF_8001] var prefix : slice base.u8 var suffix : slice base.u8 var has_alpha : base.u32[..= 1] var ycc_model : base.u32[..= 0xFF] var status : base.status if this.quirk_has_alpha_side_channel { if this.quirk_width_and_height == 0 { return "#inconsistent width and height" } wh = (this.width * this.height) as base.u64 if wh > args.workbuf.length() { return base."#bad workbuf length" } prefix = args.workbuf[.. wh] suffix = args.workbuf[wh ..] has_alpha = 1 ycc_model = base.YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC | (0x01 & (this.util.demake_pixel_blend(a: args.blend) as base.u32)) } else { prefix = this.util.empty_slice_u8() suffix = args.workbuf has_alpha = 0 ycc_model = base.YCC_MODEL__BT_601_STUDIO_RANGE } if (this.workbuf_yuv_y_end > this.workbuf_yuv_u_end) or (this.workbuf_yuv_u_end > this.workbuf_yuv_v_end) or (this.workbuf_yuv_v_end > suffix.length()) { return base."#bad workbuf length" } assert this.workbuf_yuv_u_end <= suffix.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_v_end) assert this.workbuf_yuv_y_end <= suffix.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_u_end) status = this.swizzler.swizzle_ycck!( dst: args.dst, dst_palette: args.dst.palette(), x_min_incl: 0, x_max_excl: this.width, y_min_incl: 0, y_max_excl: this.height, src0: suffix[.. this.workbuf_yuv_y_end], src1: suffix[this.workbuf_yuv_y_end .. this.workbuf_yuv_u_end], src2: suffix[this.workbuf_yuv_u_end .. this.workbuf_yuv_v_end], src3: prefix, width0: this.mbw * 16, width1: this.mbw * 8, width2: this.mbw * 8, width3: this.width * has_alpha, height0: this.mbh * 16, height1: this.mbh * 8, height2: this.mbh * 8, height3: this.height * has_alpha, stride0: this.mbw * 16, stride1: this.mbw * 8, stride2: this.mbw * 8, stride3: this.width * has_alpha, h0: 2, h1: 1, h2: 1, h3: (2 * has_alpha) as base.u8, v0: 2, v1: 1, v2: 1, v3: (2 * has_alpha) as base.u8, ycc_model: ycc_model as base.u8, ycc_upsampling: base.YCC_UPSAMPLING__FANCY_LIKE_LIBWEBP as base.u8, scratch_buffer_2k: this.swizzle_ycck_scratch_buffer_2k[..]) return status }