Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-color

Source of release 0.8.2

0.8.2 / src / icc / transform_ops.lucb

#==============================================================================================
#
#   icc/transform_ops - running a transform's ops on pixels
#
#   DESCRIPTION:
#       Port of skcms's Transform_inl.h for one lane (N == 1, the portable build): the
#       loads and stores of every pixel format, the color ops (swap, clamp, invert, alpha,
#       matrices, Lab and XYZ), the curve ops (gamma, sRGB-ish, PQ-ish, HLG-ish and its
#       inverse, tables), the HLG OOTF, and the multilinear interpolation of an A2B or B2A
#       grid (clut). Multi-byte formats are little-endian in memory, as on every target skcms
#       runs on, except the big-endian 16-bit ones; half floats convert as the portable
#       F_from_Half and Half_from_F do, flushing denormals to zero.
#
#==============================================================================================

## The color of the pixel in flight.
struct Rgba:
    var r: f32
    var g: f32
    var b: f32
    var a: f32

## run_program: the steps on each pixel in turn, starting from opaque black.
func run_program(steps: const Step[], src: const u8[], dst: u8[], count: usize, src_bpp: usize, dst_bpp: usize):
    for i in 0..<count:
        var px = Rgba(r = 0.0, g = 0.0, b = 0.0, a = 1.0)
        let source = src[i * src_bpp..<(i + 1) * src_bpp]
        for step in &steps:
            if not exec_step(step, source, dst[i * dst_bpp..<(i + 1) * dst_bpp], &px):
                break

# mark: Helpers ================================================================================

## F_from_U8.
func f_from_u8(v: u8) -> f32:
    return (f32)v * (1.0 / 255.0)

## F_from_U16_BE: all 16-bit ICC values are big-endian.
func f_from_u16_be(data: const u8[], at: usize) -> f32:
    return (f32)(((u32)data[at] << 8) | (u32)data[at + 1]) * (1.0 / 65535.0)

## A little-endian value of `bytes` bytes at `at`.
func load_le(data: const u8[], at: usize, bytes: usize) -> u64:
    var v: u64 = 0
    for k in 0..<bytes:
        v |= (u64)data[at + k] << (u64)(8 * k)
    return v

func store_le(data: u8[], at: usize, bytes: usize, v: u64):
    for k in 0..<bytes:
        data[at + k] = (u8)(v >> (u64)(8 * k))

## to_fixed: rounding to an integer through a truncating conversion of f + 0.5.
func to_fixed(f: f32) -> u32:
    return (u32)(i32)(f + 0.5)

## U16_from_F.
func u16_from_f(v: f32) -> u16:
    return (u16)(v * 65535.0 + 0.5)

## F_from_Half, the portable path: denormal halves flush to zero.
func f_from_half(half: u16) -> f32:
    let wide = (u32)half
    let s = wide & 0x8000
    let em = wide ^ s
    # Simply flush all denorm half floats to zero.
    if em < 0x0400:
        return 0.0
    # Constructing the float is easy if the half is not denormalized.
    return f32.bits((s << 16) +% (em << 13) +% ((127 - 15) << 23))

## Half_from_F, the portable path: denormal halves (and all denormal floats) flush to zero.
func half_from_f(f: f32) -> u16:
    let sem = f.bits()
    let s = sem & 0x80000000
    let em = sem ^ s
    if em < 0x38800000:
        return 0
    return (u16)((s >> 16) +% (em >> 13) -% ((127 - 15) << 10))

