dymokomi/luce-webp
Source of release 0.1.0
0.1.0 / src / webp / vp8_predict.lucb
#==============================================================================================
#
# webp/vp8_predict - Intra prediction
#
# DESCRIPTION:
# Port of the intra predictors of dsp/dec.c (paragraph 12): 16x16 luma, 8x8 chroma
# and 4x4 luma predictions, each written in place in the prediction work area,
# whose stride is `bps`. The samples above a block are at `dst - bps` and those to
# its left at `dst - 1`; the corner is at `dst - bps - 1`, and for 4x4 blocks four
# more top samples follow the top row.
#
#==============================================================================================
# mark: Helpers ===============================================================================
## Copy `count` bytes from `source` to `target`.
inline func copy_bytes(target: u8*, source: const u8*, count: usize):
memory.copy(u8[](target, count), u8[]((u8*)source, count), count)
## Set `count` bytes at `target` to `value`.
inline func fill_bytes(target: u8*, value: u8, count: usize):
memory.set(u8[](target, count), value)
## `v` clipped to 0..255 (VP8kclip1, clip_8b).
inline func clip_255(v: i32) -> u8:
return (u8)v if (v & ~255) == 0 else 0 if v < 0 else 255
## AVG3 of three samples.
inline func avg3(a: i32, b: i32, c: i32) -> u8:
return (u8)((a + 2 * b + c + 2) >> 2)
## AVG2 of two samples.
inline func avg2(a: i32, b: i32) -> u8:
return (u8)((a + b + 1) >> 1)
## The sample at column `x` of row `y` relative to `dst`, where `y` may be -1.
inline func sample_at(dst: u8*, x: usize, y: usize) -> u8*:
return dst + x + y * bps
# mark: TrueMotion ============================================================================
## TrueMotion: each sample is left + top - corner, clipped (TM4, TM8uv, TM16).
func true_motion(dst: u8*, size: usize):
let top = dst - bps
let corner = (i32)(top - 1)[0]
var row = dst
for y in 0..<size:
let left = (i32)(row - 1)[0] - corner
for x in 0..<size:
row[x] = clip_255(left + (i32)top[x])
row = row + bps
# mark: 16x16 =================================================================================
## VE16: every row is the row above.
func ve16(dst: u8*):
for j in 0..<(usize)16:
copy_bytes(dst + j * bps, dst - bps, 16)
## HE16: every row is its left sample.
func he16(dst: u8*):
for j in 0..<(usize)16:
let row = dst + j * bps
fill_bytes(row, (row - 1)[0], 16)
## Put16: the 16x16 block filled with `v`.
func put16(v: u8, dst: u8*):
for j in 0..<(usize)16:
fill_bytes(dst + j * bps, v, 16)
## DC16: the average of the 16 top and 16 left samples.
func dc16(dst: u8*):
var dc: i32 = 16
for j in 0..<(usize)16:
dc += (i32)(dst - 1)[j * bps] + (i32)(dst - bps)[j]
put16((u8)(dc >> 5), dst)
## DC16NoTop: the average of the left samples.
func dc16_no_top(dst: u8*):
var dc: i32 = 8
for j in 0..<(usize)16:
dc += (i32)(dst - 1)[j * bps]
put16((u8)(dc >> 4), dst)
## DC16NoLeft: the average of the top samples.
func dc16_no_left(dst: u8*):
var dc: i32 = 8
for i in 0..<(usize)16:
dc += (i32)(dst - bps)[i]
put16((u8)(dc >> 4), dst)
## VP8PredLuma16[mode].
func predict_luma16(mode: u8, dst: u8*):
match mode:
0:
dc16(dst)
1:
true_motion(dst, 16)
2:
ve16(dst)
3:
he16(dst)
4:
dc16_no_top(dst)
5:
dc16_no_left(dst)
_:
put16(0x80, dst)
# mark: Chroma ================================================================================
## Put8x8uv: the 8x8 block filled with `v`.
func put8x8uv(v: u8, dst: u8*):
for j in 0..<(usize)8:
fill_bytes(dst + j * bps, v, 8)
## VP8PredChroma8[mode].
func predict_chroma8(mode: u8, dst: u8*):
match mode:
0:
var dc0: i32 = 8
for i in 0..<(usize)8:
dc0 += (i32)(dst - bps)[i] + (i32)(dst - 1)[i * bps]
put8x8uv((u8)(dc0 >> 4), dst)
1:
true_motion(dst, 8)
2:
for j in 0..<(usize)8:
copy_bytes(dst + j * bps, dst - bps, 8)
3:
for j in 0..<(usize)8:
let row = dst + j * bps
fill_bytes(row, (row - 1)[0], 8)
4:
# DC8uvNoTop.
var dc0: i32 = 4
for i in 0..<(usize)8:
dc0 += (i32)(dst - 1)[i * bps]
put8x8uv((u8)(dc0 >> 3), dst)
5:
# DC8uvNoLeft.
var dc0: i32 = 4
for i in 0..<(usize)8:
dc0 += (i32)(dst - bps)[i]
put8x8uv((u8)(dc0 >> 3), dst)
_:
put8x8uv(0x80, dst)
# mark: 4x4 ===================================================================================
## VE4: the row above, smoothed.
func ve4(dst: u8*):
let top = dst - bps
let corner = (i32)(top - 1)[0]
let vals: u8[4] = [avg3(corner, (i32)top[0], (i32)top[1]), avg3((i32)top[0], (i32)top[1], (i32)top[2]), avg3((i32)top[1], (i32)top[2], (i32)top[3]), avg3((i32)top[2], (i32)top[3], (i32)top[4])]
for i in 0..<(usize)4:
let row = dst + i * bps
row[0] = vals[0]
row[1] = vals[1]
row[2] = vals[2]
row[3] = vals[3]
## HE4: the left column, smoothed.
func he4(dst: u8*):
let left = dst - 1
let a = (i32)(left - bps)[0]
let b = (i32)left[0]
let c = (i32)left[bps]
let d = (i32)left[2 * bps]
let e = (i32)left[3 * bps]
fill_bytes(dst, avg3(a, b, c), 4)
fill_bytes(dst + bps, avg3(b, c, d), 4)
fill_bytes(dst + 2 * bps, avg3(c, d, e), 4)
fill_bytes(dst + 3 * bps, avg3(d, e, e), 4)
## DC4: the average of the four top and four left samples.
func dc4(dst: u8*):
var dc: i32 = 4
for i in 0..<(usize)4:
dc += (i32)(dst - bps)[i] + (i32)(dst - 1)[i * bps]
let v = (u8)(dc >> 3)
for i in 0..<(usize)4:
fill_bytes(dst + i * bps, v, 4)
## RD4: down-right.
func rd4(dst: u8*):
let left = dst - 1
let top = dst - bps
let i = (i32)left[0]
let j = (i32)left[bps]
let k = (i32)left[2 * bps]
let l = (i32)left[3 * bps]
let x = (i32)(top - 1)[0]
let a = (i32)top[0]
let b = (i32)top[1]
let c = (i32)top[2]
let d = (i32)top[3]
sample_at(dst, 0, 3)[0] = avg3(j, k, l)
let ijk = avg3(i, j, k)
sample_at(dst, 1, 3)[0] = ijk
sample_at(dst, 0, 2)[0] = ijk
let xij = avg3(x, i, j)
sample_at(dst, 2, 3)[0] = xij
sample_at(dst, 1, 2)[0] = xij
sample_at(dst, 0, 1)[0] = xij
let axi = avg3(a, x, i)
sample_at(dst, 3, 3)[0] = axi
sample_at(dst, 2, 2)[0] = axi
sample_at(dst, 1, 1)[0] = axi
sample_at(dst, 0, 0)[0] = axi
let bax = avg3(b, a, x)
sample_at(dst, 3, 2)[0] = bax
sample_at(dst, 2, 1)[0] = bax
sample_at(dst, 1, 0)[0] = bax
let cba = avg3(c, b, a)
sample_at(dst, 3, 1)[0] = cba
sample_at(dst, 2, 0)[0] = cba
sample_at(dst, 3, 0)[0] = avg3(d, c, b)
## LD4: down-left.
func ld4(dst: u8*):
let top = dst - bps
let a = (i32)top[0]
let b = (i32)top[1]
let c = (i32)top[2]
let d = (i32)top[3]
let e = (i32)top[4]
let f = (i32)top[5]
let g = (i32)top[6]
let h = (i32)top[7]
sample_at(dst, 0, 0)[0] = avg3(a, b, c)
let bcd = avg3(b, c, d)
sample_at(dst, 1, 0)[0] = bcd
sample_at(dst, 0, 1)[0] = bcd
let cde = avg3(c, d, e)
sample_at(dst, 2, 0)[0] = cde
sample_at(dst, 1, 1)[0] = cde
sample_at(dst, 0, 2)[0] = cde
let def = avg3(d, e, f)
sample_at(dst, 3, 0)[0] = def
sample_at(dst, 2, 1)[0] = def
sample_at(dst, 1, 2)[0] = def
sample_at(dst, 0, 3)[0] = def
let efg = avg3(e, f, g)
sample_at(dst, 3, 1)[0] = efg
sample_at(dst, 2, 2)[0] = efg
sample_at(dst, 1, 3)[0] = efg
let fgh = avg3(f, g, h)
sample_at(dst, 3, 2)[0] = fgh
sample_at(dst, 2, 3)[0] = fgh
sample_at(dst, 3, 3)[0] = avg3(g, h, h)
## VR4: vertical-right.
func vr4(dst: u8*):
let left = dst - 1
let top = dst - bps
let i = (i32)left[0]
let j = (i32)left[bps]
let k = (i32)left[2 * bps]
let x = (i32)(top - 1)[0]
let a = (i32)top[0]
let b = (i32)top[1]
let c = (i32)top[2]
let d = (i32)top[3]
let xa = avg2(x, a)
sample_at(dst, 0, 0)[0] = xa
sample_at(dst, 1, 2)[0] = xa
let ab = avg2(a, b)
sample_at(dst, 1, 0)[0] = ab
sample_at(dst, 2, 2)[0] = ab
let bc = avg2(b, c)
sample_at(dst, 2, 0)[0] = bc
sample_at(dst, 3, 2)[0] = bc
sample_at(dst, 3, 0)[0] = avg2(c, d)
sample_at(dst, 0, 3)[0] = avg3(k, j, i)
sample_at(dst, 0, 2)[0] = avg3(j, i, x)
let ixa = avg3(i, x, a)
sample_at(dst, 0, 1)[0] = ixa
sample_at(dst, 1, 3)[0] = ixa
let xab = avg3(x, a, b)
sample_at(dst, 1, 1)[0] = xab
sample_at(dst, 2, 3)[0] = xab
let abc = avg3(a, b, c)
sample_at(dst, 2, 1)[0] = abc
sample_at(dst, 3, 3)[0] = abc
sample_at(dst, 3, 1)[0] = avg3(b, c, d)
## VL4: vertical-left.
func vl4(dst: u8*):
let top = dst - bps
let a = (i32)top[0]
let b = (i32)top[1]
let c = (i32)top[2]
let d = (i32)top[3]
let e = (i32)top[4]
let f = (i32)top[5]
let g = (i32)top[6]
let h = (i32)top[7]
sample_at(dst, 0, 0)[0] = avg2(a, b)
let bc = avg2(b, c)
sample_at(dst, 1, 0)[0] = bc
sample_at(dst, 0, 2)[0] = bc
let cd = avg2(c, d)
sample_at(dst, 2, 0)[0] = cd
sample_at(dst, 1, 2)[0] = cd
let de = avg2(d, e)
sample_at(dst, 3, 0)[0] = de
sample_at(dst, 2, 2)[0] = de
sample_at(dst, 0, 1)[0] = avg3(a, b, c)
let bcd = avg3(b, c, d)
sample_at(dst, 1, 1)[0] = bcd
sample_at(dst, 0, 3)[0] = bcd
let cde = avg3(c, d, e)
sample_at(dst, 2, 1)[0] = cde
sample_at(dst, 1, 3)[0] = cde
let def = avg3(d, e, f)
sample_at(dst, 3, 1)[0] = def
sample_at(dst, 2, 3)[0] = def
sample_at(dst, 3, 2)[0] = avg3(e, f, g)
sample_at(dst, 3, 3)[0] = avg3(f, g, h)
## HU4: horizontal-up.
func hu4(dst: u8*):
let left = dst - 1
let i = (i32)left[0]
let j = (i32)left[bps]
let k = (i32)left[2 * bps]
let l = (i32)left[3 * bps]
sample_at(dst, 0, 0)[0] = avg2(i, j)
let jk = avg2(j, k)
sample_at(dst, 2, 0)[0] = jk
sample_at(dst, 0, 1)[0] = jk
let kl = avg2(k, l)
sample_at(dst, 2, 1)[0] = kl
sample_at(dst, 0, 2)[0] = kl
sample_at(dst, 1, 0)[0] = avg3(i, j, k)
let jkl = avg3(j, k, l)
sample_at(dst, 3, 0)[0] = jkl
sample_at(dst, 1, 1)[0] = jkl
let kll = avg3(k, l, l)
sample_at(dst, 3, 1)[0] = kll
sample_at(dst, 1, 2)[0] = kll
let ll = (u8)l
sample_at(dst, 3, 2)[0] = ll
sample_at(dst, 2, 2)[0] = ll
sample_at(dst, 0, 3)[0] = ll
sample_at(dst, 1, 3)[0] = ll
sample_at(dst, 2, 3)[0] = ll
sample_at(dst, 3, 3)[0] = ll
## HD4: horizontal-down.
func hd4(dst: u8*):
let left = dst - 1
let top = dst - bps
let i = (i32)left[0]
let j = (i32)left[bps]
let k = (i32)left[2 * bps]
let l = (i32)left[3 * bps]
let x = (i32)(top - 1)[0]
let a = (i32)top[0]
let b = (i32)top[1]
let c = (i32)top[2]
let ix = avg2(i, x)
sample_at(dst, 0, 0)[0] = ix
sample_at(dst, 2, 1)[0] = ix
let ji = avg2(j, i)
sample_at(dst, 0, 1)[0] = ji
sample_at(dst, 2, 2)[0] = ji
let kj = avg2(k, j)
sample_at(dst, 0, 2)[0] = kj
sample_at(dst, 2, 3)[0] = kj
sample_at(dst, 0, 3)[0] = avg2(l, k)
sample_at(dst, 3, 0)[0] = avg3(a, b, c)
sample_at(dst, 2, 0)[0] = avg3(x, a, b)
let ixa = avg3(i, x, a)
sample_at(dst, 1, 0)[0] = ixa
sample_at(dst, 3, 1)[0] = ixa
let jix = avg3(j, i, x)
sample_at(dst, 1, 1)[0] = jix
sample_at(dst, 3, 2)[0] = jix
let kji = avg3(k, j, i)
sample_at(dst, 1, 2)[0] = kji
sample_at(dst, 3, 3)[0] = kji
sample_at(dst, 1, 3)[0] = avg3(l, k, j)
## VP8PredLuma4[mode].
func predict_luma4(mode: u8, dst: u8*):
match mode:
0:
dc4(dst)
1:
true_motion(dst, 4)
2:
ve4(dst)
3:
he4(dst)
4:
rd4(dst)
5:
vr4(dst)
6:
ld4(dst)
7:
vl4(dst)
8:
hd4(dst)
_:
hu4(dst)