@hraness/dawg 0.6.1 → 0.8.0

package/src/audio/strings/bow.ts

@@ -21,7 +21,11 @@
  *   force and falls with beta and the mute (`sord`).
  * - Slur: `slurTo` retunes over 7 ms and keeps the bow (no new attack).
  * - Tremolo: `tremhz` reverses the bow that many times a second, with a
- *   seeded per-voice rate jitter.
+ *   seeded per-voice rate jitter. At each reversal the bow force eases off
+ *   with the bow speed (the friction curve narrows as dir^2), so the
+ *   string rings through the turn instead of sticking to a slow bow and
+ *   flattening; the pitch lock averages each stroke's middle (one update
+ *   per stroke) instead of chasing the turns' transient periods.
  */
 import { Decimate2 } from "../dsp/oversample.ts";
 import { thiranFor } from "../dsp/interp.ts";
@@ -52,6 +56,12 @@ export const SLUR_RANGE = 24;
  */
 const LOCK_GAIN = 0.25;
 const LOCK_RANGE = 0.03;
+/** Tremolo: |sin| of the reversal phase past which a stroke is steady. */
+const STROKE_STEADY = 0.7;
+/** Tremolo: lock step per stroke, on the stroke's mean period error. */
+const STROKE_LOCK_GAIN = 0.2;
+/** Tremolo: the friction slope widens at most 1 / FLOOR^2 at a turn. */
+const TURN_FORCE_FLOOR = 0.05;
 /** Speed ratio between dyn 0 and dyn 1 (the review's 8:1). */
 const SPEED_RATIO = 8;
 /** Extra gain law across dyn, in dB (with the 18 dB speed law: 28 dB). */
@@ -323,6 +333,11 @@ export class BowedString {
   private readonly decim?: Decimate2;
   private readonly tremRate: number;
   private readonly tremPhase: number;
+  /** Tremolo: between turns, and that stroke's lock measurements. */
+  private steady = true;
+  private strokeErr = 0;
+  private strokeCount = 0;
+  private strokeSkip = 0;
   /** Internal-rate sample count. */
   private n = 0;
   private off: number;
@@ -548,6 +563,20 @@ export class BowedString {
         Math.PI * (this.tremRate * (n / this.rate) + this.tremPhase),
       );
       dir = Math.tanh(4 * s);
+      const steady = Math.abs(s) > STROKE_STEADY;
+      if (steady !== this.steady) {
+        // Leaving a stroke's middle: one lock step on its mean error.
+        if (this.steady && this.strokeCount > 0)
+          this.lock = clamp(
+            this.lock - (STROKE_LOCK_GAIN * this.strokeErr) / this.strokeCount,
+            -LOCK_RANGE,
+            LOCK_RANGE,
+          );
+        this.steady = steady;
+        this.strokeErr = 0;
+        this.strokeCount = 0;
+        this.strokeSkip = 0;
+      }
     }
     // Note-off lifts the bow: the normal force falls over `release` (the
     // friction curve narrows, STK's bow pressure), with the bow still
