@octoseq/mir 0.1.0-main.26cefa1 → 0.1.0-main.2b93a77

package/dist/{chunk-KIGWMJLC.js → chunk-CI7QGWP7.js}

@@ -286,6 +286,26 @@ async function onsetEnvelopeFromMelGpu(mel, gpu, options) {
 }
 
 // src/dsp/spectral.ts
+function amplitudeEnvelope(samples, sampleRate, config) {
+  const hopSize = config?.hopSize ?? 512;
+  const windowSize = config?.windowSize ?? hopSize;
+  const nFrames = Math.floor((samples.length - windowSize) / hopSize) + 1;
+  const times = new Float32Array(nFrames);
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const start = t * hopSize;
+    const end = Math.min(start + windowSize, samples.length);
+    let sumSq = 0;
+    for (let i = start; i < end; i++) {
+      const s = samples[i] ?? 0;
+      sumSq += s * s;
+    }
+    const rms = Math.sqrt(sumSq / (end - start));
+    times[t] = (start + windowSize / 2) / sampleRate;
+    values[t] = rms;
+  }
+  return { times, values };
+}
 function spectralCentroid(spec) {
   const nFrames = spec.times.length;
   const out = new Float32Array(nFrames);
@@ -802,6 +822,20 @@ function hzToMel(hz) {
 function melToHz(mel) {
   return 700 * (Math.pow(10, mel / 2595) - 1);
 }
+function hzToFeatureIndex(hz, config) {
+  const melMin = hzToMel(config.fMin);
+  const melMax = hzToMel(config.fMax);
+  const melHz = hzToMel(hz);
+  const normalized = (melHz - melMin) / (melMax - melMin);
+  return normalized * (config.nMels - 1);
+}
+function featureIndexToHz(index, config) {
+  const melMin = hzToMel(config.fMin);
+  const melMax = hzToMel(config.fMax);
+  const normalized = index / (config.nMels - 1);
+  const mel = melMin + normalized * (melMax - melMin);
+  return melToHz(mel);
+}
 function buildMelFilterBank(sampleRate, fftSize, nMels, fMin, fMax) {
   const nBins = (fftSize >>> 1) + 1;
   const nyquist = sampleRate / 2;
@@ -1553,6 +1587,452 @@ async function spectrogram(audio, config, gpu, options = {}) {
   };
 }
 
+// src/dsp/cqt.ts
+var CQT_DEFAULTS = {
+  /** Quarter-tone resolution (24 bins per octave) */
+  binsPerOctave: 24,
+  /** C1 (lowest note on a standard piano) */
+  fMin: 32.7,
+  /** C9 (well above audible range for most content) */
+  fMax: 8372
+};
+function cqtBinToHz(bin, config) {
+  return config.fMin * Math.pow(2, bin / config.binsPerOctave);
+}
+function hzToCqtBin(hz, config) {
+  if (hz <= 0) return -Infinity;
+  return config.binsPerOctave * Math.log2(hz / config.fMin);
+}
+function getNumOctaves(config) {
+  return Math.log2(config.fMax / config.fMin);
+}
+function getNumBins(config) {
+  const nOctaves = getNumOctaves(config);
+  return Math.ceil(nOctaves * config.binsPerOctave);
+}
+function getCqtBinFrequencies(config) {
+  const nBins = getNumBins(config);
+  const freqs = new Float32Array(nBins);
+  for (let k = 0; k < nBins; k++) {
+    freqs[k] = cqtBinToHz(k, config);
+  }
+  return freqs;
+}
+var kernelBankCache = /* @__PURE__ */ new Map();
+function kernelCacheKey(config, fftSize, sampleRate) {
+  return `${config.binsPerOctave}:${config.fMin}:${config.fMax}:${fftSize}:${sampleRate}`;
+}
+function createCqtKernel(binIndex, config, fftSize, sampleRate) {
+  const centerFreq = cqtBinToHz(binIndex, config);
+  const freqResolution = sampleRate / fftSize;
+  const Q = 1 / (Math.pow(2, 1 / config.binsPerOctave) - 1);
+  const bandwidth = centerFreq / Q;
+  const fLow = centerFreq - bandwidth / 2;
+  const fHigh = centerFreq + bandwidth / 2;
+  const startBin = Math.max(0, Math.floor(fLow / freqResolution));
+  const endBin = Math.min(
+    Math.floor(fftSize / 2) + 1,
+    Math.ceil(fHigh / freqResolution) + 1
+  );
+  const numBins = Math.max(1, endBin - startBin);
+  const weights = new Float32Array(numBins);
+  for (let i = 0; i < numBins; i++) {
+    const binFreq = (startBin + i) * freqResolution;
+    if (binFreq <= centerFreq) {
+      if (centerFreq > fLow) {
+        weights[i] = (binFreq - fLow) / (centerFreq - fLow);
+      } else {
+        weights[i] = 1;
+      }
+    } else {
+      if (fHigh > centerFreq) {
+        weights[i] = (fHigh - binFreq) / (fHigh - centerFreq);
+      } else {
+        weights[i] = 1;
+      }
+    }
+    weights[i] = Math.max(0, Math.min(1, weights[i] ?? 0));
+  }
+  let sum = 0;
+  for (let i = 0; i < numBins; i++) {
+    sum += weights[i] ?? 0;
+  }
+  if (sum > 0) {
+    for (let i = 0; i < numBins; i++) {
+      weights[i] = (weights[i] ?? 0) / sum;
+    }
+  }
+  return {
+    centerFreq,
+    startBin,
+    endBin,
+    weights
+  };
+}
+function getCqtKernelBank(config, fftSize, sampleRate) {
+  const key = kernelCacheKey(config, fftSize, sampleRate);
+  const cached = kernelBankCache.get(key);
+  if (cached) return cached;
+  const nBins = getNumBins(config);
+  const kernels = new Array(nBins);
+  for (let k = 0; k < nBins; k++) {
+    kernels[k] = createCqtKernel(k, config, fftSize, sampleRate);
+  }
+  const bank = {
+    config,
+    fftSize,
+    sampleRate,
+    kernels
+  };
+  kernelBankCache.set(key, bank);
+  return bank;
+}
+function applyCqtKernels(stftMagnitudes, kernelBank) {
+  const nCqtBins = kernelBank.kernels.length;
+  const cqtMagnitudes = new Float32Array(nCqtBins);
+  for (let k = 0; k < nCqtBins; k++) {
+    const kernel = kernelBank.kernels[k];
+    if (!kernel) continue;
+    let sum = 0;
+    for (let i = 0; i < kernel.weights.length; i++) {
+      const stftBin = kernel.startBin + i;
+      const stftMag = stftMagnitudes[stftBin] ?? 0;
+      const weight = kernel.weights[i] ?? 0;
+      sum += stftMag * weight;
+    }
+    cqtMagnitudes[k] = sum;
+  }
+  return cqtMagnitudes;
+}
+function withCqtDefaults(partial) {
+  return {
+    binsPerOctave: partial?.binsPerOctave ?? CQT_DEFAULTS.binsPerOctave,
+    fMin: partial?.fMin ?? CQT_DEFAULTS.fMin,
+    fMax: partial?.fMax ?? CQT_DEFAULTS.fMax,
+    hopSize: partial?.hopSize
+  };
+}
+async function cqtSpectrogram(audio, config, options = {}) {
+  const sampleRate = audio.sampleRate;
+  if (config.fMin <= 0) {
+    throw new Error("@octoseq/mir: CQT fMin must be positive");
+  }
+  if (config.fMax <= config.fMin) {
+    throw new Error("@octoseq/mir: CQT fMax must be greater than fMin");
+  }
+  if (config.binsPerOctave <= 0) {
+    throw new Error("@octoseq/mir: CQT binsPerOctave must be positive");
+  }
+  const Q = 1 / (Math.pow(2, 1 / config.binsPerOctave) - 1);
+  const minFreqResolution = config.fMin / Q / 2;
+  const minFftSize = Math.ceil(sampleRate / minFreqResolution);
+  let fftSize = 1;
+  while (fftSize < minFftSize) {
+    fftSize *= 2;
+  }
+  fftSize = Math.min(fftSize, 16384);
+  const hopSize = config.hopSize ?? Math.floor(fftSize / 4);
+  const stft = await spectrogram(
+    audio,
+    { fftSize, hopSize, window: "hann" },
+    void 0,
+    { isCancelled: options.isCancelled }
+  );
+  const kernelBank = getCqtKernelBank(config, fftSize, sampleRate);
+  const nFrames = stft.magnitudes.length;
+  const cqtMagnitudes = new Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    if (options.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    const stftFrame = stft.magnitudes[frame];
+    if (!stftFrame) continue;
+    cqtMagnitudes[frame] = applyCqtKernels(stftFrame, kernelBank);
+  }
+  const nOctaves = getNumOctaves(config);
+  getNumBins(config);
+  return {
+    sampleRate,
+    config,
+    times: stft.times,
+    magnitudes: cqtMagnitudes,
+    nOctaves,
+    binsPerOctave: config.binsPerOctave,
+    binFrequencies: getCqtBinFrequencies(config)
+  };
+}
+async function computeCqt(audio, config, options = {}) {
+  const startTime = performance.now();
+  const fullConfig = withCqtDefaults(config);
+  const cqt = await cqtSpectrogram(audio, fullConfig, options);
+  const endTime = performance.now();
+  return {
+    cqt,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+
+// src/dsp/cqtSignals.ts
+var BASS_MIN_HZ = 20;
+var BASS_MAX_HZ = 300;
+var TONAL_STABILITY_WINDOW_FRAMES = 20;
+var CHROMA_BINS = 12;
+function normalizeMinMax(values) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i] ?? 0;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const range = max - min;
+  const result = new Float32Array(values.length);
+  if (range > 0) {
+    for (let i = 0; i < values.length; i++) {
+      result[i] = ((values[i] ?? 0) - min) / range;
+    }
+  } else {
+    result.fill(0.5);
+  }
+  return result;
+}
+function weightedCentroid(values, startIndex = 0) {
+  let sumWeighted = 0;
+  let sumWeights = 0;
+  for (let i = 0; i < values.length; i++) {
+    const weight = values[i] ?? 0;
+    sumWeighted += (startIndex + i) * weight;
+    sumWeights += weight;
+  }
+  return sumWeights > 0 ? sumWeighted / sumWeights : startIndex + values.length / 2;
+}
+function computeHarmonicEnergyFrame(frame, cqt) {
+  if (frame.length === 0) return 0;
+  let totalEnergy = 0;
+  for (let i = 0; i < frame.length; i++) {
+    const mag = frame[i] ?? 0;
+    totalEnergy += mag * mag;
+  }
+  if (totalEnergy === 0) return 0;
+  let maxMag = 0;
+  let fundamentalBin = 0;
+  for (let i = 0; i < frame.length; i++) {
+    const mag = frame[i] ?? 0;
+    if (mag > maxMag) {
+      maxMag = mag;
+      fundamentalBin = i;
+    }
+  }
+  const fundamentalFreq = cqtBinToHz(fundamentalBin, cqt.config);
+  let harmonicEnergy2 = 0;
+  const numHarmonics = 6;
+  for (let h = 1; h <= numHarmonics; h++) {
+    const harmonicFreq = fundamentalFreq * h;
+    const harmonicBin = Math.round(hzToCqtBin(harmonicFreq, cqt.config));
+    if (harmonicBin >= 0 && harmonicBin < frame.length) {
+      const mag = frame[harmonicBin] ?? 0;
+      const weight = 1 / h;
+      harmonicEnergy2 += mag * mag * weight;
+    }
+  }
+  let weightSum = 0;
+  for (let h = 1; h <= numHarmonics; h++) {
+    weightSum += 1 / h;
+  }
+  harmonicEnergy2 /= weightSum;
+  return Math.min(1, harmonicEnergy2 / totalEnergy);
+}
+function harmonicEnergy(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const values = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (cqtFrame) {
+      values[frame] = computeHarmonicEnergyFrame(cqtFrame, cqt);
+    }
+  }
+  const normalized = normalizeMinMax(values);
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "harmonicEnergy",
+    times: cqt.times,
+    values: normalized,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function bassPitchMotion(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const bassStartBin = Math.max(0, Math.floor(hzToCqtBin(BASS_MIN_HZ, cqt.config)));
+  const bassEndBin = Math.min(
+    cqt.magnitudes[0]?.length ?? 0,
+    Math.ceil(hzToCqtBin(BASS_MAX_HZ, cqt.config))
+  );
+  const bassNumBins = bassEndBin - bassStartBin;
+  if (bassNumBins <= 0) {
+    return {
+      kind: "cqt1d",
+      signalId: "bassPitchMotion",
+      times: cqt.times,
+      values: new Float32Array(nFrames),
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: { totalMs: 0, cpuMs: 0 }
+      }
+    };
+  }
+  const centroids = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (!cqtFrame) continue;
+    const bassBins = new Float32Array(bassNumBins);
+    for (let i = 0; i < bassNumBins; i++) {
+      bassBins[i] = cqtFrame[bassStartBin + i] ?? 0;
+    }
+    centroids[frame] = weightedCentroid(bassBins, bassStartBin);
+  }
+  const motion = new Float32Array(nFrames);
+  for (let frame = 1; frame < nFrames; frame++) {
+    motion[frame] = Math.abs((centroids[frame] ?? 0) - (centroids[frame - 1] ?? 0));
+  }
+  motion[0] = motion[1] ?? 0;
+  const normalized = normalizeMinMax(motion);
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "bassPitchMotion",
+    times: cqt.times,
+    values: normalized,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function computeChroma(frame, binsPerOctave) {
+  const chroma = new Float32Array(CHROMA_BINS);
+  const binsPerSemitone = binsPerOctave / CHROMA_BINS;
+  for (let i = 0; i < frame.length; i++) {
+    const chromaBin = Math.floor(i % binsPerOctave / binsPerSemitone) % CHROMA_BINS;
+    const mag = frame[i] ?? 0;
+    chroma[chromaBin] = (chroma[chromaBin] ?? 0) + mag * mag;
+  }
+  let sum = 0;
+  for (let i = 0; i < CHROMA_BINS; i++) {
+    sum += chroma[i] ?? 0;
+  }
+  if (sum > 0) {
+    for (let i = 0; i < CHROMA_BINS; i++) {
+      chroma[i] = (chroma[i] ?? 0) / sum;
+    }
+  }
+  return chroma;
+}
+function tonalStability(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const chromas = new Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (cqtFrame) {
+      chromas[frame] = computeChroma(cqtFrame, cqt.binsPerOctave);
+    } else {
+      chromas[frame] = new Float32Array(CHROMA_BINS);
+    }
+  }
+  const halfWindow = Math.floor(TONAL_STABILITY_WINDOW_FRAMES / 2);
+  const instability = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const windowStart = Math.max(0, frame - halfWindow);
+    const windowEnd = Math.min(nFrames, frame + halfWindow + 1);
+    const windowSize = windowEnd - windowStart;
+    const avgChroma = new Float32Array(CHROMA_BINS);
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          avgChroma[c] = (avgChroma[c] ?? 0) + (chroma[c] ?? 0);
+        }
+      }
+    }
+    for (let c = 0; c < CHROMA_BINS; c++) {
+      avgChroma[c] = (avgChroma[c] ?? 0) / windowSize;
+    }
+    let totalVariance = 0;
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          const diff = (chroma[c] ?? 0) - (avgChroma[c] ?? 0);
+          totalVariance += diff * diff;
+        }
+      }
+    }
+    totalVariance /= windowSize * CHROMA_BINS;
+    instability[frame] = totalVariance;
+  }
+  const normalizedInstability = normalizeMinMax(instability);
+  const stability = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    stability[frame] = 1 - (normalizedInstability[frame] ?? 0);
+  }
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "tonalStability",
+    times: cqt.times,
+    values: stability,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function computeCqtSignal(cqt, signalId) {
+  switch (signalId) {
+    case "harmonicEnergy":
+      return harmonicEnergy(cqt);
+    case "bassPitchMotion":
+      return bassPitchMotion(cqt);
+    case "tonalStability":
+      return tonalStability(cqt);
+    default:
+      throw new Error(`@octoseq/mir: unknown CQT signal ID: ${signalId}`);
+  }
+}
+function computeAllCqtSignals(cqt) {
+  const results = /* @__PURE__ */ new Map();
+  results.set("harmonicEnergy", harmonicEnergy(cqt));
+  results.set("bassPitchMotion", bassPitchMotion(cqt));
+  results.set("tonalStability", tonalStability(cqt));
+  return results;
+}
+
 // src/runner/runMir.ts
 function nowMs2() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
