@waveform-playlist/core 11.3.0 → 12.0.0

package/dist/index.mjs

@@ -2,10 +2,50 @@
 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,
@@ -39,6 +79,7 @@ function createClip(options) {
     id: generateId(),
     audioBuffer,
     startSample,
+    startTick,
     durationSamples,
     offsetSamples,
     sampleRate,
@@ -85,6 +126,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,
@@ -234,14 +276,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;
@@ -266,12 +300,313 @@ function normalizedToDb(normalized, floor = DEFAULT_FLOOR) {
   const clamped = Math.max(0, normalized);
   return clamped * -floor + floor;
 }
+function gainToDb(gain) {
+  return 20 * Math.log10(Math.max(gain, 1e-4));
+}
 function gainToNormalized(gain, floor = DEFAULT_FLOOR) {
   if (gain <= 0) return 0;
   const db = 20 * Math.log10(gain);
   return dBToNormalized(db, floor);
 }
 
+// src/utils/musicalTicks.ts
+function snapToTicks(snapTo, timeSignature, ppqn = 960) {
+  const ts = timeSignature;
+  switch (snapTo) {
+    case "bar":
+      return ticksPerBar(ts, ppqn);
+    case "beat":
+      return ticksPerBeat(ts, ppqn);
+    case "1/2":
+      return ppqn * 2;
+    case "1/4":
+      return ppqn;
+    case "1/8":
+      return ppqn / 2;
+    case "1/16":
+      return ppqn / 4;
+    case "1/32":
+      return ppqn / 8;
+    case "1/2T":
+      return Math.round(ppqn * 2 * 2 / 3);
+    case "1/4T":
+      return Math.round(ppqn * 2 / 3);
+    case "1/8T":
+      return Math.round(ppqn * 2 / 6);
+    case "1/16T":
+      return Math.round(ppqn * 2 / 12);
+    case "off":
+      return 0;
+  }
+}
+var MIN_PIXELS_PER_UNIT = 8;
+var MIN_PIXELS_PER_LABEL = 60;
+function computeMusicalTicks(params) {
+  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 pixelsPerQuarterNote = ppqn / ticksPerPixel;
+  const tpEighth = ppqn / 2;
+  const tpSixteenth = ppqn / 4;
+  const pixelsPerEighth = tpEighth / ticksPerPixel;
+  const pixelsPerSixteenth = tpSixteenth / ticksPerPixel;
+  let zoomLevel;
+  if (pixelsPerQuarterNote * 4 < MIN_PIXELS_PER_UNIT) {
+    zoomLevel = "coarse";
+  } else if (pixelsPerQuarterNote < MIN_PIXELS_PER_UNIT) {
+    zoomLevel = "bar";
+  } else if (pixelsPerEighth < MIN_PIXELS_PER_UNIT) {
+    zoomLevel = "beat";
+  } else if (pixelsPerSixteenth < MIN_PIXELS_PER_UNIT) {
+    zoomLevel = "eighth";
+  } else {
+    zoomLevel = "sixteenth";
+  }
+  let coarseQuarterNoteStep;
+  let coarseQuarterNotes = 0;
+  if (zoomLevel === "coarse") {
+    coarseQuarterNotes = 2;
+    while (coarseQuarterNotes * ppqn / ticksPerPixel < MIN_PIXELS_PER_UNIT) {
+      coarseQuarterNotes *= 2;
+    }
+    coarseQuarterNoteStep = coarseQuarterNotes;
+  }
+  const startTick = startPixel * ticksPerPixel;
+  const endTick = endPixel * ticksPerPixel;
+  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);
+      }
+    }
+  }
+  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 {
+      stepTicks = tpSixteenth;
+    }
+    const segmentTickStart = Math.max(segmentStartTick, startTick);
+    const segmentTickEnd = Math.min(segmentEndTick - 1, endTick);
+    if (segmentTickStart > segmentTickEnd) {
+      continue;
+    }
+    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.sort((a, b) => a.pixel - b.pixel);
+  const result = {
+    ticks,
+    pixelsPerQuarterNote,
+    zoomLevel,
+    ...coarseQuarterNoteStep !== void 0 ? { coarseQuarterNoteStep } : {}
+  };
+  return result;
+}
+function snapTickToGrid(tick, snapTo, meterEntries, ppqn = 960) {
+  if (snapTo === "off") return tick;
+  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;
+  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
 function clipStartTime(clip) {
   return clip.startSample / clip.sampleRate;
@@ -285,6 +620,12 @@ function clipOffsetTime(clip) {
 function clipDurationTime(clip) {
   return clip.durationSamples / clip.sampleRate;
 }
+function trackChannelCount(track) {
+  return track.clips.reduce(
+    (max, clip) => Math.max(max, clip.audioBuffer?.numberOfChannels ?? 1),
+    1
+  );
+}
 function clipPixelWidth(startSample, durationSamples, samplesPerPixel) {
   return Math.floor((startSample + durationSamples) / samplesPerPixel) - Math.floor(startSample / samplesPerPixel);
 }
@@ -421,24 +762,35 @@ var getShortcutLabel = (shortcut) => {
 export {
   InteractionState,
   MAX_CANVAS_WIDTH,
+  MIN_PIXELS_PER_UNIT,
   PPQN,
+  appendPeaks,
+  appendToAudioBuffer,
   applyFadeIn,
   applyFadeOut,
+  calculateDuration,
   clipDurationTime,
   clipEndTime,
   clipOffsetTime,
   clipPixelWidth,
   clipStartTime,
   clipsOverlap,
+  computeMusicalTicks,
+  concatenateAudioData,
+  createAudioBuffer,
   createClip,
   createClipFromSeconds,
+  createClipFromTicks,
   createTimeline,
   createTrack,
   dBToNormalized,
+  detectMeterChanges,
   exponentialCurve,
   findGaps,
+  gainToDb,
   gainToNormalized,
   generateCurve,
+  generatePeaks,
   getClipsAtSample,
   getClipsInRange,
   getShortcutLabel,
@@ -454,11 +806,13 @@ export {
   samplesToTicks,
   secondsToPixels,
   secondsToSamples,
+  snapTickToGrid,
   snapToGrid,
+  snapToTicks,
   sortClipsByTime,
   ticksPerBar,
   ticksPerBeat,
-  ticksToBarBeatLabel,
-  ticksToSamples
+  ticksToSamples,
+  trackChannelCount
 };
 //# sourceMappingURL=index.mjs.map