@hraness/dawg 0.6.1 → 0.7.0

package/src/audio/dsp/formant.ts

@@ -0,0 +1,427 @@
+/**
+ * Vowel formant tables shared by the `vowel` filter (and, from the sing
+ * lane, the Klatt cascade): frequency (Hz), level (dB) and bandwidth (Hz)
+ * per formant, plus a log-frequency morph between two vowels.
+ */
+
+export type Formants = readonly (readonly [number, number, number])[];
+
+/**
+ * Formant frequency (Hz), level (dB) and bandwidth (Hz). The five plain
+ * vowels use the classic tenor formant table (published acoustic
+ * phonetics data); the extended set approximates F1–F3 from standard
+ * vowel charts with tenor-typical F4/F5.
+ */
+export const VOWEL_FORMANTS: Readonly<Record<string, Formants>> = Object.freeze(
+  {
+    a: [
+      [650, 0, 80],
+      [1080, -6, 90],
+      [2650, -7, 120],
+      [2900, -8, 130],
+      [3250, -22, 140],
+    ],
+    e: [
+      [400, 0, 70],
+      [1700, -14, 80],
+      [2600, -12, 100],
+      [3200, -14, 120],
+      [3580, -20, 120],
+    ],
+    i: [
+      [290, 0, 40],
+      [1870, -15, 90],
+      [2800, -18, 100],
+      [3250, -20, 120],
+      [3540, -30, 120],
+    ],
+    o: [
+      [400, 0, 40],
+      [800, -10, 80],
+      [2600, -12, 100],
+      [2800, -12, 120],
+      [3000, -26, 120],
+    ],
+    u: [
+      [350, 0, 40],
+      [600, -20, 60],
+      [2700, -17, 100],
+      [2900, -14, 120],
+      [3300, -26, 120],
+    ],
+    ae: extended(660, 1720, 2410),
+    aa: extended(710, 1100, 2540),
+    oe: extended(390, 1680, 2400),
+    ue: extended(300, 1600, 2200),
+    y: extended(250, 1750, 2160),
+    uh: extended(600, 1170, 2390),
+    un: extended(500, 1400, 2500),
+    en: extended(550, 1650, 2500),
+    an: extended(650, 1050, 2550),
+    on: extended(450, 850, 2550),
+  },
+);
+
+function extended(f1: number, f2: number, f3: number): Formants {
+  return [
+    [f1, 0, 70],
+    [f2, -8, 90],
+    [f3, -14, 110],
+    [3300, -16, 130],
+    [3750, -24, 140],
+  ];
+}
+
+/**
+ * Formants `morph` (0..1) of the way from `from` to `to`: frequency and
+ * bandwidth interpolate on a log scale (equal steps sound equal), level in
+ * dB. 0 returns `from`'s values exactly, 1 returns `to`'s.
+ */
+export function morphFormants(
+  from: Formants,
+  to: Formants,
+  morph: number,
+): Array<[number, number, number]> {
+  const m = Math.min(1, Math.max(0, morph));
+  return from.map(([hz, level, bw], index) => {
+    if (m === 0) return [hz, level, bw];
+    const [toHz, toLevel, toBw] = to[index] ?? [hz, level, bw];
+    if (m === 1) return [toHz, toLevel, toBw];
+    return [
+      hz * (toHz / hz) ** m,
+      level + (toLevel - level) * m,
+      bw * (toBw / bw) ** m,
+    ];
+  });
+}
+
+// ---- sing lane: SATB tables, Klatt cascade, morph and tuning ----
+
+/**
+ * Vowel formant tables and the resonators that sing them.
+ *
+ * Tables: F1-F5 frequency (Hz), level (dB), bandwidth (Hz) for soprano,
+ * alto, tenor and bass singers on a e i o u: the Csound manual's "Formant
+ * Values" appendix (the FOF table, after Sundberg's singer data). The tenor
+ * rows equal VOWEL_FORMANTS above.
+ *
+ * Resonator: Klatt 1980 ("Software for a cascade/parallel formant
+ * synthesizer", JASA 67(3)) two-pole digital resonator with unity DC gain:
+ *   C = -exp(-2 pi BW T), B = 2 exp(-pi BW T) cos(2 pi F T), A = 1 - B - C,
+ *   y[n] = A x[n] + B y[n-1] + C y[n-2].
+ * In cascade the relative formant levels come out right on their own.
+ */
+
+export type Formant = readonly [hz: number, db: number, bw: number];
+export type VowelTable = readonly Formant[];
+export const VOICE_TYPES = ["soprano", "alto", "tenor", "bass"] as const;
+export type VoiceType = (typeof VOICE_TYPES)[number];
+export const VOWELS = ["a", "e", "i", "o", "u"] as const;
+
+const row = (f: number[], db: number[], bw: number[]): VowelTable =>
+  f.map((hz, i) => [hz, db[i]!, bw[i]!] as const);
+
+export const SINGER_FORMANTS: Readonly<
+  Record<VoiceType, Record<string, VowelTable>>
+> = {
+  soprano: {
+    a: row(
+      [800, 1150, 2900, 3900, 4950],
+      [0, -6, -32, -20, -50],
+      [80, 90, 120, 130, 140],
+    ),
+    e: row(
+      [350, 2000, 2800, 3600, 4950],
+      [0, -20, -15, -40, -56],
+      [60, 100, 120, 150, 200],
+    ),
+    i: row(
+      [270, 2140, 2950, 3900, 4950],
+      [0, -12, -26, -26, -44],
+      [60, 90, 100, 120, 120],
+    ),
+    o: row(
+      [450, 800, 2830, 3800, 4950],
+      [0, -11, -22, -22, -50],
+      [70, 80, 100, 130, 135],
+    ),
+    u: row(
+      [325, 700, 2700, 3800, 4950],
+      [0, -16, -35, -40, -60],
+      [50, 60, 170, 180, 200],
+    ),
+  },
+  alto: {
+    a: row(
+      [800, 1150, 2800, 3500, 4950],
+      [0, -4, -20, -36, -60],
+      [80, 90, 120, 130, 140],
+    ),
+    e: row(
+      [400, 1600, 2700, 3300, 4950],
+      [0, -24, -30, -35, -60],
+      [60, 80, 120, 150, 200],
+    ),
+    i: row(
+      [350, 1700, 2700, 3700, 4950],
+      [0, -20, -30, -36, -60],
+      [50, 100, 120, 150, 200],
+    ),
+    o: row(
+      [450, 800, 2830, 3500, 4950],
+      [0, -9, -16, -28, -55],
+      [70, 80, 100, 130, 135],
+    ),
+    u: row(
+      [325, 700, 2530, 3500, 4950],
+      [0, -12, -30, -40, -64],
+      [50, 60, 170, 180, 200],
+    ),
+  },
+  tenor: {
+    a: row(
+      [650, 1080, 2650, 2900, 3250],
+      [0, -6, -7, -8, -22],
+      [80, 90, 120, 130, 140],
+    ),
+    e: row(
+      [400, 1700, 2600, 3200, 3580],
+      [0, -14, -12, -14, -20],
+      [70, 80, 100, 120, 120],
+    ),
+    i: row(
+      [290, 1870, 2800, 3250, 3540],
+      [0, -15, -18, -20, -30],
+      [40, 90, 100, 120, 120],
+    ),
+    o: row(
+      [400, 800, 2600, 2800, 3000],
+      [0, -10, -12, -12, -26],
+      [40, 80, 100, 120, 120],
+    ),
+    u: row(
+      [350, 600, 2700, 2900, 3300],
+      [0, -20, -17, -14, -26],
+      [40, 60, 100, 120, 120],
+    ),
+  },
+  bass: {
+    a: row(
+      [600, 1040, 2250, 2450, 2750],
+      [0, -7, -9, -9, -20],
+      [60, 70, 110, 120, 130],
+    ),
+    e: row(
+      [400, 1620, 2400, 2800, 3100],
+      [0, -12, -9, -12, -18],
+      [40, 80, 100, 120, 120],
+    ),
+    i: row(
+      [250, 1750, 2600, 3050, 3340],
+      [0, -30, -16, -22, -28],
+      [60, 90, 100, 120, 120],
+    ),
+    o: row(
+      [400, 750, 2400, 2600, 2900],
+      [0, -11, -21, -20, -40],
+      [40, 80, 100, 120, 120],
+    ),
+    u: row(
+      [350, 600, 2400, 2675, 2950],
+      [0, -20, -32, -28, -36],
+      [40, 80, 100, 120, 120],
+    ),
+  },
+};
+
+/** Morph two tables: frequencies and bandwidths in log Hz, levels in dB. */
+export function morphVowel(a: VowelTable, b: VowelTable, t: number): Formant[] {
+  return a.map(([fa, da, ba], i) => {
+    const [fb, db, bb] = b[i]!;
+    return [
+      fa * (fb / fa) ** t,
+      da + (db - da) * t,
+      ba * (bb / ba) ** t,
+    ] as const;
+  });
+}
+
+/**
+ * Vowel position along a sequence, e.g. "a>o>u" at t in [0,1]; plain "a"
+ * is constant. Unknown letters fall back to "a".
+ */
+export function vowelAt(voice: VoiceType, spec: string, t: number): Formant[] {
+  const table = SINGER_FORMANTS[voice];
+  const names = spec.split(">").map((s) => (table[s] ? s : "a"));
+  if (names.length === 1) return [...table[names[0]!]!];
+  if (t >= 1) return [...table[names[names.length - 1]!]!];
+  const x = Math.min(0.999999, Math.max(0, t)) * (names.length - 1);
+  const i = Math.floor(x);
+  return morphVowel(table[names[i]!]!, table[names[i + 1]!]!, x - i);
+}
+
+/** Klatt resonator with coefficient updates at control rate. */
+export class Resonator {
+  private a = 1;
+  private b = 0;
+  private c = 0;
+  private y1 = 0;
+  private y2 = 0;
+  set(hz: number, bw: number, sampleRate: number): void {
+    const t = 1 / sampleRate;
+    const f = Math.min(hz, sampleRate * 0.45);
+    this.c = -Math.exp(-2 * Math.PI * bw * t);
+    this.b = 2 * Math.exp(-Math.PI * bw * t) * Math.cos(2 * Math.PI * f * t);
+    this.a = 1 - this.b - this.c;
+  }
+  /** Writes the coefficients at `out[at..at+2]`; returns the next index. */
+  coeffsInto(out: Float64Array, at: number): number {
+    out[at] = this.a;
+    out[at + 1] = this.b;
+    out[at + 2] = this.c;
+    return at + 3;
+  }
+  /** H(e^jw) as [re, im], given cos/sin of w and 2w. */
+  response(cw: number, sw: number, c2w: number, s2w: number): [number, number] {
+    const out = new Float64Array(2);
+    this.responseInto(cw, sw, c2w, s2w, out);
+    return [out[0]!, out[1]!];
+  }
+  /** `response` written into `out[0..1]` (no allocation on the hot path). */
+  responseInto(
+    cw: number,
+    sw: number,
+    c2w: number,
+    s2w: number,
+    out: Float64Array,
+  ): void {
+    const re = 1 - this.b * cw - this.c * c2w;
+    const im = this.b * sw + this.c * s2w;
+    const d = re * re + im * im;
+    out[0] = (this.a * re) / d;
+    out[1] = (-this.a * im) / d;
+  }
+  process(x: number): number {
+    const y = this.a * x + this.b * this.y1 + this.c * this.y2;
+    this.y2 = this.y1;
+    this.y1 = y;
+    return y;
+  }
+}
+
+/** Constant-peak-gain band-pass (RBJ, 0 dB at centre) for parallel banks. */
+export class Bandpass {
+  private b0 = 0;
+  private b2 = 0;
+  private a1 = 0;
+  private a2 = 0;
+  private x1 = 0;
+  private x2 = 0;
+  private y1 = 0;
+  private y2 = 0;
+  set(hz: number, bw: number, sampleRate: number): void {
+    const w = (2 * Math.PI * Math.min(hz, sampleRate * 0.45)) / sampleRate;
+    const q = Math.max(0.3, hz / Math.max(1, bw));
+    const alpha = Math.sin(w) / (2 * q);
+    const a0 = 1 + alpha;
+    this.b0 = alpha / a0;
+    this.b2 = -alpha / a0;
+    this.a1 = (-2 * Math.cos(w)) / a0;
+    this.a2 = (1 - alpha) / a0;
+  }
+  /** Writes the coefficients at `out[at..at+3]`; returns the next index. */
+  coeffsInto(out: Float64Array, at: number): number {
+    out[at] = this.b0;
+    out[at + 1] = this.b2;
+    out[at + 2] = this.a1;
+    out[at + 3] = this.a2;
+    return at + 4;
+  }
+  /** H(e^jw) as [re, im], given cos/sin of w and 2w. */
+  response(cw: number, sw: number, c2w: number, s2w: number): [number, number] {
+    const out = new Float64Array(2);
+    this.responseInto(cw, sw, c2w, s2w, out);
+    return [out[0]!, out[1]!];
+  }
+  /** `response` written into `out[0..1]` (no allocation on the hot path). */
+  responseInto(
+    cw: number,
+    sw: number,
+    c2w: number,
+    s2w: number,
+    out: Float64Array,
+  ): void {
+    const nr = this.b0 + this.b2 * c2w;
+    const ni = -this.b2 * s2w;
+    const dr = 1 + this.a1 * cw + this.a2 * c2w;
+    const di = -this.a1 * sw - this.a2 * s2w;
+    const d = dr * dr + di * di;
+    out[0] = (nr * dr + ni * di) / d;
+    out[1] = (ni * dr - nr * di) / d;
+  }
+  process(x: number): number {
+    const y =
+      this.b0 * x + this.b2 * this.x2 - this.a1 * this.y1 - this.a2 * this.y2;
+    this.x2 = this.x1;
+    this.x1 = x;
+    this.y2 = this.y1;
+    this.y1 = y;
+    return y;
+  }
+}
+
+/** Five-formant cascade (the Klatt voicing branch). */
+export class Cascade {
+  readonly res = [
+    new Resonator(),
+    new Resonator(),
+    new Resonator(),
+    new Resonator(),
+    new Resonator(),
+  ];
+  set(formants: readonly Formant[], scale: number, sampleRate: number): void {
+    for (let i = 0; i < 5; i += 1) {
+      const [hz, , bw] = formants[i]!;
+      this.res[i]!.set(hz * scale, bw * Math.sqrt(scale), sampleRate);
+    }
+  }
+  process(x: number): number {
+    let y = x;
+    for (const r of this.res) y = r.process(y);
+    return y;
+  }
+}
+
+/**
+ * Formant tuning for high voices (review fix; Sundberg 1987, Joliveau,
+ * Smith and Wolfe 2004): when f0 rises above F1 (and 2 f0 above F2), the
+ * singer opens the jaw so F1 tracks f0 and F2 tracks 2 f0. Applied to the
+ * effective (formant-scaled) frequencies; bandwidths widen in proportion.
+ * A no-op below the crossing, so low voices keep the table exactly.
+ */
+export function tuneToPitch(
+  formants: readonly Formant[],
+  f0: number,
+  scale: number,
+): readonly Formant[] {
+  const need1 = (1.05 * f0) / scale;
+  if (
+    formants[0]![0] >= need1 &&
+    formants[1]![0] >= Math.max((2.05 * f0) / scale, formants[0]![0] * 1.25)
+  )
+    return formants; // below the crossing: the table as-is, no allocation
+  const out = formants.map((f) => [...f] as [number, number, number]);
+  const f1 = out[0]!;
+  const want1 = (1.05 * f0) / scale;
+  if (f1[0] < want1) {
+    f1[2] *= want1 / f1[0];
+    f1[0] = want1;
+  }
+  const f2 = out[1]!;
+  const want2 = Math.max((2.05 * f0) / scale, f1[0] * 1.25);
+  if (f2[0] < want2) {
+    f2[2] *= want2 / f2[0];
+    f2[0] = want2;
+  }
+  return out;
+}

