dymokomi/luce-color
Source of release 0.8.1
0.8.1 / 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")