spessasynth_lib 0.0.1

package/package/midi_parser/used_keys_loaded.js

@@ -0,0 +1,172 @@
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from '../utils/loggin.js'
+import { consoleColors } from '../utils/other.js'
+import { DEFAULT_PERCUSSION } from '../synthetizer/synthetizer.js'
+import { messageTypes, midiControllers } from './midi_message.js'
+
+/**
+ * @param mid {MIDI}
+ * @param soundfont {SoundFont2}
+ */
+export function getUsedProgramsAndKeys(mid, soundfont)
+{
+    SpessaSynthGroupCollapsed("%cSearching for all used programs and keys...",
+        consoleColors.info);
+    // find every bank:program combo and every key:velocity for each. Make sure to care about ports and drums
+    const channelsAmount = 16 +  Math.max.apply(undefined, mid.midiPorts) * 16;
+    /**
+     *
+     * @type {{program: number, bank: number, drums: boolean, string: string}[]}
+     */
+    const channelPresets = [];
+    for (let i = 0; i < channelsAmount; i++) {
+        const bank = i % 16 === DEFAULT_PERCUSSION ? 128 : 0;
+        channelPresets.push({
+            program: 0,
+            bank: bank,
+            drums: i % 16 === DEFAULT_PERCUSSION, // drums appear on 9 every 16 channels,
+            string: `${bank}:0`
+        });
+    }
+
+    function updateString(ch)
+    {
+        // check if this exists in the soundfont
+        let exists = soundfont.getPreset(ch.bank, ch.program);
+        if(exists.bank !== ch.bank && mid.embeddedSoundFont)
+        {
+            // maybe it doesn't exists becase RMIDI has a bank shift?
+            exists = soundfont.getPreset(ch.bank - 1, ch.program);
+        }
+        ch.bank = exists.bank;
+        ch.program = exists.program;
+        ch.string = ch.bank + ":" + ch.program;
+        if(!usedProgramsAndKeys[ch.string])
+        {
+            SpessaSynthInfo(`%cDetected a new preset: %c${ch.string}`,
+                consoleColors.info,
+                consoleColors.recognized);
+            usedProgramsAndKeys[ch.string] = new Set();
+        }
+    }
+    /**
+     * find all programs used and key-velocity combos in them
+     * bank:program each has a set of midiNote-velocity
+     * @type {Object<string, Set<string>>}
+     */
+    const usedProgramsAndKeys = {};
+    // check for xg
+    let system = "gs";
+    mid.tracks.forEach((t, trackNum) => {
+        const portOffset = mid.midiPorts[trackNum] * 16;
+        for(const event of t)
+        {
+            const status = event.messageStatusByte & 0xF0;
+            if(
+                status !== messageTypes.noteOn &&
+                status !== messageTypes.controllerChange &&
+                status !== messageTypes.programChange &&
+                status !== messageTypes.systemExclusive
+            )
+            {
+                continue;
+            }
+            const channel = (event.messageStatusByte & 0xF) + portOffset;
+            let ch = channelPresets[channel];
+            switch(status)
+            {
+                case messageTypes.programChange:
+                    ch.program = event.messageData[0];
+                    updateString(ch);
+                    break;
+
+                case messageTypes.controllerChange:
+                    if(event.messageData[0] !== midiControllers.bankSelect)
+                    {
+                        continue;
+                    }
+                    if(system === "gs" && ch.drums)
+                    {
+                        continue;
+                    }
+                    const bank = event.messageData[1];
+                    if(system === "xg")
+                    {
+                        const drumsBool = bank === 120 || bank === 126 || bank === 127;
+                        if(drumsBool !== ch.drums)
+                        {
+                            // drum change is a program change
+                            ch.drums = drumsBool;
+                            ch.bank = ch.drums ? 128 : bank;
+                            updateString(ch);
+                        }
+                        else
+                        {
+                            ch.bank = ch.drums ? 128 : bank;
+                        }
+                        continue;
+                    }
+                    channelPresets[channel].bank = bank;
+                    // do not update the data, bank change doesnt change the preset
+                    break;
+
+                case messageTypes.noteOn:
+                    if(event.messageData[1] === 0)
+                    {
+                        // that's a note off
+                        continue;
+                    }
+                    if(!usedProgramsAndKeys[ch.string])
+                    {
+                        usedProgramsAndKeys[ch.string] = new Set();
+                    }
+                    usedProgramsAndKeys[ch.string].add(`${event.messageData[0]}-${event.messageData[1]}`);
+                    break;
+
+                case messageTypes.systemExclusive:
+                    // check for drum sysex
+                    if(
+                        event.messageData[0] !== 0x41 || // roland
+                        event.messageData[2] !== 0x42 || // GS
+                        event.messageData[3] !== 0x12 || // GS
+                        event.messageData[4] !== 0x40 || // system parameter
+                        (event.messageData[5] & 0x10 ) === 0 || // part parameter
+                        event.messageData[6] !== 0x15 // drum pars
+
+                    )
+                    {
+                        // check for XG
+                        if(
+                            event.messageData[0] === 0x43 && // yamaha
+                            event.messageData[2] === 0x4C && // sXG ON
+                            event.messageData[5] === 0x7E &&
+                            event.messageData[6] === 0x00
+                        )
+                        {
+                            system = "xg";
+                        }
+                        continue;
+                    }
+                    const sysexChannel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][event.messageData[5] & 0x0F] + portOffset;
+                    const isDrum = !!(event.messageData[7] > 0 && event.messageData[5] >> 4);
+                    ch = channelPresets[sysexChannel];
+                    ch.drums = isDrum;
+                    ch.bank = isDrum ? 128 : 0;
+                    updateString(ch);
+                    break;
+
+            }
+        }
+    });
+    for(const key of Object.keys(usedProgramsAndKeys))
+    {
+        if(usedProgramsAndKeys[key].size === 0)
+        {
+            SpessaSynthInfo(`%cDetected change but no keys for %c${key}`,
+                consoleColors.info,
+                consoleColors.value)
+            delete usedProgramsAndKeys[key];
+        }
+    }
+    SpessaSynthGroupEnd();
+    return usedProgramsAndKeys;
+}

