5a24289898fd
nrcj.wgsl
// Joint colour noise reduction (`lightcraft_pipeline::nrc_joint`). Each kernel mirrors its CPU
// twin there, in the same order of operations; keep them in step.
//
// Buffers: `a`, `b` inputs, `dst` output. Images are interleaved: RGB / Y,R−Y,B−Y (3 per pixel),
// chroma pairs R−Y,B−Y (2 per pixel), path pairs (h, v; exp(−path), see `nrc_joint`) or weight pairs (h, v).
// Kernels with the noise model: P[0] = n, P[1] = w, P[2] = h, P[3..6] = alpha, P[6..9] = beta,
// P[9..12] = ymax, P[12] = tolerance.
fn ja(i: u32) -> vec3<f32> {
return vec3<f32>(a[3u * i], a[3u * i + 1u], a[3u * i + 2u]);
}
fn jb3(i: u32) -> vec3<f32> {
return vec3<f32>(b[3u * i], b[3u * i + 1u], b[3u * i + 2u]);
}
fn ja2(i: u32) -> vec2<f32> {
return vec2<f32>(a[2u * i], a[2u * i + 1u]);
}
fn jvc(v: vec3<f32>, i: u32) -> f32 {
return select(select(v.x, v.y, i == 1u), v.z, i == 2u);
}
// `JointNoise::var`.
fn nvar(i: u32, y: f32) -> f32 {
let yy = min(y, pf(9u + i));
return max(pf(3u + i) * max(yy, 0.0) + pf(6u + i), 1e-14);
}
// `nrc_joint::distance`.
fn jdist(p: vec3<f32>, q: vec3<f32>) -> f32 {
let y = 0.5 * (p.x + q.x);
let t = 0.025 * max(y, 0.0);
let allowance = t * t;
var sum = 0.0;
for (var i = 0u; i < 3u; i++) {
let v = nvar(i, y);
let d = jvc(p, i) - jvc(q, i);
let excess = max(d * d - v, 0.0);
if (excess != 0.0) {
sum += excess / (3.0 * pf(12u) * v + allowance);
}
}
return sum;
}
// `nrc_joint::weight`.
fn jweight(d: f32, p: f32) -> f32 {
let m = max(d, p);
return select(exp(-m), 1.0, m == 0.0);
}
// `nrc_joint::yuv` of pixel `i` of image `a`.
fn jyuv(i: u32) -> vec3<f32> {
let c = ja(i);
let y = lum2020(c);
return vec3<f32>(y, c.x - y, c.z - y);
}
// `nrc_joint::yuv` of `n` pixels of image `a` from pixel P[1] on (a band's rows): P[0] = n.
@compute @workgroup_size(256)
fn nrcj_yuv(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let c = jyuv(pu(1u) + i);
dst[3u * i] = c.x;
dst[3u * i + 1u] = c.y;
dst[3u * i + 2u] = c.z;
}
// The chroma pair (R−Y, B−Y) of the transformed image `a` (P[0] = n).
@compute @workgroup_size(256)
fn nrcj_uv(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
dst[2u * i] = a[3u * i + 1u];
dst[2u * i + 1u] = a[3u * i + 2u];
}
// Noise samples of image `a`, transformed on the fly (`nrc_joint::noise_model`): P[0] = sample count,
// P[1] = w, P[2] = h, P[3] = stride. Per sample 11 values: valid, brightness, 3 × 3 residuals.
@compute @workgroup_size(256)
fn nrcj_samples(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let k = lin_index(g, nw);
if (k >= pu(0u)) {
return;
}
let w = pu(1u);
let h = pu(2u);
let index = k * pu(3u);
let x = index % w;
let y = index / w;
let o = 11u * k;
if (x == 0u || y == 0u || x + 1u == w || y + 1u == h) {
dst[o] = 0.0;
return;
}
let c = jyuv(index);
var brightness = 0.0;
for (var s = 0u; s < 3u; s++) {
let d = min(min(min(min(1u << s, x), y), w - x - 1u), h - y - 1u);
var m = vec3<f32>(0.0);
m = m + 0.25 * jyuv(index - d);
m = m + 0.25 * jyuv(index + d);
m = m + 0.25 * jyuv(index - d * w);
m = m + 0.25 * jyuv(index + d * w);
let r = c - m;
dst[o + 2u + 3u * s] = r.x * r.x;
dst[o + 3u + 3u * s] = r.y * r.y;
dst[o + 4u + 3u * s] = r.z * r.z;
brightness += m.x / 3.0;
}
dst[o] = 1.0;
dst[o + 1u] = max(brightness, 0.0);
}
// `nrc_joint::median8`: the same 19-comparator network, on plain variables (a private array indexed in a
// loop ends up in slow local memory on some GPUs).
fn med8(v0: f32, v1: f32, v2: f32, v3: f32, v4: f32, v5: f32, v6: f32, v7: f32) -> f32 {
var a = v0;
var b = v1;
var c = v2;
var d = v3;
var e = v4;
var f = v5;
var g = v6;
var h = v7;
let t0 = min(a, c);
c = max(a, c);
a = t0;
let t1 = min(b, d);
d = max(b, d);
b = t1;
let t2 = min(e, g);
g = max(e, g);
e = t2;
let t3 = min(f, h);
h = max(f, h);
f = t3;
let t4 = min(a, e);
e = max(a, e);
a = t4;
let t5 = min(b, f);
f = max(b, f);
b = t5;
let t6 = min(c, g);
g = max(c, g);
c = t6;
let t7 = min(d, h);
h = max(d, h);
d = t7;
let t8 = min(a, b);
b = max(a, b);
a = t8;
let t9 = min(c, d);
d = max(c, d);
c = t9;
let t10 = min(e, f);
f = max(e, f);
e = t10;
let t11 = min(g, h);
h = max(g, h);
g = t11;
let t12 = min(c, e);
e = max(c, e);
c = t12;
let t13 = min(d, f);
f = max(d, f);
d = t13;
let t14 = min(b, e);
e = max(b, e);
b = t14;
let t15 = min(d, g);
g = max(d, g);
d = t15;
let t16 = min(b, c);
c = max(b, c);
b = t16;
let t17 = min(d, e);
e = max(d, e);
d = t17;
let t18 = min(f, g);
g = max(f, g);
f = t18;
return 0.5 * (d + e);
}
// The farther of a value's distances to the least and largest of 8 (`speck_share`'s pre-test).
fn reach8(p: f32, v0: f32, v1: f32, v2: f32, v3: f32, v4: f32, v5: f32, v6: f32, v7: f32) -> f32 {
let lo = min(min(min(v0, v1), min(v2, v3)), min(min(v4, v5), min(v6, v7)));
let hi = max(max(max(v0, v1), max(v2, v3)), max(max(v4, v5), max(v6, v7)));
return max(abs(p - lo), abs(p - hi));
}
// The two largest values so far (`t.x` ≥ `t.y`) with `s` added, as the CPU's fold.
fn top2(t: vec2<f32>, s: f32) -> vec2<f32> {
return select(vec2<f32>(t.x, max(t.y, s)), vec2<f32>(s, t.x), s > t.x);
}
// One border pixel's share of the colour shift (`speck_share`).
fn sshare(q: vec3<f32>, m: vec3<f32>, du: f32, dv: f32, vu: f32, vv: f32, excess: f32) -> f32 {
return ((q.y - m.y) * du / vu + (q.z - m.z) * dv / vv) / excess;
}
// `nrc_joint::despeck` + `speck_share`: `a` = transformed image, writes it with the chroma of compact
// colour specks replaced. Noise parameters as `nrcj_pilot`; P[13] = threshold, P[14] = share.
@compute @workgroup_size(256)
fn nrcj_speck(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let w = pu(1u);
let h = pu(2u);
let x = i % w;
let y = i / w;
let p = ja(i);
var o = p;
if (x >= 2u && y >= 2u && x + 2u < w && y + 2u < h) {
let threshold = pf(13u);
let share = pf(14u);
let up = i - 2u * w;
let dn = i + 2u * w;
// ring: corners and edge centres of the 5 × 5 square (in the CPU's order)
let r0 = ja(up - 2u);
let r1 = ja(up);
let r2 = ja(up + 2u);
let r3 = ja(i - 2u);
let r4 = ja(i + 2u);
let r5 = ja(dn - 2u);
let r6 = ja(dn);
let r7 = ja(dn + 2u);
let ym = (((((((r0.x + r1.x) + r2.x) + r3.x) + r4.x) + r5.x) + r6.x) + r7.x) / 8.0;
let vu = nvar(1u, ym);
let vv = nvar(2u, ym);
let bu = reach8(p.y, r0.y, r1.y, r2.y, r3.y, r4.y, r5.y, r6.y, r7.y);
let bv = reach8(p.z, r0.z, r1.z, r2.z, r3.z, r4.z, r5.z, r6.z, r7.z);
if (bu * bu / vu + bv * bv / vv > threshold) {
var m = vec3<f32>(0.0, med8(r0.y, r1.y, r2.y, r3.y, r4.y, r5.y, r6.y, r7.y), med8(r0.z, r1.z, r2.z, r3.z, r4.z, r5.z, r6.z, r7.z));
let du = p.y - m.y;
let dv = p.z - m.z;
let excess = du * du / vu + dv * dv / vv;
if (excess > threshold) {
m.x = med8(r0.x, r1.x, r2.x, r3.x, r4.x, r5.x, r6.x, r7.x);
let dy = p.x - m.x;
let luminance = dy * dy / nvar(0u, ym);
let alone = clamp((1.5 * excess - luminance) / excess, 0.0, 1.0);
if (alone > 0.0) {
// the two largest border shares (`speck_share`)
var top = vec2<f32>(0.0, 0.0);
top = top2(top, sshare(r0, m, du, dv, vu, vv, excess));
top = top2(top, sshare(r1, m, du, dv, vu, vv, excess));
top = top2(top, sshare(r2, m, du, dv, vu, vv, excess));
top = top2(top, sshare(r3, m, du, dv, vu, vv, excess));
top = top2(top, sshare(r4, m, du, dv, vu, vv, excess));
top = top2(top, sshare(r5, m, du, dv, vu, vv, excess));
top = top2(top, sshare(r6, m, du, dv, vu, vv, excess));
top = top2(top, sshare(r7, m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(up - 1u), m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(up + 1u), m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(i - w - 2u), m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(i - w + 2u), m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(i + w - 2u), m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(i + w + 2u), m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(dn - 1u), m, du, dv, vu, vv, excess));
top = top2(top, sshare(ja(dn + 1u), m, du, dv, vu, vv, excess));
let compact = clamp((0.8 - top.y) / 0.3, 0.0, 1.0);
let t = clamp((excess - threshold) / threshold, 0.0, 1.0);
let k = share * t * t * (3.0 - 2.0 * t) * alone * compact;
if (k > 0.0) {
o.y += k * (m.y - p.y);
o.z += k * (m.z - p.z);
}
}
}
}
}
dst[3u * i] = o.x;
dst[3u * i + 1u] = o.y;
dst[3u * i + 2u] = o.z;
}
// `nrc_joint::pilot`: `a` = transformed image, `b` = its gaussian(0.8); writes the guide.
@compute @workgroup_size(256)
fn nrcj_pilot(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let w = pu(1u);
let h = pu(2u);
let x = i % w;
let y = i / w;
var out = jb3(i);
if (!(x == 0u || y == 0u || x + 1u == w || y + 1u == h)) {
let p = ja(i);
// 9 · noise variance per component, at the pixel's luminance
let nv = 9.0 * vec3<f32>(nvar(0u, p.x), nvar(1u, p.x), nvar(2u, p.x));
// axis 0 (left/right) and axis 1 (up/down), written out: private arrays indexed in a loop end up in
// slow local memory on some GPUs
let qa = ja(i - 1u);
let qb = ja(i + 1u);
let mh = (qa + p + qb) / 3.0;
let ha = qa - mh;
let hp = p - mh;
let hb = qb - mh;
let th = (ha * ha + hp * hp + hb * hb) / nv;
let vh = th.x + th.y + th.z;
let ua = ja(i - w);
let ub = ja(i + w);
let mv = (ua + p + ub) / 3.0;
let va = ua - mv;
let vp = p - mv;
let vb = ub - mv;
let tv = (va * va + vp * vp + vb * vb) / nv;
let vvar = tv.x + tv.y + tv.z;
// the axis choice fades in between 0.8 and 1.25 times its bound (nrc_joint::pilot_pick)
let sv = smoothstep(0.8, 1.25, vh / max(4.0, 4.0 * vvar));
let sh = smoothstep(0.8, 1.25, vvar / max(4.0, 4.0 * vh));
if (sv >= 1.0) {
out = mv;
} else if (sh >= 1.0) {
out = mh;
} else {
out = out + (mv - out) * sv + (mh - out) * sh;
}
}
dst[3u * i] = out.x;
dst[3u * i + 1u] = out.y;
dst[3u * i + 2u] = out.z;
}
// Paths of the direct neighbours, exp(−distance) (1 where there is no pair): `a` = guide; writes path pairs.
@compute @workgroup_size(256)
fn nrcj_links1(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let w = pu(1u);
let h = pu(2u);
let x = i % w;
let y = i / w;
let p = ja(i);
var q = vec2<f32>(1.0);
if (x + 1u < w) {
let d = jdist(p, ja(i + 1u));
q.x = jweight(d, d);
}
if (y + 1u < h) {
let d = jdist(p, ja(i + w));
q.y = jweight(d, d);
}
dst[2u * i] = q.x;
dst[2u * i + 1u] = q.y;
}
// Paths of length 2·delta from those of length delta (`a`, path pairs): their minimum. P[3] = delta.
@compute @workgroup_size(256)
fn nrcj_paths(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let w = pu(1u);
let h = pu(2u);
let delta = pu(3u);
let x = i % w;
let y = i / w;
var ph = a[2u * i];
var pv = a[2u * i + 1u];
if (x + delta < w) {
ph = min(ph, a[2u * (i + delta)]);
}
if (y + delta < h) {
pv = min(pv, a[2u * (i + delta * w) + 1u]);
}
dst[2u * i] = ph;
dst[2u * i + 1u] = pv;
}
// `nrc_joint::path_weight`.
fn jpweight(d: f32, path: f32) -> f32 {
return select(min(exp(-d), path), path, d == 0.0);
}
// The pair weights at distance `next` from the guide (`a`) and the paths (`b`); writes weight pairs.
// Noise parameters as `nrcj_pilot`; P[13] = next.
@compute @workgroup_size(256)
fn nrcj_links(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let w = pu(1u);
let h = pu(2u);
let next = pu(13u);
let x = i % w;
let y = i / w;
let p = ja(i);
var lh = 0.0;
var lv = 0.0;
let ph = b[2u * i];
let pv = b[2u * i + 1u];
if (x + next < w && ph > 0.0) {
lh = jpweight(jdist(p, ja(i + next)), ph);
}
if (y + next < h && pv > 0.0) {
lv = jpweight(jdist(p, ja(i + next * w)), pv);
}
dst[2u * i] = lh;
dst[2u * i + 1u] = lv;
}
// One horizontal diffusion step (`nrc_joint::diffuse_h`): `a` = chroma pairs, `b` = weight pairs.
// P[0] = n, P[1] = w, P[2] = h, P[3] = delta, P[4] = rate.
@compute @workgroup_size(256)
fn nrcj_dh(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let w = pu(1u);
let delta = pu(3u);
let rate = pf(4u);
let x = i % w;
let p = ja2(i);
var o = p;
if (x >= delta) {
o += rate * b[2u * (i - delta)] * (ja2(i - delta) - p);
}
if (x + delta < w) {
o += rate * b[2u * i] * (ja2(i + delta) - p);
}
dst[2u * i] = o.x;
dst[2u * i + 1u] = o.y;
}
// One vertical diffusion step (`nrc_joint::v_row`), parameters as `nrcj_dh`.
@compute @workgroup_size(256)
fn nrcj_dv(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let i = lin_index(g, nw);
if (i >= pu(0u)) {
return;
}
let w = pu(1u);
let h = pu(2u);
let delta = pu(3u);
let rate = pf(4u);
let y = i / w;
let p = ja2(i);
var o = p;
if (y >= delta) {
o += rate * b[2u * (i - delta * w) + 1u] * (ja2(i - delta * w) - p);
}
if (y + delta < h) {
o += rate * b[2u * i + 1u] * (ja2(i + delta * w) - p);
}
dst[2u * i] = o.x;
dst[2u * i + 1u] = o.y;
}
// Back to RGB with the image's own luminance, blended by the strength: `a` = image, `b` = a band's
// filtered chroma pairs, `dst` = the whole output. P[0] = pixels written, P[1] = strength,
// P[2] = first pixel written (in the image), P[3] = first pixel of the band (in the image).
@compute @workgroup_size(256)
fn nrcj_recon(@builtin(global_invocation_id) g: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>) {
let k = lin_index(g, nw);
if (k >= pu(0u)) {
return;
}
let s = pf(1u);
let i = pu(2u) + k;
let bi = i - pu(3u);
let p = ja(i);
let y = lum2020(p);
let r = y + b[2u * bi];
let bl = y + b[2u * bi + 1u];
let res = vec3<f32>(r, (y - 0.2627 * r - 0.0593 * bl) / 0.6780, bl);
let o = p + s * (res - p);
dst[3u * i] = o.x;
dst[3u * i + 1u] = o.y;
dst[3u * i + 2u] = o.z;
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.