@hraness/dawg 0.6.0 → 0.6.1

package/src/audio/keys/piano.ts

@@ -156,6 +156,12 @@ 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;
 }>;
 
 type Rattle = {
@@ -207,18 +213,47 @@ 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);
     this.pulse = hammerPulse(
       Math.max(2, Math.round(thMs * 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 +269,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 +278,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,7 +306,11 @@ export class PianoVoice {
           t60: 0.6 + 1.2 * prep(),
           u: 0.35,
         });
-    const loud = v ** 1.4 * (1 - 0.4 * p.felt);
+    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 G = (0.35 * loud) / Math.sqrt(Math.max(energy, 1e-9));
     const mags = candidates.map(
       (c) => pulseMag(this.pulse, (TAU * c.hz) / sr) * Math.abs(c.u),
@@ -295,7 +339,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/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);

package/src/audio/live.ts

@@ -19,10 +19,15 @@ import {
 import { bpmAtTick } from "../../core/tempo.ts";
 import { EMPTY_SAMPLE_BANK, sampleKey, type SampleBank } from "./samples.ts";
 import { RENDER_CHANNELS, renderScorePcm } from "./wav.ts";
-import { engineFor } from "./instruments.ts";
+import { engineFor, RING_OUT_FADE_SECONDS } from "./instruments.ts";
+import { chordDigest, chordTimeline } from "./granular.ts";
+import { resolveGranular } from "../../core/granular.ts";
 import { noteHz, resolveTuning } from "../../core/tuning.ts";
 import { liveFitPending, withLiveFit } from "./fit.ts";
+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";
 
 /** A rendered live note: interleaved stereo 16-bit PCM. */
 export type LiveNotePcm = Readonly<{
@@ -37,11 +42,22 @@ export type LiveNotePcm = Readonly<{
    */
   fitting?: true;
   /**
-   * True when this is only the first window of a guitar-rig note
+   * True when this is only the first window of a guitar-rig or bowed 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;
+  /**
+   * The organ clock tick a first window rendered at: pass it back as the
+   * request's `clock` for the full pass so the wheels and rotors continue.
+   */
+  clock?: number;
+  /**
+   * The key's release does not fade the voice: it rings to the end of its
+   * rendered tail (0.6.1 modal `damp 0`), which ends in a `RING_OUT_FADE_SECONDS`
+   * fade when the length cap cut it.
+   */
+  ringOut?: true;
 }>;
 
 export type LiveNoteRequest = Readonly<{
@@ -58,6 +74,8 @@ export type LiveNoteRequest = Readonly<{
   tick?: number;
   /** Render the whole note even through a guitar rig (the background pass). */
   full?: boolean;
+  /** An organ note's clock tick from its first window (`LiveNotePcm.clock`). */
+  clock?: number;
 }>;
 
 /**
@@ -78,6 +96,8 @@ const CACHE_ENTRIES = 96;
  */
 export class LiveSynth {
   private readonly cache = new Map<string, LiveNotePcm>();
+  /** f061-organ: the live organ clock's origin (performance.now ms). */
+  private readonly organEpoch = performance.now();
 
   public constructor(private readonly sampleRate: number) {}
 
@@ -122,6 +142,38 @@ export class LiveSynth {
     );
     const velocity = Math.max(0, Math.min(1, request.velocity));
     const pitch = Math.max(0, Math.min(127, Math.round(request.pitch)));
+    // f061-organ: one rotating speaker and one set of free-running wheels
+    // per organ track. Each key renders from the song tick it sounds at
+    // (or the synth's own clock when stopped), so successive notes share
+    // the track's rotor and wheel phases instead of restarting them.
+    const organTick =
+      track.keys && isOrganFamily(track.instrument)
+        ? Math.max(
+            0,
+            Math.round(
+              request.clock ??
+                request.tick ??
+                ((performance.now() - this.organEpoch) / 1000) * ticksPerSecond,
+            ),
+          )
+        : undefined;
+    // Granular `quant chord` (0.6.1): a live note snaps to the song's
+    // chords at the played tick, as the offline render of the same note.
+    const quantChord =
+      track.granular !== undefined &&
+      liveEngine?.id === "granular" &&
+      resolveGranular(track.granular).quant === "chord"
+        ? { score, tick: request.tick ?? 0 }
+        : undefined;
+    const chord = quantChord
+      ? chordDigest(
+          chordTimeline(score),
+          quantChord.tick,
+          quantChord.tick +
+            durationTicks +
+            Math.ceil(liveEngine!.tailSeconds(track, pitch) * ticksPerSecond),
+        )
+      : undefined;
     const key = JSON.stringify([
       liveTrack(track),
       pitch,
@@ -137,6 +189,7 @@ export class LiveSynth {
       ...(score.tuning || track.tuning
         ? [score.tuning ?? null, score.key]
         : []),
+      ...(organTick !== undefined ? [`organ:${organTick}`] : []),
       // A 0.6 engine's assets, and the key it may tune to.
       ...(liveEngine
         ? [
@@ -147,21 +200,44 @@ export class LiveSynth {
             score.key ?? null,
           ]
         : []),
+      ...(chord ? [chord] : []),
     ]);
-    return { track, score, bpm, seconds, durationTicks, velocity, pitch, key };
+    return {
+      track,
+      score,
+      bpm,
+      seconds,
+      durationTicks,
+      velocity,
+      pitch,
+      key,
+      organTick,
+      quantChord,
+    };
   }
 
   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 {
+      track,
+      score,
+      bpm,
+      seconds,
+      durationTicks,
+      velocity,
+      pitch,
+      key,
+      organTick,
+      quantChord,
+    } = 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.
+    // Organs too: wheels, rotors and drive cost 4-8 ms per note-second.
     const windowed =
       request.full !== true &&
-      hasRig(track) &&
+      (hasRig(track) || organTick !== undefined || bowedTrack(track)) &&
       seconds > LIVE_RIG_WINDOW_SECONDS &&
       !this.cache.has(key);
     if (windowed) {
@@ -214,6 +290,8 @@ export class LiveSynth {
           ? 1
           : Math.max(MAX_LIVE_NOTE_SECONDS + 4, seconds + tail),
         ...(request.samples ? { samples: request.samples } : {}),
+        ...(organTick ? { seedTick: organTick } : {}),
+        ...(quantChord ? { quantChord } : {}),
       }),
     );
     const frames = windowed
@@ -233,9 +311,13 @@ export class LiveSynth {
           ),
         )
       : tail;
+    const ringOut = !windowed && liveEngine?.ringOut?.(track) === true;
+    const pcm = audio.pcm.subarray(0, frames * RENDER_CHANNELS);
+    if (ringOut) fadeCutTail(pcm, frames, this.sampleRate);
     const rendered: LiveNotePcm = {
-      pcm: audio.pcm.subarray(0, frames * RENDER_CHANNELS),
+      pcm,
       frames,
+      ...(ringOut ? { ringOut: true as const } : {}),
       ...(liveEngine
         ? {
             releaseSeconds: Math.min(
@@ -245,8 +327,11 @@ export class LiveSynth {
           }
         : {}),
       ...(windowed ? { partial: true } : {}),
+      ...(windowed && organTick !== undefined ? { clock: organTick } : {}),
     };
     if (liveFitPending()) return { ...rendered, fitting: true };
+    // Organ keys render at their song tick: caching them would only evict.
+    if (organTick !== undefined) return rendered;
     this.cache.set(windowed ? `${key}#window` : key, rendered);
     this.trim();
     return rendered;
@@ -266,17 +351,32 @@ export class LiveSynth {
  * without track `time`, so a key sounds once, as played, not re-placed.
  */
 function liveTrack(track: Track): Track {
-  // A held key is the performance: the recorded pedal and the render-time
+  // A held key is the performance: the recorded pedals and the render-time
   // humanize stay out of it. The velocity curve stays, so a key sounds like
   // the note it records as.
   const {
     solo: _solo,
     time: _time,
     pedal: _pedal,
+    softPedal: _softPedal,
+    sostenuto: _sostenuto,
     humanize: _humanize,
     ...rest
   } = track;
-  return { ...rest, muted: false };
+  // A bowed section plays two players live (f061-bowed render budget).
+  return liveStringTrack({ ...rest, muted: false });
+}
+
+/**
+ * Whether the track is a bowed string: a held bow costs about 5 ms per
+ * second, so it windows like a rig (the bow loop is causal too).
+ */
+function bowedTrack(track: Track): boolean {
+  return (
+    track.instrument === "string" &&
+    track.string !== undefined &&
+    isBowed(resolveString(track.string))
+  );
 }
 
 /** Whether the track plays through a guitar rig stage. */
@@ -299,6 +399,32 @@ function samplerDigest(track: Track, bank: SampleBank | undefined): string[] {
 }
 
 /** Frames up to the last non-silent sample, so mixing skips the dead tail. */
+/**
+ * A ring-out note cut by the render length still sounds at its last frame:
+ * fade its final `RING_OUT_FADE_SECONDS` linearly to zero so the cap never
+ * clicks (each step stays under -60 dB of full scale). A tail that already
+ * decayed to silence is left alone.
+ */
+export function fadeCutTail(
+  pcm: Int16Array,
+  frames: number,
+  sampleRate: number,
+): void {
+  if (frames === 0) return;
+  const last = (frames - 1) * RENDER_CHANNELS;
+  // Below -60 dBFS the cut is inaudible.
+  if (Math.abs(pcm[last]!) < 33 && Math.abs(pcm[last + 1]!) < 33) return;
+  const fade = Math.min(frames, Math.round(RING_OUT_FADE_SECONDS * sampleRate));
+  for (let i = 0; i < fade; i += 1) {
+    const frame = frames - fade + i;
+    const gain = (fade - 1 - i) / fade;
+    for (let c = 0; c < RENDER_CHANNELS; c += 1) {
+      const at = frame * RENDER_CHANNELS + c;
+      pcm[at] = Math.round(pcm[at]! * gain);
+    }
+  }
+}
+
 function audibleFrames(pcm: Int16Array): number {
   let last = pcm.length - 1;
   while (last >= 0 && pcm[last] === 0) last -= 1;
@@ -344,6 +470,7 @@ export class LiveFullRenderer {
         velocity: request.velocity,
         seconds: request.seconds,
         ...(request.tick === undefined ? {} : { tick: request.tick }),
+        ...(request.clock === undefined ? {} : { clock: request.clock }),
         ...(request.samples ? { samples: request.samples } : {}),
       };
       try {

package/src/audio/preview.ts

@@ -16,6 +16,12 @@
  * wavetables so position changes are audible.
  */
 import { isDrumInstrument } from "../../core/drums.ts";
+import { slicePedals } from "../../core/expression.ts";
+import {
+  isStringTrack,
+  resolveString,
+  stringPresetOf,
+} from "../../core/strings.ts";
 import type { SongMaster } from "../../core/master.ts";
 import { MODES, parseKey } from "../../core/chords.ts";
 import { rhythmVoicePitch } from "../../core/rhythm.ts";
@@ -131,6 +137,14 @@ export function phraseRole(track: Track): PhraseRole {
   if (isWavetableInstrument(track.instrument)) return "drone";
   // Grain clouds are textures: held notes let them evolve.
   if (track.instrument === "granular") return "drone";
+  if (isStringTrack(track) && resolveString(track.string).exciter === "bow") {
+    // Bowed: low strings walk a line, solo strings sing a legato line,
+    // sections and pizz/trem hold chords.
+    const preset = stringPresetOf(track.string);
+    if (/^(contrabass|contrabasses|cello|cellos)$/.test(preset)) return "riff";
+    if (/^(violin|viola|fiddle|erhu|kamancheh)$/.test(preset)) return "lead";
+    return "chord";
+  }
   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))
@@ -287,7 +301,7 @@ function sliceTrack(track: Track, start: number, end: number): Track {
         lanes[name] = sliceLane(points, start, end);
     sliced.fxAutomation = lanes;
   }
-  return sliced as Track;
+  return slicePedals(sliced as Track, [{ from: start, to: end, offset: 0 }]);
 }
 
 /**