Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-webp

Source of release 0.1.0

0.1.0 / src / webp / vp8l_transform.lucb

#==============================================================================================
#
#   webp/vp8l_transform - The inverse transforms and color conversion
#
#   DESCRIPTION:
#       Port of dsp/lossless.c and dsp/lossless_common.h: the four VP8L transforms undone
#       (the predictor transform with its 14 predictors per tile, the cross-color
#       transform, the subtract-green transform, and color indexing with pixel bundling),
#       and ARGB to RGBA. Pixels are ARGB words: alpha in the top byte, blue in the low.
#       The predictor reads the row above from the output (`out - width`); the caller
#       keeps the last row of a batch there for the next batch.
#
#==============================================================================================

## The transforms (VP8LImageTransformType).
let predictor_transform: u32 = 0
let cross_color_transform: u32 = 1
let subtract_green_transform: u32 = 2
let color_indexing_transform: u32 = 3
let argb_black: u32 = 0xff000000

## A transform read from the stream (VP8LTransform).
struct Transform:
    var kind: u32
    ## The tile size's bits, or the bundling's for color indexing.
    var bits: u32
    ## The size of the image the transform applies to.
    var xsize: usize
    var ysize: usize
    ## Its sub-image (predictor modes, color multipliers) or palette.
    var data: u32[]

## VP8LSubSampleSize: `size` divided by 2^`bits`, rounded up.
inline func sub_sample_size(size: usize, bits: u32) -> usize:
    return (size + ((usize)1 << bits) - 1) >> bits

# mark: Pixels ================================================================================

## VP8LAddPixels: the channels added, each modulo 256.
inline func add_pixels(a: u32, b: u32) -> u32:
    let alpha_and_green = (a & 0xff00ff00) +% (b & 0xff00ff00)
    let red_and_blue = (a & 0x00ff00ff) +% (b & 0x00ff00ff)
    return (alpha_and_green & 0xff00ff00) | (red_and_blue & 0x00ff00ff)

## Average2: each channel's average, rounded down.
inline func average2(a0: u32, a1: u32) -> u32:
    return (((a0 ^ a1) & 0xfefefefe) >> 1) + (a0 & a1)

## Clip255: a channel computed in 32 bits back to 0..255 (negative is 0).
inline func clip255(a: u32) -> u32:
    if a < 256:
        return a
    return ~a >> 24

## AddSubtractComponentFull.
inline func add_subtract_full(a: u32, b: u32, c: u32) -> u32:
    return clip255(a +% b -% c)

## ClampedAddSubtractFull: left + top - top left, per channel, clamped.
inline func clamped_add_subtract_full(c0: u32, c1: u32, c2: u32) -> u32:
    let a = add_subtract_full(c0 >> 24, c1 >> 24, c2 >> 24)
    let r = add_subtract_full((c0 >> 16) & 0xff, (c1 >> 16) & 0xff, (c2 >> 16) & 0xff)
    let g = add_subtract_full((c0 >> 8) & 0xff, (c1 >> 8) & 0xff, (c2 >> 8) & 0xff)
    let b = add_subtract_full(c0 & 0xff, c1 & 0xff, c2 & 0xff)
    return (a << 24) | (r << 16) | (g << 8) | b

