spessasynth_core 1.0.0

package/spessasynth_core/sequencer/sequencer.js

@@ -0,0 +1,192 @@
+import { _addNewMidiPort, _processEvent } from './worklet_sequencer/process_event.js'
+import { _findFirstEventIndex, _processTick } from './worklet_sequencer/process_tick.js'
+import { loadNewSequence, loadNewSongList, nextSong, previousSong } from './worklet_sequencer/song_control.js'
+import { _playTo, _recalculateStartTime, play, setTimeTicks } from './worklet_sequencer/play.js'
+import { midiControllers } from '../midi_parser/midi_message.js'
+import { SpessaSynthWarn } from '../utils/loggin.js'
+
+class Sequencer
+{
+    /**
+     * @param Synthesizer {Synthesizer}
+     */
+    constructor(Synthesizer)
+    {
+        this.synth = Synthesizer;
+        this.ignoreEvents = false;
+
+        // event's number in this.events
+        /**
+         * @type {number[]}
+         */
+        this.eventIndex = [];
+        this.songIndex = 0;
+
+        // tracks the time that we have already played
+        /**
+         * @type {number}
+         */
+        this.playedTime = 0;
+
+        /**
+         * The (relative) time when the sequencer was paused. If it's not paused then it's undefined.
+         * @type {number}
+         */
+        this.pausedTime = undefined;
+
+        /**
+         * Absolute playback startTime, bases on the synth's time
+         * @type {number}
+         */
+        this.absoluteStartTime = this.currentTime;
+
+        /**
+         * Controls the playback's rate
+         * @type {number}
+         */
+        this._playbackRate = 1;
+
+        /**
+         * Currently playing notes (for pausing and resuming)
+         * @type {{
+         *     midiNote: number,
+         *     channel: number,
+         *     velocity: number
+         * }[]}
+         */
+        this.playingNotes = [];
+
+        // controls if the sequencer loops (defaults to true)
+        this.loop = true;
+
+        /**
+         * the current track data
+         * @type {MIDI}
+         */
+        this.midiData = undefined;
+
+        /**
+         * midi port number for the corresponding track
+         * @type {number[]}
+         */
+        this.midiPorts = [];
+
+        this.midiPortChannelOffset = 0;
+
+        /**
+         * midi port: channel offset
+         * @type {Object<number, number>}
+         */
+        this.midiPortChannelOffsets = {};
+    }
+
+    /**
+     * @param value {number}
+     */
+    set playbackRate(value)
+    {
+        const time = this.currentTime;
+        this._playbackRate = value;
+        this.currentTime = time;
+    }
+
+    get currentTime()
+    {
+        // return the paused time if it's set to something other than undefined
+        if(this.pausedTime)
+        {
+            return this.pausedTime;
+        }
+
+        return (this.synth.currentTime - this.absoluteStartTime) * this._playbackRate;
+    }
+
+    set currentTime(time)
+    {
+        if(time < 0 || time > this.duration || time === 0)
+        {
+            // time is 0
+            this.setTimeTicks(this.midiData.firstNoteOn - 1);
+            return;
+        }
+        this.stop();
+        this.playingNotes = [];
+        this.pausedTime = undefined;
+        const isNotFinished = this._playTo(time);
+        this._recalculateStartTime(time);
+        if(!isNotFinished)
+        {
+            return;
+        }
+        this.play();
+    }
+
+    /**
+     * Pauses the playback
+     */
+    pause()
+    {
+        if(this.paused)
+        {
+            SpessaSynthWarn("Already paused");
+            return;
+        }
+        this.pausedTime = this.currentTime;
+        this.stop();
+    }
+
+    /**
+     * Stops the playback
+     */
+    stop()
+    {
+        this.clearProcessHandler()
+        // disable sustain
+        for (let i = 0; i < 16; i++) {
+            this.synth.controllerChange(i, midiControllers.sustainPedal, 0);
+        }
+        this.synth.stopAllChannels();
+    }
+
+    _resetTimers()
+    {
+        this.playedTime = 0
+        this.eventIndex = Array(this.tracks.length).fill(0);
+    }
+
+    /**
+     * true if paused, false if playing or stopped
+     * @returns {boolean}
+     */
+    get paused()
+    {
+        return this.pausedTime !== undefined;
+    }
+
+    setProcessHandler()
+    {
+        this.synth.processTickCallback = this._processTick.bind(this);
+    }
+
+    clearProcessHandler()
+    {
+        this.synth.processTickCallback = undefined;
+    }
+}
+
+Sequencer.prototype._processEvent = _processEvent;
+Sequencer.prototype._addNewMidiPort = _addNewMidiPort;
+Sequencer.prototype._processTick = _processTick;
+Sequencer.prototype._findFirstEventIndex = _findFirstEventIndex;
+
+Sequencer.prototype.loadNewSequence = loadNewSequence;
+Sequencer.prototype.loadNewSongList = loadNewSongList;
+Sequencer.prototype.nextSong = nextSong;
+Sequencer.prototype.previousSong = previousSong;
+
+Sequencer.prototype.play = play;
+Sequencer.prototype._playTo = _playTo;
+Sequencer.prototype.setTimeTicks = setTimeTicks;
+Sequencer.prototype._recalculateStartTime = _recalculateStartTime;
+
+export { Sequencer }

