@blibliki/engine 0.1.27 → 0.3.2

package/src/core/Note/frequencyTable.ts

@@ -1,146 +1,146 @@
-const frequencyTable: { [key: string]: number } = {
-  C0: 16.35,
-  "C#0": 17.32,
-  Db0: 17.32,
-  D0: 18.35,
-  "D#0": 19.45,
-  Eb0: 19.45,
-  E0: 20.6,
-  F0: 21.83,
-  "F#0": 23.12,
-  Gb0: 23.12,
-  G0: 24.5,
-  "G#0": 25.96,
-  Ab0: 25.96,
-  A0: 27.5,
-  "A#0": 29.14,
-  Bb0: 29.14,
-  B0: 30.87,
-  C1: 32.7,
-  "C#1": 34.65,
-  Db1: 34.65,
-  D1: 36.71,
-  "D#1": 38.89,
-  Eb1: 38.89,
-  E1: 41.2,
-  F1: 43.65,
-  "F#1": 46.25,
-  Gb1: 46.25,
-  G1: 49.0,
-  "G#1": 51.91,
-  Ab1: 51.91,
-  A1: 55.0,
-  "A#1": 58.27,
-  Bb1: 58.27,
-  B1: 61.74,
-  C2: 65.41,
-  "C#2": 69.3,
-  Db2: 69.3,
-  D2: 73.42,
-  "D#2": 77.78,
-  Eb2: 77.78,
-  E2: 82.41,
-  F2: 87.31,
-  "F#2": 92.5,
-  Gb2: 92.5,
-  G2: 98.0,
-  "G#2": 103.83,
-  Ab2: 103.83,
-  A2: 110.0,
-  "A#2": 116.54,
-  Bb2: 116.54,
-  B2: 123.47,
-  C3: 130.81,
-  "C#3": 138.59,
-  Db3: 138.59,
-  D3: 146.83,
-  "D#3": 155.56,
-  Eb3: 155.56,
-  E3: 164.81,
-  F3: 174.61,
-  "F#3": 185.0,
-  Gb3: 185.0,
-  G3: 196.0,
-  "G#3": 207.65,
-  Ab3: 207.65,
-  A3: 220.0,
-  "A#3": 233.08,
-  Bb3: 233.08,
-  B3: 246.94,
-  C4: 261.63,
-  "C#4": 277.18,
-  Db4: 277.18,
-  D4: 293.66,
-  "D#4": 311.13,
-  Eb4: 311.13,
-  E4: 329.63,
-  F4: 349.23,
-  "F#4": 369.99,
-  Gb4: 369.99,
-  G4: 392.0,
-  "G#4": 415.3,
-  Ab4: 415.3,
-  A4: 440.0,
-  "A#4": 466.16,
-  Bb4: 466.16,
-  B4: 493.88,
-  C5: 523.25,
-  "C#5": 554.37,
-  Db5: 554.37,
-  D5: 587.33,
-  "D#5": 622.25,
-  Eb5: 622.25,
-  E5: 659.26,
-  F5: 698.46,
-  "F#5": 739.99,
-  Gb5: 739.99,
-  G5: 783.99,
-  "G#5": 830.61,
-  Ab5: 830.61,
-  A5: 880.0,
-  "A#5": 932.33,
-  Bb5: 932.33,
-  B5: 987.77,
-  C6: 1046.5,
-  "C#6": 1108.73,
-  Db6: 1108.73,
-  D6: 1174.66,
-  "D#6": 1244.51,
-  Eb6: 1244.51,
-  E6: 1318.51,
-  F6: 1396.91,
-  "F#6": 1479.98,
-  Gb6: 1479.98,
-  G6: 1567.98,
-  "G#6": 1661.22,
-  Ab6: 1661.22,
-  A6: 1760.0,
-  "A#6": 1864.66,
-  Bb6: 1864.66,
-  B6: 1975.53,
-  C7: 2093.0,
-  "C#7": 2217.46,
-  Db7: 2217.46,
-  D7: 2349.32,
-  "D#7": 2489.02,
-  Eb7: 2489.02,
-  E7: 2637.02,
-  F7: 2793.83,
-  "F#7": 2959.96,
-  Gb7: 2959.96,
-  G7: 3135.96,
-  "G#7": 3322.44,
-  Ab7: 3322.44,
-  A7: 3520.0,
-  "A#7": 3729.31,
-  Bb7: 3729.31,
-  B7: 3951.07,
-  C8: 4186.01,
-  "C#8": 4434.92,
-  Db8: 4434.92,
-  D8: 4698.64,
-  "D#8": 4978.03,
-  Eb8: 4978.03,
-};
+const frequencyTable = new Map<string, number>([
+  ["C0", 16.35],
+  ["C#0", 17.32],
+  ["Db0", 17.32],
+  ["D0", 18.35],
+  ["D#0", 19.45],
+  ["Eb0", 19.45],
+  ["E0", 20.6],
+  ["F0", 21.83],
+  ["F#0", 23.12],
+  ["Gb0", 23.12],
+  ["G0", 24.5],
+  ["G#0", 25.96],
+  ["Ab0", 25.96],
+  ["A0", 27.5],
+  ["A#0", 29.14],
+  ["Bb0", 29.14],
+  ["B0", 30.87],
+  ["C1", 32.7],
+  ["C#1", 34.65],
+  ["Db1", 34.65],
+  ["D1", 36.71],
+  ["D#1", 38.89],
+  ["Eb1", 38.89],
+  ["E1", 41.2],
+  ["F1", 43.65],
+  ["F#1", 46.25],
+  ["Gb1", 46.25],
+  ["G1", 49.0],
+  ["G#1", 51.91],
+  ["Ab1", 51.91],
+  ["A1", 55.0],
+  ["A#1", 58.27],
+  ["Bb1", 58.27],
+  ["B1", 61.74],
+  ["C2", 65.41],
+  ["C#2", 69.3],
+  ["Db2", 69.3],
+  ["D2", 73.42],
+  ["D#2", 77.78],
+  ["Eb2", 77.78],
+  ["E2", 82.41],
+  ["F2", 87.31],
+  ["F#2", 92.5],
+  ["Gb2", 92.5],
+  ["G2", 98.0],
+  ["G#2", 103.83],
+  ["Ab2", 103.83],
+  ["A2", 110.0],
+  ["A#2", 116.54],
+  ["Bb2", 116.54],
+  ["B2", 123.47],
+  ["C3", 130.81],
+  ["C#3", 138.59],
+  ["Db3", 138.59],
+  ["D3", 146.83],
+  ["D#3", 155.56],
+  ["Eb3", 155.56],
+  ["E3", 164.81],
+  ["F3", 174.61],
+  ["F#3", 185.0],
+  ["Gb3", 185.0],
+  ["G3", 196.0],
+  ["G#3", 207.65],
+  ["Ab3", 207.65],
+  ["A3", 220.0],
+  ["A#3", 233.08],
+  ["Bb3", 233.08],
+  ["B3", 246.94],
+  ["C4", 261.63],
+  ["C#4", 277.18],
+  ["Db4", 277.18],
+  ["D4", 293.66],
+  ["D#4", 311.13],
+  ["Eb4", 311.13],
+  ["E4", 329.63],
+  ["F4", 349.23],
+  ["F#4", 369.99],
+  ["Gb4", 369.99],
+  ["G4", 392.0],
+  ["G#4", 415.3],
+  ["Ab4", 415.3],
+  ["A4", 440.0],
+  ["A#4", 466.16],
+  ["Bb4", 466.16],
+  ["B4", 493.88],
+  ["C5", 523.25],
+  ["C#5", 554.37],
+  ["Db5", 554.37],
+  ["D5", 587.33],
+  ["D#5", 622.25],
+  ["Eb5", 622.25],
+  ["E5", 659.26],
+  ["F5", 698.46],
+  ["F#5", 739.99],
+  ["Gb5", 739.99],
+  ["G5", 783.99],
+  ["G#5", 830.61],
+  ["Ab5", 830.61],
+  ["A5", 880.0],
+  ["A#5", 932.33],
+  ["Bb5", 932.33],
+  ["B5", 987.77],
+  ["C6", 1046.5],
+  ["C#6", 1108.73],
+  ["Db6", 1108.73],
+  ["D6", 1174.66],
+  ["D#6", 1244.51],
+  ["Eb6", 1244.51],
+  ["E6", 1318.51],
+  ["F6", 1396.91],
+  ["F#6", 1479.98],
+  ["Gb6", 1479.98],
+  ["G6", 1567.98],
+  ["G#6", 1661.22],
+  ["Ab6", 1661.22],
+  ["A6", 1760.0],
+  ["A#6", 1864.66],
+  ["Bb6", 1864.66],
+  ["B6", 1975.53],
+  ["C7", 2093.0],
+  ["C#7", 2217.46],
+  ["Db7", 2217.46],
+  ["D7", 2349.32],
+  ["D#7", 2489.02],
+  ["Eb7", 2489.02],
+  ["E7", 2637.02],
+  ["F7", 2793.83],
+  ["F#7", 2959.96],
+  ["Gb7", 2959.96],
+  ["G7", 3135.96],
+  ["G#7", 3322.44],
+  ["Ab7", 3322.44],
+  ["A7", 3520.0],
+  ["A#7", 3729.31],
+  ["Bb7", 3729.31],
+  ["B7", 3951.07],
+  ["C8", 4186.01],
+  ["C#8", 4434.92],
+  ["Db8", 4434.92],
+  ["D8", 4698.64],
+  ["D#8", 4978.03],
+  ["Eb8", 4978.03],
+]);
 
 export default frequencyTable;

