@dawcore/transport 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -173,7 +173,9 @@ var Timer = class {
       } catch (err) {
         console.warn("[waveform-playlist] Timer tick error:", String(err));
       }
-      this._scheduleFrame();
+      if (this._running) {
+        this._scheduleFrame();
+      }
     });
   }
 };
@@ -850,7 +852,7 @@ var ClipPlayer = class {
         if (!clip.audioBuffer) continue;
         const clipStartSample = clip.startSample;
         const clipEndSample = clipStartSample + clip.durationSamples;
-        if (clipStartSample <= newSample && clipEndSample > newSample) {
+        if (clipStartSample < newSample && clipEndSample > newSample) {
           const offsetIntoClipSamples = newSample - clipStartSample;
           const offsetSamples = clip.offsetSamples + offsetIntoClipSamples;
           let durationSamples = clipEndSample - newSample;
@@ -1013,8 +1015,145 @@ var MetronomePlayer = class {
   }
 };
 
+// src/audio/count-in-player.ts
+var CountInPlayer = class {
+  constructor(audioContext, tempoMap, destination, toAudioTime) {
+    this._activeSources = /* @__PURE__ */ new Set();
+    this._totalBeats = 0;
+    this._beatsGenerated = 0;
+    this._accentBuffer = null;
+    this._normalBuffer = null;
+    this._meterMap = null;
+    this._onBeat = null;
+    this._audioContext = audioContext;
+    this._tempoMap = tempoMap;
+    this._destination = destination;
+    this._toAudioTime = toAudioTime;
+  }
+  configure(config) {
+    this._totalBeats = config.totalBeats;
+    this._beatsGenerated = 0;
+    this._accentBuffer = config.accentBuffer;
+    this._normalBuffer = config.normalBuffer;
+    this._meterMap = config.meterMap;
+    this._tempoMap = config.tempoMap;
+    this._onBeat = config.onBeat;
+  }
+  generate(fromTick, toTick) {
+    if (!this._accentBuffer || !this._normalBuffer || !this._meterMap) {
+      return [];
+    }
+    const events = [];
+    const meterMap = this._meterMap;
+    let entry = meterMap.getEntryAt(fromTick);
+    let beatSize = meterMap.ticksPerBeat(fromTick);
+    const tickIntoSection = fromTick - entry.tick;
+    let tick = entry.tick + Math.ceil(tickIntoSection / beatSize) * beatSize;
+    while (tick < toTick && this._beatsGenerated < this._totalBeats) {
+      const tickPos = tick;
+      const currentEntry = meterMap.getEntryAt(tickPos);
+      if (currentEntry.tick !== entry.tick) {
+        entry = currentEntry;
+        beatSize = meterMap.ticksPerBeat(tickPos);
+      }
+      this._beatsGenerated++;
+      const isAccent = meterMap.isBarBoundary(tickPos);
+      events.push({
+        tick: tickPos,
+        isAccent,
+        buffer: isAccent ? this._accentBuffer : this._normalBuffer,
+        beat: this._beatsGenerated,
+        totalBeats: this._totalBeats
+      });
+      beatSize = meterMap.ticksPerBeat(tickPos);
+      tick += beatSize;
+    }
+    return events;
+  }
+  consume(event) {
+    try {
+      const source = this._audioContext.createBufferSource();
+      source.buffer = event.buffer;
+      source.connect(this._destination);
+      this._activeSources.add(source);
+      source.addEventListener("ended", () => {
+        this._activeSources.delete(source);
+        try {
+          source.disconnect();
+        } catch (err) {
+          console.warn(
+            "[waveform-playlist] CountInPlayer: error disconnecting source:",
+            String(err)
+          );
+        }
+      });
+      const transportTime = this._tempoMap.ticksToSeconds(event.tick);
+      source.start(this._toAudioTime(transportTime));
+    } catch (err) {
+      console.warn(
+        "[waveform-playlist] CountInPlayer.consume: failed to schedule beat " + event.beat + "/" + event.totalBeats + ": " + String(err)
+      );
+    }
+    this._onBeat?.(event.beat, event.totalBeats);
+  }
+  onPositionJump(_newTick) {
+  }
+  silence() {
+    for (const source of this._activeSources) {
+      try {
+        source.stop();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] CountInPlayer.silence: error stopping source:",
+          String(err)
+        );
+      }
+      try {
+        source.disconnect();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] CountInPlayer.silence: error disconnecting:",
+          String(err)
+        );
+      }
+    }
+    this._activeSources.clear();
+  }
+};
+
+// src/audio/click-sounds.ts
+var DEFAULT_ACCENT_FREQUENCY = 1e3;
+var DEFAULT_NORMAL_FREQUENCY = 800;
+var ACCENT_DURATION = 0.04;
+var NORMAL_DURATION = 0.03;
+function synthesizeClick(audioContext, frequency, duration) {
+  const sampleRate = audioContext.sampleRate;
+  const length = Math.ceil(sampleRate * duration);
+  const buffer = audioContext.createBuffer(1, length, sampleRate);
+  const data = buffer.getChannelData(0);
+  for (let i = 0; i < length; i++) {
+    const t = i / sampleRate;
+    const envelope = Math.exp(-t * 50);
+    data[i] = Math.sin(2 * Math.PI * frequency * t) * envelope;
+  }
+  return buffer;
+}
+function createDefaultClickSounds(audioContext, options) {
+  const accentFreq = options?.accentFrequency ?? DEFAULT_ACCENT_FREQUENCY;
+  const normalFreq = options?.normalFrequency ?? DEFAULT_NORMAL_FREQUENCY;
+  if (accentFreq <= 0 || normalFreq <= 0) {
+    console.warn(
+      "[waveform-playlist] createDefaultClickSounds: frequency must be positive, got accent=" + accentFreq + " normal=" + normalFreq
+    );
+  }
+  return {
+    accent: synthesizeClick(audioContext, accentFreq, ACCENT_DURATION),
+    normal: synthesizeClick(audioContext, normalFreq, NORMAL_DURATION)
+  };
+}
+
 // src/transport.ts