package/spessasynth_core/sequencer/worklet_sequencer/play.js

@@ -0,0 +1,221 @@
+import { getEvent, messageTypes, midiControllers } from '../../midi_parser/midi_message.js'
+
+
+// an array with preset default values
+const defaultControllerArray = new Int16Array(127);
+// default values
+defaultControllerArray[midiControllers.mainVolume] = 100;
+defaultControllerArray[midiControllers.expressionController] = 127;
+defaultControllerArray[midiControllers.pan] = 64;
+defaultControllerArray[midiControllers.releaseTime] = 64;
+defaultControllerArray[midiControllers.brightness] = 64;
+defaultControllerArray[midiControllers.effects1Depth] = 40;
+
+/**
+ * plays from start to the target time, excluding note messages (to get the synth to the correct state)
+ * @private
+ * @param time {number} in seconds
+ * @param ticks {number} optional MIDI ticks, when given is used instead of time
+ * @returns {boolean} true if the midi file is not finished
+ * @this {Sequencer}
+ */
+export function _playTo(time, ticks = undefined)
+{
+    this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
+    // process every non note message from the start
+    this.synth.resetAllControllers();
+
+    this._resetTimers()
+    /**
+     * save pitch bends here and send them only after
+     * @type {number[]}
+     */
+    const pitchBends = Array(16).fill(8192);
+
+    /**
+     * Save controllers here and send them only after
+     * @type {number[][]}
+     */
+    const savedControllers = [];
+    for (let i = 0; i < 16; i++)
+    {
+        savedControllers.push(Array.from(defaultControllerArray));
+    }
+
+    while(true)
+    {
+        // find next event
+        let trackIndex = this._findFirstEventIndex();
+        let event = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        if(ticks !== undefined)
+        {
+            if(event.ticks >= ticks)
+            {
+                break;
+            }
+        }
+        else
+        {
+            if(this.playedTime >= time)
+            {
+                break;
+            }
+        }
+
+        // skip note ons
+        const info = getEvent(event.messageStatusByte);
+        switch(info.status)
+        {
+            // skip note messages
+            case messageTypes.noteOn:
+            case messageTypes.noteOff:
+                break;
+
+            // skip pitch bend
+            case messageTypes.pitchBend:
+                pitchBends[info.channel] = event.messageData[1] << 7 | event.messageData[0];
+                break;
+
+            case messageTypes.controllerChange:
+                // do not skip data entries
+                const controllerNumber = event.messageData[0];
+                if(
+                    controllerNumber === midiControllers.dataDecrement           ||
+                    controllerNumber === midiControllers.dataEntryMsb            ||
+                    controllerNumber === midiControllers.dataDecrement           ||
+                    controllerNumber === midiControllers.lsbForControl6DataEntry ||
+                    controllerNumber === midiControllers.RPNLsb                  ||
+                    controllerNumber === midiControllers.RPNMsb                  ||
+                    controllerNumber === midiControllers.NRPNLsb                 ||
+                    controllerNumber === midiControllers.NRPNMsb                 ||
+                    controllerNumber === midiControllers.bankSelect              ||
+                    controllerNumber === midiControllers.lsbForControl0BankSelect||
+                    controllerNumber === midiControllers.resetAllControllers
+                )
+                {
+                    this.synth.controllerChange(info.channel, controllerNumber, event.messageData[1]);
+                }
+                else
+                {
+                    // Keep in mind midi ports to determine channel!!
+                    const channel = info.channel + (this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0);
+                    if(savedControllers[channel] === undefined)
+                    {
+                        savedControllers[channel] = Array.from(defaultControllerArray);
+                    }
+                    savedControllers[channel][controllerNumber] = event.messageData[1];
+                }
+                break;
+
+            // midiport: handle it and make sure that the saved controllers table is the same size as synth channels
+            case messageTypes.midiPort:
+                this._processEvent(event, trackIndex);
+                if(this.synth.workletProcessorChannels.length > savedControllers.length)
+                {
+                    while(this.synth.workletProcessorChannels.length > savedControllers.length)
+                    {
+                        savedControllers.push(Array.from(defaultControllerArray));
+                    }
+                }
+                break;
+
+            default:
+                this._processEvent(event, trackIndex);
+                break;
+        }
+
+        this.eventIndex[trackIndex]++;
+        // find next event
+        trackIndex = this._findFirstEventIndex();
+        let nextEvent = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        if(nextEvent === undefined)
+        {
+            this.stop();
+            return false;
+        }
+        this.playedTime += this.oneTickToSeconds * (nextEvent.ticks - event.ticks);
+    }
+
+    // restoring saved controllers
+    // for all synth channels
+    for (let channelNumber = 0; channelNumber < this.synth.workletProcessorChannels.length; channelNumber++) {
+        // restore pitch bends
+        if(pitchBends[channelNumber] !== undefined) {
+            this.synth.pitchWheel(channelNumber, pitchBends[channelNumber] >> 7, pitchBends[channelNumber] & 0x7F);
+        }
+        if(savedControllers[channelNumber] !== undefined)
+        {
+            // every controller that has changed
+            savedControllers[channelNumber].forEach((value, index) => {
+                if(value !== defaultControllerArray[index])
+                {
+                    this.synth.controllerChange(channelNumber, index, value);
+                }
+            })
+        }
+    }
+    return true;
+}
+
+/**
+ * Starts the playback
+ * @param resetTime {boolean} If true, time is set to 0s
+ * @this {Sequencer}
+ */
+export function play(resetTime = false)
+{
+
+    // reset the time if necesarry
+    if(resetTime)
+    {
+        this.currentTime = 0;
+        return;
+    }
+
+    if(this.currentTime >= this.duration)
+    {
+        this.currentTime = 0;
+        return;
+    }
+
+    // unpause if paused
+    if(this.paused)
+    {
+        // adjust the start time
+        this._recalculateStartTime(this.pausedTime)
+        this.pausedTime = undefined;
+    }
+
+    this.playingNotes.forEach(n => {
+        this.synth.noteOn(n.channel, n.midiNote, n.velocity);
+    });
+    this.setProcessHandler();
+}
+
+/**
+ * @this {Sequencer}
+ * @param ticks {number}
+ */
+export function setTimeTicks(ticks)
+{
+    this.stop();
+    this.playingNotes = [];
+    this.pausedTime = undefined;
+    const isNotFinished = this._playTo(0, ticks);
+    this._recalculateStartTime(this.playedTime);
+    if(!isNotFinished)
+    {
+        return;
+    }
+    this.play();
+}
+
+/**
+ * @param time
+ * @private
+ * @this {Sequencer}
+ */
+export function _recalculateStartTime(time)
+{
+    this.absoluteStartTime = this.synth.currentTime - time / this._playbackRate;
+}

