dymokomi/luce-browser-render
Source of release 0.6.1
0.6.1 / src / raster / lowp_stages.lucb
#==============================================================================================
#
# lowp_stages - the blend and shader stages of the low precision pipeline
#
# DESCRIPTION:
# Port of tiny-skia pipeline/lowp.rs, part 2, as Skia m144's lowp stages compute
# them on NEON: the blend modes in u16 math (div255), the matrix stages, the x1
# tiling stages and the gradient stages (gradient lookup, evenly spaced gradients,
# sweep angle, radius) with round_F_to_U16.
#
# Copyright (c) 2018 Google Inc. All rights reserved.
# Copyright (c) 2020 Yevhenii Reizner All rights reserved.
# SPDX-License-Identifier: BSD-3-Clause (see LICENSE-skia, LICENSE-tiny-skia)
#
#==============================================================================================
# The blend kernels work on one half (8 lanes) of the u16x16 registers, called directly per
# half by the stage: through a function pointer on whole registers they were several times
# slower.
func lowp_blend_fn(p: LowpPipeline*, f: func(U16x8, U16x8, U16x8, U16x8) -> U16x8):
for h: usize in 0..<2:
let sa = p.a[h]
let da = p.da[h]
p.r[h] = f(p.r[h], p.dr[h], sa, da)
p.g[h] = f(p.g[h], p.dg[h], sa, da)
p.b[h] = f(p.b[h], p.db[h], sa, da)
p.a[h] = f(sa, da, sa, da)
lowp_next_stage(p)
# The same logic applied to color, and source_over for alpha.
func lowp_blend_fn2(p: LowpPipeline*, f: func(U16x8, U16x8, U16x8, U16x8) -> U16x8):
for h: usize in 0..<2:
let sa = p.a[h]
let da = p.da[h]
p.r[h] = f(p.r[h], p.dr[h], sa, da)
p.g[h] = f(p.g[h], p.dg[h], sa, da)
p.b[h] = f(p.b[h], p.db[h], sa, da)
p.a[h] = sa +% div255(da *% lowp_inv(sa))
lowp_next_stage(p)
# mark: blend_fn! =============================================================================
func lowp_clear_k(_s: U16x8, _d: U16x8, _sa: U16x8, _da: U16x8) -> U16x8:
return u16[8](0)
func lowp_source_atop_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
return div255(s *% da +% d *% lowp_inv(sa))
func lowp_destination_atop_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
return div255(d *% sa +% s *% lowp_inv(da))
func lowp_source_in_k(s: U16x8, _d: U16x8, _sa: U16x8, da: U16x8) -> U16x8:
return div255(s *% da)
func lowp_destination_in_k(_s: U16x8, d: U16x8, sa: U16x8, _da: U16x8) -> U16x8:
return div255(d *% sa)
func lowp_source_out_k(s: U16x8, _d: U16x8, _sa: U16x8, da: U16x8) -> U16x8:
return div255(s *% lowp_inv(da))
func lowp_destination_out_k(_s: U16x8, d: U16x8, sa: U16x8, _da: U16x8) -> U16x8:
return div255(d *% lowp_inv(sa))
func lowp_destination_over_k(s: U16x8, d: U16x8, _sa: U16x8, da: U16x8) -> U16x8:
return d +% div255(s *% lowp_inv(da))
func lowp_modulate_k(s: U16x8, d: U16x8, _sa: U16x8, _da: U16x8) -> U16x8:
return div255(s *% d)
func lowp_multiply_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
return div255(s *% lowp_inv(da) +% d *% lowp_inv(sa) +% s *% d)
func lowp_screen_k(s: U16x8, d: U16x8, _sa: U16x8, _da: U16x8) -> U16x8:
return s +% d -% div255(s *% d)
func lowp_xor_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
return div255(s *% lowp_inv(da) +% d *% lowp_inv(sa))
func lowp_plus_k(s: U16x8, d: U16x8, _sa: U16x8, _da: U16x8) -> U16x8:
return u16x8_min(s +% d, u16[8](255))
func lowp_clear(p: LowpPipeline*):
lowp_blend_fn(p, lowp_clear_k)
func lowp_source_atop(p: LowpPipeline*):
lowp_blend_fn(p, lowp_source_atop_k)
func lowp_destination_atop(p: LowpPipeline*):
lowp_blend_fn(p, lowp_destination_atop_k)
func lowp_source_in(p: LowpPipeline*):
lowp_blend_fn(p, lowp_source_in_k)
func lowp_destination_in(p: LowpPipeline*):
lowp_blend_fn(p, lowp_destination_in_k)
func lowp_source_out(p: LowpPipeline*):
lowp_blend_fn(p, lowp_source_out_k)
func lowp_destination_out(p: LowpPipeline*):
lowp_blend_fn(p, lowp_destination_out_k)
func lowp_source_over(p: LowpPipeline*):
lowp_source_over_math(p)
lowp_next_stage(p)
func lowp_source_over_math(p: LowpPipeline*):
for h: usize in 0..<2:
let inv_a = lowp_inv(p.a[h])
p.r[h] = p.r[h] +% div255(p.dr[h] *% inv_a)
p.g[h] = p.g[h] +% div255(p.dg[h] *% inv_a)
p.b[h] = p.b[h] +% div255(p.db[h] *% inv_a)
p.a[h] = p.a[h] +% div255(p.da[h] *% inv_a)
func lowp_destination_over(p: LowpPipeline*):
lowp_blend_fn(p, lowp_destination_over_k)
func lowp_modulate(p: LowpPipeline*):
lowp_blend_fn(p, lowp_modulate_k)
func lowp_multiply(p: LowpPipeline*):
lowp_blend_fn(p, lowp_multiply_k)
func lowp_screen(p: LowpPipeline*):
lowp_blend_fn(p, lowp_screen_k)
func lowp_xor(p: LowpPipeline*):
lowp_blend_fn(p, lowp_xor_k)
func lowp_plus(p: LowpPipeline*):
lowp_blend_fn(p, lowp_plus_k)
# mark: blend_fn2! ============================================================================
func lowp_darken_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
return s +% d -% div255(u16x8_max(s *% da, d *% sa))
func lowp_lighten_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
return s +% d -% div255(u16x8_min(s *% da, d *% sa))
func lowp_exclusion_k(s: U16x8, d: U16x8, _sa: U16x8, _da: U16x8) -> U16x8:
return s +% d -% u16[8](2) *% div255(s *% d)
func lowp_difference_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
return s +% d -% u16[8](2) *% div255(u16x8_min(s *% da, d *% sa))
func lowp_hard_light_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
let two = u16[8](2)
return div255(s *% lowp_inv(da) +% d *% lowp_inv(sa) +% u16x8_blend(u16x8_cmp_le(s +% s, sa), two *% s *% d, sa *% da -% two *% (sa -% s) *% (da -% d)))
func lowp_overlay_k(s: U16x8, d: U16x8, sa: U16x8, da: U16x8) -> U16x8:
let two = u16[8](2)
return div255(s *% lowp_inv(da) +% d *% lowp_inv(sa) +% u16x8_blend(u16x8_cmp_le(d +% d, da), two *% s *% d, sa *% da -% two *% (sa -% s) *% (da -% d)))
func lowp_darken(p: LowpPipeline*):
lowp_blend_fn2(p, lowp_darken_k)
func lowp_lighten(p: LowpPipeline*):
lowp_blend_fn2(p, lowp_lighten_k)
func lowp_exclusion(p: LowpPipeline*):
lowp_blend_fn2(p, lowp_exclusion_k)
func lowp_difference(p: LowpPipeline*):
lowp_blend_fn2(p, lowp_difference_k)
func lowp_hard_light(p: LowpPipeline*):
lowp_blend_fn2(p, lowp_hard_light_k)
func lowp_overlay(p: LowpPipeline*):
lowp_blend_fn2(p, lowp_overlay_k)
# mark: Matrices ==============================================================================
# Coordinates are f32x16 (`F16`, four F4 quarters) carried in the u16 registers. lowp's mad
# rounds twice.
# matrix_2x3 (matrix_translate and matrix_scale_translate compute the same values).
func lowp_transform(p: LowpPipeline*):
let ts = p.ctx.transform
let x = lowp_join(p.r, p.g)
let y = lowp_join(p.b, p.a)
var nx: F16 = ---
var ny: F16 = ---
for q: usize in 0..<4:
nx[q] = lowp_mad(x[q], f32[4](ts.sx), lowp_mad(y[q], f32[4](ts.kx), f32[4](ts.tx)))
ny[q] = lowp_mad(x[q], f32[4](ts.ky), lowp_mad(y[q], f32[4](ts.sy), f32[4](ts.ty)))
lowp_split(nx, &p.r, &p.g)
lowp_split(ny, &p.b, &p.a)
lowp_next_stage(p)
# matrix_perspective: the row-major 3x3 matrix, then the divide by its z.
func lowp_transform_perspective(p: LowpPipeline*):
let m = p.ctx.transform
let x = lowp_join(p.r, p.g)
let y = lowp_join(p.b, p.a)
var nx: F16 = ---
var ny: F16 = ---
for q: usize in 0..<4:
let tx = lowp_mad(x[q], f32[4](m.sx), lowp_mad(y[q], f32[4](m.kx), f32[4](m.tx)))
let ty = lowp_mad(x[q], f32[4](m.ky), lowp_mad(y[q], f32[4](m.sy), f32[4](m.ty)))
let tz = lowp_mad(x[q], f32[4](m.persp0), lowp_mad(y[q], f32[4](m.persp1), f32[4](m.persp2)))
nx[q] = tx * f4_rcp_precise(tz)
ny[q] = ty * f4_rcp_precise(tz)
lowp_split(nx, &p.r, &p.g)
lowp_split(ny, &p.b, &p.a)
lowp_next_stage(p)
# matrix_scale_translate with a unit y scale (y = y * 1 + 0 is y).
func lowp_scale_translate_x(p: LowpPipeline*):
let m = p.ctx.scale_translate_x
var x = lowp_join(p.r, p.g)
for q: usize in 0..<4:
x[q] = lowp_mad(x[q], f32[4](m.sx), f32[4](m.tx))
lowp_split(x, &p.r, &p.g)
lowp_next_stage(p)
# mark: Tiling ================================================================================
# Clamp x to [0,1], both sides inclusive (think, gradients). Even repeat and mirror funnel
# through a clamp to handle bad inputs like +Inf, NaN.
func lowp_clamp_x_1(p: LowpPipeline*):
var x = lowp_join(p.r, p.g)
for q: usize in 0..<4:
x[q] = lowp_clamp_01_(x[q])
lowp_split(x, &p.r, &p.g)
lowp_next_stage(p)
func lowp_repeat_x_1(p: LowpPipeline*):
var x = lowp_join(p.r, p.g)
for q: usize in 0..<4:
x[q] = lowp_clamp_01_(x[q] - f4_vfloor(x[q]))
lowp_split(x, &p.r, &p.g)
lowp_next_stage(p)
func lowp_mirror_x_1(p: LowpPipeline*):
var x = lowp_join(p.r, p.g)
let one = f32[4](1.0)
for q: usize in 0..<4:
let fl = f4_vfloor((x[q] - one) * f32[4](0.5))
x[q] = lowp_clamp_01_(f4_abs((x[q] - one) - (fl + fl) - one))
lowp_split(x, &p.r, &p.g)
lowp_next_stage(p)
# mark: Gradients =============================================================================
func lowp_gradient(p: LowpPipeline*):
let ctx = &p.ctx.gradient
# N.B. The loop starts at 1 because idx 0 is the color to use before the first stop.
let t = lowp_join(p.r, p.g)
var idx: u32[16]
for i in 1..<ctx.len:
let tt = ctx.t_values.data[i]
for l: usize in 0..<16:
idx[l] +%= (u32)(t[l >> 2][l & 3] >= tt)
lowp_gradient_lookup(ctx, idx, t, &p.r, &p.g, &p.b, &p.a)
lowp_next_stage(p)
func lowp_evenly_spaced_gradient(p: LowpPipeline*):
let ctx = &p.ctx.gradient
let t = lowp_join(p.r, p.g)
let scale = (f32)(ctx.len - 1)
var idx: u32[16]
for l: usize in 0..<16:
idx[l] = (u32)(i32)(t[l >> 2][l & 3] * scale) # fcvtzs: saturating, NaN to 0
lowp_gradient_lookup(ctx, idx, t, &p.r, &p.g, &p.b, &p.a)
lowp_next_stage(p)
func lowp_evenly_spaced_2_stop_gradient(p: LowpPipeline*):
let ctx = p.ctx.evenly_spaced_2_stop_gradient
let t = lowp_join(p.r, p.g)
var rf: F16 = ---
var gf: F16 = ---
var bf: F16 = ---
var af: F16 = ---
for q: usize in 0..<4:
rf[q] = lowp_mad(t[q], f32[4](ctx.factor.r), f32[4](ctx.bias.r))
gf[q] = lowp_mad(t[q], f32[4](ctx.factor.g), f32[4](ctx.bias.g))
bf[q] = lowp_mad(t[q], f32[4](ctx.factor.b), f32[4](ctx.bias.b))
af[q] = lowp_mad(t[q], f32[4](ctx.factor.a), f32[4](ctx.bias.a))
round_f32_to_u16(&rf, &gf, &bf, &af, &p.r, &p.g, &p.b, &p.a)
lowp_next_stage(p)
func lowp_xy_to_unit_angle(p: LowpPipeline*):
var x = lowp_join(p.r, p.g)
let y = lowp_join(p.b, p.a)
let zero = f32[4](0.0)
for q: usize in 0..<4:
let xabs = f4_abs(x[q])
let yabs = f4_abs(y[q])
let slope = lowp_fmin(xabs, yabs) / lowp_fmax(xabs, yabs)
let s = slope * slope
# Use a 7th degree polynomial to approximate atan. This was generated using
# sollya.gforge.inria.fr. A float optimized polynomial was generated using the
# following command.
# P1 = fpminimax((1/(2*Pi))*atan(x),[|1,3,5,7|],[|24...|],[2^(-40),1],relative);
var phi = slope * (f32[4](0.15912117063999176025390625) + s * (f32[4](-5.185396969318389892578125e-2) + s * (f32[4](2.476101927459239959716796875e-2) + s * f32[4](-7.0547382347285747528076171875e-3))))
phi = f4_blend(f4_cmp_lt(xabs, yabs), f32[4](0.25) - phi, phi)
phi = f4_blend(f4_cmp_lt(x[q], zero), f32[4](0.5) - phi, phi)
phi = f4_blend(f4_cmp_lt(y[q], zero), f32[4](1.0) - phi, phi)
phi = f4_blend(f4_cmp_ne(phi, phi), zero, phi) # Check for NaN.
x[q] = phi
lowp_split(x, &p.r, &p.g)
lowp_next_stage(p)
func lowp_xy_to_radius(p: LowpPipeline*):
var x = lowp_join(p.r, p.g)
let y = lowp_join(p.b, p.a)
for q: usize in 0..<4:
x[q] = f4_sqrt(x[q] * x[q] + y[q] * y[q])
lowp_split(x, &p.r, &p.g)
lowp_next_stage(p)
## Skia's gather of the stops' factors and biases at `idx`, then t * factor + bias rounded to
## u16. An index past the context (Skia reads beyond its arrays then) is clamped.
func lowp_gradient_lookup(ctx: const GradientCtx*, idx: const u32[16], t: F16, r: U16x16*, g: U16x16*, b: U16x16*, a: U16x16*):
let factors = ctx.factors.view()
let biases = ctx.biases.view()
let last = (u32)factors.length - 1
var fr: F16 = ---
var fg: F16 = ---
var fb: F16 = ---
var fa: F16 = ---
var br: F16 = ---
var bg: F16 = ---
var bb: F16 = ---
var ba: F16 = ---
for l: usize in 0..<16:
let i = (usize)(idx[l] if idx[l] < last else last)
let f = factors[i]
let bias = biases[i]
let h = l >> 2
let k = l & 3
fr[h][k] = f.r
fg[h][k] = f.g
fb[h][k] = f.b
fa[h][k] = f.a
br[h][k] = bias.r
bg[h][k] = bias.g
bb[h][k] = bias.b
ba[h][k] = bias.a
for q: usize in 0..<4:
fr[q] = lowp_mad(t[q], fr[q], br[q])
fg[q] = lowp_mad(t[q], fg[q], bg[q])
fb[q] = lowp_mad(t[q], fb[q], bb[q])
fa[q] = lowp_mad(t[q], fa[q], ba[q])
round_f32_to_u16(&fr, &fg, &fb, &fa, r, g, b, a)
## round_F_to_U16: color channels clamped to [0,1] (lowp's min/max), then x * 255 + 0.5
## converted to u16; alpha is assumed to be in [0,1] already.
func round_f32_to_u16(rf: const F16*, gf: const F16*, bf: const F16*, af: const F16*, r: U16x16*, g: U16x16*, b: U16x16*, a: U16x16*):
let scale = f32[4](255.0)
let half_ = f32[4](0.5)
for q: usize in 0..<4:
let rq = lowp_clamp_01_((*rf)[q]) * scale + half_
let gq = lowp_clamp_01_((*gf)[q]) * scale + half_
let bq = lowp_clamp_01_((*bf)[q]) * scale + half_
let aq = (*af)[q] * scale + half_
let h = q >> 1
let o = (q & 1) * 4
for k: usize in 0..<4:
# The colors are in [0.5, 255.5]; alpha's conversion saturates like fcvtzu.
(*r)[h][o + k] = (u16)rq[k]
(*g)[h][o + k] = (u16)gq[k]
(*b)[h][o + k] = (u16)bq[k]
(*a)[h][o + k] = (u16)aq[k]