@@ -556,7 +585,10 @@ export class BowedString {
     // half-reflecting junction that brakes the string.
     const bowVel = this.vtarget * (on ? env : 1) * dir;
     const contact = on || env > 0 ? 1 : 0;
-    const slope = on ? this.slope : this.slope / Math.max(1e-3, env * env);
+    let slope = on ? this.slope : this.slope / Math.max(1e-3, env * env);
+    // A turning bow presses less: the friction curve narrows with speed.
+    if (this.tremRate > 0)
+      slope /= Math.max(TURN_FORCE_FLOOR, Math.abs(dir)) ** 2;
     const bOut = bb[(this.bw - this.Nb) & mask]!;
     const raw = nb[(this.nw - this.Nn) & mask]!;
     const nOut = this.a * raw + this.tx1 - this.a * this.ty1;
@@ -566,7 +598,9 @@ export class BowedString {
     const bridgeRefl = -this.sy;
     const nutRefl = -nOut;
     const dv = bowVel - (bridgeRefl + nutRefl);
-    let f = (Math.abs(dv * slope) + 0.75) ** -4;
+    const r = 1 / (Math.abs(dv * slope) + 0.75);
+    const r2 = r * r;
+    let f = r2 * r2;
     if (f > 1) f = 1;
     const nv = contact * dv * f;
     nb[this.nw & mask] = bridgeRefl + nv;
@@ -591,8 +625,9 @@ export class BowedString {
     this.bpY1 = y;
     if (!(prev < 0 && y >= 0)) return;
     const cross = n - 1 + prev / (prev - y);
-    const last = this.lastCross;
-    this.lastCross = cross;
+    // Tremolo: only periods wholly inside a stroke's middle count.
+    const last = this.steady ? this.lastCross : -1;
+    this.lastCross = this.steady ? cross : -1;
     // Settle first: the attack and a slur's glide are not steady periods.
     if (last < 0 || n < 0.05 * this.rate) return;
     if (this.slurAt >= 0 && n < this.slurAt + this.slurLen + 0.02 * this.rate)
@@ -600,6 +635,14 @@ export class BowedString {
     const period = cross - last;
     const err = period / this.target - 1;
     if (Math.abs(err) > 0.1) return;
+    if (this.tremRate > 0) {
+      // The first period of a stroke still carries the turn.
+      if ((this.strokeSkip += 1) > 1) {
+        this.strokeErr += err;
+        this.strokeCount += 1;
+      }
+      return;
+    }
     this.lock = clamp(this.lock - LOCK_GAIN * err, -LOCK_RANGE, LOCK_RANGE);
   }
 

package/src/audio/strings/engine.ts

@@ -20,6 +20,7 @@ import { interpolateAutomation } from "../effects/common.ts";
 import { seedHash, unit } from "../dsp/rng.ts";
 import type { EngineContext, InstrumentEngine } from "../instruments.ts";
 import { applyBody, bodyFor, symKeys, sympathetic } from "./body.ts";
+import { keysTrim } from "../keys/calibration.ts";
 import { clamp } from "./loop.ts";
 import { PluckString, type Exciter, type PluckSpec } from "./pluck.ts";
 import {
@@ -337,6 +338,10 @@ export function renderStrings(
   const cap = Math.max(1, Math.round(values.voices as number));
   const tuning = context.tuning;
   const bowed = isBowed(values);
+  // Calibration 1 (q08): the keyboard string presets (the harpsichord) take
+  // the keys' key-tracked level trim; other presets have no row.
+  const trimPreset =
+    (context.score.calibration ?? 0) >= 1 ? track.string?.preset : undefined;
   const L = new Float64Array(total);
   const R = dryR ? new Float64Array(total) : undefined;
   const voices: Voice[] = [];
@@ -416,6 +421,7 @@ export function renderStrings(
         `${note.id}:${note.startTick + (context.seedTick ?? 0)}:string`,
       );
       const strings: { hz: number; gain: number; ratio: number }[] = [];
+      const trim = trimPreset ? keysTrim(trimPreset, note.pitch) : 1;
       // The course's tuning error belongs to the key, not to the strike: it
       // is seeded by track and key (so every velocity of a key beats the
       // same way) and centred, so the course's mean pitch is the table's.
@@ -430,7 +436,7 @@ export function renderStrings(
         const ratio = 2 ** ((d * 100 + jitter) / 1200);
         strings.push({
           hz: baseHz * ratio,
-          gain: 1 / Math.sqrt(unison),
+          gain: trim / Math.sqrt(unison),
           ratio,
         });
       }
@@ -442,7 +448,7 @@ export function renderStrings(
             hz * 2 ** (((unit(course, unison, 1) - 0.5) * 4) / 1200);
           strings.push({
             hz: tuned,
-            gain: oct / Math.sqrt(unison),
+            gain: (trim * oct) / Math.sqrt(unison),
             ratio: tuned / baseHz,
           });
         }

package/src/audio/synth/oscillators.ts

@@ -110,28 +110,38 @@ function triangle(phase: number): number {
  * names when a track sets synth parameters.
  */
 export function legacyWave(instrument: string, phase: number): number {
+  return legacyWaveFor(instrument)(phase);
+}
+
+/**
+ * `legacyWave` with the tone chosen once: `legacyWaveFor(name)(phase)`
+ * equals `legacyWave(name, phase)`, without matching the name per sample.
+ */
+export function legacyWaveFor(instrument: string): (phase: number) => number {
   const name = instrument.trim().toLowerCase();
-  const cycle = phase - Math.floor(phase);
-  const sine = Math.sin(2 * Math.PI * phase);
-  if (name.includes("square")) return cycle < 0.5 ? 1 : -1;
-  if (name.includes("saw")) return 2 * cycle - 1;
-  if (name.includes("triangle")) return 1 - 4 * Math.abs(cycle - 0.5);
-  if (name.includes("bass")) {
+  if (name.includes("square"))
+    return (phase) => (phase - Math.floor(phase) < 0.5 ? 1 : -1);
+  if (name.includes("saw"))
+    return (phase) => 2 * (phase - Math.floor(phase)) - 1;
+  if (name.includes("triangle"))
+    return (phase) => 1 - 4 * Math.abs(phase - Math.floor(phase) - 0.5);
+  if (name.includes("bass"))
     // A rounded fundamental plus a quiet octave gives bass tracks useful weight.
-    return Math.tanh(
-      0.9 * Math.sin(2 * Math.PI * phase) +
-        0.25 * Math.sin(4 * Math.PI * phase),
-    );
-  }
-  if (name.includes("piano") || name.includes("pluck")) {
+    return (phase) =>
+      Math.tanh(
+        0.9 * Math.sin(2 * Math.PI * phase) +
+          0.25 * Math.sin(4 * Math.PI * phase),
+      );
+  if (name.includes("piano") || name.includes("pluck"))
     // Add stable harmonics; the envelope above supplies the note decay.
-    const harmonic =
-      Math.sin(4 * Math.PI * phase) * 0.28 +
-      Math.sin(6 * Math.PI * phase) * 0.12;
-    return Math.tanh(sine + harmonic);
-  }
+    return (phase) => {
+      const harmonic =
+        Math.sin(4 * Math.PI * phase) * 0.28 +
+        Math.sin(6 * Math.PI * phase) * 0.12;
+      return Math.tanh(Math.sin(2 * Math.PI * phase) + harmonic);
+    };
   // Unknown instruments deliberately fall back to the original sine voice.
-  return sine;
+  return (phase) => Math.sin(2 * Math.PI * phase);
 }
 
 /**
@@ -230,9 +240,9 @@ const BUILT_IN: Readonly<Record<string, OscillatorFactory>> = Object.freeze({
   pulse: (init) => (phase, increment) => pulse(phase, increment, init.width()),
   triangle: (init) => (init.partials ? additive(init) : triangle),
   user: (init) => additive(init),
-  piano: () => (phase) => legacyWave("piano", phase),
-  pluck: () => (phase) => legacyWave("pluck", phase),
-  bass: () => (phase) => legacyWave("bass", phase),
+  piano: () => legacyWaveFor("piano"),
+  pluck: () => legacyWaveFor("pluck"),
+  bass: () => legacyWaveFor("bass"),
   white: (init) => () => (init.random() * 2 - 1) * 0.6,
   pink: (init) => pinkNoise(init.random),
   brown: (init) => {

package/src/audio/synth/voice.ts

@@ -31,6 +31,7 @@ import {
 } from "../../../core/synth.ts";
 import {
   Biquad,
+  Svf,
   CONTROL_SAMPLES,
   clamp,
   interpolateAutomation,
@@ -197,6 +198,8 @@ const BUTTERWORTH_Q2 = 1.3066;
 class NoteFilter {
   private readonly first = new Biquad();
   private readonly second = new Biquad();
+  private readonly svfFirst: Svf;
+  private readonly svfSecond: Svf;
   private readonly ladder = new Float64Array(4);
   private ladderG = 0;
   private ladderK = 0;
@@ -210,7 +213,22 @@ class NoteFilter {
     readonly anchor: number,
     readonly envelope: Envelope,
     private readonly sampleRate: number,
-  ) {}
+  ) {
+    this.svfFirst = new Svf(type);
+    this.svfSecond = new Svf(type);
+  }
+
+  /**
+   * A negative depth sweeps the cutoff down during the attack, often to
+   * the 20 Hz floor within a few milliseconds. A direct-form biquad
+   * re-designed every control block blows up under that fall (its state
+   * belongs to the old coefficients), so those notes run on the SVF, whose
+   * state stays valid. Positive and zero depths keep the biquad, so their
+   * renders are unchanged.
+   */
+  private get isSvf(): boolean {
+    return this.depth < 0;
+  }
 
   private get isLadder(): boolean {
     return this.slope === "ladder" && this.type === "lpf";
@@ -231,6 +249,17 @@ class NoteFilter {
       this.ladderK = 3.9 * clamp((q - 0.707) / 11.3, 0, 1);
       return;
     }
+    if (this.isSvf) {
+      if (this.slope === "24db") {
+        this.svfFirst.set(frequency, BUTTERWORTH_Q1, this.sampleRate);
+        this.svfSecond.set(
+          frequency,
+          (q * BUTTERWORTH_Q2) / 0.707,
+          this.sampleRate,
+        );
+      } else this.svfFirst.set(frequency, q, this.sampleRate);
+      return;
+    }
     if (this.slope === "24db") {
       this.first.set(this.type, frequency, BUTTERWORTH_Q1, this.sampleRate);
       this.second.set(
@@ -255,6 +284,10 @@ class NoteFilter {
       stages[3]! += g * (stages[2]! - stages[3]!);
       return stages[3]! * (1 + 0.5 * this.ladderK);
     }
+    if (this.isSvf) {
+      const once = this.svfFirst.process(input);
+      return this.slope === "24db" ? this.svfSecond.process(once) : once;
+    }
     const once = this.first.process(input);
     return this.slope === "24db" ? this.second.process(once) : once;
   }

package/src/audio/vocoder/bank.ts

@@ -0,0 +1,314 @@
+/**
+ * The channel vocoder (0.7): a bank of cascaded RBJ band-passes analyses
+ * the modulator, each band's follower shapes the same band of the carrier.
+ * Ported from the reviewed prototype (proto/vocoder, DSP v2):
+ * - layout from bands/lo/hi/width only (sample-rate independent);
+ * - band k reads the modulator advanced by its group delay plus the attack;
+ * - formant: synthesis band k takes the envelope at fractional analysis
+ *   index k - formant / 12 / log2(ratio);
+ * - enhance whitens the carrier per band (each band normalised by its own
+ *   follower), so a dull carrier still speaks in every band;
+ * - fixed makeup gain from the layout only, never from the rendered span.
+ * A stereo carrier runs one analysis and one synthesis bank per channel.
+ */
+import {
+  bandpass,
+  bankDesign,
+  runBiquad,
+  type Biquad,
+} from "../dsp/bandbank.ts";
+import { follow, followCoef, gateCurve, holdCurve } from "../dsp/follow.ts";
+import { unit } from "../dsp/rng.ts";
+import { at, VOCODER_BLOCK, type VocoderControl } from "./control.ts";
+import { hissPath, unvoicedCurve } from "./detect.ts";
+
+/** Fixed channel makeup from the layout only (fitted once on the voice fixture). */
+export function channelMakeup(bands: number, width: number): number {
+  return (
+    (1.4 * (bands / 16) ** 0.29) / (width <= 1 ? width ** 0.35 : width ** 1.1)
+  );
+}
+
+/** Reference band level for depth < 1: envelope^depth * REF^(1 - depth). */
+const REF = 0.02;
+
+/** A noise sample in -1..1 at an absolute song sample. */
+export function noiseSample(seed: number, songSample: number): number {
+  return unit(seed, songSample, 11) * 2 - 1;
+}
+
+/** Follower with an optional per-sample release curve and hold. */
+function followVarying(
+  x: Float64Array,
+  attack: number,
+  release: number,
+  releaseCurve: Float64Array | undefined,
+  sampleRate: number,
+  hold?: Uint8Array,
+): Float64Array {
+  if (!releaseCurve) return follow(x, attack, release, sampleRate, hold);
+  const a = followCoef(attack, sampleRate);
+  const out = new Float64Array(x.length);
+  let e = 0;
+  let lastRelease = Number.NaN;
+  let r = 0;
+  for (let i = 0; i < x.length; i += 1) {
+    if (releaseCurve[i] !== lastRelease) {
+      lastRelease = releaseCurve[i]!;
+      r = followCoef(lastRelease, sampleRate);
+    }
+    if (!hold || hold[i] === 0) {
+      const v = Math.abs(x[i]!);
+      const c = v > e ? a : r;
+      e = c * e + (1 - c) * v;
+    }
+    out[i] = e;
+  }
+  return out;
+}
+
+/** Runs a biquad whose coefficients may change at 32-sample blocks. */
+function runBand(
+  x: Float64Array,
+  filter: Biquad,
+  filterAt: ((i: number) => Biquad) | undefined,
+): void {
+  if (!filterAt) {
+    runBiquad(filter, x);
+    return;
+  }
+  let z1 = 0;
+  let z2 = 0;
+  let f = filterAt(0);
+  for (let i = 0; i < x.length; i += 1) {
+    if (i % VOCODER_BLOCK === 0) f = filterAt(i);
+    const v = x[i]!;
+    const y = f.b0 * v + z1;
+    z1 = f.b1 * v - f.a1 * y + z2;
+    z2 = f.b2 * v - f.a2 * y;
+    x[i] = y;
+  }
+}
+
+/**
+ * The band filter run twice in cascade, in one pass when the coefficients
+ * are fixed (the same arithmetic per sample as two passes).
+ */
+function runBandTwice(
+  x: Float64Array,
+  filter: Biquad,
+  filterAt: ((i: number) => Biquad) | undefined,
+): void {
+  if (filterAt) {
+    runBand(x, filter, filterAt);
+    runBand(x, filter, filterAt);
+    return;
+  }
+  const { b0, b1, b2, a1, a2 } = filter;
+  let p1 = 0;
+  let p2 = 0;
+  let q1 = 0;
+  let q2 = 0;
+  for (let i = 0; i < x.length; i += 1) {
+    const v = x[i]!;
+    const y = b0 * v + p1;
+    p1 = b1 * v - a1 * y + p2;
+    p2 = b2 * v - a2 * y;
+    const w = b0 * y + q1;
+    q1 = b1 * y - a1 * w + q2;
+    q2 = b2 * y - a2 * w;
+    x[i] = w;
+  }
+}
+
+/** `e[i] *= g[i]` (its own function so the loop is optimised). */
+function multiplyInto(e: Float64Array, g: Float64Array): void {
+  for (let i = 0; i < e.length; i += 1) e[i] = e[i]! * g[i]!;
+}
+
+/** Cross-fades the carrier toward level-matched noise where `u` is unvoiced. */
+function blendUnvoiced(
+  carrier: Float64Array,
+  u: Float64Array,
+  control: VocoderControl,
+  seed: number,
+  origin: number,
+  sr: number,
+): void {
+  const level = follow(carrier, 0.01, 0.1, sr);
+  const curve = control.curves.unvoiced;
+  const fixed = control.settings.unvoiced;
+  for (let i = 0; i < carrier.length; i += 1) {
+    const w = u[i]! * (curve ? curve[i]! : fixed);
+    if (w <= 0) continue;
+    const noise = noiseSample(seed, origin + i);
+    carrier[i] =
+      carrier[i]! * (1 - w) + noise * 1.7 * Math.max(level[i]!, 0.05) * w;
+  }
+}
+
+/**
+ * One synthesis band into `out` with a fixed formant shift and depth: the
+ * envelope interpolated between analysis bands `ea` and `eb` by `fr`, shaped
+ * by `depth`, over the carrier band `syn` (whitened by `ec` when enhancing).
+ * A small function of its own so the JIT optimises the loop: inlined in
+ * `channelVocode`, which runs once per render, it stayed in the baseline tier.
+ */
+function mixBandFixed(
+  out: Float64Array,
+  syn: Float64Array,
+  ea: Float64Array,
+  eb: Float64Array,
+  fr: number,
+  ec: Float64Array | undefined,
+  depth: number,
+  scale: number,
+): void {
+  const n = out.length;
+  const refPow = REF ** (1 - depth);
+  if (ec)
+    for (let i = 0; i < n; i += 1) {
+      const e = ea[i]! * (1 - fr) + eb[i]! * fr;
+      const level = depth === 1 ? e : e ** depth * refPow;
+      const g = level / (ec[i]! + 1e-5);
+      out[i]! += syn[i]! * Math.min(g, 1e3) * scale;
+    }
+  else
+    for (let i = 0; i < n; i += 1) {
+      const e = ea[i]! * (1 - fr) + eb[i]! * fr;
+      const level = depth === 1 ? e : e ** depth * refPow;
+      out[i]! += syn[i]! * level * 8 * scale;
+    }
+}
+
+/**
+ * Vocodes each carrier channel with `mod`. The modulator is read up to the
+ * largest band advance past each output sample (zero past its end).
+ * Returns the wet signal per channel, after `gain` and before the peak guard
+ * and `mix` (`applyVocoderStage` adds those).
+ */
+export function channelVocode(
+  mod: Float64Array,
+  cars: readonly Float64Array[],
+  control: VocoderControl,
+): Float64Array[] {
+  const { settings: p, sampleRate: sr, origin, seed } = control;
+  const n = Math.min(mod.length, ...cars.map((c) => c.length));
+  const { bands, ratio } = bankDesign(p, sr);
+  const nb = bands.length;
+  const widthCurve = control.curves.width;
+  // Width automation re-designs the band filters per block.
+  const designs = new Map<number, Biquad[]>();
+  const filtersFor = (width: number): Biquad[] => {
+    let known = designs.get(width);
+    if (!known) {
+      const octaves = Math.log2(ratio) * width * 1.55;
+      known = bands.map((b) =>
+        bandpass(Math.min(b.hz, 0.45 * sr), octaves, sr),
+      );
+      designs.set(width, known);
+    }
+    return known;
+  };
+  const filterAt = (k: number, offset: number) =>
+    widthCurve
+      ? (i: number): Biquad =>
+          filtersFor(widthCurve[Math.min(n - 1, i + offset)]!)[k]!
+      : undefined;
+  const gate = gateCurve(mod.subarray(0, n), sr, control.gateDb);
+  if (gate && control.hold) holdCurve(gate, control.hold);
+  const unvoicedOn = p.unvoiced > 0 || control.curves.unvoiced !== undefined;
+  const u = unvoicedOn
+    ? unvoicedCurve(mod.subarray(0, n), sr, p.sens, origin, gate)
+    : undefined;
+  // Analysis: one envelope per band.
+  const env: Float64Array[] = [];
+  const band = new Float64Array(n);
+  for (let k = 0; k < nb; k += 1) {
+    const b = bands[k]!;
+    if (!b.live) {
+      env.push(new Float64Array(n));
+      continue;
+    }
+    // The modulator advanced by the band's delay, zero past its end.
+    const from = Math.min(b.advance, mod.length);
+    const take = Math.min(n, mod.length - from);
+    band.set(mod.subarray(from, from + take));
+    band.fill(0, take);
+    runBandTwice(band, b.filter, filterAt(k, b.advance));
+    const e = followVarying(
+      band,
+      p.attack,
+      p.release,
+      control.curves.release,
+      sr,
+      control.hold,
+    );
+    if (gate) multiplyInto(e, gate);
+    env.push(e);
+  }
+  const shiftOf = (i: number): number =>
+    at(control, "formant", i) / 12 / Math.log2(ratio);
+  const staticShift = control.curves.formant ? undefined : shiftOf(0);
+  const synthEnv = (k: number, i: number): number => {
+    const pos = k - (staticShift ?? shiftOf(i));
+    const i0 = Math.floor(pos);
+    const fr = pos - i0;
+    const a = i0 >= 0 && i0 < nb ? env[i0]![i]! : 0;
+    const b = i0 + 1 >= 0 && i0 + 1 < nb ? env[i0 + 1]![i]! : 0;
+    return a * (1 - fr) + b * fr;
+  };
+  const scale = channelMakeup(p.bands, p.width);
+  const depthCurve = control.curves.depth;
+  const shape = (e: number, i: number): number => {
+    const depth = depthCurve ? depthCurve[i]! : p.depth;
+    return depth === 1 ? e : e ** depth * REF ** (1 - depth);
+  };
+  const hiss =
+    p.hiss > 0 || control.curves.hiss ? hissPath(mod, n, sr) : undefined;
+  const zeros = new Float64Array(n);
+  const outs: Float64Array[] = [];
+  for (const car of cars) {
+    const carrier = car.slice(0, n);
+    if (u) blendUnvoiced(carrier, u, control, seed, origin, sr);
+    const out = new Float64Array(n);
+    const syn = new Float64Array(n);
+    for (let k = 0; k < nb; k += 1) {
+      const b = bands[k]!;
+      if (!b.live) continue;
+      syn.set(carrier);
+      runBandTwice(syn, b.filter, filterAt(k, 0));
+      // The envelope this band reads: a fixed pair of analysis bands and
+      // weight unless the formant is automated (same arithmetic as
+      // `synthEnv`, without a call per sample).
+      let ea: Float64Array = zeros;
+      let eb: Float64Array = zeros;
+      let fr = 0;
+      if (staticShift !== undefined) {
+        const pos = k - staticShift;
+        const i0 = Math.floor(pos);
+        fr = pos - i0;
+        if (i0 >= 0 && i0 < nb) ea = env[i0]!;
+        if (i0 + 1 >= 0 && i0 + 1 < nb) eb = env[i0 + 1]!;
+      }
+      const ec = p.enhance
+        ? followVarying(syn, p.attack, p.release, control.curves.release, sr)
+        : undefined;
+      if (staticShift !== undefined && depthCurve === undefined)
+        mixBandFixed(out, syn, ea, eb, fr, ec, p.depth, scale);
+      else
+        for (let i = 0; i < n; i += 1) {
+          const level = shape(synthEnv(k, i), i);
+          if (ec) {
+            const g = level / (ec[i]! + 1e-5);
+            out[i]! += syn[i]! * Math.min(g, 1e3) * scale;
+          } else out[i]! += syn[i]! * level * 8 * scale;
+        }
+    }
+    if (hiss)
+      for (let i = 0; i < n; i += 1)
+        out[i]! += at(control, "hiss", i) * hiss[i]! * (gate ? gate[i]! : 1);
+    outs.push(out);
+  }
+  return outs;
+}