package/spessasynth_core/sequencer/worklet_sequencer/process_event.js

@@ -0,0 +1,138 @@
+import { getEvent, messageTypes } from '../../midi_parser/midi_message.js'
+import { consoleColors } from '../../utils/other.js'
+import { readBytesAsUintBigEndian } from '../../utils/byte_functions.js'
+import { SpessaSynthWarn } from '../../utils/loggin.js'
+
+/**
+ * Processes a single event
+ * @param event {MidiMessage}
+ * @param trackIndex {number}
+ * @this {Sequencer}
+ * @private
+ */
+export function _processEvent(event, trackIndex)
+{
+    if(this.ignoreEvents) return;
+    const statusByteData = getEvent(event.messageStatusByte);
+    statusByteData.channel += this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0;
+    // process the event
+    switch (statusByteData.status) {
+        case messageTypes.noteOn:
+            const velocity = event.messageData[1];
+            if(velocity > 0) {
+                this.synth.noteOn(statusByteData.channel, event.messageData[0], velocity);
+                this.playingNotes.push({
+                    midiNote: event.messageData[0],
+                    channel: statusByteData.channel,
+                    velocity: velocity
+                });
+            }
+            else
+            {
+                this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+                this.playingNotes.splice(this.playingNotes.findIndex(n =>
+                    n.midiNote === event.messageData[0] && n.channel === statusByteData.channel), 1);
+            }
+            break;
+
+        case messageTypes.noteOff:
+            this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+            this.playingNotes.splice(this.playingNotes.findIndex(n =>
+                n.midiNote === event.messageData[0] && n.channel === statusByteData.channel), 1);
+            break;
+
+        case messageTypes.setTempo:
+            this.oneTickToSeconds = 60 / (getTempo(event) * this.midiData.timeDivision);
+            if(this.oneTickToSeconds === 0)
+            {
+                this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
+                SpessaSynthWarn("invalid tempo! falling back to 120 BPM");
+            }
+            break;
+
+        case messageTypes.midiPort:
+            const port = event.messageData[0];
+            // assign new 16 channels if the port is not occupied yet
+            if(this.midiPortChannelOffset === 0)
+            {
+                this.midiPortChannelOffset += 16;
+                this.midiPortChannelOffsets[port] = 0;
+            }
+
+            if(this.midiPortChannelOffsets[port] === undefined)
+            {
+                if(this.synth.workletProcessorChannels.length < this.midiPortChannelOffset + 16) {
+                    this._addNewMidiPort();
+                }
+                this.midiPortChannelOffsets[port] = this.midiPortChannelOffset;
+                this.midiPortChannelOffset += 16;
+            }
+
+            this.midiPorts[trackIndex] = port;
+            break;
+
+        case messageTypes.endOfTrack:
+        case messageTypes.midiChannelPrefix:
+        case messageTypes.timeSignature:
+        case messageTypes.songPosition:
+        case messageTypes.activeSensing:
+        case messageTypes.keySignature:
+            break;
+
+        default:
+            SpessaSynthWarn(`%cUnrecognized Event: %c${event.messageStatusByte}%c status byte: %c${Object.keys(messageTypes).find(k => messageTypes[k] === statusByteData.status)}`,
+                consoleColors.warn,
+                consoleColors.unrecognized,
+                consoleColors.warn,
+                consoleColors.value);
+            break;
+
+        case messageTypes.pitchBend:
+            this.synth.pitchWheel(statusByteData.channel, event.messageData[1], event.messageData[0]);
+            break;
+
+        case messageTypes.controllerChange:
+            this.synth.controllerChange(statusByteData.channel, event.messageData[0], event.messageData[1]);
+            break;
+
+        case messageTypes.programChange:
+            this.synth.programChange(statusByteData.channel, event.messageData[0]);
+            break;
+
+        case messageTypes.systemExclusive:
+            this.synth.systemExclusive(event.messageData);
+            break;
+
+        case messageTypes.reset:
+            this.synth.stopAllChannels();
+            this.synth.resetAllControllers();
+            break;
+    }
+}
+
+/**
+ * Adds 16 channels to the synth
+ * @this {Sequencer}
+ * @private
+ */
+export function _addNewMidiPort()
+{
+    for (let i = 0; i < 16; i++) {
+        this.synth.addNewChannel(true);
+        if(i === 9)
+        {
+            this.synth.setDrums(this.synth.workletProcessorChannels.length - 1, true);
+        }
+    }
+}
+
+/**
+ * gets tempo from the midi message
+ * @param event {MidiMessage}
+ * @return {number} the tempo in bpm
+ */
+function getTempo(event)
+{
+    event.messageData.currentIndex = 0;
+    return 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
+}