package/package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "spessasynth_lib",
+  "version": "3.9.12",
+  "description": "No compromise SoundFont and MIDI library and player",
+  "browser": "index.js",
+  "types": "@types/index.d.ts",
+  "type": "module",
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/spessasus/SpessaSynth.git"
+  },
+  "keywords": [
+    "soundfont",
+    "synthesizer",
+    "synth",
+    "sf2",
+    "sf3",
+    "midi",
+    "midi-player",
+    "web-audio-api",
+    "web-midi-api",
+    "player",
+    "soundfont2",
+    "soundfont3"
+  ],
+  "author": {
+    "name": "spessasus",
+    "email": "spesekspesek@gmail.com",
+    "url": "https://github.com/spessasus"
+  },
+  "license": "(MIT AND Apache-2.0)",
+  "bugs": {
+    "url": "https://github.com/spessasus/SpessaSynth/issues",
+    "email": "spesekspesek@gmail.com"
+  },
+  "homepage": "https://github.com/spessasus/SpessaSynth#readme"
+}

package/package/sequencer/README.md

@@ -0,0 +1,23 @@
+## This is the sequencer's folder.
+The code here is responsible for playing back the parsed MIDI sequence with the synthesizer.
+
+### Message protocol:
+#### Message structure
+```js
+const message = {
+    messageType: number, // WorkletSequencerMessageType
+    messageData: any     // any
+}
+```
+
+#### To worklet
+Sequencer uses `Synthetizer`'s `post` method to post a message with `messageData` set to `workletMessageType.sequencerSpecific`.
+The `messageData` is set to the sequencer's message.
+
+#### From worklet
+`WorkletSequencer` uses `SpessaSynthProcessor`'s post to send a message with `messageData` set to `returnMessageType.sequencerSpecific`.
+The `messageData` is set to the sequencer's return message.
+
+
+### Process tick
+`processTick` is called every time the `process` method is called via `SpessaSynthProcessor.processTickCallback`.

