spessasynth_lib 3.26.0 → 3.26.1

package/synthetizer/audio_effects/reverb.js

@@ -0,0 +1,35 @@
+import { reverbBufferBinary } from "./reverb_as_binary.js";
+
+/**
+ * Creates a reverb processor
+ * @param context {BaseAudioContext}
+ * @param reverbBuffer {AudioBuffer}
+ * @returns {{conv: ConvolverNode, promise: Promise<AudioBuffer>}}
+ */
+export function getReverbProcessor(context, reverbBuffer = undefined)
+{
+    let solve;
+    /**
+     * @type {Promise<AudioBuffer>}
+     */
+    let promise = new Promise(r => solve = r);
+    const convolver = context.createConvolver();
+    if (reverbBuffer)
+    {
+        convolver.buffer = reverbBuffer;
+        solve();
+    }
+    else
+    {
+        // decode
+        promise = context.decodeAudioData(reverbBufferBinary.slice(0));
+        promise.then(b =>
+        {
+            convolver.buffer = b;
+        });
+    }
+    return {
+        conv: convolver,
+        promise: promise
+    };
+}

package/synthetizer/audio_effects/reverb_as_binary.js

@@ -0,0 +1,18 @@
+import { rbCompressed } from "./rb_compressed.min.js";
+import { SpessaSynthCoreUtils } from "spessasynth_core";
+
+// convert the base64 string to array buffer
+const binaryString = atob(rbCompressed);
+const binary = new Uint8Array(binaryString.length);
+for (let i = 0; i < binaryString.length; i++)
+{
+    binary[i] = binaryString.charCodeAt(i);
+}
+
+
+/**
+ * the reverb is zlib compressed, decompress here
+ * @type {ArrayBuffer}
+ */
+const reverbBufferBinary = SpessaSynthCoreUtils.inflateSync(binary).buffer;
+export { reverbBufferBinary };

package/synthetizer/key_modifier_manager.js

@@ -0,0 +1,113 @@
+import { workletMessageType } from "./worklet_message.js";
+import { KeyModifier } from "spessasynth_core";
+
+/**
+ * @enum {number}
+ */
+export const workletKeyModifierMessageType = {
+    addMapping: 0,    // [channel<number>, midiNote<number>, mapping<KeyModifier>]
+    deleteMapping: 1, // [channel<number>, midiNote<number>]
+    clearMappings: 2 // <no data>
+};
+
+export class WorkletKeyModifierManagerWrapper
+{
+    /**
+     * @param synth {Synthetizer}
+     */
+    constructor(synth)
+    {
+        this.synth = synth;
+        /**
+         * The velocity override mappings for MIDI keys
+         * @type {KeyModifier[][]}
+         * @private
+         */
+        this._keyModifiers = [];
+    }
+    
+    /**
+     * @private
+     * @param type {workletKeyModifierMessageType}
+     * @param data {any}
+     */
+    _sendToWorklet(type, data)
+    {
+        this.synth.post({
+            messageType: workletMessageType.keyModifierManager,
+            messageData: [
+                type,
+                data
+            ]
+        });
+    }
+    
+    /**
+     * Modifies a single key
+     * @param channel {number} the channel affected. Usually 0-15
+     * @param midiNote {number} the MIDI note to change. 0-127
+     * @param options {{
+     *     velocity: number|undefined,
+     *     patch: {
+     *         bank: number,
+     *         program: number
+     *     }|undefined,
+     *     gain: number|undefined
+     * }} the key's modifiers
+     */
+    addModifier(channel, midiNote, options)
+    {
+        const velocity = options?.velocity ?? -1;
+        const program = options?.patch?.program ?? -1;
+        const bank = options?.patch?.bank ?? -1;
+        const gain = options?.gain ?? 1;
+        const mod = new KeyModifier(velocity, bank, program, gain);
+        if (this._keyModifiers[channel] === undefined)
+        {
+            this._keyModifiers[channel] = [];
+        }
+        this._keyModifiers[channel][midiNote] = mod;
+        this._sendToWorklet(
+            workletKeyModifierMessageType.addMapping,
+            [channel, midiNote, mod]
+        );
+    }
+    
+    /**
+     * Gets a key modifier
+     * @param channel {number} the channel affected. Usually 0-15
+     * @param midiNote {number} the MIDI note to change. 0-127
+     * @returns {KeyModifier|undefined}
+     */
+    getModifier(channel, midiNote)
+    {
+        return this._keyModifiers?.[channel]?.[midiNote];
+    }
+    
+    /**
+     * Deletes a key modifier
+     * @param channel {number} the channel affected. Usually 0-15
+     * @param midiNote {number} the MIDI note to change. 0-127
+     */
+    deleteModifier(channel, midiNote)
+    {
+        this._sendToWorklet(
+            workletKeyModifierMessageType.deleteMapping,
+            [channel, midiNote]
+        );
+        if (this._keyModifiers[channel]?.[midiNote] === undefined)
+        {
+            return;
+        }
+        this._keyModifiers[channel][midiNote] = undefined;
+    }
+    
+    /**
+     * Clears ALL Modifiers
+     */
+    clearModifiers()
+    {
+        this._sendToWorklet(workletKeyModifierMessageType.clearMappings, undefined);
+        this._keyModifiers = [];
+    }
+}

