diff --git a/cmd/mxl-pattern/main.go b/cmd/mxl-pattern/main.go index 24db40e..213e980 100644 --- a/cmd/mxl-pattern/main.go +++ b/cmd/mxl-pattern/main.go @@ -198,9 +198,21 @@ var patterns = map[string]pattern{ kernelPath: "kernels/dynamic/smpteBars.wgsl", motion: true, }, + "gray-bars": { + name: "gray-bars", + description: "13-step grayscale bars (Y 64..940)", + kernelPath: "kernels/static/yBars.wgsl", + motion: false, + }, + "gray-bars-move": { + name: "gray-bars-move", + description: "13-step grayscale bars (Y 64..940) with moving square", + kernelPath: "kernels/dynamic/yBars.wgsl", + motion: false, + }, "gray-ramp": { name: "gray-ramp", - description: "Y gradient", + description: "Y gradient (black -> 100% white)", kernelPath: "kernels/static/yRamp.wgsl", motion: false, }, diff --git a/kernels/dynamic/yBars.wgsl b/kernels/dynamic/yBars.wgsl new file mode 100644 index 0000000..0e6b9fd --- /dev/null +++ b/kernels/dynamic/yBars.wgsl @@ -0,0 +1,71 @@ +// 13-step grayscale bars (Y 64..940 in even 73-code steps), Rec.709, 10-bit +// Y'CbCr, packed as v210 (4:2:2). Chroma neutral. +// One work-item per 16-byte block = 6 pixels (6 Y + 3 Cb + 3 Cr). + +struct Params { + width: u32, + height: u32, + frame: u32, // animation tick (0,1,2,... per generated frame), NOT the raw grain index + _pad0: u32, +}; + +@group(0) @binding(0) var out: array; +@group(0) @binding(1) var params: Params; + +fn bar_index(px: u32) -> u32 { + return min((px * 13u) / params.width, 12u); +} + +@compute @workgroup_size(64) +fn main(@builtin(global_invocation_id) gid: vec3) { + let block = gid.x; + let total = (params.width * params.height) / 6u; + if (block >= total) { + return; + } + + let y_tab = array(64u, 137u, 210u, 283u, 356u, 429u, 502u, 575u, 648u, 721u, 794u, 867u, 940u); + + let x = (block * 6u) % params.width; + let py = (block * 6u) / params.width; + // Moving square: horizontal oscillation around screen center. + // frame is a small tick; converting the huge raw grain index here + // would destroy f32 precision and freeze the motion. + let centerX = f32(params.width) / 2.0; + let centerY = f32(params.height) / 2.0; + let fps = 25.0; + let t = f32(params.frame) / fps; + const squareSize = 150u; + let half = f32(squareSize) / 2.0; + let offsetPixels = sin(t * 0.5) * (centerX - half); + + let sq_x_min = centerX - half + offsetPixels; + let sq_x_max = centerX + half + offsetPixels; + let sq_y_min = centerY - half; + let sq_y_max = centerY + half; + let py_f = f32(py); + + var y: array; + var cb: array; + var cr: array; + for (var i = 0u; i < 6u; i++) { + let b = bar_index(x + i); + let px = f32(x + i); + y[i] = y_tab[b]; + cb[i] = 512u; + cr[i] = 512u; + if (px >= sq_x_min && px < sq_x_max && py_f >= sq_y_min && py_f < sq_y_max) { + y[i] = 1004u - y[i]; + cb[i] = 1024u - cb[i]; + cr[i] = 1024u - cr[i]; + } + } + + // v210 word layout, chroma co-sited with luma samples 0/2/4: + // w0 = Cb0|Y0<<10|Cr0<<20; w1 = Y1|Cb2<<10|Y2<<20; + // w2 = Cr2|Y3<<10|Cb4<<20; w3 = Y4|Cr4<<10|Y5<<20 + out[block * 4u + 0u] = (cb[0] & 0x3FFu) | ((y[0] & 0x3FFu) << 10u) | ((cr[0] & 0x3FFu) << 20u); + out[block * 4u + 1u] = (y[1] & 0x3FFu) | ((cb[2] & 0x3FFu) << 10u) | ((y[2] & 0x3FFu) << 20u); + out[block * 4u + 2u] = (cr[2] & 0x3FFu) | ((y[3] & 0x3FFu) << 10u) | ((cb[4] & 0x3FFu) << 20u); + out[block * 4u + 3u] = (y[4] & 0x3FFu) | ((cr[4] & 0x3FFu) << 10u) | ((y[5] & 0x3FFu) << 20u); +} diff --git a/kernels/static/yBars.wgsl b/kernels/static/yBars.wgsl new file mode 100644 index 0000000..89b610d --- /dev/null +++ b/kernels/static/yBars.wgsl @@ -0,0 +1,48 @@ +// 13-step grayscale bars (Y 64..940 in even 73-code steps), Rec.709, 10-bit +// Y'CbCr, packed as v210 (4:2:2). Chroma neutral. +// One work-item per 16-byte block = 6 pixels (6 Y + 3 Cb + 3 Cr). + +struct Params { + width: u32, + height: u32, + frame: u32, // animation tick (0,1,2,... per generated frame), NOT the raw grain index + _pad0: u32, +}; + +@group(0) @binding(0) var out: array; +@group(0) @binding(1) var params: Params; + +fn bar_index(px: u32) -> u32 { + return min((px * 13u) / params.width, 12u); +} + +@compute @workgroup_size(64) +fn main(@builtin(global_invocation_id) gid: vec3) { + let block = gid.x; + let total = (params.width * params.height) / 6u; + if (block >= total) { + return; + } + + let y_tab = array(64u, 137u, 210u, 283u, 356u, 429u, 502u, 575u, 648u, 721u, 794u, 867u, 940u); + + // 6 = pixels per v210 block (NOT the bar count) + let x = (block * 6u) % params.width; + var y: array; + var cb: array; + var cr: array; + for (var i = 0u; i < 6u; i++) { + let b = bar_index(x + i); + y[i] = y_tab[b]; + cb[i] = 512u; + cr[i] = 512u; + } + + // v210 word layout, chroma co-sited with luma samples 0/2/4: + // w0 = Cb0|Y0<<10|Cr0<<20; w1 = Y1|Cb2<<10|Y2<<20; + // w2 = Cr2|Y3<<10|Cb4<<20; w3 = Y4|Cr4<<10|Y5<<20 + out[block * 4u + 0u] = (cb[0] & 0x3FFu) | ((y[0] & 0x3FFu) << 10u) | ((cr[0] & 0x3FFu) << 20u); + out[block * 4u + 1u] = (y[1] & 0x3FFu) | ((cb[2] & 0x3FFu) << 10u) | ((y[2] & 0x3FFu) << 20u); + out[block * 4u + 2u] = (cr[2] & 0x3FFu) | ((y[3] & 0x3FFu) << 10u) | ((cb[4] & 0x3FFu) << 20u); + out[block * 4u + 3u] = (y[4] & 0x3FFu) | ((cr[4] & 0x3FFu) << 10u) | ((y[5] & 0x3FFu) << 20u); +} diff --git a/kernels/static/yRamp.wgsl b/kernels/static/yRamp.wgsl new file mode 100644 index 0000000..7ce195a --- /dev/null +++ b/kernels/static/yRamp.wgsl @@ -0,0 +1,49 @@ +// 75% SMPTE color bars + moving square, Rec.709, 10-bit Y'CbCr, packed as v210 (4:2:2). +// One work-item per 16-byte block = 6 pixels (6 Y + 3 Cb + 3 Cr). + +struct Params { + width: u32, + height: u32, + frame: u32, // animation tick (0,1,2,... per generated frame), NOT the raw grain index + _pad0: u32, +}; + +@group(0) @binding(0) var out: array; +@group(0) @binding(1) var params: Params; + +fn bar_index(px: u32) -> u32 { + return min((px * 7u) / params.width, 6u); +} + +@compute @workgroup_size(64) +fn main(@builtin(global_invocation_id) gid: vec3) { + let block = gid.x; + let total = (params.width * params.height) / 6u; + if (block >= total) { + return; + } + + // Bar order: 75% white, yellow, cyan, green, magenta, red, blue + let y_tab = array(721u, 674u, 581u, 534u, 251u, 204u, 111u); + let cb_tab = array(512u, 176u, 589u, 253u, 771u, 435u, 848u); + let cr_tab = array(512u, 543u, 176u, 207u, 817u, 848u, 481u); + + let x = (block * 6u) % params.width; + var y: array; + var cb: array; + var cr: array; + for (var i = 0u; i < 6u; i++) { + let px = f32(x + i); + y[i] = 64u + (u32(px) * 876u) / params.width; + cb[i] = 512u; + cr[i] = 512u; + } + + // v210 word layout, chroma co-sited with luma samples 0/2/4: + // w0 = Cb0|Y0<<10|Cr0<<20; w1 = Y1|Cb2<<10|Y2<<20; + // w2 = Cr2|Y3<<10|Cb4<<20; w3 = Y4|Cr4<<10|Y5<<20 + out[block * 4u + 0u] = (cb[0] & 0x3FFu) | ((y[0] & 0x3FFu) << 10u) | ((cr[0] & 0x3FFu) << 20u); + out[block * 4u + 1u] = (y[1] & 0x3FFu) | ((cb[2] & 0x3FFu) << 10u) | ((y[2] & 0x3FFu) << 20u); + out[block * 4u + 2u] = (cr[2] & 0x3FFu) | ((y[3] & 0x3FFu) << 10u) | ((cb[4] & 0x3FFu) << 20u); + out[block * 4u + 3u] = (y[4] & 0x3FFu) | ((cr[4] & 0x3FFu) << 10u) | ((y[5] & 0x3FFu) << 20u); +}