@hraness/dawg 0.5.0 → 0.6.0

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;
+  }
+}