package/synthetizer/sfman_message.js

@@ -0,0 +1,9 @@
+/**
+ * @enum {number}
+ */
+export const WorkletSoundfontManagerMessageType = {
+    reloadSoundFont: 0,      // buffer<ArrayBuffer>
+    addNewSoundFont: 2,      // [buffer<ArrayBuffer>, id<string>, bankOffset<number>]
+    deleteSoundFont: 3,      // id<string>
+    rearrangeSoundFonts: 4   // newOrder<string[]> // where string is the id
+};

package/synthetizer/synth_event_handler.js

@@ -0,0 +1,217 @@
+import { synthDisplayTypes } from "spessasynth_core";
+
+/**
+ * synth_event_handler.js
+ * purpose: manages the synthesizer's event system, calling assigned functions when synthesizer requests dispatching the event
+ */
+
+/**
+ * @typedef {Object} NoteOnCallback
+ * @property {number} midiNote - The MIDI note number.
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} velocity - The velocity of the note.
+ */
+
+/**
+ * @typedef {Object} NoteOffCallback
+ * @property {number} midiNote - The MIDI note number.
+ * @property {number} channel - The MIDI channel number.
+ */
+
+/**
+ * @typedef {Object} DrumChangeCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {boolean} isDrumChannel - Indicates if the channel is a drum channel.
+ */
+
+/**
+ * @typedef {Object} ProgramChangeCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} program - The program number.
+ * @property {number} bank - The bank number.
+ */
+
+/**
+ * @typedef {Object} ControllerChangeCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} controllerNumber - The controller number.
+ * @property {number} controllerValue - The value of the controller.
+ */
+
+/**
+ * @typedef {Object} MuteChannelCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {boolean} isMuted - Indicates if the channel is muted.
+ */
+
+/**
+ * @typedef {Object} PresetListChangeCallbackSingle
+ * @property {string} presetName - The name of the preset.
+ * @property {number} bank - The bank number.
+ * @property {number} program - The program number.
+ */
+
+/**
+ * @typedef {PresetListChangeCallbackSingle[]} PresetListChangeCallback - A list of preset objects.
+ */
+
+/**
+ * @typedef {Object} SynthDisplayCallback
+ * @property {Uint8Array} displayData - The data to display.
+ * @property {synthDisplayTypes} displayType - The type of display.
+ */
+
+/**
+ * @typedef {Object} PitchWheelCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} MSB - The most significant byte of the pitch-wheel value.
+ * @property {number} LSB - The least significant byte of the pitch-wheel value.
+ */
+
+/**
+ * @typedef {Object} ChannelPressureCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} pressure - The pressure value.
+ */
+
+/**
+ * @typedef {Error} SoundfontErrorCallback - The error message for soundfont errors.
+ */
+
+/**
+ * @typedef {
+ *     NoteOnCallback |
+ *     NoteOffCallback |
+ *     DrumChangeCallback |
+ *     ProgramChangeCallback |
+ *     ControllerChangeCallback |
+ *     MuteChannelCallback |
+ *     PresetListChangeCallback |
+ *     PitchWheelCallback |
+ *     SoundfontErrorCallback |
+ *     ChannelPressureCallback |
+ *     SynthDisplayCallback |
+ *     undefined
+ * } EventCallbackData
+ */
+
+/**
+ * @typedef {
+ * "noteon"|
+ * "noteoff"|
+ * "pitchwheel"|
+ * "controllerchange"|
+ * "programchange"|
+ * "channelpressure"|
+ * "polypressure" |
+ * "drumchange"|
+ * "stopall"|
+ * "newchannel"|
+ * "mutechannel"|
+ * "presetlistchange"|
+ * "allcontrollerreset"|
+ * "soundfonterror"|
+ * "synthdisplay"} EventTypes
+ */
+export class EventHandler
+{
+    /**
+     * A new synthesizer event handler
+     */
+    constructor()
+    {
+        /**
+         * The main list of events
+         * @type {Object<EventTypes, Object<string, function(EventCallbackData)>>}
+         */
+        this.events = {
+            "noteoff": {},              // called on a note off message
+            "noteon": {},               // called on a note on message
+            "pitchwheel": {},           // called on a pitch-wheel change
+            "controllerchange": {},     // called on a controller change
+            "programchange": {},        // called on a program change
+            "channelpressure": {},      // called on a channel pressure message
+            "polypressure": {},         // called on a poly pressure message
+            "drumchange": {},           // called when a channel type changes
+            "stopall": {},              // called when the synth receives stop all command
+            "newchannel": {},           // called when a new channel is created
+            "mutechannel": {},          // called when a channel is muted/unmuted
+            "presetlistchange": {},     // called when the preset list changes (soundfont gets reloaded)
+            "allcontrollerreset": {},   // called when all controllers are reset
+            "soundfonterror": {},       // called when a soundfont parsing error occurs
+            "synthdisplay": {}          // called when there's a SysEx message to display some text
+        };
+        
+        /**
+         * Set to 0 to disabled, otherwise in seconds
+         * @type {number}
+         */
+        this.timeDelay = 0;
+    }
+    
+    /**
+     * Adds a new event listener
+     * @param name {EventTypes}
+     * @param id {string} the unique identifier for the event (to delete it
+     * @param callback {function(EventCallbackData)}
+     */
+    addEvent(name, id, callback)
+    {
+        this.events[name][id] = callback;
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Removes an event listener
+     * @param name {EventTypes}
+     * @param id {string}
+     */
+    removeEvent(name, id)
+    {
+        delete this.events[name][id];
+    }
+    
+    /**
+     * Calls the given event
+     * @param name {EventTypes}
+     * @param eventData {EventCallbackData}
+     */
+    callEvent(name, eventData)
+    {
+        if (this.events[name])
+        {
+            if (this.timeDelay > 0)
+            {
+                setTimeout(() =>
+                {
+                    Object.values(this.events[name]).forEach(ev =>
+                    {
+                        try
+                        {
+                            ev(eventData);
+                        }
+                        catch (e)
+                        {
+                            console.error(`Error while executing an event callback for ${name}:`, e);
+                        }
+                    });
+                }, this.timeDelay * 1000);
+            }
+            else
+            {
+                Object.values(this.events[name]).forEach(ev =>
+                    {
+                        try
+                        {
+                            ev(eventData);
+                        }
+                        catch (e)
+                        {
+                            console.error(`Error while executing an event callback for ${name}:`, e);
+                        }
+                    }
+                );
+            }
+        }
+    }
+}

package/synthetizer/synth_soundfont_manager.js

@@ -0,0 +1,112 @@
+import { workletMessageType } from "./worklet_message.js";
+import { WorkletSoundfontManagerMessageType } from "./sfman_message.js";
+import { SpessaSynthCoreUtils } from "spessasynth_core";
+
+export class SoundfontManager
+{
+    /**
+     * Creates a new instance of the soundfont manager
+     * @param synth {Synthetizer}
+     */
+    constructor(synth)
+    {
+        /**
+         * The current list of soundfonts, in order from the most important to the least.
+         * @type {{
+         *     id: string,
+         *     bankOffset: number
+         * }[]}
+         */
+        this.soundfontList = [{
+            id: "main",
+            bankOffset: 0
+        }];
+        
+        /**
+         * @type {MessagePort}
+         * @private
+         */
+        this._port = synth.worklet.port;
+        this.synth = synth;
+    }
+    
+    /**
+     * @private
+     * @param type {WorkletSoundfontManagerMessageType}
+     * @param data {any}
+     */
+    _sendToWorklet(type, data)
+    {
+        this._port.postMessage({
+            messageType: workletMessageType.soundFontManager,
+            messageData: [
+                type,
+                data
+            ]
+        });
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Adds a new soundfont buffer with a given ID
+     * @param soundfontBuffer {ArrayBuffer} - the soundfont's buffer
+     * @param id {string} - the soundfont's unique identifier
+     * @param bankOffset {number} - the soundfont's bank offset. Default is 0
+     */
+    async addNewSoundFont(soundfontBuffer, id, bankOffset = 0)
+    {
+        if (this.soundfontList.find(s => s.id === id) !== undefined)
+        {
+            throw new Error("Cannot overwrite the existing soundfont. Use soundfontManager.delete(id) instead.");
+        }
+        this._sendToWorklet(WorkletSoundfontManagerMessageType.addNewSoundFont, [soundfontBuffer, id, bankOffset]);
+        await new Promise(r => this.synth._resolveWhenReady = r);
+        this.soundfontList.push({
+            id: id,
+            bankOffset: bankOffset
+        });
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Deletes a soundfont with the given ID
+     * @param id {string} - the soundfont to delete
+     */
+    deleteSoundFont(id)
+    {
+        if (this.soundfontList.length === 0)
+        {
+            SpessaSynthCoreUtils.SpessaSynthWarn("1 soundfont left. Aborting!");
+            return;
+        }
+        if (this.soundfontList.findIndex(s => s.id === id) === -1)
+        {
+            SpessaSynthCoreUtils.SpessaSynthWarn(`No soundfont with id of "${id}" found. Aborting!`);
+            return;
+        }
+        this._sendToWorklet(WorkletSoundfontManagerMessageType.deleteSoundFont, id);
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Rearranges the soundfonts in a given order
+     * @param newList {string[]} the order of soundfonts, a list of identifiers, first overwrites second
+     */
+    rearrangeSoundFonts(newList)
+    {
+        this._sendToWorklet(WorkletSoundfontManagerMessageType.rearrangeSoundFonts, newList);
+        this.soundfontList.sort((a, b) =>
+            newList.indexOf(a.id) - newList.indexOf(b.id)
+        );
+    }
+    
+    /**
+     * DELETES ALL SOUNDFONTS! and creates a new one with id "main"
+     * @param newBuffer {ArrayBuffer}
+     */
+    async reloadManager(newBuffer)
+    {
+        this._sendToWorklet(WorkletSoundfontManagerMessageType.reloadSoundFont, newBuffer);
+        await new Promise(r => this.synth._resolveWhenReady = r);
+    }
+}