@hraness/dawg 0.6.0 → 0.7.0

package/src/audio/strings/engine.ts

@@ -20,8 +20,15 @@ import { interpolateAutomation } from "../effects/common.ts";
 import { seedHash, unit } from "../dsp/rng.ts";
 import type { EngineContext, InstrumentEngine } from "../instruments.ts";
 import { applyBody, bodyFor, symKeys, sympathetic } from "./body.ts";
+import { keysTrim } from "../keys/calibration.ts";
 import { clamp } from "./loop.ts";
 import { PluckString, type Exciter, type PluckSpec } from "./pluck.ts";
+import {
+  BowedString,
+  type BowControl,
+  type BowSpec,
+  type BowNote,
+} from "./bow.ts";
 
 const BLOCK = 128;
 /** Longest a single string may ring (seconds). */
@@ -84,8 +91,155 @@ export function noteSpec(
   };
 }
 
+/** Whether resolved values play the bowed voice (`exciter bow`). */
+export function isBowed(values: StringValues): boolean {
+  return values.exciter === "bow";
+}
+
+/** Play mode keeps a bowed section to two players (live budget). */
+export const LIVE_BOW_UNISON = 2;
+
+/** The track as play mode hears it: a bowed section capped at 2 players. */
+export function liveStringTrack(track: Track): Track {
+  if (track.instrument !== "string" || !track.string) return track;
+  const values = resolveString(track.string);
+  if (!isBowed(values) || (values.unison as number) <= LIVE_BOW_UNISON)
+    return track;
+  return { ...track, string: { ...track.string, unison: LIVE_BOW_UNISON } };
+}
+
+/** Bow lanes read every 32 samples (`string-<name>`, absent: the value). */
+const BOW_LANES = ["pressure", "speed", "sord", "dyn"] as const;
+
+/** The bowed spec and note fields for one note. */
+export function bowSpec(
+  values: StringValues,
+  note: PerformedNote,
+  track: Track,
+  context: EngineContext,
+): { spec: BowSpec; velocity: number; control?: (t: number) => BowControl } {
+  const at = (name: string) => valueAt(track, values, name, note.startTick);
+  let velocity = clamp(note.velocity, 0, 1);
+  const articulation = note.articulation;
+  const sens = clamp(values.vel as number, 0, 1);
+  velocity = 1 - sens * (1 - velocity);
+  let attack = values.attack as number;
+  let release = values.release as number;
+  // Detache (spec 4): staccato and ghost are short strokes, quick on and off.
+  if (articulation === "staccato" || articulation === "ghost") {
+    attack = Math.min(attack, 0.01);
+    release = Math.min(release, 0.03);
+  }
+  // A harder stroke presses harder (spec 4: pressure += 0.3 (vel - 0.5)).
+  const press = (p: number) => clamp(p + 0.3 * (velocity - 0.5), 0, 1);
+  // Accent and marcato bite: pressure +0.2 for the first 80 ms.
+  const bite = articulation === "accent" || articulation === "marcato";
+  const spec: BowSpec = {
+    decay: Math.max(0.02, at("ring")),
+    track: values.track as number,
+    damp: clamp(values.damp as number, 0, 1),
+    pos: clamp(at("pos"), 0.01, 0.5),
+    pressure: press(at("pressure")),
+    speed: clamp(at("speed"), 0, 1),
+    attack,
+    release,
+    tremhz: values.tremhz as number,
+    sord: clamp(at("sord"), 0, 1),
+  };
+  const lanes = BOW_LANES.filter(
+    (name) =>
+      (track.fxAutomation?.[`string-${name}` as FxLane]?.length ?? 0) > 0,
+  );
+  const dyn = clamp(values.dyn as number, 0, 1);
+  if (lanes.length === 0 && dyn === 1 && !bite) return { spec, velocity };
+  const fixed: BowControl = {
+    pressure: spec.pressure,
+    speed: spec.speed,
+    sord: spec.sord,
+    dyn,
+  };
+  const bitten: BowControl = {
+    ...fixed,
+    pressure: clamp(spec.pressure + 0.2, 0, 1),
+  };
+  if (lanes.length === 0)
+    return {
+      spec,
+      velocity,
+      control: bite ? (t) => (t < 0.08 ? bitten : fixed) : () => fixed,
+    };
+  // Lanes are read in ticks; warped songs read them at the note's tempo.
+  const ticksPerSecond = context.sampleRate / context.samplesPerTick;
+  const control = (t: number): BowControl => {
+    const tick = note.startTick + t * ticksPerSecond;
+    const lane = (name: string) =>
+      clamp(valueAt(track, values, name, tick), 0, 1);
+    return {
+      pressure: clamp(
+        press(lane("pressure")) + (bite && t < 0.08 ? 0.2 : 0),
+        0,
+        1,
+      ),
+      speed: lane("speed"),
+      sord: lane("sord"),
+      dyn: lane("dyn"),
+    };
+  };
+  return { spec, velocity, control };
+}
+
+/** The preset vibrato alone (a slur keeps it running). */
+function vibratoCurve(
+  note: PerformedNote,
+  values: StringValues,
+  track: Track,
+  player: Readonly<{ rate: number; depth: number; phase: number }> = SOLO,
+): ((t: number) => number) | undefined {
+  if (note.performance?.replaceVibrato) return undefined;
+  const rate = valueAt(track, values, "vib", note.startTick) * player.rate;
+  const depth =
+    valueAt(track, values, "vibmod", note.startTick) * 100 * player.depth;
+  const delay = values.vibdelay as number;
+  if (!(rate > 0 && depth > 0)) return undefined;
+  const phase = player.phase;
+  return (t: number) => {
+    if (t <= delay) return 0;
+    const fade = Math.min(1, (t - delay) / 0.15);
+    return depth * fade * Math.sin(2 * Math.PI * (rate * (t - delay) + phase));
+  };
+}
+
+const SOLO = { rate: 1, depth: 1, phase: 0 } as const;
+
+/** Longest seeded onset spread of a bowed section's players (spec 2). */
+export const SECTION_SPREAD = 0.025;
+
+/**
+ * One section player (spec 2, Ensemble): seeded vibrato rate x0.92-1.08,
+ * depth x0.8-1.2 and phase, and an onset up to 25 ms late (scaled down
+ * for notes under 0.25 s). The first player stays on the grid.
+ */
+export function sectionPlayer(
+  seed: number,
+  index: number,
+  hold: number,
+): { rate: number; depth: number; phase: number; onset: number } {
+  const h = seedHash(`${seed}:${index}:player`);
+  return {
+    rate: 0.92 + 0.16 * unit(h, 0, 1),
+    depth: 0.8 + 0.4 * unit(h, 1, 1),
+    phase: unit(h, 2, 1),
+    onset:
+      index === 0
+        ? 0
+        : SECTION_SPREAD * unit(h, 3, 1) * Math.min(1, hold / 0.25),
+  };
+}
+
 type Voice = {
-  string: PluckString;
+  string: PluckString | BowedString;
+  /** The string's pitch over the note's base pitch (a slur keeps it). */
+  ratio: number;
   start: number;
   pitch: number;
   group: number;
@@ -94,6 +248,26 @@ type Voice = {
   damp?: Readonly<{ from: number; tau: number }>;
 };
 
+/**
+ * Whether pending note `index` (starting at `start`) is a lone note: no
+ * other note starts with it, so a held single note may slur into it.
+ */
+function slurs(
+  pending: readonly { start: number }[],
+  index: number,
+  start: number,
+): boolean {
+  return (
+    pending[index - 1]?.start !== start && pending[index + 1]?.start !== start
+  );
+}
+
+/** A 64th note in samples at the song's start tempo (the slur window). */
+function slurWindow(context: EngineContext): number {
+  const ticks = (context.score.ticksPerBeat ?? 480) / 16;
+  return ticks * context.samplesPerTick;
+}
+
 /** Ring-out after the last note-off, in seconds. */
 export function stringTailSeconds(track: Track): number {
   const values = resolveString(track.string);
@@ -163,6 +337,11 @@ export function renderStrings(
   const octbelow = values.octbelow as number;
   const cap = Math.max(1, Math.round(values.voices as number));
   const tuning = context.tuning;
+  const bowed = isBowed(values);
+  // Calibration 1 (q08): the keyboard string presets (the harpsichord) take
+  // the keys' key-tracked level trim; other presets have no row.
+  const trimPreset =
+    (context.score.calibration ?? 0) >= 1 ? track.string?.preset : undefined;
   const L = new Float64Array(total);
   const R = dryR ? new Float64Array(total) : undefined;
   const voices: Voice[] = [];
@@ -183,6 +362,47 @@ export function renderStrings(
       next += 1;
       const baseHz = noteHz(note.pitch, note.cents, tuning);
       if (!(baseHz > 0) || baseHz >= 0.45 * sr) continue;
+      // Slur (bowed): a single note that starts while one earlier single
+      // note is still bowed moves that bow to the new pitch in 7 ms, with
+      // no new attack (legato articulation overlaps its notes, so it
+      // slurs too). Chords and double stops start new strokes.
+      if (bowed && slurs(pending, next - 1, start)) {
+        const held = voices.filter(
+          (v) => !v.string.done && v.string.offAt > start - v.start,
+        );
+        const groups = new Set(held.map((v) => v.group));
+        const pitches = new Set(held.map((v) => v.pitch));
+        // A true legato only: the held note lets go within a short window
+        // of the new one (a 64th note or 150 ms, legato's own overlap), or
+        // the new note is marked legato. A pedal or a note held under a
+        // moving line keeps sounding and the new note takes a new stroke.
+        const window = Math.max(0.15 * sr, slurWindow(context));
+        const letsGo =
+          note.articulation === "legato" ||
+          held.every((v) => v.start + v.string.offAt <= start + window);
+        const range = held.every((v) =>
+          (v.string as BowedString).canSlurTo(baseHz * v.ratio),
+        );
+        if (
+          letsGo &&
+          range &&
+          groups.size === 1 &&
+          pitches.size === 1 &&
+          held[0]!.start < start
+        ) {
+          const hold = holdSamples(note, start, context) / sr;
+          for (const v of held) {
+            (v.string as BowedString).slurTo(
+              baseHz * v.ratio,
+              start - v.start,
+              Math.max(0.01, hold),
+              note.performance?.cents,
+            );
+            v.pitch = note.pitch;
+          }
+          continue;
+        }
+      }
       // Restrike: the same key damps its previous string.
       for (const v of voices)
         if (v.pitch === note.pitch) v.string.releaseAt(start - v.start);
@@ -197,11 +417,11 @@ export function renderStrings(
         for (const v of held)
           if (v.group === oldest) v.string.releaseAt(start - v.start);
       }
-      const { spec, velocity } = noteSpec(values, note, track);
       const seed = seedHash(
         `${note.id}:${note.startTick + (context.seedTick ?? 0)}:string`,
       );
-      const strings: { hz: number; gain: number }[] = [];
+      const strings: { hz: number; gain: number; ratio: number }[] = [];
+      const trim = trimPreset ? keysTrim(trimPreset, note.pitch) : 1;
       // The course's tuning error belongs to the key, not to the strike: it
       // is seeded by track and key (so every velocity of a key beats the
       // same way) and centred, so the course's mean pitch is the table's.
@@ -213,42 +433,74 @@ export function renderStrings(
       for (let i = 0; i < unison; i += 1) {
         const d = unison > 1 ? (i / (unison - 1) - 0.5) * detune : 0;
         const jitter = jitters[i]! - meanJitter;
+        const ratio = 2 ** ((d * 100 + jitter) / 1200);
         strings.push({
-          hz: baseHz * 2 ** ((d * 100 + jitter) / 1200),
-          gain: 1 / Math.sqrt(unison),
+          hz: baseHz * ratio,
+          gain: trim / Math.sqrt(unison),
+          ratio,
         });
       }
       if (oct > 0 && note.pitch < octbelow) {
         const up = noteHz(Math.min(127, note.pitch + 12), note.cents, tuning);
         const hz = up > 0 ? up : baseHz * 2;
-        if (hz < 0.45 * sr)
+        if (hz < 0.45 * sr) {
+          const tuned =
+            hz * 2 ** (((unit(course, unison, 1) - 0.5) * 4) / 1200);
           strings.push({
-            hz: hz * 2 ** (((unit(course, unison, 1) - 0.5) * 4) / 1200),
-            gain: oct / Math.sqrt(unison),
+            hz: tuned,
+            gain: (trim * oct) / Math.sqrt(unison),
+            ratio: tuned / baseHz,
           });
+        }
       }
       const hold = holdSamples(note, start, context) / sr;
-      const cents = centsCurve(note, values, track);
+      const pluck = bowed ? undefined : noteSpec(values, note, track);
+      const bow = bowed ? bowSpec(values, note, track, context) : undefined;
+      const cents = bowed
+        ? note.performance?.cents
+        : centsCurve(note, values, track);
+      const section = bowed && unison > 1;
       strings.forEach((s, i) => {
+        // Section players (not the octave string) are seeded as players.
+        const player =
+          section && i < unison ? sectionPlayer(seed, i, hold) : undefined;
+        const onset = player ? Math.round(player.onset * sr) : 0;
+        const vibrato = bowed
+          ? vibratoCurve(note, values, track, player)
+          : undefined;
         const pan =
           strings.length > 1 ? (i / (strings.length - 1) - 0.5) * spread : 0;
-        const string = new PluckString(
-          spec,
-          {
-            hz: s.hz,
-            velocity,
-            hold: Math.max(0.01, hold),
-            seed: seedHash(`${seed}:${i}`),
-            ...(cents ? { cents } : {}),
-          },
-          sr,
-          MAX_RING,
-        );
+        const common = {
+          hz: s.hz,
+          hold: Math.max(0.01, hold - onset / sr),
+          seed: seedHash(`${seed}:${i}`),
+          ...(cents ? { cents } : {}),
+        };
+        const string = bow
+          ? new BowedString(
+              bow.spec,
+              {
+                ...common,
+                velocity: bow.velocity,
+                ...(vibrato ? { vibrato } : {}),
+                ...(bow.control ? { control: bow.control } : {}),
+              } satisfies BowNote,
+              sr,
+              // A bow sustains for as long as the note is held.
+              Math.max(MAX_RING, hold + bow.spec.release + 1),
+            )
+          : new PluckString(
+              pluck!.spec,
+              { ...common, velocity: pluck!.velocity },
+              sr,
+              MAX_RING,
+            );
         const gl = R ? s.gain * Math.sqrt(0.5 - pan / 2) * Math.SQRT2 : s.gain;
         const gr = s.gain * Math.sqrt(0.5 + pan / 2) * Math.SQRT2;
         voices.push({
           string,
-          start,
+          ratio: s.ratio,
+          start: start + onset,
           pitch: note.pitch,
           group: start,
           gainL: gl,

package/src/audio/strings/measure.test-helpers.ts

@@ -24,6 +24,7 @@ export type TestNote = {
   seconds?: number;
   velocity?: number;
   performance?: PerformedNote["performance"];
+  articulation?: PerformedNote["articulation"];
 };
 
 /** Renders notes on a string track (mono, before effects). */
@@ -58,6 +59,7 @@ export function render(
     startTick: Math.round(((n.start ?? 0) * SR) / SPT),
     durationTicks: Math.round(((n.seconds ?? seconds) * SR) / SPT),
     ...(n.performance ? { performance: n.performance } : {}),
+    ...(n.articulation ? { articulation: n.articulation } : {}),
   })) as unknown as PerformedNote[];
   const dry = new Float64Array(samples);
   renderStrings(dry, undefined, performed, track, context);

package/src/audio/synth/oscillators.ts

@@ -110,28 +110,38 @@ function triangle(phase: number): number {
  * names when a track sets synth parameters.
  */
 export function legacyWave(instrument: string, phase: number): number {
+  return legacyWaveFor(instrument)(phase);
+}
+
+/**
+ * `legacyWave` with the tone chosen once: `legacyWaveFor(name)(phase)`
+ * equals `legacyWave(name, phase)`, without matching the name per sample.
+ */
+export function legacyWaveFor(instrument: string): (phase: number) => number {
   const name = instrument.trim().toLowerCase();
-  const cycle = phase - Math.floor(phase);
-  const sine = Math.sin(2 * Math.PI * phase);
-  if (name.includes("square")) return cycle < 0.5 ? 1 : -1;
-  if (name.includes("saw")) return 2 * cycle - 1;
-  if (name.includes("triangle")) return 1 - 4 * Math.abs(cycle - 0.5);
-  if (name.includes("bass")) {
+  if (name.includes("square"))
+    return (phase) => (phase - Math.floor(phase) < 0.5 ? 1 : -1);
+  if (name.includes("saw"))
+    return (phase) => 2 * (phase - Math.floor(phase)) - 1;
+  if (name.includes("triangle"))
+    return (phase) => 1 - 4 * Math.abs(phase - Math.floor(phase) - 0.5);
+  if (name.includes("bass"))
     // A rounded fundamental plus a quiet octave gives bass tracks useful weight.
-    return Math.tanh(
-      0.9 * Math.sin(2 * Math.PI * phase) +
-        0.25 * Math.sin(4 * Math.PI * phase),
-    );
-  }
-  if (name.includes("piano") || name.includes("pluck")) {
+    return (phase) =>
+      Math.tanh(
+        0.9 * Math.sin(2 * Math.PI * phase) +
+          0.25 * Math.sin(4 * Math.PI * phase),
+      );
+  if (name.includes("piano") || name.includes("pluck"))
     // Add stable harmonics; the envelope above supplies the note decay.
-    const harmonic =
-      Math.sin(4 * Math.PI * phase) * 0.28 +
-      Math.sin(6 * Math.PI * phase) * 0.12;
-    return Math.tanh(sine + harmonic);
-  }
+    return (phase) => {
+      const harmonic =
+        Math.sin(4 * Math.PI * phase) * 0.28 +
+        Math.sin(6 * Math.PI * phase) * 0.12;
+      return Math.tanh(Math.sin(2 * Math.PI * phase) + harmonic);
+    };
   // Unknown instruments deliberately fall back to the original sine voice.
-  return sine;
+  return (phase) => Math.sin(2 * Math.PI * phase);
 }
 
 /**
@@ -230,9 +240,9 @@ const BUILT_IN: Readonly<Record<string, OscillatorFactory>> = Object.freeze({
   pulse: (init) => (phase, increment) => pulse(phase, increment, init.width()),
   triangle: (init) => (init.partials ? additive(init) : triangle),
   user: (init) => additive(init),
-  piano: () => (phase) => legacyWave("piano", phase),
-  pluck: () => (phase) => legacyWave("pluck", phase),
-  bass: () => (phase) => legacyWave("bass", phase),
+  piano: () => legacyWaveFor("piano"),
+  pluck: () => legacyWaveFor("pluck"),
+  bass: () => legacyWaveFor("bass"),
   white: (init) => () => (init.random() * 2 - 1) * 0.6,
   pink: (init) => pinkNoise(init.random),
   brown: (init) => {

package/src/audio/synth/voice.ts

@@ -31,6 +31,7 @@ import {
 } from "../../../core/synth.ts";
 import {
   Biquad,
+  Svf,
   CONTROL_SAMPLES,
   clamp,
   interpolateAutomation,
@@ -197,6 +198,8 @@ const BUTTERWORTH_Q2 = 1.3066;
 class NoteFilter {
   private readonly first = new Biquad();
   private readonly second = new Biquad();
+  private readonly svfFirst: Svf;
+  private readonly svfSecond: Svf;
   private readonly ladder = new Float64Array(4);
   private ladderG = 0;
   private ladderK = 0;
@@ -210,7 +213,22 @@ class NoteFilter {
     readonly anchor: number,
     readonly envelope: Envelope,
     private readonly sampleRate: number,
-  ) {}
+  ) {
+    this.svfFirst = new Svf(type);
+    this.svfSecond = new Svf(type);
+  }
+
+  /**
+   * A negative depth sweeps the cutoff down during the attack, often to
+   * the 20 Hz floor within a few milliseconds. A direct-form biquad
+   * re-designed every control block blows up under that fall (its state
+   * belongs to the old coefficients), so those notes run on the SVF, whose
+   * state stays valid. Positive and zero depths keep the biquad, so their
+   * renders are unchanged.
+   */
+  private get isSvf(): boolean {
+    return this.depth < 0;
+  }
 
   private get isLadder(): boolean {
     return this.slope === "ladder" && this.type === "lpf";
@@ -231,6 +249,17 @@ class NoteFilter {
       this.ladderK = 3.9 * clamp((q - 0.707) / 11.3, 0, 1);
       return;
     }
+    if (this.isSvf) {
+      if (this.slope === "24db") {
+        this.svfFirst.set(frequency, BUTTERWORTH_Q1, this.sampleRate);
+        this.svfSecond.set(
+          frequency,
+          (q * BUTTERWORTH_Q2) / 0.707,
+          this.sampleRate,
+        );
+      } else this.svfFirst.set(frequency, q, this.sampleRate);
+      return;
+    }
     if (this.slope === "24db") {
       this.first.set(this.type, frequency, BUTTERWORTH_Q1, this.sampleRate);
       this.second.set(
@@ -255,6 +284,10 @@ class NoteFilter {
       stages[3]! += g * (stages[2]! - stages[3]!);
       return stages[3]! * (1 + 0.5 * this.ladderK);
     }
+    if (this.isSvf) {
+      const once = this.svfFirst.process(input);
+      return this.slope === "24db" ? this.svfSecond.process(once) : once;
+    }
     const once = this.first.process(input);
     return this.slope === "24db" ? this.second.process(once) : once;
   }