Luce packages
LuceLuce BaseLuciaOS

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)