summaryrefslogtreecommitdiff
path: root/examples/micscope
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 00:19:38 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commitc37f1b3b1374df2a2a434d16cd772a4bb00c567e (patch)
tree4feccf16cf1f6808bae6ba26602705d557ab2fb7 /examples/micscope
parent9bd77e54943d954291b5faef287ccca5dcebd7a4 (diff)
downloadsketchbook-c37f1b3b1374df2a2a434d16cd772a4bb00c567e.tar.gz
sketchbook-c37f1b3b1374df2a2a434d16cd772a4bb00c567e.zip
micscope: on the scope module, its copy of the scope code gone
micscope carried the code the scope module was lifted from: seven shaders byte for byte, its layouts but for a comment, and a private live view (Live, analyseLive, drawLive) that was Scope.push, scroll and spectrum. Now the live view is ss.live, a scope.Scope, pushed the microphone and drawn with the panel's world rects and the camera (Views.camera), every frame, clipped away while a recording stands in for it so its columns keep up as before; the tuner reads its history from ss.live.gpu.tape. The take panels run scope.kernels and scope.pipelines over the tape with scope.layouts' blocks, wavePass and spectrogramPass inlined at their one use; maxFreq, min_freq and floor_db are the scope's. src/layouts.zig keeps only the tuner's blocks, the build compiles only the tuner's two shaders, and the tuner names notes with scope.midi, scope.hz and scope.note_names. Takes, transport and tuner are as they were. 1003 lines out, 91 in. Tests: zig build test, 67/67 steps, 10/10 tests (the live history's own test went with it; the scope module tests the same). Pictures: the four scripts' 18 screenshots, captured before and after with the same scripts and compared pixel by pixel (two runs before differ by themselves wherever wall-clock playback or microphone timing shows: the playheads, how far the live view has filled). The one difference not of that kind is the live spectrum: micscope made every image at most 132 rows, so its 184-row spectrum was stretched from 132; the scope makes it at its size, so the live spectrum's lines come out crisp (at most 86 in a channel, inside its rect). The take spectra keep micscope's 132. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'examples/micscope')
-rw-r--r--examples/micscope/README.md7
-rw-r--r--examples/micscope/build.zig15
-rw-r--r--examples/micscope/shaders/spectrogram.comp208
-rw-r--r--examples/micscope/shaders/spectrogram.frag45
-rw-r--r--examples/micscope/shaders/spectrum.comp128
-rw-r--r--examples/micscope/shaders/spectrum.frag51
-rw-r--r--examples/micscope/shaders/view.vert7
-rw-r--r--examples/micscope/shaders/waveform.comp72
-rw-r--r--examples/micscope/shaders/waveform.frag56
-rw-r--r--examples/micscope/src/layouts.zig125
-rw-r--r--examples/micscope/src/main.zig353
-rw-r--r--examples/micscope/src/tuner.zig25
12 files changed, 90 insertions, 1002 deletions
diff --git a/examples/micscope/README.md b/examples/micscope/README.md
index 759c27c..bd55ee0 100644
--- a/examples/micscope/README.md
+++ b/examples/micscope/README.md
@@ -26,6 +26,11 @@ piccolo's top, against any A4 (`[` and `]`, 440 Hz by default).
Panels are rendered at world resolution and the camera only scales them,
so moving or zooming it recomputes nothing.
+The waveform, spectrogram and spectrum shaders are sketchbook's `scope`
+module's (`src/scope/shaders/`): the live view is a `scope.Scope`, and the
+take panels run `scope.kernels` and `scope.pipelines` over the tape. The
+tuner's are micscope's own.
+
| Shader | Does |
| --- | --- |
| `spectrum.comp` | Blackman-Harris window around the playhead, zero-padded 2×, radix-2 Stockham FFT (8192 points, one workgroup), dBFS per bin, then one value per log-spaced pixel column: a Catmull-Rom spline through the bins where columns are narrower than a bin, the loudest bin where they span several. Smoothed in time (fast attack, slow release) with falling peaks. |
@@ -39,7 +44,7 @@ offset), uploaded once. A take's waveform and spectrogram are recomputed
only when its view changes, and its panel redrawn only when something on
it moved; only the selected take's spectrum runs every frame.
-The live view uploads the microphone's last 1.4 s each frame and analyses
+The live view (the scope module's) uploads the microphone's last 1.4 s each frame and analyses
only the columns that became complete, into ring buffers the fragment
shaders read from the oldest column. A column waits until everything its
spectrogram windows reach has been heard (6160 samples past its centre),
diff --git a/examples/micscope/build.zig b/examples/micscope/build.zig
index 0853cdc..2de639d 100644
--- a/examples/micscope/build.zig
+++ b/examples/micscope/build.zig
@@ -6,19 +6,13 @@ pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const sb = sketchbook.init(b, .{ .target = target, .optimize = optimize });
- // The shaders, as SPIR-V for the native host and WGSL for the web; their
- // uniform blocks come from the Zig structs in src/layouts.zig.
+ // The tuner's shaders, as SPIR-V for the native host and WGSL for the
+ // web; their uniform blocks come from the Zig structs in src/layouts.zig.
+ // The waveform, spectrogram and spectrum are the scope module's.
const layouts = b.createModule(.{ .root_source_file = b.path("src/layouts.zig") });
const shaders = sb.addShaders(.{
- .layouts = .{ .module = layouts, .types = &.{ "SpectrumParams", "WaveParams", "WaveView", "SpectrumView", "SpectrogramParams", "SpectrogramView", "TunerParams" } },
+ .layouts = .{ .module = layouts, .types = &.{"TunerParams"} },
.sources = &.{
- b.path("shaders/view.vert"),
- b.path("shaders/waveform.comp"),
- b.path("shaders/waveform.frag"),
- b.path("shaders/spectrogram.comp"),
- b.path("shaders/spectrogram.frag"),
- b.path("shaders/spectrum.comp"),
- b.path("shaders/spectrum.frag"),
b.path("shaders/tuner_difference.comp"),
b.path("shaders/tuner.comp"),
},
@@ -30,6 +24,7 @@ pub fn build(b: *std.Build) void {
.imports = &.{
.{ .name = "layouts", .module = layouts },
.{ .name = "shaders", .module = shaders.module },
+ .{ .name = "scope", .module = sb.modules.scope },
},
});
const steps = app.addSteps(.{
diff --git a/examples/micscope/shaders/spectrogram.comp b/examples/micscope/shaders/spectrogram.comp
deleted file mode 100644
index b32f4c5..0000000
--- a/examples/micscope/shaders/spectrogram.comp
+++ /dev/null
@@ -1,208 +0,0 @@
-#version 450
-#extension GL_GOOGLE_include_directive : require
-// The spectrogram, one workgroup per column, the same columns as the
-// waveform (waveform.comp), so the two line up in time.
-//
-// Two resolutions per column, because one window cannot serve both ends of
-// a log axis: 2048 samples resolve 23 Hz, which is sharp in time and fine
-// in the kilohertz, but leaves 20 to 100 Hz (a quarter of the height) to
-// four bins. So the low end is analysed again from the signal low-passed
-// and decimated to a quarter of the rate: the same 2048 points then span
-// 170 ms and resolve 6 Hz. Rows take the long analysis below 250 Hz, the
-// short one above 500 Hz, and blend in between.
-//
-// A single window's spectrum of noise scatters as much as its level (each
-// bin is chi-squared with 2 degrees of freedom), which in dB shows as
-// speckle full of black holes, and finer bins only make more of them. So
-// the long analysis averages three windows a quarter window apart in time
-// (Welch): steady lines stay as sharp, noise settles. Multitaper averaging
-// was tried and measured against a reference (see test/README.md): sine
-// tapers and DPSS both widen narrow lines into slabs and leak, which a
-// 96 dB scale shows.
-//
-// Each analysis is a Blackman-Harris window zero-padded to 4096 points,
-// transformed as 2048 complex points (even and odd samples as real and
-// imaginary parts) by an in-place radix-2 FFT in shared memory, then split
-// into the real signal's bins. Zoomed out, a column averages the power of
-// up to four windows spread across its samples, so it neither skips sound
-// nor flickers as the view moves; zoomed in, neighbouring windows overlap.
-// Rows are log-spaced: a Catmull-Rom spline through the bins' levels where
-// rows are finer than bins, the loudest bin where they are coarser.
-layout(local_size_x = 256) in;
-
-#include "SpectrogramParams.glsl"
-
-layout(set = 0, binding = 0) readonly buffer Tape { float tape[]; };
-// MAX_ROWS rows of MAX_COLUMNS levels, dBFS; row 0 is the lowest frequency.
-layout(set = 1, binding = 0) buffer Levels { float levels[]; };
-
-// Match layouts.zig.
-const uint MAX_COLUMNS = 2048;
-const uint W = 2048;
-const uint N = 4096;
-const uint HALF = N / 2;
-const uint LOG2_HALF = 11;
-const uint THREADS = 256;
-// The long analysis: every DECIMATE-th sample of the low-passed signal.
-const uint DECIMATE = 4;
-// Its bins needed below the blend: 600 Hz at 12 kHz / 4096 is bin 205.
-const uint LONG_BINS = 256;
-// Windows the long analysis averages per column, a quarter window apart.
-const uint WELCH = 3;
-const float BLEND_LO = 250.0;
-const float BLEND_HI = 500.0;
-const float PI = 3.14159265358979;
-const float SILENCE = -160.0;
-// Columns past the end of the tape.
-const float NO_TAPE = 1000.0;
-const float A0 = 0.35875;
-const float A1 = 0.48829;
-const float A2 = 0.14128;
-const float A3 = 0.01168;
-
-shared vec2 z[HALF];
-// Power per bin, summed over windows; then dBFS.
-shared float short_bins[HALF + 1];
-shared float long_bins[LONG_BINS];
-
-float sample_at(int i) {
- return i >= 0 && i < int(u.samples) ? tape[u.offset + uint(i)] : 0.0;
-}
-
-// The signal low-passed for decimation: a triangle over 7 samples (two
-// boxes of 4), whose zeros sit on 12 and 24 kHz, exactly where anything
-// that would fold onto the low bins comes from.
-float low_passed(int i) {
- return (sample_at(i - 3) + 2.0 * sample_at(i - 2) + 3.0 * sample_at(i - 1) + 4.0 * sample_at(i) + 3.0 * sample_at(i + 1) + 2.0 * sample_at(i + 2) + sample_at(i + 3)) / 16.0;
-}
-
-float blackman_harris(uint i) {
- float a = 2.0 * PI * float(i) / float(W - 1);
- return A0 - A1 * cos(a) + A2 * cos(2.0 * a) - A3 * cos(3.0 * a);
-}
-
-vec2 mul(vec2 a, vec2 b) {
- return vec2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
-}
-
-float windowed(int centre, uint i, bool long_window) {
- if (long_window) return low_passed(centre + (int(i) - int(W / 2)) * int(DECIMATE)) * blackman_harris(i);
- return sample_at(centre + int(i) - int(W / 2)) * blackman_harris(i);
-}
-
-// Adds the power spectrum of the window centred on sample `centre`.
-void analyse(int centre, bool long_window) {
- uint t = gl_LocalInvocationID.x;
- // Even and odd samples packed as one complex sequence, in bit-reversed
- // order for the in-place transform. Past W it is all padding.
- for (uint i = t; i < HALF; i += THREADS) {
- vec2 v = vec2(0.0);
- if (2u * i < W) v = vec2(windowed(centre, 2u * i, long_window), windowed(centre, 2u * i + 1u, long_window));
- z[bitfieldReverse(i) >> (32u - LOG2_HALF)] = v;
- }
- barrier();
- for (uint s = 1u; s <= LOG2_HALF; s++) {
- uint half_size = 1u << (s - 1u);
- for (uint j = t; j < HALF / 2u; j += THREADS) {
- uint k = j & (half_size - 1u);
- uint i0 = ((j >> (s - 1u)) << s) + k;
- uint i1 = i0 + half_size;
- float angle = -PI * float(k) / float(half_size);
- vec2 b = mul(vec2(cos(angle), sin(angle)), z[i1]);
- vec2 a = z[i0];
- z[i0] = a + b;
- z[i1] = a - b;
- }
- barrier();
- }
- // The real signal's bins from the packed transform:
- // X[k] = E[k] + e^(-2 pi i k / N) O[k], with E and O the even and odd
- // samples' spectra, recovered from Z[k] and conj(Z[HALF - k]).
- uint count = long_window ? LONG_BINS : HALF + 1u;
- for (uint k = t; k < count; k += THREADS) {
- vec2 zk = z[k % HALF];
- vec2 zc = z[(HALF - k) % HALF];
- zc.y = -zc.y;
- vec2 even = 0.5 * (zk + zc);
- vec2 d = 0.5 * (zk - zc);
- vec2 odd = vec2(d.y, -d.x);
- float angle = -2.0 * PI * float(k) / float(N);
- vec2 x = even + mul(vec2(cos(angle), sin(angle)), odd);
- if (long_window) long_bins[k] += dot(x, x);
- else short_bins[k] += dot(x, x);
- }
- barrier();
-}
-
-float bin_level(uint k, bool long_window) {
- return long_window ? long_bins[min(k, LONG_BINS - 1u)] : short_bins[min(k, HALF)];
-}
-
-// The level of the row spanning bins `lo` to `hi` of one analysis.
-float row_level(float lo, float hi, bool long_window) {
- if (hi - lo < 1.0) {
- float mid = sqrt(lo * hi);
- uint i = uint(floor(mid));
- float f = mid - floor(mid);
- float p0 = bin_level(max(i, 1u) - 1u, long_window);
- float p1 = bin_level(i, long_window);
- float p2 = bin_level(i + 1u, long_window);
- float p3 = bin_level(i + 2u, long_window);
- float v = p1 + 0.5 * f * (p2 - p0 + f * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3 + f * (3.0 * (p1 - p2) + p3 - p0)));
- return clamp(v, SILENCE, max(max(p1, p2), max(p0, p3)));
- }
- float v = SILENCE;
- for (uint i = uint(floor(lo)); i <= uint(ceil(hi)); i++) v = max(v, bin_level(i, long_window));
- return v;
-}
-
-// Average power over `count` windows to dBFS: a full-scale sine at a bin's
-// centre gives (W * A0 / 2) squared.
-float to_db(float power, uint count) {
- float ratio = power / float(count) / (0.25 * float(W) * A0 * float(W) * A0);
- return ratio > 0.0 ? max(10.0 * log(ratio) / log(10.0), SILENCE) : SILENCE;
-}
-
-void main() {
- uint c = gl_WorkGroupID.x;
- uint t = gl_LocalInvocationID.x;
- for (uint k = t; k <= HALF; k += THREADS) short_bins[k] = 0.0;
- for (uint k = t; k < LONG_BINS; k += THREADS) long_bins[k] = 0.0;
- barrier();
-
- float start = float(c) * u.spp;
- uint short_windows = uint(clamp(ceil(u.spp / float(W / 2u)), 1.0, 4.0));
- for (uint w = 0u; w < short_windows; w++) {
- analyse(int(float(u.first) + start + u.spp * (float(w) + 0.5) / float(short_windows)), false);
- }
- // Zoomed out, the windows spread across the column average already;
- // zoomed in, WELCH windows a quarter window apart around its centre.
- uint long_windows = uint(clamp(ceil(u.spp / float(W * DECIMATE / 2u)), 1.0, 4.0));
- if (long_windows == 1u) {
- int centre = int(float(u.first) + start + 0.5 * u.spp);
- for (uint w = 0u; w < WELCH; w++) analyse(centre + (int(w) - int(WELCH / 2u)) * int(W * DECIMATE / 4u), true);
- long_windows = WELCH;
- } else {
- for (uint w = 0u; w < long_windows; w++) {
- analyse(int(float(u.first) + start + u.spp * (float(w) + 0.5) / float(long_windows)), true);
- }
- }
-
- for (uint k = t; k <= HALF; k += THREADS) short_bins[k] = to_db(short_bins[k], short_windows);
- for (uint k = t; k < LONG_BINS; k += THREADS) long_bins[k] = to_db(long_bins[k], long_windows);
- barrier();
-
- bool inside = float(u.first) + start < float(u.samples);
- float short_hz = u.rate / float(N);
- float long_hz = short_hz / float(DECIMATE);
- float ratio = log(u.max_freq / u.min_freq);
- for (uint r = t; r < u.rows; r += THREADS) {
- float lo = u.min_freq * exp(ratio * float(r) / float(u.rows));
- float hi = u.min_freq * exp(ratio * float(r + 1u) / float(u.rows));
- float blend = smoothstep(BLEND_LO, BLEND_HI, sqrt(lo * hi));
- float v = 0.0;
- if (blend < 1.0) v += (1.0 - blend) * row_level(lo / long_hz, hi / long_hz, true);
- if (blend > 0.0) v += blend * row_level(lo / short_hz, hi / short_hz, false);
- levels[r * MAX_COLUMNS + (u.slot + c) % u.ring] = inside ? v : NO_TAPE;
- }
-}
diff --git a/examples/micscope/shaders/spectrogram.frag b/examples/micscope/shaders/spectrogram.frag
deleted file mode 100644
index 9cb5e3d..0000000
--- a/examples/micscope/shaders/spectrogram.frag
+++ /dev/null
@@ -1,45 +0,0 @@
-#version 450
-#extension GL_GOOGLE_include_directive : require
-// The spectrogram (spectrogram.comp): time across, as the waveform above
-// it, log frequency up, each level through a heat gradient (inferno:
-// black, violet, red, orange, pale yellow), with the playhead.
-layout(location = 0) out vec4 out_color;
-
-#include "SpectrogramView.glsl"
-
-layout(set = 2, binding = 0) readonly buffer Levels { float levels[]; };
-
-// Match layouts.zig and spectrogram.comp.
-const uint MAX_COLUMNS = 2048;
-const float NO_TAPE = 1000.0;
-
-// Matplotlib's inferno, as a polynomial fit (Matt Zucker's, CC0).
-vec3 inferno(float t) {
- const vec3 c0 = vec3(0.0002189403691192265, 0.001651004631001012, -0.01948089843709184);
- const vec3 c1 = vec3(0.1065134194856116, 0.5639564367884091, 3.932712388889277);
- const vec3 c2 = vec3(11.60249308247187, -3.972853965665698, -15.9423941062914);
- const vec3 c3 = vec3(-41.70399613139459, 17.43639888205313, 44.35414519872813);
- const vec3 c4 = vec3(77.162935699427, -33.40235894210092, -81.80730925738993);
- const vec3 c5 = vec3(-71.31942824499214, 32.62606426397723, 73.20951985803202);
- const vec3 c6 = vec3(25.13112622477341, -12.24266895238567, -23.07032500287172);
- return clamp(c0 + t * (c1 + t * (c2 + t * (c3 + t * (c4 + t * (c5 + t * c6))))), 0.0, 1.0);
-}
-
-void main() {
- vec2 p = gl_FragCoord.xy;
- uint row = uint(u.size.y - p.y);
- uint x = uint(p.x);
- float db = levels[row * MAX_COLUMNS + (x + u.scroll) % uint(u.size.x)];
- if (x + u.filled < uint(u.size.x)) db = NO_TAPE;
- vec3 color = vec3(0.035, 0.03, 0.05);
- if (db < NO_TAPE) {
- float t = clamp((db - u.floor_db) / (u.ceil_db - u.floor_db), 0.0, 1.0);
- // A touch of contrast: quiet stays dark, loud blooms.
- color = inferno(pow(t, 1.3));
- }
- if (u.playhead >= 0.0) {
- float d = abs(p.x - u.playhead);
- color = mix(color, vec3(1.0, 0.85, 0.3), clamp(1.5 - d, 0.0, 1.0) * 0.8);
- }
- out_color = vec4(color, 1.0);
-}
diff --git a/examples/micscope/shaders/spectrum.comp b/examples/micscope/shaders/spectrum.comp
deleted file mode 100644
index e576e30..0000000
--- a/examples/micscope/shaders/spectrum.comp
+++ /dev/null
@@ -1,128 +0,0 @@
-#version 450
-#extension GL_GOOGLE_include_directive : require
-// The spectrum at the playhead, entirely on the GPU, in one workgroup:
-//
-// 1. a Blackman-Harris window of the tape ending at `u.end`, zero-padded to
-// N. Its sidelobes sit below -92 dB, so the finely sampled spectrum shows
-// the signal rather than the window's ripples;
-// 2. a radix-2 Stockham FFT, ping-ponging between the scratch halves;
-// 3. levels in dBFS per bin;
-// 4. one value per log-spaced column. Where columns are narrower than a bin
-// (the low end), a Catmull-Rom spline through the bins' levels; where a
-// column spans several bins (the high end), their loudest. The zero
-// padding already interpolates between the window's own bins, so the
-// curve is continuous at every zoom;
-// 5. smoothing in time (fast attack, slow release) and falling peaks, kept
-// in the column buffer between frames.
-layout(local_size_x = 256) in;
-
-#include "SpectrumParams.glsl"
-
-layout(set = 0, binding = 0) readonly buffer Tape { float tape[]; };
-// Two halves of N complex values, which the workgroup's threads read from
-// each other: coherent, for Vulkan; WGSL's storageBarrier covers it.
-#ifdef SKETCHBOOK_WEB
-layout(set = 1, binding = 0) buffer Scratch { vec2 scratch[]; };
-#else
-layout(set = 1, binding = 0) coherent buffer Scratch { vec2 scratch[]; };
-#endif
-// x: smoothed level, y: peak, both dBFS.
-layout(set = 1, binding = 1) buffer Columns { vec2 columns[]; };
-
-// Match layouts.zig.
-const uint N = 8192;
-const uint LOG2_N = 13;
-const uint W = 4096;
-const uint THREADS = 256;
-const float PI = 3.14159265358979;
-const float SILENCE = -160.0;
-// Blackman-Harris, 4 terms. A0 is also its coherent gain.
-const float A0 = 0.35875;
-const float A1 = 0.48829;
-const float A2 = 0.14128;
-const float A3 = 0.01168;
-
-void sync() {
- memoryBarrierBuffer();
- barrier();
-}
-
-void main() {
- uint t = gl_LocalInvocationID.x;
-
- // 1. Window.
- int first = int(u.end) - int(W);
- for (uint i = t; i < N; i += THREADS) {
- float x = 0.0;
- int at = first + int(i);
- if (i < W && at >= 0 && at < int(u.samples)) {
- float a = 2.0 * PI * float(i) / float(W - 1);
- x = tape[u.offset + uint(at)] * (A0 - A1 * cos(a) + A2 * cos(2.0 * a) - A3 * cos(3.0 * a));
- }
- scratch[i] = vec2(x, 0.0);
- }
- sync();
-
- // 2. FFT: after stage s, sub-transforms of 2p = 2^(s+1) points, in order.
- for (uint s = 0; s < LOG2_N; s++) {
- uint p = 1u << s;
- uint from = (s & 1u) * N;
- uint to = N - from;
- for (uint i = t; i < N / 2; i += THREADS) {
- uint k = i & (p - 1u);
- vec2 a = scratch[from + i];
- vec2 b = scratch[from + i + N / 2];
- float angle = -PI * float(k) / float(p);
- vec2 w = vec2(cos(angle), sin(angle));
- b = vec2(b.x * w.x - b.y * w.y, b.x * w.y + b.y * w.x);
- uint j = (i << 1u) - k;
- scratch[to + j] = a + b;
- scratch[to + j + p] = a - b;
- }
- sync();
- }
- uint result = (LOG2_N & 1u) * N;
-
- // 3. Levels into the other half. A full-scale sine peaks at W * A0 / 2:
- // the window sums to W * A0, and a real sine splits between ±f.
- uint levels = N - result;
- for (uint i = t; i <= N / 2; i += THREADS) {
- float amplitude = length(scratch[result + i]) * 2.0 / (float(W) * A0);
- scratch[levels + i].x = amplitude > 0.0 ? max(20.0 * log(amplitude) / log(10.0), SILENCE) : SILENCE;
- }
- sync();
-
- // 4 and 5. Columns.
- float bin_hz = u.rate / float(N);
- float ratio = log(u.max_freq / u.min_freq);
- for (uint c = t; c < u.columns; c += THREADS) {
- float lo = u.min_freq * exp(ratio * float(c) / float(u.columns)) / bin_hz;
- float hi = u.min_freq * exp(ratio * float(c + 1u) / float(u.columns)) / bin_hz;
- float mid = sqrt(lo * hi);
- float v;
- if (hi - lo < 1.0) {
- uint i = uint(floor(mid));
- float f = mid - floor(mid);
- float p0 = scratch[levels + min(max(i, 1u) - 1u, N / 2)].x;
- float p1 = scratch[levels + min(i, N / 2)].x;
- float p2 = scratch[levels + min(i + 1u, N / 2)].x;
- float p3 = scratch[levels + min(i + 2u, N / 2)].x;
- v = p1 + 0.5 * f * (p2 - p0 + f * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3 + f * (3.0 * (p1 - p2) + p3 - p0)));
- v = clamp(v, SILENCE, max(max(p1, p2), max(p0, p3)));
- } else {
- v = SILENCE;
- uint end = min(uint(ceil(hi)), N / 2);
- for (uint i = uint(floor(lo)); i <= end; i++) v = max(v, scratch[levels + i].x);
- }
- vec2 old = columns[c];
- vec2 now;
- if (u.reset != 0u) {
- now = vec2(v, v);
- } else {
- float rate = v > old.x ? 40.0 : 6.0;
- now.x = mix(old.x, v, 1.0 - exp(-rate * u.dt));
- now.y = max(now.x, old.y - 24.0 * u.dt);
- }
- columns[c] = now;
- }
-}
diff --git a/examples/micscope/shaders/spectrum.frag b/examples/micscope/shaders/spectrum.frag
deleted file mode 100644
index e88b091..0000000
--- a/examples/micscope/shaders/spectrum.frag
+++ /dev/null
@@ -1,51 +0,0 @@
-#version 450
-#extension GL_GOOGLE_include_directive : require
-// The spectrum from its columns (spectrum.comp): one column per pixel on a
-// log frequency axis. The curve is drawn by its distance along the normal,
-// from the neighbours' slope, so steep parts stay as thick as flat ones.
-layout(location = 0) out vec4 out_color;
-
-#include "SpectrumView.glsl"
-
-layout(set = 2, binding = 0) readonly buffer Columns { vec2 columns[]; };
-
-float y_of(float db) {
- return u.size.y * (1.0 - clamp((db - u.floor_db) / (u.ceil_db - u.floor_db), 0.0, 1.0));
-}
-
-float x_of(float hz) {
- return u.size.x * log(hz / u.min_freq) / log(u.max_freq / u.min_freq);
-}
-
-// How close `p` is to a grid line, 0..1.
-float grid(vec2 p) {
- const float lines[10] = float[](20.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0, 20000.0);
- float near = 1e9;
- for (int i = 0; i < 10; i++) near = min(near, abs(p.x - x_of(lines[i])));
- float step = u.size.y * 12.0 / (u.ceil_db - u.floor_db);
- float db = mod(p.y, step);
- near = min(near, min(db, step - db));
- return clamp(1.0 - near, 0.0, 1.0);
-}
-
-void main() {
- vec2 p = gl_FragCoord.xy;
- int n = int(u.size.x);
- int x = int(p.x);
- float y = y_of(columns[x].x);
- float slope = (y_of(columns[min(x + 1, n - 1)].x) - y_of(columns[max(x - 1, 0)].x)) * 0.5;
- float distance = abs(p.y - y) / sqrt(1.0 + slope * slope);
-
- vec3 color = vec3(0.055, 0.06, 0.07);
- color = mix(color, vec3(0.16, 0.17, 0.2), grid(p));
-
- // Fill under the curve, by frequency, fading downwards.
- float along = p.x / u.size.x;
- vec3 hue = mix(vec3(0.2, 0.75, 0.9), vec3(0.85, 0.35, 0.9), along);
- if (p.y > y) color = mix(color, hue, 0.35 * (1.0 - (p.y - y) / max(u.size.y - y, 1.0)) + 0.08);
- // Peaks, then the curve.
- float peak = abs(p.y - y_of(columns[x].y));
- color = mix(color, vec3(0.9, 0.9, 0.95), clamp(1.0 - peak, 0.0, 1.0) * 0.45);
- color = mix(color, mix(hue, vec3(1.0), 0.5), clamp(1.6 - distance, 0.0, 1.0));
- out_color = vec4(color, 1.0);
-}
diff --git a/examples/micscope/shaders/view.vert b/examples/micscope/shaders/view.vert
deleted file mode 100644
index d9461e9..0000000
--- a/examples/micscope/shaders/view.vert
+++ /dev/null
@@ -1,7 +0,0 @@
-#version 450
-// One triangle over the whole target, from the vertex index alone: the
-// fragment shaders work in pixels (gl_FragCoord).
-void main() {
- vec2 p = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
- gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
-}
diff --git a/examples/micscope/shaders/waveform.comp b/examples/micscope/shaders/waveform.comp
deleted file mode 100644
index d1d64e5..0000000
--- a/examples/micscope/shaders/waveform.comp
+++ /dev/null
@@ -1,72 +0,0 @@
-#version 450
-#extension GL_GOOGLE_include_directive : require
-// One workgroup per waveform column: the lowest and highest the signal goes
-// in it, and its RMS. Each column also includes the linearly interpolated
-// signal at its own edges, which it shares with its neighbours, so that
-// zoomed in past one sample per column the columns still join into one
-// continuous line.
-layout(local_size_x = 64) in;
-
-#include "WaveParams.glsl"
-
-layout(set = 0, binding = 0) readonly buffer Tape { float tape[]; };
-// x: min, y: max, z: RMS, w: 1 where the column has tape under it.
-layout(set = 1, binding = 0) buffer Columns { vec4 columns[]; };
-
-const uint THREADS = 64;
-shared float lows[THREADS];
-shared float highs[THREADS];
-shared float squares[THREADS];
-
-float sample_at(int i) {
- return i >= 0 && i < int(u.samples) ? tape[u.offset + uint(i)] : 0.0;
-}
-
-// The signal at `t` samples after `u.first`, between samples linearly.
-float signal(float t) {
- float whole = floor(t);
- int i = int(u.first) + int(whole);
- return mix(sample_at(i), sample_at(i + 1), t - whole);
-}
-
-void main() {
- uint c = gl_WorkGroupID.x;
- uint t = gl_LocalInvocationID.x;
- float start = float(c) * u.spp;
- float end = start + u.spp;
- int first = int(ceil(start));
- int last = min(int(floor(end)), int(u.samples) - int(u.first) - 1);
-
- float lo = 1e9;
- float hi = -1e9;
- float sq = 0.0;
- for (int i = first + int(t); i <= last; i += int(THREADS)) {
- float v = tape[u.offset + u.first + uint(i)];
- lo = min(lo, v);
- hi = max(hi, v);
- sq += v * v;
- }
- if (t == 0u) {
- float a = signal(start);
- float b = signal(min(end, float(u.samples - u.first - 1u)));
- lo = min(lo, min(a, b));
- hi = max(hi, max(a, b));
- }
- lows[t] = lo;
- highs[t] = hi;
- squares[t] = sq;
- barrier();
- for (uint stride = THREADS / 2u; stride > 0u; stride >>= 1u) {
- if (t < stride) {
- lows[t] = min(lows[t], lows[t + stride]);
- highs[t] = max(highs[t], highs[t + stride]);
- squares[t] += squares[t + stride];
- }
- barrier();
- }
- if (t == 0u) {
- float count = float(max(last - first + 1, 1));
- float inside = float(u.first) + start < float(u.samples) ? 1.0 : 0.0;
- columns[(u.slot + c) % u.ring] = vec4(lows[0], highs[0], sqrt(squares[0] / count), inside);
- }
-}
diff --git a/examples/micscope/shaders/waveform.frag b/examples/micscope/shaders/waveform.frag
deleted file mode 100644
index 37be7ce..0000000
--- a/examples/micscope/shaders/waveform.frag
+++ /dev/null
@@ -1,56 +0,0 @@
-#version 450
-#extension GL_GOOGLE_include_directive : require
-// The waveform from its columns (waveform.comp): one column per pixel, the
-// band between its low and high filled, anti-aliased, at least a pixel
-// thick; the RMS inside it brighter; played and unplayed in two colors,
-// red while recording, green for the live microphone.
-layout(location = 0) out vec4 out_color;
-
-#include "WaveView.glsl"
-
-layout(set = 2, binding = 0) readonly buffer Columns { vec4 columns[]; };
-
-// Match layouts.Tint.
-const uint TINT_RECORDING = 1u;
-const uint TINT_LIVE = 2u;
-
-void main() {
- vec2 p = gl_FragCoord.xy;
- uint x = uint(p.x);
- vec4 col = columns[(x + u.scroll) % uint(u.size.x)];
- if (x + u.filled < uint(u.size.x)) col.w = 0.0;
- float mid = u.size.y * 0.5;
- float scale = u.size.y * 0.46 * u.gain;
-
- vec3 color = vec3(0.055, 0.06, 0.07);
- if (col.w > 0.0) color = vec3(0.075, 0.08, 0.095);
- // Center line.
- color = mix(color, vec3(0.2, 0.22, 0.26), clamp(1.0 - abs(p.y - mid), 0.0, 1.0) * 0.6);
-
- if (col.w > 0.0) {
- float top = mid - col.y * scale - 0.5;
- float bottom = mid - col.x * scale + 0.5;
- float outside = max(top - p.y, p.y - bottom);
- float cover = clamp(0.5 - outside, 0.0, 1.0);
- float rms = col.z * scale;
- float inner = clamp(rms - abs(p.y - mid) + 0.5, 0.0, 1.0);
- bool played = u.playhead >= 0.0 && p.x < u.playhead;
- vec3 band = played ? vec3(0.35, 0.8, 0.95) : vec3(0.45, 0.5, 0.58);
- vec3 core = played ? vec3(0.7, 0.95, 1.0) : vec3(0.65, 0.7, 0.78);
- if (u.tint == TINT_RECORDING) {
- band = vec3(0.95, 0.35, 0.35);
- core = vec3(1.0, 0.6, 0.55);
- } else if (u.tint == TINT_LIVE) {
- band = vec3(0.35, 0.75, 0.5);
- core = vec3(0.65, 1.0, 0.75);
- }
- color = mix(color, mix(band, core, inner), cover);
- }
-
- // Playhead.
- if (u.playhead >= 0.0) {
- float d = abs(p.x - u.playhead);
- color = mix(color, vec3(1.0, 0.85, 0.3), clamp(1.5 - d, 0.0, 1.0));
- }
- out_color = vec4(color, 1.0);
-}
diff --git a/examples/micscope/src/layouts.zig b/examples/micscope/src/layouts.zig
index cd5be65..be95799 100644
--- a/examples/micscope/src/layouts.zig
+++ b/examples/micscope/src/layouts.zig
@@ -1,124 +1,7 @@
-//! What the shaders read, as Zig structs: the only definition. The shaders
-//! include GLSL generated from these (see sketchbook's `glsl.zig`). No
-//! imports, so the shader build can compile this alone.
-
-/// FFT length: the analysis window, zero-padded to twice its size so the
-/// spectrum is sampled twice as finely as the window resolves.
-pub const fft_size = 8192;
-pub const window = 4096;
-/// The most columns a view can have; the column buffers hold this many.
-pub const max_columns = 2048;
-/// The tallest spectrogram; its buffer holds this many rows of
-/// `max_columns`.
-pub const max_rows = 1024;
-// All three analyses read samples `offset + i` of the tape buffer for
-// `0 <= i < samples`: the takes share one buffer, and a take's analysis
-// never reads its neighbours.
-/// The spectrogram's window, zero-padded to `spectrogram_fft` points.
-pub const spectrogram_window = 2048;
-pub const spectrogram_fft = 4096;
-
-/// spectrum.comp: the window ending at `end`, and the columns to fill.
-pub const SpectrumParams = extern struct {
- offset: u32,
- /// Sample index one past the window's last sample.
- end: u32,
- /// Samples on the tape.
- samples: u32,
- columns: u32,
- /// Nonzero: forget the smoothed levels and peaks.
- reset: u32,
- rate: f32,
- min_freq: f32,
- max_freq: f32,
- /// Seconds since the previous analysis, for smoothing.
- dt: f32,
- pad0: u32 = 0,
- pad1: u32 = 0,
- pad2: u32 = 0,
-
- pub const glsl = .{ .uniform = .{ .set = 2, .instance = "u" } };
-};
-
-/// waveform.comp: column `c` covers samples `first + c * spp` up to the next
-/// column's start, and is written to slot `(slot + c) % ring`: the live
-/// view writes its newest columns into a ring, the others from slot 0.
-pub const WaveParams = extern struct {
- offset: u32,
- first: u32,
- samples: u32,
- columns: u32,
- spp: f32,
- slot: u32,
- ring: u32,
- pad: u32 = 0,
-
- pub const glsl = .{ .uniform = .{ .set = 2, .instance = "u" } };
-};
-
-pub const Tint = enum(u32) { take, recording, live };
-
-/// waveform.frag. Pixel column `x` shows slot `(x + scroll) % width`; only
-/// the last `filled` columns have anything in them.
-pub const WaveView = extern struct {
- size: [2]f32,
- /// Pixels; negative hides it.
- playhead: f32,
- gain: f32,
- /// A `Tint`.
- tint: u32,
- scroll: u32,
- filled: u32,
- pad: u32 = 0,
-
- pub const glsl = .{ .uniform = .{ .set = 3, .instance = "u" } };
-};
-
-/// spectrum.frag.
-pub const SpectrumView = extern struct {
- size: [2]f32,
- floor_db: f32,
- ceil_db: f32,
- min_freq: f32,
- max_freq: f32,
- pad: [2]f32 = .{ 0, 0 },
-
- pub const glsl = .{ .uniform = .{ .set = 3, .instance = "u" } };
-};
-
-/// spectrogram.comp: the same columns as `WaveParams`, each analysed into
-/// `rows` log-spaced frequency rows, row 0 the lowest.
-/// Columns land in slots as `WaveParams` says.
-pub const SpectrogramParams = extern struct {
- offset: u32,
- first: u32,
- samples: u32,
- columns: u32,
- rows: u32,
- spp: f32,
- rate: f32,
- min_freq: f32,
- max_freq: f32,
- slot: u32,
- ring: u32,
- pad: u32 = 0,
-
- pub const glsl = .{ .uniform = .{ .set = 2, .instance = "u" } };
-};
-
-/// spectrogram.frag; `scroll` and `filled` as in `WaveView`.
-pub const SpectrogramView = extern struct {
- size: [2]f32,
- floor_db: f32,
- ceil_db: f32,
- /// Pixels; negative hides it.
- playhead: f32,
- scroll: u32,
- filled: u32,
- pad: f32 = 0,
-
- pub const glsl = .{ .uniform = .{ .set = 3, .instance = "u" } };
-};
+//! What the tuner's shaders read, as Zig structs: the only definition. The
+//! shaders include GLSL generated from these (see sketchbook's `glsl.zig`).
+//! No imports, so the shader build can compile this alone. The views' own
+//! blocks are the scope module's (`scope.layouts`).
/// tuner.comp: the YIN window is the `tuner_window + tuner_lags` samples
/// ending at `end`, read like the other analyses (`offset`, `samples`).
diff --git a/examples/micscope/src/main.zig b/examples/micscope/src/main.zig
index facc169..3b44ba0 100644
--- a/examples/micscope/src/main.zig
+++ b/examples/micscope/src/main.zig
@@ -17,7 +17,10 @@
const std = @import("std");
const sk = @import("sketch");
const gpu = sk.abi.gpu;
-const layouts = @import("layouts");
+const scope = @import("scope");
+const layouts = scope.layouts;
+/// The tuner's blocks; its shaders are `shaders`.
+const tuner_layouts = @import("layouts");
const shaders = @import("shaders");
const tuner = @import("tuner.zig");
@@ -33,18 +36,8 @@ const max_takes = 64;
const stream = 1;
/// How far ahead playback keeps the stream filled.
const lead_seconds = 0.06;
-const min_freq = 20.0;
-const floor_db = -96.0;
/// The live view's span.
const live_seconds = 6;
-/// The microphone's recent past, kept for the live view: a frame's new
-/// columns and everything their analysis windows reach.
-const live_history = 1 << 16;
-/// How far spectrogram.comp reads past a column's centre: the long
-/// analysis, 2048 points decimated 4×, three windows a quarter apart, plus
-/// its low-pass. The live view analyses a column once that much has been
-/// heard, so its columns are final; it runs this far behind.
-const live_reach = 6160;
pub const Transport = enum { stopped, recording, forward, backward };
@@ -114,7 +107,8 @@ pub const Session = struct {
cursor: usize = 0,
/// The take being recorded, by id.
recording: u32 = 0,
- live: Live = .{},
+ /// The microphone's recent past and the live view.
+ live: scope.Scope = .{},
/// Pitch, by tuner.comp: of the microphone (live, or recording), and
/// of the selected take at its playhead.
tuners: [2]tuner.Tracker = @splat(.{}),
@@ -126,33 +120,6 @@ pub const Session = struct {
/// Which tracker a readback belongs to: its index, as the download key.
const Tuned = enum(u32) { input, take };
-/// The microphone's last `live_history` samples, and how far the live
-/// view's columns have got. Column `k` covers samples `k * spp` up to the
-/// next, counted from the first sample heard, and lands in slot
-/// `k % columns`: a ring the views read from the oldest.
-const Live = struct {
- samples: [live_history]f32 = @splat(0),
- /// Samples heard since the session started.
- heard: u64 = 0,
- /// The next column to analyse.
- next: u64 = 0,
- /// Columns analysed since the view was (re)made, up to `columns`.
- filled: u32 = 0,
- columns: u32 = 0,
- spp: u32 = 0,
-
- fn push(live: *Live, heard: []const f32) void {
- const h = &live.samples;
- if (heard.len >= h.len) {
- @memcpy(h, heard[heard.len - h.len ..]);
- } else {
- std.mem.copyForwards(f32, h[0 .. h.len - heard.len], h[heard.len..]);
- @memcpy(h[h.len - heard.len ..], heard);
- }
- live.heard += heard.len;
- }
-};
-
/// GPU objects, made on first use.
const Gpu = struct {
ready: bool = false,
@@ -160,15 +127,12 @@ const Gpu = struct {
tape: sk.Buffer = .none,
capacity: usize = 0,
uploaded: usize = 0,
- /// `Live.samples`.
- live_tape: sk.Buffer = .none,
/// spectrum.comp's FFT, shared by every panel.
scratch: sk.Buffer = .none,
- /// tuner.comp's results, a `layouts.Pitch` each, by `Tuned`, and the
- /// difference functions it searches.
+ /// tuner.comp's results, a `tuner_layouts.Pitch` each, by `Tuned`, and
+ /// the difference functions it searches.
pitches: [2]sk.Buffer = @splat(.none),
differences: [2]sk.Buffer = @splat(.none),
- live: Panel = .{},
/// For the takes on screen, by take id; the least recently used is
/// reused.
panels: [16]Panel = @splat(.{}),
@@ -660,8 +624,8 @@ pub fn draw(s: *const State, ss: *Session, store: *Store, f: *sk.Frame) void {
ss.tuners[@intFromEnum(Tuned.take)] = .{};
};
for (in.downloads) |d| {
- if (d.key >= ss.tuners.len or d.bytes.len < @sizeOf(layouts.Pitch)) continue;
- ss.tuners[d.key].feed(std.mem.bytesToValue(layouts.Pitch, d.bytes[0..@sizeOf(layouts.Pitch)]), s.a4, @floatCast(dt));
+ if (d.key >= ss.tuners.len or d.bytes.len < @sizeOf(tuner_layouts.Pitch)) continue;
+ ss.tuners[d.key].feed(std.mem.bytesToValue(tuner_layouts.Pitch, d.bytes[0..@sizeOf(tuner_layouts.Pitch)]), s.a4, @floatCast(dt));
}
if (!f.host.gpu()) {
@@ -730,35 +694,6 @@ fn play(ss: *Session, t: *Take, tape: []const f32, f: *sk.Frame, forward: bool,
// ---------------------------------------------------------------------------
// GPU: buffers, compute, passes.
-const view_pipeline = struct {
- fn make(fragment: []const u8) gpu.Pipeline {
- return .{
- .vertex = .{ .code = shaders.view_vert },
- .fragment = .{ .code = fragment, .uniform_buffers = 1, .storage_buffers = 1 },
- .stride = 0,
- .attributes = &.{},
- .blend = .none,
- };
- }
-};
-const wave_pipelines = [_]gpu.Pipeline{view_pipeline.make(shaders.waveform_frag)};
-const spectrum_pipelines = [_]gpu.Pipeline{view_pipeline.make(shaders.spectrum_frag)};
-const spectrogram_pipelines = [_]gpu.Pipeline{view_pipeline.make(shaders.spectrogram_frag)};
-
-const spectrum_kernel: gpu.Kernel = .{
- .code = shaders.spectrum_comp,
- .readonly_buffers = 1,
- .readwrite_buffers = 2,
- .uniform_buffers = 1,
- .threads = .{ 256, 1, 1 },
-};
-const spectrogram_kernel: gpu.Kernel = .{
- .code = shaders.spectrogram_comp,
- .readonly_buffers = 1,
- .readwrite_buffers = 1,
- .uniform_buffers = 1,
- .threads = .{ 256, 1, 1 },
-};
const tuner_difference_kernel: gpu.Kernel = .{
.code = shaders.tuner_difference_comp,
.readonly_buffers = 1,
@@ -773,21 +708,13 @@ const tuner_kernel: gpu.Kernel = .{
.uniform_buffers = 1,
.threads = .{ 256, 1, 1 },
};
-const waveform_kernel: gpu.Kernel = .{
- .code = shaders.waveform_comp,
- .readonly_buffers = 1,
- .readwrite_buffers = 1,
- .uniform_buffers = 1,
- .threads = .{ 64, 1, 1 },
-};
fn setup(g: *Gpu, f: *sk.Frame) void {
if (g.ready) return;
g.ready = true;
g.scratch = f.host.newBuffer(layouts.fft_size * 2 * @sizeOf([2]f32));
- g.live_tape = f.host.newBuffer(live_history * @sizeOf(f32));
- for (&g.pitches) |*b| b.* = f.host.newBuffer(@sizeOf(layouts.Pitch));
- for (&g.differences) |*b| b.* = f.host.newBuffer(layouts.tuner_lags * @sizeOf(f32));
+ for (&g.pitches) |*b| b.* = f.host.newBuffer(@sizeOf(tuner_layouts.Pitch));
+ for (&g.differences) |*b| b.* = f.host.newBuffer(tuner_layouts.tuner_lags * @sizeOf(f32));
}
fn makeBuffers(p: *Panel, f: *sk.Frame) void {
@@ -845,11 +772,9 @@ fn render(s: *const State, ss: *Session, store: *Store, f: *sk.Frame, rate: f64,
const g = &ss.gpu;
setup(g, f);
sync(g, f, store.tape.items);
- // New code may mean new shaders: make everything again.
- if (f.in.reloaded) {
- g.live.forget();
- for (&g.panels) |*p| p.forget();
- }
+ // New code may mean new shaders: make everything again (the live view
+ // sees to its own).
+ if (f.in.reloaded) for (&g.panels) |*p| p.forget();
const takes = store.takes.items;
const selected = if (takes.len > 0) @min(s.selected, takes.len - 1) else 0;
const recording = s.transport.value == .recording;
@@ -860,31 +785,31 @@ fn render(s: *const State, ss: *Session, store: *Store, f: *sk.Frame, rate: f64,
// Images are made at world size; the camera only scales them.
const size = l.box(0);
- // The live view keeps up even while it is hidden.
- analyseLive(ss, f, size, rate);
+ f.clip(view);
+ // The live view, in the world's last slot. It keeps up even while it is
+ // hidden: drawn clipped away while a recording stands in for it.
+ const live = l.box(world.takes);
+ if (!world.live) f.clip(.{ .x = 0, .y = 0, .w = 0, .h = 0 });
+ ss.live.draw(f, .{ .seconds = live_seconds, .wave = live.wave, .spectrogram = live.spectrogram, .spectrum = live.spectrum, .gain = s.gain, .camera = cam });
+ f.clip(view);
// The tuner: on the microphone's newest sound, and on the selected take
// around its playhead.
- const reach = layouts.tuner_window + layouts.tuner_lags;
+ const reach = tuner_layouts.tuner_window + tuner_layouts.tuner_lags;
if (recording and takes.len > 0) {
const t = takes[takes.len - 1];
tune(g, f, .input, g.tape, t.start, t.len, t.len, rate);
- } else tune(g, f, .input, g.live_tape, 0, live_history, live_history, rate);
+ } else tune(g, f, .input, ss.live.gpu.tape, 0, scope.history, scope.history, rate);
if (!recording and takes.len > 0) {
const t = takes[selected];
const end: usize = @intFromFloat(@max(t.heard, 0));
tune(g, f, .take, g.tape, t.start, t.len, end + reach / 2, rate);
}
- f.clip(view);
- for (0..world.slots()) |slot| {
+ for (0..world.takes) |slot| {
const k: u32 = @intCast(slot);
const b = l.box(k).toScreen(cam);
if (b.whole.y + b.whole.h <= view.y or b.whole.y >= view.y + view.h) continue;
- if (k == world.takes) {
- drawLive(s, ss, f, size, b, rate, dt);
- } else {
- const tint: layouts.Tint = if (recording and k + 1 == world.takes) .recording else .take;
- drawTake(s, g, f, size, b, &takes[k], s.views[k], k == selected, tint, rate, dt);
- }
+ const tint: layouts.Tint = if (recording and k + 1 == world.takes) .recording else .take;
+ drawTake(s, g, f, size, b, &takes[k], s.views[k], k == selected, tint, rate, dt);
}
f.clip(null);
labels(s, ss, store, f, world, cam, rate);
@@ -895,7 +820,7 @@ fn render(s: *const State, ss: *Session, store: *Store, f: *sk.Frame, rate: f64,
fn tune(g: *Gpu, f: *sk.Frame, which: Tuned, tape: sk.Buffer, offset: usize, samples: usize, end: usize, rate: f64) void {
const result = g.pitches[@intFromEnum(which)];
const difference = g.differences[@intFromEnum(which)];
- const params = gpu.uniform(f.scratch, layouts.TunerParams{
+ const params = gpu.uniform(f.scratch, tuner_layouts.TunerParams{
.offset = @intCast(offset),
.end = @intCast(end),
.samples = @intCast(samples),
@@ -911,7 +836,7 @@ fn tune(g: *Gpu, f: *sk.Frame, which: Tuned, tape: sk.Buffer, offset: usize, sam
.readwrite = &.{difference},
.uniforms = params,
// Match tuner_difference.comp's LAGS_PER_GROUP.
- .groups = .{ (layouts.tuner_lags + 15) / 16, 1, 1 },
+ .groups = .{ (tuner_layouts.tuner_lags + 15) / 16, 1, 1 },
});
f.compute(.{
.label = "tuner.comp",
@@ -920,7 +845,7 @@ fn tune(g: *Gpu, f: *sk.Frame, which: Tuned, tape: sk.Buffer, offset: usize, sam
.readwrite = &.{result},
.uniforms = params,
});
- f.download(result, .{ .size = @sizeOf(layouts.Pitch), .key = @intFromEnum(which) });
+ f.download(result, .{ .size = @sizeOf(tuner_layouts.Pitch), .key = @intFromEnum(which) });
}
/// The pitches the tuner looks for: a five-string bass's low B to a
@@ -928,35 +853,11 @@ fn tune(g: *Gpu, f: *sk.Frame, which: Tuned, tape: sk.Buffer, offset: usize, sam
const tuner_low = 30.0;
const tuner_high = 4200.0;
-fn wavePass(f: *sk.Frame, p: *Panel, size: [2]u32, view: layouts.WaveView) void {
- f.gpu(.{
- .label = "waveform.frag",
- .image = p.wave,
- .width = size[0],
- .height = size[1],
- .clear = null,
- .pipelines = &wave_pipelines,
- .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, view), .fragment_storage = &.{p.wave_columns} }},
- });
-}
-
-fn spectrogramPass(f: *sk.Frame, p: *Panel, size: [2]u32, view: layouts.SpectrogramView) void {
- f.gpu(.{
- .label = "spectrogram.frag",
- .image = p.spectrogram,
- .width = size[0],
- .height = size[1],
- .clear = null,
- .pipelines = &spectrogram_pipelines,
- .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, view), .fragment_storage = &.{p.levels} }},
- });
-}
-
/// The spectrum's analysis of `tape`, then its pass.
fn spectrum(g: *Gpu, f: *sk.Frame, tape: sk.Buffer, p: *Panel, size: [2]u32, params: layouts.SpectrumParams, rate: f64) void {
f.compute(.{
.label = "spectrum.comp",
- .kernel = spectrum_kernel,
+ .kernel = scope.kernels.spectrum,
.readonly = &.{tape},
.readwrite = &.{ g.scratch, p.spectrum_columns },
.uniforms = gpu.uniform(f.scratch, params),
@@ -967,26 +868,22 @@ fn spectrum(g: *Gpu, f: *sk.Frame, tape: sk.Buffer, p: *Panel, size: [2]u32, par
.width = size[0],
.height = size[1],
.clear = null,
- .pipelines = &spectrum_pipelines,
+ .pipelines = &scope.pipelines.spectrum,
.draws = &.{.{
.pipeline = 0,
.vertex_count = 3,
.fragment_uniforms = gpu.uniform(f.scratch, layouts.SpectrumView{
.size = .{ @floatFromInt(size[0]), @floatFromInt(size[1]) },
- .floor_db = floor_db,
+ .floor_db = scope.floor_db,
.ceil_db = 0,
- .min_freq = min_freq,
- .max_freq = maxFreq(rate),
+ .min_freq = scope.min_freq,
+ .max_freq = scope.maxFreq(rate),
}),
.fragment_storage = &.{p.spectrum_columns},
}},
});
}
-fn maxFreq(rate: f64) f32 {
- return @floatCast(@min(20_000, rate / 2));
-}
-
fn drawTake(s: *const State, g: *Gpu, f: *sk.Frame, size: Box, b: Box, t: *const Take, view: View, selected: bool, tint: layouts.Tint, rate: f64, dt: f64) void {
const p = panelFor(g, f, t.id);
@@ -1009,7 +906,7 @@ fn drawTake(s: *const State, g: *Gpu, f: *sk.Frame, size: Box, b: Box, t: *const
p.wave_key = key;
f.compute(.{
.label = "waveform.comp",
- .kernel = waveform_kernel,
+ .kernel = scope.kernels.waveform,
.readonly = &.{g.tape},
.readwrite = &.{p.wave_columns},
.uniforms = gpu.uniform(f.scratch, params),
@@ -1027,8 +924,8 @@ fn drawTake(s: *const State, g: *Gpu, f: *sk.Frame, size: Box, b: Box, t: *const
.rows = spectrogram[1],
.spp = spp,
.rate = @floatCast(rate),
- .min_freq = min_freq,
- .max_freq = maxFreq(rate),
+ .min_freq = scope.min_freq,
+ .max_freq = scope.maxFreq(rate),
.slot = 0,
.ring = layouts.max_columns,
};
@@ -1037,7 +934,7 @@ fn drawTake(s: *const State, g: *Gpu, f: *sk.Frame, size: Box, b: Box, t: *const
p.spectrogram_key = analysis_key;
f.compute(.{
.label = "spectrogram.comp",
- .kernel = spectrogram_kernel,
+ .kernel = scope.kernels.spectrogram,
.readonly = &.{g.tape},
.readwrite = &.{p.levels},
.uniforms = gpu.uniform(f.scratch, analysis),
@@ -1059,8 +956,8 @@ fn drawTake(s: *const State, g: *Gpu, f: *sk.Frame, size: Box, b: Box, t: *const
.columns = shown[0],
.reset = 0,
.rate = @floatCast(rate),
- .min_freq = min_freq,
- .max_freq = maxFreq(rate),
+ .min_freq = scope.min_freq,
+ .max_freq = scope.maxFreq(rate),
.dt = 0,
};
const spectrum_key = std.hash.Wyhash.hash(1, std.mem.asBytes(&sparams));
@@ -1084,11 +981,19 @@ fn drawTake(s: *const State, g: *Gpu, f: *sk.Frame, size: Box, b: Box, t: *const
const wave_drawn = std.hash.Wyhash.hash(p.wave_key, std.mem.asBytes(&wave_view));
if (wave_drawn != p.wave_drawn) {
p.wave_drawn = wave_drawn;
- wavePass(f, p, wave, wave_view);
+ f.gpu(.{
+ .label = "waveform.frag",
+ .image = p.wave,
+ .width = wave[0],
+ .height = wave[1],
+ .clear = null,
+ .pipelines = &scope.pipelines.wave,
+ .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, wave_view), .fragment_storage = &.{p.wave_columns} }},
+ });
}
const spectrogram_view: layouts.SpectrogramView = .{
.size = .{ @floatFromInt(spectrogram[0]), @floatFromInt(spectrogram[1]) },
- .floor_db = floor_db,
+ .floor_db = scope.floor_db,
.ceil_db = -6,
.playhead = playhead,
.scroll = 0,
@@ -1097,127 +1002,16 @@ fn drawTake(s: *const State, g: *Gpu, f: *sk.Frame, size: Box, b: Box, t: *const
const spectrogram_drawn = std.hash.Wyhash.hash(p.spectrogram_key, std.mem.asBytes(&spectrogram_view));
if (spectrogram_drawn != p.spectrogram_drawn) {
p.spectrogram_drawn = spectrogram_drawn;
- spectrogramPass(f, p, spectrogram, spectrogram_view);
- }
- f.image(p.wave, b.wave, .{});
- f.image(p.spectrogram, b.spectrogram, .{});
- f.image(p.spectrum, b.spectrum, .{});
-}
-
-/// Analyses the live view's new columns into its rings: only those whose
-/// windows have been heard in full, so each is analysed once.
-fn analyseLive(ss: *Session, f: *sk.Frame, b: Box, rate: f64) void {
- const live = &ss.live;
- const g = &ss.gpu;
- const p = &g.live;
- makeBuffers(p, f);
- const columns: u32 = @intFromFloat(@min(b.wave.w, layouts.max_columns));
- const spp: u32 = @max(1, @as(u32, @intFromFloat(@round(live_seconds * rate / @as(f64, @floatFromInt(columns))))));
- if (columns != live.columns or spp != live.spp or f.in.reloaded) {
- live.columns = columns;
- live.spp = spp;
- live.filled = 0;
- live.next = 0;
- }
- if (f.in.microphone.len > 0) f.upload(g.live_tape, 0, std.mem.sliceAsBytes(&live.samples));
-
- // History index of heard sample `i`: `i - base`. A column is ready once
- // all it reads is heard, and analysable while all it reads is kept.
- const base: i64 = @as(i64, @intCast(live.heard)) - live_history;
- const ready = (live.heard -| live_reach) / spp;
- const kept: u64 = @intCast(@max(0, @divFloor(base + live_reach + spp - 1, spp)));
- live.next = @max(live.next, kept, ready -| columns);
- if (ready <= live.next) return;
- const count: u32 = @intCast(ready - live.next);
- const first: u32 = @intCast(@as(i64, @intCast(live.next * spp)) - base);
- const slot: u32 = @intCast(live.next % columns);
- f.compute(.{
- .label = "waveform.comp live",
- .kernel = waveform_kernel,
- .readonly = &.{g.live_tape},
- .readwrite = &.{p.wave_columns},
- .uniforms = gpu.uniform(f.scratch, layouts.WaveParams{
- .offset = 0,
- .first = first,
- .samples = live_history,
- .columns = count,
- .spp = @floatFromInt(spp),
- .slot = slot,
- .ring = columns,
- }),
- .groups = .{ count, 1, 1 },
- });
- f.compute(.{
- .label = "spectrogram.comp live",
- .kernel = spectrogram_kernel,
- .readonly = &.{g.live_tape},
- .readwrite = &.{p.levels},
- .uniforms = gpu.uniform(f.scratch, layouts.SpectrogramParams{
- .offset = 0,
- .first = first,
- .samples = live_history,
- .columns = count,
- .rows = @intFromFloat(@min(b.spectrogram.h, spectrogram_height)),
- .spp = @floatFromInt(spp),
- .rate = @floatCast(rate),
- .min_freq = min_freq,
- .max_freq = maxFreq(rate),
- .slot = slot,
- .ring = columns,
- }),
- .groups = .{ count, 1, 1 },
- });
- live.filled = @intCast(@min(columns, live.filled + count));
- live.next = ready;
-}
-
-fn drawLive(s: *const State, ss: *Session, f: *sk.Frame, size: Box, b: Box, rate: f64, dt: f64) void {
- const live = &ss.live;
- const g = &ss.gpu;
- const p = &g.live;
- const wave = target(f, &p.wave, &p.wave_size, size.wave);
- const spectrogram = target(f, &p.spectrogram, &p.spectrogram_size, size.spectrogram);
- const scroll: u32 = @intCast(live.next % @max(live.columns, 1));
- const wave_view: layouts.WaveView = .{
- .size = .{ @floatFromInt(wave[0]), @floatFromInt(wave[1]) },
- .playhead = -1,
- .gain = s.gain,
- .tint = @intFromEnum(layouts.Tint.live),
- .scroll = scroll,
- .filled = live.filled,
- };
- const wave_drawn = std.hash.Wyhash.hash(0, std.mem.asBytes(&wave_view));
- if (wave_drawn != p.wave_drawn) {
- p.wave_drawn = wave_drawn;
- wavePass(f, p, wave, wave_view);
- }
- const spectrogram_view: layouts.SpectrogramView = .{
- .size = .{ @floatFromInt(spectrogram[0]), @floatFromInt(spectrogram[1]) },
- .floor_db = floor_db,
- .ceil_db = -6,
- .playhead = -1,
- .scroll = scroll,
- .filled = live.filled,
- };
- const spectrogram_drawn = std.hash.Wyhash.hash(0, std.mem.asBytes(&spectrogram_view));
- if (spectrogram_drawn != p.spectrogram_drawn) {
- p.spectrogram_drawn = spectrogram_drawn;
- spectrogramPass(f, p, spectrogram, spectrogram_view);
+ f.gpu(.{
+ .label = "spectrogram.frag",
+ .image = p.spectrogram,
+ .width = spectrogram[0],
+ .height = spectrogram[1],
+ .clear = null,
+ .pipelines = &scope.pipelines.spectrogram,
+ .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, spectrogram_view), .fragment_storage = &.{p.levels} }},
+ });
}
- // The spectrum of the newest samples, smoothed.
- const shown = target(f, &p.spectrum, &p.spectrum_size, size.spectrum);
- spectrum(g, f, g.live_tape, p, shown, .{
- .offset = 0,
- .end = live_history,
- .samples = live_history,
- .columns = shown[0],
- .reset = @intFromBool(p.spectrum_key == 0),
- .rate = @floatCast(rate),
- .min_freq = min_freq,
- .max_freq = maxFreq(rate),
- .dt = @floatCast(dt),
- }, rate);
- p.spectrum_key = 1;
f.image(p.wave, b.wave, .{});
f.image(p.spectrogram, b.spectrogram, .{});
f.image(p.spectrum, b.spectrum, .{});
@@ -1321,19 +1115,19 @@ fn labels(s: *const State, ss: *const Session, store: *const Store, f: *sk.Frame
/// the pitch as a needle between them, and the note in cents and Hz.
fn tunerOverlay(f: *sk.Frame, r: sk.Rect, reading: ?tuner.Reading, a4: f32, rate: f64, detailed: bool) void {
const at = reading orelse return;
- const max_freq = maxFreq(rate);
+ const max_freq = scope.maxFreq(rate);
const fade: u8 = @intFromFloat(255 * std.math.clamp(1 - at.quiet / tuner.hold_seconds, 0.2, 1));
const cents = at.cents();
const color = sk.Color.hex(if (@abs(cents) <= 5) green else if (@abs(cents) <= 15) yellow else 0xff8a4d).alpha(fade);
const x = struct {
fn of(rect: sk.Rect, hz: f32, ceiling: f32) f32 {
- return rect.x + @log(hz / min_freq) / @log(ceiling / min_freq) * rect.w;
+ return rect.x + @log(hz / scope.min_freq) / @log(ceiling / scope.min_freq) * rect.w;
}
}.of;
- const freq = tuner.frequency(at.pitch, a4);
- const lo = tuner.frequency(@as(f32, @floatFromInt(at.note)) - 2.5, a4);
- const hi = tuner.frequency(@as(f32, @floatFromInt(at.note)) + 2.5, a4);
+ const freq = scope.hz(at.pitch, a4);
+ const lo = scope.hz(@as(f32, @floatFromInt(at.note)) - 2.5, a4);
+ const hi = scope.hz(@as(f32, @floatFromInt(at.note)) + 2.5, a4);
f.fill(.{ .x = x(r, lo, max_freq), .y = r.y, .w = @max(x(r, hi, max_freq) - x(r, lo, max_freq), 1), .h = r.h }, sk.Color.white.alpha(fade / 10));
f.fill(.{ .x = @round(x(r, freq, max_freq)), .y = r.y, .w = 1, .h = r.h }, color);
// The harmonics the pitch accounts for.
@@ -1407,21 +1201,21 @@ fn axes(f: *sk.Frame, b: Box, rate: f64, span: ?[2]f64) void {
f.text(b.wave.x, below, 1, left, dim);
f.text(b.wave.x + b.wave.w - @as(f32, @floatFromInt(right.len * 8)), below, 1, right, dim);
- const max_freq = maxFreq(rate);
+ const max_freq = scope.maxFreq(rate);
for ([_]f64{ 100, 1000, 10000 }) |hz| {
- const y = b.spectrogram.y + b.spectrogram.h * (1 - @as(f32, @floatCast(@log(hz / min_freq) / @log(max_freq / min_freq))));
+ const y = b.spectrogram.y + b.spectrogram.h * (1 - @as(f32, @floatCast(@log(hz / scope.min_freq) / @log(max_freq / scope.min_freq))));
f.fill(.{ .x = b.spectrogram.x, .y = y, .w = 6, .h = 1 }, sk.Color.white.alpha(140));
f.text(b.spectrogram.x + 9, y - 4, 1, hzLabel(f, hz), sk.Color.white.alpha(170));
}
for ([_]f64{ 50, 200, 1000, 5000, 20000 }) |hz| {
if (hz > max_freq) continue;
- const x = b.spectrum.x + @as(f32, @floatCast(@log(hz / min_freq) / @log(max_freq / min_freq))) * b.spectrum.w;
+ const x = b.spectrum.x + @as(f32, @floatCast(@log(hz / scope.min_freq) / @log(max_freq / scope.min_freq))) * b.spectrum.w;
f.text(@min(x + 3, b.spectrum.x + b.spectrum.w - 24), b.spectrum.y + b.spectrum.h + 4, 1, hzLabel(f, hz), dim);
}
var db: f32 = -24;
- while (db > floor_db) : (db -= 24) {
- const y = b.spectrum.y + b.spectrum.h * (db / floor_db);
+ while (db > scope.floor_db) : (db -= 24) {
+ const y = b.spectrum.y + b.spectrum.h * (db / scope.floor_db);
f.print(b.spectrum.x + 4, y + 3, 1, dim, "{d}", .{db});
}
}
@@ -1489,10 +1283,3 @@ test {
_ = tuner;
}
-test "the live history keeps the newest samples in order" {
- var live: Live = .{};
- live.push(&.{ 1, 2, 3 });
- live.push(&.{4});
- try std.testing.expectEqualSlices(f32, &.{ 1, 2, 3, 4 }, live.samples[live_history - 4 ..]);
- try std.testing.expectEqual(@as(u64, 4), live.heard);
-}
diff --git a/examples/micscope/src/tuner.zig b/examples/micscope/src/tuner.zig
index 92a8482..159798b 100644
--- a/examples/micscope/src/tuner.zig
+++ b/examples/micscope/src/tuner.zig
@@ -10,10 +10,9 @@
//! once the pitch is 60 cents from it, so a note held a quarter tone sharp
//! does not flicker between two names.
const std = @import("std");
+const scope = @import("scope");
const layouts = @import("layouts");
-pub const names = [12][]const u8{ "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
-
/// Estimates clearer than this are a note (YIN's threshold is 0.12, so
/// clarity 0.88 at least when its first dip was found).
pub const min_clarity = 0.85;
@@ -22,17 +21,8 @@ pub const min_level = -60.0;
/// How long the last note stays (shown as fading) after the sound stops.
pub const hold_seconds = 1.0;
-/// Fractional MIDI number of `freq`.
-pub fn midi(freq: f32, a4: f32) f32 {
- return 69 + 12 * std.math.log2(freq / a4);
-}
-
-pub fn frequency(m: f32, a4: f32) f32 {
- return a4 * std.math.pow(f32, 2, (m - 69) / 12);
-}
-
pub fn name(note: i32) []const u8 {
- return names[@intCast(@mod(note, 12))];
+ return scope.note_names[@intCast(@mod(note, 12))];
}
pub fn octave(note: i32) i32 {
@@ -67,7 +57,7 @@ pub const Tracker = struct {
}
return;
}
- const m = midi(p.freq, a4);
+ const m = scope.midi(p.freq, a4);
if (t.count > 0 and @abs(m - t.median()) > 1) t.count = 0;
if (t.count == t.recent.len) {
std.mem.copyForwards(f32, t.recent[0 .. t.recent.len - 1], t.recent[1..]);
@@ -97,21 +87,16 @@ fn pitchOf(freq: f32) layouts.Pitch {
}
test "notes and octaves on the chromatic scale" {
- try std.testing.expectApproxEqAbs(@as(f32, 69), midi(440, 440), 1e-4);
- try std.testing.expectApproxEqAbs(@as(f32, 40), midi(82.4069, 440), 1e-3);
try std.testing.expectEqualStrings("E", name(40));
try std.testing.expectEqual(@as(i32, 2), octave(40));
try std.testing.expectEqualStrings("B", name(23));
try std.testing.expectEqual(@as(i32, 0), octave(23));
- try std.testing.expectApproxEqAbs(@as(f32, 261.626), frequency(60, 440), 1e-2);
- // Another reference pitch moves every note with it.
- try std.testing.expectApproxEqAbs(@as(f32, 69), midi(442, 442), 1e-4);
}
test "a held note settles, in cents from it" {
var t: Tracker = .{};
// A4, 12 cents sharp.
- const sharp = frequency(69.12, 440);
+ const sharp = scope.hz(69.12, 440);
for (0..20) |_| t.feed(pitchOf(sharp), 440, 1.0 / 60.0);
const r = t.reading.?;
try std.testing.expectEqual(@as(i32, 69), r.note);
@@ -132,7 +117,7 @@ test "a new note shows at once, a quarter tone does not flicker" {
for (0..3) |_| t.feed(pitchOf(146.83), 440, 1.0 / 60.0);
try std.testing.expectEqual(@as(i32, 50), t.reading.?.note);
// 55 cents sharp of D3 stays D3.
- for (0..30) |_| t.feed(pitchOf(frequency(50.55, 440)), 440, 1.0 / 60.0);
+ for (0..30) |_| t.feed(pitchOf(scope.hz(50.55, 440)), 440, 1.0 / 60.0);
try std.testing.expectEqual(@as(i32, 50), t.reading.?.note);
}