spessasynth_lib 3.25.0 → 3.25.2

package/synthetizer/worklet_system/main_processor.js

@@ -2,7 +2,11 @@ import { WorkletSequencer } from "../../sequencer/worklet_sequencer/worklet_sequ
 import { SpessaSynthInfo } from "../../utils/loggin.js";
 import { consoleColors } from "../../utils/other.js";
 import { voiceKilling } from "./worklet_methods/stopping_notes/voice_killing.js";
-import { ALL_CHANNELS_OR_DIFFERENT_ACTION, returnMessageType } from "./message_protocol/worklet_message.js";
+import {
+    ALL_CHANNELS_OR_DIFFERENT_ACTION,
+    masterParameterType,
+    returnMessageType
+} from "./message_protocol/worklet_message.js";
 import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
 import { VOLUME_ENVELOPE_SMOOTHING_FACTOR } from "./worklet_utilities/volume_envelope.js";
 import { handleMessage } from "./message_protocol/handle_message.js";
@@ -181,13 +185,28 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
      * @type {SynthSystem}
      */
     system = DEFAULT_SYNTH_MODE;
-    
     /**
      * Current total voices amount
      * @type {number}
      */
     totalVoicesAmount = 0;
     
+    /**
+     * Synth's default (reset) preset
+     * @type {BasicPreset}
+     */
+    defaultPreset;
+    
+    defaultPresetUsesOverride = false;
+    
+    /**
+     * Synth's default (reset) drum preset
+     * @type {BasicPreset}
+     */
+    drumPreset;
+    
+    defaultDrumsUsesOverride = false;
+    
     /**
      * Creates a new worklet synthesis system. contains all channels
      * @param options {{
@@ -232,8 +251,7 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
         }
         this.sendPresetList();
         
-        this.defaultPreset = this.getPreset(0, 0);
-        this.drumPreset = this.getPreset(128, 0);
+        this.getDefaultPresets();
         
         
         for (let i = 0; i < options.processorOptions.midiChannels; i++)
@@ -300,6 +318,30 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
         return this.masterGain * this.midiVolume;
     }
     
+    getDefaultPresets()
+    {
+        // override this to XG, to set the default preset to NOT be XG drums!
+        const sys = this.system;
+        this.system = "xg";
+        this.defaultPreset = this.getPreset(0, 0);
+        this.defaultPresetUsesOverride = this.overrideSoundfont?.presets?.indexOf(this.defaultPreset) >= 0;
+        this.system = sys;
+        this.drumPreset = this.getPreset(128, 0);
+        this.defaultDrumsUsesOverride = this.overrideSoundfont?.presets?.indexOf(this.drumPreset) >= 0;
+    }
+    
+    /**
+     * @param value {SynthSystem}
+     */
+    setSystem(value)
+    {
+        this.system = value;
+        this.post({
+            messageType: returnMessageType.masterParameterChange,
+            messageData: [masterParameterType.midiSystem, this.system]
+        });
+    }
+    
     /**
      * @param bank {number}
      * @param program {number}

package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -158,6 +158,9 @@ export function handleMessage(message)
                 case masterParameterType.interpolationType:
                     this.interpolationType = value;
                     break;
+                
+                case masterParameterType.midiSystem:
+                    this.setSystem(value);
             }
             break;
         
@@ -183,7 +186,7 @@ export function handleMessage(message)
         case workletMessageType.lockController:
             if (data[0] === ALL_CHANNELS_OR_DIFFERENT_ACTION)
             {
-                channelObject.lockPreset = data[1];
+                channelObject.setPresetLock(data[1]);
             }
             else
             {

package/synthetizer/worklet_system/message_protocol/worklet_message.js

@@ -70,7 +70,8 @@ export const masterParameterType = {
     mainVolume: 0,
     masterPan: 1,
     voicesCap: 2,
-    interpolationType: 3
+    interpolationType: 3,
+    midiSystem: 4
 };
 
 
@@ -110,12 +111,11 @@ export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
  *
  * 0 - channel properties           -> [...<ChannelProperty>] see message_sending.js line 29
  * 1 - event call                   -> {eventName<string>, eventData:<the event's data>}
- * 2 - reported current time        -> currentTime<number>
+ * 2 - master parameter change      -> [parameter<masterParameterType>, value<string|number>]
  * 3 - sequencer specific           -> [messageType<WorkletSequencerReturnMessageType> messageData<any>] note: refer to sequencer_message.js
  * 4 - synthesizer snapshot         -> snapshot<SynthesizerSnapshot> note: refer to synthesizer_snapshot.js
  * 5 - ready                        -> (no data)
  * 6 - soundfontError               -> errorMessage<string>
- * 7 - idenfity                     -> version<string>
  */
 
 /**
@@ -124,10 +124,9 @@ export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
 export const returnMessageType = {
     channelProperties: 0,
     eventCall: 1,
-    reportedCurrentTime: 2,
+    masterParameterChange: 2,
     sequencerSpecific: 3,
     synthesizerSnapshot: 4,
     ready: 5,
-    soundfontError: 6,
-    identify: 7
+    soundfontError: 6
 };

package/synthetizer/worklet_system/snapshot/channel_snapshot.js

@@ -15,6 +15,12 @@ export class ChannelSnapshot
      */
     bank;
     