package/spessasynth_core/sequencer/worklet_sequencer/process_tick.js

@@ -0,0 +1,85 @@
+/**
+ * Processes a single tick
+ * @private
+ * @this {Sequencer}
+ */
+export function _processTick()
+{
+    let current = this.currentTime;
+    while(this.playedTime < current)
+    {
+        // find next event
+        let trackIndex = this._findFirstEventIndex();
+        let event = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        this._processEvent(event, trackIndex);
+
+        this.eventIndex[trackIndex]++;
+
+        // find next event
+        trackIndex = this._findFirstEventIndex();
+        if(this.tracks[trackIndex].length <= this.eventIndex[trackIndex])
+        {
+            // song has ended
+            if(this.loop)
+            {
+                this.setTimeTicks(this.midiData.loop.start);
+                return;
+            }
+            this.eventIndex[trackIndex]--;
+            this.pause(true);
+            if(this.songs.length > 1)
+            {
+                this.nextSong();
+            }
+            return;
+        }
+        let eventNext = this.tracks[trackIndex][this.eventIndex[trackIndex]];
+        this.playedTime += this.oneTickToSeconds * (eventNext.ticks - event.ticks);
+
+        // loop
+        if((this.midiData.loop.end <= event.ticks) && this.loop)
+        {
+            this.setTimeTicks(this.midiData.loop.start);
+            return;
+        }
+        // if song has ended
+        else if(current >= this.duration)
+        {
+            if(this.loop)
+            {
+                this.setTimeTicks(this.midiData.loop.start);
+                return;
+            }
+            this.eventIndex[trackIndex]--;
+            this.pause(true);
+            if(this.songs.length > 1)
+            {
+                this.nextSong();
+            }
+            return;
+        }
+    }
+}
+
+
+/**
+ * @returns {number} the index of the first to the current played time
+ * @this {Sequencer}
+ */
+export function _findFirstEventIndex()
+{
+    let index = 0;
+    let ticks = Infinity;
+    this.tracks.forEach((track, i) => {
+        if(this.eventIndex[i] >= track.length)
+        {
+            return;
+        }
+        if(track[this.eventIndex[i]].ticks < ticks)
+        {
+            index = i;
+            ticks = track[this.eventIndex[i]].ticks;
+        }
+    });
+    return index;
+}