spessasynth_lib 0.0.1

package/package/sequencer/worklet_sequencer/events.js

@@ -0,0 +1,92 @@
+import { returnMessageType } from '../../synthetizer/worklet_system/message_protocol/worklet_message.js'
+import { WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from './sequencer_message.js'
+
+/**
+ * @param messageType {WorkletSequencerMessageType}
+ * @param messageData {any}
+ * @this {WorkletSequencer}
+ */
+export function processMessage(messageType, messageData)
+{
+    switch (messageType)
+    {
+        default:
+            break;
+
+        case WorkletSequencerMessageType.loadNewSongList:
+            this.loadNewSongList(messageData);
+            break;
+
+        case WorkletSequencerMessageType.pause:
+            this.pause();
+            break;
+
+        case WorkletSequencerMessageType.play:
+            this.play(messageData);
+            break;
+
+        case WorkletSequencerMessageType.stop:
+            this.stop();
+            break;
+
+        case WorkletSequencerMessageType.setTime:
+            this.currentTime = messageData;
+            break;
+
+        case WorkletSequencerMessageType.changeMIDIMessageSending:
+            this.sendMIDIMessages = messageData;
+            break;
+
+        case WorkletSequencerMessageType.setPlaybackRate:
+            this.playbackRate = messageData;
+            break;
+
+        case WorkletSequencerMessageType.setLoop:
+            this.loop = messageData;
+            break;
+
+        case WorkletSequencerMessageType.changeSong:
+            if (messageData)
+            {
+                this.nextSong();
+            }
+            else
+            {
+                this.previousSong();
+            }
+            break;
+
+        case WorkletSequencerMessageType.getMIDI:
+            this.post(WorkletSequencerReturnMessageType.getMIDI, this.midiData);
+    }
+}
+
+/**
+ *
+ * @param messageType {WorkletSequencerReturnMessageType}
+ * @param messageData {any}
+ * @this {WorkletSequencer}
+ */
+export function post(messageType, messageData = undefined)
+{
+    if(!this.synth.enableEventSystem)
+    {
+        return;
+    }
+    this.synth.post({
+        messageType: returnMessageType.sequencerSpecific,
+        messageData: {
+            messageType: messageType,
+            messageData: messageData
+        }
+    })
+}
+
+/**
+ * @param message {number[]}
+ * @this {WorkletSequencer}
+ */
+export function sendMIDIMessage(message)
+{
+    this.post(WorkletSequencerReturnMessageType.midiEvent, message);
+}

package/package/sequencer/worklet_sequencer/play.js

@@ -0,0 +1,309 @@
+import { getEvent, messageTypes, midiControllers } from '../../midi_parser/midi_message.js'
+import { WorkletSequencerReturnMessageType } from './sequencer_message.js'
+import { MIDI_CHANNEL_COUNT } from '../../synthetizer/synthetizer.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 {WorkletSequencer}
+ */
+export function _playTo(time, ticks = undefined)
+{
+    this.oneTickToSeconds = 60 / (120 * this.midiData.timeDivision);
+    // reset
+    this.synth.resetAllControllers();
+    if(this.sendMIDIMessages)
+    {
+        this.sendMIDIMessage([messageTypes.reset]);
+        for(let ch = 0; ch < MIDI_CHANNEL_COUNT; ch++)
+        {
+            this.sendMIDIMessage([messageTypes.controllerChange | ch, midiControllers.resetAllControllers, 0]);
+        }
+    }
+    this._resetTimers()
+
+    const channelsToSave = this.synth.workletProcessorChannels.length;
+    /**
+     * save pitch bends here and send them only after
+     * @type {number[]}
+     */
+    const pitchBends = Array(channelsToSave).fill(8192);
+
+    /**
+     * Save programs here and send them only after
+     * @type {number[]}
+     */
+    const programs = Array(channelsToSave).fill(-1  );
+
+    /**
+     * Save controllers here and send them only after
+     * @type {number[][]}
+     */
+    const savedControllers = [];
+    for (let i = 0; i < channelsToSave; 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);
+        // Keep in mind midi ports to determine channel!!
+        const channel = info.channel + (this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0);
+        switch(info.status)
+        {
+            // skip note messages
+            case messageTypes.noteOn:
+            case messageTypes.noteOff:
+            case messageTypes.keySignature:
+                break;
+
+            // skip pitch bend
+            case messageTypes.pitchBend:
+                pitchBends[channel] = event.messageData[1] << 7 | event.messageData[0];
+                break;
+
+            case messageTypes.programChange:
+                programs[channel] = event.messageData[0];
+                break;
+
+            case messageTypes.controllerChange:
+                // do not skip data entries
+                const controllerNumber = event.messageData[0];
+                if(
+                    controllerNumber === midiControllers.dataDecrement           ||
+                    controllerNumber === midiControllers.dataIncrement           ||
+                    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
+                )
+                {
+                    if(this.sendMIDIMessages)
+                    {
+                        this.sendMIDIMessage([messageTypes.controllerChange | (channel % 16), controllerNumber, event.messageData[1]])
+                    }
+                    else
+                    {
+                        let ccV = event.messageData[1];
+                        if(this.midiData.embeddedSoundFont !== undefined && controllerNumber === midiControllers.bankSelect)
+                        {
+                            // special case if the RMID is embedded: subtract 1 from bank. See wiki About-RMIDI
+                            ccV--;
+                        }
+                        this.synth.controllerChange(channel, controllerNumber, ccV);
+                    }
+                }
+                else
+                {
+                    if(savedControllers[channel] === undefined)
+                    {
+                        savedControllers[channel] = Array.from(defaultControllerArray);
+                    }
+                    savedControllers[channel][controllerNumber] = event.messageData[1];
+                }
+                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
+    if(this.sendMIDIMessages)
+    {
+        // for all 16 channels
+        for (let channelNumber = 0; channelNumber < channelsToSave; channelNumber++) {
+            // send saved pitch bend
+            this.sendMIDIMessage([messageTypes.pitchBend | (channelNumber % 16), pitchBends[channelNumber] & 0x7F, pitchBends[channelNumber] >> 7]);
+
+            // every controller that has changed
+            savedControllers[channelNumber].forEach((value, index) => {
+                if(value !== defaultControllerArray[index])
+                {
+                    this.sendMIDIMessage([messageTypes.controllerChange | (channelNumber % 16), index, value])
+                }
+            });
+
+            // restore programs
+            if(programs[channelNumber] !== 0)
+            {
+                this.sendMIDIMessage([messageTypes.programChange | (channelNumber % 16), programs[channelNumber]]);
+            }
+        }
+    }
+    else
+    {
+        // for all synth channels
+        for (let channelNumber = 0; channelNumber < channelsToSave; 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);
+                    }
+                })
+            }
+            // restore programs
+            if(programs[channelNumber] !== -1)
+            {
+                this.synth.programChange(channelNumber, programs[channelNumber]);
+            }
+        }
+    }
+    return true;
+}
+
+/**
+ * Starts the playback
+ * @param resetTime {boolean} If true, time is set to 0s
+ * @this {WorkletSequencer}
+ */
+export function play(resetTime = false)
+{
+    if(this.midiData === undefined)
+    {
+        return;
+    }
+
+    // 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;
+    }
+    if(!this.sendMIDIMessages)
+    {
+        const time = this.currentTime;
+        this.playingNotes.forEach(n => {
+            const timeOffset = n.startTime - time;
+            this.synth.noteOn(n.channel, n.midiNote, n.velocity, false, true, currentTime + timeOffset);
+        });
+    }
+    this.setProcessHandler();
+}
+
+/**
+ * Coverts ticks to time in seconds
+ * @param changes {{tempo: number, ticks: number}[]}
+ * @param ticks {number}
+ * @param division {number}
+ * @returns {number}
+ */
+export function ticksToSeconds(changes, ticks, division)
+{
+    if (ticks <= 0) {
+        return 0;
+    }
+
+    // find the last tempo change that has occured
+    let tempo = changes.find(v => v.ticks < ticks);
+
+    let timeSinceLastTempo = ticks - tempo.ticks;
+    return ticksToSeconds(changes, ticks - timeSinceLastTempo, division) + (timeSinceLastTempo * 60) / (tempo.tempo * division);
+}
+
+/**
+ * @this {WorkletSequencer}
+ * @param ticks {number}
+ */
+export function setTimeTicks(ticks)
+{
+    this.stop();
+    this.playingNotes = [];
+    this.pausedTime = undefined;
+    this.post(
+        WorkletSequencerReturnMessageType.timeChange,
+        currentTime - ticksToSeconds(this.midiData.tempoChanges, ticks, this.midiData.timeDivision)
+    );
+    const isNotFinished = this._playTo(0, ticks);
+    this._recalculateStartTime(this.playedTime);
+    if(!isNotFinished)
+    {
+        return;
+    }
+    this.play();
+}
+
+/**
+ * @param time
+ * @private
+ * @this {WorkletSequencer}
+ */
+export function _recalculateStartTime(time)
+{
+    this.absoluteStartTime = currentTime - time / this._playbackRate;
+}

