@waveform-playlist/core 11.3.1 → 12.0.0

package/dist/index.js

@@ -24,8 +24,11 @@ __export(index_exports, {
   MAX_CANVAS_WIDTH: () => MAX_CANVAS_WIDTH,
   MIN_PIXELS_PER_UNIT: () => MIN_PIXELS_PER_UNIT,
   PPQN: () => PPQN,
+  appendPeaks: () => appendPeaks,
+  appendToAudioBuffer: () => appendToAudioBuffer,
   applyFadeIn: () => applyFadeIn,
   applyFadeOut: () => applyFadeOut,
+  calculateDuration: () => calculateDuration,
   clipDurationTime: () => clipDurationTime,
   clipEndTime: () => clipEndTime,
   clipOffsetTime: () => clipOffsetTime,
@@ -33,16 +36,21 @@ __export(index_exports, {
   clipStartTime: () => clipStartTime,
   clipsOverlap: () => clipsOverlap,
   computeMusicalTicks: () => computeMusicalTicks,
+  concatenateAudioData: () => concatenateAudioData,
+  createAudioBuffer: () => createAudioBuffer,
   createClip: () => createClip,
   createClipFromSeconds: () => createClipFromSeconds,
+  createClipFromTicks: () => createClipFromTicks,
   createTimeline: () => createTimeline,
   createTrack: () => createTrack,
   dBToNormalized: () => dBToNormalized,
+  detectMeterChanges: () => detectMeterChanges,
   exponentialCurve: () => exponentialCurve,
   findGaps: () => findGaps,
   gainToDb: () => gainToDb,
   gainToNormalized: () => gainToNormalized,
   generateCurve: () => generateCurve,
+  generatePeaks: () => generatePeaks,
   getClipsAtSample: () => getClipsAtSample,
   getClipsInRange: () => getClipsInRange,
   getShortcutLabel: () => getShortcutLabel,
@@ -64,7 +72,6 @@ __export(index_exports, {
   sortClipsByTime: () => sortClipsByTime,
   ticksPerBar: () => ticksPerBar,
   ticksPerBeat: () => ticksPerBeat,
-  ticksToBarBeatLabel: () => ticksToBarBeatLabel,
   ticksToSamples: () => ticksToSamples,
   trackChannelCount: () => trackChannelCount
 });
@@ -74,10 +81,50 @@ module.exports = __toCommonJS(index_exports);
 var MAX_CANVAS_WIDTH = 1e3;
 
 // src/types/clip.ts
+function createClipFromTicks(options) {
+  const { startTick, ticksToSeconds, bpm, ppqn } = options;
+  if (startTick < 0) {
+    throw new Error("createClipFromTicks: startTick must be non-negative");
+  }
+  let toSeconds;
+  if (ticksToSeconds) {
+    toSeconds = ticksToSeconds;
+  } else if (bpm !== void 0 && ppqn !== void 0) {
+    toSeconds = (tick) => tick * 60 / (ppqn * bpm);
+  } else {
+    throw new Error(
+      "createClipFromTicks: either ticksToSeconds callback or both bpm and ppqn are required"
+    );
+  }
+  const sampleRate = options.audioBuffer?.sampleRate ?? options.sampleRate ?? options.waveformData?.sample_rate;
+  if (sampleRate === void 0) {
+    throw new Error("createClipFromTicks: sampleRate is required when audioBuffer is not provided");
+  }
+  const startSample = Math.round(toSeconds(startTick) * sampleRate);
+  return createClip({
+    audioBuffer: options.audioBuffer,
+    startSample,
+    startTick,
+    durationSamples: options.durationSamples,
+    offsetSamples: options.offsetSamples,
+    gain: options.gain,
+    name: options.name,
+    color: options.color,
+    fadeIn: options.fadeIn,
+    fadeOut: options.fadeOut,
+    waveformData: options.waveformData,
+    sampleRate: options.sampleRate,
+    sourceDurationSamples: options.sourceDurationSamples,
+    midiNotes: options.midiNotes,
+    midiChannel: options.midiChannel,
+    midiProgram: options.midiProgram
+  });
+}
 function createClip(options) {
   const {
     audioBuffer,
     startSample,
+    startTick,
     offsetSamples = 0,
     gain = 1,
     name,
@@ -111,6 +158,7 @@ function createClip(options) {
     id: generateId(),
     audioBuffer,
     startSample,
+    startTick,
     durationSamples,
     offsetSamples,
     sampleRate,
@@ -157,6 +205,7 @@ function createClipFromSeconds(options) {
   return createClip({
     audioBuffer,
     startSample: Math.round(startTime * sampleRate),
+    startTick: options.startTick,
     durationSamples: Math.round(duration * sampleRate),
     offsetSamples: Math.round(offset * sampleRate),
     sampleRate,
@@ -306,14 +355,6 @@ function samplesToTicks(samples, bpm, sampleRate, ppqn = PPQN) {
 function snapToGrid(ticks, gridSizeTicks) {
   return Math.round(ticks / gridSizeTicks) * gridSizeTicks;
 }
-function ticksToBarBeatLabel(ticks, timeSignature, ppqn = PPQN) {
-  const barTicks = ticksPerBar(timeSignature, ppqn);
-  const beatTicks = ticksPerBeat(timeSignature, ppqn);
-  const bar = Math.floor(ticks / barTicks) + 1;
-  const beatInBar = Math.floor(ticks % barTicks / beatTicks) + 1;
-  if (beatInBar === 1) return `${bar}`;
-  return `${bar}.${beatInBar}`;
-}
 
 // src/utils/dBUtils.ts
 var DEFAULT_FLOOR = -100;
@@ -349,11 +390,12 @@ function gainToNormalized(gain, floor = DEFAULT_FLOOR) {
 
 // src/utils/musicalTicks.ts
 function snapToTicks(snapTo, timeSignature, ppqn = 960) {
+  const ts = timeSignature;
   switch (snapTo) {
     case "bar":
-      return ticksPerBar(timeSignature, ppqn);
+      return ticksPerBar(ts, ppqn);
     case "beat":
-      return ticksPerBeat(timeSignature, ppqn);
+      return ticksPerBeat(ts, ppqn);
     case "1/2":
       return ppqn * 2;
     case "1/4":
@@ -379,22 +421,20 @@ function snapToTicks(snapTo, timeSignature, ppqn = 960) {
 var MIN_PIXELS_PER_UNIT = 8;
 var MIN_PIXELS_PER_LABEL = 60;
 function computeMusicalTicks(params) {
-  const { timeSignature, ticksPerPixel, startPixel, endPixel, ppqn = 960 } = params;
-  if (ticksPerPixel <= 0 || ppqn <= 0 || timeSignature[1] <= 0) {
-    return { ticks: [], pixelsPerBar: 0, pixelsPerBeat: 0, zoomLevel: "coarse" };
+  const { meterEntries, ticksPerPixel, startPixel, endPixel, ppqn = 960 } = params;
+  const firstMeter = meterEntries[0] ?? { tick: 0, numerator: 4, denominator: 4 };
+  if (ticksPerPixel <= 0 || ppqn <= 0 || firstMeter.denominator <= 0) {
+    return { ticks: [], pixelsPerQuarterNote: 0, zoomLevel: "coarse" };
   }
-  const tpBeat = ticksPerBeat(timeSignature, ppqn);
-  const tpBar = ticksPerBar(timeSignature, ppqn);
+  const pixelsPerQuarterNote = ppqn / ticksPerPixel;
   const tpEighth = ppqn / 2;
   const tpSixteenth = ppqn / 4;
-  const pixelsPerBar = tpBar / ticksPerPixel;
-  const pixelsPerBeat = tpBeat / ticksPerPixel;
   const pixelsPerEighth = tpEighth / ticksPerPixel;
   const pixelsPerSixteenth = tpSixteenth / ticksPerPixel;
   let zoomLevel;
-  if (pixelsPerBar < MIN_PIXELS_PER_UNIT) {
+  if (pixelsPerQuarterNote * 4 < MIN_PIXELS_PER_UNIT) {
     zoomLevel = "coarse";
-  } else if (pixelsPerBeat < MIN_PIXELS_PER_UNIT) {
+  } else if (pixelsPerQuarterNote < MIN_PIXELS_PER_UNIT) {
     zoomLevel = "bar";
   } else if (pixelsPerEighth < MIN_PIXELS_PER_UNIT) {
     zoomLevel = "beat";
@@ -403,64 +443,247 @@ function computeMusicalTicks(params) {
   } else {
     zoomLevel = "sixteenth";
   }
-  let stepTicks;
-  let coarseBarStep;
+  let coarseQuarterNoteStep;
+  let coarseQuarterNotes = 0;
   if (zoomLevel === "coarse") {
-    let multiplier = 2;
-    while (tpBar * multiplier / ticksPerPixel < MIN_PIXELS_PER_UNIT) {
-      multiplier *= 2;
+    coarseQuarterNotes = 2;
+    while (coarseQuarterNotes * ppqn / ticksPerPixel < MIN_PIXELS_PER_UNIT) {
+      coarseQuarterNotes *= 2;
     }
-    stepTicks = tpBar * multiplier;
-    coarseBarStep = multiplier;
-  } else if (zoomLevel === "bar") {
-    stepTicks = tpBar;
-  } else if (zoomLevel === "beat") {
-    stepTicks = tpBeat;
-  } else if (zoomLevel === "eighth") {
-    stepTicks = tpEighth;
-  } else {
-    stepTicks = tpSixteenth;
+    coarseQuarterNoteStep = coarseQuarterNotes;
   }
   const startTick = startPixel * ticksPerPixel;
   const endTick = endPixel * ticksPerPixel;
-  const firstStep = Math.floor(startTick / stepTicks) * stepTicks;
-  const ticks = [];
-  for (let tick = firstStep; tick <= endTick; tick += stepTicks) {
-    const pixel = tick / ticksPerPixel;
-    if (pixel < startPixel || pixel > endPixel) {
-      continue;
+  const segments = [];
+  {
+    let cumulativeBars = 0;
+    for (let i = 0; i < meterEntries.length; i++) {
+      const meter = meterEntries[i];
+      const segmentStart = meter.tick;
+      const segmentEnd = i + 1 < meterEntries.length ? meterEntries[i + 1].tick : Number.MAX_SAFE_INTEGER;
+      const ts = [meter.numerator, meter.denominator];
+      const tpBar = ticksPerBar(ts, ppqn);
+      segments.push({
+        segmentStartTick: segmentStart,
+        segmentEndTick: segmentEnd,
+        meter,
+        barOffset: cumulativeBars
+      });
+      if (segmentEnd !== Number.MAX_SAFE_INTEGER) {
+        const segmentLen = segmentEnd - segmentStart;
+        cumulativeBars += Math.floor(segmentLen / tpBar);
+      }
     }
-    let type;
-    if (tick % tpBar === 0) {
-      type = "major";
-    } else if (tick % tpBeat === 0) {
-      type = "minor";
+  }
+  const ticks = [];
+  for (const { segmentStartTick, segmentEndTick, meter, barOffset } of segments) {
+    const ts = [meter.numerator, meter.denominator];
+    const tpBeat = ticksPerBeat(ts, ppqn);
+    const tpBar = ticksPerBar(ts, ppqn);
+    let stepTicks;
+    if (zoomLevel === "coarse") {
+      stepTicks = coarseQuarterNotes * ppqn;
+    } else if (zoomLevel === "bar") {
+      stepTicks = tpBar;
+    } else if (zoomLevel === "beat") {
+      stepTicks = tpBeat;
+    } else if (zoomLevel === "eighth") {
+      stepTicks = tpEighth;
     } else {
-      type = "minorMinor";
+      stepTicks = tpSixteenth;
+    }
+    const segmentTickStart = Math.max(segmentStartTick, startTick);
+    const segmentTickEnd = Math.min(segmentEndTick - 1, endTick);
+    if (segmentTickStart > segmentTickEnd) {
+      continue;
     }
-    const barIndex = Math.floor(tick / tpBar);
-    let label;
-    if (type === "major") {
-      label = ticksToBarBeatLabel(tick, timeSignature, ppqn);
-    } else if (type === "minor" && pixelsPerBeat >= MIN_PIXELS_PER_LABEL) {
-      label = ticksToBarBeatLabel(tick, timeSignature, ppqn);
+    const offsetIntoSegment = segmentTickStart - segmentStartTick;
+    const firstStepOffset = Math.floor(offsetIntoSegment / stepTicks) * stepTicks;
+    const firstStepTick = segmentStartTick + firstStepOffset;
+    for (let tick = firstStepTick; tick <= segmentTickEnd && tick < segmentEndTick; tick += stepTicks) {
+      const pixel = tick / ticksPerPixel;
+      if (pixel < startPixel || pixel > endPixel) {
+        continue;
+      }
+      const tickOffsetInSegment = tick - segmentStartTick;
+      let type;
+      if (tickOffsetInSegment % tpBar === 0) {
+        type = "major";
+      } else if (tickOffsetInSegment % tpBeat === 0) {
+        type = "minor";
+      } else {
+        type = "minorMinor";
+      }
+      const barIndexInSegment = Math.floor(tickOffsetInSegment / tpBar);
+      const barIndex = barOffset + barIndexInSegment;
+      let label;
+      if (type === "major") {
+        label = `${barIndex + 1}`;
+      } else if (type === "minor" && tpBeat / ticksPerPixel >= MIN_PIXELS_PER_LABEL) {
+        const beatInBar = Math.floor(tickOffsetInSegment % tpBar / tpBeat) + 1;
+        label = `${barIndex + 1}.${beatInBar}`;
+      }
+      ticks.push({ pixel, type, barIndex, ...label !== void 0 ? { label } : {} });
     }
-    ticks.push({ pixel, type, barIndex, ...label !== void 0 ? { label } : {} });
   }
+  ticks.sort((a, b) => a.pixel - b.pixel);
   const result = {
     ticks,
-    pixelsPerBar,
-    pixelsPerBeat,
+    pixelsPerQuarterNote,
     zoomLevel,
-    ...coarseBarStep !== void 0 ? { coarseBarStep } : {}
+    ...coarseQuarterNoteStep !== void 0 ? { coarseQuarterNoteStep } : {}
   };
   return result;
 }
-function snapTickToGrid(tick, snapTo, timeSignature, ppqn = 960) {
+function snapTickToGrid(tick, snapTo, meterEntries, ppqn = 960) {
   if (snapTo === "off") return tick;
-  const gridSize = snapToTicks(snapTo, timeSignature, ppqn);
+  let meter = meterEntries[0] ?? { tick: 0, numerator: 4, denominator: 4 };
+  for (const entry of meterEntries) {
+    if (entry.tick <= tick) {
+      meter = entry;
+    } else {
+      break;
+    }
+  }
+  const ts = [meter.numerator, meter.denominator];
+  const gridSize = snapToTicks(snapTo, ts, ppqn);
   if (gridSize <= 0) return tick;
-  return Math.round(tick / gridSize) * gridSize;
+  const offset = tick - meter.tick;
+  return meter.tick + Math.round(offset / gridSize) * gridSize;
+}
+
+// src/utils/meterDetection.ts
+function detectMeterChanges(beats, firstBeatTick, ppqn) {
+  const DEFAULT_NUMERATOR = 4;
+  const DENOMINATOR = 4;
+  const defaultResult = [
+    { tick: 0, numerator: DEFAULT_NUMERATOR, denominator: DENOMINATOR }
+  ];
+  if (beats.length === 0) {
+    return defaultResult;
+  }
+  const firstDownbeatIndex = beats.findIndex((b) => b.beat === 1);
+  if (firstDownbeatIndex === -1) {
+    return defaultResult;
+  }
+  const bars = [];
+  let barStartBeatIndex = firstDownbeatIndex;
+  for (let i = firstDownbeatIndex + 1; i < beats.length; i++) {
+    if (beats[i].beat === 1) {
+      bars.push({ beatIndex: barStartBeatIndex, count: i - barStartBeatIndex });
+      barStartBeatIndex = i;
+    }
+  }
+  if (bars.length === 0) {
+    return defaultResult;
+  }
+  const rawEntries = [];
+  let prevNumerator = -1;
+  for (const bar of bars) {
+    const numerator = bar.count;
+    if (numerator !== prevNumerator) {
+      const tick = firstBeatTick + bar.beatIndex * ppqn;
+      rawEntries.push({ tick, numerator, denominator: DENOMINATOR });
+      prevNumerator = numerator;
+    }
+  }
+  if (rawEntries.length === 0) {
+    return defaultResult;
+  }
+  if (rawEntries[0].tick === 0) {
+    return rawEntries;
+  }
+  const tick0Entry = {
+    tick: 0,
+    numerator: rawEntries[0].numerator,
+    denominator: DENOMINATOR
+  };
+  const rest = rawEntries[0].numerator === tick0Entry.numerator ? rawEntries.slice(1) : rawEntries;
+  return [tick0Entry, ...rest];
+}
+
+// src/utils/peaksGenerator.ts
+function generatePeaks(samples, samplesPerPixel, bits = 16) {
+  const numPeaks = Math.ceil(samples.length / samplesPerPixel);
+  const peakArray = bits === 8 ? new Int8Array(numPeaks * 2) : new Int16Array(numPeaks * 2);
+  const maxValue = 2 ** (bits - 1);
+  for (let i = 0; i < numPeaks; i++) {
+    const start = i * samplesPerPixel;
+    const end = Math.min(start + samplesPerPixel, samples.length);
+    let min = 0;
+    let max = 0;
+    for (let j = start; j < end; j++) {
+      const value = samples[j];
+      if (value < min) min = value;
+      if (value > max) max = value;
+    }
+    peakArray[i * 2] = Math.max(-maxValue, Math.floor(min * maxValue));
+    peakArray[i * 2 + 1] = Math.min(maxValue - 1, Math.floor(max * maxValue));
+  }
+  return peakArray;
+}
+function appendPeaks(existingPeaks, newSamples, samplesPerPixel, totalSamplesProcessed, bits = 16) {
+  const maxValue = 2 ** (bits - 1);
+  const remainder = totalSamplesProcessed % samplesPerPixel;
+  let offset = 0;
+  if (remainder > 0 && existingPeaks.length > 0) {
+    const samplesToComplete = samplesPerPixel - remainder;
+    const endIndex = Math.min(samplesToComplete, newSamples.length);
+    let min = existingPeaks[existingPeaks.length - 2] / maxValue;
+    let max = existingPeaks[existingPeaks.length - 1] / maxValue;
+    for (let i = 0; i < endIndex; i++) {
+      const value = newSamples[i];
+      if (value < min) min = value;
+      if (value > max) max = value;
+    }
+    const updated = new (bits === 8 ? Int8Array : Int16Array)(existingPeaks.length);
+    updated.set(existingPeaks);
+    updated[existingPeaks.length - 2] = Math.max(-maxValue, Math.floor(min * maxValue));
+    updated[existingPeaks.length - 1] = Math.min(maxValue - 1, Math.floor(max * maxValue));
+    offset = endIndex;
+    const newPeaks2 = generatePeaks(newSamples.slice(offset), samplesPerPixel, bits);
+    const result2 = new (bits === 8 ? Int8Array : Int16Array)(updated.length + newPeaks2.length);
+    result2.set(updated);
+    result2.set(newPeaks2, updated.length);
+    return result2;
+  }
+  const newPeaks = generatePeaks(newSamples.slice(offset), samplesPerPixel, bits);
+  const result = new (bits === 8 ? Int8Array : Int16Array)(existingPeaks.length + newPeaks.length);
+  result.set(existingPeaks);
+  result.set(newPeaks, existingPeaks.length);
+  return result;
+}
+
+// src/utils/audioBufferUtils.ts
+function concatenateAudioData(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Float32Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function createAudioBuffer(audioContext, channelData, sampleRate, channelCount = 1) {
+  const channels = channelData instanceof Float32Array ? [channelData] : channelData;
+  const length = channels[0]?.length ?? 0;
+  const buffer = audioContext.createBuffer(channelCount, length, sampleRate);
+  for (let ch = 0; ch < Math.min(channelCount, channels.length); ch++) {
+    buffer.copyToChannel(new Float32Array(channels[ch]), ch);
+  }
+  return buffer;
+}
+function appendToAudioBuffer(audioContext, existingBuffer, newSamples, sampleRate) {
+  if (!existingBuffer) {
+    return createAudioBuffer(audioContext, [newSamples], sampleRate);
+  }
+  const existingData = existingBuffer.getChannelData(0);
+  const combined = concatenateAudioData([existingData, newSamples]);
+  return createAudioBuffer(audioContext, [combined], sampleRate);
+}
+function calculateDuration(sampleCount, sampleRate) {
+  return sampleCount / sampleRate;
 }
 
 // src/clipTimeHelpers.ts
@@ -621,8 +844,11 @@ var getShortcutLabel = (shortcut) => {
   MAX_CANVAS_WIDTH,
   MIN_PIXELS_PER_UNIT,
   PPQN,
+  appendPeaks,
+  appendToAudioBuffer,
   applyFadeIn,
   applyFadeOut,
+  calculateDuration,
   clipDurationTime,
   clipEndTime,
   clipOffsetTime,
@@ -630,16 +856,21 @@ var getShortcutLabel = (shortcut) => {
   clipStartTime,
   clipsOverlap,
   computeMusicalTicks,
+  concatenateAudioData,
+  createAudioBuffer,
   createClip,
   createClipFromSeconds,
+  createClipFromTicks,
   createTimeline,
   createTrack,
   dBToNormalized,
+  detectMeterChanges,
   exponentialCurve,
   findGaps,
   gainToDb,
   gainToNormalized,
   generateCurve,
+  generatePeaks,
   getClipsAtSample,
   getClipsInRange,
   getShortcutLabel,
@@ -661,7 +892,6 @@ var getShortcutLabel = (shortcut) => {
   sortClipsByTime,
   ticksPerBar,
   ticksPerBeat,
-  ticksToBarBeatLabel,
   ticksToSamples,
   trackChannelCount
 });