@hraness/dawg 0.5.0 → 0.6.0

package/src/audio/live.ts

@@ -17,11 +17,32 @@ import {
   type Track,
 } from "../../core/score.ts";
 import { bpmAtTick } from "../../core/tempo.ts";
-import { sampleKey, type SampleBank } from "./samples.ts";
+import { EMPTY_SAMPLE_BANK, sampleKey, type SampleBank } from "./samples.ts";
 import { RENDER_CHANNELS, renderScorePcm } from "./wav.ts";
+import { engineFor } from "./instruments.ts";
+import { noteHz, resolveTuning } from "../../core/tuning.ts";
+import { liveFitPending, withLiveFit } from "./fit.ts";
+import type { LiveFullReply, LiveFullRequest } from "./live-worker.ts";
 
 /** A rendered live note: interleaved stereo 16-bit PCM. */
-export type LiveNotePcm = Readonly<{ pcm: Int16Array; frames: number }>;
+export type LiveNotePcm = Readonly<{
+  pcm: Int16Array;
+  frames: number;
+  /** Release fade on note-off, in seconds; absent is the 10 ms default. */
+  releaseSeconds?: number;
+  /**
+   * A fitted sample window (0.6 `bpm`/`len`/`fitmode`) longer than 8 s is
+   * still being computed: the note is silent and not cached; play it again
+   * once its background fit (fit.ts `onFitReady`) lands.
+   */
+  fitting?: true;
+  /**
+   * True when this is only the first window of a guitar-rig note
+   * (`LIVE_RIG_WINDOW_SECONDS`): call `LiveSynth.render` again with
+   * `full: true` off the key path and swap the result in by voice id.
+   */
+  partial?: boolean;
+}>;
 
 export type LiveNoteRequest = Readonly<{
   score: TrackScore;
@@ -35,8 +56,18 @@ export type LiveNoteRequest = Readonly<{
   samples?: SampleBank;
   /** Song tick being played: the tempo there sets length and synced effects. */
   tick?: number;
+  /** Render the whole note even through a guitar rig (the background pass). */
+  full?: boolean;
 }>;
 
+/**
+ * A guitar rig (stomp, head, cab) is oversampled and costs 15-25 ms per
+ * track-second, so a held note through one first renders only this window,
+ * at render quality, and the rest follows in the background. Every rig stage
+ * is causal, so the window is the exact prefix of the full note.
+ */
+export const LIVE_RIG_WINDOW_SECONDS = 0.75;
+
 /** Longest a single live note is rendered for (a held sustain pedal). */
 export const MAX_LIVE_NOTE_SECONDS = 8;
 const CACHE_ENTRIES = 96;
@@ -58,12 +89,24 @@ export class LiveSynth {
     return this.cache.size;
   }
 
-  public render(request: LiveNoteRequest): LiveNotePcm | undefined {
+  /**
+   * Stores a whole rig note rendered elsewhere (the background worker) so the
+   * next press of that key hits the cache and skips the window.
+   */
+  public adopt(request: LiveNoteRequest, pcm: LiveNotePcm): void {
+    const plan = this.plan(request);
+    if (!plan || pcm.partial) return;
+    this.cache.set(plan.key, pcm);
+    this.trim();
+  }
+
+  private plan(request: LiveNoteRequest) {
     const track = request.score.tracks.find(
       (candidate) => candidate.id === request.trackId,
     );
     if (!track) return undefined;
     const { score } = request;
+    const liveEngine = engineFor(track);
     const bpm =
       request.tick === undefined
         ? score.tempoBpm
@@ -88,11 +131,43 @@ export class LiveSynth {
       score.ticksPerBeat,
       this.sampleRate,
       samplerDigest(track, request.samples),
+      // Assets a 0.6 engine reads (a granular sample source).
+      ...engineDigest(track, request.samples),
       // The song tuning and key (the default tuning root) retune live notes.
       ...(score.tuning || track.tuning
         ? [score.tuning ?? null, score.key]
         : []),
+      // A 0.6 engine's assets, and the key it may tune to.
+      ...(liveEngine
+        ? [
+            liveEngine.assetDigests?.(
+              track,
+              request.samples ?? EMPTY_SAMPLE_BANK,
+            ) ?? [],
+            score.key ?? null,
+          ]
+        : []),
     ]);
+    return { track, score, bpm, seconds, durationTicks, velocity, pitch, key };
+  }
+
+  public render(request: LiveNoteRequest): LiveNotePcm | undefined {
+    const plan = this.plan(request);
+    if (!plan) return undefined;
+    const { track, score, bpm, seconds, durationTicks, velocity, pitch, key } =
+      plan;
+    const liveEngine = engineFor(track);
+    // The first window of a rig note: its own cache entry, swapped for the
+    // whole note once the background pass has rendered it.
+    const windowed =
+      request.full !== true &&
+      hasRig(track) &&
+      seconds > LIVE_RIG_WINDOW_SECONDS &&
+      !this.cache.has(key);
+    if (windowed) {
+      const first = this.cache.get(`${key}#window`);
+      if (first) return first;
+    }
     const hit = this.cache.get(key);
     if (hit) {
       // Refresh LRU order.
@@ -112,7 +187,7 @@ export class LiveSynth {
       ticksPerBeat: score.ticksPerBeat,
       // The song tuning, and the key whose tonic is the default root.
       ...(score.tuning ? { tuning: score.tuning } : {}),
-      ...(score.tuning || track.tuning ? { key: score.key } : {}),
+      ...(score.tuning || track.tuning || liveEngine ? { key: score.key } : {}),
       tracks: [liveTrack(track)],
       notes: [
         {
@@ -125,23 +200,64 @@ export class LiveSynth {
         },
       ],
     });
-    const audio = renderScorePcm(single, {
-      sampleRate: this.sampleRate,
-      maxSeconds: MAX_LIVE_NOTE_SECONDS + 4,
-      ...(request.samples ? { samples: request.samples } : {}),
-    });
-    const frames = audibleFrames(audio.pcm);
+    // A 0.6 engine's ring-out sets the one-note length and the key release.
+    const tail = liveEngine
+      ? Math.max(0, liveEngine.tailSeconds(track, pitch))
+      : 0;
+    // Fitted sample windows over 8 s fit in the background (silent until
+    // ready, never at the wrong pitch); shorter ones fit synchronously.
+    const audio = withLiveFit(() =>
+      renderScorePcm(single, {
+        sampleRate: this.sampleRate,
+        // The renderer's shortest one-shot is 1 s; the window is cut below.
+        maxSeconds: windowed
+          ? 1
+          : Math.max(MAX_LIVE_NOTE_SECONDS + 4, seconds + tail),
+        ...(request.samples ? { samples: request.samples } : {}),
+      }),
+    );
+    const frames = windowed
+      ? Math.min(
+          audibleFrames(audio.pcm),
+          Math.round(LIVE_RIG_WINDOW_SECONDS * this.sampleRate),
+        )
+      : audibleFrames(audio.pcm);
+    const release = liveEngine?.releaseSeconds
+      ? liveEngine.releaseSeconds(
+          track,
+          pitch,
+          noteHz(
+            pitch,
+            undefined,
+            resolveTuning(score.tuning, track.tuning, score.key),
+          ),
+        )
+      : tail;
     const rendered: LiveNotePcm = {
       pcm: audio.pcm.subarray(0, frames * RENDER_CHANNELS),
       frames,
+      ...(liveEngine
+        ? {
+            releaseSeconds: Math.min(
+              Math.max(0, release),
+              MAX_LIVE_NOTE_SECONDS,
+            ),
+          }
+        : {}),
+      ...(windowed ? { partial: true } : {}),
     };
-    this.cache.set(key, rendered);
+    if (liveFitPending()) return { ...rendered, fitting: true };
+    this.cache.set(windowed ? `${key}#window` : key, rendered);
+    this.trim();
+    return rendered;
+  }
+
+  private trim(): void {
     while (this.cache.size > CACHE_ENTRIES) {
       const oldest = this.cache.keys().next().value;
       if (oldest === undefined) break;
       this.cache.delete(oldest);
     }
-    return rendered;
   }
 }
 
@@ -163,6 +279,17 @@ function liveTrack(track: Track): Track {
   return { ...rest, muted: false };
 }
 
+/** Whether the track plays through a guitar rig stage. */
+function hasRig(track: Track): boolean {
+  return Boolean(track.fx?.stomp || track.fx?.head || track.fx?.cab);
+}
+
+function engineDigest(track: Track, bank: SampleBank | undefined): string[] {
+  const engine = engineFor(track);
+  if (!engine?.assetDigests || !bank) return [];
+  return [...engine.assetDigests(track, bank)];
+}
+
 function samplerDigest(track: Track, bank: SampleBank | undefined): string[] {
   if (!isSamplerInstrument(track.instrument) || !track.sampler || !bank)
     return [];
@@ -177,3 +304,95 @@ function audibleFrames(pcm: Int16Array): number {
   while (last >= 0 && pcm[last] === 0) last -= 1;
   return Math.ceil((last + 1) / RENDER_CHANNELS);
 }
+
+/**
+ * Renders whole guitar-rig notes on a worker (`live-worker.ts`), in request
+ * order. When a worker cannot start, `full` falls back to rendering on the
+ * calling thread in a later tick, as before.
+ */
+export class LiveFullRenderer {
+  private worker: Bun.Worker | undefined;
+  private broken = false;
+  private nextId = 1;
+  private readonly pending = new Map<
+    number,
+    (pcm: LiveNotePcm | undefined) => void
+  >();
+
+  public full(
+    synth: LiveSynth,
+    request: LiveNoteRequest,
+  ): Promise<LiveNotePcm | undefined> {
+    const worker = this.ensure();
+    if (!worker)
+      return new Promise((resolve) =>
+        setTimeout(() => resolve(synth.render({ ...request, full: true })), 0),
+      );
+    const id = this.nextId;
+    this.nextId += 1;
+    return new Promise((resolve) => {
+      this.pending.set(id, (pcm) => {
+        if (pcm) synth.adopt(request, pcm);
+        resolve(pcm);
+      });
+      const message: LiveFullRequest = {
+        id,
+        sampleRate: synth.rate,
+        score: request.score.toJSON(),
+        trackId: request.trackId,
+        pitch: request.pitch,
+        velocity: request.velocity,
+        seconds: request.seconds,
+        ...(request.tick === undefined ? {} : { tick: request.tick }),
+        ...(request.samples ? { samples: request.samples } : {}),
+      };
+      try {
+        worker.postMessage(message);
+      } catch {
+        this.pending.delete(id);
+        this.fail();
+        setTimeout(() => resolve(synth.render({ ...request, full: true })), 0);
+      }
+    });
+  }
+
+  /** Stops the worker; pending notes resolve without a full pass. */
+  public close(): void {
+    this.fail();
+  }
+
+  private ensure(): Bun.Worker | undefined {
+    if (this.worker) return this.worker;
+    if (this.broken) return undefined;
+    try {
+      // The DOM lib's Worker type lacks Bun's `unref`; the runtime is Bun's.
+      const worker = new Worker(
+        new URL("./live-worker.ts", import.meta.url).href,
+      ) as unknown as Bun.Worker;
+      worker.addEventListener("message", (event: Event) => {
+        const reply = (event as MessageEvent<LiveFullReply>).data;
+        const done = this.pending.get(reply.id);
+        if (!done) return;
+        this.pending.delete(reply.id);
+        done(reply.pcm);
+      });
+      worker.addEventListener("error", () => this.fail());
+      worker.unref();
+      this.worker = worker;
+      return worker;
+    } catch {
+      this.broken = true;
+      return undefined;
+    }
+  }
+
+  private fail(): void {
+    this.broken = true;
+    const worker = this.worker;
+    this.worker = undefined;
+    worker?.terminate();
+    const waiters = [...this.pending.values()];
+    this.pending.clear();
+    for (const done of waiters) done(undefined);
+  }
+}

package/src/audio/loudness.ts

@@ -3,7 +3,7 @@
  * K-weighted mean square, momentary (400 ms) and short-term (3 s) loudness
  * every 100 ms, gated integrated loudness (absolute -70 LUFS, relative
  * -10 LU), loudness range per EBU Tech 3342 (short-term values gated at
- * -70 LUFS and -20 LU, 10th to 95th percentile) and true peak from a 4x
+ * -70 LUFS and -20 LU, 10th to 95th percentile) and true peak from an 8x
  * oversampled polyphase interpolator (BS.1770-4 Annex 2, with a longer
  * windowed-sinc filter than its example). Validated against
  * the synthetic test signals of EBU Tech 3341 and 3342 in loudness.test.ts.
@@ -31,7 +31,7 @@ export type Loudness = Readonly<{
   shortTermMax: number;
   /** Loudness range (LRA), LU. */
   range: number;
-  /** dBTP: the 4x oversampled peak. */
+  /** dBTP: the 8x oversampled peak. */
   truePeak: number;
   /** dBFS: the highest sample. */
   samplePeak: number;
@@ -239,15 +239,18 @@ function besselI0(x: number): number {
 let phases: Float64Array[] | undefined;
 
 /**
- * The true-peak interpolator: four Kaiser-windowed sinc phases of 32 taps,
- * each in time order over x[n-15] .. x[n+16], estimating the signal at
- * n + 1/8, 3/8, 5/8 and 7/8. With the samples themselves they give the 4x
- * oversampled true peak. BS.1770-4 Annex 2's 12-tap example filter rolls
+ * The true-peak interpolator: Kaiser-windowed sinc phases of 32 taps, each
+ * in time order over x[n-15] .. x[n+16], estimating the signal at n + 1/8,
+ * 3/8, 5/8 and 7/8, then (0.6) n + 2/8, 4/8 and 6/8. With the samples
+ * themselves they give an evenly spaced 8x oversampled true peak; the odd
+ * eighths alone left 1/4-sample gaps that read dense material up to 0.2 dB
+ * low at a peak near n + 3/4. The odd phases come first and are unchanged,
+ * so a peak they already caught reads the same. BS.1770-4 Annex 2's 12-tap example filter rolls
  * off early and reads dense, bright material (supersaws, distortion) up to
  * half a dB low; this one stays within a few hundredths of a 64x reference.
  */
 export function truePeakPhases(): readonly Float64Array[] {
-  phases ??= [1, 3, 5, 7].map((eighth) => {
+  phases ??= [1, 3, 5, 7, 2, 4, 6].map((eighth) => {
     const frac = eighth / 8;
     const taps = new Float64Array(TAPS_PER_PHASE);
     const before = TAPS_PER_PHASE / 2 - 1;
@@ -266,9 +269,23 @@ export function truePeakPhases(): readonly Float64Array[] {
   return phases;
 }
 
+let interleaved: Float64Array | undefined;
+
+/** The seven phases interleaved by tap (`tap * 7 + phase`). */
+function interleavedPhases(): Float64Array {
+  if (interleaved) return interleaved;
+  const branches = truePeakPhases();
+  const flat = new Float64Array(TAPS_PER_PHASE * branches.length);
+  branches.forEach((taps, phase) => {
+    for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1)
+      flat[tap * branches.length + phase] = taps[tap]!;
+  });
+  return (interleaved = flat);
+}
+
 /**
  * Largest absolute value between each sample and the next (both samples
- * and the four interpolated points), as `out[n]` for n .. n+1.
+ * and the seven interpolated points), as `out[n]` for n .. n+1.
  */
 export function interSamplePeaks(
   channel: Float64Array,
@@ -277,6 +294,7 @@ export function interSamplePeaks(
 ): void {
   const n = channel.length;
   const branches = truePeakPhases();
+  const flat = interleavedPhases();
   const before = TAPS_PER_PHASE / 2 - 1;
   const at = (index: number): number => {
     if (index >= 0 && index < n) return channel[index]!;
@@ -287,23 +305,50 @@ export function interSamplePeaks(
     let peak = Math.abs(channel[index]!);
     const next = Math.abs(at(index + 1));
     if (next > peak) peak = next;
-    const inside = index - before >= 0 && index + TAPS_PER_PHASE - before <= n;
-    for (const taps of branches) {
-      let sum = 0;
-      if (inside)
-        for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1)
-          sum += channel[index - before + tap]! * taps[tap]!;
-      else
+    const base = index - before;
+    if (base >= 0 && base + TAPS_PER_PHASE <= n) {
+      // Every phase in one pass over the window (the interior fast path).
+      let s0 = 0;
+      let s1 = 0;
+      let s2 = 0;
+      let s3 = 0;
+      let s4 = 0;
+      let s5 = 0;
+      let s6 = 0;
+      for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1) {
+        const x = channel[base + tap]!;
+        const k = tap * 7;
+        s0 += x * flat[k]!;
+        s1 += x * flat[k + 1]!;
+        s2 += x * flat[k + 2]!;
+        s3 += x * flat[k + 3]!;
+        s4 += x * flat[k + 4]!;
+        s5 += x * flat[k + 5]!;
+        s6 += x * flat[k + 6]!;
+      }
+      peak = Math.max(
+        peak,
+        Math.abs(s0),
+        Math.abs(s1),
+        Math.abs(s2),
+        Math.abs(s3),
+        Math.abs(s4),
+        Math.abs(s5),
+        Math.abs(s6),
+      );
+    } else
+      for (const taps of branches) {
+        let sum = 0;
         for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1)
-          sum += at(index - before + tap) * taps[tap]!;
-      const magnitude = Math.abs(sum);
-      if (magnitude > peak) peak = magnitude;
-    }
+          sum += at(base + tap) * taps[tap]!;
+        const magnitude = Math.abs(sum);
+        if (magnitude > peak) peak = magnitude;
+      }
     if (peak > out[index]!) out[index] = peak;
   }
 }
 
-/** The 4x oversampled true peak of a stereo buffer, linear. */
+/** The 8x oversampled true peak of a stereo buffer, linear. */
 export function truePeakGain(
   left: Float64Array,
   right: Float64Array,

package/src/audio/preview.ts

@@ -129,6 +129,8 @@ export function phraseRole(track: Track): PhraseRole {
   if (isSamplerInstrument(track.instrument))
     return track.sampler?.mode === "keyed" ? "chord" : "groove";
   if (isWavetableInstrument(track.instrument)) return "drone";
+  // Grain clouds are textures: held notes let them evolve.
+  if (track.instrument === "granular") return "drone";
   const words = `${track.instrument} ${track.name} ${track.id}`.toLowerCase();
   if (/\b(bass|sub|808)/.test(words)) return "riff";
   if (/\b(lead|arp|pluck|saw|square|pulse|z_|mono|melody|hook)/.test(words))