package/package/sequencer/sequencer.js

@@ -0,0 +1,439 @@
+import { MIDI } from '../midi_parser/midi_loader.js'
+import { Synthetizer } from '../synthetizer/synthetizer.js'
+import { messageTypes } from '../midi_parser/midi_message.js'
+import { workletMessageType } from '../synthetizer/worklet_system/message_protocol/worklet_message.js'
+import {
+    WorkletSequencerMessageType,
+    WorkletSequencerReturnMessageType,
+} from './worklet_sequencer/sequencer_message.js'
+import { SpessaSynthWarn } from '../utils/loggin.js'
+import { DUMMY_MIDI_DATA, MidiData } from '../midi_parser/midi_data.js'
+
+/**
+ * sequencer.js
+ * purpose: plays back the midi file decoded by midi_loader.js, including support for multi-channel midis (adding channels when more than 1 midi port is detected)
+ */
+
+/**
+ * @typedef MidFile {Object}
+ * @property {ArrayBuffer} binary - the binary data of the file.
+ * @property {string|undefined} altName - the alternative name for the file
+ */
+
+/**
+ * @typedef {MIDI|MidFile} MIDIFile
+ */
+
+export class Sequencer
+{
+    /**
+     * Creates a new Midi sequencer for playing back MIDI files
+     * @param midiBinaries {MIDIFile[]} List of the buffers of the MIDI files
+     * @param synth {Synthetizer} synth to send events to
+     */
+    constructor(midiBinaries, synth)
+    {
+        this.ignoreEvents = false;
+        this.synth = synth;
+        this.highResTimeOffset = 0;
+
+        /**
+         * Absolute playback startTime, bases on the synth's time
+         * @type {number}
+         */
+        this.absoluteStartTime = this.synth.currentTime;
+
+        /**
+         * @type {function(MIDI)}
+         * @private
+         */
+        this._getMIDIResolve = undefined;
+
+        /**
+         * Controls the playback's rate
+         * @type {number}
+         */
+        this._playbackRate = 1;
+
+        this.songIndex = 0;
+
+        this._loop = true;
+
+        /**
+         * Indicates whether the sequencer has finished playing a sequence
+         * @type {boolean}
+         */
+        this.isFinished = false;
+
+        /**
+         * The current sequence's length, in seconds
+         * @type {number}
+         */
+        this.duration = 0;
+
+        this.synth.sequencerCallbackFunction = this._handleMessage.bind(this);
+
+        this.loadNewSongList(midiBinaries);
+
+        window.addEventListener("beforeunload", this.resetMIDIOut.bind(this))
+    }
+
+    resetMIDIOut()
+    {
+        if(!this.MIDIout)
+        {
+            return;
+        }
+        for (let i = 0; i < 16; i++)
+        {
+            this.MIDIout.send([messageTypes.controllerChange | i, 120, 0]); // all notes off
+            this.MIDIout.send([messageTypes.controllerChange | i, 123, 0]); // all sound off
+        }
+        this.MIDIout.send([messageTypes.reset]); // reset
+    }
+
+    set loop(value)
+    {
+        this._sendMessage(WorkletSequencerMessageType.setLoop, value);
+        this._loop = value;
+    }
+
+    get loop()
+    {
+        return this._loop;
+    }
+
+    /**
+     * @param messageType {WorkletSequencerMessageType}
+     * @param messageData {any}
+     * @private
+     */
+    _sendMessage(messageType, messageData = undefined)
+    {
+        this.synth.post({
+            channelNumber: -1,
+            messageType: workletMessageType.sequencerSpecific,
+            messageData: {
+                messageType: messageType,
+                messageData: messageData
+            }
+        });
+    }
+
+    /**
+     * Executes when MIDI parsing has an error.
+     * @type {function(string)}
+     */
+    onError;
+
+    /**
+     * @param {WorkletSequencerReturnMessageType} messageType
+     * @param {any} messageData
+     * @private
+     */
+    _handleMessage(messageType, messageData)
+    {
+        if(this.ignoreEvents)
+        {
+            return;
+        }
+        switch (messageType)
+        {
+            default:
+                break;
+
+            case WorkletSequencerReturnMessageType.midiEvent:
+                /**
+                 * @type {number[]}
+                 */
+                let midiEventData = messageData;
+                if (this.MIDIout) {
+                    if (midiEventData[0] >= 0x80) {
+                        this.MIDIout.send(midiEventData);
+                        return;
+                    }
+                }
+                break;
+
+            case WorkletSequencerReturnMessageType.songChange:
+                /**
+                 * messageData is expected to be {MidiData}
+                 * @type {MidiData}
+                 */
+                let songChangeData = messageData[0];
+                this.songIndex = messageData[1];
+                this.midiData = songChangeData;
+                this.absoluteStartTime = 0;
+                this.duration = this.midiData.duration;
+                Object.entries(this.onSongChange).forEach((callback) => callback[1](songChangeData));
+                this.unpause();
+                break;
+
+            case WorkletSequencerReturnMessageType.textEvent:
+                /**
+                 * @type {[Uint8Array, number]}
+                 */
+                let textEventData = messageData;
+                if (this.onTextEvent) {
+                    this.onTextEvent(textEventData[0], textEventData[1]);
+                }
+                break;
+
+            case WorkletSequencerReturnMessageType.timeChange:
+                // message data is absolute time
+                const time = this.synth.currentTime - messageData;
+                Object.entries(this.onTimeChange).forEach((callback) => callback[1](time));
+                this.unpause();
+                this._recalculateStartTime(time);
+                break;
+
+            case WorkletSequencerReturnMessageType.pause:
+                this.pausedTime = this.currentTime;
+                this.isFinished = messageData;
+                break;
+
+            case WorkletSequencerReturnMessageType.midiError:
+                if(this.onError)
+                {
+                    this.onError(messageData);
+                }
+                else
+                {
+                    throw new Error(messageData);
+                }
+                return;
+
+            case WorkletSequencerReturnMessageType.getMIDI:
+                if(this._getMIDIResolve)
+                {
+                    this._getMIDIResolve(messageData);
+                }
+        }
+    }
+
+    /**
+     * @param value {number}
+     */
+    set playbackRate(value)
+    {
+        this._sendMessage(WorkletSequencerMessageType.setPlaybackRate, value);
+        this.highResTimeOffset *= (value / this._playbackRate);
+        this._playbackRate = value;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get playbackRate()
+    {
+        return this._playbackRate;
+    }
+
+    /**
+     * Adds a new event that gets called when the song changes
+     * @param callback {function(MidiData)}
+     * @param id {string} must be unique
+     */
+    addOnSongChangeEvent(callback, id)
+    {
+        this.onSongChange[id] = callback;
+        callback(this.midiData);
+    }
+
+    /**
+     * Adds a new event that gets called when the time changes
+     * @param callback {function(number)} the new time, in seconds
+     * @param id {string} must be unique
+     */
+    addOnTimeChangeEvent(callback, id)
+    {
+        this.onTimeChange[id] = callback;
+    }
+
+    /**
+     * @returns {Promise<MIDI>}
+     */
+    async getMIDI()
+    {
+        return new Promise(resolve => {
+            this._getMIDIResolve = resolve;
+            this._sendMessage(WorkletSequencerMessageType.getMIDI, undefined);
+        });
+    }
+
+    /**
+     * @param midiBuffers {MIDIFile[]}
+     */
+    loadNewSongList(midiBuffers)
+    {
+        this.pause();
+        // add some dummy data
+        this.midiData = DUMMY_MIDI_DATA;
+        this.duration = 99999;
+        this._sendMessage(WorkletSequencerMessageType.loadNewSongList, midiBuffers);
+        this.songIndex = 0;
+        this.songsAmount = midiBuffers.length;
+        if(this.songsAmount > 1)
+        {
+            this.loop = false;
+        }
+    }
+
+    nextSong()
+    {
+        this._sendMessage(WorkletSequencerMessageType.changeSong, true);
+    }
+
+    previousSong()
+    {
+        this._sendMessage(WorkletSequencerMessageType.changeSong, false);
+    }
+
+    /**
+     * @returns {number} Current playback time, in seconds
+     */
+    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;
+    }
+
+    /**
+     * @param time
+     * @private
+     */
+    _recalculateStartTime(time)
+    {
+        this.absoluteStartTime = this.synth.currentTime - time / this._playbackRate;
+        this.highResTimeOffset = (this.synth.currentTime - (performance.now() / 1000)) * this._playbackRate;
+    }
+
+    /**
+     * Use for visualization as it's not affected by the audioContext stutter
+     * @returns {number}
+     */
+    get currentHighResolutionTime() {
+        if (this.pausedTime) {
+            return this.pausedTime;
+        }
+        const highResTimeOffset = this.highResTimeOffset;
+        const absoluteStartTime = this.absoluteStartTime;
+
+        // sync performance.now to current time
+        const performanceElapsedTime = ((performance.now() / 1000) - absoluteStartTime) * this._playbackRate;
+
+        let currentPerformanceTime = highResTimeOffset + performanceElapsedTime;
+        const currentAudioTime = this.currentTime;
+
+        const smoothingFactor = 0.01 * this._playbackRate;
+
+        // diff times smoothing factor
+        const timeDifference = currentAudioTime - currentPerformanceTime;
+        this.highResTimeOffset += timeDifference * smoothingFactor;
+
+        // return a smoothed performance time
+        currentPerformanceTime = this.highResTimeOffset + performanceElapsedTime;
+        return currentPerformanceTime;
+    }
+
+
+    set currentTime(time)
+    {
+        this.unpause()
+        this._sendMessage(WorkletSequencerMessageType.setTime, time);
+    }
+
+    /**
+     * @param output {MIDIOutput}
+     */
+    connectMidiOutput(output)
+    {
+        this.resetMIDIOut();
+        this.MIDIout = output;
+        this._sendMessage(WorkletSequencerMessageType.changeMIDIMessageSending, output !== undefined);
+        this.currentTime -= 0.1;
+    }
+
+    /**
+     * Pauses the playback
+     */
+    pause()
+    {
+        if(this.paused)
+        {
+            SpessaSynthWarn("Already paused");
+            return;
+        }
+        this.pausedTime = this.currentTime;
+        this._sendMessage(WorkletSequencerMessageType.pause);
+    }
+
+    unpause()
+    {
+        this.pausedTime = undefined;
+        this.isFinished = false;
+    }
+
+    /**
+     * true if paused, false if playing or stopped
+     * @returns {boolean}
+     */
+    get paused()
+    {
+        return this.pausedTime !== undefined;
+    }
+
+    /**
+     * Starts the playback
+     * @param resetTime {boolean} If true, time is set to 0s
+     */
+    play(resetTime = false)
+    {
+        if(this.isFinished)
+        {
+            resetTime = true;
+        }
+        this._recalculateStartTime(this.pausedTime || 0);
+        this.unpause()
+        this._sendMessage(WorkletSequencerMessageType.play, resetTime);
+    }
+
+    /**
+     * Stops the playback
+     */
+    stop()
+    {
+        this._sendMessage(WorkletSequencerMessageType.stop);
+    }
+
+    /**
+     * The sequence's data, except for the track data.
+     *  @type {MidiData}
+     */
+    midiData;
+
+    /**
+     * @type {Object<string, function(MidiData)>}
+     * @private
+     */
+    onSongChange = {};
+
+    /**
+     * Fires on text event
+     * @param data {Uint8Array} the data text
+     * @param type {number} the status byte of the message (the meta status byte)
+     */
+    onTextEvent;
+
+    /**
+     * Fires when CurrentTime changes
+     * @type {Object<string, function(number)>} the time that was changed to
+     * @private
+     */
+    onTimeChange = {};
+}