package/src/audio/dsp/glottal.ts

@@ -0,0 +1,243 @@
+/**
+ * Glottal source: the Liljencrants-Fant (LF) flow-derivative pulse shaped by
+ * one voice-quality knob Rd (Fant 1995, "The LF-model revisited"): 0.3 is
+ * pressed and bright, 1.0 modal, 2.7 breathy and dark. One period tables are
+ * precomputed on an Rd grid and read with linear interpolation in phase and
+ * across Rd, so the per-sample cost is two table reads.
+ *
+ * Fant's Rd relations (all in units of the period T0 = 1):
+ *   Ra = (-1 + 4.8 Rd) / 100, Rk = (22.4 + 11.8 Rd) / 100,
+ *   Rg = Rk / (4 (0.11 Rd / (0.5 + 1.2 Rk) - Ra)),
+ *   tp = 1 / (2 Rg), te = tp (1 + Rk), ta = Ra.
+ */
+import { fftInPlace } from "./fft.ts";
+
+export const GLOTTAL_TABLE = 2048;
+export const RD_MIN = 0.3;
+export const RD_MAX = 2.7;
+export const RD_STEP = 0.1;
+const RD_COUNT = Math.round((RD_MAX - RD_MIN) / RD_STEP) + 1;
+
+function lfTable(rd: number, n: number): Float64Array {
+  const ra = (-1 + 4.8 * rd) / 100;
+  const rk = (22.4 + 11.8 * rd) / 100;
+  const rg = rk / (4 * ((0.11 * rd) / (0.5 + 1.2 * rk) - ra));
+  const tp = 1 / (2 * rg);
+  let te = tp * (1 + rk);
+  if (te > 0.98) te = 0.98;
+  const ta = Math.max(ra, 1e-4);
+  const tc = 1;
+  // return-phase constant: eps * ta = 1 - exp(-eps (tc - te))
+  let eps = 1 / ta;
+  for (let i = 0; i < 60; i += 1) eps = (1 - Math.exp(-eps * (tc - te))) / ta;
+  const wg = Math.PI / tp;
+  const shape = (alpha: number, out: Float64Array): number => {
+    const e0 = -1 / (Math.exp(alpha * te) * Math.sin(wg * te));
+    let sum = 0;
+    for (let i = 0; i < n; i += 1) {
+      const t = i / n;
+      let v: number;
+      if (t <= te) v = e0 * Math.exp(alpha * t) * Math.sin(wg * t);
+      else
+        v =
+          -(1 / (eps * ta)) *
+          (Math.exp(-eps * (t - te)) - Math.exp(-eps * (tc - te)));
+      out[i] = v;
+      sum += v;
+    }
+    return sum / n;
+  };
+  // alpha makes the net flow zero (the derivative integrates to 0)
+  const out = new Float64Array(n);
+  let lo = -50;
+  let hi = 200;
+  for (let i = 0; i < 80; i += 1) {
+    const mid = (lo + hi) / 2;
+    if (shape(mid, out) > 0) hi = mid;
+    else lo = mid;
+  }
+  shape((lo + hi) / 2, out);
+  // remove residual DC exactly
+  let mean = 0;
+  for (const v of out) mean += v;
+  mean /= n;
+  for (let i = 0; i < n; i += 1) out[i] = out[i]! - mean;
+  return out;
+}
+
+let tables: Float64Array[] | undefined;
+function lfTables(): Float64Array[] {
+  if (!tables) {
+    tables = [];
+    for (let i = 0; i < RD_COUNT; i += 1)
+      tables.push(lfTable(RD_MIN + i * RD_STEP, GLOTTAL_TABLE));
+  }
+  return tables;
+}
+
+/**
+ * Band-limited mip levels (review fix: the single table aliased badly at
+ * 22,050 Hz). Each Rd table is truncated by FFT to its first H harmonics,
+ * H on a half-octave grid. A voice at f0 reads the two levels below
+ * nmax = fs / (2 f0) and crossfades between them by log(nmax), so the
+ * output never holds a harmonic above Nyquist and the timbre moves
+ * continuously with pitch (no level jumps under vibrato). The build stores
+ * Float32 tables of size max(64, 8 H) rounded up to a power of two
+ * (about 0.6 MB for 25 Rd x 19 levels).
+ */
+export const MIP_HARMONICS = [
+  2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64, 91, 128, 181, 256, 362, 512, 724, 1023,
+];
+let mips: Float64Array[][] | undefined; // [level][rd]
+function truncate(src: Float64Array, harmonics: number): Float64Array {
+  const n = src.length;
+  const re = Float64Array.from(src);
+  const im = new Float64Array(n);
+  fftInPlace(re, im);
+  for (let k = 0; k < n; k += 1) {
+    const h = k <= n / 2 ? k : n - k;
+    if (h > harmonics) {
+      re[k] = 0;
+      im[k] = 0;
+    }
+  }
+  fftInPlace(re, im, true);
+  for (let i = 0; i < n; i += 1) re[i] = re[i]! / n;
+  return re;
+}
+function mipTables(): Float64Array[][] {
+  if (!mips) {
+    const base = lfTables();
+    mips = MIP_HARMONICS.map((h) => base.map((t) => truncate(t, h)));
+  }
+  return mips;
+}
+
+function readLevel(
+  level: Float64Array[],
+  ri: number,
+  rf: number,
+  i0: number,
+  i1: number,
+  pf: number,
+): number {
+  const a = level[ri]!;
+  const b = level[ri + 1]!;
+  const va = a[i0]! + (a[i1]! - a[i0]!) * pf;
+  const vb = b[i0]! + (b[i1]! - b[i0]!) * pf;
+  return va + (vb - va) * rf;
+}
+
+/**
+ * LF flow derivative at `phase` in [0,1) for voice quality `rd`; peak
+ * excitation -1. `inc` is f0 / sampleRate: when given, the read is
+ * band-limited (mip levels); without it, the full table (aliases; kept
+ * only to measure the difference).
+ */
+// The mip level choice depends only on `inc`, which changes once per period
+// or control step: memoised so the per-sample cost is the table reads.
+let lastInc = Number.NaN;
+let lastLevel = 0;
+let lastBlend = 0;
+function chooseLevel(inc: number): void {
+  lastInc = inc;
+  const nmax = 0.5 / Math.max(inc, 1e-9);
+  let j = 0;
+  while (j + 1 < MIP_HARMONICS.length && MIP_HARMONICS[j + 1]! <= nmax) j += 1;
+  if (j === 0 || MIP_HARMONICS[j]! > nmax) {
+    lastLevel = 0;
+    lastBlend = -1;
+    return;
+  }
+  // blend level j-1 (weight 1-f) and level j (weight f): both are below nmax
+  const top =
+    j + 1 < MIP_HARMONICS.length
+      ? MIP_HARMONICS[j + 1]!
+      : MIP_HARMONICS[j]! * Math.SQRT2;
+  lastLevel = j;
+  lastBlend = Math.min(
+    1,
+    Math.log(nmax / MIP_HARMONICS[j]!) / Math.log(top / MIP_HARMONICS[j]!),
+  );
+}
+
+/**
+ * Builds the LF tables and their mip levels now (about 50 ms) instead of on
+ * the first sounding sample, so a live key never pays for them. Idempotent.
+ */
+export function warmGlottal(): void {
+  mipTables();
+}
+
+/**
+ * LF flow derivative at `phase` in [0,1) for voice quality `rd`; peak
+ * excitation -1. `inc` is f0 / sampleRate: when given, the read is
+ * band-limited (mip levels); without it, the full table (aliases; kept
+ * only to measure the difference).
+ */
+export function glottal(phase: number, rd: number, inc?: number): number {
+  const r = (Math.min(RD_MAX, Math.max(RD_MIN, rd)) - RD_MIN) / RD_STEP;
+  const ri = Math.min(RD_COUNT - 2, Math.floor(r));
+  const rf = r - ri;
+  const p = phase * GLOTTAL_TABLE;
+  const pi = Math.floor(p);
+  const pf = p - pi;
+  const i0 = pi % GLOTTAL_TABLE;
+  const i1 = (pi + 1) % GLOTTAL_TABLE;
+  if (inc === undefined) return readLevel(lfTables(), ri, rf, i0, i1, pf);
+  const m = mipTables();
+  if (inc !== lastInc) chooseLevel(inc);
+  const j = lastLevel;
+  if (lastBlend < 0) return readLevel(m[0]!, ri, rf, i0, i1, pf);
+  const lo = readLevel(m[j - 1]!, ri, rf, i0, i1, pf);
+  const hi = readLevel(m[j]!, ri, rf, i0, i1, pf);
+  return lo + (hi - lo) * lastBlend;
+}
+
+/** Open-phase weight (1 while the glottis is open) for breath-noise gating. */
+let owRd = Number.NaN;
+let owTe = 0;
+export function openWeight(phase: number, rd: number): number {
+  if (rd !== owRd) {
+    const rk = (22.4 + 11.8 * rd) / 100;
+    const ra = (-1 + 4.8 * rd) / 100;
+    const rg = rk / (4 * ((0.11 * rd) / (0.5 + 1.2 * rk) - ra));
+    owRd = rd;
+    owTe = Math.min(0.98, (1 / (2 * rg)) * (1 + rk));
+  }
+  const te = owTe;
+  return phase < te ? 0.5 - 0.5 * Math.cos((2 * Math.PI * phase) / te) : 0.15;
+}
+
+const spectra = new Map<number, Float64Array>();
+
+/**
+ * Power of harmonics 1..`count` of the LF flow derivative at `rd`
+ * (rounded to the table's 0.1 grid), from a DFT of one period. Cached:
+ * the sing engine's level normalization reads it at control rate.
+ */
+export function glottalSpectrum(rd: number, count: number): Float64Array {
+  const index = Math.round(
+    (Math.min(RD_MAX, Math.max(RD_MIN, rd)) - RD_MIN) / RD_STEP,
+  );
+  const key = index * 1024 + count;
+  const hit = spectra.get(key);
+  if (hit) return hit;
+  const at = RD_MIN + index * RD_STEP;
+  const n = 1024;
+  const x = new Float64Array(n);
+  for (let i = 0; i < n; i += 1) x[i] = glottal(i / n, at);
+  const out = new Float64Array(count + 1);
+  for (let h = 1; h <= count; h += 1) {
+    let re = 0;
+    let im = 0;
+    for (let i = 0; i < n; i += 1) {
+      const a = (2 * Math.PI * h * i) / n;
+      re += x[i]! * Math.cos(a);
+      im -= x[i]! * Math.sin(a);
+    }
+    out[h] = (re * re + im * im) / (n * n);
+  }
+  spectra.set(key, out);
+  return out;
+}

package/src/audio/dsp/interp.ts

@@ -51,11 +51,16 @@ export function allpassDelay(a: number, w: number): number {
 export function thiranFor(d: number, w = 0): number {
   let a = (1 - d) / (1 + d);
   if (w < 1e-9) return a;
+  const s = Math.sin(w);
+  const c = Math.cos(w);
   for (let i = 0; i < 4; i += 1) {
     const f = allpassDelay(a, w) - d;
     if (Math.abs(f) < 1e-10) break;
-    const h = 1e-6;
-    const df = (allpassDelay(a + h, w) - allpassDelay(a - h, w)) / (2 * h);
+    // d(delay)/da in closed form: the phase is atan2(-s, a + c) -
+    // atan2(-a s, 1 + a c), so no extra atan2 pair per step.
+    const p = a + c;
+    const q = 1 + a * c;
+    const df = -(s / (p * p + s * s) + s / (q * q + a * a * s * s)) / w;
     if (df === 0) break;
     a = clamp(a - f / df, -0.9, 0.9);
   }