spessasynth_lib 3.25.1 → 3.25.2

package/synthetizer/worklet_system/main_processor.js

@@ -191,6 +191,22 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
      */
     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 {{
@@ -235,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++)
@@ -303,6 +318,18 @@ 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}
      */

package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -186,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/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, true);
+        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/worklet_methods/controller_control/controller_change.js

@@ -66,18 +66,11 @@ export function controllerChange(controllerNumber, controllerValue, force = fals
             
             // special case: bank select
             case midiControllers.bankSelect:
-                if (!force)
-                {
-                    this.setBankSelect(controllerValue);
-                }
-                else
-                {
-                    this.bank = controllerValue;
-                }
+                this.setBankSelect(controllerValue);
                 break;
             
             case midiControllers.lsbForControl0BankSelect:
-                this.setBankSelect(controllerValue, false, true);
+                this.setBankSelect(controllerValue, true);
                 break;
             
             // check for RPN and NPRN and data entry

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

@@ -38,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, 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,
@@ -52,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,
@@ -67,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
         });
         

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/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;

package/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js

@@ -27,7 +27,8 @@ import { channelPressure } from "../worklet_methods/tuning_control/channel_press
 import { pitchWheel } from "../worklet_methods/tuning_control/pitch_wheel.js";
 import { setOctaveTuning } from "../worklet_methods/tuning_control/set_octave_tuning.js";
 import { programChange } from "../worklet_methods/program_change.js";
-import { parseBankSelect } from "../../../utils/xg_hacks.js";
+import { chooseBank, parseBankSelect } from "../../../utils/xg_hacks.js";
+import { DEFAULT_PERCUSSION } from "../../synth_constants.js";
 
 /**
  * This class represents a single MIDI Channel within the synthesizer.
@@ -114,6 +115,12 @@ class WorkletProcessorChannel
      */
     bank = 0;
     
+    /**
+     * The bank LSB number of the channel (used for patch changes in XG mode).
+     * @type {number}
+     */
+    bankLSB = 0;
+    
     /**
      * The preset currently assigned to the channel.
      * @type {BasicPreset}
@@ -126,6 +133,12 @@ class WorkletProcessorChannel
      */
     lockPreset = false;
     
+    /**
+     * Indicates the MIDI system when the preset was locked.
+     * @type {SynthSystem}
+     */
+    lockedSystem = "gs";
+    
     /**
      * Indicates whether the channel uses a preset from the override soundfont.
      * @type {boolean}
@@ -190,6 +203,11 @@ class WorkletProcessorChannel
         this.channelNumber = channelNumber;
     }
     
+    get isXGChannel()
+    {
+        return this.synth.system === "xg" || (this.lockPreset && this.lockedSystem === "xg");
+    }
+    
     /**
      * @param type {customControllers|number}
      * @param value {number}
@@ -231,32 +249,43 @@ class WorkletProcessorChannel
         ));
     }
     
+    /**
+     * @param locked {boolean}
+     */
+    setPresetLock(locked)
+    {
+        this.lockPreset = locked;
+        if (locked)
+        {
+            this.lockedSystem = this.synth.system;
+        }
+    }
+    
     /**
      * @param bank {number}
-     * @param force {boolean}
      * @param isLSB {boolean}
      */
