@hraness/dawg 0.5.0 → 0.6.1

package/src/audio/effects/gaze.ts

@@ -0,0 +1,354 @@
+/**
+ * Shoegaze stages (0.6.1): wobble, bloom, swell (mono, after the cab) and
+ * double (stereo, right after pan). Ported from the guitar design lane's
+ * prototype (proto/guitar/rig.ts wobbleCurve, addFeedback, applySwell,
+ * applyDouble).
+ *
+ * - wobble: a held tremolo arm (the "glide guitar" of Kevin Shields). One
+ *   seeded curve per track in render time bends the whole voice sum
+ *   together. The voice is read through a moving, non-causal delay whose
+ *   slope is the pitch ratio, so a sine of peak `depth` cents is exact.
+ * - bloom: feedback. The highest note held past `delay` grows a partial at
+ *   `harm` × f0 with a slow seeded drift of a few cents (one seed per
+ *   note id), the way a loud amp makes the top note sing.
+ * - swell: a Slow Gear style volume swell; the gain resets at each onset
+ *   cluster and rises over `time`.
+ * - double: automatic double tracking. A second take is the input delayed
+ *   `time` ms with a seeded wander of ± `drift` ms and a darker tilt,
+ *   spread against the dry take by `width`.
+ *
+ * Every random number comes from the track id (and note id), so a render
+ * is byte-identical on every run.
+ */
+import type { FxValues } from "../../../core/fx.ts";
+import type { Track } from "../../../core/score.ts";
+import { seededRandom } from "../dsp/rng.ts";
+import { OnePole } from "../dsp/filters.ts";
+import {
+  CONTROL_SAMPLES,
+  clamp,
+  fxReader,
+  type EffectContext,
+  type EffectNote,
+} from "./common.ts";
+
+const CENTS_TO_LOG = Math.LN2 / 1200;
+
+/** Catmull-Rom (4-point Hermite) read of `x` at a fractional position. */
+function readAt(x: Float64Array, position: number): number {
+  const last = x.length - 1;
+  if (last < 0) return 0;
+  const p = clamp(position, 0, last);
+  const i = Math.floor(p);
+  const t = p - i;
+  const a = x[Math.max(0, i - 1)]!;
+  const b = x[i]!;
+  const c = x[Math.min(last, i + 1)]!;
+  const d = x[Math.min(last, i + 2)]!;
+  const c1 = 0.5 * (c - a);
+  const c2 = a - 2.5 * b + 2 * c - 0.5 * d;
+  const c3 = 0.5 * (d - a) + 1.5 * (b - c);
+  return ((c3 * t + c2) * t + c1) * t + b;
+}
+
+export type WobbleShape = Readonly<{
+  /** Read offset in seconds at time t (positive: earlier audio). */
+  offset: (t: number) => number;
+  /** Pitch deviation in cents at time t. */
+  cents: (t: number) => number;
+  /** Largest possible |offset| in seconds (the components' summed amplitude). */
+  span: number;
+}>;
+
+/**
+ * Most a wobble moves a note in time, in seconds. Slow, deep settings
+ * (100 c at 0.05 Hz) would otherwise drag strums 170 ms off the grid; past
+ * this bound the depth gives way instead.
+ */
+export const WOBBLE_MAX_OFFSET = 0.015;
+
+/**
+ * The track's wobble curve: three seeded sines (the first at `rate`, the
+ * others off-ratio) weighted by `drift`. Each component's delay amplitude
+ * is chosen so its pitch contribution peaks at its share of `depth`.
+ */
+export function wobbleShape(
+  depth: number,
+  rate: number,
+  drift: number,
+  seed: string,
+): WobbleShape {
+  const r = seededRandom(`wobble:${seed}`);
+  const phase = [r(), r(), r()].map((x) => x * 2 * Math.PI);
+  const ratio = [1, 0.61 + 0.1 * r(), 1.53 + 0.2 * r()];
+  const d = clamp(drift, 0, 1);
+  const weight = [1 - d, 0.6 * d, 0.4 * d];
+  const norm = weight[0]! + weight[1]! + weight[2]!;
+  const hz = ratio.map((k) => Math.max(0.01, rate) * k);
+  // Delay amplitude (s) whose derivative peaks at the component's cents.
+  const amp = hz.map(
+    (f, k) => ((weight[k]! / norm) * depth * CENTS_TO_LOG) / (2 * Math.PI * f),
+  );
+  return {
+    span: amp[0]! + amp[1]! + amp[2]!,
+    // Reading at t + offset(t): ratio = 1 + offset'(t) ≈ 2^(cents/1200).
+    offset: (t) => {
+      let s = 0;
+      for (let k = 0; k < 3; k += 1)
+        s += amp[k]! * Math.sin(2 * Math.PI * hz[k]! * t + phase[k]!);
+      return s;
+    },
+    cents: (t) => {
+      let s = 0;
+      for (let k = 0; k < 3; k += 1)
+        s +=
+          amp[k]! *
+          2 *
+          Math.PI *
+          hz[k]! *
+          Math.cos(2 * Math.PI * hz[k]! * t + phase[k]!);
+      return s / CENTS_TO_LOG;
+    },
+  };
+}
+
+export function applyWobble(
+  buffer: Float64Array,
+  track: Track,
+  values: FxValues,
+  context: EffectContext,
+): void {
+  const read = fxReader(track, "wobble", values, context);
+  const depth = read.param("depth");
+  const rate = read.number("rate");
+  const drift = read.number("drift");
+  const sr = context.sampleRate;
+  const peak = depth.automated ? 100 : depth.at(0);
+  if (peak <= 0 || buffer.length === 0) return;
+  // Unit-depth shape, scaled by the (possibly automated) depth.
+  const shape = wobbleShape(1, rate, drift, track.id);
+  // Depth that keeps every read within WOBBLE_MAX_OFFSET of the grid.
+  const most = shape.span > 0 ? WOBBLE_MAX_OFFSET / shape.span : Infinity;
+  const source = buffer.slice();
+  let scale = Math.min(most, depth.at(0));
+  for (let index = 0; index < buffer.length; index += 1) {
+    if (depth.automated && index % CONTROL_SAMPLES === 0)
+      scale = Math.min(most, depth.at(index));
+    const t = index / sr;
+    buffer[index] = readAt(source, index + scale * shape.offset(t) * sr);
+  }
+}
+
+/**
+ * Feedback bloom. Only the highest note sounding at once feeds back (one
+ * dominant loop), and only once it has been held past `delay`. One sweep:
+ * the dominant note is found per 32-sample block from the sorted note
+ * starts and a small active set, and a hand-over crossfades 20 ms, so the
+ * cost is O(samples + notes log notes) even on a dense strum.
+ *
+ * The partial feeds back from the signal itself: its level follows an
+ * envelope of the incoming buffer (50 ms attack, `time` release), so a
+ * quiet, faded or muted track blooms quietly or not at all, and the
+ * partial never sits more than about -6 dB under the input's peak.
+ */
+export function applyBloom(
+  buffer: Float64Array,
+  track: Track,
+  values: FxValues,
+  context: EffectContext,
+): void {
+  const notes = context.notes;
+  if (!notes || notes.length === 0) return;
+  const read = fxReader(track, "bloom", values, context);
+  const amount = read.number("amount");
+  if (amount <= 0) return;
+  const harm = read.number("harm");
+  const sr = context.sampleRate;
+  const delay = Math.round(read.number("delay") * sr);
+  const grow = Math.max(0.05, read.number("time"));
+  const release = Math.round(0.08 * sr);
+  const fade = Math.max(1, Math.round(0.02 * sr));
+  // Envelope (peak-equivalent of a smoothed RMS) of the input.
+  const follow = new Float64Array(buffer.length);
+  const up = 1 - Math.exp(-1 / (0.05 * sr));
+  const down = 1 - Math.exp(-1 / (Math.max(0.1, grow) * sr));
+  let power = 0;
+  for (let index = 0; index < buffer.length; index += 1) {
+    const x2 = buffer[index]! * buffer[index]!;
+    power += (x2 > power ? up : down) * (x2 - power);
+    follow[index] = Math.sqrt(2 * power);
+  }
+  const sorted = notes
+    .filter((note) => note.length > delay)
+    .sort((x, y) => x.start - y.start || y.hz - x.hz);
+  type Loop = {
+    note: EffectNote;
+    phase: number;
+    driftHz: number;
+    level: number;
+    /** Hand-over gain 0..1 and its direction. */
+    gain: number;
+    rising: boolean;
+  };
+  const loops: Loop[] = [];
+  const active: EffectNote[] = [];
+  let next = 0;
+  let current: EffectNote | undefined;
+  for (let block = 0; block < buffer.length; block += BLOCK) {
+    while (next < sorted.length && sorted[next]!.start <= block)
+      active.push(sorted[next++]!);
+    for (let k = active.length - 1; k >= 0; k -= 1)
+      if (active[k]!.start + active[k]!.length <= block) active.splice(k, 1);
+    let top: EffectNote | undefined;
+    for (const note of active)
+      if (note.start + delay <= block && (!top || note.hz > top.hz)) top = note;
+    if (top !== current) {
+      for (const loop of loops) if (loop.note !== top) loop.rising = false;
+      if (top && !loops.some((loop) => loop.note === top)) {
+        const r = seededRandom(`bloom:${track.id}:${top.id}`);
+        loops.push({
+          note: top,
+          phase: r() * 2 * Math.PI,
+          driftHz: 0.2 + 0.3 * r(),
+          // Relative to the input envelope; at most -6 dB under it.
+          level: Math.min(0.5, 0.6 * amount * (0.5 + 0.5 * top.velocity)),
+          gain: current ? 0 : 1,
+          rising: true,
+        });
+      }
+      current = top;
+    }
+    const end = Math.min(buffer.length, block + BLOCK);
+    for (let k = loops.length - 1; k >= 0; k -= 1) {
+      const loop = loops[k]!;
+      const from = loop.note.start + delay;
+      const off = loop.note.start + loop.note.length;
+      for (let index = block; index < end; index += 1) {
+        const t = (index - from) / sr;
+        const cents = 3 * Math.sin(2 * Math.PI * loop.driftHz * t);
+        loop.phase +=
+          (2 * Math.PI * harm * loop.note.hz * 2 ** (cents / 1200)) / sr;
+        loop.gain = loop.rising
+          ? Math.min(1, loop.gain + 1 / fade)
+          : Math.max(0, loop.gain - 1 / fade);
+        let env =
+          follow[index]! * loop.level * loop.gain * (1 - Math.exp(-t / grow));
+        if (index > off) env *= Math.max(0, 1 - (index - off) / release);
+        buffer[index]! += env * Math.sin(loop.phase);
+      }
+      if (loop.gain <= 0 || end > off + release) {
+        loops.splice(k, 1);
+        if (current === loop.note) current = undefined;
+      }
+    }
+  }
+}
+
+/** Control block of the bloom sweep, in samples. */
+const BLOCK = 32;
+
+/** Onset clusters (notes within 40 ms of the cluster's first), sorted. */
+function onsets(notes: readonly EffectNote[], sr: number): number[] {
+  const gap = 0.04 * sr;
+  const out: number[] = [];
+  for (const start of notes.map((note) => note.start).sort((a, b) => a - b))
+    if (out.length === 0 || start - out[out.length - 1]! > gap) out.push(start);
+  return out;
+}
+
+export function applySwell(
+  buffer: Float64Array,
+  track: Track,
+  values: FxValues,
+  context: EffectContext,
+): void {
+  const notes = context.notes;
+  if (!notes || notes.length === 0) return;
+  const read = fxReader(track, "swell", values, context);
+  const mix = read.param("mix");
+  const sr = context.sampleRate;
+  // Reaches about -0.4 dB at `time`.
+  const tau = (Math.max(0.01, read.number("time")) / 3) * sr;
+  // A new onset over a ringing chord first ducks the gain to 0 over at
+  // most `duck` (scaled by how high it was), then rises again: no click.
+  const duck = 0.006 * sr;
+  const starts = onsets(notes, sr);
+  let next = 0;
+  let last = Number.NEGATIVE_INFINITY;
+  let g = 1;
+  let from = 0;
+  let fall = 0;
+  let wet = mix.at(0);
+  for (let index = 0; index < buffer.length; index += 1) {
+    if (mix.automated && index % CONTROL_SAMPLES === 0) wet = mix.at(index);
+    while (next < starts.length && starts[next]! <= index) {
+      // Before the first onset nothing sounds: rise from silence.
+      from = last === Number.NEGATIVE_INFINITY ? 0 : g;
+      fall = Math.round(duck * from);
+      last = starts[next++]!;
+    }
+    if (last !== Number.NEGATIVE_INFINITY) {
+      const elapsed = index - last;
+      g =
+        elapsed < fall
+          ? from * (1 - elapsed / fall)
+          : 1 - Math.exp(-(elapsed - fall) / tau);
+    }
+    buffer[index] = buffer[index]! * (1 - wet + wet * g * g);
+  }
+}
+
+/** Seeded wandering delay of one channel, read non-causally from `x`. */
+function secondTake(
+  x: Float64Array,
+  time: number,
+  drift: number,
+  seed: string,
+  sr: number,
+): Float64Array {
+  const r = seededRandom(`double:${seed}`);
+  const ph1 = r() * 2 * Math.PI;
+  const ph2 = r() * 2 * Math.PI;
+  const f1 = 0.35 + 0.3 * r();
+  const f2 = 0.11 + 0.1 * r();
+  const tilt = new OnePole(5500, sr);
+  const out = new Float64Array(x.length);
+  let d = (time / 1000) * sr;
+  for (let index = 0; index < x.length; index += 1) {
+    if (index % CONTROL_SAMPLES === 0) {
+      const t = index / sr;
+      const wander =
+        0.65 * Math.sin(2 * Math.PI * f1 * t + ph1) +
+        0.35 * Math.sin(2 * Math.PI * f2 * t + ph2);
+      d = ((time + drift * wander) / 1000) * sr;
+    }
+    const position = index - d;
+    out[index] = tilt.process(position < 0 ? 0 : readAt(x, position));
+  }
+  return out;
+}
+
+export function applyDouble(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  values: FxValues,
+  context: EffectContext,
+): void {
+  const read = fxReader(track, "double", values, context);
+  const time = read.number("time");
+  const drift = read.number("drift");
+  const width = clamp(read.number("width"), 0, 1);
+  const sr = context.sampleRate;
+  const copyL = secondTake(left, time, drift, track.id, sr);
+  const copyR = secondTake(right, time, drift, track.id, sr);
+  for (let index = 0; index < left.length; index += 1) {
+    const l = left[index]!;
+    const r = right[index]!;
+    const cl = copyL[index]!;
+    const cr = copyR[index]!;
+    // width 1: the dry take left, the second take right; 0: both centred.
+    left[index] = 0.5 * (l + cl) + 0.5 * width * (l - cl);
+    right[index] = 0.5 * (r + cr) - 0.5 * width * (r - cr);
+  }
+}

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