dymokomi/luce-webp
Source of release 0.1.0
0.1.0 / src / webp / vp8_filter.lucb
#==============================================================================================
#
# webp/vp8_filter - The loop filters and their strengths
#
# DESCRIPTION:
# Port of the edge filters of dsp/dec.c (paragraph 15: the simple filter, on luma
# only, and the complex filter, on luma and chroma, each on a macroblock's left and
# top edges and on its three inner edges each way), and of frame_dec.c's DoFilter
# and PrecomputeFilterStrengths. Each filter reads up to four samples on each side
# of an edge at `p`, `step` apart across it, and the filtered edges follow one
# another `stride` apart along it. libwebp's clipping tables become the clamps they
# hold.
#
#==============================================================================================
# mark: Clamps ================================================================================
## VP8ksclip1: `v` clamped to -128..127.
inline func sclip1(v: i32) -> i32:
return -128 if v < -128 else 127 if v > 127 else v
## VP8ksclip2: `v` clamped to -16..15.
inline func sclip2(v: i32) -> i32:
return -16 if v < -16 else 15 if v > 15 else v
## VP8kabs0.
inline func abs0(v: i32) -> i32:
return -v if v < 0 else v
# mark: Edges =================================================================================
## DoFilter2: four samples in, the two at the edge out.
inline func do_filter2(p: u8*, step: usize):
let p1 = (i32)(p - 2 * step)[0]
let p0 = (i32)(p - step)[0]
let q0 = (i32)p[0]
let q1 = (i32)p[step]
let a = 3 * (q0 - p0) + sclip1(p1 - q1)
let a1 = sclip2((a + 4) >> 3)
let a2 = sclip2((a + 3) >> 3)
(p - step)[0] = clip_255(p0 + a2)
p[0] = clip_255(q0 - a1)
## DoFilter4: four samples in, four out.
inline func do_filter4(p: u8*, step: usize):
let p1 = (i32)(p - 2 * step)[0]
let p0 = (i32)(p - step)[0]
let q0 = (i32)p[0]
let q1 = (i32)p[step]
let a = 3 * (q0 - p0)
let a1 = sclip2((a + 4) >> 3)
let a2 = sclip2((a + 3) >> 3)
let a3 = (a1 + 1) >> 1
(p - 2 * step)[0] = clip_255(p1 + a3)
(p - step)[0] = clip_255(p0 + a2)
p[0] = clip_255(q0 - a1)
p[step] = clip_255(q1 - a3)
## DoFilter6: six samples in, six out.
inline func do_filter6(p: u8*, step: usize):
let p2 = (i32)(p - 3 * step)[0]
let p1 = (i32)(p - 2 * step)[0]
let p0 = (i32)(p - step)[0]
let q0 = (i32)p[0]
let q1 = (i32)p[step]
let q2 = (i32)p[2 * step]
let a = sclip1(3 * (q0 - p0) + sclip1(p1 - q1))
# a is in [-128,127], a1 in [-27,27], a2 in [-18,18] and a3 in [-9,9].
let a1 = (27 * a + 63) >> 7
let a2 = (18 * a + 63) >> 7
let a3 = (9 * a + 63) >> 7
(p - 3 * step)[0] = clip_255(p2 + a3)
(p - 2 * step)[0] = clip_255(p1 + a2)
(p - step)[0] = clip_255(p0 + a1)
p[0] = clip_255(q0 - a1)
p[step] = clip_255(q1 - a2)
p[2 * step] = clip_255(q2 - a3)
## Hev: whether the edge has high variance.
inline func hev(p: const u8*, step: usize, thresh: i32) -> bool:
let p1 = (i32)(p - 2 * step)[0]
let p0 = (i32)(p - step)[0]
let q0 = (i32)p[0]
let q1 = (i32)p[step]
return abs0(p1 - p0) > thresh or abs0(q1 - q0) > thresh
## NeedsFilter: whether the simple filter applies.
inline func needs_filter(p: const u8*, step: usize, t: i32) -> bool:
let p1 = (i32)(p - 2 * step)[0]
let p0 = (i32)(p - step)[0]
let q0 = (i32)p[0]
let q1 = (i32)p[step]
return 4 * abs0(p0 - q0) + abs0(p1 - q1) <= t
## NeedsFilter2: whether the complex filter applies.
inline func needs_filter2(p: const u8*, step: usize, t: i32, it: i32) -> bool:
let p3 = (i32)(p - 4 * step)[0]
let p2 = (i32)(p - 3 * step)[0]
let p1 = (i32)(p - 2 * step)[0]
let p0 = (i32)(p - step)[0]
let q0 = (i32)p[0]
let q1 = (i32)p[step]
let q2 = (i32)p[2 * step]
let q3 = (i32)p[3 * step]
if 4 * abs0(p0 - q0) + abs0(p1 - q1) > t:
return false
return abs0(p3 - p2) <= it and abs0(p2 - p1) <= it and abs0(p1 - p0) <= it and abs0(q3 - q2) <= it and abs0(q2 - q1) <= it and abs0(q1 - q0) <= it
# mark: Simple filter =========================================================================
## SimpleVFilter16: the horizontal edge above `p`, 16 samples wide.
func simple_v_filter16(p: u8*, stride: usize, thresh: i32):
let thresh2 = 2 * thresh + 1
for i in 0..<(usize)16:
if needs_filter(p + i, stride, thresh2):
do_filter2(p + i, stride)
## SimpleHFilter16: the vertical edge left of `p`, 16 samples high.
func simple_h_filter16(p: u8*, stride: usize, thresh: i32):
let thresh2 = 2 * thresh + 1
for i in 0..<(usize)16:
if needs_filter(p + i * stride, 1, thresh2):
do_filter2(p + i * stride, 1)
## SimpleVFilter16i: the three inner horizontal edges.
func simple_v_filter16i(p: u8*, stride: usize, thresh: i32):
for k in 1..<(usize)4:
simple_v_filter16(p + 4 * k * stride, stride, thresh)
## SimpleHFilter16i: the three inner vertical edges.
func simple_h_filter16i(p: u8*, stride: usize, thresh: i32):
for k in 1..<(usize)4:
simple_h_filter16(p + 4 * k, stride, thresh)
# mark: Complex filter ========================================================================
## FilterLoop26: a macroblock edge, `size` samples along it.
func filter_loop26(p: u8*, hstride: usize, vstride: usize, size: usize, thresh: i32, ithresh: i32, hev_thresh: i32):
let thresh2 = 2 * thresh + 1
var at = p
for i in 0..<size:
if needs_filter2(at, hstride, thresh2, ithresh):
if hev(at, hstride, hev_thresh):
do_filter2(at, hstride)
else:
do_filter6(at, hstride)
at = at + vstride
## FilterLoop24: an inner edge, `size` samples along it.
func filter_loop24(p: u8*, hstride: usize, vstride: usize, size: usize, thresh: i32, ithresh: i32, hev_thresh: i32):
let thresh2 = 2 * thresh + 1
var at = p
for i in 0..<size:
if needs_filter2(at, hstride, thresh2, ithresh):
if hev(at, hstride, hev_thresh):
do_filter2(at, hstride)
else:
do_filter4(at, hstride)
at = at + vstride
# mark: Macroblocks ===========================================================================
## DoFilter: the edges of macroblock (`mb_x`, `mb_y`) in the row cache.
func filter_macroblock(dec: const Vp8*, fb: FrameBuffers*, mb_x: usize, mb_y: usize):
let y_bps = fb.cache_y_stride
let strength = fb.f_info[mb_x]
let y_dst = fb.cache_y + mb_x * 16
let ilevel = (i32)strength.ilevel
let edge_limit = (i32)strength.limit
if edge_limit == 0:
return
if dec.filter_type == 1:
# The simple filter.
if mb_x > 0:
simple_h_filter16(y_dst, y_bps, edge_limit + 4)
if strength.inner:
simple_h_filter16i(y_dst, y_bps, edge_limit)
if mb_y > 0:
simple_v_filter16(y_dst, y_bps, edge_limit + 4)
if strength.inner:
simple_v_filter16i(y_dst, y_bps, edge_limit)
return
# The complex filter.
let uv_bps = fb.cache_uv_stride
let u_dst = fb.cache_u + mb_x * 8
let v_dst = fb.cache_v + mb_x * 8
let hev_thresh = (i32)strength.hev_thresh
if mb_x > 0:
filter_loop26(y_dst, 1, y_bps, 16, edge_limit + 4, ilevel, hev_thresh)
filter_loop26(u_dst, 1, uv_bps, 8, edge_limit + 4, ilevel, hev_thresh)
filter_loop26(v_dst, 1, uv_bps, 8, edge_limit + 4, ilevel, hev_thresh)
if strength.inner:
for k in 1..<(usize)4:
filter_loop24(y_dst + 4 * k, 1, y_bps, 16, edge_limit, ilevel, hev_thresh)
filter_loop24(u_dst + 4, 1, uv_bps, 8, edge_limit, ilevel, hev_thresh)
filter_loop24(v_dst + 4, 1, uv_bps, 8, edge_limit, ilevel, hev_thresh)
if mb_y > 0:
filter_loop26(y_dst, y_bps, 1, 16, edge_limit + 4, ilevel, hev_thresh)
filter_loop26(u_dst, uv_bps, 1, 8, edge_limit + 4, ilevel, hev_thresh)
filter_loop26(v_dst, uv_bps, 1, 8, edge_limit + 4, ilevel, hev_thresh)
if strength.inner:
for k in 1..<(usize)4:
filter_loop24(y_dst + 4 * k * y_bps, y_bps, 1, 16, edge_limit, ilevel, hev_thresh)
filter_loop24(u_dst + 4 * uv_bps, uv_bps, 1, 8, edge_limit, ilevel, hev_thresh)
filter_loop24(v_dst + 4 * uv_bps, uv_bps, 1, 8, edge_limit, ilevel, hev_thresh)
## FilterRow: the edges of the decoded macroblock row.
func filter_macroblock_row(dec: const Vp8*, fb: FrameBuffers*, mb_y: usize):
for mb_x in dec.tl_mb_x..<dec.br_mb_x:
filter_macroblock(dec, fb, mb_x, mb_y)
## PrecomputeFilterStrengths: each segment's strengths, for 16x16 and 4x4 macroblocks
## (`fstrengths[segment * 2 + is_i4x4]`).
func precompute_filter_strengths(dec: Vp8*):
if dec.filter_type == 0:
return
let hdr = &dec.filter_hdr
for s in 0..<num_mb_segments:
# The initial level.
var base_level: i32 = 0
if dec.segment_hdr.use_segment:
base_level = dec.segment_hdr.filter_strength[s]
if not dec.segment_hdr.absolute_delta:
base_level += hdr.level
else:
base_level = hdr.level
for i4x4 in 0..<(usize)2:
var strength = FilterInfo()
var level = base_level
if hdr.use_lf_delta:
level += hdr.ref_lf_delta[0]
if i4x4 == 1:
level += hdr.mode_lf_delta[0]
level = 0 if level < 0 else 63 if level > 63 else level
if level > 0:
var ilevel = level
if hdr.sharpness > 0:
if hdr.sharpness > 4:
ilevel >>= 2
else:
ilevel >>= 1
if ilevel > 9 - hdr.sharpness:
ilevel = 9 - hdr.sharpness
if ilevel < 1:
ilevel = 1
strength.ilevel = (u8)ilevel
strength.limit = (u8)(2 * level + ilevel)
strength.hev_thresh = 2 if level >= 40 else 1 if level >= 15 else 0
strength.inner = i4x4 == 1
dec.fstrengths[s * 2 + i4x4] = strength