@dawcore/transport 0.0.3 → 0.0.4

package/dist/index.mjs

@@ -215,28 +215,43 @@ var SampleTimeline = class {
 };
 
 // src/timeline/tempo-map.ts
+var CURVE_EPSILON = 1e-15;
+var CURVE_SUBDIVISIONS = 64;
+function curveNormalizedAt(x, slope) {
+  if (slope > 0.499999 && slope < 0.500001) return x;
+  const p = Math.max(CURVE_EPSILON, Math.min(1 - CURVE_EPSILON, slope));
+  return p * p / (1 - p * 2) * (Math.pow((1 - p) / p, 2 * x) - 1);
+}
 var TempoMap = class {
   constructor(ppqn = 960, initialBpm = 120) {
     this._ppqn = ppqn;
-    this._entries = [{ tick: 0, bpm: initialBpm, secondsAtTick: 0 }];
+    this._entries = [{ tick: 0, bpm: initialBpm, interpolation: "step", secondsAtTick: 0 }];
   }
   getTempo(atTick = 0) {
-    const entry = this._entryAt(atTick);
-    return entry.bpm;
-  }
-  setTempo(bpm, atTick = 0) {
+    return this._getTempoAt(atTick);
+  }
+  setTempo(bpm, atTick = 0, options) {
+    const interpolation = options?.interpolation ?? "step";
+    if (typeof interpolation === "object" && interpolation.type === "curve") {
+      const s = interpolation.slope;
+      if (!Number.isFinite(s) || s <= 0 || s >= 1) {
+        throw new Error(
+          "[waveform-playlist] TempoMap: curve slope must be between 0 and 1 (exclusive), got " + s
+        );
+      }
+    }
     if (atTick === 0) {
-      this._entries[0] = { ...this._entries[0], bpm };
+      this._entries[0] = { ...this._entries[0], bpm, interpolation: "step" };
       this._recomputeCache(0);
       return;
     }
     let i = this._entries.length - 1;
     while (i > 0 && this._entries[i].tick > atTick) i--;
     if (this._entries[i].tick === atTick) {
-      this._entries[i] = { ...this._entries[i], bpm };
+      this._entries[i] = { ...this._entries[i], bpm, interpolation };
     } else {
       const secondsAtTick = this._ticksToSecondsInternal(atTick);
-      this._entries.splice(i + 1, 0, { tick: atTick, bpm, secondsAtTick });
+      this._entries.splice(i + 1, 0, { tick: atTick, bpm, interpolation, secondsAtTick });
       i = i + 1;
     }
     this._recomputeCache(i);
@@ -257,6 +272,28 @@ var TempoMap = class {
     }
     const entry = this._entries[lo];
     const secondsIntoSegment = seconds - entry.secondsAtTick;
+    const nextEntry = lo < this._entries.length - 1 ? this._entries[lo + 1] : null;
+    if (nextEntry && nextEntry.interpolation === "linear") {
+      return Math.round(
+        entry.tick + this._secondsToTicksLinear(
+          secondsIntoSegment,
+          entry.bpm,
+          nextEntry.bpm,
+          nextEntry.tick - entry.tick
+        )
+      );
+    }
+    if (nextEntry && typeof nextEntry.interpolation === "object") {
+      return Math.round(
+        entry.tick + this._secondsToTicksCurve(
+          secondsIntoSegment,
+          entry.bpm,
+          nextEntry.bpm,
+          nextEntry.tick - entry.tick,
+          nextEntry.interpolation.slope
+        )
+      );
+    }
     const ticksPerSecond = entry.bpm / 60 * this._ppqn;
     return Math.round(entry.tick + secondsIntoSegment * ticksPerSecond);
   }
@@ -268,15 +305,122 @@ var TempoMap = class {
   }
   clearTempos() {
     const first = this._entries[0];
-    this._entries = [{ tick: 0, bpm: first.bpm, secondsAtTick: 0 }];
+    this._entries = [{ tick: 0, bpm: first.bpm, interpolation: "step", secondsAtTick: 0 }];
+  }
+  /** Get the interpolated BPM at a tick position */
+  _getTempoAt(atTick) {
+    const entryIndex = this._entryIndexAt(atTick);
+    const entry = this._entries[entryIndex];
+    const nextEntry = entryIndex < this._entries.length - 1 ? this._entries[entryIndex + 1] : null;
+    if (nextEntry && nextEntry.interpolation !== "step") {
+      const segmentTicks = nextEntry.tick - entry.tick;
+      const ticksInto = atTick - entry.tick;
+      if (segmentTicks > 0) {
+        const progress = ticksInto / segmentTicks;
+        if (nextEntry.interpolation === "linear") {
+          return entry.bpm + (nextEntry.bpm - entry.bpm) * progress;
+        }
+        const t = curveNormalizedAt(progress, nextEntry.interpolation.slope);
+        return entry.bpm + (nextEntry.bpm - entry.bpm) * t;
+      }
+    }
+    return entry.bpm;
   }
   _ticksToSecondsInternal(ticks) {
-    const entry = this._entryAt(ticks);
+    const entryIndex = this._entryIndexAt(ticks);
+    const entry = this._entries[entryIndex];
     const ticksIntoSegment = ticks - entry.tick;
+    const nextEntry = entryIndex < this._entries.length - 1 ? this._entries[entryIndex + 1] : null;
+    if (nextEntry && nextEntry.interpolation === "linear") {
+      const segmentTicks = nextEntry.tick - entry.tick;
+      return entry.secondsAtTick + this._ticksToSecondsLinear(ticksIntoSegment, entry.bpm, nextEntry.bpm, segmentTicks);
+    }
+    if (nextEntry && typeof nextEntry.interpolation === "object") {
+      const segmentTicks = nextEntry.tick - entry.tick;
+      return entry.secondsAtTick + this._ticksToSecondsCurve(
+        ticksIntoSegment,
+        entry.bpm,
+        nextEntry.bpm,
+        segmentTicks,
+        nextEntry.interpolation.slope
+      );
+    }
     const secondsPerTick = 60 / (entry.bpm * this._ppqn);
     return entry.secondsAtTick + ticksIntoSegment * secondsPerTick;
   }
-  _entryAt(tick) {
+  /**
+   * Exact integration for a linear BPM ramp using the logarithmic formula.
+   * For bpm(t) = bpm0 + r*t where r = (bpm1-bpm0)/T:
+   *   seconds = (T * 60) / (ppqn * (bpm1-bpm0)) * ln(bpmAtTick / bpm0)
+   */
+  _ticksToSecondsLinear(ticks, bpm0, bpm1, totalSegmentTicks) {
+    if (totalSegmentTicks === 0) return 0;
+    const bpmAtTick = bpm0 + (bpm1 - bpm0) * (ticks / totalSegmentTicks);
+    if (Math.abs(bpm1 - bpm0) < 1e-10) {
+      return ticks * 60 / (bpm0 * this._ppqn);
+    }
+    const deltaBpm = bpm1 - bpm0;
+    return totalSegmentTicks * 60 / (this._ppqn * deltaBpm) * Math.log(bpmAtTick / bpm0);
+  }
+  /**
+   * Inverse of _ticksToSecondsLinear: given seconds, return ticks.
+   * Closed-form via exponential: bpmAtTick = bpm0 * exp(seconds * deltaBpm * ppqn / (60 * T))
+   * then ticks = (bpmAtTick - bpm0) * T / deltaBpm
+   *
+   * Note: exp(log(x)) has ~1 ULP floating-point error, so round-trips depend on
+   * Math.round() in the caller (secondsToTicks). This is sufficient for all tested
+   * BPM ranges (10–300 BPM) but is not algebraically exact like the previous
+   * trapezoidal/quadratic approach was.
+   */
+  _secondsToTicksLinear(seconds, bpm0, bpm1, totalSegmentTicks) {
+    if (totalSegmentTicks === 0 || seconds === 0) return 0;
+    if (Math.abs(bpm1 - bpm0) < 1e-10) {
+      return seconds * bpm0 * this._ppqn / 60;
+    }
+    const deltaBpm = bpm1 - bpm0;
+    const bpmAtTick = bpm0 * Math.exp(seconds * deltaBpm * this._ppqn / (60 * totalSegmentTicks));
+    return (bpmAtTick - bpm0) / deltaBpm * totalSegmentTicks;
+  }
+  /**
+   * Subdivided trapezoidal integration for a Möbius-Ease tempo curve.
+   * The BPM at progress p is: bpm0 + curveNormalizedAt(p, slope) * (bpm1 - bpm0).
+   * We subdivide into CURVE_SUBDIVISIONS intervals and apply trapezoidal rule.
+   */
+  _ticksToSecondsCurve(ticks, bpm0, bpm1, totalSegmentTicks, slope) {
+    if (totalSegmentTicks === 0 || ticks === 0) return 0;
+    const n = CURVE_SUBDIVISIONS;
+    const dt = ticks / n;
+    let seconds = 0;
+    let prevBpm = bpm0;
+    for (let i = 1; i <= n; i++) {
+      const progress = dt * i / totalSegmentTicks;
+      const curBpm = bpm0 + curveNormalizedAt(progress, slope) * (bpm1 - bpm0);
+      seconds += dt * 60 / this._ppqn * (1 / prevBpm + 1 / curBpm) / 2;
+      prevBpm = curBpm;
+    }
+    return seconds;
+  }
+  /**
+   * Inverse of _ticksToSecondsCurve: given seconds into a curved segment,
+   * return ticks. Uses binary search since there's no closed-form inverse.
+   */
+  _secondsToTicksCurve(seconds, bpm0, bpm1, totalSegmentTicks, slope) {
+    if (totalSegmentTicks === 0 || seconds === 0) return 0;
+    const iterations = Math.min(40, Math.max(1, Math.ceil(Math.log2(2 * totalSegmentTicks))));
+    let lo = 0;
+    let hi = totalSegmentTicks;
+    for (let i = 0; i < iterations; i++) {
+      const mid = (lo + hi) / 2;
+      const midSeconds = this._ticksToSecondsCurve(mid, bpm0, bpm1, totalSegmentTicks, slope);
+      if (midSeconds < seconds) {
+        lo = mid;
+      } else {
+        hi = mid;
+      }
+    }
+    return (lo + hi) / 2;
+  }
+  _entryIndexAt(tick) {
     let lo = 0;
     let hi = this._entries.length - 1;
     while (lo < hi) {
@@ -287,16 +431,31 @@ var TempoMap = class {
         hi = mid - 1;
       }
     }
-    return this._entries[lo];
+    return lo;
   }
   _recomputeCache(fromIndex) {
     for (let i = Math.max(1, fromIndex); i < this._entries.length; i++) {
       const prev = this._entries[i - 1];
       const tickDelta = this._entries[i].tick - prev.tick;
-      const secondsPerTick = 60 / (prev.bpm * this._ppqn);
+      const entry = this._entries[i];
+      let segmentSeconds;
+      if (entry.interpolation === "linear") {
+        segmentSeconds = this._ticksToSecondsLinear(tickDelta, prev.bpm, entry.bpm, tickDelta);
+      } else if (typeof entry.interpolation === "object") {
+        segmentSeconds = this._ticksToSecondsCurve(
+          tickDelta,
+          prev.bpm,
+          entry.bpm,
+          tickDelta,
+          entry.interpolation.slope
+        );
+      } else {
+        const secondsPerTick = 60 / (prev.bpm * this._ppqn);
+        segmentSeconds = tickDelta * secondsPerTick;
+      }
       this._entries[i] = {
-        ...this._entries[i],
-        secondsAtTick: prev.secondsAtTick + tickDelta * secondsPerTick
+        ...entry,
+        secondsAtTick: prev.secondsAtTick + segmentSeconds
       };
     }
   }
@@ -863,6 +1022,7 @@ var Transport = class _Transport {
     this._mutedTrackIds = /* @__PURE__ */ new Set();
     this._playing = false;
     this._loopEnabled = false;
+    this._loopStartTick = 0;
     this._loopStartSeconds = 0;
     this._listeners = /* @__PURE__ */ new Map();
     this._audioContext = audioContext;
@@ -1080,6 +1240,7 @@ var Transport = class _Transport {
       return;
     }
     this._loopEnabled = enabled;
+    this._loopStartTick = startTick;
     this._loopStartSeconds = this._tempoMap.ticksToSeconds(startTick);
     this._scheduler.setLoop(enabled, startTick, endTick);
     this._clipPlayer.setLoop(enabled, startTick, endTick);
@@ -1108,14 +1269,18 @@ var Transport = class _Transport {
     const startTick = this._sampleTimeline.samplesToTicks(startSample);
     const endTick = this._sampleTimeline.samplesToTicks(endSample);
     this._loopEnabled = enabled;
+    this._loopStartTick = startTick;
     this._loopStartSeconds = this._tempoMap.ticksToSeconds(startTick);
     this._clipPlayer.setLoopSamples(enabled, startSample, endSample);
     this._scheduler.setLoop(enabled, startTick, endTick);
     this._emit("loop");
   }
   // --- Tempo ---
-  setTempo(bpm, atTick) {
-    this._tempoMap.setTempo(bpm, atTick);
+  setTempo(bpm, atTick, options) {
+    this._tempoMap.setTempo(bpm, atTick, options);
+    if (this._loopEnabled) {
+      this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
+    }
     this._emit("tempochange");
   }
   getTempo(atTick) {
@@ -1139,6 +1304,9 @@ var Transport = class _Transport {
   }
   clearTempos() {
     this._tempoMap.clearTempos();
+    if (this._loopEnabled) {
+      this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
+    }
     this._emit("tempochange");
   }
   barToTick(bar) {