Files
wuffs/std/vp8/decode_macroblocks.wuffs
T
Nigel Tao 381e186f30 std/vp8: swizzle_ycck once, not once per MB row
This prepares us to change std/vp8's YCC upsampling method from "basic"
to "fancy, like libwebp". Wuffs' current implementation of "fancy"
requires the initial Y coordinate to be zero, as fancy upsampling
special cases the top row of the image and it's simpler if the top row
(row zero) is always presented in the upsampling call.

This is not an optimization or pessimization per se, but for the record,
the performance impact is between negligible and a small improvement.

name                                               old speed      new speed      delta

wuffs_webp_lossy_decode_image_19k_8bpp/clang14     33.7MB/s ± 0%  34.1MB/s ± 0%  +1.28%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_40k_24bpp/clang14     106MB/s ± 0%   106MB/s ± 0%  +0.09%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_77k_24bpp/clang14     129MB/s ± 0%   130MB/s ± 0%  +0.54%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_552k_32bpp/clang14    207MB/s ± 0%   211MB/s ± 0%  +1.90%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_4002k_24bpp/clang14   137MB/s ± 0%   138MB/s ± 0%  +0.40%  (p=0.008 n=5+5)

wuffs_webp_lossy_decode_image_19k_8bpp/gcc12       32.9MB/s ± 0%  32.9MB/s ± 0%  +0.05%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_40k_24bpp/gcc12      98.4MB/s ± 0%  98.8MB/s ± 0%  +0.42%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_77k_24bpp/gcc12       125MB/s ± 0%   125MB/s ± 0%  +0.17%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_552k_32bpp/gcc12      211MB/s ± 0%   214MB/s ± 0%  +1.21%  (p=0.008 n=5+5)
wuffs_webp_lossy_decode_image_4002k_24bpp/gcc12     137MB/s ± 0%   137MB/s ± 0%    ~     (p=0.095 n=5+5)
2026-07-03 21:47:26 +10:00

436 lines
15 KiB
Plaintext

// 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
pri func decoder.decode_macroblocks!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status {
var mby : base.u32
var mbx : base.u32
var status : base.status
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
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
}
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)
}
// TODO(§): re-enable this when swizzle_ycck can take y_min_incl > 0.
//
// status = this.swizzle_one_row_of_macroblocks!(dst: args.dst, workbuf: args.workbuf, mby: mby - 1)
// if not status.is_ok() {
// return status
// }
}
mby += 1
}
if this.mbh > 0 {
mby = this.mbh - 1
if this.filt_level <= 0 {
// No-op.
} else if this.filt_simple {
this.filter_simple!(workbuf: args.workbuf, mby: mby)
} else {
this.filter_normal!(workbuf: args.workbuf, mby: mby)
}
status = this.swizzle_one_row_of_macroblocks!(dst: args.dst, workbuf: args.workbuf, mby: mby)
if not status.is_ok() {
return status
}
}
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]
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_one_row_of_macroblocks!(
dst: ptr base.pixel_buffer,
workbuf: slice base.u8,
mby: base.u32[..= 0x3FF]) base.status {
var y_min_incl : base.u32[..= 0x3FFF]
var y_max_excl : base.u32[..= 0x3FFF]
var o : base.u64
var src0 : slice base.u8
var src1 : slice base.u8
var src2 : slice base.u8
var status : base.status
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 > args.workbuf.length()) {
return base."#bad workbuf length"
}
assert this.workbuf_yuv_u_end <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_v_end)
assert this.workbuf_yuv_y_end <= args.workbuf.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_u_end)
// There are 16 rows of pixels per macroblock. However, the bottom 6 rows
// of pixels (the bottom 3 rows of samples, at 4:2:0 chroma subsampling)
// can be modified by the the macroblock below's loop filtering (which
// happens after decoder.swizzle_one_row_of_macroblocks returns), unless
// we're swizzling the bottom-most row of macroblocks.
y_min_incl = (args.mby * 16) ~sat- 6
y_min_incl = 0 // TODO(§): delete this.
y_max_excl = (args.mby * 16) + 10
if (args.mby + 1) >= this.mbh {
y_max_excl = this.height
}
o = (y_min_incl * this.workbuf_yuv_y_stride) as base.u64
if o < this.workbuf_yuv_y_end {
src0 = args.workbuf[o .. this.workbuf_yuv_y_end]
}
o = (((y_min_incl / 2) * this.workbuf_yuv_uv_stride) as base.u64) + this.workbuf_yuv_y_end
if o < this.workbuf_yuv_u_end {
src1 = args.workbuf[o .. this.workbuf_yuv_u_end]
}
o = (((y_min_incl / 2) * this.workbuf_yuv_uv_stride) as base.u64) + this.workbuf_yuv_u_end
if o < this.workbuf_yuv_v_end {
src2 = args.workbuf[o .. this.workbuf_yuv_v_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: y_min_incl,
y_max_excl: y_max_excl,
src0: src0,
src1: src1,
src2: src2,
src3: this.util.empty_slice_u8(),
width0: this.mbw * 16,
width1: this.mbw * 8,
width2: this.mbw * 8,
width3: 0,
height0: (this.mbh * 16) ~sat- y_min_incl,
height1: (this.mbh * 8) ~sat- (y_min_incl / 2),
height2: (this.mbh * 8) ~sat- (y_min_incl / 2),
height3: 0,
stride0: this.mbw * 16,
stride1: this.mbw * 8,
stride2: this.mbw * 8,
stride3: 0,
h0: 2,
h1: 1,
h2: 1,
h3: 0,
v0: 2,
v1: 1,
v2: 1,
v3: 0,
ycc_model: base.YCC_MODEL__BT_601_STUDIO_RANGE as base.u8,
// TODO(§): let fancy upsampling work with y_min_incl > 0.
ycc_upsampling: base.YCC_UPSAMPLING__BASIC as base.u8,
scratch_buffer_2k: this.swizzle_ycck_scratch_buffer_2k[..])
return status
}