spessasynth_lib 3.25.0 → 3.25.2

package/midi_parser/midi_editor.js

@@ -5,6 +5,8 @@ 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}
@@ -126,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>}
      */
@@ -336,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}`,
@@ -361,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);
-                        }
-                        
-                        // add the bank MSB
-                        const bankChange = getControllerChange(
-                            midiChannel,
-                            midiControllers.bankSelect,
-                            desiredBank,
-                            e.ticks
-                        );
-                        addEventBefore(bankChange);
+                            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
+                            {
+                                // 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 if (system === "xg")
+                        }
+                        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));
                             }
                         }
                     }
@@ -450,12 +468,7 @@ export function modifyMIDI(
             
             case messageTypes.systemExclusive:
                 // check for xg on
-                if (
-                    e.messageData[0] === 0x43 && // Yamaha
-                    e.messageData[2] === 0x4C && // XG ON
-                    e.messageData[5] === 0x7E &&
-                    e.messageData[6] === 0x00
-                )
+                if (isXGOn(e))
                 {
                     SpessaSynthInfo("%cXG system on detected", consoleColors.info);
                     system = "xg";
@@ -479,11 +492,7 @@ export function modifyMIDI(
                 }
                 else
                     // check for GS on
-                if (
-                    e.messageData[0] === 0x41    // roland
-                    && e.messageData[2] === 0x42 // GS
-                    && e.messageData[6] === 0x7F // Mode set
-                )
+                if (isGSOn(e))
                 {
                     // that's a GS on, we're done here
                     addedGs = true;
@@ -495,10 +504,7 @@ export function modifyMIDI(
                 }
                 else
                     // check for GM/2 on
-                if (
-                    e.messageData[0] === 0x7E // non realtime
-                    && e.messageData[2] === 0x09 // gm system
-                )
+                if (isGMOn(e))
                 {
                     // that's a GM/2 system change, remove it!
                     SpessaSynthInfo(
@@ -511,7 +517,7 @@ export function modifyMIDI(
         }
     }
     // check for gs
-    if (!addedGs)
+    if (!addedGs && desiredProgramChanges.length > 0)
     {
         // gs is not on, add it on the first track at index 0 (or 1 if track name is first)
         let index = 0;

package/midi_parser/rmidi_writer.js

@@ -7,6 +7,8 @@ import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo } from "../utils
 import { consoleColors } from "../utils/other.js";
 import { writeLittleEndian } from "../utils/byte_functions/little_endian.js";
 import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
+import { chooseBank, parseBankSelect } from "../utils/xg_hacks.js";
+import { isGMOn, isGSDrumsOn, isGSOn, isXGOn } from "../utils/sysex_detector.js";
 
 /**
  * @enum {string}
@@ -122,6 +124,7 @@ export function writeRMIDI(
          *     program: number,
          *     drums: boolean,
          *     lastBank: MIDIMessage,
+         *     lastBankLSB: MIDIMessage,
          *     hasBankSelect: boolean
          * }[]}
          */
@@ -132,6 +135,7 @@ export function writeRMIDI(
                 program: 0,
                 drums: i % 16 === DEFAULT_PERCUSSION, // drums appear on 9 every 16 channels,
                 lastBank: undefined,
+                lastBankLSB: undefined,
                 hasBankSelect: false
             });
         }
@@ -166,37 +170,18 @@ export function writeRMIDI(
             if (status === messageTypes.systemExclusive)
             {
                 // check for drum sysex
-                if (
-                    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 part
-                )
+                if (!isGSDrumsOn(e))
                 {
                     // check for XG
-                    if (
-                        e.messageData[0] === 0x43 && // yamaha
-                        e.messageData[2] === 0x4C && // sXG ON
-                        e.messageData[5] === 0x7E &&
-                        e.messageData[6] === 0x00
-                    )
+                    if (isXGOn(e))
                     {
                         system = "xg";
                     }
-                    else if (
-                        e.messageData[0] === 0x41    // roland
-                        && e.messageData[2] === 0x42 // GS
-                        && e.messageData[6] === 0x7F // Mode set
-                    )
+                    else if (isGSOn(e))
                     {
                         system = "gs";
                     }
-                    else if (
-                        e.messageData[0] === 0x7E // non realtime
-                        && e.messageData[2] === 0x09 // gm system
-                    )
+                    else if (isGMOn(e))
                     {
                         system = "gm";
                         unwantedSystems.push({
@@ -213,47 +198,73 @@ export function writeRMIDI(
             
             // program change
             const chNum = (e.messageStatusByte & 0xF) + portOffset;
+            /**
+             * @type {{program: number, drums: boolean, lastBank: MIDIMessage, lastBankLSB: MIDIMessage, hasBankSelect: boolean}}
+             */
             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
-                const bank = channel.drums ? 128 : realBank;
+                const bankLSB = (channel?.lastBankLSB?.messageData[1] - mid.bankOffset) || 0;
                 if (channel.lastBank === undefined)
                 {
                     continue;
                 }
-                if (system === "xg" && channel.drums)
-                {
-                    // drums override: set the bank to 127
-                    channelsInfo[chNum].lastBank.messageData[1] = 127;
-                }
-                
+                // 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
                     const targetBank = (soundfont.presets.find(p => p.program === e.messageData[0])?.bank + bankOffset) || bankOffset;
                     channel.lastBank.messageData[1] = targetBank;
+                    if (channel?.lastBankLSB?.messageData)
+                    {
+                        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
@@ -262,11 +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 && !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
@@ -274,19 +295,42 @@ export function writeRMIDI(
                 }
                 continue;
             }
-            // we only care about bank select
-            if (e.messageData[0] !== midiControllers.bankSelect)
+            
+            // controller change
+            // we only care about bank-selects
+            const isLSB = e.messageData[0] === midiControllers.lsbForControl0BankSelect;
+            if (e.messageData[0] !== midiControllers.bankSelect && !isLSB)
             {
                 continue;
             }
             // bank select
             channel.hasBankSelect = true;
-            if (system === "xg")
+            const bankNumber = e.messageData[1];
+            // interpret
+            const intepretation = parseBankSelect(
+                channel?.lastBank?.messageData[1] || 0,
+                bankNumber,
+                system,
+                isLSB,
+                channel.drums,
+                chNum
+            );
+            if (intepretation.drumsStatus === 2)
+            {
+                channel.drums = true;
+            }
+            else if (intepretation.drumsStatus === 1)
+            {
+                channel.drums = false;
+            }
+            if (isLSB)
+            {
+                channel.lastBankLSB = e;
+            }
+            else
             {
-                // check for xg drums
-                channel.drums = e.messageData[1] === 120 || e.messageData[1] === 126 || e.messageData[1] === 127;
+                channel.lastBank = e;
             }
-            channel.lastBank = e;
         }
         
         // add missing bank selects
@@ -339,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

@@ -2,11 +2,13 @@ import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from
 import { consoleColors } from "../utils/other.js";
 import { messageTypes, midiControllers } from "./midi_message.js";
 import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
+import { chooseBank, parseBankSelect } from "../utils/xg_hacks.js";
+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)
@@ -19,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, 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++)
@@ -28,18 +30,24 @@ export function getUsedProgramsAndKeys(soundfont)
         channelPresets.push({
             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, ch.drums, system === "xg");
         // check if this exists in the soundfont
-        let exists = soundfont.getPreset(ch.bank, ch.program);
-        ch.bank = exists.bank;
+        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(
@@ -85,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();
@@ -124,7 +135,8 @@ export function getUsedProgramsAndKeys(soundfont)
                 break;
             
             case messageTypes.controllerChange:
-                if (event.messageData[0] !== midiControllers.bankSelect)
+                const isLSB = event.messageData[0] === midiControllers.lsbForControl0BankSelect;
+                if (event.messageData[0] !== midiControllers.bankSelect && !isLSB)
                 {
                     // we only care about bank select
                     continue;
@@ -136,24 +148,43 @@ export function getUsedProgramsAndKeys(soundfont)
                 }
                 const bank = event.messageData[1];
                 const realBank = Math.max(0, bank - mid.bankOffset);
-                if (system === "xg")
+                if (isLSB)
                 {
-                    // check for xg drums
-                    const drumsBool = bank === 120 || bank === 126 || bank === 127;
-                    if (drumsBool !== ch.drums)
-                    {
+                    ch.bankLSB = realBank;
+                }
+                else
+                {
+                    ch.bank = realBank;
+                }
+                // interpret the bank
+                const intepretation = parseBankSelect(
+                    ch.bank,
+                    realBank,
+                    system,
+                    isLSB,
+                    ch.drums,
+                    channel
+                );
+                switch (intepretation.drumsStatus)
+                {
+                    case 0:
+                        // no change
+                        break;
+                    
+                    case 1:
+                        // drums changed to off
                         // drum change is a program change
-                        ch.drums = drumsBool;
-                        ch.bank = ch.drums ? 128 : realBank;
+                        ch.drums = false;
                         updateString(ch);
-                    }
-                    else
-                    {
-                        ch.bank = ch.drums ? 128 : realBank;
-                    }
-                    continue;
+                        break;
+                    
+                    case 2:
+                        // drums changed to on
+                        // drum change is a program change
+                        ch.drums = true;
+                        updateString(ch);
+                        break;
                 }
-                channelPresets[channel].bank = realBank;
                 // do not update the data, bank change doesn't change the preset
                 break;
             
@@ -163,31 +194,21 @@ export function getUsedProgramsAndKeys(soundfont)
                     // that's a note off
                     continue;
                 }
-                updateString(ch);
                 usedProgramsAndKeys[ch.string].add(`${event.messageData[0]}-${event.messageData[1]}`);
                 break;
             
             case messageTypes.systemExclusive:
                 // check for drum sysex
-                if (
-                    event.messageData[0] !== 0x41 || // roland
-                    event.messageData[2] !== 0x42 || // GS
-                    event.messageData[3] !== 0x12 || // GS
-                    event.messageData[4] !== 0x40 || // system parameter
-                    (event.messageData[5] & 0x10) === 0 || // part parameter
-                    event.messageData[6] !== 0x15 // drum pars
-                
-                )
+                if (!isGSDrumsOn(event))
                 {
                     // check for XG
-                    if (
-                        event.messageData[0] === 0x43 && // yamaha
-                        event.messageData[2] === 0x4C && // sXG ON
-                        event.messageData[5] === 0x7E &&
-                        event.messageData[6] === 0x00
-                    )
+                    if (isXGOn(event))
                     {
                         system = "xg";
+                        SpessaSynthInfo(
+                            "%cXG on detected!",
+                            consoleColors.recognized
+                        );
                     }
                     continue;
                 }
@@ -195,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.0",
+  "version": "3.25.2",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "type": "module",

package/sequencer/sequencer.js

@@ -1,4 +1,3 @@
-import { MIDI } from "../midi_parser/midi_loader.js";
 import { Synthetizer } from "../synthetizer/synthetizer.js";
 import { messageTypes } from "../midi_parser/midi_message.js";
 import { workletMessageType } from "../synthetizer/worklet_system/message_protocol/worklet_message.js";

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());