## AddSubtractComponentHalf: a + (a - b) / 2, the division truncating toward zero.
inline func add_subtract_half(a: i32, b: i32) -> u32:
    return clip255((u32)(a + (a - b) // 2))

## ClampedAddSubtractHalf.
inline func clamped_add_subtract_half(c0: u32, c1: u32, c2: u32) -> u32:
    let ave = average2(c0, c1)
    let a = add_subtract_half((i32)(ave >> 24), (i32)(c2 >> 24))
    let r = add_subtract_half((i32)((ave >> 16) & 0xff), (i32)((c2 >> 16) & 0xff))
    let g = add_subtract_half((i32)((ave >> 8) & 0xff), (i32)((c2 >> 8) & 0xff))
    let b = add_subtract_half((i32)(ave & 0xff), (i32)(c2 & 0xff))
    return (a << 24) | (r << 16) | (g << 8) | b

## Sub3: |b - c| - |a - c|.
inline func sub3(a: i32, b: i32, c: i32) -> i32:
    let pb = b - c
    let pa = a - c
    return (pb if pb >= 0 else -pb) - (pa if pa >= 0 else -pa)

## Select: `a` or `b`, whichever is closer to a + b - c in the sum of the channels.
inline func select(a: u32, b: u32, c: u32) -> u32:
    let by_alpha = sub3((i32)(a >> 24), (i32)(b >> 24), (i32)(c >> 24))
    let by_red = sub3((i32)((a >> 16) & 0xff), (i32)((b >> 16) & 0xff), (i32)((c >> 16) & 0xff))
    let by_green = sub3((i32)((a >> 8) & 0xff), (i32)((b >> 8) & 0xff), (i32)((c >> 8) & 0xff))
    let by_blue = sub3((i32)(a & 0xff), (i32)(b & 0xff), (i32)(c & 0xff))
    let pa_minus_pb = by_alpha + by_red + by_green + by_blue
    return a if pa_minus_pb <= 0 else b

# mark: The predictor transform ===============================================================

## PredictorAdd N: `num_pixels` residuals at `input` plus their predictions into `out`, the
## row above at `upper`; the pixel left of `out` is `out[-1]` (VP8LPredictor N). Modes 14
## and 15 are mode 0 (VP8LPredictorsAdd's sentinels).
func predictor_add(mode: u32, input: const u32*, upper: const u32*, num_pixels: usize, out: u32*):
    match mode:
        1:
            var left = (out - 1)[0]
            for x in 0..<num_pixels:
                left = add_pixels(input[x], left)
                out[x] = left
        2:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], upper[x])
        3:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], upper[x + 1])
        4:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], (upper + x - 1)[0])
        5:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], average2(average2((out + x - 1)[0], upper[x + 1]), upper[x]))
        6:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], average2((out + x - 1)[0], (upper + x - 1)[0]))
        7:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], average2((out + x - 1)[0], upper[x]))
        8:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], average2((upper + x - 1)[0], upper[x]))
        9:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], average2(upper[x], upper[x + 1]))
        10:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], average2(average2((out + x - 1)[0], (upper + x - 1)[0]), average2(upper[x], upper[x + 1])))
        11:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], select(upper[x], (out + x - 1)[0], (upper + x - 1)[0]))
        12:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], clamped_add_subtract_full((out + x - 1)[0], upper[x], (upper + x - 1)[0]))
        13:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], clamped_add_subtract_half((out + x - 1)[0], upper[x], (upper + x - 1)[0]))
        _:
            for x in 0..<num_pixels:
                out[x] = add_pixels(input[x], argb_black)

## PredictorInverseTransform: rows `y_start` to `y_end` of `input` into `out`.
func predictor_inverse_transform(transform: const Transform*, y_start: usize, y_end: usize, input: const u32*, out: u32*):
    let width = transform.xsize
    var src = input
    var dst = out
    var y = y_start
    if y == 0:
        # The first row follows the L mode (1), its first pixel black (0).
        predictor_add(0, src, dst, 1, dst)
        predictor_add(1, src + 1, dst + 1, width - 1, dst + 1)
        src = src + width
        dst = dst + width
        y += 1
    let tile_width = (usize)1 << transform.bits
    let mask = tile_width - 1
    let tiles_per_row = sub_sample_size(width, transform.bits)
    var pred_mode_base = transform.data.data + (y >> transform.bits) * tiles_per_row
    while y < y_end:
        var pred_mode_src = pred_mode_base
        # The first pixel follows the T mode (2).
        predictor_add(2, src, dst - width, 1, dst)
        var x: usize = 1
        while x < width:
            let mode = (pred_mode_src[0] >> 8) & 0xf
            pred_mode_src = pred_mode_src + 1
            var x_end = (x & ~mask) + tile_width
            if x_end > width:
                x_end = width
            predictor_add(mode, src + x, dst + x - width, x_end - x, dst + x)
            x = x_end
        src = src + width
        dst = dst + width
        y += 1
        if (y & mask) == 0:
            # The same mask: tiles are square.
            pred_mode_base = pred_mode_base + tiles_per_row

# mark: The other transforms ==================================================================

## VP8LAddGreenToBlueAndRed: the subtract-green transform undone.
func add_green_to_blue_and_red(src: const u32*, num_pixels: usize, dst: u32*):
    for i in 0..<num_pixels:
        let argb = src[i]
        let green = (argb >> 8) & 0xff
        var red_blue = argb & 0x00ff00ff
        red_blue = red_blue +% ((green << 16) | green)
        red_blue &= 0x00ff00ff
        dst[i] = (argb & 0xff00ff00) | red_blue

## ColorTransformDelta: (color_pred * color) >> 5, both signed bytes.
inline func color_transform_delta(color_pred: u32, color: u32) -> i32:
    return ((i32)(i8)(u8)color_pred * (i32)(i8)(u8)color) >> 5

## ColorSpaceInverseTransform: the cross-color transform undone, a tile's multipliers at a
## time.
func color_space_inverse_transform(transform: const Transform*, y_start: usize, y_end: usize, input: const u32*, out: u32*):
    let width = transform.xsize
    let tile_width = (usize)1 << transform.bits
    let tiles_per_row = sub_sample_size(width, transform.bits)
    var src = input
    var dst = out
    var y = y_start
    var pred_row = transform.data.data + (y >> transform.bits) * tiles_per_row
    while y < y_end:
        var x: usize = 0
        var pred = pred_row
        while x < width:
            let code = pred[0]
            pred = pred + 1
            let green_to_red = code & 0xff
            let green_to_blue = (code >> 8) & 0xff
            let red_to_blue = (code >> 16) & 0xff
            let end = x + tile_width if x + tile_width < width else width
            for i in x..<end:
                # VP8LTransformColorInverse.
                let argb = src[i]
                let green = argb >> 8
                var new_red = (i32)((argb >> 16) & 0xff)
                var new_blue = (i32)(argb & 0xff)
                new_red += color_transform_delta(green_to_red, green)
                new_red &= 0xff
                new_blue += color_transform_delta(green_to_blue, green)
                new_blue += color_transform_delta(red_to_blue, (u32)new_red)
                new_blue &= 0xff
                dst[i] = (argb & 0xff00ff00) | ((u32)new_red << 16) | (u32)new_blue
            x = end
        src = src + width
        dst = dst + width
        y += 1
        if (y & (tile_width - 1)) == 0:
            pred_row = pred_row + tiles_per_row