@@ -1579,6 +2059,27 @@ async function runMir(audio, request, options = {}) {
     hopSize: 512,
     window: "hann"
   };
+  if (request.fn === "amplitudeEnvelope") {
+    const cpuStart2 = nowMs2();
+    const result = amplitudeEnvelope(audio.mono, audio.sampleRate, {
+      hopSize: specConfig.hopSize,
+      windowSize: specConfig.fftSize
+    });
+    const cpuEnd = nowMs2();
+    return {
+      kind: "1d",
+      times: result.times,
+      values: result.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: cpuEnd - t0,
+          cpuMs: cpuEnd - cpuStart2
+        }
+      }
+    };
+  }
   const cpuStart = nowMs2();
   const spec = await spectrogram(asAudioBufferLike(audio), specConfig, void 0, {
     isCancelled: options.isCancelled
@@ -1908,6 +2409,36 @@ async function runMir(audio, request, options = {}) {
       }
     };
   }
+  if (request.fn === "cqtHarmonicEnergy" || request.fn === "cqtBassPitchMotion" || request.fn === "cqtTonalStability") {
+    const cqtStart = nowMs2();
+    const cqtConfig = withCqtDefaults(request.cqt);
+    const cqt = await cqtSpectrogram(asAudioBufferLike(audio), cqtConfig, {
+      isCancelled: options.isCancelled
+    });
+    const cqtEnd = nowMs2();
+    let signal;
+    if (request.fn === "cqtHarmonicEnergy") {
+      signal = harmonicEnergy(cqt);
+    } else if (request.fn === "cqtBassPitchMotion") {
+      signal = bassPitchMotion(cqt);
+    } else {
+      signal = tonalStability(cqt);
+    }
+    const end2 = nowMs2();
+    return {
+      kind: "1d",
+      times: signal.times,
+      values: signal.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cqtEnd - cqtStart + (end2 - cqtEnd)
+        }
+      }
+    };
+  }
   const { mel, usedGpu, gpuMs, cpuExtraMs } = await computeMel(backend === "gpu");
   const end = nowMs2();
   return {
@@ -1926,6 +2457,6 @@ async function runMir(audio, request, options = {}) {
   };
 }
 
-export { beatSalienceFromMel, delta, deltaDelta, detectBeatCandidates, generateTempoHypotheses, hpss, melSpectrogram, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram };
-//# sourceMappingURL=chunk-KIGWMJLC.js.map
-//# sourceMappingURL=chunk-KIGWMJLC.js.map
+export { CQT_DEFAULTS, amplitudeEnvelope, bassPitchMotion, beatSalienceFromMel, computeAllCqtSignals, computeCqt, computeCqtSignal, cqtBinToHz, cqtSpectrogram, delta, deltaDelta, detectBeatCandidates, featureIndexToHz, generateTempoHypotheses, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, hpss, hzToCqtBin, hzToFeatureIndex, hzToMel, melSpectrogram, melToHz, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram, tonalStability, withCqtDefaults };
+//# sourceMappingURL=chunk-CI7QGWP7.js.map
+//# sourceMappingURL=chunk-CI7QGWP7.js.map