@hraness/dawg 0.5.0 → 0.6.1

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

@@ -0,0 +1,78 @@
+/**
+ * One oversampler per nonlinear rig section (stomp, head): 4x at 22.05 kHz
+ * and below, 2x at 44.1/48 kHz, from the shared half-band primitives in
+ * src/audio/dsp/oversample.ts. The section's linear-phase delay is removed
+ * so a rigged track stays on the grid.
+ */
+import { Adaa1, logCosh } from "../../dsp/shape.ts";
+import { Oversample2x, Oversample4x } from "../../dsp/oversample.ts";
+
+/** Oversampling factor of a nonlinear section at `sampleRate`. */
+export function sectionFactor(sampleRate: number): 2 | 4 {
+  return sampleRate <= 32_000 ? 4 : 2;
+}
+
+type Oversampler = { process(x: number, fn: (x: number) => number): number };
+
+function oversampler(factor: 2 | 4): Oversampler {
+  return factor === 4 ? new Oversample4x() : new Oversample2x();
+}
+
+const latencies = new Map<number, number>();
+
+/** Base-rate delay of the up/down pair (impulse peak), measured once. */
+export function sectionLatency(factor: 2 | 4): number {
+  const known = latencies.get(factor);
+  if (known !== undefined) return known;
+  const os = oversampler(factor);
+  let peak = 0;
+  let at = 0;
+  for (let i = 0; i < 256; i += 1) {
+    const y = Math.abs(os.process(i === 0 ? 1 : 0, (x) => x));
+    if (y > peak) {
+      peak = y;
+      at = i;
+    }
+  }
+  latencies.set(factor, at);
+  return at;
+}
+
+/**
+ * Runs `fn` over `buffer` at the oversampled rate, in place and latency
+ * compensated. `control(i)` runs at the base rate before sample i.
+ */
+export function runSection(
+  buffer: Float64Array,
+  factor: 2 | 4,
+  fn: (x: number) => number,
+  control?: (index: number) => void,
+): void {
+  const os = oversampler(factor);
+  const latency = sectionLatency(factor);
+  const n = buffer.length;
+  for (let i = 0; i < n + latency; i += 1) {
+    if (control && i < n) control(i);
+    const y = os.process(i < n ? buffer[i]! : 0, fn);
+    if (i >= latency) buffer[i - latency] = y;
+  }
+}
+
+// Static curves with closed-form antiderivatives for first-order ADAA.
+
+/** Triode-like asymmetry: the positive half clips harder (grid current). */
+const ASYM_B = 0.35;
+const ASYM_T = Math.tanh(ASYM_B);
+const asymF = (x: number) => Math.tanh(x + ASYM_B) - ASYM_T;
+const asymAF = (x: number) => logCosh(x + ASYM_B) - ASYM_T * x;
+
+export const adaaTanh = () => new Adaa1(Math.tanh, logCosh);
+export const adaaTriode = () => new Adaa1(asymF, asymAF);
+/** Full-wave rectifier (octave up): |x|, antiderivative x|x|/2. */
+export const adaaRectify = () =>
+  new Adaa1(
+    (x) => Math.abs(x),
+    (x) => 0.5 * x * Math.abs(x),
+  );
+/** RAT diode pair: tanh of a cubic-boosted input (no closed-form F). */
+export const ratClip = (x: number) => Math.tanh(x + 0.18 * x * x * x);

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

