@waveform-playlist/spectrogram 11.3.1 → 13.0.0

package/dist/worker/spectrogram.worker.mjs

@@ -1,606 +0,0 @@
-// src/computation/fft.ts
-import FFT from "fft.js";
-var fftInstances = /* @__PURE__ */ new Map();
-var complexBuffers = /* @__PURE__ */ new Map();
-function getFftInstance(size) {
-  let instance = fftInstances.get(size);
-  if (!instance) {
-    instance = new FFT(size);
-    fftInstances.set(size, instance);
-    complexBuffers.set(size, instance.createComplexArray());
-  }
-  return instance;
-}
-function getComplexBuffer(size) {
-  const buffer = complexBuffers.get(size);
-  if (!buffer) {
-    throw new Error(`No complex buffer for size ${size}. Call getFftInstance first.`);
-  }
-  return buffer;
-}
-function fftMagnitudeDb(real, out) {
-  const n = real.length;
-  const f = getFftInstance(n);
-  const complexOut = getComplexBuffer(n);
-  f.realTransform(complexOut, real);
-  const half = n >> 1;
-  for (let i = 0; i < half; i++) {
-    const re = complexOut[i * 2];
-    const im = complexOut[i * 2 + 1];
-    let db = 20 * Math.log10(Math.sqrt(re * re + im * im) + 1e-10);
-    if (db < -160) db = -160;
-    out[i] = db;
-  }
-}
-
-// src/computation/windowFunctions.ts
-function getWindowFunction(name, size, alpha) {
-  const window = new Float32Array(size);
-  const N = size;
-  switch (name) {
-    case "rectangular":
-      for (let i = 0; i < size; i++) window[i] = 1;
-      break;
-    case "bartlett":
-      for (let i = 0; i < size; i++) {
-        window[i] = 1 - Math.abs((2 * i - N) / N);
-      }
-      break;
-    case "hann":
-      for (let i = 0; i < size; i++) {
-        window[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / N));
-      }
-      break;
-    case "hamming":
-      for (let i = 0; i < size; i++) {
-        const a = alpha ?? 0.54;
-        window[i] = a - (1 - a) * Math.cos(2 * Math.PI * i / N);
-      }
-      break;
-    case "blackman": {
-      const a0 = 0.42;
-      const a1 = 0.5;
-      const a2 = 0.08;
-      for (let i = 0; i < size; i++) {
-        window[i] = a0 - a1 * Math.cos(2 * Math.PI * i / N) + a2 * Math.cos(4 * Math.PI * i / N);
-      }
-      break;
-    }
-    case "blackman-harris": {
-      const c0 = 0.35875;
-      const c1 = 0.48829;
-      const c2 = 0.14128;
-      const c3 = 0.01168;
-      for (let i = 0; i < size; i++) {
-        window[i] = c0 - c1 * Math.cos(2 * Math.PI * i / N) + c2 * Math.cos(4 * Math.PI * i / N) - c3 * Math.cos(6 * Math.PI * i / N);
-      }
-      break;
-    }
-    default:
-      console.warn(`[spectrogram] Unknown window function "${name}", falling back to hann`);
-      for (let i = 0; i < size; i++) {
-        window[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / N));
-      }
-  }
-  let sum = 0;
-  for (let i = 0; i < size; i++) sum += window[i];
-  if (sum > 0) {
-    const scale = 2 / sum;
-    for (let i = 0; i < size; i++) window[i] *= scale;
-  }
-  return window;
-}
-
-// src/computation/frequencyScales.ts
-function linearScale(f, minF, maxF) {
-  if (maxF === minF) return 0;
-  return (f - minF) / (maxF - minF);
-}
-function logarithmicScale(f, minF, maxF) {
-  const logMin = Math.log2(Math.max(minF, 1));
-  const logMax = Math.log2(maxF);
-  if (logMax === logMin) return 0;
-  return (Math.log2(Math.max(f, 1)) - logMin) / (logMax - logMin);
-}
-function hzToMel(f) {
-  return 2595 * Math.log10(1 + f / 700);
-}
-function melScale(f, minF, maxF) {
-  const melMin = hzToMel(minF);
-  const melMax = hzToMel(maxF);
-  if (melMax === melMin) return 0;
-  return (hzToMel(f) - melMin) / (melMax - melMin);
-}
-function hzToBark(f) {
-  return 13 * Math.atan(76e-5 * f) + 3.5 * Math.atan((f / 7500) ** 2);
-}
-function barkScale(f, minF, maxF) {
-  const barkMin = hzToBark(minF);
-  const barkMax = hzToBark(maxF);
-  if (barkMax === barkMin) return 0;
-  return (hzToBark(f) - barkMin) / (barkMax - barkMin);
-}
-function hzToErb(f) {
-  return 21.4 * Math.log10(1 + 437e-5 * f);
-}
-function erbScale(f, minF, maxF) {
-  const erbMin = hzToErb(minF);
-  const erbMax = hzToErb(maxF);
-  if (erbMax === erbMin) return 0;
-  return (hzToErb(f) - erbMin) / (erbMax - erbMin);
-}
-function getFrequencyScale(name) {
-  switch (name) {
-    case "logarithmic":
-      return logarithmicScale;
-    case "mel":
-      return melScale;
-    case "bark":
-      return barkScale;
-    case "erb":
-      return erbScale;
-    case "linear":
-      return linearScale;
-    default:
-      console.warn(`[spectrogram] Unknown frequency scale "${name}", falling back to linear`);
-      return linearScale;
-  }
-}
-
-// src/worker/spectrogram.worker.ts
-var canvasRegistry = /* @__PURE__ */ new Map();
-var audioDataRegistry = /* @__PURE__ */ new Map();
-var MAX_CACHE_ENTRIES = 16;
-var fftCache = /* @__PURE__ */ new Map();
-function evictLRUCacheEntries(keepKey) {
-  while (fftCache.size >= MAX_CACHE_ENTRIES) {
-    let deleted = false;
-    for (const key of fftCache.keys()) {
-      if (key !== keepKey) {
-        fftCache.delete(key);
-        deleted = true;
-        break;
-      }
-    }
-    if (!deleted) break;
-  }
-}
-function touchCacheEntry(key) {
-  const entry = fftCache.get(key);
-  if (entry) {
-    fftCache.delete(key);
-    fftCache.set(key, entry);
-  }
-}
-function generateCacheKey(params) {
-  const { compute: c } = params;
-  return `${params.clipId}:${params.channelIndex}:${params.offsetSamples}:${params.durationSamples}:${params.sampleRate}:${c.fftSize ?? ""}:${c.zeroPaddingFactor ?? ""}:${c.hopSize ?? ""}:${c.windowFunction ?? ""}:${c.alpha ?? ""}:${params.mono ? 1 : 0}`;
-}
-var latestGeneration = 0;
-var FRAMES_PER_YIELD = 2e3;
-function isGenerationStale(generation) {
-  return generation < latestGeneration;
-}
-function yieldToMessageQueue() {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-async function computeFromChannelData(channelData, config, sampleRate, offsetSamples, durationSamples, generation) {
-  const windowSize = config.fftSize ?? 2048;
-  const zeroPaddingFactor = config.zeroPaddingFactor ?? 2;
-  const actualFftSize = windowSize * zeroPaddingFactor;
-  const hopSize = config.hopSize ?? Math.floor(windowSize / 4);
-  const windowName = config.windowFunction ?? "hann";
-  const gainDb = config.gainDb ?? 20;
-  const rangeDb = config.rangeDb ?? 80;
-  const alpha = config.alpha;
-  const frequencyBinCount = actualFftSize >> 1;
-  const totalSamples = durationSamples;
-  const window = getWindowFunction(windowName, windowSize, alpha);
-  const frameCount = Math.max(1, Math.floor((totalSamples - windowSize) / hopSize) + 1);
-  const data = new Float32Array(frameCount * frequencyBinCount);
-  const real = new Float32Array(actualFftSize);
-  const dbBuf = new Float32Array(frequencyBinCount);
-  for (let frame = 0; frame < frameCount; frame++) {
-    if (frame > 0 && frame % FRAMES_PER_YIELD === 0) {
-      await yieldToMessageQueue();
-      if (isGenerationStale(generation)) return null;
-    }
-    const start = offsetSamples + frame * hopSize;
-    for (let i = 0; i < windowSize; i++) {
-      const sampleIdx = start + i;
-      real[i] = sampleIdx < channelData.length ? channelData[sampleIdx] * window[i] : 0;
-    }
-    for (let i = windowSize; i < actualFftSize; i++) {
-      real[i] = 0;
-    }
-    fftMagnitudeDb(real, dbBuf);
-    data.set(dbBuf, frame * frequencyBinCount);
-  }
-  return {
-    fftSize: actualFftSize,
-    windowSize,
-    frequencyBinCount,
-    sampleRate,
-    hopSize,
-    frameCount,
-    data,
-    gainDb,
-    rangeDb
-  };
-}
-async function computeMonoFromChannels(channels, config, sampleRate, offsetSamples, durationSamples, generation) {
-  if (channels.length === 1) {
-    return computeFromChannelData(
-      channels[0],
-      config,
-      sampleRate,
-      offsetSamples,
-      durationSamples,
-      generation
-    );
-  }
-  const windowSize = config.fftSize ?? 2048;
-  const zeroPaddingFactor = config.zeroPaddingFactor ?? 2;
-  const actualFftSize = windowSize * zeroPaddingFactor;
-  const hopSize = config.hopSize ?? Math.floor(windowSize / 4);
-  const windowName = config.windowFunction ?? "hann";
-  const gainDb = config.gainDb ?? 20;
-  const rangeDb = config.rangeDb ?? 80;
-  const alpha = config.alpha;
-  const frequencyBinCount = actualFftSize >> 1;
-  const numChannels = channels.length;
-  const window = getWindowFunction(windowName, windowSize, alpha);
-  const frameCount = Math.max(1, Math.floor((durationSamples - windowSize) / hopSize) + 1);
-  const data = new Float32Array(frameCount * frequencyBinCount);
-  const real = new Float32Array(actualFftSize);
-  const dbBuf = new Float32Array(frequencyBinCount);
-  for (let frame = 0; frame < frameCount; frame++) {
-    if (frame > 0 && frame % FRAMES_PER_YIELD === 0) {
-      await yieldToMessageQueue();
-      if (isGenerationStale(generation)) return null;
-    }
-    const start = offsetSamples + frame * hopSize;
-    for (let i = 0; i < windowSize; i++) {
-      const sampleIdx = start + i;
-      let sum = 0;
-      for (let ch = 0; ch < numChannels; ch++) {
-        sum += sampleIdx < channels[ch].length ? channels[ch][sampleIdx] : 0;
-      }
-      real[i] = sum / numChannels * window[i];
-    }
-    for (let i = windowSize; i < actualFftSize; i++) {
-      real[i] = 0;
-    }
-    fftMagnitudeDb(real, dbBuf);
-    data.set(dbBuf, frame * frequencyBinCount);
-  }
-  return {
-    fftSize: actualFftSize,
-    windowSize,
-    frequencyBinCount,
-    sampleRate,
-    hopSize,
-    frameCount,
-    data,
-    gainDb,
-    rangeDb
-  };
-}
-function renderSpectrogramToCanvas(specData, canvasIds, canvasWidths, canvasHeight, devicePixelRatio, samplesPerPixel, colorLUT, scaleFn, minFrequency, maxFrequency, isNonLinear, globalPixelOffsets, gainDbOverride, rangeDbOverride, sampleOffset = 0) {
-  const { frequencyBinCount, frameCount, hopSize, sampleRate } = specData;
-  const gainDb = gainDbOverride ?? specData.gainDb;
-  const rawRangeDb = rangeDbOverride ?? specData.rangeDb;
-  const rangeDb = rawRangeDb === 0 ? 1 : rawRangeDb;
-  const maxF = maxFrequency > 0 ? maxFrequency : sampleRate / 2;
-  const binToFreq = (bin) => bin / frequencyBinCount * (sampleRate / 2);
-  let accumulatedOffset = 0;
-  for (let chunkIdx = 0; chunkIdx < canvasIds.length; chunkIdx++) {
-    const canvasId = canvasIds[chunkIdx];
-    const offscreen = canvasRegistry.get(canvasId);
-    if (!offscreen) {
-      console.warn(`[spectrogram-worker] Canvas "${canvasId}" not found in registry`);
-      if (!globalPixelOffsets) accumulatedOffset += canvasWidths[chunkIdx];
-      continue;
-    }
-    const canvasWidth = canvasWidths[chunkIdx];
-    const globalPixelOffset = globalPixelOffsets ? globalPixelOffsets[chunkIdx] : accumulatedOffset;
-    offscreen.width = canvasWidth * devicePixelRatio;
-    offscreen.height = canvasHeight * devicePixelRatio;
-    const ctx = offscreen.getContext("2d");
-    if (!ctx) {
-      console.warn(`[spectrogram-worker] getContext('2d') returned null for canvas "${canvasId}"`);
-      if (!globalPixelOffsets) accumulatedOffset += canvasWidth;
-      continue;
-    }
-    ctx.resetTransform();
-    ctx.clearRect(0, 0, offscreen.width, offscreen.height);
-    ctx.imageSmoothingEnabled = false;
-    const imgData = ctx.createImageData(canvasWidth, canvasHeight);
-    const pixels = imgData.data;
-    for (let x = 0; x < canvasWidth; x++) {
-      const globalX = globalPixelOffset + x;
-      const samplePos = globalX * samplesPerPixel - sampleOffset;
-      const frame = Math.floor(samplePos / hopSize);
-      if (frame < 0 || frame >= frameCount) continue;
-      const frameOffset = frame * frequencyBinCount;
-      for (let y = 0; y < canvasHeight; y++) {
-        const normalizedY = 1 - y / canvasHeight;
-        let bin = Math.floor(normalizedY * frequencyBinCount);
-        if (isNonLinear) {
-          let lo = 0;
-          let hi = frequencyBinCount - 1;
-          while (lo < hi) {
-            const mid = lo + hi >> 1;
-            const freq = binToFreq(mid);
-            const scaled = scaleFn(freq, minFrequency, maxF);
-            if (scaled < normalizedY) {
-              lo = mid + 1;
-            } else {
-              hi = mid;
-            }
-          }
-          bin = lo;
-        }
-        if (bin < 0 || bin >= frequencyBinCount) continue;
-        const db = specData.data[frameOffset + bin];
-        const normalized = Math.max(0, Math.min(1, (db + rangeDb + gainDb) / rangeDb));
-        const colorIdx = Math.floor(normalized * 255);
-        const pixelIdx = (y * canvasWidth + x) * 4;
-        pixels[pixelIdx] = colorLUT[colorIdx * 3];
-        pixels[pixelIdx + 1] = colorLUT[colorIdx * 3 + 1];
-        pixels[pixelIdx + 2] = colorLUT[colorIdx * 3 + 2];
-        pixels[pixelIdx + 3] = 255;
-      }
-    }
-    if (devicePixelRatio === 1) {
-      ctx.putImageData(imgData, 0, 0);
-    } else {
-      const tmpCanvas = new OffscreenCanvas(canvasWidth, canvasHeight);
-      const tmpCtx = tmpCanvas.getContext("2d");
-      if (!tmpCtx) {
-        console.warn(
-          `[spectrogram-worker] getContext('2d') failed for DPR scaling of "${canvasIds[chunkIdx]}"`
-        );
-        continue;
-      }
-      tmpCtx.putImageData(imgData, 0, 0);
-      ctx.imageSmoothingEnabled = false;
-      ctx.drawImage(tmpCanvas, 0, 0, offscreen.width, offscreen.height);
-    }
-    if (!globalPixelOffsets) accumulatedOffset += canvasWidth;
-  }
-}
-async function handleComputeFFT(msg) {
-  const {
-    id,
-    generation,
-    clipId,
-    config,
-    sampleRate: msgSampleRate,
-    offsetSamples,
-    durationSamples,
-    mono,
-    sampleRange,
-    channelFilter
-  } = msg;
-  const registered = audioDataRegistry.get(clipId);
-  const channelDataArrays = registered && msg.channelDataArrays.length === 0 ? registered.channelDataArrays : msg.channelDataArrays;
-  const sampleRate = registered && msg.channelDataArrays.length === 0 ? registered.sampleRate : msgSampleRate;
-  const fftSize = config.fftSize ?? 2048;
-  const zeroPaddingFactor = config.zeroPaddingFactor ?? 2;
-  const hopSize = config.hopSize ?? Math.floor(fftSize / 4);
-  const windowFunction = config.windowFunction ?? "hann";
-  const effectiveOffset = sampleRange ? sampleRange.start : offsetSamples;
-  const effectiveDuration = sampleRange ? sampleRange.end - sampleRange.start : durationSamples;
-  const cacheKey = generateCacheKey({
-    clipId,
-    channelIndex: 0,
-    offsetSamples: effectiveOffset,
-    durationSamples: effectiveDuration,
-    sampleRate,
-    compute: { fftSize, zeroPaddingFactor, hopSize, windowFunction, alpha: config.alpha },
-    mono
-  });
-  if (!fftCache.has(cacheKey)) {
-    evictLRUCacheEntries(cacheKey);
-    const spectrograms = [];
-    if (mono || channelDataArrays.length === 1) {
-      const result = await computeMonoFromChannels(
-        channelDataArrays,
-        config,
-        sampleRate,
-        effectiveOffset,
-        effectiveDuration,
-        generation
-      );
-      if (result === null) {
-        const response2 = { id, type: "aborted" };
-        self.postMessage(response2);
-        return;
-      }
-      spectrograms.push(result);
-    } else if (channelFilter !== void 0) {
-      const channelData = channelDataArrays[channelFilter];
-      if (!channelData) {
-        const response2 = {
-          id,
-          type: "error",
-          error: `channelFilter ${channelFilter} out of range (${channelDataArrays.length} channels)`
-        };
-        self.postMessage(response2);
-        return;
-      }
-      const result = await computeFromChannelData(
-        channelData,
-        config,
-        sampleRate,
-        effectiveOffset,
-        effectiveDuration,
-        generation
-      );
-      if (result === null) {
-        const response2 = { id, type: "aborted" };
-        self.postMessage(response2);
-        return;
-      }
-      spectrograms.push(result);
-    } else {
-      for (const channelData of channelDataArrays) {
-        const result = await computeFromChannelData(
-          channelData,
-          config,
-          sampleRate,
-          effectiveOffset,
-          effectiveDuration,
-          generation
-        );
-        if (result === null) {
-          const response2 = { id, type: "aborted" };
-          self.postMessage(response2);
-          return;
-        }
-        spectrograms.push(result);
-      }
-    }
-    fftCache.set(cacheKey, { spectrograms, sampleOffset: effectiveOffset });
-  } else {
-    touchCacheEntry(cacheKey);
-  }
-  const response = { id, type: "cache-key", cacheKey };
-  self.postMessage(response);
-}
-self.onmessage = (e) => {
-  const msg = e.data;
-  if (msg.type === "register-canvas") {
-    try {
-      canvasRegistry.set(msg.canvasId, msg.canvas);
-    } catch (err) {
-      console.warn("[spectrogram-worker] register-canvas failed:", err);
-    }
-    return;
-  }
-  if (msg.type === "unregister-canvas") {
-    try {
-      canvasRegistry.delete(msg.canvasId);
-    } catch (err) {
-      console.warn("[spectrogram-worker] unregister-canvas failed:", err);
-    }
-    return;
-  }
-  if (msg.type === "register-audio-data") {
-    try {
-      audioDataRegistry.set(msg.clipId, {
-        channelDataArrays: msg.channelDataArrays,
-        sampleRate: msg.sampleRate
-      });
-    } catch (err) {
-      console.warn("[spectrogram-worker] register-audio-data failed:", err);
-    }
-    return;
-  }
-  if (msg.type === "unregister-audio-data") {
-    try {
-      audioDataRegistry.delete(msg.clipId);
-      const prefix = `${msg.clipId}:`;
-      for (const key of fftCache.keys()) {
-        if (key.startsWith(prefix)) {
-          fftCache.delete(key);
-        }
-      }
-    } catch (err) {
-      console.warn("[spectrogram-worker] unregister-audio-data failed:", err);
-    }
-    return;
-  }
-  if (msg.type === "abort-generation") {
-    latestGeneration = Math.max(latestGeneration, msg.generation);
-    return;
-  }
-  if (msg.type === "compute-fft") {
-    const { id, generation } = msg;
-    if (isGenerationStale(generation)) {
-      const response = { id, type: "aborted" };
-      self.postMessage(response);
-      return;
-    }
-    handleComputeFFT(msg).catch((err) => {
-      const errorMsg = err instanceof Error ? `${err.message}
-${err.stack}` : String(err);
-      const response = { id, type: "error", error: errorMsg };
-      self.postMessage(response);
-    });
-    return;
-  }
-  if (msg.type === "render-chunks") {
-    const { id, generation } = msg;
-    if (isGenerationStale(generation)) {
-      const response = { id, type: "aborted" };
-      self.postMessage(response);
-      return;
-    }
-    try {
-      const {
-        cacheKey,
-        canvasIds,
-        canvasWidths,
-        globalPixelOffsets,
-        canvasHeight,
-        devicePixelRatio,
-        samplesPerPixel,
-        colorLUT,
-        frequencyScale,
-        minFrequency,
-        maxFrequency,
-        gainDb,
-        rangeDb,
-        channelIndex
-      } = msg;
-      const cacheEntry = fftCache.get(cacheKey);
-      if (!cacheEntry) {
-        const response2 = {
-          id,
-          type: "error",
-          error: `cache-miss: key "${cacheKey}" not found (cache has ${fftCache.size} entries)`
-        };
-        self.postMessage(response2);
-        return;
-      }
-      if (channelIndex >= cacheEntry.spectrograms.length) {
-        const response2 = {
-          id,
-          type: "error",
-          error: `cache-miss: channelIndex ${channelIndex} out of range (${cacheEntry.spectrograms.length} channels cached)`
-        };
-        self.postMessage(response2);
-        return;
-      }
-      const scaleFn = getFrequencyScale(frequencyScale ?? "mel");
-      const isNonLinear = frequencyScale !== "linear";
-      renderSpectrogramToCanvas(
-        cacheEntry.spectrograms[channelIndex],
-        canvasIds,
-        canvasWidths,
-        canvasHeight,
-        devicePixelRatio,
-        samplesPerPixel,
-        colorLUT,
-        scaleFn,
-        minFrequency,
-        maxFrequency,
-        isNonLinear,
-        globalPixelOffsets,
-        gainDb,
-        rangeDb,
-        cacheEntry.sampleOffset
-      );
-      const response = { id, type: "done" };
-      self.postMessage(response);
-    } catch (err) {
-      const response = { id, type: "error", error: String(err) };
-      self.postMessage(response);
-    }
-    return;
-  }
-  console.warn(`[spectrogram-worker] Unknown message type: ${msg.type}`);
-};
-//# sourceMappingURL=spectrogram.worker.mjs.map