@hraness/dawg 0.4.1 → 0.6.0

package/src/audio/effects/bus.ts

@@ -17,6 +17,7 @@ import type { Track } from "../../../core/score.ts";
 import {
   CONTROL_SAMPLES,
   interpolateAutomation,
+  tickAtSample,
   type EffectContext,
 } from "./common.ts";
 import { applyDelay, applyReverb } from "./space.ts";
@@ -58,13 +59,13 @@ function send(
   stemR: Float64Array,
   base: number,
   lane: readonly Readonly<{ tick: number; value: number }>[],
-  samplesPerTick: number,
+  context: Pick<EffectContext, "samplesPerTick" | "warp">,
 ): void {
   if (base <= 0 && lane.length === 0) return;
   let level = base;
   for (let index = 0; index < outL.length; index += 1) {
     if (lane.length > 0 && index % CONTROL_SAMPLES === 0)
-      level = interpolateAutomation(lane, index / samplesPerTick, base);
+      level = interpolateAutomation(lane, tickAtSample(context, index), base);
     outL[index]! += stemL[index]! * level;
     outR[index]! += stemR[index]! * level;
   }
@@ -89,7 +90,7 @@ export function sendToBus(
       stemR,
       track.delay.mix,
       track.delayMixAutomation ?? [],
-      context.samplesPerTick,
+      context,
     );
   }
   if (track.reverb) {
@@ -101,7 +102,7 @@ export function sendToBus(
       stemR,
       track.reverb.mix,
       track.fxAutomation?.["reverb-mix"] ?? [],
-      context.samplesPerTick,
+      context,
     );
   }
 }

package/src/audio/effects/chain.ts

@@ -1,7 +1,8 @@
 /**
  * The fixed per-track effects chain (`FX_CHAIN` in core/fx.ts):
  *
- *   filter → djf → autofilter → vowel → crush → distort → tremolo →
+ *   filter → djf → autofilter → vowel → crush → distort → stomp → head →
+ *   cab → tremolo →
  *   compressor → pan → phaser → chorus → leslie → postgain → delay → reverb
  *
  * Stages before pan run on the mono voice sum; pan spreads it to stereo;
@@ -19,6 +20,7 @@ import {
   applyVowel,
 } from "./filter.ts";
 import { applyChorus, applyLeslie, applyPhaser } from "./modulation.ts";
+import { applyCab, applyHead, applyStomp } from "./rig/index.ts";
 import { applyDelay, applyReverb } from "./space.ts";
 
 export {
@@ -52,6 +54,9 @@ const MONO: Readonly<Partial<Record<FxName, MonoStage>>> = Object.freeze({
   vowel: applyVowel,
   crush: applyCrush,
   distort: applyDistort,
+  stomp: applyStomp,
+  head: applyHead,
+  cab: applyCab,
   tremolo: applyTremolo,
   compressor: applyCompressor,
 });

package/src/audio/effects/common.ts

@@ -12,6 +12,7 @@
 import type { AutomationPoint, Track } from "../../../core/score.ts";
 import type { FxLane, FxValues } from "../../../core/fx.ts";
 import type { DecodedSample } from "../samples.ts";
+import type { SampleWarp } from "../warp.ts";
 
 /** Effect parameters are refreshed at this sample interval. */
 export const CONTROL_SAMPLES = 32;
@@ -22,8 +23,34 @@ export type EffectContext = Readonly<{
   tempoBpm: number;
   /** Decoded `reverb.ir` samples by track id (built-in impulses need none). */
   irs?: ReadonlyMap<string, DecodedSample>;
+  /** The song's tempo map in samples; absent: constant tempo. */
+  warp?: SampleWarp;
 }>;
 
