/* Next Echo compute core: port of echo_core.py (log-mel, learned window embeddings, log-mel baseline, detection). */ (function (root, factory) { if (typeof module === "object" && module.exports) module.exports = factory(); else root.Core = factory(); })(typeof self !== "undefined" ? self : this, function () { "use strict"; const SR = 16000, N_FFT = 512, HOP = 256, N_MELS = 64, WIN = 64, STEP = 16; const WIN_SEC = (WIN - 1) * HOP / SR + N_FFT / SR; const ASSETS = ["model.json"]; // iterative radix-2 FFT on (re, im) in place function fft(re, im) { const n = re.length; for (let i = 1, j = 0; i < n; i++) { let bit = n >> 1; for (; j & bit; bit >>= 1) j ^= bit; j ^= bit; if (i < j) { [re[i], re[j]] = [re[j], re[i]]; [im[i], im[j]] = [im[j], im[i]]; } } for (let len = 2; len <= n; len <<= 1) { const ang = -2 * Math.PI / len; for (let i = 0; i < n; i += len) { for (let k = 0; k < len / 2; k++) { const wr = Math.cos(ang * k), wi = Math.sin(ang * k); const ar = re[i + k + len / 2], ai = im[i + k + len / 2]; const tr = ar * wr - ai * wi, ti = ar * wi + ai * wr; re[i + k + len / 2] = re[i + k] - tr; im[i + k + len / 2] = im[i + k] - ti; re[i + k] += tr; im[i + k] += ti; } } } } function logmel(ctx, x) { if (x.length < N_FFT) { const y = new Float64Array(N_FFT); y.set(x); x = y; } const n = 1 + Math.floor((x.length - N_FFT) / HOP), nb = N_FFT / 2 + 1, fb = ctx.fb.data; const w = new Float64Array(N_FFT); for (let i = 0; i < N_FFT; i++) w[i] = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / N_FFT); const out = Array.from({ length: N_MELS }, () => new Float64Array(n)); const re = new Float64Array(N_FFT), im = new Float64Array(N_FFT), p = new Float64Array(nb); for (let f = 0; f < n; f++) { for (let i = 0; i < N_FFT; i++) { re[i] = x[f * HOP + i] * w[i]; im[i] = 0; } fft(re, im); for (let k = 0; k < nb; k++) p[k] = re[k] * re[k] + im[k] * im[k]; for (let m = 0; m < N_MELS; m++) { let s = 0; for (let k = 0; k < nb; k++) s += fb[m * nb + k] * p[k]; out[m][f] = Math.log(s + 1e-6); } } return out; } function padFrames(lm, n) { if (lm[0].length >= n) return lm; let mn = Infinity; for (const r of lm) for (const v of r) if (v < mn) mn = v; return lm.map(r => { const o = new Float64Array(n).fill(mn); o.set(r); return o; }); } function windowStarts(nFrames) { const s = []; for (let t = 0; t <= Math.max(nFrames - WIN, 0); t += STEP) s.push(t); return s; } function norm(v) { let s = 0; for (const x of v) s += x * x; const n = Math.max(Math.sqrt(s), 1e-12); return Float64Array.from(v, x => x / n); } function embedWindow(ctx, lm, s) { const d = new Float64Array(N_MELS * WIN); for (let m = 0; m < N_MELS; m++) for (let t = 0; t < WIN; t++) d[m * WIN + t] = (lm[m][s + t] - ctx.mu) / ctx.sd; return norm(NLRT.forward(ctx.layers, NLRT.T([1, N_MELS, WIN], d)).data); } function statsWindow(ctx, lm, s) { const v = new Float64Array(2 * N_MELS); for (let m = 0; m < N_MELS; m++) { let mean = 0; for (let t = 0; t < WIN; t++) mean += (lm[m][s + t] - ctx.mu) / ctx.sd; mean /= WIN; let var_ = 0; for (let t = 0; t < WIN; t++) { const z = (lm[m][s + t] - ctx.mu) / ctx.sd - mean; var_ += z * z; } v[m] = mean; v[N_MELS + m] = Math.sqrt(var_ / WIN); } let mm = 0; for (const x of v) mm += x; mm /= v.length; return norm(v.map(x => x - mm)); } function queryVectors(ctx, q) { const lm = padFrames(logmel(ctx, q), WIN), starts = []; for (let s = 0; s + WIN <= lm[0].length; s += 8) starts.push(s); const e = starts.map(s => { let a = 0; for (let m = 0; m < N_MELS; m++) for (let t = 0; t < WIN; t++) a += lm[m][s + t]; return a / (N_MELS * WIN); }); const top = Math.max(...e), sel = starts.filter((_, i) => e[i] >= top - 1.5); const qe = new Float64Array(64), qs = new Float64Array(2 * N_MELS); for (const s of sel) { const a = embedWindow(ctx, lm, s), b = statsWindow(ctx, lm, s); a.forEach((v, i) => qe[i] += v / sel.length); b.forEach((v, i) => qs[i] += v / sel.length); } return [norm(qe), norm(qs)]; } function similarityCurves(ctx, q, rec, onProgress) { const [qe, qs] = queryVectors(ctx, q); const lm = padFrames(logmel(ctx, rec), WIN), starts = windowStarts(lm[0].length); const learned = [], base = []; starts.forEach((s, k) => { const e = embedWindow(ctx, lm, s), b = statsWindow(ctx, lm, s); let a1 = 0, a2 = 0; for (let i = 0; i < e.length; i++) a1 += e[i] * qe[i]; for (let i = 0; i < b.length; i++) a2 += b[i] * qs[i]; learned.push(a1); base.push(a2); if (onProgress && k % 20 === 0) onProgress(k / starts.length); }); return { times: starts.map(s => s * HOP / SR), learned, base }; } function median(a) { const b = Array.from(a).sort((x, y) => x - y), n = b.length; return n % 2 ? b[(n - 1) / 2] : (b[n / 2 - 1] + b[n / 2]) / 2; } function robustZ(c) { const med = median(c), mad = median(Array.from(c, v => Math.abs(v - med))) + 1e-6; return Array.from(c, v => (v - med) / (1.4826 * mad)); } function finalScores(learned, base, cfg) { const zl = robustZ(learned), zb = robustZ(base), a = cfg.alpha; return [zl.map((v, i) => a * v + (1.0 - a) * zb[i]), cfg.baseline_norm === "z" ? zb : Array.from(base)]; } function detect(times, sims, th) { const out = []; let cur = null; times.forEach((t, i) => { if (sims[i] >= th) { if (cur === null) cur = [t, t + WIN_SEC, sims[i]]; else { cur[1] = t + WIN_SEC; cur[2] = Math.max(cur[2], sims[i]); } } else if (cur !== null) { out.push(cur); cur = null; } }); if (cur !== null) out.push(cur); return out; } function init(assets) { const m = NLRT.decode(assets["model.json"]); return { layers: m.nets.embed, fb: m.tensors.mel_fb, mu: m.meta.mu, sd: m.meta.sd, thresholds: m.meta.thresholds, score: m.meta.score, meta: m.meta }; } function runCase(ctx, input) { const q = Float64Array.from(input.query, v => v / 32768), r = Float64Array.from(input.recording, v => v / 32768); const c = similarityCurves(ctx, q, r), [nx, bl] = finalScores(c.learned, c.base, ctx.score); return { learned: c.learned, base: c.base, det_learned: detect(c.times, nx, ctx.thresholds.learned), det_base: detect(c.times, bl, ctx.thresholds.baseline) }; } return { ASSETS, init, SR, WIN_SEC, logmel, similarityCurves, finalScores, detect, runCase }; });