Spaces:
Running
Running
| // effects.js - dependency-free browser port of scripts/effects.py (numpy + scipy + librosa DSP chain). | |
| // | |
| // applyChain(wav /* Float32Array mono */, sr, { pitch: 2, robot: 40, ... }) -> Float32Array | |
| // | |
| // Processing order == order of EFFECTS (time -> identity -> tone -> character -> space -> output), | |
| // identical to the Python module. Filters, gain, gate and delay effects are numerically matched to | |
| // scipy (float64 internally, float32 between stages like the Python code). STFT-based effects follow | |
| // the same algorithms (librosa 1.0 phase vocoder, scipy stft/istft framing); micro-pitch and room use | |
| // a seeded JS PRNG instead of numpy's PCG64 stream, so they are perceptually (not sample-) equivalent. | |
| export const EFFECTS = [ | |
| // key, label, group, min, max, step, default, unit, desc | |
| { key: "speed", label: "Tempo", group: "Time", min: 0.7, max: 1.4, step: 0.05, default: 1.0, unit: "×", desc: "time stretch without changing pitch (granular OLA)" }, | |
| { key: "pitch", label: "Pitch", group: "Identity", min: -6, max: 6, step: 0.5, default: 0, unit: "st", desc: "lower ↔ higher, duration unchanged" }, | |
| { key: "formant", label: "Vocal tract", group: "Identity", min: -6, max: 6, step: 0.5, default: 0, unit: "st", desc: "spectral envelope shift (larger ↔ smaller “body”), harmonics unchanged" }, | |
| { key: "warmth", label: "Warmth", group: "Tone", min: -8, max: 8, step: 0.5, default: 0, unit: "dB", desc: "low shelf (250 Hz) – body and weight" }, | |
| { key: "presence", label: "Presence", group: "Tone", min: -8, max: 8, step: 0.5, default: 0, unit: "dB", desc: "high shelf (3.5 kHz) – clarity and edge" }, | |
| { key: "dynamic", label: "Dynamic EQ", group: "Tone", min: 0, max: 100, step: 1, default: 0, unit: "%", desc: "level-dependent harshness reduction at 1.2–4 kHz" }, | |
| { key: "deess", label: "De-esser", group: "Tone", min: 0, max: 100, step: 1, default: 0, unit: "%", desc: "dynamic taming of strong sibilants (>5 kHz)" }, | |
| { key: "drive", label: "Drive", group: "Character", min: 0, max: 50, step: 1, default: 0, unit: "%", desc: "soft tanh saturation – texture and grit" }, | |
| { key: "saturation", label: "Warm saturation", group: "Character", min: 0, max: 100, step: 1, default: 0, unit: "%", desc: "asymmetric soft clipping – harmonic coloring" }, | |
| { key: "robot", label: "Robot", group: "Character", min: 0, max: 100, step: 1, default: 0, unit: "%", desc: "42 Hz ring modulation – metallic color" }, | |
| { key: "micro", label: "Micro-pitch", group: "Character", min: 0, max: 100, step: 1, default: 0, unit: "%", desc: "layer of grains detuned by up to ±85 cents" }, | |
| { key: "halo", label: "Granular halo", group: "Character", min: 0, max: 80, step: 1, default: 0, unit: "%", desc: "35 ms smoothed grains added to the signal" }, | |
| { key: "chorus", label: "Chorus", group: "Space", min: 0, max: 100, step: 1, default: 0, unit: "%", desc: "18 ms delay modulated at 0.27 Hz" }, | |
| { key: "echo", label: "Echo", group: "Space", min: 0, max: 40, step: 1, default: 0, unit: "%", desc: "short 115 ms delay – sense of space" }, | |
| { key: "room", label: "Small room", group: "Space", min: 0, max: 100, step: 1, default: 0, unit: "%", desc: "synthetic convolution reverb, 220 ms tail" }, | |
| { key: "gate", label: "Pause gate", group: "Output", min: 0, max: 60, step: 1, default: 0, unit: "dB", desc: "downward expander: parts quieter than the threshold (dB below peak) are attenuated a further 3 dB/dB – removes electronic “breaths” in pauses; 0 = off" }, | |
| { key: "lowpass", label: "Low-pass filter", group: "Output", min: 4000, max: 11000, step: 250, default: 11000, unit: "Hz", desc: "cuts the band above the cutoff (11000 = off); 10 kHz removes the HiFi-GAN whistle near Nyquist, speech unaffected" }, | |
| { key: "volume", label: "Output gain", group: "Output", min: -12, max: 12, step: 0.5, default: 0, unit: "dB", desc: "output gain with limiter" }, | |
| ]; | |
| export const DEFAULTS = Object.fromEntries(EFFECTS.map((e) => [e.key, e.default])); | |
| // default "robot" preset in the UI (chosen by ear 2026-09-24): slight warmth + presence, a bit of chorus and echo; rest neutral | |
| export const PRESET = { warmth: 8.0, presence: 8.0 }; | |
| export const UI_DEFAULTS = { ...DEFAULTS, ...PRESET }; | |
| // ---------------------------------------------------------------- small numeric helpers | |
| const clip = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v); | |
| // Python round(): round half to even (used by librosa for the stretched length) | |
| function roundHalfEven(x) { | |
| const f = Math.floor(x), d = x - f; | |
| if (d < 0.5) return f; | |
| if (d > 0.5) return f + 1; | |
| return f % 2 === 0 ? f : f + 1; | |
| } | |
| // np.interp(xq, arange(n), y) for a single query (clamps like numpy; `right` = value past the last sample) | |
| function interp1(y, q, right) { | |
| const n = y.length; | |
| if (q <= 0) return y[0]; | |
| if (q >= n - 1) return right === undefined ? y[n - 1] : q === n - 1 ? y[n - 1] : right; | |
| const i = Math.floor(q), t = q - i; | |
| return y[i] + (y[i + 1] - y[i]) * t; | |
| } | |
| function hannPeriodic(n) { // scipy.signal.get_window('hann', n) / librosa 'hann' (fftbins=True) | |
| const w = new Float64Array(n); | |
| for (let i = 0; i < n; i++) w[i] = 0.5 - 0.5 * Math.cos((2 * Math.PI * i) / n); | |
| return w; | |
| } | |
| function hanningSym(n) { // np.hanning(n) | |
| const w = new Float64Array(n); | |
| if (n === 1) { w[0] = 1; return w; } | |
| for (let i = 0; i < n; i++) w[i] = 0.5 - 0.5 * Math.cos((2 * Math.PI * i) / (n - 1)); | |
| return w; | |
| } | |
| // deterministic PRNG (mulberry32) + Box-Muller; replaces np.random.default_rng(seed) | |
| function makeRng(seed) { | |
| let a = (seed + 0x9e3779b9) >>> 0; | |
| const next = () => { | |
| a = (a + 0x6d2b79f5) | 0; | |
| let t = Math.imul(a ^ (a >>> 15), 1 | a); | |
| t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; | |
| return ((t ^ (t >>> 14)) >>> 0) / 4294967296; | |
| }; | |
| return { | |
| uniform: (lo, hi) => lo + (hi - lo) * next(), | |
| normal: () => { | |
| let u = 0; | |
| while (u === 0) u = next(); | |
| return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * next()); | |
| }, | |
| }; | |
| } | |
| // ---------------------------------------------------------------- FFT (iterative radix-2, complex in-place) | |
| const _plans = new Map(); | |
| function fftPlan(n) { | |
| let p = _plans.get(n); | |
| if (p) return p; | |
| const levels = Math.round(Math.log2(n)); | |
| if (1 << levels !== n) throw new Error("FFT size must be a power of 2, got " + n); | |
| const rev = new Uint32Array(n); | |
| for (let i = 0; i < n; i++) { | |
| let r = 0, x = i; | |
| for (let j = 0; j < levels; j++) { r = (r << 1) | (x & 1); x >>= 1; } | |
| rev[i] = r; | |
| } | |
| const cos = new Float64Array(n >> 1), sin = new Float64Array(n >> 1); | |
| for (let i = 0; i < n >> 1; i++) { cos[i] = Math.cos((2 * Math.PI * i) / n); sin[i] = Math.sin((2 * Math.PI * i) / n); } | |
| p = { rev, cos, sin }; | |
| _plans.set(n, p); | |
| return p; | |
| } | |
| // forward: e^{-j}, inverse: e^{+j} (unscaled) | |
| function fft(re, im, inverse) { | |
| const n = re.length; | |
| const { rev, cos, sin } = fftPlan(n); | |
| for (let i = 0; i < n; i++) { | |
| const j = rev[i]; | |
| if (j > i) { let t = re[i]; re[i] = re[j]; re[j] = t; t = im[i]; im[i] = im[j]; im[j] = t; } | |
| } | |
| const sgn = inverse ? 1 : -1; | |
| for (let size = 2; size <= n; size <<= 1) { | |
| const half = size >> 1, step = n / size; | |
| for (let start = 0; start < n; start += size) { | |
| for (let k = 0, t = 0; k < half; k++, t += step) { | |
| const wr = cos[t], wi = sgn * sin[t]; | |
| const a = start + k, b = a + half; | |
| const xr = re[b] * wr - im[b] * wi, xi = re[b] * wi + im[b] * wr; | |
| re[b] = re[a] - xr; im[b] = im[a] - xi; | |
| re[a] += xr; im[a] += xi; | |
| } | |
| } | |
| } | |
| } | |
| function nextPow2(n) { let p = 1; while (p < n) p <<= 1; return p; } | |
| // ---------------------------------------------------------------- STFT helpers | |
| // generic framed rfft: frames start at `f*hop - offset` in x (zeros outside), returns half spectra | |
| function stftFrames(x, nFft, hop, offset, nFrames, win) { | |
| const nb = (nFft >> 1) + 1, n = x.length; | |
| const re = new Float64Array(nb * nFrames), im = new Float64Array(nb * nFrames); | |
| const fr = new Float64Array(nFft), fi = new Float64Array(nFft); | |
| for (let f = 0; f < nFrames; f++) { | |
| const start = f * hop - offset; | |
| for (let i = 0; i < nFft; i++) { | |
| const idx = start + i; | |
| fr[i] = idx >= 0 && idx < n ? x[idx] * win[i] : 0; | |
| fi[i] = 0; | |
| } | |
| fft(fr, fi, false); | |
| re.set(fr.subarray(0, nb), f * nb); | |
| im.set(fi.subarray(0, nb), f * nb); | |
| } | |
| return { re, im, nb, nFrames, nFft, hop }; | |
| } | |
| // inverse rfft of one frame (columns of S) into out (length nFft), scaled by 1/nFft | |
| function irfftFrame(S, f, fr, fi) { | |
| const { nb, nFft } = S, off = f * nb; | |
| for (let k = 0; k < nb; k++) { fr[k] = S.re[off + k]; fi[k] = S.im[off + k]; } | |
| for (let k = nb; k < nFft; k++) { fr[k] = S.re[off + nFft - k]; fi[k] = -S.im[off + nFft - k]; } | |
| fft(fr, fi, true); | |
| const s = 1 / nFft; | |
| for (let i = 0; i < nFft; i++) fr[i] *= s; | |
| } | |
| // weighted overlap-add of windowed inverse frames; norm = OLA of win^2 (returns both buffers) | |
| function overlapAdd(S, win) { | |
| const { nFft, hop, nFrames } = S; | |
| const L = nFft + hop * (nFrames - 1); | |
| const y = new Float64Array(L), norm = new Float64Array(L); | |
| const fr = new Float64Array(nFft), fi = new Float64Array(nFft); | |
| for (let f = 0; f < nFrames; f++) { | |
| irfftFrame(S, f, fr, fi); | |
| const o = f * hop; | |
| for (let i = 0; i < nFft; i++) { y[o + i] += fr[i] * win[i]; norm[o + i] += win[i] * win[i]; } | |
| } | |
| return { y, norm }; | |
| } | |
| // ---------------------------------------------------------------- librosa-style time stretch / pitch shift | |
| // librosa.stft(center=True, pad_mode='constant', hann) | |
| function stftLibrosa(x, nFft, hop) { | |
| const nFrames = 1 + Math.floor(x.length / hop); // padded length n + nFft -> frames = 1 + (n)/hop | |
| return stftFrames(x, nFft, hop, nFft >> 1, nFrames, hannPeriodic(nFft)); | |
| } | |
| // librosa.istft(center=True, length=length) | |
| function istftLibrosa(S, length) { | |
| const { nFft, hop } = S; | |
| const nFrames = Math.min(S.nFrames, Math.ceil((length + 2 * (nFft >> 1)) / hop)); | |
| const S2 = { ...S, nFrames }; | |
| const { y, norm } = overlapAdd(S2, hannPeriodic(nFft)); | |
| const out = new Float32Array(length), half = nFft >> 1, tiny = 1.1754944e-38; | |
| for (let i = 0; i < length; i++) { | |
| const j = i + half; | |
| if (j < y.length) out[i] = norm[j] > tiny ? y[j] / norm[j] : y[j]; | |
| } | |
| return out; | |
| } | |
| // librosa 1.0 phase_vocoder: cumulative raw phase differences + linear magnitude interpolation | |
| function phaseVocoder(S, rate) { | |
| const { re, im, nb, nFrames } = S; | |
| const nOut = Math.ceil(nFrames / rate); // np.arange(0, nFrames, rate) | |
| const oRe = new Float64Array(nb * nOut), oIm = new Float64Array(nb * nOut); | |
| const ph = new Float64Array(nb * nFrames), mg = new Float64Array(nb * nFrames); | |
| for (let i = 0; i < ph.length; i++) { ph[i] = Math.atan2(im[i], re[i]); mg[i] = Math.hypot(re[i], im[i]); } | |
| const phase = new Float64Array(nb); | |
| const first = Math.floor(0 * rate); | |
| for (let k = 0; k < nb; k++) phase[k] = ph[first * nb + k]; | |
| for (let t = 0; t < nOut; t++) { | |
| const tt = t * rate; | |
| const i0 = Math.floor(tt), i1 = Math.min(i0 + 1, nFrames - 1); | |
| if (t > 0) { // phase[t] = phase[t-1] + diff[t-1] | |
| const pt = (t - 1) * rate, p0 = Math.floor(pt), p1 = Math.min(p0 + 1, nFrames - 1); | |
| for (let k = 0; k < nb; k++) phase[k] += ph[p1 * nb + k] - ph[p0 * nb + k]; | |
| } | |
| // magnitude: linear interpolation (extrapolate from the last segment past nFrames-1) | |
| const a = tt - i0; | |
| let m0 = i0, m1 = i1, alpha = a; | |
| if (i1 === i0) { if (nFrames > 1) { m0 = nFrames - 2; m1 = nFrames - 1; alpha = tt - m0; } else { alpha = 0; } } | |
| for (let k = 0; k < nb; k++) { | |
| const mag = mg[m0 * nb + k] + (mg[m1 * nb + k] - mg[m0 * nb + k]) * alpha; | |
| const p = phase[k]; | |
| oRe[t * nb + k] = mag * Math.cos(p); | |
| oIm[t * nb + k] = mag * Math.sin(p); | |
| } | |
| } | |
| return { re: oRe, im: oIm, nb, nFrames: nOut, nFft: S.nFft, hop: S.hop }; | |
| } | |
| // librosa.effects.time_stretch (n_fft 2048, hop 512) | |
| function timeStretch(x, rate) { | |
| const S = stftLibrosa(x, 2048, 512); | |
| const S2 = phaseVocoder(S, rate); | |
| return istftLibrosa(S2, roundHalfEven(x.length / rate)); | |
| } | |
| // bandlimited windowed-sinc resampler (stands in for soxr_hq): output sample i taken at input position i/ratio | |
| function resample(x, ratio, nOut) { | |
| const fc = Math.min(1, ratio); // cutoff relative to input Nyquist (anti-alias when downsampling) | |
| const zc = 24; // zero crossings per side at fc = 1 | |
| const W = zc / fc, R = 64, beta = 8.6; | |
| const i0 = (z) => { let s = 1, t = 1; const q = (z * z) / 4; for (let k = 1; k < 60; k++) { t *= q / (k * k); s += t; if (t < 1e-14 * s) break; } return s; }; | |
| const tabN = Math.ceil(W * R) + 2, tab = new Float64Array(tabN), ib = 1 / i0(beta); | |
| for (let i = 0; i < tabN; i++) { | |
| const t = i / R; | |
| if (t >= W) { tab[i] = 0; continue; } | |
| const s = t === 0 ? 1 : Math.sin(Math.PI * fc * t) / (Math.PI * fc * t); | |
| const r = t / W; | |
| tab[i] = fc * s * i0(beta * Math.sqrt(1 - r * r)) * ib; | |
| } | |
| const out = new Float32Array(nOut), n = x.length; | |
| for (let i = 0; i < nOut; i++) { | |
| const t0 = i / ratio; | |
| const k0 = Math.max(0, Math.ceil(t0 - W)), k1 = Math.min(n - 1, Math.floor(t0 + W)); | |
| let acc = 0; | |
| for (let k = k0; k <= k1; k++) { | |
| const u = Math.abs(k - t0) * R, j = Math.floor(u), fr = u - j; | |
| acc += x[k] * (tab[j] + (tab[j + 1] - tab[j]) * fr); | |
| } | |
| out[i] = acc; | |
| } | |
| return out; | |
| } | |
| // librosa.effects.pitch_shift: stretch by 2^(-st/12), resample back, fix length | |
| function pitchShift(x, sr, nSteps) { | |
| const rate = Math.pow(2, -nSteps / 12); | |
| const ys = timeStretch(x, rate); | |
| const r = resample(ys, rate, Math.ceil(ys.length * rate)); | |
| const out = new Float32Array(x.length); | |
| out.set(r.subarray(0, Math.min(r.length, x.length))); | |
| return out; | |
| } | |
| // ---------------------------------------------------------------- formant (scipy.signal.stft / istft, n_fft 1024, hop 256) | |
| function formant(x, sr, shiftSt) { | |
| if (Math.abs(shiftSt) < 1e-6) return x; | |
| const nFft = 1024, hop = 256, half = 512, n = x.length; | |
| const L1 = n + 2 * half; // boundary='zeros' | |
| const nadd = (((-(L1 - nFft)) % hop) + hop) % hop; // padded=True | |
| const L = L1 + nadd; | |
| const nFrames = (L - nFft) / hop + 1; | |
| const win = hannPeriodic(nFft); | |
| const S = stftFrames(x, nFft, hop, half, nFrames, win); | |
| const nb = S.nb, scale = 1 / 512; // scipy 'spectrum' scaling = 1/sum(win) | |
| const radius = Math.max(3, Math.round((175 * nFft) / sr)); | |
| const kw = 1 / (2 * radius + 1); | |
| const ratio = Math.pow(2, shiftSt / 12); | |
| const gateF = new Float64Array(nb); | |
| for (let k = 0; k < nb; k++) { | |
| const hz = (k * sr) / nFft; | |
| gateF[k] = clip(hz / 180, 0, 1) * clip((7500 - hz) / 2000, 0, 1); | |
| } | |
| const logm = new Float64Array(nb), env = new Float64Array(nb); | |
| for (let f = 0; f < nFrames; f++) { | |
| const off = f * nb; | |
| for (let k = 0; k < nb; k++) logm[k] = Math.log(Math.hypot(S.re[off + k], S.im[off + k]) * scale + 1e-7); | |
| // np.convolve(mode='same') with a box kernel, zero padded at the edges | |
| for (let k = 0; k < nb; k++) { | |
| let s = 0; | |
| const a = Math.max(0, k - radius), b = Math.min(nb - 1, k + radius); | |
| for (let j = a; j <= b; j++) s += logm[j]; | |
| env[k] = s * kw; | |
| } | |
| for (let k = 0; k < nb; k++) { | |
| const src = clip(k / ratio, 0, nb - 1); | |
| const warped = interp1(env, src); | |
| const g = Math.exp(clip((warped - env[k]) * gateF[k], -1.38, 1.38)); | |
| S.re[off + k] *= g; S.im[off + k] *= g; | |
| } | |
| } | |
| const { y, norm } = overlapAdd(S, win); | |
| const out = new Float32Array(n); | |
| for (let i = 0; i < n; i++) { | |
| const j = i + half; | |
| out[i] = norm[j] > 1e-10 ? y[j] / norm[j] : y[j]; | |
| } | |
| return out; | |
| } | |
| // ---------------------------------------------------------------- IIR filters | |
| // scipy.signal.lfilter(b, a, x) with 2nd-order sections, direct form II transposed, zero initial state | |
| function biquad(b0, b1, b2, a1, a2, x) { | |
| const n = x.length, y = new Float32Array(n); | |
| let z1 = 0, z2 = 0; | |
| for (let i = 0; i < n; i++) { | |
| const xi = x[i], yi = b0 * xi + z1; | |
| z1 = b1 * xi - a1 * yi + z2; | |
| z2 = b2 * xi - a2 * yi; | |
| y[i] = yi; | |
| } | |
| return y; | |
| } | |
| // RBJ shelving biquad, same formulas as effects._shelf | |
| function shelf(x, sr, f0, gainDb, high) { | |
| if (Math.abs(gainDb) < 1e-6) return x; | |
| const A = Math.pow(10, gainDb / 40); | |
| const w0 = (2 * Math.PI * f0) / sr; | |
| const cos = Math.cos(w0), sin = Math.sin(w0); | |
| const alpha = (sin / 2) * Math.sqrt((A + 1 / A) * (1 / 0.9 - 1) + 2); | |
| const s = 2 * Math.sqrt(A) * alpha; | |
| let b, a; | |
| if (high) { | |
| b = [A * ((A + 1) + (A - 1) * cos + s), -2 * A * ((A - 1) + (A + 1) * cos), A * ((A + 1) + (A - 1) * cos - s)]; | |
| a = [(A + 1) - (A - 1) * cos + s, 2 * ((A - 1) - (A + 1) * cos), (A + 1) - (A - 1) * cos - s]; | |
| } else { | |
| b = [A * ((A + 1) - (A - 1) * cos + s), 2 * A * ((A - 1) - (A + 1) * cos), A * ((A + 1) - (A - 1) * cos - s)]; | |
| a = [(A + 1) + (A - 1) * cos + s, -2 * ((A - 1) + (A + 1) * cos), (A + 1) + (A - 1) * cos - s]; | |
| } | |
| return biquad(b[0] / a[0], b[1] / a[0], b[2] / a[0], a[1] / a[0], a[2] / a[0], x); | |
| } | |
| // sos = array of [b0,b1,b2,a1,a2] (a0 = 1); zi (optional) = per-section [z1,z2]; returns Float64Array | |
| function sosfilt(sos, x, zi) { | |
| const n = x.length, y = new Float64Array(n); | |
| y.set(x); | |
| for (let s = 0; s < sos.length; s++) { | |
| const [b0, b1, b2, a1, a2] = sos[s]; | |
| let z1 = zi ? zi[s][0] : 0, z2 = zi ? zi[s][1] : 0; | |
| for (let i = 0; i < n; i++) { | |
| const xi = y[i], yi = b0 * xi + z1; | |
| z1 = b1 * xi - a1 * yi + z2; | |
| z2 = b2 * xi - a2 * yi; | |
| y[i] = yi; | |
| } | |
| } | |
| return y; | |
| } | |
| // scipy.signal.sosfilt_zi: steady state for a unit step, scaled by the DC gain of the preceding sections | |
| function sosfiltZi(sos) { | |
| const zi = []; | |
| let scale = 1; | |
| for (const [b0, b1, b2, a1, a2] of sos) { | |
| const H1 = (b0 + b1 + b2) / (1 + a1 + a2); | |
| const z2 = b2 - a2 * H1, z1 = b1 - a1 * H1 + z2; | |
| zi.push([z1 * scale, z2 * scale]); | |
| scale *= H1; | |
| } | |
| return zi; | |
| } | |
| // scipy.signal.sosfiltfilt(sos, x) with default odd padding, padlen = 3*(2*nsec+1) (all coefficients nonzero) | |
| function sosfiltfilt(sos, x) { | |
| const n = x.length; | |
| let padlen = 3 * (2 * sos.length + 1); | |
| if (padlen >= n) padlen = Math.max(0, n - 1); | |
| const L = n + 2 * padlen, ext = new Float64Array(L); | |
| for (let i = 0; i < padlen; i++) ext[i] = 2 * x[0] - x[padlen - i]; | |
| for (let i = 0; i < n; i++) ext[padlen + i] = x[i]; | |
| for (let i = 0; i < padlen; i++) ext[padlen + n + i] = 2 * x[n - 1] - x[n - 2 - i]; | |
| const zi = sosfiltZi(sos); | |
| const scaled = (v) => zi.map(([a, b]) => [a * v, b * v]); | |
| let y = sosfilt(sos, ext, scaled(ext[0])); | |
| y.reverse(); | |
| y = sosfilt(sos, y, scaled(y[0])); | |
| y.reverse(); | |
| const out = new Float32Array(n); | |
| for (let i = 0; i < n; i++) out[i] = y[padlen + i]; | |
| return out; | |
| } | |
| // --- Butterworth design (analog prototype -> prewarp -> bilinear with fs=2, like scipy.signal.butter) | |
| function butterPoles(order) { // buttap: -exp(j*pi*m/(2N)), m = -N+1, -N+3, ..., N-1 | |
| const p = []; | |
| for (let m = -order + 1; m <= order - 1; m += 2) p.push([-Math.cos((Math.PI * m) / (2 * order)), -Math.sin((Math.PI * m) / (2 * order))]); | |
| return p; | |
| } | |
| const cmul = (a, b) => [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]]; | |
| const cdiv = (a, b) => { const d = b[0] * b[0] + b[1] * b[1]; return [(a[0] * b[0] + a[1] * b[1]) / d, (a[1] * b[0] - a[0] * b[1]) / d]; }; | |
| const csqrt = (z) => { const r = Math.hypot(z[0], z[1]); const re = Math.sqrt((r + z[0]) / 2); const im = Math.sqrt(Math.max(0, (r - z[0]) / 2)); return [re, z[1] < 0 ? -im : im]; }; | |
| const bilinear = (p) => cdiv([4 + p[0], p[1]], [4 - p[0], -p[1]]); // z = (2fs + s)/(2fs - s), fs = 2 | |
| // 8th (or any even) order low-pass as unity-DC-gain biquads | |
| function butterLowpassSos(order, fc, sr) { | |
| const warped = 4 * Math.tan((Math.PI * (fc / (sr / 2))) / 2); | |
| const poles = butterPoles(order).map((p) => bilinear([p[0] * warped, p[1] * warped])); | |
| const sos = []; | |
| for (const z of poles) { | |
| if (z[1] <= 0) continue; // one per conjugate pair (Butterworth has no real poles for even order) | |
| const a1 = -2 * z[0], a2 = z[0] * z[0] + z[1] * z[1]; | |
| const g = (1 + a1 + a2) / 4; | |
| sos.push([g, 2 * g, g, a1, a2]); | |
| } | |
| return sos; | |
| } | |
| // 2nd-order (prototype) band-pass = 2 biquads, matches scipy.signal.butter(2, [lo, hi], 'band', output='sos') | |
| function butterBandpassSos2(lo, hi, sr) { | |
| const wl = 4 * Math.tan((Math.PI * (lo / (sr / 2))) / 2), wh = 4 * Math.tan((Math.PI * (hi / (sr / 2))) / 2); | |
| const bw = wh - wl, wo = Math.sqrt(wl * wh); | |
| const p = butterPoles(2)[1]; // upper-half-plane prototype pole | |
| const plp = [(p[0] * bw) / 2, (p[1] * bw) / 2]; | |
| const disc = csqrt([plp[0] * plp[0] - plp[1] * plp[1] - wo * wo, 2 * plp[0] * plp[1]]); | |
| const q = [[plp[0] + disc[0], plp[1] + disc[1]], [plp[0] - disc[0], plp[1] - disc[1]]]; | |
| // gain: k = bw^2 (lp2bp) * 16 / prod(4 - p_bp) over all 4 poles (= |4 - q1|^2 |4 - q2|^2 with conjugates) | |
| let denom = 1; | |
| for (const qq of q) denom *= (4 - qq[0]) * (4 - qq[0]) + qq[1] * qq[1]; | |
| const k = (bw * bw * 16) / denom; | |
| const sos = []; | |
| q.forEach((qq, i) => { | |
| const z = bilinear(qq); | |
| const a1 = -2 * z[0], a2 = z[0] * z[0] + z[1] * z[1]; | |
| const g = i === 0 ? k : 1; | |
| sos.push([g, 0, -g, a1, a2]); // zeros at z = +1 and z = -1 in each section | |
| }); | |
| return sos; | |
| } | |
| // ---------------------------------------------------------------- dynamic band processing | |
| function envelope(x, sr, attack = 0.002, release = 0.07) { | |
| const ea = Math.exp(-1 / (sr * attack)), er = Math.exp(-1 / (sr * release)); | |
| const env = new Float32Array(x.length); | |
| let e = 0; | |
| for (let i = 0; i < x.length; i++) { | |
| const ax = Math.abs(x[i]); | |
| const c = ax > e ? ea : er; | |
| e = c * e + (1 - c) * ax; | |
| env[i] = e; | |
| } | |
| return env; | |
| } | |
| function bandDynamic(x, sr, lo, hi, amount, thresh = 0.02, maxRed = 0.8) { | |
| if (amount <= 0) return x; | |
| const sos = butterBandpassSos2(lo, Math.min(hi, sr / 2 - 100), sr); | |
| const band = Float32Array.from(sosfilt(sos, x)); | |
| const env = envelope(band, sr); | |
| const out = new Float32Array(x.length), m = amount / 100; | |
| for (let i = 0; i < x.length; i++) { | |
| const red = m * clip((env[i] - thresh) / Math.max(env[i], 1e-4), 0, maxRed); | |
| out[i] = x[i] - band[i] * red; | |
| } | |
| return out; | |
| } | |
| // ---------------------------------------------------------------- granular layers, room, gate | |
| function grains(x, sr, sizeS, mix, detuneCents = 0, seed = 0) { | |
| if (mix <= 0) return x; | |
| const rng = makeRng(seed); | |
| const size = Math.floor(sr * sizeS), hop = size >> 1; | |
| const win = hanningSym(size); | |
| const n = x.length, out = new Float64Array(n + size); | |
| const g = new Float64Array(size); | |
| for (let start = 0; start < n - size; start += hop) { | |
| for (let i = 0; i < size; i++) g[i] = x[start + i] * win[i]; | |
| if (detuneCents) { | |
| const r = Math.pow(2, rng.uniform(-detuneCents, detuneCents) / 1200); | |
| const g2 = new Float32Array(size); | |
| for (let i = 0; i < size; i++) g2[i] = interp1(g, i * r, 0) * win[i]; | |
| for (let i = 0; i < size; i++) out[start + i] += g2[i]; | |
| } else { | |
| for (let i = 0; i < size; i++) out[start + i] += g[i]; | |
| } | |
| } | |
| const y = new Float32Array(n); | |
| for (let i = 0; i < n; i++) y[i] = (1 - mix) * x[i] + mix * out[i]; | |
| return y; | |
| } | |
| function fftConvolve(x, h, nOut) { | |
| const N = nextPow2(x.length + h.length - 1); | |
| const xr = new Float64Array(N), xi = new Float64Array(N), hr = new Float64Array(N), hi = new Float64Array(N); | |
| xr.set(x); hr.set(h); | |
| fft(xr, xi, false); fft(hr, hi, false); | |
| for (let i = 0; i < N; i++) { | |
| const r = xr[i] * hr[i] - xi[i] * hi[i], im = xr[i] * hi[i] + xi[i] * hr[i]; | |
| xr[i] = r; xi[i] = im; | |
| } | |
| fft(xr, xi, true); | |
| const out = new Float64Array(nOut); | |
| for (let i = 0; i < nOut; i++) out[i] = xr[i] / N; | |
| return out; | |
| } | |
| function room(x, sr, mix, tailS = 0.22, seed = 1) { | |
| if (mix <= 0) return x; | |
| const rng = makeRng(seed); | |
| const n = Math.floor(sr * tailS), ir = new Float64Array(n); | |
| const tau = (sr * tailS) / 4; | |
| for (let i = 0; i < n; i++) ir[i] = rng.normal() * Math.exp(-i / tau); | |
| ir[0] = 1; | |
| let e = 0; | |
| for (let i = 0; i < n; i++) e += ir[i] * ir[i]; | |
| const s = 1 / Math.sqrt(e); | |
| for (let i = 0; i < n; i++) ir[i] *= s; | |
| const wet = fftConvolve(x, ir, x.length); | |
| const y = new Float32Array(x.length); | |
| for (let i = 0; i < x.length; i++) y[i] = (1 - 0.5 * mix) * x[i] + mix * 0.6 * Math.fround(wet[i]); | |
| return y; | |
| } | |
| // downward expander (pause gate), see effects._gate | |
| function gate(x, sr, depthDb, ratio = 4.0, floorDb = -40.0, attack = 0.005, release = 0.06) { | |
| const hop = Math.floor(0.005 * sr), n = x.length; | |
| if (n < 4 * hop) return x; | |
| const nFrames = Math.ceil((n + 1) / hop); // sliding windows of 2*hop over pad(x, hop) taken every hop | |
| const env = new Float64Array(nFrames); | |
| let peak = 0; | |
| for (let f = 0; f < nFrames; f++) { | |
| let s = 0; | |
| const start = f * hop - hop; | |
| for (let i = 0; i < 2 * hop; i++) { const j = start + i; if (j >= 0 && j < n) s += x[j] * x[j]; } | |
| env[f] = Math.sqrt(s / (2 * hop) + 1e-12); | |
| if (env[f] > peak) peak = env[f]; | |
| } | |
| if (peak <= 0) return x; | |
| const thr = -Math.abs(depthDb); | |
| const gainDb = new Float64Array(nFrames); | |
| for (let f = 0; f < nFrames; f++) { | |
| const envDb = 20 * Math.log10(env[f] / peak); | |
| gainDb[f] = Math.max(Math.min(0, (envDb - thr) * (ratio - 1)), floorDb); | |
| } | |
| const aAtt = Math.exp(-hop / (attack * sr)), aRel = Math.exp(-hop / (release * sr)); | |
| const gain = new Float64Array(nFrames); | |
| let g = gainDb[0]; | |
| for (let f = 0; f < nFrames; f++) { | |
| const v = gainDb[f], c = v > g ? aAtt : aRel; | |
| g = c * g + (1 - c) * v; | |
| gain[f] = Math.pow(10, g / 20); | |
| } | |
| const y = new Float32Array(n); | |
| for (let i = 0; i < n; i++) y[i] = x[i] * interp1(gain, i / hop); | |
| return y; | |
| } | |
| // ---------------------------------------------------------------- the chain | |
| export function applyChain(wav, sr, params) { | |
| const p = { ...DEFAULTS }; | |
| for (const k in params || {}) if (k in DEFAULTS) p[k] = Number(params[k]); | |
| let x = wav instanceof Float32Array ? wav : Float32Array.from(wav); | |
| if (Math.abs(p.speed - 1) > 1e-3) x = timeStretch(x, p.speed); | |
| if (Math.abs(p.pitch) > 1e-6) x = pitchShift(x, sr, p.pitch); | |
| x = formant(x, sr, p.formant); | |
| x = shelf(x, sr, 250, p.warmth, false); | |
| x = shelf(x, sr, 3500, p.presence, true); | |
| x = bandDynamic(x, sr, 1200, 4000, p.dynamic); | |
| x = bandDynamic(x, sr, 5000, Math.min(9000, sr / 2 - 200), p.deess, 0.01); | |
| if (p.drive > 0) { | |
| const k = 1 + (p.drive / 100) * 7, tk = Math.tanh(k); | |
| x = x.map((v) => Math.tanh(k * v) / tk); | |
| } | |
| if (p.saturation > 0) { | |
| const k = 1 + (p.saturation / 100) * 7, tk = Math.tanh(k), t15 = Math.tanh(0.15); | |
| x = x.map((v) => (Math.tanh(k * v + 0.15) - t15) / tk); | |
| } | |
| if (p.robot > 0) { | |
| const m = p.robot / 100, y = new Float32Array(x.length); | |
| for (let i = 0; i < x.length; i++) { | |
| const ring = x[i] * Math.fround(Math.sin((2 * Math.PI * 42 * i) / sr)); | |
| y[i] = (1 - m) * x[i] + m * ring * 1.6; | |
| } | |
| x = y; | |
| } | |
| x = grains(x, sr, 0.05, (p.micro / 100) * 0.8, 85); | |
| x = grains(x, sr, 0.035, p.halo / 100); | |
| if (p.chorus > 0) { | |
| const d = Math.floor(0.018 * sr), n = x.length, m = (p.chorus / 100) * 0.5, y = new Float32Array(n); | |
| for (let t = 0; t < n; t++) { | |
| const mod = d + 0.003 * sr * Math.sin((2 * Math.PI * 0.27 * t) / sr); | |
| const wet = Math.fround(interp1(x, clip(t - mod, 0, n - 1))); | |
| y[t] = (1 - m) * x[t] + m * wet; | |
| } | |
| x = y; | |
| } | |
| if (p.echo > 0) { | |
| const d = Math.floor(0.115 * sr), n = x.length, fb = p.echo / 100; | |
| const y = Float32Array.from(x); | |
| for (let i = 1; i < 4; i++) { | |
| const g = Math.pow(fb, i); | |
| if (g < 0.01) break; | |
| for (let j = i * d; j < n; j++) y[j] += g * x[j - i * d]; | |
| } | |
| x = y; | |
| } | |
| x = room(x, sr, p.room / 100); | |
| if (p.gate > 0) x = gate(x, sr, p.gate); | |
| if (p.lowpass < 10900 && p.lowpass < sr / 2) x = sosfiltfilt(butterLowpassSos(8, p.lowpass, sr), x); | |
| if (Math.abs(p.volume) > 1e-6) { | |
| const g = Math.pow(10, p.volume / 20); | |
| x = x.map((v) => v * g); | |
| } | |
| let peak = 0; | |
| for (let i = 0; i < x.length; i++) { const a = Math.abs(x[i]); if (a > peak) peak = a; } | |
| if (peak > 0.98) x = x.map((v) => (v / peak) * 0.98); | |
| return x instanceof Float32Array ? x : Float32Array.from(x); | |
| } | |
| export default { EFFECTS, DEFAULTS, PRESET, UI_DEFAULTS, applyChain }; | |