## The value of a curve op's transfer function at `x`.
func apply_curve(step: const Step*, x: f32) -> f32:
    match step.op:
        .gamma:
            let tf = step.tf else trap("a gamma op has a transfer function")
            let (v, sign) = strip_sign(x)
            return apply_sign(approx_pow(v, tf.g), sign)
        .tf:
            let tf = step.tf else trap("a tf op has a transfer function")
            let (v, sign) = strip_sign(x)
            # The transfer function has a linear part up to d, exponential at d and after.
            let y = tf.c * v + tf.f if v < tf.d else approx_pow(tf.a * v + tf.b, tf.g) + tf.e
            return apply_sign(y, sign)
        .pq:
            let tf = step.tf else trap("a pq op has a transfer function")
            let (v, sign) = strip_sign(x)
            let y = approx_pow(max_(tf.a + tf.b * approx_pow(v, tf.c), 0.0) / (tf.d + tf.e * approx_pow(v, tf.c)), tf.f)
            return apply_sign(y, sign)
        .hlg:
            let tf = step.tf else trap("an hlg op has a transfer function")
            let big_r = tf.a
            let big_g = tf.b
            let a = tf.c
            let b = tf.d
            let c = tf.e
            let k = tf.f + 1.0
            let (v, sign) = strip_sign(x)
            let y = approx_pow(v * big_r, big_g) if v * big_r <= 1.0 else approx_exp((v - c) * a) + b
            return k * apply_sign(y, sign)
        .hlginv:
            let tf = step.tf else trap("an hlginv op has a transfer function")
            let big_r = tf.a
            let big_g = tf.b
            let a = tf.c
            let b = tf.d
            let c = tf.e
            let k = tf.f + 1.0
            let (stripped, sign) = strip_sign(x)
            let v = stripped / k
            let y = big_r * approx_pow(v, big_g) if v <= 1.0 else a * approx_log(v - b) + c
            return apply_sign(y, sign)
        .table:
            let curve = step.curve else trap("a table op has a curve")
            return table(curve, x)
        _:
            return x

## table: the curve's table at `v` clamped to 0..1, interpolated linearly.
func table(curve: const Curve*, v: f32) -> f32:
    # Clamp the input to [0,1], then scale to a table index.
    let ix = max_(0.0, min_(v, 1.0)) * (f32)(curve.table_entries - 1)
    # We'll look up (equal or adjacent) entries at lo and hi, then lerp by t between them.
    let lo = (usize)(i32)ix
    let hi = (usize)(i32)minus_1_ulp(ix + 1.0)
    let t = ix - (f32)lo
    var l: f32 = 0.0
    var h: f32 = 0.0
    if curve.table_8.length > 0:
        l = f_from_u8(curve.table_8[lo])
        h = f_from_u8(curve.table_8[hi])
    else:
        l = f_from_u16_be(curve.table_16, 2 * lo)
        h = f_from_u16_be(curve.table_16, 2 * hi)
    return l + (h - l) * t

## compute_Y_in_xyzd50: the luminance of the HLG OOTF (Rec. 2020's weights) in XYZ D50.
func compute_y_in_xyzd50(x: f32, y: f32, z: f32) -> f32:
    return -0.02831655 * x + 1.00995452 * y + 0.02102382 * z

# mark: CLUT ===================================================================================