@@ -0,0 +1,238 @@
+/**
+ * Stomp boxes (`fx.stomp`): fuzz (Big Muff family), face (Fuzz Face), od
+ * (Tube Screamer), rat (RAT) and octave (Octavia). Circuit-inspired
+ * per-sample models ported from the 0.6 guitar prototype, run inside one
+ * oversampler with ADAA shapers.
+ */
+import type { Adaa1 } from "../../dsp/shape.ts";
+import { Dc, Hp1, Lp1, clamp, dbToGain } from "./filters.ts";
+import {
+  adaaRectify,
+  adaaTanh,
+  adaaTriode,
+  ratClip,
+  runSection,
+} from "./section.ts";
+
+export const STOMP_TYPES = ["fuzz", "face", "od", "rat", "octave"] as const;
+export type StompType = (typeof STOMP_TYPES)[number];
+
+export type StompSettings = {
+  gain: number;
+  tone: number;
+  level: number;
+  octave: number;
+};
+
+/** A stomp circuit at the oversampled rate `sr`. */
+export type StompCircuit = {
+  process(x: number): number;
+  /** Re-reads gain, tone and level (control rate, automated only). */
+  set(settings: StompSettings): void;
+};
+
+export function stompCircuit(
+  type: string,
+  initial: StompSettings,
+  sr: number,
+): StompCircuit {
+  switch (type) {
+    case "fuzz":
+      return fuzz(initial, sr);
+    case "face":
+      return face(initial, sr);
+    case "rat":
+      return rat(initial, sr);
+    case "octave":
+      return octave(initial, sr);
+    default:
+      return od(initial, sr);
+  }
+}
+
+function fuzz(initial: StompSettings, sr: number): StompCircuit {
+  // Input HPF, two cascaded clipping stages with interstage lowpass, then
+  // the passive LP/HP tone blend (the Muff's mid scoop).
+  const hp = new Hp1(90, sr);
+  const s1 = adaaTanh();
+  const s2 = adaaTanh();
+  const lpA = new Lp1(3200, sr);
+  const hpB = new Hp1(60, sr);
+  const lpB = new Lp1(2600, sr);
+  const toneLp = new Lp1(800, sr);
+  const toneHp = new Hp1(1600, sr);
+  let pre = 1;
+  let tone = 0.5;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 2 ** (0.5 + 0.55 * p.gain);
+    tone = clamp(p.tone, 0, 1);
+    out = dbToGain(p.level) * 0.7;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      let x = hp.process(input) * pre;
+      x = lpA.process(s1.process(x)) * 6;
+      x = lpB.process(s2.process(hpB.process(x)));
+      const y = (1 - tone) * toneLp.process(x) + tone * toneHp.process(x) * 1.6;
+      return y * out;
+    },
+  };
+}
+
+function face(initial: StompSettings, sr: number): StompCircuit {
+  // Asymmetric and round; cleans up as the input drops.
+  const hp = new Hp1(40, sr);
+  const s = adaaTriode();
+  const dc = new Dc(sr, 12);
+  const lp = new Lp1(2500, sr);
+  let pre = 1;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 2 ** (0.3 + 0.5 * p.gain);
+    lp.set(2500 + 4000 * clamp(p.tone, 0, 1), sr);
+    out = dbToGain(p.level) * 0.8;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      return lp.process(dc.process(s.process(hp.process(input) * pre))) * out;
+    },
+  };
+}
+
+function od(initial: StompSettings, sr: number): StompCircuit {
+  // Clean path plus a soft-clipped 720 Hz high-passed gain path (diodes in
+  // the op-amp feedback), then the tone lowpass.
+  const hp = new Hp1(720, sr);
+  const lpGain = new Lp1(5600, sr);
+  const s = adaaTanh();
+  const tone = new Lp1(700, sr);
+  let pre = 1;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 1 + 10 ** (p.gain / 5);
+    tone.set(700 * 2 ** (3 * clamp(p.tone, 0, 1)), sr);
+    out = dbToGain(p.level) * 0.6;
+  };
+  set(initial);
+  return {
+    set,
+    process(x) {
+      const y = x + s.process(lpGain.process(hp.process(x) * pre)) * 0.5;
+      return tone.process(y) * out;
+    },
+  };
+}
+
+function rat(initial: StompSettings, sr: number): StompCircuit {
+  // Op-amp gain whose bandwidth shrinks with gain (LM308 GBW), hard diode
+  // clip to ground, then the passive filter.
+  const hp = new Hp1(60, sr);
+  const lpOp = new Lp1(20_000, sr);
+  const filter = new Lp1(475, sr);
+  let gain = 1;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    gain = Math.min(1 + 2 ** (0.67 * p.gain + 1.5), 2000);
+    lpOp.set(clamp(1.0e6 / 3 / gain, 900, 20_000), sr);
+    filter.set(475 * 2 ** (6 * clamp(p.tone, 0, 1)), sr);
+    out = dbToGain(p.level) * 0.55;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      const x = lpOp.process(hp.process(input) * gain * 0.02);
+      return filter.process(ratClip(x)) * out;
+    },
+  };
+}
+
+function octave(initial: StompSettings, sr: number): StompCircuit {
+  // Rectified (octave-up) path blended into a fuzz.
+  const hp = new Hp1(120, sr);
+  const rect: Adaa1 = adaaRectify();
+  const dc = new Dc(sr, 20);
+  const s = adaaTanh();
+  const lp = new Lp1(3000, sr);
+  let pre = 1;
+  let mix = 0.7;
+  let out = 1;
+  const set = (p: StompSettings) => {
+    pre = 2 ** (0.5 + 0.5 * p.gain);
+    lp.set(3000 + 4000 * clamp(p.tone, 0, 1), sr);
+    mix = clamp(p.octave, 0, 1);
+    out = dbToGain(p.level) * 0.7;
+  };
+  set(initial);
+  return {
+    set,
+    process(input) {
+      const x = hp.process(input);
+      const o = dc.process(rect.process(x * 2)) * 2;
+      return lp.process(s.process(((1 - mix) * x + mix * o) * pre)) * out;
+    },
+  };
+}
+
+/** Stomp calibration input: a 196 Hz (G3) sine at guitar level. */
+export const STOMP_CALIBRATION_DBFS = -18;
+
+const stompMakeups = new Map<string, number>();
+
+/**
+ * Linear gain that brings a pedal at `settings` (level taken as 0 dB) back
+ * to the calibration sine's level, so switching or kicking on a stomp does
+ * not jump the track by 15-25 dB; `level` stays a trim on top. Measured on
+ * the circuit itself, deterministic, cached per settings and rate.
+ */
+export function stompMakeup(
+  type: string,
+  settings: StompSettings,
+  sampleRate: number,
+  factor: 2 | 4,
+): number {
+  const key = `${sampleRate}|${factor}|${type}|${settings.gain}|${settings.tone}|${settings.octave}`;
+  const known = stompMakeups.get(key);
+  if (known !== undefined) return known;
+  const amplitude = 10 ** (STOMP_CALIBRATION_DBFS / 20) * Math.SQRT2;
+  const settle = Math.round(sampleRate * 0.1);
+  const length = settle + Math.round(sampleRate * 0.1);
+  const buffer = new Float64Array(length);
+  const w = (2 * Math.PI * 196) / sampleRate;
+  for (let i = 0; i < length; i += 1) buffer[i] = amplitude * Math.sin(w * i);
+  const circuit = stompCircuit(
+    type,
+    { ...settings, level: 0 },
+    sampleRate * factor,
+  );
+  runSection(buffer, factor, (x) => circuit.process(x));
+  let sum = 0;
+  for (let i = settle; i < length; i += 1) sum += buffer[i]! * buffer[i]!;
+  const rms = Math.sqrt(sum / (length - settle));
+  const target = 10 ** (STOMP_CALIBRATION_DBFS / 20);
+  const makeup = rms > 1e-12 ? target / rms : 1;
+  stompMakeups.set(key, makeup);
+  if (stompMakeups.size > 4096)
+    stompMakeups.delete(stompMakeups.keys().next().value!);
+  return makeup;
+}
+
+/** Makeup for an automated gain: linear between whole steps. */
+export function stompMakeupAt(
+  type: string,
+  settings: StompSettings,
+  sampleRate: number,
+  factor: 2 | 4,
+): number {
+  const g = clamp(settings.gain, 0, 10);
+  const g0 = Math.min(9, Math.floor(g));
+  const at = (gain: number) =>
+    stompMakeup(type, { ...settings, gain }, sampleRate, factor);
+  const a = at(g0);
+  return a + (at(g0 + 1) - a) * (g - g0);
+}

