@e9g/buffered-audio-nodes-utils 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+import { ExecutionProvider } from 'buffered-audio-nodes-core';
+
+declare function bandpass(channels: Array<Float32Array>, sampleRate: number, highPass?: number, lowPass?: number): void;
+
+interface BiquadCoefficients {
+    fb: [number, number, number];
+    fa: [number, number, number];
+}
+declare function biquadFilter(samples: Float32Array, fb: [number, number, number], fa: [number, number, number]): Float32Array;
+declare function zeroPhaseBiquadFilter(signal: Float32Array, coefficients: BiquadCoefficients): void;
+declare function lowPassCoefficients(sampleRate: number, frequency: number): BiquadCoefficients;
+declare function highPassCoefficients(sampleRate: number, frequency: number): BiquadCoefficients;
+declare function bandPassCoefficients(sampleRate: number, centerFreq: number, quality: number): BiquadCoefficients;
+declare function preFilterCoefficients(sampleRate: number): BiquadCoefficients;
+declare function rlbFilterCoefficients(sampleRate: number): BiquadCoefficients;
+
+declare function dbToLinear(db: number): number;
+declare function linearToDb(linear: number): number;
+
+declare function smoothEnvelope(envelope: Float32Array, windowSize: number, scratch?: Float32Array): void;
+
+type FftBackend = "vkfft" | "fftw" | "js";
+interface FftAddon {
+    batchFft(input: Float32Array, fftSize: number, batchCount: number): {
+        re: Float32Array;
+        im: Float32Array;
+    };
+    batchIfft(re: Float32Array, im: Float32Array, fftSize: number, batchCount: number): Float32Array;
+}
+declare function detectFftBackend(executionProviders: ReadonlyArray<ExecutionProvider>, options?: {
+    vkfftPath?: string;
+    fftwPath?: string;
+}): FftBackend;
+interface FftBackendConfig {
+    readonly backend: FftBackend;
+    readonly addonOptions: {
+        vkfftPath?: string;
+        fftwPath?: string;
+    };
+}
+declare function initFftBackend(executionProviders: ReadonlyArray<ExecutionProvider>, properties: {
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+}): FftBackendConfig;
+declare function getFftAddon(backend: FftBackend, options?: {
+    vkfftPath?: string;
+    fftwPath?: string;
+}): FftAddon | null;
+
+declare function interleave(samples: Array<Float32Array>, frames: number, channels: number): Float32Array;
+declare function deinterleaveBuffer(buffer: Buffer, channels: number): Array<Float32Array>;
+
+/**
+ * Mixed-radix FFT for non-power-of-2 sizes.
+ * Uses Cooley-Tukey decimation-in-time with radix-2, radix-3, and radix-5 butterflies.
+ * All state is per-instance (safe for concurrent use).
+ */
+declare class MixedRadixFft {
+    private readonly size;
+    private readonly radices;
+    private readonly permutation;
+    private readonly twiddleRe;
+    private readonly twiddleIm;
+    readonly frameRe: Float32Array;
+    readonly frameIm: Float32Array;
+    readonly outRe: Float32Array;
+    readonly outIm: Float32Array;
+    private readonly auxIm;
+    constructor(size: number);
+    fft(xRe: Float32Array, xIm: Float32Array, outRe: Float32Array, outIm: Float32Array): void;
+    ifft(xRe: Float32Array, xIm: Float32Array, outRe: Float32Array, outIm: Float32Array): void;
+    private radix2;
+    private radix3;
+    private radix5;
+}
+
+declare function replaceChannel(chunk: {
+    readonly samples: Array<Float32Array>;
+}, ch: number, newData: Float32Array, channels: number): Array<Float32Array>;
+
+/**
+ * Resample audio channels by spawning ffmpeg directly.
+ * This avoids TransformStream nesting deadlocks when called from within _process().
+ */
+declare function resampleDirect(ffmpegPath: string, channels: Array<Float32Array>, sourceSampleRate: number, targetSampleRate: number): Promise<Array<Float32Array>>;
+
+interface StftResult {
+    readonly real: Array<Float32Array>;
+    readonly imag: Array<Float32Array>;
+    readonly frames: number;
+    readonly fftSize: number;
+}
+interface StftOutput {
+    readonly real: Array<Float32Array>;
+    readonly imag: Array<Float32Array>;
+}
+declare function stft(signal: Float32Array, fftSize: number, hopSize: number, output?: StftOutput, backend?: FftBackend, fftAddonOptions?: {
+    vkfftPath?: string;
+    fftwPath?: string;
+}): StftResult;
+declare function istft(result: StftResult, hopSize: number, outputLength: number, backend?: FftBackend, fftAddonOptions?: {
+    vkfftPath?: string;
+    fftwPath?: string;
+}): Float32Array;
+declare function hanningWindow(size: number, periodic?: boolean): Float32Array;
+interface FftWorkspace {
+    re: Float32Array;
+    im: Float32Array;
+    outRe: Float32Array;
+    outIm: Float32Array;
+}
+declare function createFftWorkspace(size: number): FftWorkspace;
+declare function fft(input: Float32Array, workspace?: FftWorkspace): {
+    re: Float32Array;
+    im: Float32Array;
+};
+declare function ifft(re: Float32Array, im: Float32Array, workspace?: FftWorkspace): Float32Array;
+declare function bitReverse(re: Float32Array, im: Float32Array, size: number): void;
+declare function butterflyStages(re: Float32Array, im: Float32Array, size: number): void;
+
+export { type BiquadCoefficients, type FftBackend, type FftBackendConfig, type FftWorkspace, MixedRadixFft, type StftOutput, type StftResult, bandPassCoefficients, bandpass, biquadFilter, bitReverse, butterflyStages, createFftWorkspace, dbToLinear, deinterleaveBuffer, detectFftBackend, fft, getFftAddon, hanningWindow, highPassCoefficients, ifft, initFftBackend, interleave, istft, linearToDb, lowPassCoefficients, preFilterCoefficients, replaceChannel, resampleDirect, rlbFilterCoefficients, smoothEnvelope, stft, zeroPhaseBiquadFilter };

