@hraness/dawg 0.3.0 → 0.4.0

package/src/audio/effects/space.ts

@@ -0,0 +1,337 @@
+/**
+ * Send effects on the stereo pair: delay and reverb. Without their
+ * optional parameters both render exactly as the original renderer did.
+ */
+import type { Track } from "../../../core/score.ts";
+import type { DecodedSample } from "../samples.ts";
+import {
+  builtinImpulse,
+  convolveStereo,
+  sampleImpulse,
+  type Impulse,
+} from "./convolution.ts";
+import {
+  CONTROL_SAMPLES,
+  OnePole,
+  Param,
+  interpolateAutomation,
+  type EffectContext,
+} from "./common.ts";
+
+/** Delay length in seconds: `time` when set, otherwise `beats` at the tempo. */
+export function delaySeconds(track: Track, tempoBpm: number): number {
+  const delay = track.delay;
+  if (!delay) return 0;
+  return delay.time !== undefined && delay.time > 0
+    ? delay.time
+    : (delay.beats * 60) / tempoBpm;
+}
+
+/**
+ * Stereo feedback delay. Absent `pingpong`, each side echoes its own input
+ * and feeds back into the opposite side (the original sound). With
+ * `pingpong`, the mono sum enters the left line only and every repeat
+ * crosses over, so echoes alternate left, right, left. `highcut` runs a
+ * one-pole low-pass on everything written into the lines, so each repeat
+ * is darker than the last. Feedback and mix follow their lanes. `wetOnly`
+ * (a shared orbit bus) replaces the input with the repeats alone.
+ */
+export function applyDelay(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+  wetOnly = false,
+): void {
+  const delay = track.delay;
+  if (!delay) return;
+  const feedbackLane = track.delayFeedbackAutomation ?? [];
+  const mixLane = track.delayMixAutomation ?? [];
+  if (delay.mix <= 0 && mixLane.length === 0) return;
+  const { sampleRate, samplesPerTick } = context;
+  const length = Math.max(
+    1,
+    Math.round(delaySeconds(track, context.tempoBpm) * sampleRate),
+  );
+  const lineL = new Float64Array(length);
+  const lineR = new Float64Array(length);
+  let feedback = delay.feedback;
+  let mix = delay.mix;
+  const automated = feedbackLane.length > 0 || mixLane.length > 0;
+  const pingpong = delay.pingpong === true;
+  const highcut =
+    delay.highcut === undefined
+      ? undefined
+      : [
+          new OnePole(delay.highcut, sampleRate),
+          new OnePole(delay.highcut, sampleRate),
+        ];
+  for (let index = 0; index < left.length; index += 1) {
+    if (automated && index % CONTROL_SAMPLES === 0) {
+      const tick = index / samplesPerTick;
+      feedback = interpolateAutomation(feedbackLane, tick, delay.feedback);
+      mix = interpolateAutomation(mixLane, tick, delay.mix);
+    }
+    const slot = index % length;
+    const wetL = lineL[slot]!;
+    const wetR = lineR[slot]!;
+    const dryL = left[index]!;
+    const dryR = right[index]!;
+    let writeL: number;
+    let writeR: number;
+    if (pingpong) {
+      writeL = (dryL + dryR) * 0.5 + wetR * feedback;
+      writeR = wetL * feedback;
+    } else {
+      writeL = dryL + wetR * feedback;
+      writeR = dryR + wetL * feedback;
+    }
+    if (highcut) {
+      writeL = highcut[0]!.process(writeL);
+      writeR = highcut[1]!.process(writeR);
+    }
+    lineL[slot] = writeL;
+    lineR[slot] = writeR;
+    left[index] = (wetOnly ? 0 : dryL) + wetL * mix;
+    right[index] = (wetOnly ? 0 : dryR) + wetR * mix;
+  }
+}
+
+/** Seconds until the track's delay decays below -60 dB, bounded. */
+export function delayTailFor(track: Track, tempoBpm: number): number {
+  if (!track.delay) return 0;
+  const feedback = Math.max(
+    track.delay.feedback,
+    ...(track.delayFeedbackAutomation ?? []).map((point) => point.value),
+  );
+  const repeats =
+    feedback <= 0.001 ? 1 : Math.min(64, Math.log(0.001) / Math.log(feedback));
+  return delaySeconds(track, tempoBpm) * (repeats + 1);
+}
+
+/** Freeverb comb and allpass tunings at 44.1 kHz; the right side is spread. */
+const COMB_TUNING = [1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617] as const;
+const ALLPASS_TUNING = [556, 441, 341, 225] as const;
+const STEREO_SPREAD = 23;
+const REVERB_INPUT_GAIN = 0.015;
+const REVERB_WET_SCALE = 3;
+
+/**
+ * Convolution wet level: an energy-normalized impulse on the summed pair,
+ * scaled so `mix` sounds as loud as the algorithmic tail at the same mix.
+ */
+const IR_WET_SCALE = 2.1;
+
+/** Impulses decoded from samples, by sha256 and rate (small: a few IRs). */
+const SAMPLE_IMPULSES = new Map<string, Impulse>();
+const MAX_SAMPLE_IMPULSES = 8;
+
+/**
+ * The impulse a track's `reverb.ir` names at this rate: a generated
+ * built-in, or the decoded sample in `irs`. Undefined when the track has no
+ * `ir` or its sample did not load (the algorithmic reverb then plays).
+ */
+export function reverbImpulse(
+  track: Track,
+  sampleRate: number,
+  irs?: ReadonlyMap<string, DecodedSample>,
+): Impulse | undefined {
+  const ir = track.reverb?.ir;
+  if (!ir) return undefined;
+  if (ir.src.startsWith("builtin:"))
+    return builtinImpulse(ir.src.slice("builtin:".length), sampleRate);
+  const sample = irs?.get(track.id);
+  if (!sample) return undefined;
+  const key = `${sample.sha256}@${sampleRate}`;
+  let impulse = SAMPLE_IMPULSES.get(key);
+  if (!impulse) {
+    impulse = sampleImpulse(
+      `${ir.src}#${sample.sha256}`,
+      sample.mono,
+      sample.sampleRate,
+      sampleRate,
+    );
+    if (SAMPLE_IMPULSES.size >= MAX_SAMPLE_IMPULSES)
+      SAMPLE_IMPULSES.delete(SAMPLE_IMPULSES.keys().next().value!);
+    SAMPLE_IMPULSES.set(key, impulse);
+  }
+  return impulse;
+}
+
+/** Seconds of reverb tail a render keeps for this track. */
+export function reverbTailFor(
+  track: Track,
+  sampleRate = 44_100,
+  irs?: ReadonlyMap<string, DecodedSample>,
+): number {
+  const reverb = track.reverb;
+  const lane = track.fxAutomation?.["reverb-mix"] ?? [];
+  if (!reverb || (reverb.mix <= 0 && lane.length === 0)) return 0;
+  const impulse = reverbImpulse(track, sampleRate, irs);
+  const decay = impulse
+    ? impulse.left.length / sampleRate
+    : (reverb.fade ?? 1 + 3 * reverb.size);
+  return Math.min(20, decay + (reverb.predelay ?? 0));
+}
+
+/**
+ * Schroeder–Moorer reverb in the Freeverb arrangement: eight damped
+ * feedback combs then four allpasses per side, the right side detuned.
+ * `size` sets comb feedback and damping; `fade` instead sets each comb's
+ * feedback for an exact -60 dB decay time; `dim` sets the in-loop damping
+ * frequency, `lowpass` filters the input and `predelay` delays it.
+ * `wetOnly` (a shared orbit bus) replaces the input with the tail alone.
+ */
+export function applyReverb(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+  wetOnly = false,
+): void {
+  const reverb = track.reverb;
+  if (!reverb) return;
+  const mixParam = new Param(
+    reverb.mix,
+    track.fxAutomation?.["reverb-mix"],
+    context.samplesPerTick,
+  );
+  if (reverb.mix <= 0 && !mixParam.automated) return;
+  const { sampleRate } = context;
+  const impulse = reverbImpulse(track, sampleRate, context.irs);
+  if (impulse) {
+    applyConvolutionReverb(
+      left,
+      right,
+      track,
+      context,
+      impulse,
+      mixParam,
+      wetOnly,
+    );
+    return;
+  }
+  const scale = sampleRate / 44_100;
+  const sizeFeedback = 0.7 + 0.28 * reverb.size;
+  const damp =
+    reverb.dim === undefined
+      ? 0.2 + 0.3 * reverb.size
+      : Math.exp(
+          (-2 * Math.PI * Math.min(reverb.dim, sampleRate * 0.45)) / sampleRate,
+        );
+  let wet = reverb.mix * REVERB_WET_SCALE;
+  const channel = (spread: number) => ({
+    combs: COMB_TUNING.map((tuning) => {
+      const length = Math.max(1, Math.round((tuning + spread) * scale));
+      return {
+        buffer: new Float64Array(length),
+        index: 0,
+        store: 0,
+        feedback:
+          reverb.fade === undefined
+            ? sizeFeedback
+            : Math.min(0.995, 10 ** ((-3 * length) / sampleRate / reverb.fade)),
+      };
+    }),
+    allpasses: ALLPASS_TUNING.map((tuning) => ({
+      buffer: new Float64Array(
+        Math.max(1, Math.round((tuning + spread) * scale)),
+      ),
+      index: 0,
+    })),
+  });
+  const sides = [channel(0), channel(STEREO_SPREAD)] as const;
+  const process = (side: (typeof sides)[number], input: number): number => {
+    let output = 0;
+    for (const comb of side.combs) {
+      const delayed = comb.buffer[comb.index]!;
+      comb.store = delayed * (1 - damp) + comb.store * damp;
+      comb.buffer[comb.index] = input + comb.store * comb.feedback;
+      comb.index = comb.index + 1 === comb.buffer.length ? 0 : comb.index + 1;
+      output += delayed;
+    }
+    for (const allpass of side.allpasses) {
+      const delayed = allpass.buffer[allpass.index]!;
+      allpass.buffer[allpass.index] = output + delayed * 0.5;
+      output = delayed - output;
+      allpass.index =
+        allpass.index + 1 === allpass.buffer.length ? 0 : allpass.index + 1;
+    }
+    return output;
+  };
+  const inputFilter =
+    reverb.lowpass === undefined
+      ? undefined
+      : new OnePole(reverb.lowpass, sampleRate);
+  const predelaySamples = Math.round((reverb.predelay ?? 0) * sampleRate);
+  const predelay =
+    predelaySamples > 0 ? new Float64Array(predelaySamples) : undefined;
+  for (let index = 0; index < left.length; index += 1) {
+    if (mixParam.automated && index % CONTROL_SAMPLES === 0)
+      wet = mixParam.at(index) * REVERB_WET_SCALE;
+    let input = (left[index]! + right[index]!) * REVERB_INPUT_GAIN;
+    if (inputFilter) input = inputFilter.process(input);
+    if (predelay) {
+      const slot = index % predelaySamples;
+      const delayed = predelay[slot]!;
+      predelay[slot] = input;
+      input = delayed;
+    }
+    if (wetOnly) {
+      left[index] = process(sides[0], input) * wet;
+      right[index] = process(sides[1], input) * wet;
+    } else {
+      left[index]! += process(sides[0], input) * wet;
+      right[index]! += process(sides[1], input) * wet;
+    }
+  }
+}
+
+/**
+ * `reverb.ir`: the summed pair (through `lowpass` and `predelay`, as the
+ * algorithmic reverb) convolved with the impulse and added at `mix`.
+ * `size`, `fade` and `dim` describe the algorithmic tail and do nothing
+ * here: the impulse is the room.
+ */
+function applyConvolutionReverb(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+  impulse: Impulse,
+  mixParam: Param,
+  wetOnly: boolean,
+): void {
+  const reverb = track.reverb!;
+  const { sampleRate } = context;
+  const input = new Float64Array(left.length);
+  const inputFilter =
+    reverb.lowpass === undefined
+      ? undefined
+      : new OnePole(reverb.lowpass, sampleRate);
+  const offset = Math.round((reverb.predelay ?? 0) * sampleRate);
+  for (let index = 0; index + offset < left.length; index += 1) {
+    let value = (left[index]! + right[index]!) * 0.5;
+    if (inputFilter) value = inputFilter.process(value);
+    input[index + offset] = value;
+  }
+  if (wetOnly) {
+    left.fill(0);
+    right.fill(0);
+  }
+  let wet = reverb.mix * IR_WET_SCALE;
+  convolveStereo(
+    input,
+    impulse,
+    left,
+    right,
+    wet,
+    mixParam.automated
+      ? (index) => {
+          if (index % CONTROL_SAMPLES === 0)
+            wet = mixParam.at(index) * IR_WET_SCALE;
+          return wet;
+        }
+      : undefined,
+  );
+}