package/src/audio/engine.ts

@@ -9,6 +9,7 @@ import {
   type ClickLevel,
 } from "./click.ts";
 import type { LiveNotePcm } from "./live.ts";
+import { RING_OUT_FADE_SECONDS } from "./instruments.ts";
 import { measureLoudness, pcmChannels } from "./loudness.ts";
 import type { MasterReport } from "./master.ts";
 import { levelOf, type SoundLevel } from "./preview.ts";
@@ -308,8 +309,16 @@ type LiveVoice = {
   /** Fade-out frames left once released early; undefined while sounding. */
   fadeLeft: number | undefined;
   fadeFrames: number;
+  /** Rings to its end on note-off (0.6.1 modal ring-out). */
+  ringOut?: boolean;
 };
 
+/**
+ * At most this many ring-out voices sound at once; the oldest beyond it fades
+ * over `RING_OUT_FADE_SECONDS` (spec 7.3: 32 resonator voices).
+ */
+export const MAX_RING_OUT_VOICES = 32;
+
 type PlayRequest = {
   score: TrackScore;
   beat: number | undefined;
@@ -530,25 +539,66 @@ export class AudioEngine {
       existing.pcm = note.pcm;
       existing.frames = note.frames;
       existing.fadeLeft = undefined;
-    } else
+      existing.fadeFrames = this.releaseFrames(note);
+      existing.ringOut = note.ringOut === true;
+    } else {
       this.voices.set(id, {
         pcm: note.pcm,
         frames: note.frames,
         position: 0,
         fadeLeft: undefined,
-        fadeFrames: Math.max(1, Math.round(this.sampleRate * 0.01)),
+        fadeFrames: this.releaseFrames(note),
+        ...(note.ringOut ? { ringOut: true } : {}),
       });
+      if (note.ringOut) this.capRingOut();
+    }
     // Write what is due now so the voice joins the very next chunk.
     const first = this.written;
     this.pump();
     return this.frameMs(first);
   }
 
