spessasynth_lib 3.25.23 → 3.26.1

package/synthetizer/{worklet_wrapper/synth_soundfont_manager.js → synth_soundfont_manager.js}

@@ -1,6 +1,6 @@
-import { workletMessageType } from "../audio_engine/message_protocol/worklet_message.js";
+import { workletMessageType } from "./worklet_message.js";
 import { WorkletSoundfontManagerMessageType } from "./sfman_message.js";
-import { SpessaSynthWarn } from "../../utils/loggin.js";
+import { SpessaSynthCoreUtils } from "spessasynth_core";
 
 export class SoundfontManager
 {
@@ -46,6 +46,7 @@ export class SoundfontManager
         });
     }
     
+    // noinspection JSUnusedGlobalSymbols
     /**
      * Adds a new soundfont buffer with a given ID
      * @param soundfontBuffer {ArrayBuffer} - the soundfont's buffer
@@ -66,6 +67,7 @@ export class SoundfontManager
         });
     }
     
+    // noinspection JSUnusedGlobalSymbols
     /**
      * Deletes a soundfont with the given ID
      * @param id {string} - the soundfont to delete
@@ -74,17 +76,18 @@ export class SoundfontManager
     {
         if (this.soundfontList.length === 0)
         {
-            SpessaSynthWarn("1 soundfont left. Aborting!");
+            SpessaSynthCoreUtils.SpessaSynthWarn("1 soundfont left. Aborting!");
             return;
         }
         if (this.soundfontList.findIndex(s => s.id === id) === -1)
         {
-            SpessaSynthWarn(`No soundfont with id of "${id}" found. Aborting!`);
+            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
@@ -98,7 +101,7 @@ export class SoundfontManager
     }
     
     /**
-     * DELETES ALL SOUNDFONTS!! and creates a new one with id "main"
+     * DELETES ALL SOUNDFONTS! and creates a new one with id "main"
      * @param newBuffer {ArrayBuffer}
      */
     async reloadManager(newBuffer)

package/synthetizer/{worklet_wrapper/synthetizer.js → synthetizer.js}

@@ -1,24 +1,29 @@
-import { consoleColors } from "../../utils/other.js";
-import { messageTypes, midiControllers } from "../../midi/midi_message.js";
-import { EventHandler } from "./synth_event_handler.js";
-import { FancyChorus } from "../audio_effects/fancy_chorus.js";
-import { getReverbProcessor } from "../audio_effects/reverb.js";
+import { consoleColors } from "../utils/other.js";
 import {
     ALL_CHANNELS_OR_DIFFERENT_ACTION,
-    returnMessageType,
-    workletMessageType
-} from "../audio_engine/message_protocol/worklet_message.js";
-import { SpessaSynthInfo, SpessaSynthWarn } from "../../utils/loggin.js";
-import { DEFAULT_SYNTH_CONFIG } from "../audio_effects/effects_config.js";
+    BasicMIDI,
+    channelConfiguration,
+    DEFAULT_PERCUSSION,
+    DEFAULT_SYNTH_MODE,
+    interpolationTypes,
+    masterParameterType,
+    messageTypes,
+    MIDI_CHANNEL_COUNT,
+    midiControllers,
+    SpessaSynthCoreUtils as util,
+    SynthesizerSnapshot,
+    VOICE_CAP
+} from "spessasynth_core";
+import { EventHandler } from "./synth_event_handler.js";
+import { FancyChorus } from "./audio_effects/fancy_chorus.js";
+import { getReverbProcessor } from "./audio_effects/reverb.js";
+import { returnMessageType, workletMessageType } from "./worklet_message.js";
+import { DEFAULT_SYNTH_CONFIG } from "./audio_effects/effects_config.js";
 import { SoundfontManager } from "./synth_soundfont_manager.js";
 import { WorkletKeyModifierManagerWrapper } from "./key_modifier_manager.js";
-import { channelConfiguration } from "../audio_engine/engine_components/controller_tables.js";
-import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE, MIDI_CHANNEL_COUNT, VOICE_CAP } from "../synth_constants.js";
-import { BasicMIDI } from "../../midi/basic_midi.js";
-import { fillWithDefaults } from "../../utils/fill_with_defaults.js";
-import { DEFAULT_SEQUENCER_OPTIONS } from "../../sequencer/worklet_wrapper/default_sequencer_options.js";
+import { fillWithDefaults } from "../utils/fill_with_defaults.js";
+import { DEFAULT_SEQUENCER_OPTIONS } from "../sequencer/default_sequencer_options.js";
 import { WORKLET_PROCESSOR_NAME } from "./worklet_url.js";
