spessasynth_lib 3.25.0 → 3.25.2

package/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js

@@ -27,6 +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 { chooseBank, parseBankSelect } from "../../../utils/xg_hacks.js";
+import { DEFAULT_PERCUSSION } from "../../synth_constants.js";
 
 /**
  * This class represents a single MIDI Channel within the synthesizer.
@@ -113,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}
@@ -125,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}
@@ -189,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}
@@ -230,14 +249,61 @@ class WorkletProcessorChannel
         ));
     }
     
+    /**
+     * @param locked {boolean}
+     */
+    setPresetLock(locked)
+    {
+        this.lockPreset = locked;
+        if (locked)
+        {
+            this.lockedSystem = this.synth.system;
+        }
+    }
+    
     /**
      * @param bank {number}
+     * @param isLSB {boolean}
      */
-    setBankSelect(bank)
+    setBankSelect(bank, isLSB = false)
     {
-        if (!this.lockPreset)
+        if (this.lockPreset)
+        {
+            return;
+        }
+        if (isLSB)
+        {
+            this.bankLSB = bank;
+        }
+        else
         {
             this.bank = bank;
+            const bankLogic = parseBankSelect(
+                this.getBankSelect(),
+                bank,
+                this.synth.system,
+                false,
+                this.drumChannel,
+                this.channelNumber
+            );
+            switch (bankLogic.drumsStatus)
+            {
+                default:
+                case 0:
+                    break;
+                
+                case 1:
+                    if (this.channelNumber % 16 === DEFAULT_PERCUSSION)
+                    {
+                        // cannot disable drums on channel 9
+                        this.bank = 127;
+                    }
+                    break;
+                
+                case 2:
+                    this.setDrums(true);
+                    break;
+            }
         }
     }
     
@@ -246,11 +312,7 @@ class WorkletProcessorChannel
      */
     getBankSelect()
     {
-        if (this.drumChannel)
-        {
-            return 128;
-        }
-        return this.bank;
+        return chooseBank(this.bank, this.bankLSB, this.drumChannel, this.isXGChannel);
     }
     
     /**
@@ -286,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/sysex_detector.js

@@ -0,0 +1,46 @@
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isXGOn(e)
+{
+    return e.messageData[0] === 0x43 && // Yamaha
+        e.messageData[2] === 0x4C &&    // XG ON
+        e.messageData[5] === 0x7E &&
+        e.messageData[6] === 0x00;
+}
+
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isGSDrumsOn(e)
+{
+    return e.messageData[0] === 0x41 &&     // roland
+        e.messageData[2] === 0x42 &&        // GS
+        e.messageData[3] === 0x12 &&        // GS
+        e.messageData[4] === 0x40 &&        // system parameter
+        (e.messageData[5] & 0x10) !== 0 &&  // part parameter
+        e.messageData[6] === 0x15;          // drum pars
+}
+
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isGSOn(e)
+{
+    return e.messageData[0] === 0x41  // roland
+        && e.messageData[2] === 0x42  // GS
+        && e.messageData[6] === 0x7F; // Mode set
+}
+
+/**
+ * @param e {MIDIMessage}
+ * @returns boolean
+ */
+export function isGMOn(e)
+{
+    return e.messageData[0] === 0x7E  // non realtime
+        && e.messageData[2] === 0x09; // gm system
+}

package/utils/xg_hacks.js

@@ -0,0 +1,176 @@
+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}
+ */
+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
+ * @param bank {number} the cc change bank number
+ * @param system {SynthSystem} MIDI system
+ * @param isLSB {boolean} is bank LSB?
+ * @param isDrums {boolean} is drum channel?
+ * @param channelNumber {number} channel number
+ * @returns {{
+ *     newBank: number,
+ *     drumsStatus: 0|1|2
+ * }} 0 - unchanged, 1 - OFF, 2 - ON
+ */
+export function parseBankSelect(bankBefore, bank, system, isLSB, isDrums, channelNumber)
+{
+    // 64 means SFX in MSB, so it is allowed
+    let out = bankBefore;
+    let drumsStatus = 0;
+    if (isLSB)
+    {
+        if (system === "xg")
+        {
+            if (!isValidXGMSB(bank))
+            {
+                out = bank;
+            }
+        }
+        else if (system === "gm2")
+        {
+            out = bank;
+        }
+    }
+    else
+    {
+        let canSetBankSelect = true;
+        switch (system)
+        {
+            case "gm":
+                // gm ignores bank select
+                SpessaSynthInfo(
+                    `%cIgnoring the Bank Select (${bank}), as the synth is in GM mode.`,
+                    consoleColors.info
+                );
+                canSetBankSelect = false;
+                break;
+            
+            case "xg":
+                canSetBankSelect = isValidXGMSB(bank);
+                // for xg, if msb is 120, 126 or 127, then it's drums
+                if (isXGDrums(bank))
+                {
+                    drumsStatus = 2;
+                }
+                else
+                {
+                    // drums shall not be disabled on channel 9
+                    if (channelNumber % 16 !== DEFAULT_PERCUSSION)
+                    {
+                        drumsStatus = 1;
+                    }
+                }
+                break;
+            
+            case "gm2":
+                if (bank === 120)
+                {
+                    drumsStatus = 2;
+                }
+                else
+                {
+                    if (channelNumber % 16 !== DEFAULT_PERCUSSION)
+                    {
+                        drumsStatus = 1;
+                    }
+                }
+        }
+        
+        if (isDrums)
+        {
+            // 128 for percussion channel
+            bank = 128;
+        }
+        if (bank === 128 && !isDrums)
+        {
+            // if a channel is not for percussion, default to bank current
+            bank = bankBefore;
+        }
+        if (canSetBankSelect)
+        {
+            out = bank;
+        }
+    }
+    return {
+        newBank: out,
+        drumsStatus: drumsStatus
+    };
+}
+
+
+/**
+ * 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, isDrums, isXG)
+{
+    if (isXG)
+    {
+        if (isDrums)
+        {
+            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;
+    }
+}