package/src/audio/engine.ts

@@ -4,6 +4,7 @@ import { LoopPlayer } from "./player.ts";
 import { LoopRenderer, type LoopRender } from "./renderer.ts";
 import { clickSounds, clicksIn, type ClickLevel } from "./click.ts";
 import type { LiveNotePcm } from "./live.ts";
+import { levelOf, type SoundLevel } from "./preview.ts";
 import { DEFAULT_SAMPLE_RATE, RENDER_CHANNELS } from "./wav.ts";
 
 /**
@@ -304,10 +305,15 @@ export class AudioEngine {
   private queued: PlayRequest | undefined;
   private draining = false;
   private lastRenderMs = 0;
+  /** The loop last swapped in, for `level` (measured on demand, once). */
+  private lastLoopPcm: Int16Array | undefined;
+  private measured: { pcm: Int16Array; level: SoundLevel } | undefined;
   private respawns = 0;
   private respawnTimer: ReturnType<typeof setTimeout> | undefined;
   /** Play mode: keep a player running without a loop for live voices. */
   private monitoring = false;
+  /** A lead set by `setLeadMs` (play mode, auditions) is not adapted. */
+  private leadPinned = false;
   private readonly voices = new Map<number, LiveVoice>();
   private click: ClickBus | undefined;
   private clickVoices: { sound: Float32Array; position: number }[] = [];