-var Transport = class _Transport {
+var _Transport = class _Transport {
   constructor(audioContext, options = {}) {
     this._trackNodes = /* @__PURE__ */ new Map();
     this._tracks = [];
@@ -1024,7 +1163,22 @@ var Transport = class _Transport {
     this._loopEnabled = false;
     this._loopStartTick = 0;
     this._loopStartSeconds = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this._listeners = /* @__PURE__ */ new Map();
+    // --- Count-In state ---
+    this._countInEnabled = false;
+    this._countInBars = 1;
+    this._countInMode = "recording-only";
+    this._recording = false;
+    this._countingIn = false;
+    this._countInStartPosition = 0;
+    this._countInDuration = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this._countInScheduler = null;
+    this._accentBuffer = null;
+    this._normalBuffer = null;
+    this._schedulerLookahead = 0.2;
+    this._ppqn = 960;
     this._audioContext = audioContext;
     const sampleRate = options.sampleRate ?? audioContext.sampleRate;
     const ppqn = options.ppqn ?? 960;
@@ -1032,6 +1186,8 @@ var Transport = class _Transport {
     const numerator = options.numerator ?? 4;
     const denominator = options.denominator ?? 4;
     const lookahead = options.schedulerLookahead ?? 0.2;
+    this._ppqn = ppqn;
+    this._schedulerLookahead = lookahead;
     _Transport._validateOptions(sampleRate, ppqn, tempo, numerator, denominator, lookahead);
     this._clock = new Clock(audioContext);
     this._sampleTimeline = new SampleTimeline(sampleRate);
@@ -1046,8 +1202,16 @@ var Transport = class _Transport {
     });
     this._sampleTimeline.setTempoMap(this._tempoMap);
     this._initAudioGraph(audioContext);
+    this._initCountIn(audioContext, options);
     this._timer = new Timer(() => {
       const time = this._clock.getTime();
+      if (this._countingIn) {
+        this._countInScheduler?.advance(time);
+        if (time >= this._countInDuration) {
+          this._finishCountIn();
+        }
+        return;
+      }
       if (this._endTime !== void 0 && time >= this._endTime) {
         this.stop();
         return;
@@ -1064,6 +1228,10 @@ var Transport = class _Transport {
     if (startTime !== void 0) {
       this._clock.seekTo(startTime);
     }
+    if (this._shouldCountIn()) {
+      this._startCountIn(endTime);
+      return;
+    }
     const currentTime = this._clock.getTime();
     this._scheduler.reset(currentTime);
     this._endTime = endTime;
@@ -1076,6 +1244,13 @@ var Transport = class _Transport {
   }
   pause() {
     if (!this._playing) return;
+    if (this._countingIn) {
+      this._cancelCountIn();
+      this._clock.stop();
+      this._playing = false;
+      this._emit("pause");
+      return;
+    }
     this._timer.stop();
     this._clock.stop();
     this._silenceAll();
@@ -1084,6 +1259,9 @@ var Transport = class _Transport {
   }
   stop() {
     const wasPlaying = this._playing;
+    if (this._countingIn) {
+      this._cancelCountIn();
+    }
     this._timer.stop();
     this._clock.reset();
     this._scheduler.reset(0);
@@ -1096,14 +1274,19 @@ var Transport = class _Transport {
   }
   seek(time) {
     const wasPlaying = this._playing;
-    if (wasPlaying) {
+    const wasCountingIn = this._countingIn;
+    if (wasCountingIn) {
+      this._cancelCountIn();
+      this._playing = false;
+    }
+    if (wasPlaying && !wasCountingIn) {
       this._timer.stop();
     }
     this._silenceAll();
     this._clock.seekTo(time);
     this._scheduler.reset(time);
     this._endTime = void 0;
-    if (wasPlaying) {
+    if (wasPlaying && !wasCountingIn) {
       this._clock.start();
       const seekTick = this._tempoMap.secondsToTicks(time);
       this._clipPlayer.onPositionJump(seekTick);
@@ -1111,6 +1294,9 @@ var Transport = class _Transport {
     }
   }
   getCurrentTime() {
+    if (this._countingIn) {
+      return this._countInStartPosition;
+    }
     const t = this._clock.getTime();
     if (this._loopEnabled && t < this._loopStartSeconds) {
       return this._loopStartSeconds;
@@ -1281,7 +1467,7 @@ var Transport = class _Transport {
     if (this._loopEnabled) {
       this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
     }
-    this._emit("tempochange");
+    this._emit("tempochange", { bpm, atTick: atTick ?? 0 });
   }
   getTempo(atTick) {
     return this._tempoMap.getTempo(atTick);
@@ -1289,25 +1475,35 @@ var Transport = class _Transport {
   // --- Meter ---
   setMeter(numerator, denominator, atTick) {
     this._meterMap.setMeter(numerator, denominator, atTick);
-    this._emit("meterchange");
+    this._emit("meterchange", { numerator, denominator, atTick: atTick ?? 0 });
   }
   getMeter(atTick) {
     return this._meterMap.getMeter(atTick);
   }
   removeMeter(atTick) {
     this._meterMap.removeMeter(atTick);
-    this._emit("meterchange");
+    const meter = this._meterMap.getMeter(atTick);
+    this._emit("meterchange", {
+      numerator: meter.numerator,
+      denominator: meter.denominator,
+      atTick
+    });
   }
   clearMeters() {
     this._meterMap.clearMeters();
-    this._emit("meterchange");
+    const meter = this._meterMap.getMeter();
+    this._emit("meterchange", {
+      numerator: meter.numerator,
+      denominator: meter.denominator,
+      atTick: 0
+    });
   }
   clearTempos() {
     this._tempoMap.clearTempos();
     if (this._loopEnabled) {
       this._loopStartSeconds = this._tempoMap.ticksToSeconds(this._loopStartTick);
     }
-    this._emit("tempochange");
+    this._emit("tempochange", { bpm: this._tempoMap.getTempo(), atTick: 0 });
   }
   barToTick(bar) {
     return this._meterMap.barToTick(bar);
@@ -1328,8 +1524,40 @@ var Transport = class _Transport {
     this._metronomePlayer.setEnabled(enabled);
   }
   setMetronomeClickSounds(accent, normal) {
+    this._accentBuffer = accent;
+    this._normalBuffer = normal;
     this._metronomePlayer.setClickSounds(accent, normal);
   }
+  setCountIn(enabled) {
+    this._countInEnabled = enabled;
+  }
+  setCountInBars(bars) {
+    const rounded = Math.round(bars);
+    if (rounded < _Transport.MIN_COUNT_IN_BARS) {
+      console.warn(
+        "[waveform-playlist] Transport.setCountInBars: clamping " + bars + " to " + _Transport.MIN_COUNT_IN_BARS
+      );
+      this._countInBars = _Transport.MIN_COUNT_IN_BARS;
+      return;
+    }
+    if (rounded > _Transport.MAX_COUNT_IN_BARS) {
+      console.warn(
+        "[waveform-playlist] Transport.setCountInBars: clamping " + bars + " to " + _Transport.MAX_COUNT_IN_BARS
+      );
+      this._countInBars = _Transport.MAX_COUNT_IN_BARS;
+      return;
+    }
+    this._countInBars = rounded;
+  }
+  setCountInMode(mode) {
+    this._countInMode = mode;
+  }
+  setRecording(recording) {
+    this._recording = recording;
+  }
+  isCountingIn() {
+    return this._countingIn;
+  }
   // --- Effects Hook ---
   connectTrackOutput(trackId, node) {
     const trackNode = this._trackNodes.get(trackId);
@@ -1418,9 +1646,94 @@ var Transport = class _Transport {
     this._scheduler.addListener(this._clipPlayer);
     this._scheduler.addListener(this._metronomePlayer);
   }
+  _initCountIn(audioContext, options) {
+    const toAudioTime = (transportTime) => this._clock.toAudioTime(transportTime);
+    this._countInPlayer = new CountInPlayer(
+      audioContext,
+      this._tempoMap,
+      this._masterNode.input,
+      toAudioTime
+    );
+    try {
+      const { accent, normal } = createDefaultClickSounds(audioContext, {
+        accentFrequency: options.accentFrequency,
+        normalFrequency: options.normalFrequency
+      });
+      this._accentBuffer = accent;
+      this._normalBuffer = normal;
+      this._metronomePlayer.setClickSounds(accent, normal);
+    } catch (err) {
+      console.warn(
+        "[waveform-playlist] Transport: failed to create default click sounds. Metronome and count-in will be silent until setMetronomeClickSounds() is called. Error: " + String(err)
+      );
+    }
+  }
+  _shouldCountIn() {
+    if (!this._countInEnabled) return false;
+    if (!this._accentBuffer || !this._normalBuffer) {
+      console.warn("[waveform-playlist] Transport: count-in skipped \u2014 no click sounds loaded");
+      return false;
+    }
+    if (this._countInMode === "recording-only" && !this._recording) return false;
+    return true;
+  }
+  _startCountIn(endTime) {
+    const currentTime = this._clock.getTime();
+    this._countInStartPosition = currentTime;
+    this._countingIn = true;
+    this._playing = true;
+    this._endTime = endTime;
+    const playPositionTick = this._tempoMap.secondsToTicks(currentTime);
+    const meter = this._meterMap.getMeter(playPositionTick);
+    const totalBeats = meter.numerator * this._countInBars;
+    const bpmAtPosition = this._tempoMap.getTempo(playPositionTick);
+    const ticksPerBeat = this._ppqn * (4 / meter.denominator);
+    const countInTicks = totalBeats * ticksPerBeat;
+    const countInTempoMap = new TempoMap(this._ppqn, bpmAtPosition);
+    const countInMeterMap = new MeterMap(this._ppqn, meter.numerator, meter.denominator);
+    this._countInDuration = countInTempoMap.ticksToSeconds(countInTicks);
+    this._countInScheduler = new Scheduler(countInTempoMap, {
+      lookahead: this._schedulerLookahead
+    });
+    this._countInPlayer.configure({
+      totalBeats,
+      accentBuffer: this._accentBuffer,
+      normalBuffer: this._normalBuffer,
+      meterMap: countInMeterMap,
+      tempoMap: countInTempoMap,
+      onBeat: (beat, total) => {
+        this._emit("countIn", { beat, totalBeats: total });
+      }
+    });
+    this._countInScheduler.addListener(this._countInPlayer);
+    this._countInScheduler.reset(0);
+    this._clock.seekTo(0);
+    this._clock.start();
+    this._timer.start();
+  }
+  _finishCountIn() {
+    this._countInScheduler?.removeListener(this._countInPlayer);
+    this._countInScheduler = null;
+    this._countingIn = false;
+    this._emit("countInEnd");
+    this._clock.seekTo(this._countInStartPosition);
+    const currentTime = this._clock.getTime();
+    this._scheduler.reset(currentTime);
+    const currentTick = this._tempoMap.secondsToTicks(currentTime);
+    this._clipPlayer.onPositionJump(currentTick);
+    this._emit("play");
+  }
+  _cancelCountIn() {
+    this._countInPlayer.silence();
+    this._countInScheduler?.removeListener(this._countInPlayer);
+    this._countInScheduler = null;
+    this._countingIn = false;
+    this._timer.stop();
+  }
   _silenceAll() {
     this._clipPlayer.silence();
     this._metronomePlayer.silence();
+    this._countInPlayer.silence();
   }
   _applyMuteState() {
     const hasSolo = this._soloedTrackIds.size > 0;
@@ -1430,12 +1743,12 @@ var Transport = class _Transport {
       node.setMute(isExplicitlyMuted || isSoloMuted);
     }
   }
-  _emit(event) {
+  _emit(event, ...args) {
     const listeners = this._listeners.get(event);
     if (listeners) {
       for (const cb of listeners) {
         try {
-          cb();
+          cb(...args);
         } catch (err) {
           console.warn(
             '[waveform-playlist] Transport "' + event + '" listener threw:',
@@ -1446,6 +1759,10 @@ var Transport = class _Transport {
     }
   }
 };
+// --- Count-In ---
+_Transport.MIN_COUNT_IN_BARS = 1;
+_Transport.MAX_COUNT_IN_BARS = 8;
+var Transport = _Transport;
 
 // src/adapter.ts
 var NativePlayoutAdapter = class {
@@ -1462,6 +1779,27 @@ var NativePlayoutAdapter = class {
     }
     if (this._audioContext.state === "suspended") {
       await this._audioContext.resume();
+      const MIN_WARMUP = 0.02;
+      const warmupTarget = Math.max(MIN_WARMUP, this._audioContext.outputLatency ?? MIN_WARMUP);
+      if (this._audioContext.currentTime < warmupTarget) {
+        const MAX_WARMUP_MS = 2e3;
+        await new Promise((resolve) => {
+          const startMs = performance.now();
+          const check = () => {
+            if (this._audioContext.currentTime >= warmupTarget) {
+              resolve();
+            } else if (this._audioContext.state === "closed" || performance.now() - startMs > MAX_WARMUP_MS) {
+              console.warn(
+                "[waveform-playlist] AudioContext warmup timed out (currentTime=" + this._audioContext.currentTime + ", target=" + warmupTarget + ", state=" + this._audioContext.state + "). Proceeding without warmup."
+              );
+              resolve();
+            } else {
+              requestAnimationFrame(check);
+            }
+          };
+          requestAnimationFrame(check);
+        });
+      }
     }
   }
   setTracks(tracks) {
@@ -1512,6 +1850,21 @@ var NativePlayoutAdapter = class {
   setLoop(enabled, start, end) {
     this._transport.setLoopSeconds(enabled, start, end);
   }
+  setCountIn(enabled) {
+    this._transport.setCountIn(enabled);
+  }
+  setCountInBars(bars) {
+    this._transport.setCountInBars(bars);
+  }
+  setCountInMode(mode) {
+    this._transport.setCountInMode(mode);
+  }
+  setRecording(recording) {
+    this._transport.setRecording(recording);
+  }
+  isCountingIn() {
+    return this._transport.isCountingIn();
+  }
   dispose() {
     this._transport.dispose();
   }