278 lines
7.3 KiB
TypeScript
278 lines
7.3 KiB
TypeScript
import { Editor } from "./main";
|
|
import { tryEvaluate } from "./Evaluator";
|
|
// @ts-ignore
|
|
import { getAudioContext } from "superdough";
|
|
// @ts-ignore
|
|
import "zyklus";
|
|
const zeroPad = (num: number, places: number) =>
|
|
String(num).padStart(places, "0");
|
|
|
|
export interface TimePosition {
|
|
/**
|
|
* A position in time.
|
|
*
|
|
* @param bar - The bar number
|
|
* @param beat - The beat number
|
|
* @param pulse - The pulse number
|
|
*/
|
|
bar: number;
|
|
beat: number;
|
|
pulse: number;
|
|
}
|
|
|
|
export class Clock {
|
|
/**
|
|
*
|
|
* @param app - main application instance
|
|
* @param clock - zyklus clock
|
|
* @param ctx - current AudioContext used by app
|
|
* @param bpm - current beats per minute value
|
|
* @param time_signature - time signature
|
|
* @param time_position - current time position
|
|
* @param ppqn - pulses per quarter note
|
|
* @param tick - current tick since origin
|
|
* @param running - Is the clock running?
|
|
*/
|
|
|
|
private _bpm: number;
|
|
private _ppqn: number;
|
|
clock: any;
|
|
ctx: AudioContext;
|
|
logicalTime: number;
|
|
time_signature: number[];
|
|
time_position: TimePosition;
|
|
tick: number;
|
|
running: boolean;
|
|
timeviewer: HTMLElement;
|
|
deadline: number;
|
|
|
|
constructor(
|
|
public app: Editor,
|
|
ctx: AudioContext,
|
|
) {
|
|
this.time_position = { bar: 0, beat: 0, pulse: 0 };
|
|
this.time_signature = [4, 4];
|
|
this.logicalTime = 0;
|
|
this.tick = 0;
|
|
this._bpm = 120;
|
|
this._ppqn = 48;
|
|
this.ctx = ctx;
|
|
this.running = true;
|
|
this.deadline = 0;
|
|
this.timeviewer = document.getElementById("timeviewer")!;
|
|
this.clock = getAudioContext().createClock(
|
|
this.clockCallback,
|
|
this.pulse_duration,
|
|
);
|
|
}
|
|
|
|
// @ts-ignore
|
|
clockCallback = (time: number, duration: number, tick: number) => {
|
|
/**
|
|
* Callback function for the zyklus clock. Updates the clock info and sends a
|
|
* MIDI clock message if the setting is enabled. Also evaluates the global buffer.
|
|
*
|
|
* @param time - precise AudioContext time when the tick should happen
|
|
* @param duration - seconds between each tick
|
|
* @param tick - count of the current tick
|
|
*/
|
|
let deadline = time - getAudioContext().currentTime;
|
|
this.deadline = deadline;
|
|
this.tick = tick;
|
|
if (this.app.clock.running) {
|
|
if (this.app.settings.send_clock) {
|
|
this.app.api.MidiConnection.sendMidiClock();
|
|
}
|
|
const futureTimeStamp = this.app.clock.convertTicksToTimeposition(
|
|
this.app.clock.tick,
|
|
);
|
|
this.app.clock.time_position = futureTimeStamp;
|
|
if (futureTimeStamp.pulse % this.app.clock.ppqn == 0) {
|
|
this.timeviewer.innerHTML = `${zeroPad(futureTimeStamp.bar, 2)}:${futureTimeStamp.beat + 1
|
|
} / ${this.app.clock.bpm}`;
|
|
}
|
|
if (this.app.exampleIsPlaying) {
|
|
tryEvaluate(this.app, this.app.example_buffer);
|
|
} else {
|
|
tryEvaluate(this.app, this.app.global_buffer);
|
|
}
|
|
}
|
|
|
|
// Implement TransportNode clock callback and update clock info with it
|
|
};
|
|
|
|
convertTicksToTimeposition(ticks: number): TimePosition {
|
|
/**
|
|
* Converts ticks to a time position.
|
|
*
|
|
* @param ticks - ticks to convert
|
|
* @returns TimePosition
|
|
*/
|
|
const beatsPerBar = this.app.clock.time_signature[0];
|
|
const ppqnPosition = ticks % this.app.clock.ppqn;
|
|
const beatNumber = Math.floor(ticks / this.app.clock.ppqn);
|
|
const barNumber = Math.floor(beatNumber / beatsPerBar);
|
|
const beatWithinBar = Math.floor(beatNumber % beatsPerBar);
|
|
return { bar: barNumber, beat: beatWithinBar, pulse: ppqnPosition };
|
|
}
|
|
|
|
get ticks_before_new_bar(): number {
|
|
/**
|
|
* Calculates the number of ticks before the next bar.
|
|
*
|
|
* @returns number - ticks before the next bar
|
|
*/
|
|
const ticskMissingFromBeat = this.ppqn - this.time_position.pulse;
|
|
const beatsMissingFromBar = this.beats_per_bar - this.time_position.beat;
|
|
return beatsMissingFromBar * this.ppqn + ticskMissingFromBeat;
|
|
}
|
|
|
|
get next_beat_in_ticks(): number {
|
|
/**
|
|
* Calculates the number of ticks before the next beat.
|
|
*
|
|
* @returns number - ticks before the next beat
|
|
*/
|
|
return this.app.clock.pulses_since_origin + this.time_position.pulse;
|
|
}
|
|
|
|
get beats_per_bar(): number {
|
|
/**
|
|
* Returns the number of beats per bar.
|
|
*
|
|
* @returns number - beats per bar
|
|
*/
|
|
return this.time_signature[0];
|
|
}
|
|
|
|
get beats_since_origin(): number {
|
|
/**
|
|
* Returns the number of beats since the origin.
|
|
*
|
|
* @returns number - beats since the origin
|
|
*/
|
|
return Math.floor(this.tick / this.ppqn);
|
|
}
|
|
|
|
get pulses_since_origin(): number {
|
|
/**
|
|
* Returns the number of pulses since the origin.
|
|
*
|
|
* @returns number - pulses since the origin
|
|
*/
|
|
return this.tick;
|
|
}
|
|
|
|
get pulse_duration(): number {
|
|
/**
|
|
* Returns the duration of a pulse in seconds.
|
|
* @returns number - duration of a pulse in seconds
|
|
*/
|
|
return 60 / this.bpm / this.ppqn;
|
|
}
|
|
|
|
public pulse_duration_at_bpm(bpm: number = this.bpm): number {
|
|
/**
|
|
* Returns the duration of a pulse in seconds at a given bpm.
|
|
*
|
|
* @param bpm - bpm to calculate the pulse duration for
|
|
* @returns number - duration of a pulse in seconds
|
|
*/
|
|
return 60 / bpm / this.ppqn;
|
|
}
|
|
|
|
get bpm(): number {
|
|
/**
|
|
* Returns the current bpm.
|
|
* @returns number - current bpm
|
|
*/
|
|
return this._bpm;
|
|
}
|
|
|
|
get tickDuration(): number {
|
|
/**
|
|
* Returns the duration of a tick in seconds.
|
|
* @returns number - duration of a tick in seconds
|
|
*/
|
|
return 1 / this.ppqn;
|
|
}
|
|
|
|
set bpm(bpm: number) {
|
|
/**
|
|
* Sets the bpm.
|
|
* @param bpm - bpm to set
|
|
*/
|
|
if (bpm > 0 && this._bpm !== bpm) {
|
|
this._bpm = bpm;
|
|
this.clock.setDuration(() => (this.tickDuration * 60) / this.bpm);
|
|
}
|
|
}
|
|
|
|
get ppqn(): number {
|
|
/**
|
|
* Returns the current ppqn.
|
|
* @returns number - current ppqn
|
|
*/
|
|
return this._ppqn;
|
|
}
|
|
|
|
set ppqn(ppqn: number) {
|
|
/**
|
|
* Sets the ppqn.
|
|
* @param ppqn - ppqn to set
|
|
* @returns number - current ppqn
|
|
*/
|
|
if (ppqn > 0 && this._ppqn !== ppqn) {
|
|
this._ppqn = ppqn;
|
|
}
|
|
}
|
|
|
|
public nextTickFrom(time: number, nudge: number): number {
|
|
const pulseDuration = this.pulse_duration;
|
|
const nudgedTime = time + nudge;
|
|
const nextTickTime = Math.ceil(nudgedTime / pulseDuration) * pulseDuration;
|
|
const remainingTime = nextTickTime - nudgedTime;
|
|
return remainingTime;
|
|
}
|
|
|
|
public convertPulseToSecond(n: number): number {
|
|
return n * this.pulse_duration;
|
|
}
|
|
|
|
public start(): void {
|
|
/**
|
|
* Start the clock
|
|
*
|
|
* @remark also sends a MIDI message if a port is declared
|
|
*/
|
|
this.app.audioContext.resume();
|
|
this.running = true;
|
|
this.app.api.MidiConnection.sendStartMessage();
|
|
this.clock.start();
|
|
}
|
|
|
|
public pause(): void {
|
|
/**
|
|
* Pause the clock.
|
|
*
|
|
* @remark also sends a MIDI message if a port is declared
|
|
*/
|
|
this.running = false;
|
|
this.app.api.MidiConnection.sendStopMessage();
|
|
this.clock.pause();
|
|
}
|
|
|
|
public stop(): void {
|
|
/**
|
|
* Stops the clock.
|
|
*
|
|
* @remark also sends a MIDI message if a port is declared
|
|
*/
|
|
this.running = false;
|
|
this.tick = 0;
|
|
this.time_position = { bar: 0, beat: 0, pulse: 0 };
|
|
this.app.api.MidiConnection.sendStopMessage();
|
|
this.clock.stop();
|
|
}
|
|
}
|