+    /**
+     * If the bank is LSB. For restoring.
+     * @type {boolean}
+     */
+    isBankLSB;
+    
     /**
      * The name of the patch currently loaded in the channel.
      * @type {string}
@@ -27,6 +33,12 @@ export class ChannelSnapshot
      */
     lockPreset;
     
+    /**
+     * Indicates the MIDI system when the preset was locked
+     * @type {SynthSystem}
+     */
+    lockedSystem;
+    
     /**
      * The array of all MIDI controllers (in 14-bit values) with the modulator sources at the end.
      * @type {Int16Array}
@@ -103,7 +115,9 @@ export class ChannelSnapshot
         // program data
         channelSnapshot.program = channelObject.preset.program;
         channelSnapshot.bank = channelObject.getBankSelect();
+        channelSnapshot.isBankLSB = channelSnapshot.bank !== channelObject.bank;
         channelSnapshot.lockPreset = channelObject.lockPreset;
+        channelSnapshot.lockedSystem = channelObject.lockedSystem;
         channelSnapshot.patchName = channelObject.preset.presetName;
         
         // controller data
@@ -152,9 +166,10 @@ export class ChannelSnapshot
         channelObject.velocityOverride = channelSnapshot.velocityOverride;
         
         // restore preset and lock
-        channelObject.lockPreset = false;
-        channelObject.setBankSelect(channelSnapshot.bank);
+        channelObject.setPresetLock(false);
+        channelObject.setBankSelect(channelSnapshot.bank, channelSnapshot.isBankLSB);
         channelObject.programChange(channelSnapshot.program);
-        channelObject.lockPreset = channelSnapshot.lockPreset;
+        channelObject.setPresetLock(channelSnapshot.lockPreset);
+        channelObject.lockedSystem = channelSnapshot.lockedSystem;
     }
 }

package/synthetizer/worklet_system/snapshot/synthesizer_snapshot.js

@@ -94,7 +94,7 @@ export class SynthesizerSnapshot
     static applySnapshot(workletProcessor, snapshot)
     {
         // restore system
-        workletProcessor.system = snapshot.system;
+        workletProcessor.setSystem(snapshot.system);
         
         // restore pan and volume
         workletProcessor.setMasterGain(snapshot.mainVolume);

package/synthetizer/worklet_system/worklet_methods/controller_control/controller_change.js

@@ -1,9 +1,6 @@
-import { SpessaSynthInfo } from "../../../../utils/loggin.js";
 import { midiControllers } from "../../../../midi_parser/midi_message.js";
 import { computeModulators } from "../../worklet_utilities/worklet_modulator.js";
-import { consoleColors } from "../../../../utils/other.js";
 import { channelConfiguration, dataEntryStates } from "../../worklet_utilities/controller_tables.js";
-import { DEFAULT_PERCUSSION } from "../../../synth_constants.js";
 
 /**
  * @param controllerNumber {number}
@@ -56,144 +53,76 @@ export function controllerChange(controllerNumber, controllerValue, force = fals
     this.midiControllers[controllerNumber] = controllerValue << 7;
     
     // interpret special CCs
-    switch (controllerNumber)
     {
-        case midiControllers.allNotesOff:
-            this.stopAllNotes();
-            break;
-        
-        case midiControllers.allSoundOff:
-            this.stopAllNotes(true);
-            break;
-        
-        // special case: bank select
-        case midiControllers.bankSelect:
-            let bankNr = controllerValue;
-            if (!force)
-            {
-                switch (this.synth.system)
-                {
-                    case "gm":
-                        // gm ignores bank select
-                        SpessaSynthInfo(
-                            `%cIgnoring the Bank Select (${controllerValue}), as the synth is in GM mode.`,
-                            consoleColors.info
-                        );
-                        return;
-                    
-                    case "xg":
-                        // for xg, if msb is 120, 126 or 127, then it's drums
-                        if (bankNr === 120 || bankNr === 126 || bankNr === 127)
-                        {
-                            this.setDrums(true);
-                        }
-                        else
-                        {
-                            // drums shall not be disabled on channel 9
-                            if (this.channelNumber % 16 !== DEFAULT_PERCUSSION)
-                            {
-                                this.setDrums(false);
-                            }
-                        }
-                        break;
-                    
-                    case "gm2":
-                        if (bankNr === 120)
-                        {
-                            this.setDrums(true);
-                        }
-                        else
-                        {
-                            if (this.channelNumber % 16 !== DEFAULT_PERCUSSION)
-                            {
-                                this.setDrums(false);
-                            }
-                        }
-                }
-                
-                if (this.drumChannel)
-                {
-                    // 128 for percussion channel
-                    bankNr = 128;
-                }
-                if (bankNr === 128 && !this.drumChannel)
+        switch (controllerNumber)
+        {
+            case midiControllers.allNotesOff:
+                this.stopAllNotes();
+                break;
+            
+            case midiControllers.allSoundOff:
+                this.stopAllNotes(true);
+                break;
+            
+            // special case: bank select
+            case midiControllers.bankSelect:
+                this.setBankSelect(controllerValue);
+                break;
+            
+            case midiControllers.lsbForControl0BankSelect:
+                this.setBankSelect(controllerValue, true);
+                break;
+            
+            // check for RPN and NPRN and data entry
+            case midiControllers.RPNLsb:
+                this.dataEntryState = dataEntryStates.RPFine;
+                break;
+            
+            case midiControllers.RPNMsb:
+                this.dataEntryState = dataEntryStates.RPCoarse;
+                break;
+            
+            case midiControllers.NRPNMsb:
+                this.dataEntryState = dataEntryStates.NRPCoarse;
+                break;
+            
+            case midiControllers.NRPNLsb:
+                this.dataEntryState = dataEntryStates.NRPFine;
+                break;
+            
+            case midiControllers.dataEntryMsb:
+                this.dataEntryCoarse(controllerValue);
+                break;
+            
+            case midiControllers.lsbForControl6DataEntry:
+                this.dataEntryFine(controllerValue);
+                break;
+            
+            case midiControllers.resetAllControllers:
+                this.resetControllersRP15Compliant();
+                break;
+            
+            case midiControllers.sustainPedal:
+                if (controllerValue >= 64)
                 {
-                    // if a channel is not for percussion, default to bank current
-                    bankNr = this.getBankSelect();
+                    this.holdPedal = true;
                 }
-            }
-            
-            this.setBankSelect(bankNr);
-            break;
-        
-        case midiControllers.lsbForControl0BankSelect:
-            if (this.synth.system === "xg")
-            {
-                if (!this.drumChannel)
+                else
                 {
-                    // some soundfonts use 127 as drums and
-                    // if it's not marked as drums by bank MSB (line 47), then we DO NOT want the drums!
-                    if (controllerValue !== 127)
+                    this.holdPedal = false;
+                    this.sustainedVoices.forEach(v =>
                     {
-                        this.setBankSelect(controllerValue);
-                    }
+                        v.release();
+                    });
+                    this.sustainedVoices = [];
                 }
-            }
-            else if (this.synth.system === "gm2")
-            {
-                this.setBankSelect(controllerValue);
-            }
-            break;
-        
-        // check for RPN and NPRN and data entry
-        case midiControllers.RPNLsb:
-            this.dataEntryState = dataEntryStates.RPFine;
-            break;
-        
-        case midiControllers.RPNMsb:
-            this.dataEntryState = dataEntryStates.RPCoarse;
-            break;
-        
-        case midiControllers.NRPNMsb:
-            this.dataEntryState = dataEntryStates.NRPCoarse;
-            break;
-        
-        case midiControllers.NRPNLsb:
-            this.dataEntryState = dataEntryStates.NRPFine;
-            break;
-        
-        case midiControllers.dataEntryMsb:
-            this.dataEntryCoarse(controllerValue);
-            break;
-        
-        case midiControllers.lsbForControl6DataEntry:
-            this.dataEntryFine(controllerValue);
-            break;
-        
-        case midiControllers.resetAllControllers:
-            this.resetControllersRP15Compliant();
-            break;
-        
-        case midiControllers.sustainPedal:
-            if (controllerValue >= 64)
-            {
-                this.holdPedal = true;
-            }
-            else
-            {
-                this.holdPedal = false;
-                this.sustainedVoices.forEach(v =>
-                {
-                    v.release();
-                });
-                this.sustainedVoices = [];
-            }
-            break;
-        
-        // default: just compute modulators
-        default:
-            this.voices.forEach(v => computeModulators(v, this.midiControllers, 1, controllerNumber));
-            break;
+                break;
+            
+            // default: just compute modulators
+            default:
+                this.voices.forEach(v => computeModulators(v, this.midiControllers, 1, controllerNumber));
+                break;
+        }
     }
     this.synth.callEvent("controllerchange", {
         channel: this.channelNumber,

package/synthetizer/worklet_system/worklet_methods/controller_control/reset_controllers.js

@@ -25,6 +25,7 @@ export function resetAllControllers(log = true)
         SpessaSynthInfo("%cResetting all controllers!", consoleColors.info);
     }
     this.callEvent("allcontrollerreset", undefined);
+    this.setSystem(DEFAULT_SYNTH_MODE);
     for (let channelNumber = 0; channelNumber < this.workletProcessorChannels.length; channelNumber++)
     {
         this.workletProcessorChannels[channelNumber].resetControllers();
@@ -37,11 +38,11 @@ export function resetAllControllers(log = true)
         // if preset is unlocked, switch to non-drums and call event
         if (!ch.lockPreset)
         {
-            ch.presetUsesOverride = true;
             ch.setBankSelect(0);
             if (channelNumber % 16 === DEFAULT_PERCUSSION)
             {
-                this.workletProcessorChannels[channelNumber].setPreset(this.drumPreset);
+                ch.setPreset(this.drumPreset);
+                ch.presetUsesOverride = this.defaultDrumsUsesOverride;
                 ch.drumChannel = true;
                 this.callEvent("drumchange", {
                     channel: channelNumber,
@@ -51,6 +52,7 @@ export function resetAllControllers(log = true)
             else
             {
                 ch.drumChannel = false;
+                ch.presetUsesOverride = this.defaultDrumsUsesOverride;
                 ch.setPreset(this.defaultPreset);
                 this.callEvent("drumchange", {
                     channel: channelNumber,
@@ -66,11 +68,14 @@ export function resetAllControllers(log = true)
             });
         }
         
+        const presetBank = ch.preset.bank;
+        const sentBank = presetBank === 128 ? 128 : (ch.presetUsesOverride ? presetBank + this.soundfontBankOffset : presetBank);
+        
         // call program change
         this.callEvent("programchange", {
             channel: channelNumber,
             program: ch.preset.program,
-            bank: ch.getBankSelect(),
+            bank: sentBank,
             userCalled: false
         });
         
@@ -110,7 +115,6 @@ export function resetAllControllers(log = true)
     }
     
     this.setMIDIVolume(1);
-    this.system = DEFAULT_SYNTH_MODE;
 }
 
 /**

package/synthetizer/worklet_system/worklet_methods/program_change.js

@@ -11,31 +11,36 @@ export function programChange(programNumber, userChange = false)
         return;
     }
     // always 128 for percussion
-    const bank = this.getBankSelect();
+    let bank = this.getBankSelect();
     let sentBank;
     let preset;
     
+    const isXG = this.isXGChannel;
     // check if override
     if (this.synth.overrideSoundfont)
     {
         const bankWithOffset = bank === 128 ? 128 : bank - this.synth.soundfontBankOffset;
-        const p = this.synth.overrideSoundfont.getPresetNoFallback(bankWithOffset, programNumber);
+        const p = this.synth.overrideSoundfont.getPresetNoFallback(
+            bankWithOffset,
+            programNumber,
+            isXG
+        );
         if (p)
         {
-            sentBank = bank;
+            sentBank = p.bank === 128 ? 128 : p.bank + this.synth.soundfontBankOffset;
             preset = p;
             this.presetUsesOverride = true;
         }
         else
         {
-            preset = this.synth.soundfontManager.getPreset(bank, programNumber);
+            preset = this.synth.soundfontManager.getPreset(bank, programNumber, isXG);
             sentBank = preset.bank;
             this.presetUsesOverride = false;
         }
     }
     else
     {
-        preset = this.synth.soundfontManager.getPreset(bank, programNumber);
+        preset = this.synth.soundfontManager.getPreset(bank, programNumber, isXG);
         sentBank = preset.bank;
         this.presetUsesOverride = false;
     }

package/synthetizer/worklet_system/worklet_methods/soundfont_management/clear_sound_font.js

@@ -11,8 +11,7 @@ export function clearSoundFont(sendPresets = true, clearOverride = true)
         delete this.overrideSoundfont;
         this.overrideSoundfont = undefined;
     }
-    this.defaultPreset = this.getPreset(0, 0);
-    this.drumPreset = this.getPreset(128, 0);
+    this.getDefaultPresets();
     this.cachedVoices = [];
     
     for (let i = 0; i < this.workletProcessorChannels.length; i++)
@@ -20,7 +19,7 @@ export function clearSoundFont(sendPresets = true, clearOverride = true)
         const channelObject = this.workletProcessorChannels[i];
         if (!clearOverride || (clearOverride && channelObject.presetUsesOverride))
         {
-            channelObject.lockPreset = false;
+            channelObject.setPresetLock(false);
         }
         channelObject.programChange(channelObject.preset.program);
     }

package/synthetizer/worklet_system/worklet_methods/soundfont_management/get_preset.js

@@ -10,11 +10,11 @@ export function getPreset(bank, program)
     {
         // if override soundfont
         const bankWithOffset = bank === 128 ? 128 : bank - this.soundfontBankOffset;
-        const preset = this.overrideSoundfont.getPresetNoFallback(bankWithOffset, program);
+        const preset = this.overrideSoundfont.getPresetNoFallback(bankWithOffset, program, this.system === "xg");
         if (preset)
         {
             return preset;
         }
     }
-    return this.soundfontManager.getPreset(bank, program);
+    return this.soundfontManager.getPreset(bank, program, this.system === "xg");
 }

package/synthetizer/worklet_system/worklet_methods/soundfont_management/reload_sound_font.js

@@ -32,8 +32,7 @@ export function reloadSoundFont(buffer, isOverride = false)
         });
         return;
     }
-    this.defaultPreset = this.getPreset(0, 0);
-    this.drumPreset = this.getPreset(128, 0);
+    this.getDefaultPresets();
     this.workletProcessorChannels.forEach(c =>
         c.programChange(c.preset.program)
     );

package/synthetizer/worklet_system/worklet_methods/system_exclusive.js

@@ -148,17 +148,17 @@ export function systemExclusive(messageData, channelOffset = 0)
                     if (messageData[3] === 0x01)
                     {
                         SpessaSynthInfo("%cGM system on", consoleColors.info);
-                        this.system = "gm";
+                        this.setSystem("gm");
                     }
                     else if (messageData[3] === 0x03)
                     {
                         SpessaSynthInfo("%cGM2 system on", consoleColors.info);
-                        this.system = "gm2";
+                        this.setSystem("gm2");
                     }
                     else
                     {
                         SpessaSynthInfo("%cGM system off, defaulting to GS", consoleColors.info);
-                        this.system = "gs";
+                        this.setSystem("gs");
                     }
                     break;
                 
@@ -312,14 +312,14 @@ export function systemExclusive(messageData, channelOffset = 0)
                         // this is a GS reset
                         SpessaSynthInfo("%cGS Reset received!", consoleColors.info);
                         this.resetAllControllers(false);
-                        this.system = "gs";
+                        this.setSystem("gs");
                     }
                     else if (messageValue === 0x7F)
                     {
                         // GS mode off
                         SpessaSynthInfo("%cGS system off, switching to GM2", consoleColors.info);
                         this.resetAllControllers(false);
-                        this.system = "gm2";
+                        this.setSystem("gm2");
                     }
                     return;
                 }
@@ -606,7 +606,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                         case 0x7E:
                             SpessaSynthInfo("%cXG system on", consoleColors.info);
                             this.resetAllControllers(false);
-                            this.system = "xg";
+                            this.setSystem("xg");
                             break;
                     }
                 }

package/synthetizer/worklet_system/worklet_methods/worklet_soundfont_manager/worklet_soundfont_manager.js

@@ -1,6 +1,7 @@
 import { SpessaSynthWarn } from "../../../../utils/loggin.js";
 import { WorkletSoundfontManagerMessageType } from "./sfman_message.js";
 import { loadSoundFont } from "../../../../soundfont/load_soundfont.js";
+import { isXGDrums } from "../../../../utils/xg_hacks.js";
 
 /**
  * @typedef {Object} SoundFontType
@@ -194,9 +195,10 @@ export class WorkletSoundfontManager
      * Gets a given preset from the soundfont stack
      * @param bankNumber {number}
      * @param programNumber {number}
+     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
      * @returns {BasicPreset} the preset
      */
