@blibliki/engine 0.3.2 → 0.3.4

package/src/modules/Filter.ts

@@ -1,4 +1,5 @@
-import { IAnyAudioContext, Module } from "@/core";
+import { Context } from "@blibliki/utils";
+import { Module } from "@/core";
 import { IModuleConstructor } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
 import { PropSchema } from "@/core/schema";
@@ -54,7 +55,7 @@ class MonoFilter extends Module<ModuleType.Filter> {
   constructor(engineId: string, params: ICreateModule<ModuleType.Filter>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
 
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
+    const audioNodeConstructor = (context: Context) =>
       newAudioWorklet(context, CustomWorklet.FilterProcessor);
 
     super(engineId, {

package/src/modules/Gain.ts

@@ -1,4 +1,5 @@
-import { IAnyAudioContext, IModule, Module } from "@/core";
+import { Context } from "@blibliki/utils";
+import { IModule, Module } from "@/core";
 import { IModuleConstructor } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
 import { PropSchema } from "@/core/schema";
@@ -26,8 +27,8 @@ export class MonoGain extends Module<ModuleType.Gain> {
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Gain>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
-      new GainNode(context);
+    const audioNodeConstructor = (context: Context) =>
+      new GainNode(context.audioContext);
 
     super(engineId, {
       ...params,

package/src/modules/Inspector.ts

@@ -1,4 +1,5 @@
-import { IAnyAudioContext, IModule, Module } from "@/core";
+import { Context } from "@blibliki/utils";
+import { IModule, Module } from "@/core";
 import { PropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
@@ -23,8 +24,8 @@ export default class Inspector extends Module<ModuleType.Inspector> {
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Inspector>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
-      new AnalyserNode(context);
+    const audioNodeConstructor = (context: Context) =>
+      new AnalyserNode(context.audioContext);
 
     super(engineId, {
       ...params,

package/src/modules/Master.ts

@@ -1,5 +1,5 @@
-import { EmptyObject } from "@blibliki/utils";
-import { IAnyAudioContext, IModule, Module } from "@/core";
+import { Context, EmptyObject } from "@blibliki/utils";
+import { IModule, Module } from "@/core";
 import { PropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
@@ -15,8 +15,7 @@ export default class Master extends Module<ModuleType.Master> {
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Master>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
-      context.destination;
+    const audioNodeConstructor = (context: Context) => context.destination;
 
     super(engineId, { ...params, audioNodeConstructor, props });
 

package/src/modules/Oscillator.ts

@@ -1,7 +1,7 @@
-import { dbToGain } from "@blibliki/utils";
-import { IAnyAudioContext, IModule, Module } from "@/core";
+import { ContextTime } from "@blibliki/transport";
+import { Context, dbToGain } from "@blibliki/utils";
+import { IModule, Module } from "@/core";
 import Note from "@/core/Note";
-import { nt, TTime } from "@/core/Timing/Time";
 import { IModuleConstructor } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
 import { PropSchema } from "@/core/schema";
@@ -95,8 +95,8 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Oscillator>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
-      new OscillatorNode(context);
+    const audioNodeConstructor = (context: Context) =>
+      new OscillatorNode(context.audioContext);
 
     super(engineId, {
       ...params,
@@ -104,7 +104,7 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
       audioNodeConstructor,
     });
 
-    this.lowOutputGain = new GainNode(this.context, {
+    this.lowOutputGain = new GainNode(this.context.audioContext, {
       gain: dbToGain(LOW_GAIN),
     });
 
@@ -140,17 +140,17 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
     this.rePlugAll();
   }
 
-  start(time: TTime) {
+  start(time: ContextTime) {
     if (this.isStated) return;
 
     this.isStated = true;
-    this.audioNode.start(nt(time));
+    this.audioNode.start(time);
   }
 
-  stop(time: TTime) {
-    this.audioNode.stop(nt(time));
+  stop(time: ContextTime) {
+    this.audioNode.stop(time);
     this.rePlugAll(() => {
-      this.audioNode = new OscillatorNode(this.context, {
+      this.audioNode = new OscillatorNode(this.context.audioContext, {
         type: this.props.wave,
         frequency: this.finalFrequency,
       });
@@ -161,7 +161,7 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
     this.isStated = false;
   }
 
-  triggerAttack = (note: Note, triggeredAt: TTime) => {
+  triggerAttack = (note: Note, triggeredAt: ContextTime) => {
     super.triggerAttack(note, triggeredAt);
 
     this.props = { frequency: note.frequency };
@@ -169,7 +169,7 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
     this.start(triggeredAt);
   };
 
-  triggerRelease(note: Note, triggeredAt: TTime) {
+  triggerRelease(note: Note, triggeredAt: ContextTime) {
     super.triggerRelease(note, triggeredAt);
 
     const lastNote = this.activeNotes.length
@@ -190,14 +190,11 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
     return transposed;
   }
 
-  private updateFrequency(actionAt?: TTime) {
+  private updateFrequency(actionAt?: ContextTime) {
     if (this.finalFrequency === undefined) return;
 
     if (actionAt) {
-      this.audioNode.frequency.setValueAtTime(
-        this.finalFrequency,
-        nt(actionAt),
-      );
+      this.audioNode.frequency.setValueAtTime(this.finalFrequency, actionAt);
     } else {
       this.audioNode.frequency.value = this.finalFrequency;
     }
@@ -208,7 +205,7 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
   }
 
   private initializeGainDetune() {
-    this.detuneGain = new GainNode(this.context, { gain: 100 });
+    this.detuneGain = new GainNode(this.context.audioContext, { gain: 100 });
     this.detuneGain.connect(this.audioNode.detune);
   }
 
@@ -249,13 +246,13 @@ export default class Oscillator extends PolyModule<ModuleType.Oscillator> {
     this.registerDefaultIOs("out");
   }
 
-  start(time: TTime) {
+  start(time: ContextTime) {
     this.audioModules.forEach((audioModule) => {
       audioModule.start(time);
     });
   }
 
-  stop(time: TTime) {
+  stop(time: ContextTime) {
     this.audioModules.forEach((audioModule) => {
       audioModule.stop(time);
     });

package/src/modules/Scale.ts

@@ -1,4 +1,5 @@
-import { IAnyAudioContext, IModule, Module } from "@/core";
+import { Context } from "@blibliki/utils";
+import { IModule, Module } from "@/core";
 import { PropSchema } from "@/core/schema";
 import { CustomWorklet, newAudioWorklet } from "@/processors";
 import { ICreateModule, ModuleType } from ".";
@@ -41,7 +42,7 @@ export default class Scale extends Module<ModuleType.Scale> {
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Scale>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
+    const audioNodeConstructor = (context: Context) =>
       newAudioWorklet(context, CustomWorklet.ScaleProcessor);
 
     super(engineId, {

package/src/modules/StepSequencer.ts

@@ -1,12 +1,11 @@
 import { INote, PropSchema, Module, IModule, MidiOutput } from "@/core";
-import { BarsBeatsSixteenths } from "@/core/Timing/Time";
 import { ICreateModule, ModuleType } from ".";
 
 export type IStepSequencer = IModule<ModuleType.StepSequencer>;
 
 export type ISequence = {
   active: boolean;
-  time: BarsBeatsSixteenths;
+  // time: BarsBeatsSixteenths;
   duration: string;
   notes: INote[];
 };

package/src/modules/VirtualMidi.ts

@@ -1,5 +1,5 @@
+import { ContextTime } from "@blibliki/transport";
 import { PropSchema, Module, IModule, MidiOutput, Note } from "@/core";
-import { TTime } from "@/core/Timing/Time";
 import MidiEvent from "@/core/midi/MidiEvent";
 import { ICreateModule, ModuleType } from ".";
 
@@ -37,13 +37,13 @@ export default class VirtualMidi extends Module<ModuleType.VirtualMidi> {
     this.midiOutput.onMidiEvent(midiEvent);
   }
 
-  triggerAttack = (note: Note, triggerAttack: TTime) => {
+  triggerAttack = (note: Note, triggerAttack: ContextTime) => {
     this.props = { activeNotes: [...this.props.activeNotes, note.fullName] };
     this.triggerPropsUpdate();
     this.sendMidi(MidiEvent.fromNote(note, true, triggerAttack));
   };
 
-  triggerRelease = (note: Note, triggerAttack: TTime) => {
+  triggerRelease = (note: Note, triggerAttack: ContextTime) => {
     this.props = {
       activeNotes: this.props.activeNotes.filter(
         (name) => name !== note.fullName,

package/src/processors/index.ts

@@ -1,5 +1,4 @@
-import { assertNever } from "@blibliki/utils";
-import { IAnyAudioContext } from "@/core";
+import { assertNever, Context } from "@blibliki/utils";
 import { filterProcessorURL } from "./filter-processor";
 import { scaleProcessorURL } from "./scale-processor";
 
@@ -8,20 +7,17 @@ export enum CustomWorklet {
   FilterProcessor = "FilterProcessor",
 }
 
-export async function loadProcessors(context: IAnyAudioContext) {
-  await context.audioWorklet.addModule(scaleProcessorURL);
-  await context.audioWorklet.addModule(filterProcessorURL);
+export async function loadProcessors(context: Context) {
+  await context.addModule(scaleProcessorURL);
+  await context.addModule(filterProcessorURL);
 }
 
-export function newAudioWorklet(
-  context: IAnyAudioContext,
-  worklet: CustomWorklet,
-) {
+export function newAudioWorklet(context: Context, worklet: CustomWorklet) {
   switch (worklet) {
     case CustomWorklet.ScaleProcessor:
-      return new AudioWorkletNode(context, "scale-processor");
+      return context.newAudioWorklet("scale-processor");
     case CustomWorklet.FilterProcessor:
-      return new AudioWorkletNode(context, "filter-processor");
+      return context.newAudioWorklet("filter-processor");
     default:
       assertNever(worklet);
   }

package/src/core/Timing/Scheduler.ts

@@ -1,37 +0,0 @@
-import { Scheduler as InternalScheduler } from "@ircam/sc-scheduling";
-import { now } from ".";
-import { nt, t, TTime } from "./Time";
-import Transport from "./Transport";
-
-export default class Scheduler {
-  transport: Transport;
-  internalScheduler: InternalScheduler;
-
-  constructor(transport: Transport) {
-    this.transport = transport;
-    this.internalScheduler = new InternalScheduler(now, {
-      currentTimeToProcessorTimeFunction: () => this.transport.playhead,
-    });
-  }
-
-  start(actionAt: TTime, callback: () => void) {
-    this.internalScheduler.add(this.processor, nt(actionAt));
-    this.defer(callback, actionAt);
-  }
-
-  stop(actionAt: TTime, callback: () => void) {
-    this.defer(() => {
-      this.internalScheduler.remove(this.processor);
-      callback();
-    }, actionAt);
-  }
-
-  defer(callback: () => void, actionAt: TTime) {
-    this.internalScheduler.defer(callback, nt(actionAt));
-  }
-
-  private processor = (currentTime: number, playhead: TTime) => {
-    console.log(`playhead: ${t(playhead).toNotation()}`);
-    return currentTime + 0.5;
-  };
-}

package/src/core/Timing/Time.ts

@@ -1,103 +0,0 @@
-import { isNumber } from "@blibliki/utils";
-import { Engine } from "@/Engine";
-import { now } from ".";
-
-export type BarsBeatsSixteenths = `${number}:${number}:${number}`;
-export type TTime = number | BarsBeatsSixteenths | Time;
-
-export const t = (value?: TTime): Time => {
-  value ??= now();
-
-  if (value instanceof Time) return value;
-
-  return new Time(value);
-};
-
-export const nt = (value?: TTime): number => {
-  value ??= now();
-
-  if (typeof value === "number") return value;
-
-  return t(value).toNumber();
-};
-
-export default class Time {
-  private value: number | BarsBeatsSixteenths;
-  private _notation?: BarsBeatsSixteenths;
-  private _number?: number;
-
-  constructor(value: TTime) {
-    this.value = value instanceof Time ? value.value : value;
-
-    if (isNumber(this.value)) {
-      this._number = this.value;
-    } else {
-      this._notation = this.value;
-    }
-  }
-
-  add(value: TTime): Time {
-    return t(this.toNumber() + t(value).toNumber());
-  }
-
-  subtrack(value: TTime): Time {
-    return t(this.toNumber() - nt(value));
-  }
-
-  isBefore(value: TTime): boolean {
-    return this.toNumber() < nt(value);
-  }
-
-  isAfter(value: TTime): boolean {
-    return this.toNumber() > nt(value);
-  }
-
-  isEqual(value: TTime): boolean {
-    return this.toNumber() > nt(value);
-  }
-
-  toNotation(): BarsBeatsSixteenths {
-    if (this._notation) return this._notation;
-
-    const [count, factor] = this.transport.timeSignature;
-    const divisionsPerBeat = 16 / factor;
-    const divisionsPerBar = count * divisionsPerBeat;
-    const secondsPerBeat = 60 / this.transport.bpm;
-
-    const totalDivisions = Math.floor(
-      ((this.value as number) / secondsPerBeat) * divisionsPerBeat,
-    );
-
-    const bars = Math.floor(totalDivisions / divisionsPerBar);
-    const beats = Math.floor(
-      (totalDivisions % divisionsPerBar) / divisionsPerBeat,
-    );
-    const divisions = totalDivisions % divisionsPerBeat;
-
-    this._notation = `${bars}:${beats}:${divisions}`;
-
-    return this._notation;
-  }
-
-  toNumber(): number {
-    if (isNumber(this._number)) return this._number;
-
-    const [beatsPerBar, sixteenths] = this.transport.timeSignature;
-    const secondsPerBeat = 60 / this.transport.bpm;
-
-    const [bars, beats, divisions] = (this.value as BarsBeatsSixteenths)
-      .split(":")
-      .map(Number);
-
-    const totalBeats =
-      bars * beatsPerBar + beats + divisions / (sixteenths / 4);
-
-    this._number = totalBeats * secondsPerBeat;
-
-    return this._number;
-  }
-
-  private get transport() {
-    return Engine.current.transport;
-  }
-}

package/src/core/Timing/Transport.ts

@@ -1,104 +0,0 @@
-import { now } from ".";
-import Scheduler from "./Scheduler";
-import Time, { t, TTime } from "./Time";
-
-export enum TransportState {
-  playing = "playing",
-  stopped = "stopped",
-  paused = "paused",
-}
-
-export type TransportEvents = {
-  start: { actionAt: TTime; offset: TTime };
-  stop: { actionAt: TTime };
-  pause: { actionAt: TTime };
-};
-
-type TPlaybackCallback = (actionAt: TTime) => void;
-
-type TransportProps = {
-  onStart?: TPlaybackCallback;
-  onStop?: TPlaybackCallback;
-};
-
-export default class Transport {
-  bpm = 120;
-  timeSignature: [number, number] = [4, 4];
-  loopStart: TTime;
-  loopEnd?: TTime;
-
-  state: TransportState = TransportState.stopped;
-  offset: TTime = 0;
-
-  private startTime: TTime = 0;
-  private onStart: TransportProps["onStart"];
-  private onStop: TransportProps["onStop"];
-  private scheduler: Scheduler;
-
-  constructor(props: TransportProps) {
-    this.onStart = props.onStart;
-    this.onStop = props.onStop;
-    this.loopStart = t("0:0:0");
-    this.scheduler = new Scheduler(this);
-  }
-
-  start({
-    offset = this.offset,
-    actionAt = now(),
-  }: {
-    offset?: TTime;
-    actionAt?: TTime;
-  }) {
-    if (this.state === TransportState.playing) return;
-
-    this.validateFutureTime(actionAt);
-
-    this.scheduler.start(actionAt, () => {
-      this.state = TransportState.playing;
-      this.offset = offset;
-      this.startTime = t(actionAt).subtrack(this.offset);
-    });
-    this.onStart?.(actionAt);
-
-    return actionAt;
-  }
-
-  stop({ actionAt: actionAt = now() }: { actionAt?: TTime }) {
-    if (this.state === TransportState.stopped) return;
-
-    this.validateFutureTime(actionAt);
-
-    this.scheduler.stop(actionAt, () => {
-      this.state = TransportState.stopped;
-      this.offset = 0;
-    });
-    this.onStop?.(actionAt);
-
-    return actionAt;
-  }
-
-  pause({ actionAt: actionAt = now() }: { actionAt?: TTime }) {
-    if (this.state === TransportState.paused) return;
-
-    this.validateFutureTime(actionAt);
-
-    this.scheduler.stop(actionAt, () => {
-      this.state = TransportState.paused;
-      this.offset = t(actionAt).subtrack(this.startTime);
-    });
-    this.onStop?.(actionAt);
-
-    return actionAt;
-  }
-
-  get playhead(): Time {
-    if (this.state === TransportState.stopped) return t(0);
-    if (this.state === TransportState.paused) return t(this.offset);
-
-    return t(now()).subtrack(this.startTime);
-  }
-
-  private validateFutureTime(time: TTime) {
-    if (t(time).isBefore(now())) throw Error("Past time not allowed");
-  }
-}

package/src/core/Timing/index.ts

@@ -1,16 +0,0 @@
-import { Engine } from "@/Engine";
-
-export { default as Transport, TransportState } from "./Transport";
-export { default as Time } from "./Time";
-
-export type { TransportEvents } from "./Transport";
-export type { TTime } from "./Time";
-
-export function now() {
-  return Engine.current.context.currentTime;
-}
-
-export function browserToContextTime(time: number): number {
-  const differenceBetweenClocks = performance.now() / 1000 - now();
-  return time / 1000 - differenceBetweenClocks;
-}