spessasynth_lib 3.25.1 → 3.25.2

package/midi_parser/midi_editor.js

@@ -6,6 +6,7 @@ import { consoleColors } from "../utils/other.js";
 import { customControllers } from "../synthetizer/worklet_system/worklet_utilities/controller_tables.js";
 import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
 import { isGMOn, isGSOn, isXGOn } from "../utils/sysex_detector.js";
+import { isXGDrums, XG_SFX_VOICE } from "../utils/xg_hacks.js";
 
 /**
  * @param ticks {number}
@@ -127,6 +128,11 @@ export function modifyMIDI(
     const midi = this;
     SpessaSynthGroupCollapsed("%cApplying changes to the MIDI file...", consoleColors.info);
     
+    SpessaSynthInfo("Desired program changes:", desiredProgramChanges);
+    SpessaSynthInfo("Desired CC changes:", desiredControllerChanges);
+    SpessaSynthInfo("Desired channels to clear:", desiredChannelsToClear);
+    SpessaSynthInfo("Desired channels to transpose:", desiredChannelsToTranspose);
+    
     /**
      * @type {Set<number>}
      */
@@ -337,7 +343,7 @@ export function modifyMIDI(
                     if (channelsToChangeProgram.has(channel))
                     {
                         const change = desiredProgramChanges.find(c => c.channel === channel);
-                        let desiredBank = change.bank;
+                        let desiredBank = Math.max(0, Math.min(change.bank, 127));
                         const desiredProgram = change.program;
                         SpessaSynthInfo(
                             `%cSetting %c${change.channel}%c to %c${desiredBank}:${desiredProgram}%c. Track num: %c${trackNum}`,
@@ -362,50 +368,61 @@ export function modifyMIDI(
                         );
                         addEventBefore(programChange);
                         
-                        // on xg, add lsb
-                        if (!change.isDrum && system === "xg")
+                        const addBank = (isLSB, v) =>
                         {
-                            const bankChangeLSB = getControllerChange(
+                            const bankChange = getControllerChange(
                                 midiChannel,
-                                midiControllers.lsbForControl0BankSelect,
-                                desiredBank,
+                                isLSB ? midiControllers.lsbForControl0BankSelect : midiControllers.bankSelect,
+                                v,
                                 e.ticks
                             );
-                            addEventBefore(bankChangeLSB);
-                        }
+                            addEventBefore(bankChange);
+                        };
                         
-                        // add the bank MSB
-                        const bankChange = getControllerChange(
-                            midiChannel,
-                            midiControllers.bankSelect,
-                            desiredBank,
-                            e.ticks
-                        );
-                        addEventBefore(bankChange);
-                        
-                        // is drums?
-                        // if so, adjust
-                        // do not add gs drum change on the drum channel
-                        if (change.isDrum)
+                        // on xg, add lsb
+                        if (system === "xg")
                         {
-                            if (system === "gs" && midiChannel !== DEFAULT_PERCUSSION)
+                            // xg drums: msb can be 120, 126 or 127
+                            if (change.isDrum)
                             {
                                 SpessaSynthInfo(
-                                    `%cAdding GS Drum change on track %c${trackNum}`,
+                                    `%cAdding XG Drum change on track %c${trackNum}`,
                                     consoleColors.recognized,
                                     consoleColors.value
                                 );
-                                addEventBefore(getDrumChange(midiChannel, e.ticks));
+                                addBank(false, isXGDrums(desiredBank) ? desiredBank : 127);
+                                addBank(true, 0);
                             }
-                            else if (system === "xg")
+                            else
                             {
+                                // sfx voice is set via MSB
+                                if (desiredBank === XG_SFX_VOICE)
+                                {
+                                    addBank(false, XG_SFX_VOICE);
+                                    addBank(true, 0);
+                                }
+                                else
+                                {
+                                    // add variation as LSB
+                                    addBank(false, 0);
+                                    addBank(true, desiredBank);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // add just msb
+                            addBank(false, desiredBank);
+                            
+                            if (change.isDrum && midiChannel !== DEFAULT_PERCUSSION)
+                            {
+                                // add gs drum change
                                 SpessaSynthInfo(
-                                    `%cAdding XG Drum change on track %c${trackNum}`,
+                                    `%cAdding GS Drum change on track %c${trackNum}`,
                                     consoleColors.recognized,
                                     consoleColors.value
                                 );
-                                // the system is xg. drums are on msb bank 127.
-                                desiredBank = 127;
+                                addEventBefore(getDrumChange(midiChannel, e.ticks));
                             }
                         }
                     }

package/midi_parser/rmidi_writer.js

@@ -204,46 +204,54 @@ export function writeRMIDI(
             const channel = channelsInfo[chNum];
             if (status === messageTypes.programChange)
             {
+                const isXG = system === "xg";
                 // check if the preset for this program exists
+                const initialProgram = e.messageData[0];
                 if (channel.drums)
                 {
-                    if (soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank === 128) === -1)
+                    if (soundfont.presets.findIndex(p => p.program === initialProgram && p.isDrumPreset(
+                        isXG,
+                        true
+                    )) === -1)
                     {
                         // doesn't exist. pick any preset that has bank 128.
-                        e.messageData[0] = soundfont.presets.find(p => p.bank === 128)?.program || 0;
+                        e.messageData[0] = soundfont.presets.find(p => p.isDrumPreset(isXG))?.program || 0;
+                        SpessaSynthInfo(
+                            `%cNo drum preset %c${initialProgram}%c. Channel %c${chNum}%c. Changing program to ${e.messageData[0]}.`,
+                            consoleColors.info,
+                            consoleColors.unrecognized,
+                            consoleColors.info,
+                            consoleColors.recognized,
+                            consoleColors.info
+                        );
                     }
                 }
                 else
                 {
-                    if (soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank !== 128) === -1)
+                    if (soundfont.presets.findIndex(p => p.program === initialProgram && !p.isDrumPreset(isXG)) === -1)
                     {
                         // doesn't exist. pick any preset that does not have bank 128.
-                        e.messageData[0] = soundfont.presets.find(p => p.bank !== 128)?.program || 0;
+                        e.messageData[0] = soundfont.presets.find(p => !p.isDrumPreset(isXG))?.program || 0;
+                        SpessaSynthInfo(
+                            `%cNo preset %c${initialProgram}%c. Channel %c${chNum}%c. Changing program to ${e.messageData[0]}.`,
+                            consoleColors.info,
+                            consoleColors.unrecognized,
+                            consoleColors.info,
+                            consoleColors.recognized,
+                            consoleColors.info
+                        );
                     }
                 }
                 channel.program = e.messageData[0];
                 // check if this preset exists for program and bank
                 const realBank = Math.max(0, channel.lastBank?.messageData[1] - mid.bankOffset); // make sure to take the previous bank offset into account
-                let bank = channel.drums ? 128 : realBank;
+                const bankLSB = (channel?.lastBankLSB?.messageData[1] - mid.bankOffset) || 0;
                 if (channel.lastBank === undefined)
                 {
                     continue;
                 }
-                if (system === "xg")
-                {
-                    if (channel.drums)
-                    {
-                        // drums override: set the bank to 127
-                        channelsInfo[chNum].lastBank.messageData[1] = 127;
-                    }
-                    else
-                    {
-                        // potential bank lsb override
-                        const bankLSB = (channel?.lastBankLSB?.messageData[1] - mid.bankOffset) || 0;
-                        bank = chooseBank(bank, bankLSB);
-                    }
-                }
-                
+                // adjust bank for XG
+                let bank = chooseBank(realBank, bankLSB, channel.drums, isXG);
                 if (soundfont.presets.findIndex(p => p.bank === bank && p.program === e.messageData[0]) === -1)
                 {
                     // no preset with this bank. find this program with any bank
@@ -254,7 +262,9 @@ export function writeRMIDI(
                         channel.lastBankLSB.messageData[1] = targetBank;
                     }
                     SpessaSynthInfo(
-                        `%cNo preset %c${bank}:${e.messageData[0]}%c. Changing bank to ${targetBank}.`,
+                        `%cNo preset %c${bank}:${e.messageData[0]}%c. Channel %c${chNum}%c. Changing bank to ${targetBank}.`,
+                        consoleColors.info,
+                        consoleColors.unrecognized,
                         consoleColors.info,
                         consoleColors.recognized,
                         consoleColors.info
@@ -263,15 +273,21 @@ export function writeRMIDI(
                 else
                 {
                     // There is a preset with this bank. Add offset. For drums add the normal offset.
-                    let drumBank = system === "xg" ? 127 : 0;
-                    const newBank = (bank === 128 ? drumBank : realBank) + bankOffset;
+                    let drumBank = bank;
+                    if (system === "xg" && bank === 128)
+                    {
+                        bank = 127;
+                    }
+                    const newBank = (bank === 128 ? 128 : drumBank) + bankOffset;
                     channel.lastBank.messageData[1] = newBank;
-                    if (channel?.lastBankLSB?.messageData)
+                    if (channel?.lastBankLSB?.messageData && !channel.drums)
                     {
                         channel.lastBankLSB.messageData[1] = channel.lastBankLSB.messageData[1] - mid.bankOffset + bankOffset;
                     }
                     SpessaSynthInfo(
-                        `%cPreset %c${bank}:${e.messageData[0]}%c exists. Changing bank to ${newBank}.`,
+                        `%cPreset %c${bank}:${e.messageData[0]}%c exists. Channel %c${chNum}%c.  Changing bank to ${newBank}.`,
+                        consoleColors.info,
+                        consoleColors.recognized,
                         consoleColors.info,
                         consoleColors.recognized,
                         consoleColors.info
@@ -307,16 +323,13 @@ export function writeRMIDI(
             {
                 channel.drums = false;
             }
-            if (bankNumber === intepretation.newBank || channel.drums)
+            if (isLSB)
             {
-                if (isLSB)
-                {
-                    channel.lastBankLSB = e;
-                }
-                else
-                {
-                    channel.lastBank = e;
-                }
+                channel.lastBankLSB = e;
+            }
+            else
+            {
+                channel.lastBank = e;
             }
         }
         
@@ -370,7 +383,8 @@ export function writeRMIDI(
             const ticks = track[indexToAdd].ticks;
             const targetBank = (soundfont.getPreset(
                 0,
-                has.program
+                has.program,
+                system === "xg"
             )?.bank + bankOffset) || bankOffset;
             track.splice(indexToAdd, 0, new MIDIMessage(
                 ticks,

package/midi_parser/used_keys_loaded.js

@@ -8,7 +8,7 @@ import { isGSDrumsOn, isXGOn } from "../utils/sysex_detector.js";
 /**
  * Gets the used programs and keys for this MIDI file with a given sound bank
  * @this {BasicMIDI}
- * @param soundfont {{getPreset: function(number, number): BasicPreset}} - the sound bank
+ * @param soundfont {BasicSoundBank|WorkletSoundfontManager} - the sound bank
  * @returns {Object<string, Set<string>>}
  */
 export function getUsedProgramsAndKeys(soundfont)
@@ -21,7 +21,7 @@ export function getUsedProgramsAndKeys(soundfont)
     // Find every bank:program combo and every key:velocity for each. Make sure to care about ports and drums
     const channelsAmount = 16 + mid.midiPortChannelOffsets.reduce((max, cur) => cur > max ? cur : max);
     /**
-     * @type {{program: number, bank: number, bankLSB: number, drums: boolean, string: string}[]}
+     * @type {{program: number, bank: number, bankLSB: number, drums: boolean, string: string, actualBank: number}[]}
      */
     const channelPresets = [];
     for (let i = 0; i < channelsAmount; i++)
@@ -31,20 +31,23 @@ export function getUsedProgramsAndKeys(soundfont)
             program: 0,
             bank: bank,
             bankLSB: 0,
+            actualBank: bank,
             drums: i % 16 === DEFAULT_PERCUSSION, // drums appear on 9 every 16 channels,
             string: `${bank}:0`
         });
     }
     
+    // check for xg
+    let system = "gs";
+    
     function updateString(ch)
     {
-        const bank = chooseBank(ch.bank, ch.bankLSB);
+        const bank = chooseBank(ch.bank, ch.bankLSB, ch.drums, system === "xg");
         // check if this exists in the soundfont
-        let exists = soundfont.getPreset(bank, ch.program);
-        ch.bank = exists.bank;
-        ch.bankLSB = 0;
+        let exists = soundfont.getPreset(bank, ch.program, system === "xg");
+        ch.actualBank = exists.bank;
         ch.program = exists.program;
-        ch.string = ch.bank + ":" + ch.program;
+        ch.string = ch.actualBank + ":" + ch.program;
         if (!usedProgramsAndKeys[ch.string])
         {
             SpessaSynthInfo(
@@ -90,8 +93,11 @@ export function getUsedProgramsAndKeys(soundfont)
     }
     
     const ports = mid.midiPorts.slice();
-    // check for xg
-    let system = "gs";
+    // initialize
+    channelPresets.forEach(c =>
+    {
+        updateString(c);
+    });
     while (remainingTracks > 0)
     {
         let trackNum = findFirstEventIndex();
@@ -142,6 +148,14 @@ export function getUsedProgramsAndKeys(soundfont)
                 }
                 const bank = event.messageData[1];
                 const realBank = Math.max(0, bank - mid.bankOffset);
+                if (isLSB)
+                {
+                    ch.bankLSB = realBank;
+                }
+                else
+                {
+                    ch.bank = realBank;
+                }
                 // interpret the bank
                 const intepretation = parseBankSelect(
                     ch.bank,
@@ -151,7 +165,6 @@ export function getUsedProgramsAndKeys(soundfont)
                     ch.drums,
                     channel
                 );
-                
                 switch (intepretation.drumsStatus)
                 {
                     case 0:
@@ -162,7 +175,6 @@ export function getUsedProgramsAndKeys(soundfont)
                         // drums changed to off
                         // drum change is a program change
                         ch.drums = false;
-                        ch.bank = realBank;
                         updateString(ch);
                         break;
                     
@@ -170,18 +182,9 @@ export function getUsedProgramsAndKeys(soundfont)
                         // drums changed to on
                         // drum change is a program change
                         ch.drums = true;
-                        ch.bank = 128;
                         updateString(ch);
                         break;
                 }
-                if (isLSB)
-                {
-                    ch.bankLSB = intepretation.newBank;
-                }
-                else
-                {
-                    ch.bank = ch.drums ? 128 : intepretation.newBank;
-                }
                 // do not update the data, bank change doesn't change the preset
                 break;
             
@@ -191,7 +194,6 @@ export function getUsedProgramsAndKeys(soundfont)
                     // that's a note off
                     continue;
                 }
-                updateString(ch);
                 usedProgramsAndKeys[ch.string].add(`${event.messageData[0]}-${event.messageData[1]}`);
                 break;
             
@@ -203,6 +205,10 @@ export function getUsedProgramsAndKeys(soundfont)
                     if (isXGOn(event))
                     {
                         system = "xg";
+                        SpessaSynthInfo(
+                            "%cXG on detected!",
+                            consoleColors.recognized
+                        );
                     }
                     continue;
                 }
@@ -210,7 +216,6 @@ export function getUsedProgramsAndKeys(soundfont)
                 const isDrum = !!(event.messageData[7] > 0 && event.messageData[5] >> 4);
                 ch = channelPresets[sysexChannel];
                 ch.drums = isDrum;
-                ch.bank = isDrum ? 128 : 0;
                 updateString(ch);
                 break;
             

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.25.1",
+  "version": "3.25.2",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "type": "module",

package/soundfont/basic_soundfont/basic_preset.js

@@ -9,6 +9,7 @@
  */
 import { generatorTypes } from "./generator.js";
 import { Modulator } from "./modulator.js";
+import { isXGDrums } from "../../utils/xg_hacks.js";
 
 export class BasicPreset
 {
@@ -78,6 +79,17 @@ export class BasicPreset
         this.defaultModulators = modulators;
     }
     
+    /**
+     * @param allowXG {boolean}
+     * @param allowSFX {boolean}
+     * @returns {boolean}
+     */
+    isDrumPreset(allowXG, allowSFX = false)
+    {
+        // sfx is not cool
+        return this.bank === 128 || (allowXG && isXGDrums(this.bank) && (this.bank !== 126 || allowSFX));
+    }
+    
     deletePreset()
     {
         this.presetZones.forEach(z => z.deleteZone());

package/soundfont/basic_soundfont/basic_soundfont.js

@@ -14,6 +14,7 @@ import { BasicInstrumentZone, BasicPresetZone } from "./basic_zones.js";
 import { Generator, generatorTypes } from "./generator.js";
 import { BasicInstrument } from "./basic_instrument.js";
 import { BasicPreset } from "./basic_preset.js";
+import { isXGDrums } from "../../utils/xg_hacks.js";
 
 class BasicSoundBank
 {
@@ -392,54 +393,63 @@ class BasicSoundBank
      * Get the appropriate preset, undefined if not foun d
      * @param bankNr {number}
      * @param programNr {number}
-     * @param fallbackToProgram {boolean} if true, if no exact match is found, will use any bank with the given preset
+     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
      * @return {BasicPreset}
      */
-    getPresetNoFallback(bankNr, programNr, fallbackToProgram = false)
+    getPresetNoFallback(bankNr, programNr, allowXGDrums = false)
     {
+        // check for exact match
         const p = this.presets.find(p => p.bank === bankNr && p.program === programNr);
         if (p)
         {
             return p;
         }
-        if (fallbackToProgram === false)
-        {
-            return undefined;
-        }
-        if (bankNr === 128)
+        // no match...
+        const isDrum = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
+        if (isDrum)
         {
-            // any drum preset
-            return this.presets.find(p => p.bank === 128);
+            if (allowXGDrums)
+            {
+                // try any drum preset with matching program?
+                const p = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
+                if (p)
+                {
+                    return p;
+                }
+            }
         }
-        return this.presets.find(p => p.program === programNr);
+        return undefined;
     }
     
     /**
      * Get the appropriate preset
      * @param bankNr {number}
      * @param programNr {number}
+     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
      * @returns {BasicPreset}
      */
-    getPreset(bankNr, programNr)
+    getPreset(bankNr, programNr, allowXGDrums = false)
     {
         // check for exact match
         let preset = this.presets.find(p => p.bank === bankNr && p.program === programNr);
+        const isDrums = bankNr === 128 || (allowXGDrums && isXGDrums(bankNr));
         if (!preset)
         {
             // no match...
-            if (bankNr === 128)
+            if (isDrums)
             {
                 // drum preset: find any preset with bank 128
-                preset = this.presets.find(p => p.bank === 128 && p.program === programNr);
+                preset = this.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNr);
                 if (!preset)
                 {
-                    preset = this.presets.find(p => p.bank === 128);
+                    // only allow 128, otherwise it would default to XG SFX
+                    preset = this.presets.find(p => p.isDrumPreset(allowXGDrums));
                 }
             }
             else
             {
                 // non-drum preset: find any preset with the given program that is not a drum preset
-                preset = this.presets.find(p => p.program === programNr && p.bank !== 128);
+                preset = this.presets.find(p => p.program === programNr && !p.isDrumPreset(allowXGDrums));
             }
             if (preset)
             {

package/soundfont/dls/dls_preset.js

@@ -15,7 +15,17 @@ export class DLSPreset extends BasicPreset
         // use stock default modulators, dls won't ever have DMOD chunk
         super(defaultModulators);
         this.program = ulInstrument & 127;
-        this.bank = (ulBank >> 8) & 127;
+        const bankMSB = (ulBank >> 8) & 127;
+        const bankLSB = ulBank & 127;
+        // switch accordingly
+        if (bankMSB > 0)
+        {
+            this.bank = bankMSB;
+        }
+        else
+        {
+            this.bank = bankLSB;
+        }
         const isDrums = ulBank >> 31;
         if (isDrums)
         {