-    getPreset(bankNumber, programNumber)
+    getPreset(bankNumber, programNumber, allowXGDrums = false)
     {
         if (this.soundfontList.length < 1)
         {
@@ -205,19 +207,25 @@ export class WorkletSoundfontManager
         for (const sf of this.soundfontList)
         {
             // check for the preset (with given offset)
-            const preset = sf.soundfont.getPresetNoFallback(bankNumber - sf.bankOffset, programNumber);
+            const preset = sf.soundfont.getPresetNoFallback(
+                bankNumber - sf.bankOffset,
+                programNumber,
+                allowXGDrums
+            );
             if (preset !== undefined)
             {
                 return preset;
             }
             // if not found, advance to the next soundfont
         }
+        const isDrum = bankNumber === 128 || (allowXGDrums && isXGDrums(bankNumber));
         // if none found, return the first correct preset found
-        if (bankNumber !== 128)
+        if (!isDrum)
         {
             for (const sf of this.soundfontList)
             {
-                const preset = sf.soundfont.presets.find(p => p.program === programNumber);
+                const preset = sf.soundfont.presets.find(p => p.program === programNumber && !p.isDrumPreset(
+                    allowXGDrums));
                 if (preset)
                 {
                     return preset;
@@ -230,7 +238,14 @@ export class WorkletSoundfontManager
         {
             for (const sf of this.soundfontList)
             {
-                const preset = sf.soundfont.presets.find(p => p.bank === 128);
+                // check for any drum type (127/128) and matching program
+                const p = sf.soundfont.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNumber);
+                if (p)
+                {
+                    return p;
+                }
+                // check for any drum preset
+                const preset = sf.soundfont.presets.find(p => p.isDrumPreset(allowXGDrums));
                 if (preset)
                 {
                     return preset;