@hraness/dawg 0.6.0 → 0.7.0

package/src/audio/keys/piano.ts

@@ -156,6 +156,17 @@ export type PianoNoteOn = Readonly<{
   trackSeed: number;
   /** Track seed plus note id (this strike's own randomness). */
   noteSeed: string;
+  /**
+   * Una corda (0.6.1) at the onset, 0..1 (half pedal 0.5); absent is 0.
+   * The hammer shifts: fewer strings struck, a softer felt spot, more of
+   * the unstruck string's aftersound.
+   */
+  soft?: number;
+  /**
+   * Song calibration (q08); 1+ keeps the hammer contact shorter than the
+   * fundamental's period and levels on what the hammer excites.
+   */
+  calibration?: number;
 }>;
 
 type Rattle = {
@@ -207,18 +218,52 @@ export class PianoVoice {
       p.decay *
       (1 - 0.15 * p.felt) *
       (prepKind === 1 ? 0.12 : prepKind >= 0 ? 0.5 : 1);
-    const after = clamp(p.after, 0, 0.95);
+    const soft = clamp(note.soft ?? 0, 0, 1);
+    let after = clamp(p.after, 0, 0.95);
     const thMs =
       lerp(3.5, 0.8, keyPos) *
       lerp(1.6, 0.7, v) *
       (1 + 1.5 * p.felt) *
       (1.3 - 0.6 * p.hardness);
+    // Una corda (keys.md 2.1): the shifted hammer meets the strings with
+    // its softer felt. Modelled spectrally, so the pulse length stays and
+    // its nulls never land on a low partial: mode input gains get a smooth
+    // two-pole low-pass relative to partial 1 (cutoff at a tenth of the
+    // spec's hammer cutoff, lowered 25% at full pedal), floored at -12 dB
+    // so no low harmonic is notched out; more of the slow aftersound is
+    // excited. Measured at keys 48-84, velocity 0.5-0.9: centroid -12 to
+    // -20% through key 72 (-5% at 84), peak -2.3 to -4.8 dB, no partial of
+    // the first eight more than 9 dB down (src/audio/keys/pedals.test.ts).
+    const softFc =
+      35 *
+      2 ** (5 * v * (0.4 + 0.6 * p.hardness) + 1.5 * keyPos) *
+      0.75 ** soft;
+    const softFloor = 1 - 0.75 * soft;
+    const softW = (hz: number) =>
+      soft > 0
+        ? Math.max(
+            softFloor,
+            ((1 + (f1 / softFc) ** 2) / (1 + (hz / softFc) ** 2)) ** soft,
+          )
+        : 1;
+    if (soft > 0) after = clamp(after + (1 - after) * 0.4 * soft, 0, 0.95);
+    const calibrated = (note.calibration ?? 0) >= 1;
+    // Calibration 1: a contact longer than about 0.6 of the fundamental's
+    // period puts the pulse's first spectral null under partial 1, and
+    // the upper keys came out as hammer noise (40 dB down at C7).
+    const contactMs = calibrated ? Math.min(thMs, 600 / f1) : thMs;
     this.pulse = hammerPulse(
-      Math.max(2, Math.round(thMs * 1e-3 * sr)),
+      Math.max(2, Math.round(contactMs * 1e-3 * sr)),
       1 + 2 * v * p.hardness,
     );
     const strings = stringsFor(key);
-    const spread = strings === 1 ? 0.08 : p.unison;
+    // Una corda strikes one string fewer: the unison spread narrows.
+    const spread =
+      strings === 1
+        ? 0.08
+        : soft > 0
+          ? p.unison * (1 - (soft * 1) / strings)
+          : p.unison;
     const maxHz = MODE_CEILING * sr;
     let partials = 0;
     while (partials < 160) {
@@ -234,6 +279,8 @@ export class PianoVoice {
     const shift = prepKind === 0 || prepKind === 2 ? 0.04 + 0.1 * prep() : 0;
     const candidates: { hz: number; t60: number; u: number }[] = [];
     let energy = 0;
+    let sum0 = 0;
+    let sumW = 0;
     for (let n = 1; n <= partials; n += 1) {
       let fn = n * f0 * Math.sqrt(1 + B * n * n);
       if (shift && n > 1) fn *= 1 - shift * Math.sin(n * Math.PI * xb) ** 2;
@@ -241,8 +288,11 @@ export class PianoVoice {
       if (Math.abs(shape) < 1e-3) continue;
       const tn = 1 / (1 / T1 + (fn / 3000) ** 2 / (1.2 * p.decay));
       const damped = prepKind === 1 && n > 3 ? 0.3 : 1;
-      const u = shape * damped;
-      energy += u * u;
+      const u0 = shape * damped;
+      energy += u0 * u0;
+      const u = u0 * softW(fn);
+      sum0 += Math.abs(u0);
+      sumW += Math.abs(u);
       if (n <= 12) {
         // Prompt sound at the centre, aftersound split into a symmetric pair.
         const d = (spread / 2) * (1 + 0.3 * (random() - 0.5));
@@ -266,11 +316,25 @@ export class PianoVoice {
           t60: 0.6 + 1.2 * prep(),
           u: 0.35,
         });
-    const loud = v ** 1.4 * (1 - 0.4 * p.felt);
-    const G = (0.35 * loud) / Math.sqrt(Math.max(energy, 1e-9));
+    let loud = v ** 1.4 * (1 - 0.4 * p.felt);
+    // Una corda's level is 30% down: half the low-pass loss (in summed mode
+    // amplitude) is made up so the extra loss stays about 1 dB.
+    if (soft > 0)
+      loud *= (1 - 0.3 * soft) * Math.sqrt(sum0 / Math.max(sumW, 1e-9));
     const mags = candidates.map(
       (c) => pulseMag(this.pulse, (TAU * c.hz) / sr) * Math.abs(c.u),
     );
+    // Calibration 1 levels on the partials the hammer actually excites
+    // (as the electric keys do), so the hammer filter no longer sets the
+    // level; legacy levels on the unfiltered strike.
+    const heard = calibrated
+      ? mags.reduce((sum, m) => sum + m * m, 0) /
+        Math.max(
+          1e-12,
+          candidates.reduce((sum, c) => sum + c.u * c.u, 0),
+        )
+      : 1;
+    const G = (0.35 * loud) / Math.sqrt(Math.max(energy * heard, 1e-9));
     const peak = Math.max(0, ...mags);
     candidates.forEach((c, i) => {
       // Below -80 dB after the hammer filter: not worth a mode.
@@ -295,7 +359,7 @@ export class PianoVoice {
           2800,
           1.5,
           0.002,
-          0.02 * v * v * p.hardness * (1 - p.felt),
+          0.02 * v * v * p.hardness * (1 - p.felt) * (1 - 0.3 * soft),
           sr,
         ),
       );

package/src/audio/keys/sympathetic.ts

@@ -0,0 +1,127 @@
+/**
+ * Sympathetic resonance for the modelled pianos (0.6.1, keys-electric
+ * lane): a per-track bank of 36 tuned feedback combs (C2..B4), fed by the
+ * dry sum, ringing with T60 4 s while the sustain pedal is down (all
+ * dampers up) and 0.06 s when it is up. Ported from the design prototype
+ * (proto/keys/keys.ts `Sympathetic`).
+ *
+ * Gating (zero cost otherwise): it runs only on a piano track with `sym`
+ * above 0 and at least one sustain pedal `down` or `half` event; between
+ * pedal-down spans it stops processing once its energy is below -90 dB.
+ * At 44.1 kHz and above it runs at half rate (pairs averaged in, output
+ * linearly interpolated), which keeps 48 kHz near the 22.05 kHz cost; the
+ * combs top out at B4 (494 Hz), far below the halved Nyquist.
+ */
+
+import { hermite4 } from "../dsp/interp.ts";
+
+const TAU = 2 * Math.PI;
+const LOW = 36;
+const HIGH = 71;
+/** Energy below which the bank goes quiet while the pedal is up. */
+const QUIET = 1e-9;
+
+export class Sympathetic {
+  private readonly lines: Float64Array[] = [];
+  private readonly delay: number[] = [];
+  private readonly lp: number[] = [];
+  private readonly ws: number[] = [];
+  private readonly gUp: number[] = [];
+  private readonly gDown: number[] = [];
+  private readonly a: number;
+  /** Internal decimation: 1 at 22.05 kHz, 2 at 44.1/48 kHz. */
+  readonly factor: number;
+
+  constructor(
+    hzOf: (pitch: number) => number,
+    readonly amount: number,
+    sr: number,
+  ) {
+    this.factor = sr >= 40_000 ? 2 : 1;
+    const rate = sr / this.factor;
+    this.a = Math.exp((-TAU * 4000) / rate);
+    const lpDelay = this.a / (1 - this.a);
+    for (let q = LOW; q <= HIGH; q += 1) {
+      const hz = hzOf(q);
+      // An unmapped tuning degree has no string to ring.
+      if (!(hz > 0) || !Number.isFinite(hz)) continue;
+      const d = Math.max(2, rate / hz - lpDelay);
+      this.lines.push(new Float64Array(Math.ceil(d) + 8));
+      this.delay.push(d);
+      this.lp.push(0);
+      this.ws.push(0);
+      this.gDown.push(10 ** ((-3 * d) / (rate * 4)));
+      this.gUp.push(10 ** ((-3 * d) / (rate * 0.06)));
+    }
+  }
+
+  /** One internal-rate step: input `x`, returns [left, right] resonance. */
+  private step(x: number, pedal: boolean, out: [number, number]): void {
+    let yl = 0;
+    let yr = 0;
+    const a = this.a;
+    for (let k = 0; k < this.lines.length; k += 1) {
+      const line = this.lines[k]!;
+      const size = line.length;
+      const w = this.ws[k]!;
+      const pos = w - this.delay[k]!;
+      const i = Math.floor(pos);
+      const at = (j: number) => line[((j % size) + size) % size]!;
+      const y = hermite4(at(i - 1), at(i), at(i + 1), at(i + 2), pos - i);
+      const f = (this.lp[k] = y + a * (this.lp[k]! - y));
+      line[w % size] = x + (pedal ? this.gDown[k]! : this.gUp[k]!) * f;
+      this.ws[k] = (w + 1) % size;
+      if (k & 1) yr += f;
+      else yl += f;
+    }
+    out[0] = yl * 0.5;
+    out[1] = yr * 0.5;
+  }
+
+  /**
+   * In place: adds resonance to `left`/`right`. `down(i)` says whether the
+   * sustain pedal is down at sample `i` (read per sample pair at most).
+   */
+  process(
+    left: Float64Array,
+    right: Float64Array,
+    down: (sample: number) => boolean,
+  ): void {
+    const c = 0.02 * this.amount;
+    const out: [number, number] = [0, 0];
+    const f = this.factor;
+    let prevL = 0;
+    let prevR = 0;
+    let energy = 0;
+    for (let i = 0; i < left.length; i += f) {
+      const pedal = down(i);
+      let x = 0;
+      for (let j = 0; j < f && i + j < left.length; j += 1)
+        x += left[i + j]! + right[i + j]!;
+      x = (x / (2 * f)) * c;
+      // Dampers down and the combs quiet: skip them entirely.
+      if (!pedal && energy < QUIET) {
+        prevL = 0;
+        prevR = 0;
+        continue;
+      }
+      this.step(x, pedal, out);
+      energy = 0.999 * energy + 0.001 * (out[0] * out[0] + out[1] * out[1]);
+      if (f === 1) {
+        left[i]! += out[0];
+        right[i]! += out[1];
+      } else {
+        // Linear interpolation back to the full rate (one sample latency
+        // at half rate, inaudible on a 4 s resonance).
+        left[i]! += 0.5 * (prevL + out[0]);
+        right[i]! += 0.5 * (prevR + out[1]);
+        if (i + 1 < left.length) {
+          left[i + 1]! += out[0];
+          right[i + 1]! += out[1];
+        }
+      }
+      prevL = out[0];
+      prevR = out[1];
+    }
+  }
+}

package/src/audio/kits.ts

@@ -7,7 +7,7 @@
  * 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 { type DrumVoice, isDrumInstrument } from "../../core/drums.ts";
 import {
   SYNTH_KITS,
   type DrumBodyParams,
@@ -48,9 +48,10 @@ function body(
   noise: number,
   state: KitVoiceState,
   sampleRate: number,
+  ratio = 1,
 ): number {
   const frequency =
-    params.base + params.sweep * Math.exp(-t * params.sweepRate);
+    (params.base + params.sweep * Math.exp(-t * params.sweepRate)) * ratio;
   state.phase += frequency / sampleRate;
   return (
     Math.sin(2 * Math.PI * state.phase) *
@@ -60,19 +61,52 @@ function body(
   );
 }
 
+/** PolyBLEP residual for a unit step at phase 0 (Välimäki). */
+function polyBlep(phase: number, step: number): number {
+  if (phase < step) {
+    const x = phase / step;
+    return x + x - x * x - 1;
+  }
+  if (phase > 1 - step) {
+    const x = (phase - 1) / step;
+    return x * x + x + x + 1;
+  }
+  return 0;
+}
+
+/** A band-limited square at `hz`, `t` seconds in (closed-form phase). */
+export function blepSquare(hz: number, t: number, sampleRate: number): number {
+  const phase = (t * hz) % 1;
+  const step = Math.min(0.5, hz / sampleRate);
+  return (
+    (phase < 0.5 ? 1 : -1) +
+    polyBlep(phase, step) -
+    polyBlep((phase + 0.5) % 1, step)
+  );
+}
+
 function hat(
   params: HatParams,
   t: number,
   noise: number,
   bright: number,
   state: KitVoiceState,
+  sampleRate = 0,
 ): 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;
+    // Calibrated (sampleRate > 0): band-limited squares, so the metal
+    // does not alias and sounds the same at every rate.
+    for (const hz of METAL_HZ)
+      square +=
+        sampleRate > 0
+          ? blepSquare(hz, t, sampleRate)
+          : (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;
@@ -90,10 +124,21 @@ export function kitDrumSample(
   bright: number,
   state: KitVoiceState,
   sampleRate: number,
+  /** Calibration 1+ (0.7): pitch ratio for toms, band-limited metal. */
+  calibrated?: Readonly<{ tomRatio: number }>,
 ): number {
   let sample: number;
+  const metalRate = calibrated ? sampleRate : 0;
   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 === "tom")
+    sample = body(
+      kit.tom,
+      t,
+      noise,
+      state,
+      sampleRate,
+      calibrated?.tomRatio ?? 1,
+    );
   else if (voice === "snare") {
     const p = kit.snare;
     state.phase += p.tone / sampleRate;
@@ -112,9 +157,10 @@ export function kitDrumSample(
       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 === "hat")
+    sample = hat(kit.hat, t, noise, bright, state, metalRate);
   else if (voice === "openhat")
-    sample = hat(kit.openhat, t, noise, bright, state);
+    sample = hat(kit.openhat, t, noise, bright, state, metalRate);
   else {
     const p = kit.rim;
     sample =
@@ -142,9 +188,92 @@ export function kitDrumSample(
   return sample * kit.gain;
 }
 
+// ── calibrated GM extras (0.7) ─────────────────────────────────────────
+
+/** GM cymbal and bell numbers that calibration 1+ plays as metal. */
+export type MetalKind = "crash" | "ride" | "cowbell";
+
+const METAL_PITCHES: Readonly<Record<number, MetalKind>> = Object.freeze({
+  49: "crash",
+  52: "crash",
+  55: "crash",
+  57: "crash",
+  51: "ride",
+  53: "ride",
+  59: "ride",
+  56: "cowbell",
+});
+
+/** The metal voice for a GM pitch, or undefined for every other number. */
+export function metalKindForPitch(pitch: number): MetalKind | undefined {
+  return METAL_PITCHES[pitch];
+}
+
+/**
+ * GM tom pitch ratio: 45 (low tom) is the voice's own tuning, and each GM
+ * semitone moves the body by two thirds of a semitone, so 41 (low floor)
+ * through 50 (high tom) spread across about half an octave.
+ */
+export function tomRatio(pitch: number): number {
+  const clamped = Math.max(35, Math.min(55, pitch));
+  return 2 ** (((clamped - 45) * 2) / 3 / 12);
+}
+
+/**
+ * One sample of a crash, ride or cowbell, `t` seconds after the hit.
+ * Crash and ride are band-limited inharmonic squares through a first
+ * difference plus bright noise; the cowbell is the classic 540/800 Hz
+ * square pair. Deterministic: closed-form phase and the caller's noise.
+ */
+export function metalSample(
+  kind: MetalKind,
+  t: number,
+  bright: number,
+  state: KitVoiceState,
+  sampleRate: number,
+): number {
+  if (kind === "cowbell") {
+    const tone =
+      (blepSquare(540, t, sampleRate) + blepSquare(800, t, sampleRate)) / 2;
+    state.band += 0.45 * (tone - state.band);
+    const envelope = 0.7 * Math.exp(-t * 60) + 0.3 * Math.exp(-t * 9);
+    return state.band * 0.5 * envelope;
+  }
+  let square = 0;
+  for (const hz of METAL_HZ) square += blepSquare(hz * 1.9, t, sampleRate);
+  const metal = (square / METAL_HZ.length - state.metalPrevious) * 1.6;
+  state.metalPrevious = square / METAL_HZ.length;
+  if (kind === "crash") {
+    const swell = Math.min(1, t / 0.004);
+    return (0.55 * bright + 0.45 * metal) * 0.42 * swell * Math.exp(-t * 4.2);
+  }
+  // Ride: a pinged bell over a long, quieter wash.
+  const ping = (0.6 * metal + 0.4 * bright) * 0.3 * Math.exp(-t * 28);
+  const wash = (0.35 * metal + 0.65 * bright) * 0.16 * Math.exp(-t * 3.5);
+  return ping + wash;
+}
+
+/** Length of a calibrated crash, ride or cowbell one-shot. */
+export const METAL_SECONDS = 1.4;
+
 /** 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;
+  if ((score.calibration ?? 0) >= 1) {
+    const drums = new Set(
+      score.tracks
+        .filter((track) => isDrumInstrument(track.instrument))
+        .map((track) => track.id),
+    );
+    if (
+      score.notes.some(
+        (note) =>
+          drums.has(note.trackId) &&
+          metalKindForPitch(note.pitch) !== undefined,
+      )
+    )
+      seconds = METAL_SECONDS;
+  }
   for (const track of score.tracks)
     seconds = Math.max(seconds, synthKit(track.kit)?.seconds ?? 0);
   return seconds;

package/src/audio/live-worker.ts

@@ -18,6 +18,7 @@ export type LiveFullRequest = Readonly<{
   velocity: number;
   seconds: number;
   tick?: number;
+  clock?: number;
   samples?: SampleBank;
 }>;
 
@@ -32,7 +33,7 @@ declare const self: Worker;
 let synth: LiveSynth | undefined;
 
 self.onmessage = (event: MessageEvent<LiveFullRequest>) => {
-  const { id, sampleRate, score, samples, tick, ...note } = event.data;
+  const { id, sampleRate, score, samples, tick, clock, ...note } = event.data;
   try {
     if (synth?.rate !== sampleRate) synth = new LiveSynth(sampleRate);
     const pcm = synth.render({
@@ -41,6 +42,7 @@ self.onmessage = (event: MessageEvent<LiveFullRequest>) => {
       full: true,
       ...(samples ? { samples } : {}),
       ...(tick === undefined ? {} : { tick }),
+      ...(clock === undefined ? {} : { clock }),
     });
     const reply: LiveFullReply = pcm ? { id, pcm } : { id };
     self.postMessage(reply);