## sample_clut (skcms's clut): multilinear interpolation of the 2^dim grid points around the input, in a grid of
## `input_channels` axes and `output_channels` (3 or 4) values a point.
func sample_clut(input_channels: u32, output_channels: u32, grid_points: const u8[], grid_8: const u8[], grid_16: const u8[], px: Rgba*):
    let dim = (usize)input_channels

    # Index contribution and weight by dimension, first low from 0, then high from 4.
    var index: i32[8] = [0, 0, 0, 0, 0, 0, 0, 0]
    var weight: f32[8] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

    # O(dim) work first: calculate index, weight from r, g, b, a.
    let inputs: f32[4] = [px.r, px.g, px.b, px.a]
    var stride: i32 = 1
    var i = dim
    while i > 0:
        i -= 1
        # x is where we logically want to sample the grid in the i-th dimension.
        let x = inputs[i] * (f32)((i32)grid_points[i] - 1)
        # lo and hi are the two integer grid points surrounding x.
        let lo = (i32)x
        let hi = (i32)minus_1_ulp(x + 1.0)
        # Notice how we fold in the accumulated stride across previous dimensions here.
        index[i] = lo * stride
        index[i + 4] = hi * stride
        stride *= (i32)grid_points[i]
        # We'll interpolate between those two integer grid points by t.
        let t = x - (f32)lo
        weight[i] = 1.0 - t
        weight[i + 4] = t

    var r: f32 = 0.0
    var g: f32 = 0.0
    var b: f32 = 0.0
    var a: f32 = 0.0 if output_channels == 4 else px.a

    # Sample 2^dim table entries per pixel, in all combinations of low and high in each
    # dimension.
    for combo in 0..<((usize)1 << dim):
        var ix = index[(combo & 1) * 4]
        var w = weight[(combo & 1) * 4]
        if dim >= 4:
            ix += index[3 + (combo & 8) // 2]
            w *= weight[3 + (combo & 8) // 2]
        if dim >= 3:
            ix += index[2 + (combo & 4)]
            w *= weight[2 + (combo & 4)]
        if dim >= 2:
            ix += index[1 + (combo & 2) * 2]
            w *= weight[1 + (combo & 2) * 2]

        let at = (usize)ix
        var big_a: f32 = 0.0
        var big_r: f32 = 0.0
        var big_g: f32 = 0.0
        var big_b: f32 = 0.0
        if output_channels == 3:
            if grid_8.length > 0:
                big_r = f_from_u8(grid_8[3 * at])
                big_g = f_from_u8(grid_8[3 * at + 1])
                big_b = f_from_u8(grid_8[3 * at + 2])
            else:
                big_r = f_from_u16_be(grid_16, 6 * at)
                big_g = f_from_u16_be(grid_16, 6 * at + 2)
                big_b = f_from_u16_be(grid_16, 6 * at + 4)
        else:
            if grid_8.length > 0:
                big_r = f_from_u8(grid_8[4 * at])
                big_g = f_from_u8(grid_8[4 * at + 1])
                big_b = f_from_u8(grid_8[4 * at + 2])
                big_a = f_from_u8(grid_8[4 * at + 3])
            else:
                big_r = f_from_u16_be(grid_16, 8 * at)
                big_g = f_from_u16_be(grid_16, 8 * at + 2)
                big_b = f_from_u16_be(grid_16, 8 * at + 4)
                big_a = f_from_u16_be(grid_16, 8 * at + 6)
        r += w * big_r
        g += w * big_g
        b += w * big_b
        a += w * big_a

    px.r = r
    px.g = g
    px.b = b
    # The A2B form takes alpha by value: only the B2A's fourth output channel lands in it.
    if output_channels == 4:
        px.a = a

# mark: Running a step =========================================================================

## One step on the pixel in flight: false after a store, which ends the pixel.
func exec_step(step: const Step*, src: const u8[], dst: u8[], px: Rgba*) -> bool:
    match step.op:
        .load_a8:
            px.a = f_from_u8(src[0])
        .load_g8:
            px.r = f_from_u8(src[0])
            px.g = px.r
            px.b = px.r
        .load_ga88:
            px.r = (f32)src[0] * (1.0 / 255.0)
            px.g = px.r
            px.b = px.r
            px.a = (f32)src[1] * (1.0 / 255.0)
        .load_4444:
            let abgr = (u32)load_le(src, 0, 2)
            px.r = (f32)((abgr >> 12) & 0xf) * (1.0 / 15.0)
            px.g = (f32)((abgr >> 8) & 0xf) * (1.0 / 15.0)
            px.b = (f32)((abgr >> 4) & 0xf) * (1.0 / 15.0)
            px.a = (f32)(abgr & 0xf) * (1.0 / 15.0)
        .load_565:
            let rgb = (u32)load_le(src, 0, 2)
            px.r = (f32)(rgb & 31) * (1.0 / 31.0)
            px.g = (f32)(rgb & (63 << 5)) * (1.0 / 2016.0)
            px.b = (f32)(rgb & (31 << 11)) * (1.0 / 63488.0)
        .load_888:
            px.r = (f32)src[0] * (1.0 / 255.0)
            px.g = (f32)src[1] * (1.0 / 255.0)
            px.b = (f32)src[2] * (1.0 / 255.0)
        .load_8888:
            px.r = (f32)src[0] * (1.0 / 255.0)
            px.g = (f32)src[1] * (1.0 / 255.0)
            px.b = (f32)src[2] * (1.0 / 255.0)
            px.a = (f32)src[3] * (1.0 / 255.0)
        .load_1010102:
            let rgba = (u32)load_le(src, 0, 4)
            px.r = (f32)(rgba & 0x3ff) * (1.0 / 1023.0)
            px.g = (f32)((rgba >> 10) & 0x3ff) * (1.0 / 1023.0)
            px.b = (f32)((rgba >> 20) & 0x3ff) * (1.0 / 1023.0)
            px.a = (f32)((rgba >> 30) & 0x3) * (1.0 / 3.0)
        .load_101010x_xr:
            # skcms subtracts in unsigned arithmetic, so codes below 384 wrap around.
            let rgba = (u32)load_le(src, 0, 4)
            px.r = (f32)((rgba & 0x3ff) -% 384) / 510.0
            px.g = (f32)(((rgba >> 10) & 0x3ff) -% 384) / 510.0
            px.b = (f32)(((rgba >> 20) & 0x3ff) -% 384) / 510.0
        .load_10101010_xr:
            # Each channel is 16 bits, where the 6 low bits are padding.
            let rgba = load_le(src, 0, 8)
            px.r = (f32)(((rgba >> 6) & 0x3ff) -% 384) / 510.0
            px.g = (f32)(((rgba >> 22) & 0x3ff) -% 384) / 510.0
            px.b = (f32)(((rgba >> 38) & 0x3ff) -% 384) / 510.0
            px.a = (f32)(((rgba >> 54) & 0x3ff) -% 384) / 510.0
        .load_161616le:
            px.r = (f32)load_le(src, 0, 2) * (1.0 / 65535.0)
            px.g = (f32)load_le(src, 2, 2) * (1.0 / 65535.0)
            px.b = (f32)load_le(src, 4, 2) * (1.0 / 65535.0)
        .load_16161616le:
            px.r = (f32)load_le(src, 0, 2) * (1.0 / 65535.0)
            px.g = (f32)load_le(src, 2, 2) * (1.0 / 65535.0)
            px.b = (f32)load_le(src, 4, 2) * (1.0 / 65535.0)
            px.a = (f32)load_le(src, 6, 2) * (1.0 / 65535.0)
        .load_161616be:
            px.r = f_from_u16_be(src, 0)
            px.g = f_from_u16_be(src, 2)
            px.b = f_from_u16_be(src, 4)
        .load_16161616be:
            px.r = f_from_u16_be(src, 0)
            px.g = f_from_u16_be(src, 2)
            px.b = f_from_u16_be(src, 4)
            px.a = f_from_u16_be(src, 6)
        .load_hhh:
            px.r = f_from_half((u16)load_le(src, 0, 2))
            px.g = f_from_half((u16)load_le(src, 2, 2))
            px.b = f_from_half((u16)load_le(src, 4, 2))
        .load_hhhh:
            px.r = f_from_half((u16)load_le(src, 0, 2))
            px.g = f_from_half((u16)load_le(src, 2, 2))
            px.b = f_from_half((u16)load_le(src, 4, 2))
            px.a = f_from_half((u16)load_le(src, 6, 2))
        .load_fff:
            px.r = f32.bits((u32)load_le(src, 0, 4))
            px.g = f32.bits((u32)load_le(src, 4, 4))
            px.b = f32.bits((u32)load_le(src, 8, 4))
        .load_ffff:
            px.r = f32.bits((u32)load_le(src, 0, 4))
            px.g = f32.bits((u32)load_le(src, 4, 4))
            px.b = f32.bits((u32)load_le(src, 8, 4))
            px.a = f32.bits((u32)load_le(src, 12, 4))
        .swap_rb:
            let t = px.r
            px.r = px.b
            px.b = t
        .clamp:
            px.r = max_(0.0, min_(px.r, 1.0))
            px.g = max_(0.0, min_(px.g, 1.0))
            px.b = max_(0.0, min_(px.b, 1.0))
            px.a = max_(0.0, min_(px.a, 1.0))
        .invert:
            px.r = 1.0 - px.r
            px.g = 1.0 - px.g
            px.b = 1.0 - px.b
            px.a = 1.0 - px.a
        .force_opaque:
            px.a = 1.0
        .premul:
            px.r *= px.a
            px.g *= px.a
            px.b *= px.a
        .unpremul:
            let scale: f32 = 1.0 / px.a if 1.0 / px.a < infinity_ else 0.0
            px.r *= scale
            px.g *= scale
            px.b *= scale
        .matrix_3x3:
            let m = step.m33 else trap("a matrix op has a matrix")
            let r = m.vals[0][0] * px.r + m.vals[0][1] * px.g + m.vals[0][2] * px.b
            let g = m.vals[1][0] * px.r + m.vals[1][1] * px.g + m.vals[1][2] * px.b
            let b = m.vals[2][0] * px.r + m.vals[2][1] * px.g + m.vals[2][2] * px.b
            px.r = r
            px.g = g
            px.b = b
        .matrix_3x4:
            let m = step.m34 else trap("a matrix op has a matrix")
            let r = m.vals[0][0] * px.r + m.vals[0][1] * px.g + m.vals[0][2] * px.b + m.vals[0][3]
            let g = m.vals[1][0] * px.r + m.vals[1][1] * px.g + m.vals[1][2] * px.b + m.vals[1][3]
            let b = m.vals[2][0] * px.r + m.vals[2][1] * px.g + m.vals[2][2] * px.b + m.vals[2][3]
            px.r = r
            px.g = g
            px.b = b
        .lab_to_xyz:
            exec_lab_to_xyz(px)
        .xyz_to_lab:
            exec_xyz_to_lab(px)
        .gamma, .tf, .pq, .hlg, .hlginv, .table:
            match step.channel:
                0: px.r = apply_curve(step, px.r)
                1: px.g = apply_curve(step, px.g)
                2: px.b = apply_curve(step, px.b)
                3: px.a = apply_curve(step, px.a)
                _:
                    px.r = apply_curve(step, px.r)
                    px.g = apply_curve(step, px.g)
                    px.b = apply_curve(step, px.b)
        .hlg_ootf_scale:
            exec_hlg_ootf_scale(px)
        .hlginv_ootf_scale:
            exec_hlginv_ootf_scale(px)
        .clut_a2b:
            let a2b = step.a2b else trap("a CLUT op has its A2B")
            sample_clut(a2b.input_channels, a2b.output_channels, a2b.grid_points, a2b.grid_8, a2b.grid_16, px)
            if a2b.input_channels == 4:
                # CMYK is opaque.
                px.a = 1.0
        .clut_b2a:
            let b2a = step.b2a else trap("a CLUT op has its B2A")
            sample_clut(b2a.input_channels, b2a.output_channels, b2a.grid_points, b2a.grid_8, b2a.grid_16, px)
        _:
            exec_store(step.op, dst, px)
            return false
    return true

func exec_lab_to_xyz(px: Rgba*):
    # The L*a*b values are in r,g,b, but normalized to [0,1]. Reconstruct them.
    let l = px.r * 100.0
    let big_a = px.g * 255.0 - 128.0
    let big_b = px.b * 255.0 - 128.0
    # Convert to CIE XYZ.
    var y = (l + 16.0) * (1.0 / 116.0)
    var x = y + big_a * (1.0 / 500.0)
    var z = y - big_b * (1.0 / 200.0)
    x = x * x * x if x * x * x > 0.008856 else (x - 16.0 / 116.0) * (1.0 / 7.787)
    y = y * y * y if y * y * y > 0.008856 else (y - 16.0 / 116.0) * (1.0 / 7.787)
    z = z * z * z if z * z * z > 0.008856 else (z - 16.0 / 116.0) * (1.0 / 7.787)
    # Adjust to XYZD50 illuminant, and stuff back into r,g,b for the next op.
    px.r = x * 0.9642
    px.g = y
    px.b = z * 0.8249

func exec_xyz_to_lab(px: Rgba*):
    var x = px.r * (1.0 / 0.9642)
    var y = px.g
    var z = px.b * (1.0 / 0.8249)
    x = approx_pow(x, 1.0 / 3.0) if x > 0.008856 else x * 7.787 + 16.0 / 116.0
    y = approx_pow(y, 1.0 / 3.0) if y > 0.008856 else y * 7.787 + 16.0 / 116.0
    z = approx_pow(z, 1.0 / 3.0) if z > 0.008856 else z * 7.787 + 16.0 / 116.0
    let l = y * 116.0 - 16.0
    let big_a = (x - y) * 500.0
    let big_b = (y - z) * 200.0
    px.r = l * (1.0 / 100.0)
    px.g = (big_a + 128.0) * (1.0 / 255.0)
    px.b = (big_b + 128.0) * (1.0 / 255.0)

## hlg_ootf_scale: the HLG reference OOTF (ITU-R BT.2100-3 Table 5), gamma 1.2 on the
## luminance, then the 1000 nit peak over the 203 nit reference white.
func exec_hlg_ootf_scale(px: Rgba*):
    let gamma_minus_1: f32 = 0.2
    let (y, sign) = strip_sign(compute_y_in_xyzd50(px.r, px.g, px.b))
    let y_to_gamma_minus1 = apply_sign(approx_pow(y, gamma_minus_1), sign)
    px.r = px.r * y_to_gamma_minus1
    px.g = px.g * y_to_gamma_minus1
    px.b = px.b * y_to_gamma_minus1
    px.r *= 1000.0 / 203.0
    px.g *= 1000.0 / 203.0
    px.b *= 1000.0 / 203.0

## hlginv_ootf_scale: the inverse of hlg_ootf_scale.
func exec_hlginv_ootf_scale(px: Rgba*):
    px.r *= 203.0 / 1000.0
    px.g *= 203.0 / 1000.0
    px.b *= 203.0 / 1000.0
    let gamma_inv_minus_1: f32 = 1.0 / 1.2 - 1.0
    let (y, sign) = strip_sign(compute_y_in_xyzd50(px.r, px.g, px.b))
    let y_to_gamma_minus1 = apply_sign(approx_pow(y, gamma_inv_minus_1), sign)
    px.r = px.r * y_to_gamma_minus1
    px.g = px.g * y_to_gamma_minus1
    px.b = px.b * y_to_gamma_minus1

# mark: Stores =================================================================================

## A store op, ending the pixel.
func exec_store(op: Op, dst: u8[], px: const Rgba*):
    match op:
        .store_a8:
            dst[0] = (u8)to_fixed(px.a * 255.0)
        .store_g8:
            # g should be holding luminance (Y) (r,g,b ~~~> X,Y,Z).
            dst[0] = (u8)to_fixed(px.g * 255.0)
        .store_ga88:
            store_le(dst, 0, 2, (u64)((u16)to_fixed(px.g * 255.0) | ((u16)to_fixed(px.a * 255.0) << 8)))
        .store_4444:
            store_le(dst, 0, 2, (u64)((u16)(to_fixed(px.r * 15.0) << 12) | (u16)(to_fixed(px.g * 15.0) << 8) | (u16)(to_fixed(px.b * 15.0) << 4) | (u16)to_fixed(px.a * 15.0)))
        .store_565:
            store_le(dst, 0, 2, (u64)((u16)to_fixed(px.r * 31.0) | (u16)(to_fixed(px.g * 63.0) << 5) | (u16)(to_fixed(px.b * 31.0) << 11)))
        .store_888:
            dst[0] = (u8)to_fixed(px.r * 255.0)
            dst[1] = (u8)to_fixed(px.g * 255.0)
            dst[2] = (u8)to_fixed(px.b * 255.0)
        .store_8888:
            store_le(dst, 0, 4, (u64)(to_fixed(px.r * 255.0) | (to_fixed(px.g * 255.0) << 8) | (to_fixed(px.b * 255.0) << 16) | (to_fixed(px.a * 255.0) << 24)))
        .store_101010x_xr:
            store_le(dst, 0, 4, (u64)(to_fixed(px.r * 510.0 + 384.0) | (to_fixed(px.g * 510.0 + 384.0) << 10) | (to_fixed(px.b * 510.0 + 384.0) << 20)))
        .store_10101010_xr:
            # Each channel is 16 bits, where the 6 low bits are padding.
            store_le(dst, 0, 8, ((u64)to_fixed(px.r * 510.0 + 384.0) << 6) | ((u64)to_fixed(px.g * 510.0 + 384.0) << 22) | ((u64)to_fixed(px.b * 510.0 + 384.0) << 38) | ((u64)to_fixed(px.a * 510.0 + 384.0) << 54))
        .store_1010102:
            store_le(dst, 0, 4, (u64)(to_fixed(px.r * 1023.0) | (to_fixed(px.g * 1023.0) << 10) | (to_fixed(px.b * 1023.0) << 20) | (to_fixed(px.a * 3.0) << 30)))
        .store_161616le:
            store_le(dst, 0, 2, (u64)u16_from_f(px.r))
            store_le(dst, 2, 2, (u64)u16_from_f(px.g))
            store_le(dst, 4, 2, (u64)u16_from_f(px.b))
        .store_16161616le:
            store_le(dst, 0, 2, (u64)(u16)to_fixed(px.r * 65535.0))
            store_le(dst, 2, 2, (u64)(u16)to_fixed(px.g * 65535.0))
            store_le(dst, 4, 2, (u64)(u16)to_fixed(px.b * 65535.0))
            store_le(dst, 6, 2, (u64)(u16)to_fixed(px.a * 65535.0))
        .store_161616be:
            let channels: f32[3] = [px.r, px.g, px.b]
            for c in 0..<(usize)3:
                let v = (u16)to_fixed(channels[c] * 65535.0)
                dst[2 * c] = (u8)(v >> 8)
                dst[2 * c + 1] = (u8)v
        .store_16161616be:
            let channels: f32[4] = [px.r, px.g, px.b, px.a]
            for c in 0..<(usize)4:
                let v = (u16)to_fixed(channels[c] * 65535.0)
                dst[2 * c] = (u8)(v >> 8)
                dst[2 * c + 1] = (u8)v
        .store_hhh:
            store_le(dst, 0, 2, (u64)half_from_f(px.r))
            store_le(dst, 2, 2, (u64)half_from_f(px.g))
            store_le(dst, 4, 2, (u64)half_from_f(px.b))
        .store_hhhh:
            store_le(dst, 0, 2, (u64)half_from_f(px.r))
            store_le(dst, 2, 2, (u64)half_from_f(px.g))
            store_le(dst, 4, 2, (u64)half_from_f(px.b))
            store_le(dst, 6, 2, (u64)half_from_f(px.a))
        .store_fff:
            store_le(dst, 0, 4, (u64)px.r.bits())
            store_le(dst, 4, 4, (u64)px.g.bits())
            store_le(dst, 8, 4, (u64)px.b.bits())
        .store_ffff:
            store_le(dst, 0, 4, (u64)px.r.bits())
            store_le(dst, 4, 4, (u64)px.g.bits())
            store_le(dst, 8, 4, (u64)px.b.bits())
            store_le(dst, 12, 4, (u64)px.a.bits())
        _:
            trap("a store op ends the program")