Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-render

Source of release 0.6.2

0.6.2 / 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]