@blibliki/transport 0.3.4

package/src/audio-context-timers.ts

@@ -0,0 +1,125 @@
+function generateUniqueNumber(map: Map<number, () => void>): number {
+  let nextId = 1;
+
+  // Keep incrementing until we find an unused ID
+  while (map.has(nextId)) {
+    nextId++;
+  }
+
+  return nextId;
+}
+
+class WebAudioWrapper {
+  private _audioBuffer: AudioBuffer | null = null;
+  private _audioContext: AudioContext | null = null;
+  private _sampleDuration: number | null = null;
+
+  get audioContext(): AudioContext {
+    this._audioContext ??= new AudioContext();
+    return this._audioContext;
+  }
+
+  get audioBuffer(): AudioBuffer {
+    this._audioBuffer ??= new AudioBuffer({
+      length: 2,
+      sampleRate: this.audioContext.sampleRate,
+    });
+    return this._audioBuffer;
+  }
+
+  get sampleDuration(): number {
+    this._sampleDuration ??= 2 / this.audioContext.sampleRate;
+    return this._sampleDuration;
+  }
+}
+
+const webAudioWrapper = new WebAudioWrapper();
+
+const SCHEDULED_TIMEOUT_FUNCTIONS = new Map<number, () => void>();
+const SCHEDULED_INTERVAL_FUNCTIONS = new Map<number, () => void>();
+
+enum TimerType {
+  interval = "interval",
+  timeout = "timeout",
+}
+
+const callIntervalFunction = (id: number, type: TimerType) => {
+  const functions =
+    type === TimerType.interval
+      ? SCHEDULED_INTERVAL_FUNCTIONS
+      : SCHEDULED_TIMEOUT_FUNCTIONS;
+
+  if (functions.has(id)) {
+    const func = functions.get(id);
+
+    if (func !== undefined) {
+      func();
+
+      if (type === TimerType.timeout) {
+        SCHEDULED_TIMEOUT_FUNCTIONS.delete(id);
+      }
+    }
+  }
+};
+
+const scheduleFunction = (id: number, delay: number, type: TimerType) => {
+  const now = performance.now();
+
+  const audioBufferSourceNode = new AudioBufferSourceNode(
+    webAudioWrapper.audioContext,
+    { buffer: webAudioWrapper.audioBuffer },
+  );
+
+  audioBufferSourceNode.onended = () => {
+    const elapsedTime = performance.now() - now;
+
+    if (elapsedTime >= delay) {
+      callIntervalFunction(id, type);
+    } else {
+      scheduleFunction(id, delay - elapsedTime, type);
+    }
+
+    audioBufferSourceNode.disconnect(webAudioWrapper.audioContext.destination);
+  };
+  audioBufferSourceNode.connect(webAudioWrapper.audioContext.destination);
+  audioBufferSourceNode.start(
+    Math.max(
+      0,
+      webAudioWrapper.audioContext.currentTime +
+        delay / 1000 -
+        webAudioWrapper.sampleDuration,
+    ),
+  );
+};
+
+export const clearInterval = (id: number) => {
+  SCHEDULED_INTERVAL_FUNCTIONS.delete(id);
+};
+
+export const clearTimeout = (id: number) => {
+  SCHEDULED_TIMEOUT_FUNCTIONS.delete(id);
+};
+
+export const setInterval = (func: () => void, delay: number) => {
+  const id = generateUniqueNumber(SCHEDULED_INTERVAL_FUNCTIONS);
+
+  SCHEDULED_INTERVAL_FUNCTIONS.set(id, () => {
+    func();
+
+    scheduleFunction(id, delay, TimerType.interval);
+  });
+
+  scheduleFunction(id, delay, TimerType.interval);
+
+  return id;
+};
+
+export const setTimeout = (func: () => void, delay: number) => {
+  const id = generateUniqueNumber(SCHEDULED_TIMEOUT_FUNCTIONS);
+
+  SCHEDULED_TIMEOUT_FUNCTIONS.set(id, func);
+
+  scheduleFunction(id, delay, TimerType.timeout);
+
+  return id;
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+export { Transport, TransportState } from "./Transport";
+export type { TransportEvent } from "./Transport";
+export { Position } from "./Position";
+export type {
+  Seconds,
+  Ticks,
+  BPM,
+  ContextTime,
+  ClockTime,
+  TimeSignature,
+} from "./types";

package/src/types.ts

@@ -0,0 +1,16 @@
+export type Seconds = number;
+
+export type ClockTime = number;
+export type ContextTime = number;
+export type Ticks = number;
+
+export type BPM = number;
+export type TimeSignature = [number, TimeSignatureDenominator];
+export type TimeSignatureDenominator = 2 | 4 | 8 | 16;
+export type TPosition = { bars: number; beats: number; sixteenths: number };
+export type TStringPosition = `${number}:${number}:${number}`;
+
+/**
+ * A number that is between [0, 1]
+ */
+export type NormalRange = number;

package/src/utils.ts

@@ -0,0 +1,106 @@
+import { BPM, NormalRange, Ticks } from "./types";
+
+// Ticks per beat
+export const TPB = 15360;
+
+export const secondsPerTick = (tempo: BPM) => {
+  return 60 / tempo / TPB;
+};
+
+export const ticksPerSecond = (tempo: BPM) => {
+  return (tempo / 60) * TPB;
+};
+
+export const insertionIndexBy = <T>(
+  arr: T[],
+  n: T,
+  comparatorFn: (a: T, b: T) => number,
+) => {
+  const index = arr.findIndex((el) => comparatorFn(n, el) < 0);
+  return index === -1 ? arr.length : index;
+};
+
+export function lerp(t: number, a: number, b: number): number {
+  return a + t * (b - a);
+}
+
+export function unlerp(t: number, a: number, b: number): number {
+  return (t - a) / (b - a);
+}
+
+/**
+ * Compute swing.
+ *
+ * This function is an attempt at mirroring the behaviour in the Reason DAW,
+ * where events before the 50% eighth mark are "expanded" and events past the
+ * mark are "compressed". That is, this function transforms the underlying
+ * transport time grid:
+ *
+ *  No swing  |<--50%-->|<--50%-->|<--50%-->| ...
+ *  16ths     0         1         2         3 ...
+ *  8ths      0         |         1         | ...
+ *  Notes     X======X  X===X     |         |
+ *            |         |         |         |
+ *            |          \        |          \
+ *  60% swing |<---60%--->|<-40%->|<---60%--->| ...
+ *  16ths     0           1       2           3 ...
+ *  8ths      0           |       1           | ...
+ *  Notes     X=======X   X==X    |           |
+ *
+ * If it is challenging to explain this mechanism to end users, you could
+ * use the approach taken in the Logic DAW, which has 6 "swing modes":
+ *
+ *  16A: 50%
+ *  16B: 54%
+ *  16C: 58%
+ *  16D: 62%
+ *  16E: 66%
+ *  16F: 71%
+ *
+ * For details, see
+ * https://www.attackmagazine.com/technique/passing-notes/daw-drum-machine-swing/2/
+ *
+ * @param time Time of event, in transport ticks (1/4 = 15360 pulses)
+ * @param amount Swing amount in range [0.5, 0.75].
+ * @returns New time of the event, with swing applied.
+ */
+export function swing(time: Ticks, amount: NormalRange): Ticks {
+  if (amount < 0.5 || amount > 0.75) {
+    throw new Error("Invalid swing amount");
+  }
+
+  /*
+    Note lengths in ticks:
+
+      1/4 = 15360
+      1/8 = 7680
+      1/16 = 3840
+  */
+
+  const t8 = time / 7680; // Input time in 8ths
+  const t8i = Math.floor(t8); // 8th in which the time sits
+  const t = t8 - t8i; // Percentage position in the 8th in which the time sits
+
+  /* 
+    ### We could make this a bit more efficient; we can simplify the 
+    <=0.5 case to
+
+      (t / 0.5) * amount
+
+    But the >0.5 case is more difficult:
+
+      amount + ((t - 0.5) / 0.5) * (1 - amount)
+
+    Using the lerp/unlerp functions here makes it clear what's going on,
+    though, so we'll keep them for now.
+  */
+  let tn = 0;
+  if (t <= 0.5) {
+    tn = lerp(unlerp(t, 0.0, 0.5), 0.0, amount);
+  } else {
+    tn = lerp(unlerp(t, 0.5, 1.0), amount, 1.0);
+  }
+
+  // Map transformed time back into ticks
+  return Math.floor((t8i + tn) * 7680);
+}