-    setBankSelect(bank, force = false, isLSB = false)
+    setBankSelect(bank, isLSB = false)
     {
         if (this.lockPreset)
         {
             return;
         }
-        if (force)
+        if (isLSB)
         {
-            this.bank = bank;
+            this.bankLSB = bank;
         }
         else
         {
+            this.bank = bank;
             const bankLogic = parseBankSelect(
                 this.getBankSelect(),
                 bank,
                 this.synth.system,
-                isLSB,
+                false,
                 this.drumChannel,
                 this.channelNumber
             );
-            this.bank = bankLogic.newBank;
             switch (bankLogic.drumsStatus)
             {
                 default:
@@ -264,7 +293,11 @@ class WorkletProcessorChannel
                     break;
                 
                 case 1:
-                    this.setDrums(false);
+                    if (this.channelNumber % 16 === DEFAULT_PERCUSSION)
+                    {
+                        // cannot disable drums on channel 9
+                        this.bank = 127;
+                    }
                     break;
                 
                 case 2:
@@ -279,11 +312,7 @@ class WorkletProcessorChannel
      */
     getBankSelect()
     {
-        if (this.drumChannel)
-        {
-            return 128;
-        }
-        return this.bank;
+        return chooseBank(this.bank, this.bankLSB, this.drumChannel, this.isXGChannel);
     }
     
     /**
@@ -319,23 +348,17 @@ class WorkletProcessorChannel
             // clear transpose
             this.channelTransposeKeyShift = 0;
             this.drumChannel = true;
-            this.setPreset(this.synth.getPreset(this.getBankSelect(), this.preset.program));
         }
         else
         {
             this.drumChannel = false;
-            this.setPreset(
-                this.synth.getPreset(
-                    this.getBankSelect(),
-                    this.preset.program
-                )
-            );
         }
         this.presetUsesOverride = false;
         this.synth.callEvent("drumchange", {
             channel: this.channelNumber,
             isDrumChannel: this.drumChannel
         });
+        this.programChange(this.preset.program);
         this.synth.sendChannelProperties();
     }
     

package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -408,7 +408,7 @@ export function getWorkletVoices(channel,
     let preset = channelObject.preset;
     if (overridePatch)
     {
-        preset = this.soundfontManager.getPreset(bank, program);
+        preset = this.soundfontManager.getPreset(bank, program, this.system === "xg");
     }
     /**
      * @returns {WorkletVoice[]}
@@ -503,8 +503,7 @@ export function getWorkletVoices(channel,
                     targetKey,
                     realKey,
                     generators,
-                    sampleAndGenerators.modulators.map(m => Modulator.copy(m)),
-                    this.filterSmoothingFactor
+                    sampleAndGenerators.modulators.map(m => Modulator.copy(m))
                 )
             );
             return voices;

package/utils/xg_hacks.js

@@ -2,6 +2,8 @@ import { SpessaSynthInfo } from "./loggin.js";
 import { consoleColors } from "./other.js";
 import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
 
+export const XG_SFX_VOICE = 64;
+
 /**
  * @param bankNr {number}
  * @returns {boolean}
@@ -11,6 +13,15 @@ export function isXGDrums(bankNr)
     return bankNr === 120 || bankNr === 126 || bankNr === 127;
 }
 
+/**
+ * @param bank {number}
+ * @returns {boolean}
+ */
+export function isValidXGMSB(bank)
+{
+    return isXGDrums(bank) || bank === XG_SFX_VOICE;
+}
+
 /**
  * Bank select hacks abstracted here
  * @param bankBefore {number} the current bank number
@@ -29,12 +40,11 @@ export function parseBankSelect(bankBefore, bank, system, isLSB, isDrums, channe
     // 64 means SFX in MSB, so it is allowed
     let out = bankBefore;
     let drumsStatus = 0;
-    const isValidMSB = b => isXGDrums(b) || b === 64;
     if (isLSB)
     {
         if (system === "xg")
         {
-            if (!isValidMSB(bank))
+            if (!isValidXGMSB(bank))
             {
                 out = bank;
             }
@@ -59,7 +69,7 @@ export function parseBankSelect(bankBefore, bank, system, isLSB, isDrums, channe
                 break;
             
             case "xg":
-                canSetBankSelect = isValidMSB(bank);
+                canSetBankSelect = isValidXGMSB(bank);
                 // for xg, if msb is 120, 126 or 127, then it's drums
                 if (isXGDrums(bank))
                 {
@@ -112,17 +122,55 @@ export function parseBankSelect(bankBefore, bank, system, isLSB, isDrums, channe
 
 
 /**
+ * Chooses a bank number according to spessasynth logic
+ * That is:
+ * for GS, bank MSB if not drum, otherwise 128
+ * for XG: bank MSB if drum and MSB is valid, 128 othewise, bank MSB if it is SFX voice, LSB otherwise
  * @param msb {number}
  * @param lsb {number}
+ * @param isDrums {boolean}
+ * @param isXG {boolean}
+ * @returns {number}
  */
-export function chooseBank(msb, lsb)
+export function chooseBank(msb, lsb, isDrums, isXG)
 {
-    if (lsb > 0)
+    if (isXG)
     {
-        if (!isXGDrums(msb) && msb !== 64)
+        if (isDrums)
         {
-            return lsb;
+            if (isXGDrums(msb))
+            {
+                return msb;
+            }
+            else
+            {
+                return 128;
+            }
         }
+        else
+        {
+            // check for SFX
+            if (msb !== XG_SFX_VOICE)
+            {
+                // if lsb is 0 and msb is not, use that
+                if (lsb === 0 && msb !== 0)
+                {
+                    return msb;
+                }
+                if (!isValidXGMSB(lsb))
+                {
+                    return lsb;
+                }
+                return 0;
+            }
+            else
+            {
+                return XG_SFX_VOICE;
+            }
+        }
+    }
+    else
+    {
+        return isDrums ? 128 : msb;
     }
-    return msb;
 }