diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-17 00:15:15 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-17 12:15:01 -0300 |
| commit | 9bd77e54943d954291b5faef287ccca5dcebd7a4 (patch) | |
| tree | 3f2d628781441568620b8108fab920713f26f649 /examples/micscope/src/main.zig | |
| parent | e997fc3e6b312b30f5af90012fc22365bab701d4 (diff) | |
| download | sketchbook-9bd77e54943d954291b5faef287ccca5dcebd7a4.tar.gz sketchbook-9bd77e54943d954291b5faef287ccca5dcebd7a4.zip | |
examples: micscope and spheres come home, as they were, building
Both lived outside any repository, beside sketchbook, with manifests that
pointed at ../01-drat-meout/lib/sketchbook, which no longer exists. They
are copied into examples/micscope and examples/spheres (their sources,
shaders, tests, test material and web icons; not their caches, builds,
packages, state files or .gitignore, which the root's covers), their
manifests depend on "../.." as the other examples do, and their
READMEs link sketchbook there. Nothing else changed: both build against
today's library and pass their own zig build test (micscope 62/62 steps,
11/11 tests, its transport, record, render and tuner scripts; spheres
75/75 steps, 3/3 tests, its play script). The originals are untouched.
micscope's test/reference.flac (3.7 MiB, CC BY-SA 3.0, credited in its
test/README.md) is the rendering reference its render script opens. The
README lists both examples.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'examples/micscope/src/main.zig')
| -rw-r--r-- | examples/micscope/src/main.zig | 1498 |
1 files changed, 1498 insertions, 0 deletions
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(¶ms)); + 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); +} |