-import { masterParameterType } from "../audio_engine/engine_methods/controller_control/master_parameters.js";
 
 
 /**
@@ -40,6 +45,7 @@ const DEFAULT_SYNTH_METHOD_OPTIONS = {
 
 
 // the "remote controller" of the worklet processor in the audio thread from the main thread
+// noinspection JSUnusedGlobalSymbols
 export class Synthetizer
 {
     
@@ -67,7 +73,7 @@ export class Synthetizer
     _destroyed = false;
     
     /**
-     * the new channels will have their audio sent to the moduled output by this constant.
+     * the new channels will have their audio sent to the modulated output by this constant.
      * what does that mean?
      * e.g., if outputsAmount is 16, then channel's 16 audio data will be sent to channel 0
      * @type {number}
@@ -110,7 +116,7 @@ export class Synthetizer
                 startRenderingData = undefined,
                 synthConfig = DEFAULT_SYNTH_CONFIG)
     {
-        SpessaSynthInfo("%cInitializing SpessaSynth synthesizer...", consoleColors.info);
+        util.SpessaSynthInfo("%cInitializing SpessaSynth synthesizer...", consoleColors.info);
         this.context = targetNode.context;
         this.targetNode = targetNode;
         
@@ -446,7 +452,7 @@ export class Synthetizer
                 break;
             
             case returnMessageType.soundfontError:
-                SpessaSynthWarn(new Error(messageData));
+                util.SpessaSynthWarn(new Error(messageData));
                 this.eventHandler.callEvent("soundfonterror", messageData);
                 break;
         }
@@ -565,7 +571,7 @@ export class Synthetizer
      */
     debugMessage()
     {
-        SpessaSynthInfo(this);
+        util.SpessaSynthInfo(this);
         this.post({
             channelNumber: 0,
             messageType: workletMessageType.debugMessage,
@@ -748,7 +754,7 @@ export class Synthetizer
     }
     
     /**
-     * Transposes the synthetizer's pitch by given semitones amount (percussion channels don’t get affected).
+     * Transposes the synthesizer's pitch by given the semitone amount (percussion channels don’t get affected).
      * @param semitones {number} the semitones to transpose by.
      * It can be a floating point number for more precision.
      */
@@ -783,7 +789,7 @@ export class Synthetizer
     
     /**
      * Sets the master stereo panning.
-     * @param pan {number} (-1 to 1), the pan (-1 is left, 0 is midde, 1 is right)
+     * @param pan {number} (-1 to 1), the pan (-1 is left, 0 is middle, 1 is right)
      */
     setMasterPan(pan)
     {
@@ -878,7 +884,7 @@ export class Synthetizer
      */
     async reloadSoundFont(soundFontBuffer)
     {
-        SpessaSynthWarn("reloadSoundFont is deprecated. Please use the soundfontManager property instead.");
+        util.SpessaSynthWarn("reloadSoundFont is deprecated. Please use the soundfontManager property instead.");
         await this.soundfontManager.reloadManager(soundFontBuffer);
     }
     

package/synthetizer/{audio_engine/message_protocol/worklet_message.js → worklet_message.js}

@@ -1,3 +1,5 @@
+import { SynthesizerSnapshot } from "spessasynth_core";
+
 /**
  * @enum {number}
  * // NOTE: Every message needs a channel number (if not relevant or all, set to -1)
@@ -33,7 +35,7 @@ export const workletMessageType = {
     killNotes: 11,
     muteChannel: 12,
     addNewChannel: 13,
-    customcCcChange: 14,
+    customCcChange: 14,
     debugMessage: 15,
     // free slot here
     setMasterParameter: 17,
@@ -50,7 +52,6 @@ export const workletMessageType = {
 };
 
 
-export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
 /**
  * @typedef {{
  *     channelNumber: number
@@ -71,6 +72,18 @@ export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
  * }} WorkletMessage
  */
 
+/**
+ * @typedef {Object} ChannelProperty
+ * @property {number} voicesAmount - the channel's current voice amount
+ * @property {number} pitchBend - the channel's current pitch bend from -8192 do 8192
+ * @property {number} pitchBendRangeSemitones - the pitch bend's range, in semitones
+ * @property {boolean} isMuted - indicates whether the channel is muted
+ * @property {boolean} isDrum - indicates whether the channel is a drum channel
+ * @property {number} transposition - the channel's transposition, in semitones
+ * @property {number} bank - the bank number of the current preset
+ * @property {number} program - the MIDI program number of the current preset
+ */
+
 /**
  * @typedef {Object} WorkletReturnMessage
  * @property {returnMessageType} messageType - the message's type

package/synthetizer/{worklet_wrapper/worklet_processor.js → worklet_processor.js}

@@ -1,22 +1,28 @@
-import { consoleColors } from "../../utils/other.js";
-import { SpessaSynthInfo, SpessaSynthLogging, SpessaSynthWarn } from "../../utils/loggin.js";
-import { SpessaSynthProcessor } from "../audio_engine/main_processor.js";
+import { consoleColors } from "../utils/other.js";
 import {
     ALL_CHANNELS_OR_DIFFERENT_ACTION,
-    returnMessageType,
-    workletMessageType
-} from "../audio_engine/message_protocol/worklet_message.js";
-import { SynthesizerSnapshot } from "../audio_engine/snapshot/synthesizer_snapshot.js";
+    BasicMIDI,
+    masterParameterType,
+    MIDI,
+    MIDI_CHANNEL_COUNT,
+    SpessaSynthCoreUtils as util,
+    SpessaSynthLogging,
+    SpessaSynthProcessor,
+    SpessaSynthSequencer,
+    SynthesizerSnapshot
+} from "spessasynth_core";
+import { returnMessageType, workletMessageType } from "./worklet_message.js";
 import { WORKLET_PROCESSOR_NAME } from "./worklet_url.js";
-import { MIDI_CHANNEL_COUNT } from "../synth_constants.js";
-import { workletKeyModifierMessageType } from "../audio_engine/engine_components/key_modifier_manager.js";
-import { masterParameterType } from "../audio_engine/engine_methods/controller_control/master_parameters.js";
+import { workletKeyModifierMessageType } from "./key_modifier_manager.js";
 import { WorkletSoundfontManagerMessageType } from "./sfman_message.js";
 import {
     SongChangeType,
     SpessaSynthSequencerMessageType,
     SpessaSynthSequencerReturnMessageType
-} from "../../sequencer/worklet_wrapper/sequencer_message.js";
+} from "../sequencer/sequencer_message.js";
+import { fillWithDefaults } from "../utils/fill_with_defaults.js";
+import { DEFAULT_SEQUENCER_OPTIONS } from "../sequencer/default_sequencer_options.js";
+import { MIDIData } from "../sequencer/midi_data.js";
 
 
 // a worklet processor wrapper for the synthesizer core
@@ -53,24 +59,165 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
         // one output is indicated by setting midiChannels to 1
         this.oneOutputMode = opts.midiChannels === 1;
         
+        // prepare synthesizer connections
+        /**
+         * @param t {returnMessageType}
+         * @param d {any}
+         */
+        const postSyn = (t, d) =>
+        {
+            // noinspection JSCheckFunctionSignatures
+            this.postMessageToMainThread({
+                messageType: t,
+                messageData: d
+            });
+        };
+        
+        // start rendering data
+        const startRenderingData = opts?.startRenderingData;
+        /**
+         * The snapshot that synth was restored from
+         * @type {SynthesizerSnapshot|undefined}
+         * @private
+         */
+        const snapshot = startRenderingData?.snapshot;
+        
         // noinspection JSUnresolvedReference
         /**
          * Initialize the synthesis engine
          * @type {SpessaSynthProcessor}
          */
         this.synthesizer = new SpessaSynthProcessor(
-            MIDI_CHANNEL_COUNT,                      // midi channel count (16)
             opts.soundfont,                          // initial sound bank
             sampleRate,                              // AudioWorkletGlobalScope
-            this.postMessageToMainThread.bind(this), // connect to message port
+            {
+                eventCall: (t, d) =>
+                {
+                    postSyn(returnMessageType.eventCall, {
+                        eventName: t,
+                        eventData: d
+                    });
+                },
+                ready: this.postReady.bind(this),
+                channelPropertyChange: (p, n) => postSyn(returnMessageType.channelPropertyChange, [n, p]),
+                masterParameterChange: (t, v) => postSyn(returnMessageType.masterParameterChange, [t, v])
+            },
             !this.oneOutputMode,                     // one output mode disables effects
             opts?.enableEventSystem,                 // enable message port?
-            opts?.startRenderingData,                // start rendering?
-            currentTime                              // AudioWorkletGlobalScope, sync with audioContext time
+            currentTime,                             // AudioWorkletGlobalScope, sync with audioContext time
+            MIDI_CHANNEL_COUNT,                      // midi channel count (16)
+            snapshot
         );
         
+        // initialize the sequencer engine
+        this.sequencer = new SpessaSynthSequencer(this.synthesizer);
+        
+        const postSeq = (type, data) =>
+        {
+            this.postMessageToMainThread({
+                messageType: returnMessageType.sequencerSpecific,
+                messageData: {
+                    messageType: type,
+                    messageData: data
+                }
+            });
+        };
+        
         // receive messages from the main thread
         this.port.onmessage = e => this.handleMessage(e.data);
+        
+        // sequencer events
+        this.sequencer.onMIDIMessage = m =>
+        {
+            postSeq(SpessaSynthSequencerReturnMessageType.midiEvent, m);
+        };
+        this.sequencer.onTimeChange = t =>
+        {
+            postSeq(SpessaSynthSequencerReturnMessageType.timeChange, t);
+        };
+        this.sequencer.onPlaybackStop = p =>
+        {
+            postSeq(SpessaSynthSequencerReturnMessageType.pause, p);
+        };
+        this.sequencer.onSongChange = (i, a) =>
+        {
+            postSeq(SpessaSynthSequencerReturnMessageType.songChange, [i, a]);
+        };
+        this.sequencer.onMetaEvent = (e, i) =>
+        {
+            postSeq(SpessaSynthSequencerReturnMessageType.metaEvent, [e, i]);
+        };
+        this.sequencer.onLoopCountChange = c =>
+        {
+            postSeq(SpessaSynthSequencerReturnMessageType.loopCountChange, c);
+        };
+        this.sequencer.onSongListChange = l =>
+        {
+            const midiDataList = l.map(s => new MIDIData(s));
+            this.postMessageToMainThread({
+                messageType: returnMessageType.sequencerSpecific,
+                messageData: {
+                    messageType: SpessaSynthSequencerReturnMessageType.songListChange,
+                    messageData: midiDataList
+                }
+            });
+        };
+        
+        // if sent, start rendering
+        if (startRenderingData)
+        {
+            if (snapshot !== undefined)
+            {
+                this.synthesizer.applySynthesizerSnapshot(snapshot);
+            }
+            
+            util.SpessaSynthInfo("%cRendering enabled! Starting render.", consoleColors.info);
+            if (startRenderingData.parsedMIDI)
+            {
+                if (startRenderingData?.loopCount !== undefined)
+                {
+                    this.sequencer.loopCount = startRenderingData?.loopCount;
+                    this.sequencer.loop = true;
+                }
+                else
+                {
+                    this.sequencer.loop = false;
+                }
+                // set voice cap to unlimited
+                this.synthesizer.voiceCap = Infinity;
+                this.synthesizer.processorInitialized.then(() =>
+                {
+                    /**
+                     * set options
+                     * @type {SequencerOptions}
+                     */
+                    const seqOptions = fillWithDefaults(
+                        startRenderingData.sequencerOptions,
+                        DEFAULT_SEQUENCER_OPTIONS
+                    );
+                    this.sequencer.skipToFirstNoteOn = seqOptions.skipToFirstNoteOn;
+                    this.sequencer.preservePlaybackState = seqOptions.preservePlaybackState;
+                    // autoplay is ignored
+                    try
+                    {
+                        this.sequencer.loadNewSongList([startRenderingData.parsedMIDI]);
+                    }
+                    catch (e)
+                    {
+                        console.error(e);
+                        postSeq(SpessaSynthSequencerReturnMessageType.midiError, e);
+                    }
+                });
+            }
+        }
+    }
+    
+    postReady()
+    {
+        this.postMessageToMainThread({
+            messageType: returnMessageType.isFullyInitialized,
+            messageData: undefined
+        });
     }
     
     /**
@@ -89,16 +236,14 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
     {
         const data = message.messageData;
         const channel = message.channelNumber;
-        /**
-         * @type {MidiAudioChannel}
-         */
+        
         let channelObject;
         if (channel >= 0)
         {
             channelObject = this.synthesizer.midiAudioChannels[channel];
             if (channelObject === undefined)
             {
-                SpessaSynthWarn(`Trying to access channel ${channel} which does not exist... ignoring!`);
+                util.SpessaSynthWarn(`Trying to access channel ${channel} which does not exist... ignoring!`);
                 return;
             }
         }
@@ -108,7 +253,7 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
                 this.synthesizer.processMessage(...data);
                 break;
             
-            case workletMessageType.customcCcChange:
+            case workletMessageType.customCcChange:
                 // custom controller change
                 channelObject.setCustomController(data[0], data[1]);
                 channelObject.updateChannelTuning();
@@ -175,7 +320,7 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
                 break;
             
             case workletMessageType.debugMessage:
-                this.synthesizer.debugMessage();
+                console.debug(this.synthesizer);
                 break;
             
             case workletMessageType.setMasterParameter:
@@ -218,7 +363,7 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
                 break;
             
             case workletMessageType.sequencerSpecific:
-                const seq = this.synthesizer.sequencer;
+                const seq = this.sequencer;
                 const messageData = data.messageData;
                 const messageType = data.messageType;
                 switch (messageType)
@@ -227,7 +372,33 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
                         break;
                     
                     case SpessaSynthSequencerMessageType.loadNewSongList:
-                        seq.loadNewSongList(messageData[0], messageData[1]);
+                        try
+                        {
+                            /**
+                             * @type {(BasicMIDI|{binary: ArrayBuffer, altName: string})[]}
+                             */
+                            const sList = messageData[0];
+                            const songMap = sList.map(s =>
+                            {
+                                if (s.duration)
+                                {
+                                    return s;
+                                }
+                                return new MIDI(s.binary, s.altName);
+                            });
+                            seq.loadNewSongList(songMap, messageData[1]);
+                        }
+                        catch (e)
+                        {
+                            console.error(e);
+                            this.postMessageToMainThread({
+                                messageType: returnMessageType.sequencerSpecific,
+                                messageData: {
+                                    messageType: SpessaSynthSequencerReturnMessageType.midiError,
+                                    messageData: e
+                                }
+                            });
+                        }
                         break;
                     
                     case SpessaSynthSequencerMessageType.pause:
@@ -298,7 +469,13 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
                         break;
                     
                     case SpessaSynthSequencerMessageType.getMIDI:
-                        seq.post(SpessaSynthSequencerReturnMessageType.getMIDI, seq.midiData);
+                        this.postMessageToMainThread({
+                            messageType: returnMessageType.sequencerSpecific,
+                            messageData: {
+                                messageType: SpessaSynthSequencerReturnMessageType.getMIDI,
+                                messageData: seq.midiData
+                            }
+                        });
                         break;
                     
                     case SpessaSynthSequencerMessageType.setSkipToFirstNote:
@@ -313,25 +490,25 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
             case workletMessageType.soundFontManager:
                 try
                 {
-                    const sfman = this.synthesizer.soundfontManager;
+                    const sfManager = this.synthesizer.soundfontManager;
                     const type = data[0];
                     const messageData = data[1];
                     switch (type)
                     {
                         case WorkletSoundfontManagerMessageType.addNewSoundFont:
-                            sfman.addNewSoundFont(messageData[0], messageData[1], messageData[2]);
+                            sfManager.addNewSoundFont(messageData[0], messageData[1], messageData[2]);
                             break;
                         
                         case WorkletSoundfontManagerMessageType.reloadSoundFont:
-                            sfman.reloadManager(messageData);
+                            sfManager.reloadManager(messageData);
                             break;
                         
                         case WorkletSoundfontManagerMessageType.deleteSoundFont:
-                            sfman.deleteSoundFont(messageData);
+                            sfManager.deleteSoundFont(messageData);
                             break;
                         
                         case WorkletSoundfontManagerMessageType.rearrangeSoundFonts:
-                            sfman.rearrangeSoundFonts(messageData);
+                            sfManager.rearrangeSoundFonts(messageData);
                     }
                 }
                 catch (e)
@@ -389,10 +566,13 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
             case workletMessageType.destroyWorklet:
                 this.alive = false;
                 this.synthesizer.destroySynthProcessor();
+                delete this.synthesizer;
+                delete this.sequencer.midiData;
+                delete this.sequencer;
                 break;
             
             default:
-                SpessaSynthWarn("Unrecognized event:", data);
+                util.SpessaSynthWarn("Unrecognized event:", data);
                 break;
         }
     }
@@ -410,6 +590,9 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
         {
             return false;
         }
+        // process sequencer
+        this.sequencer.processTick();
+        
         if (this.oneOutputMode)
         {
             const out = outputs[0];
@@ -451,4 +634,4 @@ class WorkletSpessaProcessor extends AudioWorkletProcessor
 
 // noinspection JSUnresolvedReference
 registerProcessor(WORKLET_PROCESSOR_NAME, WorkletSpessaProcessor);
-SpessaSynthInfo("%cProcessor succesfully registered!", consoleColors.recognized);
+util.SpessaSynthInfo("%cProcessor successfully registered!", consoleColors.recognized);