+/** Score tick at sample `index`, through the tempo map when there is one. */
+export function tickAtSample(
+  context: Pick<EffectContext, "samplesPerTick" | "warp">,
+  index: number,
+): number {
+  return context.warp
+    ? context.warp.tick(index)
+    : index / context.samplesPerTick;
+}
+
+/**
+ * Tempo at sample `index` for tempo-synced LFOs and delays: through the
+ * tempo map when there is one (ramps, steps and fermata holds included),
+ * else the song's constant tempo.
+ */
+export function tempoAtSample(
+  context: Pick<EffectContext, "tempoBpm" | "warp">,
+  index: number,
+): number {
+  return context.warp
+    ? context.warp.bpm(context.warp.tick(index))
+    : context.tempoBpm;
+}
+
 /** Resolve a piecewise-linear automation lane, holding the static value before its first point. */
 export function interpolateAutomation(
   points: readonly AutomationPoint[],
@@ -58,6 +85,7 @@ export class Param {
     readonly fallback: number,
     points: readonly AutomationPoint[] | undefined,
     private readonly samplesPerTick: number,
+    private readonly warp?: SampleWarp,
   ) {
     this.points = points ?? [];
     this.automated = this.points.length > 0;
@@ -67,7 +95,7 @@ export class Param {
     return this.automated
       ? interpolateAutomation(
           this.points,
-          index / this.samplesPerTick,
+          this.warp ? this.warp.tick(index) : index / this.samplesPerTick,
           this.fallback,
         )
       : this.fallback;
@@ -93,6 +121,7 @@ export function fxReader(
         values[name] as number,
         track.fxAutomation?.[`${effect}-${name}` as FxLane],
         context.samplesPerTick,
+        context.warp,
       );
     },
   };

package/src/audio/effects/dynamics.ts

@@ -10,6 +10,7 @@ import {
   fxReader,
   lfo,
   lfoHz,
+  tempoAtSample,
   type EffectContext,
 } from "./common.ts";
 
@@ -42,7 +43,7 @@ export function applyTremolo(
   for (let index = 0; index < buffer.length; index += 1) {
     if (index % CONTROL_SAMPLES === 0) {
       phasor.setHz(
-        lfoHz(sync, rate.at(index), context.tempoBpm),
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
         context.sampleRate,
       );
       if (depth.automated) amount = depth.at(index);

package/src/audio/effects/filter.ts

@@ -15,7 +15,9 @@ import {
   interpolateAutomation,
   lfo,
   lfoHz,
+  tempoAtSample,
   resonanceQ,
+  tickAtSample,
   type EffectContext,
   type FilterType,
 } from "./common.ts";
@@ -99,7 +101,7 @@ export function applyTrackFilter(
   const resonanceLane = track.resonanceAutomation ?? [];
   if (!track.filter && automation.length === 0 && resonanceLane.length === 0)
     return;
-  const { sampleRate, samplesPerTick } = context;
+  const { sampleRate } = context;
   const staticCutoff = track.filter?.cutoff ?? SCORE_LIMITS.maxFilterCutoff;
   const staticResonance = track.filter?.resonance ?? 0;
   const automated = automation.length > 0 || resonanceLane.length > 0;
@@ -111,7 +113,7 @@ export function applyTrackFilter(
   filter.update(staticCutoff, staticResonance);
   for (let index = 0; index < buffer.length; index += 1) {
     if (automated && index % CONTROL_SAMPLES === 0) {
-      const tick = index / samplesPerTick;
+      const tick = tickAtSample(context, index);
       filter.update(
         interpolateAutomation(automation, tick, staticCutoff),
         interpolateAutomation(resonanceLane, tick, staticResonance),
@@ -205,7 +207,7 @@ export function applyAutoFilter(
         : release * envelope + (1 - release) * level;
     if (index % CONTROL_SAMPLES === 0) {
       phasor.setHz(
-        lfoHz(sync, rate.at(index), context.tempoBpm),
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
         context.sampleRate,
       );
       followOctaves = follow.at(index);

package/src/audio/effects/modulation.ts

@@ -9,6 +9,7 @@ import {
   clamp,
   fxReader,
   lfoHz,
+  tempoAtSample,
   readFractional,
   type EffectContext,
 } from "./common.ts";
@@ -57,7 +58,10 @@ export function applyPhaser(
   };
   for (let index = 0; index < left.length; index += 1) {
     if (index % CONTROL_SAMPLES === 0) {
-      phasor.setHz(lfoHz(sync, rate.at(index), context.tempoBpm), sampleRate);
+      phasor.setHz(
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
+        sampleRate,
+      );
       if (depth.automated) amount = depth.at(index);
       const frequency = clamp(
         center + (sweep / 2) * Math.sin(2 * Math.PI * phasor.phase),

package/src/audio/effects/rig/cab.ts

@@ -0,0 +1,99 @@
+/**
+ * Speaker cabinets (`fx.cab`): a parametric speaker, box and microphone
+ * model from cheap biquads (no impulse response, no setup cost). Ported
+ * from the 0.6 guitar prototype; `8x10`, `1x15` and `di` are dawg
+ * additions in the same model.
+ */
+import { Rbj, clamp } from "./filters.ts";
+
+export const CAB_TYPES = [
+  "1x12",
+  "2x12",
+  "4x12",
+  "1x10",
+  "open",
+  "8x10",
+  "1x15",
+  "di",
+] as const;
+export type CabType = (typeof CAB_TYPES)[number];
+
+type CabModel = Readonly<{
+  hp: number;
+  /** Low resonance: Hz, Q, dB. */
+  low: readonly [number, number, number];
+  peaks: readonly (readonly [number, number, number])[];
+  /** Speaker roll-off (two biquads, Butterworth 4th order); 0 = none. */
+  lp: number;
+}>;
+
+const CABS: Record<CabType, CabModel> = {
+  "1x12": {
+    hp: 75,
+    low: [115, 1.4, 3],
+    peaks: [
+      [2100, 2, 3],
+      [3600, 3, 2],
+    ],
+    lp: 5200,
+  },
+  "2x12": {
+    hp: 70,
+    low: [105, 1.3, 3.5],
+    peaks: [
+      [1200, 1.5, -2],
+      [2800, 2.2, 4.5],
+    ],
+    lp: 6200,
+  },
+  "4x12": {
+    hp: 65,
+    low: [95, 1.2, 5],
+    peaks: [
+      [700, 1, -2.5],
+      [2400, 2, 4],
+      [3900, 3, 2],
+    ],
+    lp: 4700,
+  },
+  "1x10": { hp: 120, low: [160, 1.5, 2], peaks: [[1500, 1.5, 3]], lp: 4300 },
+  open: { hp: 90, low: [120, 0.9, 1], peaks: [[2500, 1.2, 2]], lp: 7000 },
+  // Bass cabinets: deep, rolled off early (10s brighter than a 15).
+  "8x10": {
+    hp: 45,
+    low: [80, 1.0, 3],
+    peaks: [
+      [800, 1.2, -2],
+      [2500, 2, 3],
+    ],
+    lp: 4500,
+  },
+  "1x15": {
+    hp: 40,
+    low: [70, 1.2, 4],
+    peaks: [
+      [1000, 1, -1.5],
+      [2000, 1.5, 2],
+    ],
+    lp: 3500,
+  },
+  // Direct in: no speaker, only a subsonic high-pass.
+  di: { hp: 20, low: [100, 0.7, 0], peaks: [], lp: 0 },
+};
+
+/** The cab's filter chain at `sr` for mic position `mic` (0..1). */
+export function cabFilters(type: string, mic: number, sr: number): Rbj[] {
+  const m = CABS[type as CabType] ?? CABS["2x12"];
+  if (m.lp === 0) return [new Rbj("hpf", m.hp, 0.707, sr)];
+  const edge = clamp(mic, 0, 1);
+  return [
+    new Rbj("hpf", m.hp, 0.707, sr),
+    new Rbj("peak", m.low[0], m.low[1], sr, m.low[2]),
+    ...m.peaks.map(
+      ([f, q, db]) => new Rbj("peak", f, q, sr, db * (1 - 0.6 * edge)),
+    ),
+    new Rbj("highshelf", 3000, 0.7, sr, 2 - 8 * edge),
+    new Rbj("lpf", m.lp * (1 - 0.3 * edge), 0.54, sr),
+    new Rbj("lpf", m.lp * (1 - 0.3 * edge), 1.31, sr),
+  ];
+}

package/src/audio/effects/rig/filters.ts

@@ -0,0 +1,152 @@
+/**
+ * Filters for the guitar rig: the full RBJ cookbook biquad (peaks and
+ * shelves, which the effects chain's `Biquad` does not offer) and a
+ * one-pole high-pass. Ported from the 0.6 guitar prototype; a new class so
+ * the shared `Biquad` is never retuned.
+ */
+
+export function clamp(x: number, lo: number, hi: number): number {
+  return x < lo ? lo : x > hi ? hi : x;
+}
+
+export function dbToGain(db: number): number {
+  return 10 ** (db / 20);
+}
+
+export type RbjType = "lpf" | "hpf" | "peak" | "lowshelf" | "highshelf";
+
+/** RBJ Audio EQ Cookbook biquad, transposed direct form II. */
+export class Rbj {
+  b0 = 1;
+  b1 = 0;
+  b2 = 0;
+  a1 = 0;
+  a2 = 0;
+  z1 = 0;
+  z2 = 0;
+
+  constructor(type: RbjType, hz: number, q: number, sr: number, db = 0) {
+    this.set(type, hz, q, sr, db);
+  }
+
+  set(type: RbjType, hz: number, q: number, sr: number, db = 0): void {
+    const w = (2 * Math.PI * clamp(hz, 10, sr * 0.49)) / sr;
+    const cw = Math.cos(w);
+    const alpha = Math.sin(w) / (2 * q);
+    const A = 10 ** (db / 40);
+    let b0: number, b1: number, b2: number, a0: number, a1: number, a2: number;
+    switch (type) {
+      case "lpf":
+        b0 = (1 - cw) / 2;
+        b1 = 1 - cw;
+        b2 = b0;
+        a0 = 1 + alpha;
+        a1 = -2 * cw;
+        a2 = 1 - alpha;
+        break;
+      case "hpf":
+        b0 = (1 + cw) / 2;
+        b1 = -(1 + cw);
+        b2 = b0;
+        a0 = 1 + alpha;
+        a1 = -2 * cw;
+        a2 = 1 - alpha;
+        break;
+      case "peak":
+        b0 = 1 + alpha * A;
+        b1 = -2 * cw;
+        b2 = 1 - alpha * A;
+        a0 = 1 + alpha / A;
+        a1 = -2 * cw;
+        a2 = 1 - alpha / A;
+        break;
+      case "lowshelf": {
+        const s = 2 * Math.sqrt(A) * alpha;
+        b0 = A * (A + 1 - (A - 1) * cw + s);
+        b1 = 2 * A * (A - 1 - (A + 1) * cw);
+        b2 = A * (A + 1 - (A - 1) * cw - s);
+        a0 = A + 1 + (A - 1) * cw + s;
+        a1 = -2 * (A - 1 + (A + 1) * cw);
+        a2 = A + 1 + (A - 1) * cw - s;
+        break;
+      }
+      case "highshelf": {
+        const s = 2 * Math.sqrt(A) * alpha;
+        b0 = A * (A + 1 + (A - 1) * cw + s);
+        b1 = -2 * A * (A - 1 + (A + 1) * cw);
+        b2 = A * (A + 1 + (A - 1) * cw - s);
+        a0 = A + 1 - (A - 1) * cw + s;
+        a1 = 2 * (A - 1 - (A + 1) * cw);
+        a2 = A + 1 - (A - 1) * cw - s;
+        break;
+      }
+    }
+    this.b0 = b0 / a0;
+    this.b1 = b1 / a0;
+    this.b2 = b2 / a0;
+    this.a1 = a1 / a0;
+    this.a2 = a2 / a0;
+  }
+
+  process(x: number): number {
+    const y = this.b0 * x + this.z1;
+    this.z1 = this.b1 * x - this.a1 * y + this.z2;
+    this.z2 = this.b2 * x - this.a2 * y;
+    return y;
+  }
+}
+
+/** One-pole low-pass y = x + p (y - x). */
+export class Lp1 {
+  p = 0;
+  y = 0;
+
+  constructor(hz: number, sr: number) {
+    this.set(hz, sr);
+  }
+
+  set(hz: number, sr: number): void {
+    this.p = Math.exp((-2 * Math.PI * clamp(hz, 1, sr * 0.49)) / sr);
+  }
+
+  process(x: number): number {
+    this.y = x + this.p * (this.y - x);
+    return this.y;
+  }
+}
+
+/** One-pole high-pass (leaky differentiator). */
+export class Hp1 {
+  p = 0;
+  x1 = 0;
+  y1 = 0;
+
+  constructor(hz: number, sr: number) {
+    this.p = Math.exp((-2 * Math.PI * clamp(hz, 1, sr * 0.49)) / sr);
+  }
+
+  process(x: number): number {
+    const y = ((1 + this.p) / 2) * (x - this.x1) + this.p * this.y1;
+    this.x1 = x;
+    this.y1 = y;
+    return y;
+  }
+}
+
+/** DC blocker y = x - x1 + R y1. */
+export class Dc {
+  r: number;
+  x1 = 0;
+  y1 = 0;
+
+  constructor(sr: number, hz: number) {
+    this.r = Math.exp((-2 * Math.PI * hz) / sr);
+  }
+
+  process(x: number): number {
+    const y = x - this.x1 + this.r * this.y1;
+    this.x1 = x;
+    this.y1 = y;
+    return y;
+  }
+}

package/src/audio/effects/rig/gate.ts

@@ -0,0 +1,39 @@
+/**
+ * Noise gate before the amp (`fx.head.gate`): a peak follower with
+ * hysteresis (opens at the threshold, closes 6 dB below it), a 50 ms hold,
+ * 1 ms attack and 80 ms release, so a high-gain head does not amplify the
+ * hiss and string noise between notes.
+ */
+export const GATE_HYSTERESIS_DB = 6;
+
+export function applyGate(
+  buffer: Float64Array,
+  thresholdDb: number,
+  sampleRate: number,
+): void {
+  const open = 10 ** (thresholdDb / 20);
+  const close = 10 ** ((thresholdDb - GATE_HYSTERESIS_DB) / 20);
+  const peakRelease = Math.exp(-1 / (0.01 * sampleRate));
+  const attack = 1 - Math.exp(-1 / (0.001 * sampleRate));
+  const release = 1 - Math.exp(-1 / (0.08 * sampleRate));
+  const holdSamples = Math.round(0.05 * sampleRate);
+  let peak = 0;
+  let gain = 0;
+  let isOpen = false;
+  let hold = 0;
+  for (let i = 0; i < buffer.length; i += 1) {
+    const x = buffer[i]!;
+    const level = Math.abs(x);
+    peak = level > peak ? level : peak * peakRelease;
+    if (peak >= open) {
+      isOpen = true;
+      hold = holdSamples;
+    } else if (peak < close) {
+      if (hold > 0) hold -= 1;
+      else isOpen = false;
+    }
+    const target = isOpen ? 1 : 0;
+    gain += (target - gain) * (target > gain ? attack : release);
+    buffer[i] = x * gain;
+  }
+}