@@ -359,6 +365,7 @@ export class AudioEngine {
    * after it is pressed); `undefined` restores the constructed lead.
    */
   public setLeadMs(ms: number | undefined): void {
+    this.leadPinned = ms !== undefined;
     this.leadFrames =
       ms === undefined
         ? this.defaultLeadFrames
@@ -371,6 +378,19 @@ export class AudioEngine {
   }
 
   /** Whether live voices and the click can sound (a streaming backend). */
+  /**
+   * RMS, peak and clips of the loop now playing (the audition meter);
+   * measured once per render, on first read. Undefined before any render
+   * or with no audio device.
+   */
+  public get level(): SoundLevel | undefined {
+    const pcm = this.lastLoopPcm;
+    if (!pcm) return undefined;
+    if (this.measured?.pcm !== pcm)
+      this.measured = { pcm, level: levelOf(pcm) };
+    return this.measured.level;
+  }
+
   public get canMonitor(): boolean {
     return this.info.backend !== "none" && !this.fallback;
   }
@@ -451,10 +471,10 @@ export class AudioEngine {
 
   /** Frames kept queued ahead of the clock right now. */
   public get lead(): number {
-    // Play mode keeps its short lead: renders run off-thread, so a slow
-    // render delays the swap, not the stream.
+    // Play mode and auditions keep their short lead: renders run
+    // off-thread, so a slow render delays the swap, not the stream.
     const adaptive =
-      this.monitoring && this.renderer.offThread
+      (this.monitoring || this.leadPinned) && this.renderer.offThread
         ? 0
         : Math.round(
             (LEAD_RENDER_FACTOR * this.lastRenderMs * this.sampleRate) / 1000,
@@ -499,8 +519,10 @@ export class AudioEngine {
           const render = await this.renderer.render(request.score);
           this.lastRenderMs = render.renderMs;
           // Stopped while rendering: the result is stale, not an error.
-          if (request.generation === this.generation)
+          if (request.generation === this.generation) {
             await this.apply(this.toLoop(render, request.score), request);
+            this.lastLoopPcm = render.pcm;
+          }
           for (const waiter of request.waiters) waiter.resolve();
         } catch (error) {
           for (const waiter of request.waiters)
@@ -569,6 +591,7 @@ export class AudioEngine {
 
   public async stopAsync(): Promise<void> {
     this.generation += 1;
+    this.lastLoopPcm = undefined;
     this.respawns = 0;
     if (this.respawnTimer) clearTimeout(this.respawnTimer);
     this.respawnTimer = undefined;

package/src/audio/kits.ts

@@ -0,0 +1,200 @@
+/**
+ * Drum kits: the synthesized kits from `core/kits.ts` rendered sample by
+ * sample, and the one catalog `/kit`, `/menu` and the agent list.
+ *
+ * The renderer calls `kitDrumSample` only for a track with `kit` set, so the
+ * default voices in `wav.ts` stay byte-identical. Everything here is plain
+ * arithmetic on the seeded noise `wav.ts` passes in, so a kit renders the
+ * same buffer on every run.
+ */
+import type { DrumVoice } from "../../core/drums.ts";
+import {
+  SYNTH_KITS,
+  type DrumBodyParams,
+  type HatParams,
+  type SynthKit,
+  synthKit,
+} from "../../core/kits.ts";
+import type { TrackScore } from "../../core/score.ts";
+import { DEFAULT_KITS } from "./packs.ts";
+
+/** Per-hit oscillator and filter state. */
+export type KitVoiceState = {
+  phase: number;
+  band: number;
+  dark: number;
+  metalPrevious: number;
+  holdLeft: number;
+  held: number;
+};
+
+export function newKitVoiceState(): KitVoiceState {
+  return {
+    phase: 0,
+    band: 0,
+    dark: 0,
+    metalPrevious: 0,
+    holdLeft: 0,
+    held: 0,
+  };
+}
+
+/** 808 hi-hat oscillator frequencies (six detuned squares). */
+const METAL_HZ = [205.3, 304.4, 369.6, 522.7, 540, 800] as const;
+
+function body(
+  params: DrumBodyParams,
+  t: number,
+  noise: number,
+  state: KitVoiceState,
+  sampleRate: number,
+): number {
+  const frequency =
+    params.base + params.sweep * Math.exp(-t * params.sweepRate);
+  state.phase += frequency / sampleRate;
+  return (
+    Math.sin(2 * Math.PI * state.phase) *
+      Math.exp(-t * params.decay) *
+      params.level +
+    noise * params.click * Math.exp(-t * params.clickDecay)
+  );
+}
+
+function hat(
+  params: HatParams,
+  t: number,
+  noise: number,
+  bright: number,
+  state: KitVoiceState,
+): number {
+  state.dark += 0.3 * (noise - state.dark);
+  const noisy = params.tone * bright + (1 - params.tone) * state.dark * 0.8;
+  let source = noisy;
+  if (params.metal > 0) {
+    let square = 0;
+    for (const hz of METAL_HZ) square += (t * hz) % 1 < 0.5 ? 1 : -1;
+    // First difference: keep the metallic top end, drop the low beating.
+    const metal = (square / METAL_HZ.length - state.metalPrevious) * 1.6;
+    state.metalPrevious = square / METAL_HZ.length;
+    source = params.metal * metal + (1 - params.metal) * noisy;
+  }
+  return source * params.level * Math.exp(-t * params.decay);
+}
+
+/** One sample of `voice` in `kit` at `t` seconds after the hit. */
+export function kitDrumSample(
+  kit: SynthKit,
+  voice: DrumVoice,
+  t: number,
+  noise: number,
+  bright: number,
+  state: KitVoiceState,
+  sampleRate: number,
+): number {
+  let sample: number;
+  if (voice === "kick") sample = body(kit.kick, t, noise, state, sampleRate);
+  else if (voice === "tom") sample = body(kit.tom, t, noise, state, sampleRate);
+  else if (voice === "snare") {
+    const p = kit.snare;
+    state.phase += p.tone / sampleRate;
+    const wires = p.snap * bright + (1 - p.snap) * noise;
+    sample =
+      Math.sin(2 * Math.PI * state.phase) *
+        p.toneLevel *
+        Math.exp(-t * p.toneDecay) +
+      wires * p.noise * Math.exp(-t * p.noiseDecay);
+  } else if (voice === "clap") {
+    const p = kit.clap;
+    state.band += p.band * (bright - state.band);
+    const span = p.gap * 3;
+    const burst = t < span ? (Math.floor(t / p.gap) % 2 === 0 ? 1 : 0.35) : 0;
+    sample =
+      state.band *
+      p.level *
+      (burst + 0.8 * Math.exp(-(t - span) * p.tail) * +(t >= span));
+  } else if (voice === "hat") sample = hat(kit.hat, t, noise, bright, state);
+  else if (voice === "openhat")
+    sample = hat(kit.openhat, t, noise, bright, state);
+  else {
+    const p = kit.rim;
+    sample =
+      (Math.sin(2 * Math.PI * p.high * t) * 0.6 +
+        Math.sin(2 * Math.PI * p.low * t) * 0.4) *
+      Math.exp(-t * p.decay) *
+      p.level;
+  }
+  if (kit.drive > 0) {
+    const amount = 1 + kit.drive * 4;
+    sample = Math.tanh(sample * amount) / Math.tanh(amount);
+  }
+  if (kit.bits > 0) {
+    const steps = 2 ** (kit.bits - 1);
+    sample = Math.round(sample * steps) / steps;
+  }
+  if (kit.hold > 1) {
+    if (state.holdLeft <= 0) {
+      state.held = sample;
+      state.holdLeft = kit.hold;
+    }
+    state.holdLeft -= 1;
+    sample = state.held;
+  }
+  return sample * kit.gain;
+}
+
+/** Longest synth-kit one-shot in the score; 0 without kits (so renders without kits are unchanged). */
+export function kitTailSeconds(score: TrackScore): number {
+  let seconds = 0;
+  for (const track of score.tracks)
+    seconds = Math.max(seconds, synthKit(track.kit)?.seconds ?? 0);
+  return seconds;
+}
+
+// ── catalog ────────────────────────────────────────────────────────────
+
+/**
+ * One entry of the kit catalog. `synth` kits render offline from the
+ * parameters in `core/kits.ts`; `sample` kits are pack banks fetched on
+ * first use (`src/audio/packs.ts`). New kinds (a user's own folder of
+ * samples, more packs) slot in here without touching the pickers.
+ */
+export type KitEntry = Readonly<{
+  name: string;
+  kind: "synth" | "sample";
+  label: string;
+  detail: string;
+  /** The prompt command that puts this kit on the focused track. */
+  command: string;
+}>;
+
+/** The default synth voices, listed first. */
+export const DEFAULT_SYNTH_KIT = "default";
+
+export function kitCatalog(): readonly KitEntry[] {
+  const synth: KitEntry[] = [
+    {
+      name: DEFAULT_SYNTH_KIT,
+      kind: "synth",
+      label: "Default (synth)",
+      detail: "the built-in voices",
+      command: `/kit ${DEFAULT_SYNTH_KIT}`,
+    },
+    ...SYNTH_KITS.map((entry): KitEntry => ({
+      name: entry.name,
+      kind: "synth",
+      label: entry.label,
+      detail: entry.description,
+      command: `/kit ${entry.name}`,
+    })),
+  ];
+  const sample = Object.entries(DEFAULT_KITS).map(
+    ([name, entry]): KitEntry => ({
+      name,
+      kind: "sample",
+      label: `${name}  ${entry.bank || entry.pack}`,
+      detail: `${entry.pack} samples (fetched once)`,
+      command: `/kit ${name}`,
+    }),
+  );
+  return Object.freeze([...synth, ...sample]);
+}