@hraness/dawg 0.6.1 → 0.7.0

package/src/audio/live.ts

@@ -28,6 +28,9 @@ import { isOrganFamily } from "../../core/keys.ts";
 import type { LiveFullReply, LiveFullRequest } from "./live-worker.ts";
 import { isBowed, liveStringTrack } from "./strings/engine.ts";
 import { resolveString } from "../../core/strings.ts";
+import { singTrack } from "../../core/sing.ts";
+import { warmGlottal } from "./dsp/glottal.ts";
+import { withSingHorizon } from "./sing/engine.ts";
 
 /** A rendered live note: interleaved stereo 16-bit PCM. */
 export type LiveNotePcm = Readonly<{
@@ -99,7 +102,18 @@ export class LiveSynth {
   /** f061-organ: the live organ clock's origin (performance.now ms). */
   private readonly organEpoch = performance.now();
 
-  public constructor(private readonly sampleRate: number) {}
+  /**
+   * `fastTail: false` always renders the whole tail window (tests compare
+   * the release-sized buffer against it).
+   */
+  public constructor(
+    private readonly sampleRate: number,
+    private readonly options: Readonly<{
+      fastTail?: boolean;
+      /** Called with each one-note render's buffer length, in frames. */
+      onRender?: (frames: number) => void;
+    }> = {},
+  ) {}
 
   public get rate(): number {
     return this.sampleRate;
@@ -237,7 +251,11 @@ export class LiveSynth {
     // Organs too: wheels, rotors and drive cost 4-8 ms per note-second.
     const windowed =
       request.full !== true &&
-      (hasRig(track) || organTick !== undefined || bowedTrack(track)) &&
+      (hasRig(track) ||
+        organTick !== undefined ||
+        bowedTrack(track) ||
+        hasFormant(track) ||
+        singTrack(track)) &&
       seconds > LIVE_RIG_WINDOW_SECONDS &&
       !this.cache.has(key);
     if (windowed) {
@@ -282,24 +300,8 @@ export class LiveSynth {
       : 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 } : {}),
-        ...(organTick ? { seedTick: organTick } : {}),
-        ...(quantChord ? { quantChord } : {}),
-      }),
-    );
-    const frames = windowed
-      ? Math.min(
-          audibleFrames(audio.pcm),
-          Math.round(LIVE_RIG_WINDOW_SECONDS * this.sampleRate),
-        )
-      : audibleFrames(audio.pcm);
+    const windowFrames = Math.round(LIVE_RIG_WINDOW_SECONDS * this.sampleRate);
+    const horizon = windowed ? windowFrames : Infinity;
     const release = liveEngine?.releaseSeconds
       ? liveEngine.releaseSeconds(
           track,
@@ -311,6 +313,44 @@ export class LiveSynth {
           ),
         )
       : tail;
+    const renderFor = (maxSeconds: number) => {
+      const out = withLiveFit(() =>
+        withSingHorizon(horizon, () =>
+          renderScorePcm(single, {
+            sampleRate: this.sampleRate,
+            maxSeconds,
+            ...(request.samples ? { samples: request.samples } : {}),
+            ...(organTick ? { seedTick: organTick } : {}),
+            ...(quantChord ? { quantChord } : {}),
+          }),
+        ),
+      );
+      this.options.onRender?.(out.frames);
+      return out;
+    };
+    const fullSeconds = Math.max(MAX_LIVE_NOTE_SECONDS + 4, seconds + tail);
+    // A damped key decays 60 dB per 4.6 x its release (a linear fade of the
+    // same energy), so 12 x release is past -150 dB: silent in 16 bits. The
+    // renderer is causal, so the short buffer is the full one's prefix; a
+    // note still sounding at its end falls back to the full window.
+    const shortSeconds =
+      !windowed &&
+      this.options.fastTail !== false &&
+      liveFastTail(track, liveEngine !== undefined)
+        ? seconds + Math.min(tail, LIVE_TAIL_RELEASES * release) + 0.1
+        : Infinity;
+    let audio =
+      // The renderer's shortest one-shot is 1 s; the window is cut below.
+      windowed ? renderFor(1) : renderFor(Math.min(fullSeconds, shortSeconds));
+    if (
+      shortSeconds < fullSeconds &&
+      audibleFrames(audio.pcm) >
+        audio.frames - Math.round(LIVE_TAIL_GUARD_SECONDS * this.sampleRate)
+    )
+      audio = renderFor(fullSeconds);
+    const frames = windowed
+      ? Math.min(audibleFrames(audio.pcm), windowFrames)
+      : audibleFrames(audio.pcm);
     const ringOut = !windowed && liveEngine?.ringOut?.(track) === true;
     const pcm = audio.pcm.subarray(0, frames * RENDER_CHANNELS);
     if (ringOut) fadeCutTail(pcm, frames, this.sampleRate);
@@ -346,6 +386,30 @@ export class LiveSynth {
   }
 }
 
+/**
+ * Pays a voice's one-off costs before a key can sound (formant.md 4.5): the
+ * sing engine builds its LF glottal tables (about 50 ms) on first use and
+ * its inner loops need a pass to compile, so the first sing key of a session
+ * would miss the 15 ms first-window budget by 4x. Every other voice has the
+ * same shape at a smaller scale: a cold first press of a grand, a bowed
+ * cello, a granular swarm or a track with effects costs 2-4x a warm one
+ * (docs/perf.md, `live.*`). Play mode calls this when it opens on a track,
+ * so the first key costs what later keys do. The warm render goes
+ * through a throwaway synth, so no cache entry or state is left behind.
+ */
+export function warmLive(
+  score: TrackScore,
+  trackId: string,
+  sampleRate: number,
+): void {
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track) return;
+  if (singTrack(track)) warmGlottal();
+  const synth = new LiveSynth(sampleRate);
+  for (const pitch of [48, 60])
+    synth.render({ score, trackId, pitch, velocity: 0.8, seconds: 0.3 });
+}
+
 /**
  * The track as it sounds live: audible regardless of mute and solo, and
  * without track `time`, so a key sounds once, as played, not re-placed.
@@ -379,6 +443,15 @@ function bowedTrack(track: Track): boolean {
   );
 }
 
+/**
+ * Whether the track plays through the 0.7 formant fx. It is not causal (one
+ * STFT frame of lookahead), but the window renders a 1 s source, well past
+ * the 0.75 s window plus one frame, so the window is an exact prefix.
+ */
+function hasFormant(track: Track): boolean {
+  return Boolean(track.fx?.formant);
+}
+
 /** 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);
@@ -425,6 +498,27 @@ export function fadeCutTail(
   }
 }
 
+/** A short live render ends at 12 x the engine's release past the note. */
+const LIVE_TAIL_RELEASES = 12;
+/** Audio within this much of a short render's end means it was cut. */
+const LIVE_TAIL_GUARD_SECONDS = 0.05;
+
+/**
+ * Whether a live note may render a buffer sized by its engine's release
+ * rather than the whole tail window: only a 0.6 engine's dry track (echoes
+ * and reverb tails are not bounded by the key's release).
+ */
+function liveFastTail(track: Track, engine: boolean): boolean {
+  return (
+    engine &&
+    track.delay === undefined &&
+    track.reverb === undefined &&
+    (track.fx === undefined || Object.keys(track.fx).length === 0) &&
+    (track.fxAutomation === undefined ||
+      Object.keys(track.fxAutomation).length === 0)
+  );
+}
+
 function audibleFrames(pcm: Int16Array): number {
   let last = pcm.length - 1;
   while (last >= 0 && pcm[last] === 0) last -= 1;