@hraness/dawg 0.4.1 → 0.6.0

package/src/audio/synth/voice.ts

@@ -19,7 +19,9 @@
  * of the score and the note, so cold, cached and worker renders agree.
  */
 import type { Note, Track } from "../../../core/score.ts";
+import type { PerformedNote } from "../../../core/expression.ts";
 import type { FxLane } from "../../../core/fx.ts";
+import { noteHz, type TuningTable } from "../../../core/tuning.ts";
 import {
   LEGACY_SOUNDS,
   SOUND_ALIASES,
@@ -78,6 +80,10 @@ export type VoiceContext = Readonly<{
    * (a wavetable track's table); otherwise the sound's resolver is used.
    */
   oscillatorFor?: (note: Note) => OscillatorFactory | undefined;
+  /** The track's merged tuning (`resolveTuning`); absent is 12-TET. */
+  tuning?: TuningTable;
+  /** Ticks added to a note's start in its noise seed (`RenderOptions`). */
+  seedTick?: number;
 }>;
 
 /** Track gain at a tick (volume × volume lane), supplied by the renderer. */
@@ -258,11 +264,16 @@ function noteFilters(
   c: Controls,
   gate: number,
   sampleRate: number,
+  accent = false,
 ): (() => NoteFilter)[] {
   const out: (() => NoteFilter)[] = [];
   for (const { prefix, type, param } of FILTERS) {
-    const depth = c.number(`${prefix}env`);
-    if (!c.has(param) && depth === 0) continue;
+    const written = c.number(`${prefix}env`);
+    if (!c.has(param) && written === 0) continue;
+    // TB-303 accent: an accented note opens the low-pass further and its
+    // filter envelope decays faster.
+    const boost = accent && prefix === "lp" ? c.number("faccent") : 0;
+    const depth = written + boost;
     const cutoff = c.number(param);
     const q = c.number(`${prefix}q`);
     const slope = type === "lpf" ? c.text("ftype") : "12db";
@@ -276,7 +287,15 @@ function noteFilters(
           q,
           depth,
           anchor,
-          envelopeFor(c, prefix, "", gate),
+          boost > 0
+            ? new Envelope(
+                c.number(`${prefix}attack`),
+                c.number(`${prefix}decay`) / 2,
+                c.number(`${prefix}sustain`),
+                c.number(`${prefix}release`),
+                gate,
+              )
+            : envelopeFor(c, prefix, "", gate),
           sampleRate,
         ),
     );
@@ -343,13 +362,25 @@ export function renderSynthNote(
     start + length + Math.ceil(release * sampleRate),
   );
   if (end <= start) return;
-  const random = seededRandom(`${note.id}:${note.startTick}:synth`);
+  const random = seededRandom(
+    `${note.id}:${note.startTick + (context.seedTick ?? 0)}:synth`,
+  );
   const amp = envelopeFor(c, "", "", gate);
   const velocity = clamp(note.velocity, 0, 1);
   const gain = c.number("gain");
-
-  // Pitch.
-  const base = 440 * 2 ** ((note.pitch - 69) / 12);
+  // Note expression (core/expression.ts): absent for plain notes, which
+  // keeps their output byte-identical.
+  const performance = (note as PerformedNote).performance;
+  const cents = performance?.cents;
+  const damp = performance?.damp;
+  const dampAt = (t: number): number =>
+    damp && t > damp.from ? Math.exp(-(t - damp.from) / damp.tau) : 1;
+
+  // Pitch: the tuning table's key frequency and the note's cents (exactly
+  // 440 · 2^((pitch − 69)/12) without either). A key a keyboard mapping
+  // leaves unmapped is silent.
+  const base = noteHz(note.pitch, note.cents, context.tuning);
+  if (!(base > 0)) return;
 
   if (isZzfxSound(sound) && !context.oscillatorFor) {
     const count = end - start;
@@ -371,28 +402,37 @@ export function renderSynthNote(
       zdelay: c.number("zdelay"),
       tremolo: c.number("tremolo"),
       random,
+      ...(cents ? { cents } : {}),
+      ...(performance?.replaceSlide ? { slideOff: true } : {}),
     });
-    const filters = noteFilters(c, gate, sampleRate).map((make) => make());
+    const filters = noteFilters(
+      c,
+      gate,
+      sampleRate,
+      performance?.accent === true,
+    ).map((make) => make());
     for (let elapsed = 0; elapsed < count; elapsed += 1) {
       const t = elapsed / sampleRate;
       if (elapsed % CONTROL_SAMPLES === 0)
         for (const filter of filters) filter.update(t);
       let value = raw[elapsed]!;
       for (const filter of filters) value = filter.process(value);
-      const level =
+      let level =
         amp.at(t) *
         velocity *
         gain *
         VOICE_LEVEL *
         gainAt(note.startTick + elapsed / samplesPerTick);
+      if (damp) level *= dampAt(t);
       left[start + elapsed]! += value * level;
       if (right) right[start + elapsed]! += value * level;
     }
     return;
   }
-  const vib = c.number("vib");
+  // A note's own vibrato or bend replaces the synth's (note over track).
+  const vib = performance?.replaceVibrato ? 0 : c.number("vib");
   const vibmod = c.number("vibmod");
-  const penv = c.number("penv");
+  const penv = performance?.replacePitchEnvelope ? 0 : c.number("penv");
   const pitchEnv =
     penv === 0
       ? undefined
@@ -463,7 +503,12 @@ export function renderSynthNote(
 
   const fm = fmOperators(c, gate);
   const fmPhases = fm.map(() => new Float64Array(unison));
-  const filterMakers = noteFilters(c, gate, sampleRate);
+  const filterMakers = noteFilters(
+    c,
+    gate,
+    sampleRate,
+    performance?.accent === true,
+  );
   const filtersL = filterMakers.map((make) => make());
   const filtersR = right ? filterMakers.map((make) => make()) : [];
 
@@ -483,6 +528,7 @@ export function renderSynthNote(
       if (pcurve >= 1) e = e * e * e;
       semitones += penv * (e - panchor);
     }
+    if (cents) semitones += cents(t) / 100;
     const frequency = semitones === 0 ? base : base * 2 ** (semitones / 12);
     if (pwsweep > 0)
       width = clamp(
@@ -522,12 +568,13 @@ export function renderSynthNote(
     }
     for (const filter of filtersL) sampleL = filter.process(sampleL);
     for (const filter of filtersR) sampleR = filter.process(sampleR);
-    const level =
+    let level =
       amp.at(t) *
       velocity *
       gain *
       VOICE_LEVEL *
       gainAt(note.startTick + elapsed / samplesPerTick);
+    if (damp) level *= dampAt(t);
     left[index]! += sampleL * level;
     if (right) right[index]! += sampleR * level;
   }

package/src/audio/synth/zzfx.ts

@@ -53,6 +53,10 @@ export type ZzfxParams = Readonly<{
   zdelay: number;
   tremolo: number;
   random: () => number;
+  /** Note expression: a pitch offset in cents at `t` seconds. */
+  cents?: (t: number) => number;
+  /** The note glides, so `slide` and `deltaSlide` are ignored. */
+  slideOff?: boolean;
 }>;
 
 function wave(sound: string, phase: number, held: number): number {
@@ -98,14 +102,16 @@ export function renderZzfx(
     const t = index / sampleRate;
     // Slide and pitch jump restart every `lfo` seconds.
     const local = params.lfo > 0 ? t % params.lfo : t;
-    let frequency =
-      base +
-      500 * params.slide * local +
-      250 * params.deltaSlide * local * local;
+    let frequency = params.slideOff
+      ? base
+      : base +
+        500 * params.slide * local +
+        250 * params.deltaSlide * local * local;
     if (params.pitchJumpTime > 0 && local >= params.pitchJumpTime)
       frequency += params.pitchJump;
     if (params.zmod > 0)
       frequency *= 1 + 0.5 * Math.sin(2 * Math.PI * params.zmod * t);
+    if (params.cents) frequency *= 2 ** (params.cents(t) / 1200);
     frequency = clamp(frequency, 0, sampleRate / 2);
     let increment = frequency / sampleRate;
     if (params.noise > 0) increment *= 1 + params.noise * (random() * 2 - 1);

package/src/audio/warp.ts

@@ -0,0 +1,147 @@
+/**
+ * Sample positions through a song's tempo map (core/tempo.ts).
+ *
+ * Renderers keep their 0.4 arithmetic (`tick / samplesPerTick`) whenever
+ * `warp` is absent, which is every score without tempo events or
+ * fermatas, so those renders stay byte-identical. With a map, every tick
+ * to sample conversion goes through it instead.
+ */
+
+import { timeMapFor, type TimeScore } from "../../core/tempo.ts";
+
+export type SampleWarp = Readonly<{
+  /** Fractional sample index where `tick` sounds. */
+  sample(tick: number): number;
+  /** Score tick sounding at sample `index`. */
+  tick(index: number): number;
+  /** Tempo at `tick`. */
+  bpm(tick: number): number;
+}>;
+
+export function sampleWarpFor(
+  score: TimeScore,
+  sampleRate: number,
+): SampleWarp | undefined {
+  const map = timeMapFor(score);
+  if (!map) return undefined;
+  // Per-sample callers (automation, effects, sampler positions) read
+  // `tick` once per sample: evaluate the map once per block and interpolate
+  // between block edges. That is exact inside constant-tempo stretches,
+  // within a hair inside a ramp, and at most one block's ticks off across
+  // a step or fermata edge (about a tick at 48 kHz), for automation and
+  // modulation reads only: note onsets use `sample`, which stays exact.
+  let grid = new Float64Array(0);
+  let known = new Uint8Array(0);
+  const edge = (block: number): number => {
+    if (block >= grid.length) {
+      const size = Math.max(block + 1, grid.length * 2, 1024);
+      const nextGrid = new Float64Array(size);
+      const nextKnown = new Uint8Array(size);
+      nextGrid.set(grid);
+      nextKnown.set(known);
+      grid = nextGrid;
+      known = nextKnown;
+    }
+    if (known[block] === 0) {
+      grid[block] = map.tick((block * WARP_BLOCK) / sampleRate);
+      known[block] = 1;
+    }
+    return grid[block]!;
+  };
+  return Object.freeze({
+    sample: (tick: number) => map.seconds(tick) * sampleRate,
+    tick: (index: number) => {
+      if (!(index >= 0) || index > MAX_GRID_SAMPLES)
+        return map.tick(index / sampleRate);
+      const block = Math.floor(index / WARP_BLOCK);
+      const into = index - block * WARP_BLOCK;
+      const from = edge(block);
+      if (into === 0) return from;
+      return from + ((edge(block + 1) - from) * into) / WARP_BLOCK;
+    },
+    bpm: (tick: number) => map.bpm(tick),
+  });
+}
+
+/** Samples between exact `tick` evaluations; ticks in between interpolate. */
+export const WARP_BLOCK = 64;
+/** Past this sample index (about 3 h at 48 kHz) `tick` evaluates directly. */
+const MAX_GRID_SAMPLES = 2 ** 29;
+
+/**
+ * Start sample and length of a note through a warp: a note inside a
+ * fermata beat stretches with it.
+ */
+export function warpedSpan(
+  warp: SampleWarp,
+  startTick: number,
+  durationTicks: number,
+): { start: number; length: number } {
+  const from = warp.sample(startTick);
+  const to = warp.sample(startTick + durationTicks);
+  return {
+    start: Math.max(0, Math.floor(from)),
+    length: Math.max(1, Math.floor(to - from)),
+  };
+}
+
+/**
+ * A fitted sample window's position map (0.6 `bpm`/`len`/`fit`): output
+ * frames after the note start to window frames and back, both at the
+ * render rate. Through a tempo map the window follows ramps and steps;
+ * at constant tempo both directions are linear.
+ */
+export type FitMap = Readonly<{
+  /** Output frames the whole window takes. */
+  length: number;
+  /** Window frame sounding `e` output frames after the start. */
+  at(e: number): number;
+  /** Output frame (after the start) where window frame `p` sounds. */
+  outAt(p: number): number;
+}>;
+
+/**
+ * The map for a window of `frames` render-rate frames that advances
+ * `perBeat` window frames per song beat from `startTick`. Without a warp the
+ * song runs at `tempoBpm` throughout.
+ */
+export function beatFitMap(
+  warp: SampleWarp | undefined,
+  timing: Readonly<{
+    tempoBpm: number;
+    ticksPerBeat: number;
+    sampleRate: number;
+  }>,
+  startTick: number,
+  frames: number,
+  perBeat: number,
+): FitMap {
+  const { tempoBpm, ticksPerBeat, sampleRate } = timing;
+  if (!warp) {
+    const ratio = perBeat / ((sampleRate * 60) / tempoBpm);
+    return Object.freeze({
+      length: frames / ratio,
+      at: (e: number) => e * ratio,
+      outAt: (p: number) => p / ratio,
+    });
+  }
+  const origin = warp.sample(startTick);
+  const outAt = (p: number) =>
+    warp.sample(startTick + (p / perBeat) * ticksPerBeat) - origin;
+  return Object.freeze({
+    length: outAt(frames),
+    at: (e: number) =>
+      ((warp.tick(origin + e) - startTick) / ticksPerBeat) * perBeat,
+    outAt,
+  });
+}
+
+/** `fit`: the window fills `held` output frames, linearly. */
+export function spanFitMap(frames: number, held: number): FitMap {
+  const ratio = frames / Math.max(1, held);
+  return Object.freeze({
+    length: held,
+    at: (e: number) => e * ratio,
+    outAt: (p: number) => p / ratio,
+  });
+}