@hraness/dawg 0.6.0 → 0.7.0

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

package/src/audio/dsp/lpc.ts

@@ -0,0 +1,50 @@
+/**
+ * Linear prediction (0.7 talkbox): autocorrelation with a deterministic
+ * white-noise floor and a 60 Hz Gaussian lag window, and Levinson-Durbin.
+ */
+
+/** Autocorrelation r[0..order] of `x` into `r`. */
+export function autocorrelate(
+  x: Float64Array,
+  order: number,
+  r: Float64Array,
+  sampleRate: number,
+): Float64Array {
+  for (let lag = 0; lag <= order; lag += 1) {
+    let s = 0;
+    for (let i = lag; i < x.length; i += 1) s += x[i]! * x[i - lag]!;
+    r[lag] = s;
+  }
+  r[0] = r[0]! * (1 + 1e-6) + 1e-12;
+  for (let lag = 1; lag <= order; lag += 1)
+    r[lag] =
+      r[lag]! * Math.exp(-0.5 * ((2 * Math.PI * 60 * lag) / sampleRate) ** 2);
+  return r;
+}
+
+/**
+ * Levinson-Durbin: predictor `a` (a[0] = 1) from autocorrelation `r`.
+ * Returns the prediction error (0 when the recursion goes unstable).
+ */
+export function levinson(
+  r: Float64Array,
+  order: number,
+  a: Float64Array,
+): number {
+  a.fill(0);
+  a[0] = 1;
+  let err = r[0]!;
+  if (err <= 0) return 0;
+  const tmp = new Float64Array(order + 1);
+  for (let i = 1; i <= order; i += 1) {
+    let acc = r[i]!;
+    for (let j = 1; j < i; j += 1) acc += a[j]! * r[i - j]!;
+    const k = -acc / err;
+    tmp.set(a);
+    for (let j = 1; j < i; j += 1) a[j] = tmp[j]! + k * tmp[i - j]!;
+    a[i] = k;
+    err *= 1 - k * k;
+    if (err <= 0) return 0;
+  }
+  return err;
+}

package/src/audio/dsp/periodicity.ts

@@ -0,0 +1,59 @@
+/**
+ * Periodicity (0.7 vocoder): 0..1 per sample, the best normalised
+ * autocorrelation over 2..20 ms lags (a YIN-style aperiodicity cue), on a
+ * ~8 kHz block-averaged copy, 30 ms frames every 5 ms. The frame grid sits on
+ * the absolute song sample (`origin` + index), so a render window and the
+ * full render agree after pre-roll.
+ */
+const posMod = (a: number, m: number): number => ((a % m) + m) % m;
+
+export function periodicityCurve(
+  x: Float64Array,
+  sampleRate: number,
+  origin = 0,
+): Float64Array {
+  const dec = Math.max(1, Math.round(sampleRate / 8000));
+  const dsr = sampleRate / dec;
+  const hop = Math.round(0.005 * sampleRate);
+  const win = Math.round(0.03 * dsr);
+  const lagLo = Math.round(dsr / 500);
+  const lagHi = Math.round(dsr / 50);
+  const out = new Float64Array(x.length);
+  const buf = new Float64Array(win + lagHi);
+  for (let s = -posMod(origin, hop); s < x.length; s += hop) {
+    for (let i = 0; i < buf.length; i += 1) {
+      let acc = 0;
+      for (let d = 0; d < dec; d += 1) {
+        const j = s + i * dec + d;
+        acc += j >= 0 && j < x.length ? x[j]! : 0;
+      }
+      buf[i] = acc / dec;
+    }
+    let e0 = 0;
+    for (let i = 0; i < win; i += 1) e0 += buf[i]! * buf[i]!;
+    let best = 0;
+    if (e0 > 1e-12)
+      for (let lag = lagLo; lag <= lagHi; lag += 1) {
+        let c = 0;
+        let el = 0;
+        for (let i = 0; i < win; i += 1) {
+          c += buf[i]! * buf[i + lag]!;
+          el += buf[i + lag]! * buf[i + lag]!;
+        }
+        const r = c / Math.sqrt(e0 * el + 1e-20);
+        if (r > best) best = r;
+      }
+    // The value labels the frame's middle hop.
+    const a = s + Math.round((win * dec) / 2) - (hop >> 1);
+    for (let i = Math.max(0, a); i < Math.min(x.length, a + hop); i += 1)
+      out[i] = best;
+  }
+  let first = 0;
+  for (let i = 0; i < out.length; i += 1)
+    if (out[i] !== 0) {
+      first = out[i]!;
+      break;
+    }
+  for (let i = 0; i < out.length && out[i] === 0; i += 1) out[i] = first;
+  return out;
+}