summaryrefslogtreecommitdiff
path: root/examples/micscope/src
diff options
context:
space:
mode:
Diffstat (limited to 'examples/micscope/src')
-rw-r--r--examples/micscope/src/layouts.zig154
-rw-r--r--examples/micscope/src/main.zig1498
-rw-r--r--examples/micscope/src/tuner.zig147
3 files changed, 1799 insertions, 0 deletions
diff --git a/examples/micscope/src/layouts.zig b/examples/micscope/src/layouts.zig
new file mode 100644
index 0000000..cd5be65
--- /dev/null
+++ b/examples/micscope/src/layouts.zig
@@ -0,0 +1,154 @@
+//! 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" } };
+};
+
+/// tuner.comp: the YIN window is the `tuner_window + tuner_lags` samples
+/// ending at `end`, read like the other analyses (`offset`, `samples`).
+pub const tuner_window = 2048;
+pub const tuner_lags = 1700;
+
+pub const TunerParams = extern struct {
+ offset: u32,
+ end: u32,
+ samples: u32,
+ rate: f32,
+ /// The pitch range searched.
+ min_freq: f32,
+ max_freq: f32,
+ /// YIN's absolute threshold on the normalised difference.
+ threshold: f32,
+ pad: u32 = 0,
+
+ pub const glsl = .{ .uniform = .{ .set = 2, .instance = "u" } };
+};
+
+/// What tuner.comp writes (std430, read back by the CPU).
+pub const Pitch = extern struct {
+ /// Hz; 0 when nothing periodic was found.
+ freq: f32,
+ /// 1 minus YIN's normalised difference at the period: 1 is perfectly
+ /// periodic.
+ clarity: f32,
+ /// RMS of the window, dBFS.
+ level: f32,
+ /// The period in samples, interpolated.
+ period: f32,
+};
diff --git a/examples/micscope/src/main.zig b/examples/micscope/src/main.zig
new file mode 100644
index 0000000..facc169
--- /dev/null
+++ b/examples/micscope/src/main.zig
@@ -0,0 +1,1498 @@
+//! micscope: records the microphone or opens sound files, plays them
+//! forwards or backwards, and shows each as a waveform, its spectrogram on
+//! the same time axis, and the spectrum at its playhead. The window is a
+//! vertical strip: on top, what the microphone hears right now (or the take
+//! being recorded); under it every take, newest first. The signal
+//! processing (windowed FFTs, log-frequency interpolation, smoothing,
+//! waveform reduction) and all the drawing run on the GPU; the CPU only
+//! moves samples: microphone to tape, tape to the GPU once, tape to the
+//! speakers.
+//!
+//! Memory by lifetime: State is the transport, the selection and the views,
+//! changed by `update` from keys and the mouse, and replayable. Store holds
+//! the takes, on disk: they are still there after a restart. Session is
+//! this process's playback cursor, the microphone's recent past and GPU
+//! objects. Transport changes, seeks and deletions are `sk.Request`s, which
+//! `draw` carries out once each.
+const std = @import("std");
+const sk = @import("sketch");
+const gpu = sk.abi.gpu;
+const layouts = @import("layouts");
+const shaders = @import("shaders");
+const tuner = @import("tuner.zig");
+
+pub const name = "micscope";
+pub const width = 1280;
+pub const height = 900;
+pub const commands = .{ "open", "takes" };
+
+/// The longest take: ten minutes at the host's rate.
+const max_seconds = 600;
+const max_takes = 64;
+/// The playback stream's key.
+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 };
+
+/// The part of a take its timeline shows, as fractions of it.
+pub const View = struct {
+ lo: f32 = 0,
+ hi: f32 = 1,
+};
+
+pub const State = struct {
+ transport: sk.Request(Transport) = .{},
+ /// The direction space resumes in.
+ backward: bool = false,
+ /// To a fraction of the selected take.
+ seek: sk.Request(f32) = .{},
+ scrubbing: bool = false,
+ dialog: sk.Request(void) = .{},
+ /// Deletes the take at this index.
+ remove: sk.Request(u32) = .{},
+ /// How many takes the Store holds. `update` keeps count as it records
+ /// and deletes; `draw` corrects it with the `takes` command if not.
+ takes: u32 = 0,
+ /// The take the transport and the keys work on, by index (oldest 0).
+ selected: u32 = 0,
+ views: [max_takes]View = @splat(.{}),
+ /// Maps the world (the panels, stacked) to the screen.
+ camera: sk.Camera = .{},
+ /// The camera keeps the bottom, where now is, in view.
+ follow: bool = true,
+ panning: bool = false,
+ /// The pointer's height when panning last moved.
+ grab: f32 = 0,
+ gain: f32 = 1,
+ /// The tuner's reference pitch: A4, in Hz.
+ a4: f32 = 440,
+};
+
+pub const Take = struct {
+ /// Its samples: `Store.tape[start..][0..len]`.
+ start: usize = 0,
+ len: usize = 0,
+ /// Stays the same when earlier takes are deleted: GPU caches go by it.
+ id: u32 = 0,
+ /// Where the listener is, in samples into the take.
+ heard: f64 = 0,
+ /// A file's name, or empty for the microphone.
+ source: [64]u8 = @splat(0),
+ source_len: u32 = 0,
+};
+
+pub const Store = struct {
+ /// Every take's mono samples at `Input.sample_rate`, one after another,
+ /// oldest first. A recording grows the last one.
+ tape: std.ArrayList(f32) = .empty,
+ takes: std.ArrayList(Take) = .empty,
+ next_id: u32 = 1,
+};
+
+pub const Session = struct {
+ transport: sk.Handled = .{},
+ seek: sk.Handled = .{},
+ dialog: sk.Handled = .{},
+ remove: sk.Handled = .{},
+ /// The take playback follows, by id, and the next of its samples to
+ /// queue.
+ playing: u32 = 0,
+ cursor: usize = 0,
+ /// The take being recorded, by id.
+ recording: u32 = 0,
+ live: Live = .{},
+ /// Pitch, by tuner.comp: of the microphone (live, or recording), and
+ /// of the selected take at its playhead.
+ tuners: [2]tuner.Tracker = @splat(.{}),
+ /// The take `tuners[1]` follows, by id.
+ tuned: u32 = 0,
+ gpu: Gpu = .{},
+};
+
+/// 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,
+ /// `Store.tape`, and how many of its samples are in it.
+ 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.
+ 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(.{}),
+};
+
+/// One panel's buffers and images, and the inputs they were last made from:
+/// unchanged, they are not made again.
+const Panel = struct {
+ id: u32 = 0,
+ used: u64 = 0,
+ wave_columns: sk.Buffer = .none,
+ spectrum_columns: sk.Buffer = .none,
+ levels: sk.Buffer = .none,
+ wave: sk.Image = .none,
+ wave_size: [2]u32 = .{ 0, 0 },
+ spectrogram: sk.Image = .none,
+ spectrogram_size: [2]u32 = .{ 0, 0 },
+ spectrum: sk.Image = .none,
+ spectrum_size: [2]u32 = .{ 0, 0 },
+ wave_key: u64 = 0,
+ spectrogram_key: u64 = 0,
+ spectrum_key: u64 = 0,
+ wave_drawn: u64 = 0,
+ spectrogram_drawn: u64 = 0,
+
+ fn forget(p: *Panel) void {
+ p.wave_key = 0;
+ p.spectrogram_key = 0;
+ p.spectrum_key = 0;
+ p.wave_drawn = 0;
+ p.spectrogram_drawn = 0;
+ }
+};
+
+// ---------------------------------------------------------------------------
+// The world: panels stacked down in the order they were made, take 0 on top
+// and the live microphone at the bottom, where now is. A take keeps its
+// place as others are added. The camera maps the world to the screen: it
+// follows the bottom unless moved, and zooms out to overview the strip.
+// Panels are rendered at world resolution and scaled by the camera, so
+// moving it never recomputes anything.
+
+const spectrogram_height = 132;
+const min_zoom = 0.3;
+/// The canvas follows the window, but no smaller than this.
+const min_width = 320;
+const min_height = 300;
+
+/// Sizes, from the canvas. Wide, a panel is a waveform over its spectrogram
+/// with the spectrum beside them, and the buttons sit in the header. Narrow
+/// (a phone), the spectrum goes under them, full width, and the buttons
+/// along the bottom, where thumbs are, big enough to hit.
+const Layout = struct {
+ w: f32,
+ h: f32,
+ narrow: bool,
+ /// World units are canvas pixels at zoom 1.
+ world_width: f32,
+ panel_height: f32,
+ /// Where the world shows, between the header and the footer or buttons.
+ view: sk.Rect,
+
+ const header = 36;
+ const footer = 22;
+ const toolbar = 56;
+ const spectrum_width = 320;
+
+ fn of(w: f32, h: f32) Layout {
+ const narrow = w < 760;
+ const margin: f32 = if (narrow) 8 else 16;
+ const bottom: f32 = if (narrow) toolbar else footer;
+ return .{
+ .w = w,
+ .h = h,
+ .narrow = narrow,
+ .world_width = w - 2 * margin,
+ .panel_height = if (narrow) 412 else 236,
+ .view = .{ .x = 0, .y = header, .w = w, .h = h - header - bottom },
+ };
+ }
+
+ /// The panel in world slot `k`.
+ fn box(l: Layout, k: u32) Box {
+ const y = @as(f32, @floatFromInt(k)) * l.panel_height;
+ const timeline_w = if (l.narrow) l.world_width else l.world_width - spectrum_width - 16;
+ const wave: sk.Rect = .{ .x = 0, .y = y + 18, .w = timeline_w, .h = 64 };
+ const spectrogram: sk.Rect = .{ .x = 0, .y = wave.y + wave.h + 2, .w = timeline_w, .h = spectrogram_height };
+ const timeline: sk.Rect = .{ .x = 0, .y = wave.y, .w = timeline_w, .h = spectrogram.y + spectrogram.h - wave.y };
+ // Under the timeline and its time labels, or beside it; room for
+ // the frequency labels under it either way.
+ const levels: sk.Rect = if (l.narrow)
+ .{ .x = 0, .y = spectrogram.y + spectrogram.h + 22, .w = l.world_width, .h = 150 }
+ else
+ .{ .x = l.world_width - spectrum_width, .y = wave.y, .w = spectrum_width, .h = timeline.h - 14 };
+ return .{
+ .whole = .{ .x = 0, .y = y, .w = l.world_width, .h = l.panel_height },
+ .wave = wave,
+ .spectrogram = spectrogram,
+ .timeline = timeline,
+ .spectrum = levels,
+ };
+ }
+
+ /// Button `i` of `buttons`: right to left in the header, or left to
+ /// right across the bottom.
+ fn button(l: Layout, i: usize) sk.Rect {
+ const n: f32 = @floatFromInt(buttons.len);
+ const at: f32 = @floatFromInt(i);
+ if (l.narrow) {
+ const w = (l.w - 8 - (n - 1) * 4) / n;
+ return .{ .x = 4 + (n - 1 - at) * (w + 4), .y = l.h - toolbar + 6, .w = w, .h = toolbar - 10 };
+ }
+ return .{ .x = l.w - 16 - (at + 1) * (button_width + 6) + 6, .y = 5, .w = button_width, .h = 26 };
+ }
+
+ fn buttonAt(l: Layout, x: f32, y: f32) ?Action {
+ for (buttons, 0..) |a, i| if (l.button(i).contains(x, y)) return a;
+ return null;
+ }
+};
+
+const Box = struct {
+ whole: sk.Rect,
+ wave: sk.Rect,
+ spectrogram: sk.Rect,
+ /// Waveform and spectrogram: one time axis, where clicks seek and
+ /// ctrl+wheel (or a pinch) zooms.
+ timeline: sk.Rect,
+ spectrum: sk.Rect,
+
+ fn toScreen(b: Box, cam: sk.Camera) Box {
+ return .{
+ .whole = cam.toScreen(b.whole),
+ .wave = cam.toScreen(b.wave),
+ .spectrogram = cam.toScreen(b.spectrogram),
+ .timeline = cam.toScreen(b.timeline),
+ .spectrum = cam.toScreen(b.spectrum),
+ };
+ }
+};
+
+const World = struct {
+ /// Slots `0..takes` are takes; slot `takes` is the live view, unless a
+ /// recording (the last take) stands in for it.
+ takes: u32,
+ live: bool,
+
+ fn of(s: *const State) World {
+ return .{ .takes = s.takes, .live = s.transport.value != .recording };
+ }
+ fn slots(w: World) u32 {
+ return w.takes + @intFromBool(w.live);
+ }
+ fn height(w: World, l: Layout) f32 {
+ return @as(f32, @floatFromInt(w.slots())) * l.panel_height;
+ }
+ /// The take at world point `p`.
+ fn takeAt(w: World, l: Layout, p: sk.shape.Point) ?u32 {
+ if (p.y < 0 or p.x < 0 or p.x > l.world_width) return null;
+ const k: u32 = @intFromFloat(@floor(p.y / l.panel_height));
+ return if (k < w.takes) k else null;
+ }
+};
+
+/// The camera's vertical range: from the world's top at the viewport's top
+/// to its bottom at the viewport's bottom.
+fn cameraRange(world: World, scale: f32, l: Layout) [2]f32 {
+ const highest = l.view.y + 4;
+ const lowest = l.view.y + l.view.h - 4 - world.height(l) * scale;
+ return .{ @min(lowest, highest), highest };
+}
+
+/// The camera as drawn: centred across, inside the world, and on the
+/// bottom while following.
+fn cameraOf(s: *const State, l: Layout) sk.Camera {
+ var cam = s.camera;
+ cam.zoom = std.math.clamp(cam.zoom, min_zoom, 1);
+ cam.x = @round((l.w - l.world_width * cam.zoom) / 2);
+ const range = cameraRange(World.of(s), cam.zoom, l);
+ cam.y = @round(if (s.follow) range[0] else std.math.clamp(cam.y, range[0], range[1]));
+ return cam;
+}
+
+/// Moves the camera, which follows again once it reaches the bottom.
+fn moveCamera(s: *State, cam: sk.Camera, in: *const sk.Input) void {
+ const l = Layout.of(in.width, in.height);
+ s.camera = cam;
+ s.follow = false;
+ s.camera = cameraOf(s, l);
+ const range = cameraRange(World.of(s), s.camera.zoom, l);
+ s.follow = s.camera.y <= range[0] + 0.5;
+}
+
+// ---------------------------------------------------------------------------
+// Update: transport, selection, views and camera, from input alone.
+
+pub fn update(s: *State, in: *const sk.Input) void {
+ if (in.started) {
+ // Nothing resumes on its own after a restart; the takes are kept.
+ s.transport.value = .stopped;
+ s.scrubbing = false;
+ s.panning = false;
+ }
+ const recording = s.transport.value == .recording;
+ for (keys) |k| if (in.pressed(k[0])) act(s, k[1], in);
+ if (in.pressed(sk.Key.equals)) s.gain = @min(s.gain * 1.25, 64);
+ if (in.pressed(sk.Key.minus)) s.gain = @max(s.gain / 1.25, 0.25);
+ if (in.pressed(sk.Key.z) and s.selected < max_takes) s.views[s.selected] = .{};
+ if (!recording and s.takes > 0) {
+ // Up the strip is older.
+ if (in.pressed(sk.Key.up)) select(s, s.selected -| 1, in);
+ if (in.pressed(sk.Key.down)) select(s, @min(s.selected + 1, s.takes - 1), in);
+ }
+ const l = Layout.of(in.width, in.height);
+ const page = l.view.h - l.panel_height / 2;
+ if (in.pressed(sk.Key.page_down)) panBy(s, -page, in);
+ if (in.pressed(sk.Key.page_up)) panBy(s, page, in);
+
+ const view = l.view;
+ for (in.events) |e| {
+ const cam = cameraOf(s, l);
+ const world = World.of(s);
+ const p = cam.toWorld(sk.shape.Point{ .x = e.x, .y = e.y });
+ switch (e.kind) {
+ .mouse_down => if (e.code == 1 and l.buttonAt(e.x, e.y) != null) {
+ act(s, l.buttonAt(e.x, e.y).?, in);
+ } else if (e.code == 2 or e.code == 3) {
+ // Middle or right drag pans.
+ s.panning = true;
+ s.grab = e.y;
+ } else if (e.code == 1 and !recording and view.contains(e.x, e.y)) {
+ const index = world.takeAt(l, p) orelse continue;
+ select(s, index, in);
+ const b = l.box(index);
+ if (b.timeline.contains(p.x, p.y)) {
+ s.scrubbing = true;
+ seekTo(s, fractionAt(s.views[index], b.timeline, p.x));
+ }
+ },
+ .mouse_move => if (s.panning) {
+ panBy(s, e.y - s.grab, in);
+ s.grab = e.y;
+ } else if (s.scrubbing and s.selected < world.takes) {
+ seekTo(s, fractionAt(s.views[s.selected], l.box(s.selected).timeline, p.x));
+ },
+ .mouse_up, .cancel => {
+ s.scrubbing = false;
+ s.panning = false;
+ },
+ // Ctrl+wheel, or a pinch (which browsers and the web host send
+ // as ctrl+wheel), zooms what is under it: a take's time on its
+ // timeline, the view anywhere else.
+ .wheel => if (view.contains(e.x, e.y)) {
+ const ctrl = e.modifiers() & sk.Key.Mod.ctrl != 0;
+ const over = world.takeAt(l, p);
+ if (ctrl and over != null and l.box(over.?).timeline.contains(p.x, p.y)) {
+ const index = over.?;
+ zoom(&s.views[index], fractionAt(s.views[index], l.box(index).timeline, p.x), std.math.pow(f32, 0.8, e.wheel()));
+ } else if (ctrl) {
+ var moved = cam;
+ moved.zoomAt(sk.shape.Point{ .x = e.x, .y = e.y }, e.wheel(), .{ .min = min_zoom, .max = 1 });
+ moveCamera(s, moved, in);
+ } else panBy(s, e.wheel() * 60, in);
+ },
+ else => {},
+ }
+ }
+}
+
+/// What keys and the buttons on top do.
+const Action = enum { record, play, forward, backward, start, end, open, delete, overview, a4_down, a4_up };
+
+const keys = [_]struct { sk.Key, Action }{
+ .{ .r, .record }, .{ .space, .play }, .{ .right, .forward }, .{ .left, .backward },
+ .{ .home, .start }, .{ .end, .end }, .{ .o, .open }, .{ .delete, .delete },
+ .{ .backspace, .delete }, .{ .@"0", .overview }, .{ .left_bracket, .a4_down }, .{ .right_bracket, .a4_up },
+};
+
+/// Everything a touch screen cannot reach by key, as buttons (see
+/// `Layout.button`). Labels change with what they would do.
+const buttons = [_]Action{ .a4_up, .a4_down, .overview, .delete, .open, .backward, .play, .record };
+const button_width = 52;
+
+fn act(s: *State, a: Action, in: *const sk.Input) void {
+ const now = s.transport.value;
+ switch (a) {
+ .record => if (now == .recording) change(s, .stopped) else record(s),
+ .play => change(s, switch (now) {
+ .forward, .backward => .stopped,
+ .stopped, .recording => if (s.backward) .backward else .forward,
+ }),
+ .forward => change(s, .forward),
+ .backward => change(s, .backward),
+ .start => seekTo(s, 0),
+ .end => seekTo(s, 1),
+ .open => s.dialog.send({}),
+ .delete => if (now != .recording and s.takes > 0) remove(s, in),
+ .overview => {
+ // The whole strip, or back to full size.
+ const l = Layout.of(in.width, in.height);
+ var cam = cameraOf(s, l);
+ cam.zoom = if (cam.zoom < 1) 1 else l.view.h / @max(World.of(s).height(l), 1);
+ moveCamera(s, cam, in);
+ s.follow = true;
+ },
+ .a4_down => s.a4 = @max(s.a4 - 1, 400),
+ .a4_up => s.a4 = @min(s.a4 + 1, 480),
+ }
+}
+
+/// Starts a new take, unless the strip is full. It takes the live view's
+/// place, which the camera follows.
+fn record(s: *State) void {
+ if (s.takes >= max_takes) return;
+ s.selected = s.takes;
+ s.takes += 1;
+ s.views[s.selected] = .{};
+ s.follow = true;
+ change(s, .recording);
+}
+
+fn change(s: *State, to: Transport) void {
+ if (to == .forward or to == .backward) s.backward = to == .backward;
+ s.transport.send(to);
+}
+
+fn seekTo(s: *State, fraction: f32) void {
+ if (s.transport.value == .recording) return;
+ s.seek.send(std.math.clamp(fraction, 0, 1));
+}
+
+/// Selects a take and brings it into view.
+fn select(s: *State, index: u32, in: *const sk.Input) void {
+ s.selected = index;
+ const l = Layout.of(in.width, in.height);
+ var cam = cameraOf(s, l);
+ const b = cam.toScreen(l.box(index).whole);
+ const view = l.view;
+ if (b.y < view.y) cam.y += view.y - b.y + 4;
+ if (b.y + b.h > view.y + view.h) cam.y -= b.y + b.h - (view.y + view.h) + 4;
+ moveCamera(s, cam, in);
+}
+
+/// Moves the world down by `pixels` on screen.
+fn panBy(s: *State, pixels: f32, in: *const sk.Input) void {
+ var cam = cameraOf(s, Layout.of(in.width, in.height));
+ cam.y += pixels;
+ moveCamera(s, cam, in);
+}
+
+/// Deletes the selected take and selects the one above it.
+fn remove(s: *State, in: *const sk.Input) void {
+ const index = @min(s.selected, s.takes - 1);
+ s.remove.send(index);
+ std.mem.copyForwards(View, s.views[index .. s.takes - 1], s.views[index + 1 .. s.takes]);
+ s.takes -= 1;
+ s.selected = index -| 1;
+ moveCamera(s, cameraOf(s, Layout.of(in.width, in.height)), in);
+}
+
+fn fractionAt(v: View, timeline: sk.Rect, x: f32) f32 {
+ return v.lo + (x - timeline.x) / timeline.w * (v.hi - v.lo);
+}
+
+/// Scales the view by `factor` around `at`, keeping it inside the take.
+fn zoom(v: *View, at: f32, factor: f32) void {
+ const span = std.math.clamp((v.hi - v.lo) * factor, 1e-6, 1);
+ var lo = at - (at - v.lo) / (v.hi - v.lo) * span;
+ lo = std.math.clamp(lo, 0, 1 - span);
+ v.lo = lo;
+ v.hi = lo + span;
+}
+
+/// `open PATH` adds a file as a take; `open` alone shows the dialog.
+/// `takes N` tells State how many takes the Store holds (`draw` sends it).
+pub fn command(s: *State, store: *Store, c: *sk.Console, line: []const u8) !bool {
+ var words = std.mem.tokenizeAny(u8, line, " \t");
+ const verb = words.next() orelse return false;
+ if (std.mem.eql(u8, verb, "takes")) {
+ const n = try std.fmt.parseInt(u32, words.next() orelse return error.ExpectedCount, 10);
+ s.takes = @min(n, max_takes);
+ s.selected = @min(s.selected, s.takes -| 1);
+ return true;
+ }
+ if (!std.mem.eql(u8, verb, "open")) return false;
+ const path = std.mem.trim(u8, words.rest(), " \t");
+ if (path.len == 0) {
+ s.dialog.send({});
+ return true;
+ }
+ if (store.takes.items.len >= max_takes) return error.TooManyTakes;
+ const samples = c.host.samples(c.host.loadSound(path));
+ if (samples.len == 0) return error.CannotOpen;
+ // Recording grows the last take: stop before this one goes after it.
+ if (s.transport.value == .recording) change(s, .stopped);
+ const kept = samples[0..@min(samples.len, max_seconds * c.in.sample_rate)];
+ var take: Take = .{ .start = store.tape.items.len, .len = kept.len, .id = store.next_id };
+ const base = std.fs.path.basename(path);
+ take.source_len = @intCast(@min(base.len, take.source.len));
+ @memcpy(take.source[0..take.source_len], base[0..take.source_len]);
+ try store.takes.ensureUnusedCapacity(c.store, 1);
+ try store.tape.appendSlice(c.store, kept);
+ store.takes.appendAssumeCapacity(take);
+ store.next_id += 1;
+ s.takes = @intCast(store.takes.items.len);
+ s.selected = s.takes - 1;
+ s.views[s.selected] = .{};
+ s.follow = true;
+ change(s, .stopped);
+ c.print("opened {s}: {d:.1} s", .{ path, @as(f64, @floatFromInt(kept.len)) / @as(f64, @floatFromInt(c.in.sample_rate)) });
+ return true;
+}
+
+// ---------------------------------------------------------------------------
+// Draw: the takes, the microphone, the speakers and the GPU.
+
+pub fn draw(s: *const State, ss: *Session, store: *Store, f: *sk.Frame) void {
+ const in = f.in;
+ const rate: f64 = @floatFromInt(in.sample_rate);
+ const dt: f64 = @min(@as(f64, @floatFromInt(in.dt)) / std.time.ns_per_s, 0.1);
+ // As big as the window: the layout follows (see `Layout`).
+ f.canvas(@intFromFloat(@max(in.window_width, min_width)), @intFromFloat(@max(in.window_height, min_height)));
+ f.clear(0x0b0c0f);
+
+ adoptTape(store, f.store);
+ if (ss.dialog.take(s.dialog) != null) f.openFile("open", .{ .pattern = "wav;flac;ogg" });
+ if (ss.remove.take(s.remove)) |index| removeTake(ss, store, index);
+
+ // Requests from State. Any of them, or another take selected, flushes
+ // what is queued, so the cursor restarts from what was heard.
+ const transport = ss.transport.take(s.transport);
+ const seek = ss.seek.take(s.seek);
+ // Recording goes by the transport's value rather than the request, so a
+ // fresh session that only caught up with the request still records.
+ if (s.transport.value != .recording) {
+ ss.recording = 0;
+ } else if (store.takes.items.len == 0 or store.takes.items[store.takes.items.len - 1].id != ss.recording) {
+ startTake(ss, store, f.store);
+ }
+ const takes = store.takes.items;
+ if (s.takes != takes.len) f.run(f.format("takes {d}", .{takes.len}));
+ const selected: ?*Take = if (takes.len > 0) &takes[@min(s.selected, takes.len - 1)] else null;
+ var queued: usize = in.stream(stream).queued;
+ if (selected) |t| {
+ if (transport != null or seek != null or t.id != ss.playing) {
+ f.audio(stream, &.{}, .{ .clear = true });
+ queued = 0;
+ ss.playing = t.id;
+ ss.cursor = @intFromFloat(std.math.clamp(@round(t.heard), 0, @as(f64, @floatFromInt(t.len))));
+ }
+ if (transport) |to| {
+ switch (to) {
+ .forward => if (ss.cursor >= t.len) {
+ ss.cursor = 0;
+ },
+ .backward => if (ss.cursor == 0) {
+ ss.cursor = t.len;
+ },
+ .stopped, .recording => {},
+ }
+ t.heard = @floatFromInt(ss.cursor);
+ }
+ if (seek) |fraction| if (s.transport.value != .recording) {
+ ss.cursor = @intFromFloat(@round(fraction * @as(f32, @floatFromInt(t.len))));
+ t.heard = @floatFromInt(ss.cursor);
+ };
+ }
+
+ // The microphone is always open: the live view shows it, and a
+ // recording keeps it.
+ f.microphone();
+ ss.live.push(in.microphone);
+ switch (s.transport.value) {
+ .recording => if (takes.len > 0 and takes[takes.len - 1].id == ss.recording) {
+ const t = &takes[takes.len - 1];
+ const room = max_seconds * in.sample_rate -| t.len;
+ const heard = in.microphone[0..@min(in.microphone.len, room)];
+ store.tape.appendSlice(f.store, heard) catch f.host.log("the store is full: recording stopped");
+ t.len = store.tape.items.len - t.start;
+ t.heard = @floatFromInt(t.len);
+ },
+ .forward, .backward => if (selected) |t| play(ss, t, store.tape.items[t.start..][0..t.len], f, s.transport.value == .forward, queued, rate, dt),
+ .stopped => {},
+ }
+
+ // The tuner's readbacks, a frame or two old.
+ if (selected) |t| if (t.id != ss.tuned) {
+ ss.tuned = t.id;
+ 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 (!f.host.gpu()) {
+ f.text(16, Layout.header, 2, "micscope needs a GPU: the host has none.", 0xff8080);
+ return;
+ }
+ render(s, ss, store, f, rate, dt);
+}
+
+/// Stores from before the strip held one tape: it becomes the first take.
+fn adoptTape(store: *Store, a: std.mem.Allocator) void {
+ if (store.takes.items.len > 0 or store.tape.items.len == 0) return;
+ store.takes.append(a, .{ .len = store.tape.items.len, .id = store.next_id }) catch return;
+ store.next_id += 1;
+}
+
+fn startTake(ss: *Session, store: *Store, a: std.mem.Allocator) void {
+ store.takes.append(a, .{ .start = store.tape.items.len, .id = store.next_id }) catch {
+ return;
+ };
+ ss.recording = store.next_id;
+ store.next_id += 1;
+}
+
+fn removeTake(ss: *Session, store: *Store, index: u32) void {
+ if (index >= store.takes.items.len) return;
+ const t = store.takes.orderedRemove(index);
+ const tape = store.tape.items;
+ std.mem.copyForwards(f32, tape[t.start .. tape.len - t.len], tape[t.start + t.len ..]);
+ store.tape.shrinkRetainingCapacity(tape.len - t.len);
+ for (store.takes.items[index..]) |*later| later.start -= t.len;
+ ss.gpu.uploaded = @min(ss.gpu.uploaded, t.start);
+ for (&ss.gpu.panels) |*p| if (p.id == t.id) {
+ p.id = 0;
+ p.forget();
+ };
+}
+
+/// Keeps the stream `lead_seconds` ahead, reading the take either way, and
+/// follows the listener.
+fn play(ss: *Session, t: *Take, tape: []const f32, f: *sk.Frame, forward: bool, queued: usize, rate: f64, dt: f64) void {
+ const lead: usize = @intFromFloat(rate * lead_seconds);
+ const want = lead -| queued;
+ // What is heard now: the cursor, less what is queued in front of it.
+ const measured: f64 = @floatFromInt(if (forward) ss.cursor -| queued else @min(ss.cursor + queued, tape.len));
+ if (forward) {
+ const n = @min(want, tape.len -| ss.cursor);
+ f.audio(stream, tape[@min(ss.cursor, tape.len)..][0..n], .{});
+ ss.cursor += n;
+ } else {
+ const n = @min(want, ss.cursor);
+ const reversed = f.scratch.alloc(f32, n) catch return;
+ for (reversed, 0..) |*sample, i| sample.* = tape[ss.cursor - 1 - i];
+ f.audio(stream, reversed, .{});
+ ss.cursor -= n;
+ }
+ // The queue drains in device-sized blocks: advance by the clock and
+ // pull gently towards the measurement, snapping when far off.
+ const direction: f64 = if (forward) 1 else -1;
+ t.heard += direction * dt * rate;
+ const off = measured - t.heard;
+ t.heard = if (@abs(off) > rate * 0.25) measured else t.heard + off * 0.15;
+ t.heard = std.math.clamp(t.heard, 0, @as(f64, @floatFromInt(tape.len)));
+}
+
+// ---------------------------------------------------------------------------
+// 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,
+ .readwrite_buffers = 1,
+ .uniform_buffers = 1,
+ .threads = .{ 256, 1, 1 },
+};
+const tuner_kernel: gpu.Kernel = .{
+ .code = shaders.tuner_comp,
+ .readonly_buffers = 2,
+ .readwrite_buffers = 1,
+ .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));
+}
+
+fn makeBuffers(p: *Panel, f: *sk.Frame) void {
+ if (p.wave_columns != .none) return;
+ p.wave_columns = f.host.newBuffer(layouts.max_columns * @sizeOf([4]f32));
+ p.spectrum_columns = f.host.newBuffer(layouts.max_columns * @sizeOf([2]f32));
+ p.levels = f.host.newBuffer(layouts.max_columns * spectrogram_height * @sizeOf(f32));
+}
+
+/// The panel for take `id`: the one it had, or the least recently used.
+fn panelFor(g: *Gpu, f: *sk.Frame, id: u32) *Panel {
+ const p = for (&g.panels) |*p| {
+ if (p.id == id) break p;
+ } else reuse: {
+ var oldest = &g.panels[0];
+ for (&g.panels) |*p| if (p.used < oldest.used) {
+ oldest = p;
+ };
+ oldest.id = id;
+ oldest.forget();
+ break :reuse oldest;
+ };
+ p.used = f.in.frame;
+ makeBuffers(p, f);
+ return p;
+}
+
+/// An image of `size`, (re)made when the size changes.
+fn target(f: *sk.Frame, image: *sk.Image, size: *[2]u32, r: sk.Rect) [2]u32 {
+ const want: [2]u32 = .{ @intFromFloat(@min(r.w, layouts.max_columns)), @intFromFloat(@min(r.h, spectrogram_height)) };
+ if (image.* == .none or size[0] != want[0] or size[1] != want[1]) {
+ if (image.* != .none) f.host.freeImage(image.*);
+ image.* = f.host.newImage(want[0], want[1]);
+ size.* = want;
+ }
+ return want;
+}
+
+/// Puts the tape on the GPU: new samples only, unless the buffer had to grow.
+fn sync(g: *Gpu, f: *sk.Frame, tape: []const f32) void {
+ if (tape.len > g.capacity or g.tape == .none) {
+ if (g.tape != .none) f.host.freeBuffer(g.tape);
+ g.capacity = @max(tape.len, g.capacity * 2, 60 * f.in.sample_rate);
+ g.tape = f.host.newBuffer(@intCast(g.capacity * @sizeOf(f32)));
+ g.uploaded = 0;
+ }
+ g.uploaded = @min(g.uploaded, tape.len);
+ if (g.uploaded < tape.len) {
+ f.upload(g.tape, @intCast(g.uploaded * @sizeOf(f32)), std.mem.sliceAsBytes(tape[g.uploaded..]));
+ g.uploaded = tape.len;
+ }
+}
+
+fn render(s: *const State, ss: *Session, store: *Store, f: *sk.Frame, rate: f64, dt: f64) void {
+ 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();
+ }
+ 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;
+ const world: World = .{ .takes = @intCast(takes.len), .live = !recording };
+ const l = Layout.of(f.in.width, f.in.height);
+ const cam = cameraOf(s, l);
+ const view = l.view;
+ // 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);
+ // The tuner: on the microphone's newest sound, and on the selected take
+ // around its playhead.
+ const reach = layouts.tuner_window + 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);
+ 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| {
+ 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);
+ }
+ }
+ f.clip(null);
+ labels(s, ss, store, f, world, cam, rate);
+}
+
+/// Finds the pitch of the `tuner_window` samples before `end` (of the
+/// `samples` from `offset`), and reads it back.
+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{
+ .offset = @intCast(offset),
+ .end = @intCast(end),
+ .samples = @intCast(samples),
+ .rate = @floatCast(rate),
+ .min_freq = tuner_low,
+ .max_freq = tuner_high,
+ .threshold = 0.12,
+ });
+ f.compute(.{
+ .label = "tuner_difference.comp",
+ .kernel = tuner_difference_kernel,
+ .readonly = &.{tape},
+ .readwrite = &.{difference},
+ .uniforms = params,
+ // Match tuner_difference.comp's LAGS_PER_GROUP.
+ .groups = .{ (layouts.tuner_lags + 15) / 16, 1, 1 },
+ });
+ f.compute(.{
+ .label = "tuner.comp",
+ .kernel = tuner_kernel,
+ .readonly = &.{ tape, difference },
+ .readwrite = &.{result},
+ .uniforms = params,
+ });
+ f.download(result, .{ .size = @sizeOf(layouts.Pitch), .key = @intFromEnum(which) });
+}
+
+/// The pitches the tuner looks for: a five-string bass's low B to a
+/// piccolo's top.
+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,
+ .readonly = &.{tape},
+ .readwrite = &.{ g.scratch, p.spectrum_columns },
+ .uniforms = gpu.uniform(f.scratch, params),
+ });
+ f.gpu(.{
+ .label = "spectrum.frag",
+ .image = p.spectrum,
+ .width = size[0],
+ .height = size[1],
+ .clear = null,
+ .pipelines = &spectrum_pipelines,
+ .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,
+ .ceil_db = 0,
+ .min_freq = min_freq,
+ .max_freq = 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);
+
+ // Waveform columns, when what they show changed.
+ const wave = target(f, &p.wave, &p.wave_size, size.wave);
+ const span = visible(view, t.len, wave[0]);
+ const first: u32 = @intFromFloat(@floor(span[0]));
+ const spp: f32 = @floatCast((span[1] - span[0]) / @as(f64, @floatFromInt(wave[0])));
+ const params: layouts.WaveParams = .{
+ .offset = @intCast(t.start),
+ .first = first,
+ .samples = @intCast(t.len),
+ .columns = wave[0],
+ .spp = spp,
+ .slot = 0,
+ .ring = layouts.max_columns,
+ };
+ const key = std.hash.Wyhash.hash(0, std.mem.asBytes(&params));
+ if (key != p.wave_key) {
+ p.wave_key = key;
+ f.compute(.{
+ .label = "waveform.comp",
+ .kernel = waveform_kernel,
+ .readonly = &.{g.tape},
+ .readwrite = &.{p.wave_columns},
+ .uniforms = gpu.uniform(f.scratch, params),
+ .groups = .{ wave[0], 1, 1 },
+ });
+ }
+
+ // The spectrogram over the same columns.
+ const spectrogram = target(f, &p.spectrogram, &p.spectrogram_size, size.spectrogram);
+ const analysis: layouts.SpectrogramParams = .{
+ .offset = @intCast(t.start),
+ .first = first,
+ .samples = @intCast(t.len),
+ .columns = spectrogram[0],
+ .rows = spectrogram[1],
+ .spp = spp,
+ .rate = @floatCast(rate),
+ .min_freq = min_freq,
+ .max_freq = maxFreq(rate),
+ .slot = 0,
+ .ring = layouts.max_columns,
+ };
+ const analysis_key = std.hash.Wyhash.hash(0, std.mem.asBytes(&analysis));
+ if (analysis_key != p.spectrogram_key) {
+ p.spectrogram_key = analysis_key;
+ f.compute(.{
+ .label = "spectrogram.comp",
+ .kernel = spectrogram_kernel,
+ .readonly = &.{g.tape},
+ .readwrite = &.{p.levels},
+ .uniforms = gpu.uniform(f.scratch, analysis),
+ .groups = .{ spectrogram[0], 1, 1 },
+ });
+ }
+
+ // The spectrum around the playhead, or of the latest while recording:
+ // every frame for the selected take, which plays and glides; the others
+ // only when it would change, and without smoothing.
+ const half: f64 = layouts.window / 2;
+ const len: f64 = @floatFromInt(t.len);
+ const end: f64 = if (tint == .recording) len else @min(t.heard + half, len + half);
+ const shown = target(f, &p.spectrum, &p.spectrum_size, size.spectrum);
+ var sparams: layouts.SpectrumParams = .{
+ .offset = @intCast(t.start),
+ .end = @intFromFloat(@max(end, 0)),
+ .samples = @intCast(t.len),
+ .columns = shown[0],
+ .reset = 0,
+ .rate = @floatCast(rate),
+ .min_freq = min_freq,
+ .max_freq = maxFreq(rate),
+ .dt = 0,
+ };
+ const spectrum_key = std.hash.Wyhash.hash(1, std.mem.asBytes(&sparams));
+ if (selected or spectrum_key != p.spectrum_key) {
+ sparams.reset = @intFromBool(!selected or p.spectrum_key == 0);
+ sparams.dt = @floatCast(dt);
+ p.spectrum_key = spectrum_key;
+ spectrum(g, f, g.tape, p, shown, sparams, rate);
+ }
+
+ const at: f32 = @floatCast((t.heard - span[0]) / (span[1] - span[0]) * @as(f64, @floatFromInt(wave[0])));
+ const playhead: f32 = if (!selected or t.len == 0 or at < 0 or at > @as(f32, @floatFromInt(wave[0]))) -1 else at;
+ const wave_view: layouts.WaveView = .{
+ .size = .{ @floatFromInt(wave[0]), @floatFromInt(wave[1]) },
+ .playhead = playhead,
+ .gain = s.gain,
+ .tint = @intFromEnum(tint),
+ .scroll = 0,
+ .filled = wave[0],
+ };
+ 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);
+ }
+ const spectrogram_view: layouts.SpectrogramView = .{
+ .size = .{ @floatFromInt(spectrogram[0]), @floatFromInt(spectrogram[1]) },
+ .floor_db = floor_db,
+ .ceil_db = -6,
+ .playhead = playhead,
+ .scroll = 0,
+ .filled = spectrogram[0],
+ };
+ 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);
+ }
+ // 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, .{});
+}
+
+/// The samples a take's timeline spans, at least 1/32 of a sample per
+/// column.
+fn visible(v: View, len: usize, columns: u32) [2]f64 {
+ const total: f64 = @floatFromInt(len);
+ var lo = v.lo * total;
+ var hi = v.hi * total;
+ const least = @as(f64, @floatFromInt(columns)) / 32;
+ if (hi - lo < least) {
+ const mid = (lo + hi) / 2;
+ lo = @max(mid - least / 2, 0);
+ hi = lo + least;
+ }
+ return .{ lo, hi };
+}
+
+// ---------------------------------------------------------------------------
+// Text.
+
+const dim = 0x7a8090;
+const bright = 0xe6e9ef;
+const red = 0xff5a5a;
+const green = 0x6fdc8c;
+const yellow = 0xffd84d;
+
+fn labels(s: *const State, ss: *const Session, store: *const Store, f: *sk.Frame, world: World, cam: sk.Camera, rate: f64) void {
+ const takes = store.takes.items;
+ const recording = s.transport.value == .recording;
+ const selected = if (takes.len > 0) @min(s.selected, takes.len - 1) else 0;
+
+ // What the transport is doing, to which take.
+ const status: struct { []const u8, u24 } = switch (s.transport.value) {
+ .recording => .{ "REC", red },
+ .forward => .{ "PLAY >", 0x7fd7ff },
+ .backward => .{ "PLAY <", 0x7fd7ff },
+ .stopped => .{ "PAUSED", dim },
+ };
+ const l = Layout.of(f.in.width, f.in.height);
+ f.text(16, 10, 2, status[0], status[1]);
+ if (takes.len > 0) {
+ const t = takes[selected];
+ const times = .{ Time{ .seconds = t.heard / rate }, Time{ .seconds = @as(f64, @floatFromInt(t.len)) / rate } };
+ // As much as fits beside the buttons (or, narrow, the corner).
+ const room = if (l.narrow) l.w - 16 * 7 else l.button(buttons.len - 1).x - 16;
+ if (room >= 480) {
+ f.print(140, 10, 2, bright, "{f} / {f}", times);
+ if (room >= 740) f.print(500, 14, 1, dim, "take {d} of {d}: {s}", .{ selected + 1, takes.len, source(&t) });
+ } else f.print(16 + 16 * 7, 14, 1, bright, "{f} / {f}", times);
+ }
+ for (buttons, 0..) |a, i| button(s, f, a, l.button(i));
+ const corner = f.format("{s}{s}", .{
+ if (s.gain != 1) f.format("gain x{d:.2} ", .{s.gain}) else "",
+ if (cam.zoom < 1) f.format("view x{d:.2}", .{cam.zoom}) else "",
+ });
+ f.text(f.in.width - 16 - @as(f32, @floatFromInt(corner.len * 8)), if (l.narrow) 14 else f.in.height - 16, 1, corner, dim);
+
+ const view = l.view;
+ f.clip(view);
+ for (0..world.slots()) |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;
+ // Centred in the band above the waveform, whatever the zoom.
+ const title_y = @round(b.whole.y + (b.wave.y - b.whole.y - 8) / 2);
+ if (k == world.takes) {
+ f.print(b.whole.x, title_y, 1, green, "LIVE the microphone, the last {d} s", .{live_seconds});
+ if (ss.live.heard == 0) f.text(b.wave.x + 8, b.wave.y + 8, 1, "nothing from the microphone yet", dim);
+ if (cam.zoom >= 0.8) axes(f, b, rate, null);
+ tunerOverlay(f, b.spectrum, ss.tuners[@intFromEnum(Tuned.input)].reading, s.a4, rate, cam.zoom >= 0.8);
+ continue;
+ }
+ const t = &takes[k];
+ const seconds = Time{ .seconds = @as(f64, @floatFromInt(t.len)) / rate };
+ if (recording and k + 1 == world.takes) {
+ f.print(b.whole.x, title_y, 1, red, "RECORDING take {d} {f}", .{ k + 1, seconds });
+ } else {
+ const chosen = k == selected;
+ if (chosen) f.fill(.{ .x = b.whole.x - if (l.narrow) @as(f32, 6) else 12, .y = b.wave.y, .w = 3, .h = b.timeline.h }, yellow);
+ f.print(b.whole.x, title_y, 1, @as(u24, if (chosen) bright else dim), "#{d} {s} {f}", .{ k + 1, source(t), seconds });
+ }
+ if (cam.zoom >= 0.8) {
+ const span = visible(s.views[k], t.len, @intFromFloat(@min(l.box(0).wave.w, layouts.max_columns)));
+ axes(f, b, rate, .{ span[0] / rate, span[1] / rate });
+ }
+ const which: ?Tuned = if (recording) (if (k + 1 == world.takes) .input else null) else if (k == selected) .take else null;
+ if (which) |w| tunerOverlay(f, b.spectrum, ss.tuners[@intFromEnum(w)].reading, s.a4, rate, cam.zoom >= 0.8);
+ }
+ f.clip(null);
+ if (world.takes == 0) f.text(16, view.y + view.h - 12, 1, "No takes yet: REC records one, OPEN opens a file.", dim);
+ // Keys, where there is a keyboard to press them.
+ if (!l.narrow) f.text(16, f.in.height - 16, 1, "R SPACE LEFT RIGHT HOME END O DEL 0 [ ] UP/DOWN take wheel or 2 fingers pan CTRL+wheel or pinch zoom", dim);
+}
+
+/// The tuner on a spectrum: the pitch and its harmonics where they fall on
+/// it, the span of two semitones either side shaded, and that span
+/// magnified across the top: the nearest notes of the chromatic scale,
+/// 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 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;
+ }
+ }.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);
+ 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.
+ for (2..9) |h| {
+ const hz = freq * @as(f32, @floatFromInt(h));
+ if (hz > max_freq) break;
+ f.fill(.{ .x = @round(x(r, hz, max_freq)), .y = r.y + r.h - 10, .w = 1, .h = 10 }, color.alpha(fade / 2));
+ }
+ if (!detailed) return;
+
+ // The magnified scale: semitones `note - 2.5` to `note + 2.5`.
+ const strip: sk.Rect = .{ .x = r.x + 6, .y = r.y + 4, .w = r.w - 12, .h = 30 };
+ const semitone = strip.w / 5;
+ const centre = strip.x + strip.w / 2;
+ f.fill(strip, sk.Color.hex(0x0b0c0f).alpha(220));
+ var c: f32 = -250;
+ while (c <= 250) : (c += 10) {
+ const whole = @mod(c, 100) == 0;
+ const h: f32 = if (whole) 10 else if (@mod(c, 50) == 0) 6 else 3;
+ f.fill(.{ .x = @round(centre + c / 100 * semitone), .y = strip.y + strip.h - h, .w = 1, .h = h }, sk.Color.hex(if (c == 0) bright else dim).alpha(if (whole) 220 else 120));
+ }
+ for (0..5) |i| {
+ const note = at.note - 2 + @as(i32, @intCast(i));
+ const label = f.format("{s}{d}", .{ tuner.name(note), tuner.octave(note) });
+ const lx = centre + (@as(f32, @floatFromInt(i)) - 2) * semitone - @as(f32, @floatFromInt(label.len * 4));
+ f.text(lx, strip.y + 4, 1, label, if (note == at.note) color else sk.Color.hex(dim).alpha(fade));
+ }
+ const needle = std.math.clamp(centre + cents / 100 * semitone, strip.x, strip.x + strip.w - 2);
+ f.fill(.{ .x = @round(needle) - 1, .y = strip.y + 14, .w = 3, .h = strip.h - 14 }, color);
+
+ // The reading.
+ const big = f.format("{s}{d}", .{ tuner.name(at.note), tuner.octave(at.note) });
+ const panel: sk.Rect = .{ .x = r.x + r.w - 6 - 124, .y = strip.y + strip.h + 4, .w = 124, .h = 50 };
+ f.fill(panel, sk.Color.hex(0x0b0c0f).alpha(200));
+ f.text(panel.x + 6, panel.y + 4, 3, big, color);
+ const whole = @round(cents);
+ f.print(panel.x + 6, panel.y + 30, 1, sk.Color.hex(bright).alpha(fade), "{s}{d:.0} cents", .{ if (whole > 0) "+" else "", if (whole == 0) 0 else whole });
+ f.print(panel.x + 6, panel.y + 40, 1, sk.Color.hex(dim).alpha(fade), "{d:.2} Hz", .{freq});
+ f.print(panel.x + 70, panel.y + 4, 1, sk.Color.hex(dim).alpha(fade), "A4 {d:.0}", .{a4});
+}
+
+fn button(s: *const State, f: *sk.Frame, a: Action, r: sk.Rect) void {
+ const now = s.transport.value;
+ const label: []const u8, const lit: ?u24 = switch (a) {
+ .record => if (now == .recording) .{ "STOP", red } else .{ "REC", null },
+ .play => if (now == .forward or now == .backward) .{ "PAUSE", 0x7fd7ff } else .{ "PLAY", null },
+ .backward => .{ "REV", if (now == .backward) 0x7fd7ff else null },
+ .open => .{ "OPEN", null },
+ .delete => .{ "DEL", null },
+ .overview => .{ "ALL", null },
+ .a4_down => .{ "A4-", null },
+ .a4_up => .{ "A4+", null },
+ .forward, .start, .end => .{ "", null },
+ };
+ f.fill(r, sk.Color.hex(if (lit) |c| c else 0x1c2029).alpha(if (lit != null) 70 else 255));
+ f.fill(.{ .x = r.x, .y = r.y + r.h - 1, .w = r.w, .h = 1 }, sk.Color.hex(lit orelse 0x2e3440));
+ f.text(r.x + (r.w - @as(f32, @floatFromInt(label.len * 8))) / 2, r.y + 9, 1, label, sk.Color.hex(lit orelse bright));
+}
+
+fn source(t: *const Take) []const u8 {
+ return if (t.source_len > 0) t.source[0..t.source_len] else "microphone";
+}
+
+/// A panel's scales: its time span (seconds; null for the live view, which
+/// ends now) under the spectrogram, frequencies up the spectrogram, and
+/// frequency and level on the spectrum.
+fn axes(f: *sk.Frame, b: Box, rate: f64, span: ?[2]f64) void {
+ const below = b.spectrogram.y + b.spectrogram.h + 4;
+ const left = if (span) |sp| f.format("{f}", .{Time{ .seconds = sp[0] }}) else f.format("-{d} s", .{live_seconds});
+ const right = if (span) |sp| f.format("{f}", .{Time{ .seconds = sp[1] }}) else "now";
+ 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);
+ 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))));
+ 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;
+ 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);
+ f.print(b.spectrum.x + 4, y + 3, 1, dim, "{d}", .{db});
+ }
+}
+
+fn hzLabel(f: *sk.Frame, hz: f64) []const u8 {
+ return if (hz >= 1000) f.format("{d}k", .{hz / 1000}) else f.format("{d}", .{hz});
+}
+
+const Time = struct {
+ seconds: f64,
+
+ pub fn format(t: Time, w: *std.Io.Writer) std.Io.Writer.Error!void {
+ const ms: u64 = @intFromFloat(@max(t.seconds, 0) * 1000);
+ try w.print("{d}:{d:0>2}.{d:0>3}", .{ ms / 60_000, ms / 1000 % 60, ms % 1000 });
+ }
+};
+
+test "zoom keeps the view inside the take and around the pointer" {
+ var v: View = .{};
+ zoom(&v, 0.5, 0.5);
+ try std.testing.expectApproxEqAbs(@as(f32, 0.25), v.lo, 1e-6);
+ try std.testing.expectApproxEqAbs(@as(f32, 0.75), v.hi, 1e-6);
+ zoom(&v, 0.0, 4);
+ try std.testing.expectEqual(@as(f32, 0), v.lo);
+ try std.testing.expectEqual(@as(f32, 1), v.hi);
+}
+
+test "the world stacks takes in order with the live view last" {
+ const world: World = .{ .takes = 3, .live = true };
+ try std.testing.expectEqual(@as(u32, 4), world.slots());
+ const l = Layout.of(width, height);
+ try std.testing.expectEqual(@as(?u32, 0), world.takeAt(l, .{ .x = 10, .y = 1 }));
+ try std.testing.expectEqual(@as(?u32, 2), world.takeAt(l, .{ .x = 10, .y = 2 * l.panel_height + 1 }));
+ try std.testing.expectEqual(@as(?u32, null), world.takeAt(l, .{ .x = 10, .y = 3 * l.panel_height + 1 }));
+}
+
+test "the camera follows the bottom and stays inside the world, wide or narrow" {
+ for ([_]Layout{ .of(width, height), .of(390, 844) }) |l| {
+ var s: State = .{ .takes = 5 };
+ const cam = cameraOf(&s, l);
+ // Following: the live view's bottom sits at the viewport's bottom.
+ try std.testing.expectApproxEqAbs(l.view.y + l.view.h - 4, cam.toScreen(l.box(5).whole).y + l.panel_height, 1);
+ s.follow = false;
+ s.camera.y = 1e6;
+ try std.testing.expectApproxEqAbs(l.view.y + 4, cameraOf(&s, l).toScreen(l.box(0).whole).y, 1);
+ }
+}
+
+test "a narrow layout stacks the spectrum under the timeline, inside the panel" {
+ const l: Layout = .of(390, 844);
+ try std.testing.expect(l.narrow);
+ const b = l.box(0);
+ try std.testing.expect(b.spectrum.y > b.timeline.y + b.timeline.h);
+ try std.testing.expect(b.spectrum.y + b.spectrum.h + 16 <= b.whole.y + b.whole.h);
+ try std.testing.expectEqual(l.world_width, b.timeline.w);
+ // Buttons fill the bottom, inside the canvas, without overlapping.
+ for (0..buttons.len) |i| {
+ const r = l.button(i);
+ try std.testing.expect(r.x >= 0 and r.x + r.w <= l.w and r.y + r.h <= l.h);
+ try std.testing.expect(r.w >= 40);
+ }
+}
+
+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
new file mode 100644
index 0000000..92a8482
--- /dev/null
+++ b/examples/micscope/src/tuner.zig
@@ -0,0 +1,147 @@
+//! From pitch estimates (tuner.comp's YIN, one per frame) to a steady note on
+//! the 12-tone equal-tempered chromatic scale, for any instrument: notes are
+//! MIDI numbers (69 is A4, at `a4` Hz), so the range is whatever the
+//! detector finds, from a bass's low B to a piccolo's top.
+//!
+//! Raw estimates jitter and, at a note's attack or release, misfire. So:
+//! unclear or quiet estimates are ignored; the median of the last few
+//! clear ones is followed, smoothed; a jump of over a semitone restarts the
+//! median, so a new note shows at once; and the note shown only changes
+//! 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 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;
+/// Quieter than this is silence, dBFS.
+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))];
+}
+
+pub fn octave(note: i32) i32 {
+ return @divFloor(note, 12) - 1;
+}
+
+pub const Reading = struct {
+ /// The note it is nearest, as a MIDI number.
+ note: i32,
+ /// The pitch, as a fractional MIDI number.
+ pitch: f32,
+ /// Seconds since a clear estimate: 0 while the note sounds.
+ quiet: f32,
+
+ pub fn cents(r: Reading) f32 {
+ return (r.pitch - @as(f32, @floatFromInt(r.note))) * 100;
+ }
+};
+
+pub const Tracker = struct {
+ recent: [5]f32 = @splat(0),
+ count: u32 = 0,
+ reading: ?Reading = null,
+
+ pub fn feed(t: *Tracker, p: layouts.Pitch, a4: f32, dt: f32) void {
+ const clear = p.freq > 0 and p.clarity >= min_clarity and p.level >= min_level;
+ if (!clear) {
+ t.count = 0;
+ if (t.reading) |*r| {
+ r.quiet += dt;
+ if (r.quiet > hold_seconds) t.reading = null;
+ }
+ return;
+ }
+ const m = 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..]);
+ t.count -= 1;
+ }
+ t.recent[t.count] = m;
+ t.count += 1;
+ const target = t.median();
+
+ const fresh = t.count == 1 or t.reading == null or t.reading.?.quiet > 0;
+ var r: Reading = if (fresh) .{ .note = @intFromFloat(@round(target)), .pitch = target, .quiet = 0 } else t.reading.?;
+ r.pitch += (target - r.pitch) * 0.4;
+ r.quiet = 0;
+ if (@abs(r.pitch - @as(f32, @floatFromInt(r.note))) > 0.6) r.note = @intFromFloat(@round(r.pitch));
+ t.reading = r;
+ }
+
+ fn median(t: *const Tracker) f32 {
+ var sorted = t.recent;
+ std.mem.sort(f32, sorted[0..t.count], {}, std.sort.asc(f32));
+ return sorted[t.count / 2];
+ }
+};
+
+fn pitchOf(freq: f32) layouts.Pitch {
+ return .{ .freq = freq, .clarity = 0.97, .level = -20, .period = 48_000 / freq };
+}
+
+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);
+ 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);
+ try std.testing.expectApproxEqAbs(@as(f32, 12), r.cents(), 0.5);
+}
+
+test "one wild estimate does not move the note" {
+ var t: Tracker = .{};
+ for (0..10) |_| t.feed(pitchOf(110), 440, 1.0 / 60.0);
+ t.feed(pitchOf(220), 440, 1.0 / 60.0);
+ t.feed(pitchOf(110), 440, 1.0 / 60.0);
+ try std.testing.expectEqual(@as(i32, 45), t.reading.?.note);
+}
+
+test "a new note shows at once, a quarter tone does not flicker" {
+ var t: Tracker = .{};
+ for (0..10) |_| t.feed(pitchOf(110), 440, 1.0 / 60.0);
+ 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);
+ try std.testing.expectEqual(@as(i32, 50), t.reading.?.note);
+}
+
+test "silence holds the note a while, then lets go" {
+ var t: Tracker = .{};
+ for (0..10) |_| t.feed(pitchOf(330), 440, 1.0 / 60.0);
+ const quiet: layouts.Pitch = .{ .freq = 0, .clarity = 0, .level = -120, .period = 0 };
+ for (0..30) |_| t.feed(quiet, 440, 1.0 / 60.0);
+ try std.testing.expect(t.reading != null);
+ for (0..60) |_| t.feed(quiet, 440, 1.0 / 60.0);
+ try std.testing.expect(t.reading == null);
+}