package/src/core/Note/index.ts

@@ -1,55 +1,75 @@
+import { Message } from "webmidi";
+import { TTime } from "../Timing/Time";
 import frequencyTable from "./frequencyTable";
 
 const Notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
 
-const NotesLength = Notes.length;
-
 const MIDI_OCTAVE_SYTSTEM = 2;
 
-export interface INote {
-  note: string;
+export type INote = {
+  name: string;
+  octave: number;
   frequency: number;
-  duration: string;
+  duration?: TTime;
   velocity?: number;
-}
+};
 
-export default class Note {
+export default class Note implements INote {
   static _notes: Note[];
-  name: string;
-  octave: number;
+  name!: string;
+  octave!: number;
   velocity = 1;
-  duration: string;
-  frequency: number;
+  duration?: TTime;
 
-  constructor(
-    eventOrString: Partial<INote> | MIDIMessageEvent | string | number
-  ) {
-    if (typeof eventOrString === "number") {
-      this.fromFrequency(eventOrString);
-    } else if (typeof eventOrString === "string") {
-      this.fromString(eventOrString);
-    } else if (eventOrString instanceof MIDIMessageEvent) {
-      this.fromEvent(eventOrString);
-    } else {
-      this.fromProps(eventOrString);
+  static fromFrequency(frequency: number) {
+    let noteName: string | undefined;
+
+    for (const [note, freq] of frequencyTable) {
+      if (freq !== frequency) continue;
+
+      noteName = note;
+      break;
     }
+
+    if (!noteName) throw Error("Not matching frequency with a note");
+
+    return new Note(noteName);
+  }
+
+  static fromEvent(message: Message) {
+    const name = Notes[message.data[1] % 12];
+    const octave = Math.floor(message.data[1] / 12) - 2;
+
+    return new Note(`${name}${octave}`);
   }
 
   static notes(octave = 3) {
     return Notes.map((note: string) => new Note(`${note}${octave}`));
   }
 
+  constructor(note: Omit<INote, "frequency"> | string) {
+    if (typeof note === "string") {
+      this.fromString(note);
+    } else {
+      this.fromProps(note);
+    }
+  }
+
   get isSemi() {
-    return this.name.slice(-1) === "#";
+    return this.name.endsWith("#");
   }
 
   get fullName() {
     return `${this.name}${this.octave}`;
   }
 
-  midiData(noteOn: boolean = true): Uint8Array {
+  get frequency(): number {
+    return frequencyTable.get(`${this.name}${this.octave}`)!;
+  }
+
+  midiData(noteOn = true): Uint8Array {
     const statusByte = noteOn ? 0x90 : 0x80;
-    return new Uint8Array([statusByte, 0, this.velocity * 100]);
+    return new Uint8Array([statusByte, this.midiNumber, this.velocity * 100]);
   }
 
   get midiNumber(): number {
@@ -60,58 +80,28 @@ export default class Note {
     return Notes.indexOf(this.name);
   }
 
-  adjustFrequency(range = 0, coarse = 0) {
-    if (this.frequency) return this.frequency;
-
-    let newOctave = this.octave + range;
-    const coarseIndex = Notes.indexOf(this.name) + coarse;
-    let nameIndex = coarseIndex;
-
-    if (coarseIndex >= NotesLength) {
-      newOctave++;
-      nameIndex = coarseIndex % NotesLength;
-    } else if (coarseIndex < 0) {
-      newOctave--;
-      nameIndex = NotesLength + nameIndex;
-    }
-    const newName = Notes[nameIndex];
-
-    return frequencyTable[`${newName}${newOctave}`];
-  }
-
   valueOf() {
     return this.fullName;
   }
 
   serialize(): INote {
     return {
-      note: this.fullName,
+      name: this.name,
+      octave: this.octave,
       frequency: this.frequency,
       velocity: this.velocity,
       duration: this.duration,
     };
   }
 
-  private fromFrequency(frequency: number) {
-    this.frequency = frequency;
-  }
-
   private fromString(string: string) {
-    const matches = string.match(/(\w#?)(\d)?/) || [];
+    const matches = /(\w#?)(\d)?/.exec(string) ?? [];
 
     this.name = matches[1];
     this.octave = matches[2] ? parseInt(matches[2]) : 1;
   }
 
-  private fromEvent(event: MIDIMessageEvent) {
-    this.name = Notes[event.data[1] % 12];
-    this.octave = Math.floor(event.data[1] / 12) - 2;
-  }
-
-  private fromProps(props: Partial<INote>) {
+  private fromProps(props: Omit<INote, "frequency">) {
     Object.assign(this, props);
-    if (!props.note) throw Error("note props is mandatory");
-
-    this.fromString(props.note);
   }
 }

package/src/core/Route.ts

@@ -0,0 +1,79 @@
+import { Optional, uuidv4 } from "@blibliki/utils";
+import { Engine } from "@/Engine";
+
+type IPlug = {
+  moduleId: string;
+  ioName: string;
+};
+
+export type IRoute = {
+  id: string;
+  source: IPlug;
+  destination: IPlug;
+};
+
+export class Routes {
+  engine: Engine;
+  routes: Map<string, IRoute>;
+
+  constructor(engine: Engine) {
+    this.engine = engine;
+    this.routes = new Map();
+  }
+
+  addRoute(props: Optional<IRoute, "id">): IRoute {
+    const id = props.id ?? uuidv4();
+    const route = { ...props, id };
+    this.routes.set(id, route);
+
+    this.plug(id);
+
+    return route;
+  }
+
+  removeRoute(id: string) {
+    this.unPlug(id);
+    this.routes.delete(id);
+  }
+
+  clear() {
+    for (const id in this.routes) {
+      this.removeRoute(id);
+    }
+  }
+
+  private plug(id: string) {
+    const { sourceIO, destinationIO } = this.getIOs(id);
+    sourceIO.plug(destinationIO);
+  }
+
+  private unPlug(id: string) {
+    const { sourceIO, destinationIO } = this.getIOs(id);
+    sourceIO.unPlug(destinationIO);
+  }
+
+  private find(id: string): IRoute {
+    const route = this.routes.get(id);
+    if (!route) throw Error(`Route with id ${id} not found`);
+
+    return route;
+  }
+
+  private getIOs(id: string) {
+    const route = this.find(id);
+    const { source, destination } = route;
+
+    const sourceIO = this.engine.findIO(
+      source.moduleId,
+      source.ioName,
+      "output",
+    );
+    const destinationIO = this.engine.findIO(
+      destination.moduleId,
+      destination.ioName,
+      "input",
+    );
+
+    return { sourceIO, destinationIO };
+  }
+}

package/src/core/Timing/Scheduler.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,103 @@
+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;
+  }
+}