Files
wuffs/std/vp8/decode_predict_default.wuffs
T
Nigel Tao bb3c85e2ef std/vp8: calculate the predicted values
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
2026-06-16 14:00:28 +10:00

676 lines
26 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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
// --------
// Predicts a 4×4 luma block, the Xs below, based on samples top and left.
//
// a b c d e f g h i
// p X X X X
// q X X X X
// r X X X X
// s X X X X
pri func decoder.predict_y4!(b: base.u32[..= 15]) {
var cachey : base.u32[..= 13]
var cachex : base.u32[..= 20]
var mode : base.u32[..= 9]
var z : base.u32
var avg : base.u8
var tm0 : base.u32
var tm1 : base.u32
var tm2 : base.u32
var a : base.u32
var b : base.u32
var c : base.u32
var d : base.u32
var e : base.u32
var f : base.u32
var g : base.u32
var h : base.u32
var i : base.u32
var p : base.u32
var q : base.u32
var r : base.u32
var s : base.u32
var ab : base.u8
var bc : base.u8
var cd : base.u8
var de : base.u8
var ef : base.u8
var pa : base.u8
var qp : base.u8
var rq : base.u8
var sr : base.u8
var abc : base.u8
var bcd : base.u8
var cde : base.u8
var def : base.u8
var efg : base.u8
var fgh : base.u8
var ghi : base.u8
var hii : base.u8
var pab : base.u8
var qpa : base.u8
var rqp : base.u8
var srq : base.u8
var ssr : base.u8
var sss : base.u8
cachey = ((args.b & 0xC) * 1) + 1
cachex = ((args.b & 0x3) * 4) + 8
mode = this.mb_subblock_modes[args.b] as base.u32
if mode == 0 { // DC.
avg = ((4 +
(this.yuv_cache[cachey - 1][cachex + 0] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 1] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 2] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 3] as base.u32) +
(this.yuv_cache[cachey + 0][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 1][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 2][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 3][cachex - 1] as base.u32)) / 8) as base.u8
z = 0
while z < 16 {
this.yuv_cache[cachey + (z >> 2)][cachex + (z & 3)] = avg
z += 1
}
} else if mode == 1 { // TM.
tm0 = this.yuv_cache[cachey - 1][cachex - 1] as base.u32
z = 0
while z < 16,
inv cachey >= 1,
inv cachex >= 8,
{
tm1 = this.yuv_cache[cachey + (z >> 2)][cachex - 1] as base.u32
tm2 = this.yuv_cache[cachey - 1][cachex + (z & 3)] as base.u32
this.yuv_cache[cachey + (z >> 2)][cachex + (z & 3)] =
CLAMP[((tm1 + tm2) ~mod- tm0) & 1023]
z += 1
}
} else if mode == 2 { // VE.
a = this.yuv_cache[cachey - 1][cachex - 1] as base.u32
b = this.yuv_cache[cachey - 1][cachex + 0] as base.u32
c = this.yuv_cache[cachey - 1][cachex + 1] as base.u32
d = this.yuv_cache[cachey - 1][cachex + 2] as base.u32
e = this.yuv_cache[cachey - 1][cachex + 3] as base.u32
f = this.yuv_cache[cachey - 1][cachex + 4] as base.u32
def = (((d + (2 * e) + f + 2) / 4) & 0xFF) as base.u8
cde = (((c + (2 * d) + e + 2) / 4) & 0xFF) as base.u8
bcd = (((b + (2 * c) + d + 2) / 4) & 0xFF) as base.u8
abc = (((a + (2 * b) + c + 2) / 4) & 0xFF) as base.u8
z = 0
while z < 4 {
this.yuv_cache[cachey + z][cachex + 0] = abc
this.yuv_cache[cachey + z][cachex + 1] = bcd
this.yuv_cache[cachey + z][cachex + 2] = cde
this.yuv_cache[cachey + z][cachex + 3] = def
z += 1
}
} else if mode == 3 { // HE.
s = this.yuv_cache[cachey + 3][cachex - 1] as base.u32
r = this.yuv_cache[cachey + 2][cachex - 1] as base.u32
q = this.yuv_cache[cachey + 1][cachex - 1] as base.u32
p = this.yuv_cache[cachey + 0][cachex - 1] as base.u32
a = this.yuv_cache[cachey - 1][cachex - 1] as base.u32
qpa = (((q + (2 * p) + a + 2) / 4) & 0xFF) as base.u8
rqp = (((r + (2 * q) + p + 2) / 4) & 0xFF) as base.u8
srq = (((s + (2 * r) + q + 2) / 4) & 0xFF) as base.u8
ssr = (((s + (2 * s) + r + 2) / 4) & 0xFF) as base.u8
z = 0
while z < 4 {
this.yuv_cache[cachey + 0][cachex + z] = qpa
this.yuv_cache[cachey + 1][cachex + z] = rqp
this.yuv_cache[cachey + 2][cachex + z] = srq
this.yuv_cache[cachey + 3][cachex + z] = ssr
z += 1
}
} else if mode == 4 { // RD.
s = this.yuv_cache[cachey + 3][cachex - 1] as base.u32
r = this.yuv_cache[cachey + 2][cachex - 1] as base.u32
q = this.yuv_cache[cachey + 1][cachex - 1] as base.u32
p = this.yuv_cache[cachey + 0][cachex - 1] as base.u32
a = this.yuv_cache[cachey - 1][cachex - 1] as base.u32
b = this.yuv_cache[cachey - 1][cachex + 0] as base.u32
c = this.yuv_cache[cachey - 1][cachex + 1] as base.u32
d = this.yuv_cache[cachey - 1][cachex + 2] as base.u32
e = this.yuv_cache[cachey - 1][cachex + 3] as base.u32
cde = (((c + (2 * d) + e + 2) / 4) & 0xFF) as base.u8
bcd = (((b + (2 * c) + d + 2) / 4) & 0xFF) as base.u8
abc = (((a + (2 * b) + c + 2) / 4) & 0xFF) as base.u8
pab = (((p + (2 * a) + b + 2) / 4) & 0xFF) as base.u8
qpa = (((q + (2 * p) + a + 2) / 4) & 0xFF) as base.u8
rqp = (((r + (2 * q) + p + 2) / 4) & 0xFF) as base.u8
srq = (((s + (2 * r) + q + 2) / 4) & 0xFF) as base.u8
this.yuv_cache[cachey + 0][cachex + 0] = pab
this.yuv_cache[cachey + 0][cachex + 1] = abc
this.yuv_cache[cachey + 0][cachex + 2] = bcd
this.yuv_cache[cachey + 0][cachex + 3] = cde
this.yuv_cache[cachey + 1][cachex + 0] = qpa
this.yuv_cache[cachey + 1][cachex + 1] = pab
this.yuv_cache[cachey + 1][cachex + 2] = abc
this.yuv_cache[cachey + 1][cachex + 3] = bcd
this.yuv_cache[cachey + 2][cachex + 0] = rqp
this.yuv_cache[cachey + 2][cachex + 1] = qpa
this.yuv_cache[cachey + 2][cachex + 2] = pab
this.yuv_cache[cachey + 2][cachex + 3] = abc
this.yuv_cache[cachey + 3][cachex + 0] = srq
this.yuv_cache[cachey + 3][cachex + 1] = rqp
this.yuv_cache[cachey + 3][cachex + 2] = qpa
this.yuv_cache[cachey + 3][cachex + 3] = pab
} else if mode == 5 { // VR.
r = this.yuv_cache[cachey + 2][cachex - 1] as base.u32
q = this.yuv_cache[cachey + 1][cachex - 1] as base.u32
p = this.yuv_cache[cachey + 0][cachex - 1] as base.u32
a = this.yuv_cache[cachey - 1][cachex - 1] as base.u32
b = this.yuv_cache[cachey - 1][cachex + 0] as base.u32
c = this.yuv_cache[cachey - 1][cachex + 1] as base.u32
d = this.yuv_cache[cachey - 1][cachex + 2] as base.u32
e = this.yuv_cache[cachey - 1][cachex + 3] as base.u32
ab = (((a + b + 1) / 2) & 0xFF) as base.u8
bc = (((b + c + 1) / 2) & 0xFF) as base.u8
cd = (((c + d + 1) / 2) & 0xFF) as base.u8
de = (((d + e + 1) / 2) & 0xFF) as base.u8
cde = (((c + (2 * d) + e + 2) / 4) & 0xFF) as base.u8
bcd = (((b + (2 * c) + d + 2) / 4) & 0xFF) as base.u8
abc = (((a + (2 * b) + c + 2) / 4) & 0xFF) as base.u8
pab = (((p + (2 * a) + b + 2) / 4) & 0xFF) as base.u8
qpa = (((q + (2 * p) + a + 2) / 4) & 0xFF) as base.u8
rqp = (((r + (2 * q) + p + 2) / 4) & 0xFF) as base.u8
this.yuv_cache[cachey + 0][cachex + 0] = ab
this.yuv_cache[cachey + 0][cachex + 1] = bc
this.yuv_cache[cachey + 0][cachex + 2] = cd
this.yuv_cache[cachey + 0][cachex + 3] = de
this.yuv_cache[cachey + 1][cachex + 0] = pab
this.yuv_cache[cachey + 1][cachex + 1] = abc
this.yuv_cache[cachey + 1][cachex + 2] = bcd
this.yuv_cache[cachey + 1][cachex + 3] = cde
this.yuv_cache[cachey + 2][cachex + 0] = qpa
this.yuv_cache[cachey + 2][cachex + 1] = ab
this.yuv_cache[cachey + 2][cachex + 2] = bc
this.yuv_cache[cachey + 2][cachex + 3] = cd
this.yuv_cache[cachey + 3][cachex + 0] = rqp
this.yuv_cache[cachey + 3][cachex + 1] = pab
this.yuv_cache[cachey + 3][cachex + 2] = abc
this.yuv_cache[cachey + 3][cachex + 3] = bcd
} else if mode == 6 { // LD.
b = this.yuv_cache[cachey - 1][cachex + 0] as base.u32
c = this.yuv_cache[cachey - 1][cachex + 1] as base.u32
d = this.yuv_cache[cachey - 1][cachex + 2] as base.u32
e = this.yuv_cache[cachey - 1][cachex + 3] as base.u32
f = this.yuv_cache[cachey - 1][cachex + 4] as base.u32
g = this.yuv_cache[cachey - 1][cachex + 5] as base.u32
h = this.yuv_cache[cachey - 1][cachex + 6] as base.u32
i = this.yuv_cache[cachey - 1][cachex + 7] as base.u32
hii = (((h + (2 * i) + i + 2) / 4) & 0xFF) as base.u8
ghi = (((g + (2 * h) + i + 2) / 4) & 0xFF) as base.u8
fgh = (((f + (2 * g) + h + 2) / 4) & 0xFF) as base.u8
efg = (((e + (2 * f) + g + 2) / 4) & 0xFF) as base.u8
def = (((d + (2 * e) + f + 2) / 4) & 0xFF) as base.u8
cde = (((c + (2 * d) + e + 2) / 4) & 0xFF) as base.u8
bcd = (((b + (2 * c) + d + 2) / 4) & 0xFF) as base.u8
this.yuv_cache[cachey + 0][cachex + 0] = bcd
this.yuv_cache[cachey + 0][cachex + 1] = cde
this.yuv_cache[cachey + 0][cachex + 2] = def
this.yuv_cache[cachey + 0][cachex + 3] = efg
this.yuv_cache[cachey + 1][cachex + 0] = cde
this.yuv_cache[cachey + 1][cachex + 1] = def
this.yuv_cache[cachey + 1][cachex + 2] = efg
this.yuv_cache[cachey + 1][cachex + 3] = fgh
this.yuv_cache[cachey + 2][cachex + 0] = def
this.yuv_cache[cachey + 2][cachex + 1] = efg
this.yuv_cache[cachey + 2][cachex + 2] = fgh
this.yuv_cache[cachey + 2][cachex + 3] = ghi
this.yuv_cache[cachey + 3][cachex + 0] = efg
this.yuv_cache[cachey + 3][cachex + 1] = fgh
this.yuv_cache[cachey + 3][cachex + 2] = ghi
this.yuv_cache[cachey + 3][cachex + 3] = hii
} else if mode == 7 { // VL.
b = this.yuv_cache[cachey - 1][cachex + 0] as base.u32
c = this.yuv_cache[cachey - 1][cachex + 1] as base.u32
d = this.yuv_cache[cachey - 1][cachex + 2] as base.u32
e = this.yuv_cache[cachey - 1][cachex + 3] as base.u32
f = this.yuv_cache[cachey - 1][cachex + 4] as base.u32
g = this.yuv_cache[cachey - 1][cachex + 5] as base.u32
h = this.yuv_cache[cachey - 1][cachex + 6] as base.u32
i = this.yuv_cache[cachey - 1][cachex + 7] as base.u32
ef = (((e + f + 1) / 2) & 0xFF) as base.u8
de = (((d + e + 1) / 2) & 0xFF) as base.u8
cd = (((c + d + 1) / 2) & 0xFF) as base.u8
bc = (((b + c + 1) / 2) & 0xFF) as base.u8
ghi = (((g + (2 * h) + i + 2) / 4) & 0xFF) as base.u8
fgh = (((f + (2 * g) + h + 2) / 4) & 0xFF) as base.u8
efg = (((e + (2 * f) + g + 2) / 4) & 0xFF) as base.u8
def = (((d + (2 * e) + f + 2) / 4) & 0xFF) as base.u8
cde = (((c + (2 * d) + e + 2) / 4) & 0xFF) as base.u8
bcd = (((b + (2 * c) + d + 2) / 4) & 0xFF) as base.u8
this.yuv_cache[cachey + 0][cachex + 0] = bc
this.yuv_cache[cachey + 0][cachex + 1] = cd
this.yuv_cache[cachey + 0][cachex + 2] = de
this.yuv_cache[cachey + 0][cachex + 3] = ef
this.yuv_cache[cachey + 1][cachex + 0] = bcd
this.yuv_cache[cachey + 1][cachex + 1] = cde
this.yuv_cache[cachey + 1][cachex + 2] = def
this.yuv_cache[cachey + 1][cachex + 3] = efg
this.yuv_cache[cachey + 2][cachex + 0] = cd
this.yuv_cache[cachey + 2][cachex + 1] = de
this.yuv_cache[cachey + 2][cachex + 2] = ef
this.yuv_cache[cachey + 2][cachex + 3] = fgh
this.yuv_cache[cachey + 3][cachex + 0] = cde
this.yuv_cache[cachey + 3][cachex + 1] = def
this.yuv_cache[cachey + 3][cachex + 2] = efg
this.yuv_cache[cachey + 3][cachex + 3] = ghi
} else if mode == 8 { // HD.
s = this.yuv_cache[cachey + 3][cachex - 1] as base.u32
r = this.yuv_cache[cachey + 2][cachex - 1] as base.u32
q = this.yuv_cache[cachey + 1][cachex - 1] as base.u32
p = this.yuv_cache[cachey + 0][cachex - 1] as base.u32
a = this.yuv_cache[cachey - 1][cachex - 1] as base.u32
b = this.yuv_cache[cachey - 1][cachex + 0] as base.u32
c = this.yuv_cache[cachey - 1][cachex + 1] as base.u32
d = this.yuv_cache[cachey - 1][cachex + 2] as base.u32
sr = (((s + r + 1) / 2) & 0xFF) as base.u8
rq = (((r + q + 1) / 2) & 0xFF) as base.u8
qp = (((q + p + 1) / 2) & 0xFF) as base.u8
pa = (((p + a + 1) / 2) & 0xFF) as base.u8
bcd = (((b + (2 * c) + d + 2) / 4) & 0xFF) as base.u8
abc = (((a + (2 * b) + c + 2) / 4) & 0xFF) as base.u8
pab = (((p + (2 * a) + b + 2) / 4) & 0xFF) as base.u8
qpa = (((q + (2 * p) + a + 2) / 4) & 0xFF) as base.u8
rqp = (((r + (2 * q) + p + 2) / 4) & 0xFF) as base.u8
srq = (((s + (2 * r) + q + 2) / 4) & 0xFF) as base.u8
this.yuv_cache[cachey + 0][cachex + 0] = pa
this.yuv_cache[cachey + 0][cachex + 1] = pab
this.yuv_cache[cachey + 0][cachex + 2] = abc
this.yuv_cache[cachey + 0][cachex + 3] = bcd
this.yuv_cache[cachey + 1][cachex + 0] = qp
this.yuv_cache[cachey + 1][cachex + 1] = qpa
this.yuv_cache[cachey + 1][cachex + 2] = pa
this.yuv_cache[cachey + 1][cachex + 3] = pab
this.yuv_cache[cachey + 2][cachex + 0] = rq
this.yuv_cache[cachey + 2][cachex + 1] = rqp
this.yuv_cache[cachey + 2][cachex + 2] = qp
this.yuv_cache[cachey + 2][cachex + 3] = qpa
this.yuv_cache[cachey + 3][cachex + 0] = sr
this.yuv_cache[cachey + 3][cachex + 1] = srq
this.yuv_cache[cachey + 3][cachex + 2] = rq
this.yuv_cache[cachey + 3][cachex + 3] = rqp
} else { // HU.
s = this.yuv_cache[cachey + 3][cachex - 1] as base.u32
r = this.yuv_cache[cachey + 2][cachex - 1] as base.u32
q = this.yuv_cache[cachey + 1][cachex - 1] as base.u32
p = this.yuv_cache[cachey + 0][cachex - 1] as base.u32
sr = (((s + r + 1) / 2) & 0xFF) as base.u8
rq = (((r + q + 1) / 2) & 0xFF) as base.u8
qp = (((q + p + 1) / 2) & 0xFF) as base.u8
rqp = (((r + (2 * q) + p + 2) / 4) & 0xFF) as base.u8
srq = (((s + (2 * r) + q + 2) / 4) & 0xFF) as base.u8
ssr = (((s + (2 * s) + r + 2) / 4) & 0xFF) as base.u8
sss = (s & 0xFF) as base.u8
this.yuv_cache[cachey + 0][cachex + 0] = qp
this.yuv_cache[cachey + 0][cachex + 1] = rqp
this.yuv_cache[cachey + 0][cachex + 2] = rq
this.yuv_cache[cachey + 0][cachex + 3] = srq
this.yuv_cache[cachey + 1][cachex + 0] = rq
this.yuv_cache[cachey + 1][cachex + 1] = srq
this.yuv_cache[cachey + 1][cachex + 2] = sr
this.yuv_cache[cachey + 1][cachex + 3] = ssr
this.yuv_cache[cachey + 2][cachex + 0] = sr
this.yuv_cache[cachey + 2][cachex + 1] = ssr
this.yuv_cache[cachey + 2][cachex + 2] = sss
this.yuv_cache[cachey + 2][cachex + 3] = sss
this.yuv_cache[cachey + 3][cachex + 0] = sss
this.yuv_cache[cachey + 3][cachex + 1] = sss
this.yuv_cache[cachey + 3][cachex + 2] = sss
this.yuv_cache[cachey + 3][cachex + 3] = sss
}
}
pri func decoder.predict_y16!(mode: base.u32[..= 12]) {
var x : base.u32
var y : base.u32
var z : base.u32
var avg : base.u8
var val : base.u8
var tm0 : base.u32
var tm1 : base.u32
var tm2 : base.u32
if args.mode == 0 { // DC.
avg = ((16 +
(this.yuv_cache[0x00][0x08] as base.u32) +
(this.yuv_cache[0x00][0x09] as base.u32) +
(this.yuv_cache[0x00][0x0A] as base.u32) +
(this.yuv_cache[0x00][0x0B] as base.u32) +
(this.yuv_cache[0x00][0x0C] as base.u32) +
(this.yuv_cache[0x00][0x0D] as base.u32) +
(this.yuv_cache[0x00][0x0E] as base.u32) +
(this.yuv_cache[0x00][0x0F] as base.u32) +
(this.yuv_cache[0x00][0x10] as base.u32) +
(this.yuv_cache[0x00][0x11] as base.u32) +
(this.yuv_cache[0x00][0x12] as base.u32) +
(this.yuv_cache[0x00][0x13] as base.u32) +
(this.yuv_cache[0x00][0x14] as base.u32) +
(this.yuv_cache[0x00][0x15] as base.u32) +
(this.yuv_cache[0x00][0x16] as base.u32) +
(this.yuv_cache[0x00][0x17] as base.u32) +
(this.yuv_cache[0x01][0x07] as base.u32) +
(this.yuv_cache[0x02][0x07] as base.u32) +
(this.yuv_cache[0x03][0x07] as base.u32) +
(this.yuv_cache[0x04][0x07] as base.u32) +
(this.yuv_cache[0x05][0x07] as base.u32) +
(this.yuv_cache[0x06][0x07] as base.u32) +
(this.yuv_cache[0x07][0x07] as base.u32) +
(this.yuv_cache[0x08][0x07] as base.u32) +
(this.yuv_cache[0x09][0x07] as base.u32) +
(this.yuv_cache[0x0A][0x07] as base.u32) +
(this.yuv_cache[0x0B][0x07] as base.u32) +
(this.yuv_cache[0x0C][0x07] as base.u32) +
(this.yuv_cache[0x0D][0x07] as base.u32) +
(this.yuv_cache[0x0E][0x07] as base.u32) +
(this.yuv_cache[0x0F][0x07] as base.u32) +
(this.yuv_cache[0x10][0x07] as base.u32)) / 32) as base.u8
z = 0
while z < 256 {
this.yuv_cache[0x01 + (z >> 4)][0x08 + (z & 15)] = avg
z += 1
}
} else if args.mode == 1 { // TM.
tm0 = this.yuv_cache[0x00][0x07] as base.u32
z = 0
while z < 256 {
tm1 = this.yuv_cache[0x01 + (z >> 4)][0x07] as base.u32
tm2 = this.yuv_cache[0x00][0x08 + (z & 15)] as base.u32
this.yuv_cache[0x01 + (z >> 4)][0x08 + (z & 15)] =
CLAMP[((tm1 + tm2) ~mod- tm0) & 1023]
z += 1
}
} else if args.mode == 2 { // VE.
x = 0
while x < 16 {
val = this.yuv_cache[0x00][0x08 + x]
y = 0
while y < 16,
inv x < 16,
{
this.yuv_cache[0x01 + y][0x08 + x] = val
y += 1
}
x += 1
}
} else if args.mode == 3 { // HE.
y = 0
while y < 16 {
val = this.yuv_cache[0x01 + y][0x07]
x = 0
while x < 16,
inv y < 16,
{
this.yuv_cache[0x01 + y][0x08 + x] = val
x += 1
}
y += 1
}
} else if args.mode <= 10 { // DCTop.
avg = ((8 +
(this.yuv_cache[0x01][0x07] as base.u32) +
(this.yuv_cache[0x02][0x07] as base.u32) +
(this.yuv_cache[0x03][0x07] as base.u32) +
(this.yuv_cache[0x04][0x07] as base.u32) +
(this.yuv_cache[0x05][0x07] as base.u32) +
(this.yuv_cache[0x06][0x07] as base.u32) +
(this.yuv_cache[0x07][0x07] as base.u32) +
(this.yuv_cache[0x08][0x07] as base.u32) +
(this.yuv_cache[0x09][0x07] as base.u32) +
(this.yuv_cache[0x0A][0x07] as base.u32) +
(this.yuv_cache[0x0B][0x07] as base.u32) +
(this.yuv_cache[0x0C][0x07] as base.u32) +
(this.yuv_cache[0x0D][0x07] as base.u32) +
(this.yuv_cache[0x0E][0x07] as base.u32) +
(this.yuv_cache[0x0F][0x07] as base.u32) +
(this.yuv_cache[0x10][0x07] as base.u32)) / 16) as base.u8
z = 0
while z < 256 {
this.yuv_cache[0x01 + (z >> 4)][0x08 + (z & 15)] = avg
z += 1
}
} else if args.mode == 11 { // DCLeft.
avg = ((8 +
(this.yuv_cache[0x00][0x08] as base.u32) +
(this.yuv_cache[0x00][0x09] as base.u32) +
(this.yuv_cache[0x00][0x0A] as base.u32) +
(this.yuv_cache[0x00][0x0B] as base.u32) +
(this.yuv_cache[0x00][0x0C] as base.u32) +
(this.yuv_cache[0x00][0x0D] as base.u32) +
(this.yuv_cache[0x00][0x0E] as base.u32) +
(this.yuv_cache[0x00][0x0F] as base.u32) +
(this.yuv_cache[0x00][0x10] as base.u32) +
(this.yuv_cache[0x00][0x11] as base.u32) +
(this.yuv_cache[0x00][0x12] as base.u32) +
(this.yuv_cache[0x00][0x13] as base.u32) +
(this.yuv_cache[0x00][0x14] as base.u32) +
(this.yuv_cache[0x00][0x15] as base.u32) +
(this.yuv_cache[0x00][0x16] as base.u32) +
(this.yuv_cache[0x00][0x17] as base.u32)) / 16) as base.u8
z = 0
while z < 256 {
this.yuv_cache[0x01 + (z >> 4)][0x08 + (z & 15)] = avg
z += 1
}
} else { // DCTopLeft.
z = 0
while z < 256 {
this.yuv_cache[0x01 + (z >> 4)][0x08 + (z & 15)] = 0x80
z += 1
}
}
}
pri func decoder.predict_uv8!(b: base.u32[..= 1], mode: base.u32[..= 12]) {
var cachey : base.u32[..= 18]
var cachex : base.u32[..= 24]
var x : base.u32
var y : base.u32
var z : base.u32
var avg : base.u8
var val : base.u8
var tm0 : base.u32
var tm1 : base.u32
var tm2 : base.u32
cachey = 0x12
cachex = (args.b * 16) + 8
if args.mode == 0 { // DC.
avg = ((8 +
(this.yuv_cache[cachey - 1][cachex + 0] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 1] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 2] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 3] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 4] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 5] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 6] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 7] as base.u32) +
(this.yuv_cache[cachey + 0][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 1][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 2][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 3][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 4][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 5][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 6][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 7][cachex - 1] as base.u32)) / 16) as base.u8
z = 0
while z < 64 {
this.yuv_cache[cachey + (z >> 3)][cachex + (z & 7)] = avg
z += 1
}
} else if args.mode == 1 { // TM.
tm0 = this.yuv_cache[cachey - 1][cachex - 1] as base.u32
z = 0
while z < 64,
inv cachey == 0x12,
inv cachex >= 8,
{
tm1 = this.yuv_cache[cachey + (z >> 3)][cachex - 1] as base.u32
tm2 = this.yuv_cache[cachey - 1][cachex + (z & 7)] as base.u32
this.yuv_cache[cachey + (z >> 3)][cachex + (z & 7)] =
CLAMP[((tm1 + tm2) ~mod- tm0) & 1023]
z += 1
}
} else if args.mode == 2 { // VE.
x = 0
while x < 8,
inv cachey == 0x12,
inv cachex >= 8,
{
val = this.yuv_cache[cachey - 1][cachex + x]
y = 0
while y < 8,
inv cachey == 0x12,
inv cachex >= 8,
inv x < 8,
{
this.yuv_cache[cachey + y][cachex + x] = val
y += 1
}
x += 1
}
} else if args.mode == 3 { // HE.
y = 0
while y < 8,
inv cachey == 0x12,
inv cachex >= 8,
{
val = this.yuv_cache[cachey + y][cachex - 1]
x = 0
while x < 8,
inv cachey == 0x12,
inv cachex >= 8,
inv y < 8,
{
this.yuv_cache[cachey + y][cachex + x] = val
x += 1
}
y += 1
}
} else if args.mode <= 10 { // DCTop.
avg = ((4 +
(this.yuv_cache[cachey + 0][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 1][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 2][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 3][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 4][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 5][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 6][cachex - 1] as base.u32) +
(this.yuv_cache[cachey + 7][cachex - 1] as base.u32)) / 8) as base.u8
z = 0
while z < 64 {
this.yuv_cache[cachey + (z >> 3)][cachex + (z & 7)] = avg
z += 1
}
} else if args.mode == 11 { // DCLeft.
avg = ((4 +
(this.yuv_cache[cachey - 1][cachex + 0] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 1] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 2] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 3] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 4] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 5] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 6] as base.u32) +
(this.yuv_cache[cachey - 1][cachex + 7] as base.u32)) / 8) as base.u8
z = 0
while z < 64 {
this.yuv_cache[cachey + (z >> 3)][cachex + (z & 7)] = avg
z += 1
}
} else { // DCTopLeft.
z = 0
while z < 64 {
this.yuv_cache[cachey + (z >> 3)][cachex + (z & 7)] = 0x80
z += 1
}
}
}