-  /** Fade a live voice out over ~10 ms (sustain lifted, mode left). */
-  public noteOff(id: number): void {
+  /** A live voice's note-off fade: 10 ms, or the instrument's release. */
+  private releaseFrames(note: LiveNotePcm): number {
+    return Math.max(
+      1,
+      Math.round(this.sampleRate * (note.releaseSeconds ?? 0.01)),
+    );
+  }
+
+  /**
+   * Past `MAX_RING_OUT_VOICES` ringing voices, fade the oldest still at full
+   * level over `RING_OUT_FADE_SECONDS` (Map order is start order).
+   */
+  private capRingOut(): void {
+    let ringing = 0;
+    for (const voice of this.voices.values())
+      if (voice.ringOut && voice.fadeLeft === undefined) ringing += 1;
+    for (const voice of this.voices.values()) {
+      if (ringing <= MAX_RING_OUT_VOICES) break;
+      if (!voice.ringOut || voice.fadeLeft !== undefined) continue;
+      this.fadeRingOut(voice);
+      ringing -= 1;
+    }
+  }
+
+  private fadeRingOut(voice: LiveVoice): void {
+    voice.fadeFrames = Math.max(
+      1,
+      Math.round(this.sampleRate * RING_OUT_FADE_SECONDS),
+    );
+    voice.fadeLeft = voice.fadeFrames;
+  }
+
+  /**
+   * Fade a live voice out over ~10 ms (sustain lifted, mode left). A
+   * ring-out voice keeps ringing; `noteOff(id, true)` silences it too.
+   */
+  public noteOff(id: number, force = false): void {
     const voice = this.voices.get(id);
-    if (voice && voice.fadeLeft === undefined)
-      voice.fadeLeft = voice.fadeFrames;
+    if (!voice || voice.fadeLeft !== undefined) return;
+    if (!voice.ringOut) voice.fadeLeft = voice.fadeFrames;
+    else if (force) this.fadeRingOut(voice);
   }
 
   /** Frames of live voice `id` already mixed, or undefined once finished. */