package/dist/index.js

@@ -0,0 +1,773 @@
+import { createRequire } from 'module';
+import { spawn } from 'child_process';
+
+// src/biquad.ts
+function biquadFilter(samples, fb, fa) {
+  const output = new Float32Array(samples.length);
+  let x1 = 0;
+  let x2 = 0;
+  let y1 = 0;
+  let y2 = 0;
+  for (let index = 0; index < samples.length; index++) {
+    const x0 = samples[index] ?? 0;
+    const y0 = fb[0] * x0 + fb[1] * x1 + fb[2] * x2 - fa[1] * y1 - fa[2] * y2;
+    output[index] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+  return output;
+}
+function zeroPhaseBiquadFilter(signal, coefficients) {
+  const { fb, fa } = coefficients;
+  let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+  for (let index = 0; index < signal.length; index++) {
+    const x0 = signal[index] ?? 0;
+    const y0 = fb[0] * x0 + fb[1] * x1 + fb[2] * x2 - fa[1] * y1 - fa[2] * y2;
+    signal[index] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+  x1 = 0;
+  x2 = 0;
+  y1 = 0;
+  y2 = 0;
+  for (let index = signal.length - 1; index >= 0; index--) {
+    const x0 = signal[index] ?? 0;
+    const y0 = fb[0] * x0 + fb[1] * x1 + fb[2] * x2 - fa[1] * y1 - fa[2] * y2;
+    signal[index] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+}
+function lowPassCoefficients(sampleRate, frequency) {
+  const w0 = 2 * Math.PI * frequency / sampleRate;
+  const cosW0 = Math.cos(w0);
+  const sinW0 = Math.sin(w0);
+  const alpha = sinW0 / Math.SQRT2;
+  const a0 = 1 + alpha;
+  return {
+    fb: [(1 - cosW0) / 2 / a0, (1 - cosW0) / a0, (1 - cosW0) / 2 / a0],
+    fa: [1, -2 * cosW0 / a0, (1 - alpha) / a0]
+  };
+}
+function highPassCoefficients(sampleRate, frequency) {
+  const w0 = 2 * Math.PI * frequency / sampleRate;
+  const cosW0 = Math.cos(w0);
+  const sinW0 = Math.sin(w0);
+  const alpha = sinW0 / Math.SQRT2;
+  const a0 = 1 + alpha;
+  return {
+    fb: [(1 + cosW0) / 2 / a0, -(1 + cosW0) / a0, (1 + cosW0) / 2 / a0],
+    fa: [1, -2 * cosW0 / a0, (1 - alpha) / a0]
+  };
+}
+function bandPassCoefficients(sampleRate, centerFreq, quality) {
+  const w0 = 2 * Math.PI * centerFreq / sampleRate;
+  const cosW0 = Math.cos(w0);
+  const sinW0 = Math.sin(w0);
+  const alpha = sinW0 / (2 * quality);
+  const a0 = 1 + alpha;
+  return {
+    fb: [alpha / a0, 0, -alpha / a0],
+    fa: [1, -2 * cosW0 / a0, (1 - alpha) / a0]
+  };
+}
+function preFilterCoefficients(sampleRate) {
+  if (sampleRate === 48e3) {
+    return {
+      fb: [1.53512485958697, -2.69169618940638, 1.19839281085285],
+      fa: [1, -1.69065929318241, 0.73248077421585]
+    };
+  }
+  const freq = 1681.974450955533;
+  const gain = 3.999843853973347;
+  const quality = 0.7071752369554196;
+  const kk = Math.tan(Math.PI * freq / sampleRate);
+  const vh = Math.pow(10, gain / 20);
+  const vb = Math.pow(vh, 0.4996667741545416);
+  const a0 = 1 + kk / quality + kk * kk;
+  return {
+    fb: [(vh + vb * kk / quality + kk * kk) / a0, 2 * (kk * kk - vh) / a0, (vh - vb * kk / quality + kk * kk) / a0],
+    fa: [1, 2 * (kk * kk - 1) / a0, (1 - kk / quality + kk * kk) / a0]
+  };
+}
+function rlbFilterCoefficients(sampleRate) {
+  if (sampleRate === 48e3) {
+    return {
+      fb: [1, -2, 1],
+      fa: [1, -1.99004745483398, 0.99007225036621]
+    };
+  }
+  const freq = 38.13547087602444;
+  const quality = 0.5003270373238773;
+  const kk = Math.tan(Math.PI * freq / sampleRate);
+  const a0 = 1 + kk / quality + kk * kk;
+  return {
+    fb: [1 / a0, -2 / a0, 1 / a0],
+    fa: [1, 2 * (kk * kk - 1) / a0, (1 - kk / quality + kk * kk) / a0]
+  };
+}
+
+// src/bandpass.ts
+function bandpass(channels, sampleRate, highPass, lowPass) {
+  if (!highPass && !lowPass) return;
+  for (const channel of channels) {
+    if (highPass) {
+      zeroPhaseBiquadFilter(channel, highPassCoefficients(sampleRate, highPass));
+    }
+    if (lowPass) {
+      zeroPhaseBiquadFilter(channel, lowPassCoefficients(sampleRate, lowPass));
+    }
+  }
+}
+
+// src/db.ts
+function dbToLinear(db) {
+  if (db === -Infinity) return 0;
+  return Math.pow(10, db / 20);
+}
+function linearToDb(linear) {
+  return 20 * Math.log10(Math.max(linear, 1e-10));
+}
+
+// src/envelope.ts
+function smoothEnvelope(envelope, windowSize, scratch) {
+  const halfWin = Math.floor(windowSize / 2);
+  const len = envelope.length;
+  const source = scratch ?? Float32Array.from(envelope);
+  if (scratch) {
+    source.set(envelope);
+  }
+  let sum = 0;
+  let count = 0;
+  for (let index = 0; index < Math.min(halfWin, len); index++) {
+    sum += source[index] ?? 0;
+    count++;
+  }
+  for (let index = 0; index < len; index++) {
+    const addIdx = index + halfWin;
+    if (addIdx < len) {
+      sum += source[addIdx] ?? 0;
+      count++;
+    }
+    const removeIdx = index - halfWin - 1;
+    if (removeIdx >= 0) {
+      sum -= source[removeIdx] ?? 0;
+      count--;
+    }
+    envelope[index] = sum / Math.max(count, 1);
+  }
+}
+var require2 = createRequire(import.meta.url);
+function tryLoadVkfft(vkfftPath) {
+  if (!vkfftPath) return null;
+  try {
+    return require2(vkfftPath);
+  } catch {
+    return null;
+  }
+}
+function tryLoadFftw(fftwPath) {
+  if (!fftwPath) return null;
+  try {
+    return require2(fftwPath);
+  } catch {
+    return null;
+  }
+}
+function detectFftBackend(executionProviders, options) {
+  for (const provider of executionProviders) {
+    if (provider === "gpu") {
+      const vkfft = tryLoadVkfft(options?.vkfftPath);
+      if (vkfft) {
+        const device = vkfft.detectDevice();
+        if (device) {
+          return "vkfft";
+        }
+      }
+    }
+    if (provider === "cpu-native") {
+      const fftw = tryLoadFftw(options?.fftwPath);
+      if (fftw) {
+        return "fftw";
+      }
+    }
+    if (provider === "cpu") {
+      return "js";
+    }
+  }
+  return "js";
+}
+function initFftBackend(executionProviders, properties) {
+  const addonOptions = { vkfftPath: properties.vkfftAddonPath, fftwPath: properties.fftwAddonPath };
+  const backend = detectFftBackend(executionProviders, addonOptions);
+  return { backend, addonOptions };
+}
+function getFftAddon(backend, options) {
+  if (backend === "vkfft") return tryLoadVkfft(options?.vkfftPath);
+  if (backend === "fftw") return tryLoadFftw(options?.fftwPath);
+  return null;
+}
+
+// src/interleave.ts
+function interleave(samples, frames, channels) {
+  const interleaved = new Float32Array(frames * channels);
+  for (let frame = 0; frame < frames; frame++) {
+    for (let ch = 0; ch < channels; ch++) {
+      interleaved[frame * channels + ch] = samples[ch]?.[frame] ?? 0;
+    }
+  }
+  return interleaved;
+}
+function deinterleaveBuffer(buffer, channels) {
+  const totalSamples = buffer.length / 4;
+  const frames = Math.floor(totalSamples / channels);
+  const result = [];
+  for (let ch = 0; ch < channels; ch++) {
+    result.push(new Float32Array(frames));
+  }
+  const view = new Float32Array(buffer.buffer, buffer.byteOffset, totalSamples);
+  for (let frame = 0; frame < frames; frame++) {
+    for (let ch = 0; ch < channels; ch++) {
+      const channelArray = result[ch];
+      const value = view[frame * channels + ch];
+      if (channelArray && value !== void 0) {
+        channelArray[frame] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/mixed-radix-fft.ts
+var MixedRadixFft = class {
+  constructor(size) {
+    this.size = size;
+    this.radices = factorize(size);
+    this.frameRe = new Float32Array(size);
+    this.frameIm = new Float32Array(size);
+    this.outRe = new Float32Array(size);
+    this.outIm = new Float32Array(size);
+    this.auxIm = new Float32Array(size);
+    this.permutation = computePermutation(size, this.radices);
+    const { twiddleRe, twiddleIm } = computeTwiddles(this.radices);
+    this.twiddleRe = twiddleRe;
+    this.twiddleIm = twiddleIm;
+  }
+  fft(xRe, xIm, outRe, outIm) {
+    const perm = this.permutation;
+    const nn = this.size;
+    for (let index = 0; index < nn; index++) {
+      const pp = perm[index] ?? 0;
+      outRe[index] = xRe[pp] ?? 0;
+      outIm[index] = xIm[pp] ?? 0;
+    }
+    let groupSize = 1;
+    let twOffset = 0;
+    for (const radix of this.radices) {
+      groupSize *= radix;
+      const subSize = groupSize / radix;
+      if (radix === 2) {
+        twOffset = this.radix2(outRe, outIm, nn, groupSize, subSize, twOffset);
+      } else if (radix === 3) {
+        twOffset = this.radix3(outRe, outIm, nn, groupSize, subSize, twOffset);
+      } else if (radix === 5) {
+        twOffset = this.radix5(outRe, outIm, nn, groupSize, subSize, twOffset);
+      }
+    }
+  }
+  ifft(xRe, xIm, outRe, outIm) {
+    const auxIm = this.auxIm;
+    const nn = this.size;
+    for (let index = 0; index < nn; index++) {
+      auxIm[index] = -(xIm[index] ?? 0);
+    }
+    this.fft(xRe, auxIm, outRe, outIm);
+    for (let index = 0; index < nn; index++) {
+      outRe[index] = (outRe[index] ?? 0) / nn;
+      outIm[index] = -(outIm[index] ?? 0) / nn;
+    }
+  }
+  radix2(outRe, outIm, nn, groupSize, subSize, twOffset) {
+    for (let group = 0; group < nn; group += groupSize) {
+      for (let ni = 0; ni < subSize; ni++) {
+        const idx0 = group + ni;
+        const idx1 = idx0 + subSize;
+        const twRe = ni === 0 ? 1 : this.twiddleRe[twOffset + ni - 1] ?? 0;
+        const twIm = ni === 0 ? 0 : this.twiddleIm[twOffset + ni - 1] ?? 0;
+        const tRe = (outRe[idx1] ?? 0) * twRe - (outIm[idx1] ?? 0) * twIm;
+        const tIm = (outRe[idx1] ?? 0) * twIm + (outIm[idx1] ?? 0) * twRe;
+        outRe[idx1] = (outRe[idx0] ?? 0) - tRe;
+        outIm[idx1] = (outIm[idx0] ?? 0) - tIm;
+        outRe[idx0] = (outRe[idx0] ?? 0) + tRe;
+        outIm[idx0] = (outIm[idx0] ?? 0) + tIm;
+      }
+    }
+    return twOffset + subSize - 1;
+  }
+  radix3(outRe, outIm, nn, groupSize, subSize, twOffset) {
+    const c3 = -0.5;
+    const s3 = -Math.sqrt(3) / 2;
+    for (let group = 0; group < nn; group += groupSize) {
+      for (let ni = 0; ni < subSize; ni++) {
+        const idx0 = group + ni;
+        const idx1 = idx0 + subSize;
+        const idx2 = idx0 + 2 * subSize;
+        let tw1Re, tw1Im, tw2Re, tw2Im;
+        if (ni === 0) {
+          tw1Re = 1;
+          tw1Im = 0;
+          tw2Re = 1;
+          tw2Im = 0;
+        } else {
+          tw1Re = this.twiddleRe[twOffset + ni - 1] ?? 0;
+          tw1Im = this.twiddleIm[twOffset + ni - 1] ?? 0;
+          tw2Re = this.twiddleRe[twOffset + subSize - 1 + ni - 1] ?? 0;
+          tw2Im = this.twiddleIm[twOffset + subSize - 1 + ni - 1] ?? 0;
+        }
+        const x1Re = (outRe[idx1] ?? 0) * tw1Re - (outIm[idx1] ?? 0) * tw1Im;
+        const x1Im = (outRe[idx1] ?? 0) * tw1Im + (outIm[idx1] ?? 0) * tw1Re;
+        const x2Re = (outRe[idx2] ?? 0) * tw2Re - (outIm[idx2] ?? 0) * tw2Im;
+        const x2Im = (outRe[idx2] ?? 0) * tw2Im + (outIm[idx2] ?? 0) * tw2Re;
+        const x0Re = outRe[idx0] ?? 0;
+        const x0Im = outIm[idx0] ?? 0;
+        const sumRe = x1Re + x2Re;
+        const sumIm = x1Im + x2Im;
+        const diffRe = x1Re - x2Re;
+        const diffIm = x1Im - x2Im;
+        outRe[idx0] = x0Re + sumRe;
+        outIm[idx0] = x0Im + sumIm;
+        outRe[idx1] = x0Re + c3 * sumRe - s3 * diffIm;
+        outIm[idx1] = x0Im + c3 * sumIm + s3 * diffRe;
+        outRe[idx2] = x0Re + c3 * sumRe + s3 * diffIm;
+        outIm[idx2] = x0Im + c3 * sumIm - s3 * diffRe;
+      }
+    }
+    return twOffset + 2 * (subSize - 1);
+  }
+  radix5(outRe, outIm, nn, groupSize, subSize, twOffset) {
+    const cos1 = Math.cos(2 * Math.PI / 5);
+    const cos2 = Math.cos(4 * Math.PI / 5);
+    const sin1 = -Math.sin(2 * Math.PI / 5);
+    const sin2 = -Math.sin(4 * Math.PI / 5);
+    for (let group = 0; group < nn; group += groupSize) {
+      for (let ni = 0; ni < subSize; ni++) {
+        const idx0 = group + ni;
+        const idx1 = idx0 + subSize;
+        const idx2 = idx0 + 2 * subSize;
+        const idx3 = idx0 + 3 * subSize;
+        const idx4 = idx0 + 4 * subSize;
+        let tw1Re, tw1Im;
+        let tw2Re, tw2Im;
+        let tw3Re, tw3Im;
+        let tw4Re, tw4Im;
+        if (ni === 0) {
+          tw1Re = 1;
+          tw1Im = 0;
+          tw2Re = 1;
+          tw2Im = 0;
+          tw3Re = 1;
+          tw3Im = 0;
+          tw4Re = 1;
+          tw4Im = 0;
+        } else {
+          tw1Re = this.twiddleRe[twOffset + ni - 1] ?? 0;
+          tw1Im = this.twiddleIm[twOffset + ni - 1] ?? 0;
+          tw2Re = this.twiddleRe[twOffset + subSize - 1 + ni - 1] ?? 0;
+          tw2Im = this.twiddleIm[twOffset + subSize - 1 + ni - 1] ?? 0;
+          tw3Re = this.twiddleRe[twOffset + 2 * (subSize - 1) + ni - 1] ?? 0;
+          tw3Im = this.twiddleIm[twOffset + 2 * (subSize - 1) + ni - 1] ?? 0;
+          tw4Re = this.twiddleRe[twOffset + 3 * (subSize - 1) + ni - 1] ?? 0;
+          tw4Im = this.twiddleIm[twOffset + 3 * (subSize - 1) + ni - 1] ?? 0;
+        }
+        const x0Re = outRe[idx0] ?? 0;
+        const x0Im = outIm[idx0] ?? 0;
+        const x1Re = (outRe[idx1] ?? 0) * tw1Re - (outIm[idx1] ?? 0) * tw1Im;
+        const x1Im = (outRe[idx1] ?? 0) * tw1Im + (outIm[idx1] ?? 0) * tw1Re;
+        const x2Re = (outRe[idx2] ?? 0) * tw2Re - (outIm[idx2] ?? 0) * tw2Im;
+        const x2Im = (outRe[idx2] ?? 0) * tw2Im + (outIm[idx2] ?? 0) * tw2Re;
+        const x3Re = (outRe[idx3] ?? 0) * tw3Re - (outIm[idx3] ?? 0) * tw3Im;
+        const x3Im = (outRe[idx3] ?? 0) * tw3Im + (outIm[idx3] ?? 0) * tw3Re;
+        const x4Re = (outRe[idx4] ?? 0) * tw4Re - (outIm[idx4] ?? 0) * tw4Im;
+        const x4Im = (outRe[idx4] ?? 0) * tw4Im + (outIm[idx4] ?? 0) * tw4Re;
+        const sum14Re = x1Re + x4Re;
+        const sum14Im = x1Im + x4Im;
+        const diff14Re = x1Re - x4Re;
+        const diff14Im = x1Im - x4Im;
+        const sum23Re = x2Re + x3Re;
+        const sum23Im = x2Im + x3Im;
+        const diff23Re = x2Re - x3Re;
+        const diff23Im = x2Im - x3Im;
+        outRe[idx0] = x0Re + sum14Re + sum23Re;
+        outIm[idx0] = x0Im + sum14Im + sum23Im;
+        outRe[idx1] = x0Re + cos1 * sum14Re + cos2 * sum23Re - sin1 * diff14Im - sin2 * diff23Im;
+        outIm[idx1] = x0Im + cos1 * sum14Im + cos2 * sum23Im + sin1 * diff14Re + sin2 * diff23Re;
+        outRe[idx2] = x0Re + cos2 * sum14Re + cos1 * sum23Re - sin2 * diff14Im + sin1 * diff23Im;
+        outIm[idx2] = x0Im + cos2 * sum14Im + cos1 * sum23Im + sin2 * diff14Re - sin1 * diff23Re;
+        outRe[idx3] = x0Re + cos2 * sum14Re + cos1 * sum23Re + sin2 * diff14Im - sin1 * diff23Im;
+        outIm[idx3] = x0Im + cos2 * sum14Im + cos1 * sum23Im - sin2 * diff14Re + sin1 * diff23Re;
+        outRe[idx4] = x0Re + cos1 * sum14Re + cos2 * sum23Re + sin1 * diff14Im + sin2 * diff23Im;
+        outIm[idx4] = x0Im + cos1 * sum14Im + cos2 * sum23Im - sin1 * diff14Re - sin2 * diff23Re;
+      }
+    }
+    return twOffset + 4 * (subSize - 1);
+  }
+};
+function factorize(size) {
+  const factors = [];
+  let remaining = size;
+  for (const prime of [5, 3, 2]) {
+    while (remaining % prime === 0) {
+      factors.push(prime);
+      remaining /= prime;
+    }
+  }
+  if (remaining !== 1) {
+    throw new Error(`MixedRadixFft: size ${size} has unsupported prime factor ${remaining} (only 2, 3, 5 supported)`);
+  }
+  factors.sort((lhs, rhs) => lhs - rhs);
+  return factors;
+}
+function computePermutation(size, radices) {
+  const permutation = new Uint16Array(size);
+  for (let index = 0; index < size; index++) {
+    let remainder = index;
+    let permuted = 0;
+    let base = size;
+    for (const radix of radices) {
+      base = base / radix;
+      const digit = remainder % radix;
+      remainder = Math.floor(remainder / radix);
+      permuted += digit * base;
+    }
+    permutation[index] = permuted;
+  }
+  return permutation;
+}
+function computeTwiddles(radices) {
+  let totalTwiddles = 0;
+  let groupSize = 1;
+  for (const radix of radices) {
+    groupSize *= radix;
+    totalTwiddles += (radix - 1) * (groupSize / radix);
+  }
+  const twiddleRe = new Float32Array(totalTwiddles);
+  const twiddleIm = new Float32Array(totalTwiddles);
+  let twOffset = 0;
+  groupSize = 1;
+  for (const radix of radices) {
+    groupSize *= radix;
+    const subSize = groupSize / radix;
+    for (let kk = 1; kk < radix; kk++) {
+      for (let ni = 0; ni < subSize; ni++) {
+        const angle = -2 * Math.PI * kk * ni / groupSize;
+        twiddleRe[twOffset] = Math.cos(angle);
+        twiddleIm[twOffset] = Math.sin(angle);
+        twOffset++;
+      }
+    }
+  }
+  return { twiddleRe, twiddleIm };
+}
+
+// src/replace-channel.ts
+function replaceChannel(chunk, ch, newData, channels) {
+  const frames = newData.length;
+  const result = [];
+  for (let writeCh = 0; writeCh < channels; writeCh++) {
+    result.push(writeCh === ch ? newData : chunk.samples[writeCh] ?? new Float32Array(frames));
+  }
+  return result;
+}
+function resampleDirect(ffmpegPath, channels, sourceSampleRate, targetSampleRate) {
+  if (sourceSampleRate === targetSampleRate) {
+    return Promise.resolve(channels.map((ch) => ch.slice()));
+  }
+  const numChannels = channels.length;
+  const frames = channels[0]?.length ?? 0;
+  if (frames === 0 || numChannels === 0) {
+    return Promise.resolve(channels);
+  }
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-f",
+      "f32le",
+      "-ar",
+      String(sourceSampleRate),
+      "-ac",
+      String(numChannels),
+      "-i",
+      "pipe:0",
+      "-af",
+      `aresample=${targetSampleRate}:resampler=soxr:dither_method=triangular`,
+      "-f",
+      "f32le",
+      "-ar",
+      String(targetSampleRate),
+      "-ac",
+      String(numChannels),
+      "pipe:1"
+    ];
+    const proc = spawn(ffmpegPath, args, { stdio: ["pipe", "pipe", "pipe"] });
+    const stdout = proc.stdout;
+    const stdin = proc.stdin;
+    const outputChunks = [];
+    const stderrChunks = [];
+    stdout.on("data", (chunk) => outputChunks.push(chunk));
+    proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    proc.on("error", (error) => {
+      reject(new Error(`Failed to spawn ffmpeg: ${error.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        const stderrOutput = Buffer.concat(stderrChunks).toString();
+        reject(new Error(`ffmpeg exited with code ${code}: ${stderrOutput}`));
+        return;
+      }
+      const outputBuffer = Buffer.concat(outputChunks);
+      resolve(deinterleaveBuffer(outputBuffer, numChannels));
+    });
+    stdin.on("error", () => {
+    });
+    const interleaved = interleave(channels, frames, numChannels);
+    const buf = Buffer.from(interleaved.buffer, interleaved.byteOffset, interleaved.byteLength);
+    stdin.write(buf, () => stdin.end());
+  });
+}
+
+// src/stft.ts
+function stft(signal, fftSize, hopSize, output, backend, fftAddonOptions) {
+  const window = hanningWindow(fftSize);
+  const numFrames = Math.floor((signal.length - fftSize) / hopSize) + 1;
+  const halfSize = fftSize / 2 + 1;
+  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
+  if (addon && numFrames > 0) {
+    const batchInput = new Float32Array(fftSize * numFrames);
+    for (let frame = 0; frame < numFrames; frame++) {
+      const offset = frame * hopSize;
+      for (let index = 0; index < fftSize; index++) {
+        batchInput[frame * fftSize + index] = (signal[offset + index] ?? 0) * (window[index] ?? 0);
+      }
+    }
+    const { re: batchRe, im: batchIm } = addon.batchFft(batchInput, fftSize, numFrames);
+    const real2 = output?.real ?? [];
+    const imag2 = output?.imag ?? [];
+    for (let frame = 0; frame < numFrames; frame++) {
+      const reSlice = batchRe.subarray(frame * halfSize, (frame + 1) * halfSize);
+      const imSlice = batchIm.subarray(frame * halfSize, (frame + 1) * halfSize);
+      if (output) {
+        output.real[frame]?.set(reSlice);
+        output.imag[frame]?.set(imSlice);
+      } else {
+        real2.push(Float32Array.from(reSlice));
+        imag2.push(Float32Array.from(imSlice));
+      }
+    }
+    return { real: real2, imag: imag2, frames: numFrames, fftSize };
+  }
+  const real = output?.real ?? [];
+  const imag = output?.imag ?? [];
+  const windowed = new Float32Array(fftSize);
+  const workspace = createFftWorkspace(fftSize);
+  for (let frame = 0; frame < numFrames; frame++) {
+    const offset = frame * hopSize;
+    for (let index = 0; index < fftSize; index++) {
+      windowed[index] = (signal[offset + index] ?? 0) * (window[index] ?? 0);
+    }
+    const { re, im } = fft(windowed, workspace);
+    if (output) {
+      output.real[frame]?.set(re.subarray(0, halfSize));
+      output.imag[frame]?.set(im.subarray(0, halfSize));
+    } else {
+      real.push(re.slice(0, halfSize));
+      imag.push(im.slice(0, halfSize));
+    }
+  }
+  return { real, imag, frames: numFrames, fftSize };
+}
+function istft(result, hopSize, outputLength, backend, fftAddonOptions) {
+  const { real, imag, frames, fftSize } = result;
+  const window = hanningWindow(fftSize);
+  const output = new Float32Array(outputLength);
+  const windowSum = new Float32Array(outputLength);
+  const halfSize = fftSize / 2 + 1;
+  const addon = backend ? getFftAddon(backend, fftAddonOptions) : null;
+  if (addon && frames > 0) {
+    const batchRe = new Float32Array(halfSize * frames);
+    const batchIm = new Float32Array(halfSize * frames);
+    for (let frame = 0; frame < frames; frame++) {
+      const re = real[frame];
+      const im = imag[frame];
+      if (!re || !im) continue;
+      batchRe.set(re, frame * halfSize);
+      batchIm.set(im, frame * halfSize);
+    }
+    const timeDomainBatch = addon.batchIfft(batchRe, batchIm, fftSize, frames);
+    for (let frame = 0; frame < frames; frame++) {
+      const offset = frame * hopSize;
+      for (let index = 0; index < fftSize; index++) {
+        const pos = offset + index;
+        if (pos < outputLength) {
+          output[pos] = (output[pos] ?? 0) + (timeDomainBatch[frame * fftSize + index] ?? 0) * (window[index] ?? 0);
+          windowSum[pos] = (windowSum[pos] ?? 0) + (window[index] ?? 0) * (window[index] ?? 0);
+        }
+      }
+    }
+  } else {
+    const fullRe = new Float32Array(fftSize);
+    const fullIm = new Float32Array(fftSize);
+    const workspace = createFftWorkspace(fftSize);
+    for (let frame = 0; frame < frames; frame++) {
+      const re = real[frame];
+      const im = imag[frame];
+      if (!re || !im) continue;
+      fullRe.fill(0);
+      fullIm.fill(0);
+      fullRe.set(re);
+      fullIm.set(im);
+      for (let index = 1; index < halfSize - 1; index++) {
+        fullRe[fftSize - index] = re[index] ?? 0;
+        fullIm[fftSize - index] = -(im[index] ?? 0);
+      }
+      const timeDomain = ifft(fullRe, fullIm, workspace);
+      const offset = frame * hopSize;
+      for (let index = 0; index < fftSize; index++) {
+        const pos = offset + index;
+        if (pos < outputLength) {
+          output[pos] = (output[pos] ?? 0) + (timeDomain[index] ?? 0) * (window[index] ?? 0);
+          windowSum[pos] = (windowSum[pos] ?? 0) + (window[index] ?? 0) * (window[index] ?? 0);
+        }
+      }
+    }
+  }
+  for (let index = 0; index < outputLength; index++) {
+    const ws = windowSum[index] ?? 0;
+    if (ws > 1e-8) {
+      output[index] = (output[index] ?? 0) / ws;
+    }
+  }
+  return output;
+}
+var hanningWindowCache = /* @__PURE__ */ new Map();
+function hanningWindow(size, periodic = true) {
+  const key = `${size}:${periodic ? "p" : "s"}`;
+  const cached = hanningWindowCache.get(key);
+  if (cached) return cached;
+  const window = new Float32Array(size);
+  const denominator = periodic ? size : size - 1;
+  for (let index = 0; index < size; index++) {
+    window[index] = 0.5 * (1 - Math.cos(2 * Math.PI * index / denominator));
+  }
+  hanningWindowCache.set(key, window);
+  return window;
+}
+function createFftWorkspace(size) {
+  return {
+    re: new Float32Array(size),
+    im: new Float32Array(size),
+    outRe: new Float32Array(size),
+    outIm: new Float32Array(size)
+  };
+}
+function fft(input, workspace) {
+  const size = input.length;
+  const re = workspace ? workspace.re : new Float32Array(size);
+  const im = workspace ? workspace.im : new Float32Array(size);
+  re.set(input);
+  if (workspace) im.fill(0);
+  if (size <= 1) return { re, im };
+  bitReverse(re, im, size);
+  butterflyStages(re, im, size);
+  return { re, im };
+}
+function ifft(re, im, workspace) {
+  const size = re.length;
+  const outRe = workspace ? workspace.outRe : Float32Array.from(re);
+  const outIm = workspace ? workspace.outIm : new Float32Array(size);
+  if (workspace) outRe.set(re);
+  for (let index = 0; index < size; index++) {
+    outIm[index] = -(im[index] ?? 0);
+  }
+  bitReverse(outRe, outIm, size);
+  butterflyStages(outRe, outIm, size);
+  for (let index = 0; index < size; index++) {
+    outRe[index] = (outRe[index] ?? 0) / size;
+  }
+  return outRe;
+}
+function bitReverse(re, im, size) {
+  let rev = 0;
+  for (let index = 0; index < size - 1; index++) {
+    if (index < rev) {
+      const tempRe = re[index];
+      const tempIm = im[index];
+      re[index] = re[rev];
+      im[index] = im[rev];
+      re[rev] = tempRe;
+      im[rev] = tempIm;
+    }
+    let bit = size >> 1;
+    while (bit <= rev) {
+      rev -= bit;
+      bit >>= 1;
+    }
+    rev += bit;
+  }
+}
+var twiddleCache = /* @__PURE__ */ new Map();
+function getTwiddleFactors(size) {
+  let cached = twiddleCache.get(size);
+  if (cached) return cached;
+  const totalFactors = size / 2 * Math.log2(size);
+  const twRe = new Float32Array(totalFactors);
+  const twIm = new Float32Array(totalFactors);
+  let offset = 0;
+  for (let step = 2; step <= size; step *= 2) {
+    const halfStep = step / 2;
+    const angle = -2 * Math.PI / step;
+    for (let pair = 0; pair < halfStep; pair++) {
+      twRe[offset + pair] = Math.cos(angle * pair);
+      twIm[offset + pair] = Math.sin(angle * pair);
+    }
+    offset += halfStep;
+  }
+  cached = { re: twRe, im: twIm };
+  twiddleCache.set(size, cached);
+  return cached;
+}
+function butterflyStages(re, im, size) {
+  const twiddle = getTwiddleFactors(size);
+  const twRe = twiddle.re;
+  const twIm = twiddle.im;
+  let twOffset = 0;
+  for (let step = 2; step <= size; step *= 2) {
+    const halfStep = step / 2;
+    for (let group = 0; group < size; group += step) {
+      for (let pair = 0; pair < halfStep; pair++) {
+        const wr = twRe[twOffset + pair];
+        const wi = twIm[twOffset + pair];
+        const evenIdx = group + pair;
+        const oddIdx = group + pair + halfStep;
+        const oddRe = re[oddIdx];
+        const oddIm = im[oddIdx];
+        const evenRe = re[evenIdx];
+        const evenIm = im[evenIdx];
+        const tRe = oddRe * wr - oddIm * wi;
+        const tIm = oddRe * wi + oddIm * wr;
+        re[oddIdx] = evenRe - tRe;
+        im[oddIdx] = evenIm - tIm;
+        re[evenIdx] = evenRe + tRe;
+        im[evenIdx] = evenIm + tIm;
+      }
+    }
+    twOffset += halfStep;
+  }
+}
+
+export { MixedRadixFft, bandPassCoefficients, bandpass, biquadFilter, bitReverse, butterflyStages, createFftWorkspace, dbToLinear, deinterleaveBuffer, detectFftBackend, fft, getFftAddon, hanningWindow, highPassCoefficients, ifft, initFftBackend, interleave, istft, linearToDb, lowPassCoefficients, preFilterCoefficients, replaceChannel, resampleDirect, rlbFilterCoefficients, smoothEnvelope, stft, zeroPhaseBiquadFilter };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@e9g/buffered-audio-nodes-utils",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Matt Cavender",
+  "license": "ISC",
+  "scripts": {
+    "check": "concurrently \"eslint . --fix --cache --format ../../agent-eslint.js\" \"tsc --noEmit --pretty false 2>&1 | node ../../agent-tsc.js\"",
+    "check:verbose": "concurrently \"eslint .\" \"tsc --noEmit\"",
+    "lint": "eslint . --fix --cache --format ../../agent-eslint.js",
+    "lint:verbose": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "build": "tsup",
+    "unit": "vitest run unit"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "concurrently": "*",
+    "tsup": "^8.0.0",
+    "typescript": "*",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "@e9g/buffered-audio-nodes-core": "*"
+  }
+}