## ColorIndexInverseTransform (ARGB): each index through the palette, several indices to
## a pixel when bundled.
func color_index_inverse_transform(transform: const Transform*, y_start: usize, y_end: usize, input: const u32*, out: u32*):
    let bits_per_pixel = (u32)8 >> transform.bits
    let width = transform.xsize
    let color_map = transform.data.data
    var src = input
    var dst = out
    if bits_per_pixel < 8:
        let pixels_per_byte = (usize)1 << transform.bits
        let count_mask = pixels_per_byte - 1
        let bit_mask = ((u32)1 << bits_per_pixel) - 1
        for y in y_start..<y_end:
            var packed_pixels: u32 = 0
            for x in 0..<width:
                if (x & count_mask) == 0:
                    packed_pixels = (src[0] >> 8) & 0xff
                    src = src + 1
                dst[0] = color_map[(usize)(packed_pixels & bit_mask)]
                dst = dst + 1
                packed_pixels >>= bits_per_pixel
        return
    for y in y_start..<y_end:
        for x in 0..<width:
            dst[x] = color_map[(usize)((src[x] >> 8) & 0xff)]
        src = src + width
        dst = dst + width

## VP8LColorIndexInverseTransformAlpha: the same over alpha bytes, the palette's green as
## the value.
func color_index_inverse_transform_alpha(transform: const Transform*, y_start: usize, y_end: usize, input: const u8*, out: u8*):
    let bits_per_pixel = (u32)8 >> transform.bits
    let width = transform.xsize
    let color_map = transform.data.data
    var src = input
    var dst = out
    if bits_per_pixel < 8:
        let pixels_per_byte = (usize)1 << transform.bits
        let count_mask = pixels_per_byte - 1
        let bit_mask = ((u32)1 << bits_per_pixel) - 1
        for y in y_start..<y_end:
            var packed_pixels: u32 = 0
            for x in 0..<width:
                if (x & count_mask) == 0:
                    packed_pixels = (u32)src[0]
                    src = src + 1
                dst[0] = (u8)((color_map[(usize)(packed_pixels & bit_mask)] >> 8) & 0xff)
                dst = dst + 1
                packed_pixels >>= bits_per_pixel
        return
    for y in y_start..<y_end:
        for x in 0..<width:
            dst[x] = (u8)((color_map[(usize)src[x]] >> 8) & 0xff)
        src = src + width
        dst = dst + width

## VP8LInverseTransform: rows `row_start` to `row_end` through `transform`, from `input` into
## `out` (which may be `input`).
func inverse_transform(transform: const Transform*, row_start: usize, row_end: usize, input: const u32*, out: u32*):
    let width = transform.xsize
    match transform.kind:
        0:
            predictor_inverse_transform(transform, row_start, row_end, input, out)
            if row_end != transform.ysize:
                # The last row predicted is the next batch's row above.
                let rows = row_end - row_start
                memory.copy(u32[](out - width, width), u32[](out + (rows - 1) * width, width), width)
        1:
            color_space_inverse_transform(transform, row_start, row_end, input, out)
        2:
            add_green_to_blue_and_red(input, (row_end - row_start) * width, out)
        _:
            if (const u32*)out == input and transform.bits > 0:
                # The packed pixels moved to the end of the unpacked region, so that they
                # unpack forward. Color indexing alone works on the packed width.
                let out_stride = (row_end - row_start) * width
                let in_stride = (row_end - row_start) * sub_sample_size(transform.xsize, transform.bits)
                let src = out + out_stride - in_stride
                memory.move(u32[](src, in_stride), u32[](out, in_stride), in_stride)
                color_index_inverse_transform(transform, row_start, row_end, src, out)
            else:
                color_index_inverse_transform(transform, row_start, row_end, input, out)

## VP8LConvertBGRAToRGBA: ARGB words to RGBA bytes.
func convert_to_rgba(src: const u32*, num_pixels: usize, dst: u8*):
    for i in 0..<num_pixels:
        let argb = src[i]
        let at = dst + i * 4
        at[0] = (u8)(argb >> 16)
        at[1] = (u8)(argb >> 8)
        at[2] = (u8)argb
        at[3] = (u8)(argb >> 24)