package/package/sequencer/worklet_sequencer/process_event.js

@@ -0,0 +1,167 @@
+import { getEvent, messageTypes, midiControllers } from '../../midi_parser/midi_message.js'
+import { WorkletSequencerReturnMessageType } from './sequencer_message.js'
+import { consoleColors } from '../../utils/other.js'
+import { SpessaSynthWarn } from '../../utils/loggin.js'
+import { readBytesAsUintBigEndian } from '../../utils/byte_functions/big_endian.js'
+import { DEFAULT_PERCUSSION } from '../../synthetizer/synthetizer.js'
+
+/**
+ * Processes a single event
+ * @param event {MidiMessage}
+ * @param trackIndex {number}
+ * @this {WorkletSequencer}
+ * @private
+ */
+export function _processEvent(event, trackIndex)
+{
+    if(this.ignoreEvents) return;
+    if(this.sendMIDIMessages)
+    {
+        if(event.messageStatusByte >= 0x80)
+        {
+            this.sendMIDIMessage([event.messageStatusByte, ...event.messageData]);
+            return;
+        }
+    }
+    const statusByteData = getEvent(event.messageStatusByte);
+    const offset = this.midiPortChannelOffsets[this.midiPorts[trackIndex]] || 0
+    statusByteData.channel += offset;
+    // 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,
+                    startTime: this.currentTime
+                });
+            }
+            else
+            {
+                this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+                const toDelete = this.playingNotes.findIndex(n =>
+                    n.midiNote === event.messageData[0] && n.channel === statusByteData.channel);
+                if(toDelete !== -1)
+                {
+                    this.playingNotes.splice(toDelete, 1);
+                }
+            }
+            break;
+
+        case messageTypes.noteOff:
+            this.synth.noteOff(statusByteData.channel, event.messageData[0]);
+            const toDelete = this.playingNotes.findIndex(n =>
+                n.midiNote === event.messageData[0] && n.channel === statusByteData.channel);
+            if(toDelete !== -1)
+            {
+                this.playingNotes.splice(toDelete, 1);
+            }
+            break;
+
+        case messageTypes.pitchBend:
+            this.synth.pitchWheel(statusByteData.channel, event.messageData[1], event.messageData[0]);
+            break;
+
+        case messageTypes.controllerChange:
+            // special case if the RMID is embedded: subtract 1 from bank. See wiki About-RMIDI
+            let v = event.messageData[1];
+            if(this.midiData.embeddedSoundFont && event.messageData[0] === midiControllers.bankSelect)
+            {
+                v--;
+            }
+            this.synth.controllerChange(statusByteData.channel, event.messageData[0], v);
+            break;
+
+        case messageTypes.programChange:
+            this.synth.programChange(statusByteData.channel, event.messageData[0]);
+            break;
+
+        case messageTypes.polyPressure:
+            this.synth.polyPressure(statusByteData.channel, event.messageData[0], event.messageData[1]);
+            break;
+
+        case messageTypes.channelPressure:
+            this.synth.channelPressure(statusByteData.channel, event.messageData[0]);
+            break;
+
+        case messageTypes.systemExclusive:
+            this.synth.systemExclusive(event.messageData, offset);
+            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;
+
+        // recongized but ignored
+        case messageTypes.timeSignature:
+        case messageTypes.endOfTrack:
+        case messageTypes.midiChannelPrefix:
+        case messageTypes.songPosition:
+        case messageTypes.activeSensing:
+        case messageTypes.keySignature:
+            break;
+
+        case messageTypes.text:
+        case messageTypes.lyric:
+        case messageTypes.copyright:
+        case messageTypes.trackName:
+        case messageTypes.marker:
+        case messageTypes.cuePoint:
+        case messageTypes.instrumentName:
+            this.post(WorkletSequencerReturnMessageType.textEvent, [event.messageData, statusByteData.status])
+            break;
+
+        case messageTypes.midiPort:
+            this.assignMIDIPort(trackIndex, event.messageData[0]);
+            break;
+
+        case messageTypes.reset:
+            this.synth.stopAllChannels();
+            this.synth.resetAllControllers();
+            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;
+    }
+}
+
+/**
+ * Adds 16 channels to the synth
+ * @this {WorkletSequencer}
+ * @private
+ */
+export function _addNewMidiPort()
+{
+    for (let i = 0; i < 16; i++) {
+        this.synth.createWorkletChannel(true);
+        if(i === DEFAULT_PERCUSSION)
+        {
+            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/package/sequencer/worklet_sequencer/process_tick.js

@@ -0,0 +1,85 @@
+/**
+ * Processes a single tick
+ * @private
+ * @this {WorkletSequencer}
+ */
+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 {WorkletSequencer}
+ */
+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;
+}

package/package/sequencer/worklet_sequencer/sequencer_message.js

@@ -0,0 +1,39 @@
+/**
+ * @enum {number}
+ * @property {number} loadNewSongList          - 0 -> [...song<MIDI>]
+ * @property {number} pause                    - 1 -> isFinished<boolean>
+ * @property {number} stop                     - 2 -> (no data)
+ * @property {number} play                     - 3 -> resetTime<boolean>
+ * @property {number} setTime                  - 4 -> time<number>
+ * @property {number} changeMIDIMessageSending - 5 -> sendMIDIMessages<boolean>
+ * @property {number} setPlaybackRate          - 6 -> playbackRate<number>
+ * @property {number} setLoop                  - 7 -> loop<boolean>
+ * @property {number} changeSong               - 8 -> goForwards<boolean> if true, next song, if false, previous
+ * @property {number} getMIDI                  - 9 -> (no data)
+ */
+export const WorkletSequencerMessageType = {
+    loadNewSongList: 0,
+    pause: 1,
+    stop: 2,
+    play: 3,
+    setTime: 4,
+    changeMIDIMessageSending: 5,
+    setPlaybackRate: 6,
+    setLoop: 7,
+    changeSong: 8,
+    getMIDI: 9
+}
+
+/**
+ *
+ * @enum {number}
+ */
+export const WorkletSequencerReturnMessageType = {
+    midiEvent: 0,               // [...midiEventBytes<number>]
+    songChange: 1,              // [midiData<MidiData>, songIndex<number>]
+    textEvent: 2,               // [messageData<number[]>, statusByte<number]
+    timeChange: 3,              // newAbsoluteTime<number>
+    pause: 4,                   // no data
+    getMIDI: 5,                 // midiData<MIDI>
+    midiError: 6,               // errorMSG<string>
+}