spessasynth_lib 3.10.0 → 3.11.1

package/@types/midi_parser/midi_data.d.ts

@@ -92,6 +92,23 @@ export class MidiData {
      * @type {Uint8Array}
      */
     rawMidiName: Uint8Array;
+    /**
+     * Indicates if the midi has an embedded soundfont
+     * @type {boolean}
+     */
+    isEmbedded: boolean;
+    /**
+     * The RMID Info data if RMID, otherwise undefined
+     * @type {Object<string, IndexedByteArray>}
+     */
+    RMIDInfo: {
+        [x: string]: IndexedByteArray;
+    };
+    /**
+     * The bank offset for RMIDI
+     * @type {number}
+     */
+    bankOffset: number;
 }
 /**
  *

package/@types/midi_parser/midi_loader.d.ts

@@ -14,11 +14,29 @@ export class MIDI {
      * @type {ArrayBuffer}
      */
     embeddedSoundFont: ArrayBuffer;
+    /**
+     * The RMID Info data if RMID, otherwise undefined
+     * @type {Object<string, IndexedByteArray>}
+     */
+    RMIDInfo: {
+        [x: string]: IndexedByteArray;
+    };
+    /**
+     * The bank offset for RMIDI
+     * @type {number}
+     */
+    bankOffset: number;
     /**
      * Contains the copyright strings
      * @type {string}
      */
     copyright: string;
+    /**
+     * The MIDI name
+     * @type {string}
+     */
+    midiName: string;
+    rawMidiName: Uint8Array;
     format: number;
     tracksAmount: number;
     timeDivision: number;
@@ -76,8 +94,6 @@ export class MIDI {
         start: number;
         end: number;
     };
-    midiName: string;
-    rawMidiName: Uint8Array;
     fileName: string;
     /**
      * The total playback time, in seconds
@@ -101,5 +117,5 @@ export class MIDI {
      */
     private _ticksToSeconds;
 }
-import { MidiMessage } from './midi_message.js';
 import { IndexedByteArray } from '../utils/indexed_array.js';
+import { MidiMessage } from './midi_message.js';

package/@types/midi_parser/rmidi_writer.d.ts

@@ -3,7 +3,20 @@
  * @param soundfontBinary {Uint8Array}
  * @param mid {MIDI}
  * @param soundfont {SoundFont2}
+ * @param bankOffset {number} the bank offset for RMIDI
+ * @param encoding {string} the encoding of the RMIDI info chunk
  * @returns {IndexedByteArray}
  */
-export function writeRMIDI(soundfontBinary: Uint8Array, mid: MIDI, soundfont: SoundFont2): IndexedByteArray;
+export function writeRMIDI(soundfontBinary: Uint8Array, mid: MIDI, soundfont: SoundFont2, bankOffset?: number, encoding?: string): IndexedByteArray;
+export type RMIDINFOChunks = string;
+export namespace RMIDINFOChunks {
+    let name: string;
+    let copyright: string;
+    let creationDate: string;
+    let comment: string;
+    let engineer: string;
+    let software: string;
+    let encoding: string;
+    let bankOffset: string;
+}
 import { IndexedByteArray } from '../utils/indexed_array.js';

package/midi_parser/midi_data.js

@@ -97,6 +97,23 @@ export class MidiData
          * @type {Uint8Array}
          */
         this.rawMidiName = midi.rawMidiName;
+
+        /**
+         * Indicates if the midi has an embedded soundfont
+         * @type {boolean}
+         */
+        this.isEmbedded = midi.embeddedSoundFont !== undefined;
+
+        /**
+         * The RMID Info data if RMID, otherwise undefined
+         * @type {Object<string, IndexedByteArray>}
+         */
+        this.RMIDInfo = midi.RMIDInfo;
+        /**
+         * The bank offset for RMIDI
+         * @type {number}
+         */
+        this.bankOffset = midi.bankOffset;
     }
 }
 
@@ -124,5 +141,8 @@ export const DUMMY_MIDI_DATA = {
     rawMidiName: new Uint8Array([76, 111, 97, 100, 105, 110, 103, 46, 46, 46]), // "Loading..."
     usedChannelsOnTrack: [],
     timeDivision: 0,
-    keyRange: {min: 0, max: 127}
+    keyRange: {min: 0, max: 127},
+    isEmbedded: false,
+    RMIDInfo: undefined,
+    bankOffset: 0
 };

package/midi_parser/midi_editor.js

@@ -186,6 +186,21 @@ export function modifyMIDI(
                     midiSystem = "xg";
                     addedGs = true; // flag as true so gs won't get added
                 }
+                else
+                // check for xg program change
+                if (
+                    message.messageData[0] === 0x43 // yamaha
+                    && message.messageData[2] === 0x4C // XG
+                    && message.messageData[3] === 0x08 // part parameter
+                    && message.messageData[5] === 0x03 // program change
+                )
+                {
+                    programChanges.push({
+                        track: trackNum,
+                        message: message,
+                        channel: message.messageData[4]
+                    });
+                }
             }
         })
     });

package/midi_parser/midi_loader.js

@@ -6,6 +6,8 @@ import { readRIFFChunk } from '../soundfont/read/riff_chunk.js'
 import { readVariableLengthQuantity } from '../utils/byte_functions/variable_length_quantity.js'
 import { readBytesAsUintBigEndian } from '../utils/byte_functions/big_endian.js'
 import { readBytesAsString } from '../utils/byte_functions/string.js'
+import { readBytesAsUintLittleEndian } from '../utils/byte_functions/little_endian.js'
+import { RMIDINFOChunks } from './rmidi_writer.js'
 
 /**
  * midi_loader.js
@@ -29,17 +31,36 @@ class MIDI{
          */
         this.embeddedSoundFont = undefined;
 
+        /**
+         * The RMID Info data if RMID, otherwise undefined
+         * @type {Object<string, IndexedByteArray>}
+         */
+        this.RMIDInfo = undefined;
+        /**
+         * The bank offset for RMIDI
+         * @type {number}
+         */
+        this.bankOffset = 0;
+
         /**
          * Contains the copyright strings
          * @type {string}
          */
         this.copyright = "";
 
+        /**
+         * The MIDI name
+         * @type {string}
+         */
+        this.midiName = "";
+
+        this.rawMidiName = new Uint8Array(0);
+
         const initialString = readBytesAsString(binaryData, 4);
         binaryData.currentIndex -= 4;
         if(initialString === "RIFF")
         {
-            // possibly an RMID file (https://web.archive.org/web/20110610135604/http://www.midi.org/about-midi/rp29spec(rmid).pdf)
+            // possibly an RMID file (https://github.com/spessasus/SpessaSynth/wiki/About-RMIDI)
             // skip size
             binaryData.currentIndex += 8;
             const rmid = readBytesAsString(binaryData, 4, undefined, false);
@@ -71,6 +92,34 @@ class MIDI{
                         this.embeddedSoundFont = binaryData.slice(startIndex, startIndex + currentChunk.size).buffer;
                     }
                 }
+                else if(currentChunk.header === "LIST")
+                {
+                    const type = readBytesAsString(currentChunk.chunkData, 4);
+                    if(type === "INFO")
+                    {
+                        SpessaSynthInfo("%cFound RMIDI INFO chunk!", consoleColors.recognized);
+                        this.RMIDInfo = {};
+                        while(currentChunk.chunkData.currentIndex <= currentChunk.size)
+                        {
+                            const infoChunk = readRIFFChunk(currentChunk.chunkData, true);
+                            this.RMIDInfo[infoChunk.header] = infoChunk.chunkData;
+                        }
+                        if(this.RMIDInfo['ICOP'])
+                        {
+                            this.copyright += readBytesAsString(this.RMIDInfo['ICOP'], this.RMIDInfo['ICOP'].length);
+                        }
+                        if(this.RMIDInfo['INAM'])
+                        {
+                            this.rawMidiName = this.RMIDInfo[RMIDINFOChunks.name];
+                            this.midiName = readBytesAsString(this.rawMidiName,  this.rawMidiName.length);
+                        }
+                        this.bankOffset = 1; // defaults to 1
+                        if(this.RMIDInfo[RMIDINFOChunks.bankOffset])
+                        {
+                            this.bankOffset = readBytesAsUintLittleEndian(this.RMIDInfo[RMIDINFOChunks.bankOffset], 2);
+                        }
+                    }
+                }
             }
         }
         else
@@ -420,39 +469,40 @@ class MIDI{
          */
         this.loop = {start: loopStart, end: loopEnd};
 
-        // get track name
-        this.midiName = "";
-
-        this.rawMidiName = new Uint8Array(0);
-
         // midi name
-        if(this.tracks.length > 1)
+        if(this.midiName.length < 1)
         {
-            // if more than 1 track and the first track has no notes, just find the first trackName in the first track
-            if(this.tracks[0].find(
-                message => message.messageStatusByte >= messageTypes.noteOn
-                &&
-                message.messageStatusByte < messageTypes.systemExclusive
-            ) === undefined)
+            if (this.tracks.length > 1)
             {
+                // if more than 1 track and the first track has no notes, just find the first trackName in the first track
+                if (
+                    this.tracks[0].find(
+                    message => message.messageStatusByte >= messageTypes.noteOn
+                        &&
+                        message.messageStatusByte < messageTypes.systemExclusive
+                    ) === undefined
+                )
+                {
+
+                    let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
+                    if (name)
+                    {
+                        this.rawMidiName = name.messageData;
+                        this.midiName = readBytesAsString(name.messageData, name.messageData.length, undefined, false);
+                    }
+                }
+            }
+            else
+            {
+                // if only 1 track, find the first "track name" event
                 let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
-                if(name)
+                if (name)
                 {
                     this.rawMidiName = name.messageData;
                     this.midiName = readBytesAsString(name.messageData, name.messageData.length, undefined, false);
                 }
             }
         }
-        else
-        {
-            // if only 1 track, find the first "track name" event
-            let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
-            if(name)
-            {
-                this.rawMidiName = name.messageData;
-                this.midiName = readBytesAsString(name.messageData, name.messageData.length, undefined, false);
-            }
-        }
 
         this.fileName = fileName;
         this.midiName = this.midiName.trim();

package/midi_parser/rmidi_writer.js

@@ -5,19 +5,42 @@ import { getStringBytes } from '../utils/byte_functions/string.js'
 import { messageTypes, midiControllers, MidiMessage } from './midi_message.js'
 import { DEFAULT_PERCUSSION } from '../synthetizer/synthetizer.js'
 import { getGsOn } from './midi_editor.js'
-import { SpessaSynthInfo } from '../utils/loggin.js'
+import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo } from '../utils/loggin.js'
 import { consoleColors } from '../utils/other.js'
+import { writeLittleEndian } from '../utils/byte_functions/little_endian.js'
+
+/**
+ * @enum {string}
+ */
+export const RMIDINFOChunks = {
+    name: "INAM",
+    copyright: "ICOP",
+    creationDate: "ICRT",
+    comment: "ICMT",
+    engineer: "IENG",
+    software: "ISFT",
+    encoding: "IENC",
+    bankOffset: "DBNK"
+}
 
 /**
  *
  * @param soundfontBinary {Uint8Array}
  * @param mid {MIDI}
  * @param soundfont {SoundFont2}
+ * @param bankOffset {number} the bank offset for RMIDI
+ * @param encoding {string} the encoding of the RMIDI info chunk
  * @returns {IndexedByteArray}
  */
-export function writeRMIDI(soundfontBinary, mid, soundfont)
+export function writeRMIDI(soundfontBinary, mid, soundfont, bankOffset = 0, encoding = "Shift_JIS")
 {
-    // add 1 to bank. See wiki About-RMIDI
+    SpessaSynthGroup("%cWriting the RMIDI File...", consoleColors.info);
+    SpessaSynthInfo(`%cConfiguration: Bank offset: %c${bankOffset}%c, encoding: %c${encoding}`,
+        consoleColors.info,
+        consoleColors.value,
+        consoleColors.info,
+        consoleColors.value);
+    // add offset to bank. See wiki About-RMIDI
     // also fix presets that don't exists since midiplayer6 doesn't seem to default to 0 when nonextistent...
     let system = "gm";
     /**
@@ -25,6 +48,8 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
      * @type {{tNum: number, e: MidiMessage}[]}
      */
     let unwantedSystems = [];
+    const channelsAmount = 16 + mid.midiPortChannelOffsets.reduce((max, cur) => cur > max ? cur: max);
+    const channelHasBankSelects = Array(channelsAmount).fill(false);
     mid.tracks.forEach((t, trackNum) => {
         /**
          * @type {boolean[]}
@@ -45,6 +70,7 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
         let drums = Array(16).fill(false);
         drums[DEFAULT_PERCUSSION] = true;
         let programs = Array(16).fill(0);
+        const portOffset = mid.midiPortChannelOffsets[mid.midiPorts[trackNum]];
         t.forEach(e => {
             const status = e.messageStatusByte & 0xF0;
             if(
@@ -114,6 +140,7 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
                 {
                     if(soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank === 128) === -1)
                     {
+                        // doesn't exist. pick any preset that has the 128 bank.
                         e.messageData[0] = soundfont.presets.find(p => p.bank === 128)?.program || 0;
                     }
                 }
@@ -121,12 +148,14 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
                 {
                     if (soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank !== 128) === -1)
                     {
+                        // doesn't exist. pick any preset that does not have the 128 bank.
                         e.messageData[0] = soundfont.presets.find(p => p.bank !== 128)?.program || 0;
                     }
                 }
                 programs[e.messageStatusByte & 0xf] = e.messageData[0];
                 // check if this preset exists for program and bank
-                const bank = lastBankChanges[chNum]?.messageData[1];
+                const realBank = lastBankChanges[chNum]?.messageData[1] - mid.bankOffset; // make sure to take the previous bank offset into account
+                const bank = drums[chNum] ? 128 : realBank;
                 if(bank === undefined)
                 {
                     return;
@@ -140,17 +169,18 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
 
                 if(soundfont.presets.findIndex(p => p.bank === bank && p.program === e.messageData[0]) === -1)
                 {
-                    // no preset with this bank. set to 1 (0)
-                    lastBankChanges[chNum].messageData[1] = 1;
-                    SpessaSynthInfo(`%cNo preset %c${bank}:${e.messageData[0]}%c. Changing bank to 1.`,
+                    // no preset with this bank. find this program with any bank
+                    const targetPreset = (soundfont.presets.find(p => p.program === e.messageData[0])?.bank + bankOffset) || bankOffset;
+                    lastBankChanges[chNum].messageData[1] = targetPreset;
+                    SpessaSynthInfo(`%cNo preset %c${bank}:${e.messageData[0]}%c. Changing bank to ${targetPreset}.`,
                         consoleColors.info,
                         consoleColors.recognized,
                         consoleColors.info);
                 }
                 else
                 {
-                    // there is a preset with this bank. add 1
-                    lastBankChanges[chNum].messageData[1]++;
+                    // there is a preset with this bank. add offset
+                    lastBankChanges[chNum].messageData[1] = realBank + bankOffset;
                     SpessaSynthInfo(`%cPreset %c${bank}:${e.messageData[0]}%c exists. Changing bank to ${lastBankChanges[chNum].messageData[1]}.`,
                         consoleColors.info,
                         consoleColors.recognized,
@@ -164,6 +194,7 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
             }
             // bank select
             hasBankSelects[chNum] = true;
+            channelHasBankSelects[chNum + portOffset] = true;
             if(system === "xg")
             {
                 // check for xg drums
@@ -177,6 +208,11 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
             {
                 return;
             }
+            // if this channel has bank selects but not in this track specifically, ignore too
+            if(channelHasBankSelects[ch + portOffset] === true)
+            {
+                return;
+            }
             // find first program change (for the given channel)
             const status = messageTypes.programChange | ch;
             let indexToAdd = t.findIndex(e => e.messageStatusByte === status);
@@ -200,7 +236,7 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
                 indexToAdd = programIndex;
             }
             const ticks = t[indexToAdd].ticks;
-            const targetBank = (soundfont.getPreset(0, programs[ch])?.bank + 1) || 1;
+            const targetBank = (soundfont.getPreset(0, programs[ch])?.bank + bankOffset) || bankOffset;
             t.splice(indexToAdd,0, new MidiMessage(
                 ticks,
                 messageTypes.controllerChange | ch,
@@ -222,30 +258,60 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
     }
     const newMid = new IndexedByteArray(writeMIDIFile(mid).buffer);
 
-    // infodata for MidiPlayer6
+    // infodata for RMID
     const today = new Date().toLocaleString();
+    const DBNK = new IndexedByteArray(2);
+    writeLittleEndian(DBNK, bankOffset, 2);
+    const ICOP = mid.copyright.length > 0 ? getStringBytes(mid.copyright) : getStringBytes("Created by SpessaSynth");
     const infodata = combineArrays([
+        // icop: copyright
         writeRIFFChunk(
             new RiffChunk(
-                "ICOP",
-                11,
-                getStringBytes("SpessaSynth")
+                RMIDINFOChunks.copyright,
+                ICOP.length,
+                ICOP
             ),
             new IndexedByteArray([73, 78, 70, 79]) // "INFO"
         ),
+        // inam: name
         writeRIFFChunk(
             new RiffChunk(
-                "INAM",
+                RMIDINFOChunks.name,
                 mid.rawMidiName.length,
                 new IndexedByteArray(mid.rawMidiName.buffer)
             ),
         ),
+        // icrd: creation date
         writeRIFFChunk(
             new RiffChunk(
-                "ICRD",
+                RMIDINFOChunks.creationDate,
                 today.length,
                 getStringBytes(today)
             )
+        ),
+        // isft: software used
+        writeRIFFChunk(
+            new RiffChunk(
+                RMIDINFOChunks.software,
+                11,
+                getStringBytes("SpessaSynth"),
+            )
+        ),
+        // ienc: encoding for the info chunk
+        writeRIFFChunk(
+            new RiffChunk(
+                RMIDINFOChunks.encoding,
+                encoding.length,
+                getStringBytes(encoding)
+            )
+        ),
+        // dbnk: bank offset
+        writeRIFFChunk(
+            new RiffChunk(
+                RMIDINFOChunks.bankOffset,
+                2,
+                DBNK
+            )
         )
     ]);
 
@@ -263,6 +329,8 @@ export function writeRMIDI(soundfontBinary, mid, soundfont)
         )),
         soundfontBinary
     ]);
+    SpessaSynthInfo("%cFinished!", consoleColors.info)
+    SpessaSynthGroupEnd();
     return writeRIFFChunk(new RiffChunk(
         "RIFF",
         rmiddata.length,

package/midi_parser/used_keys_loaded.js

@@ -31,11 +31,6 @@ export function getUsedProgramsAndKeys(mid, soundfont)
     {
         // check if this exists in the soundfont
         let exists = soundfont.getPreset(ch.bank, ch.program);
-        if(exists.bank !== ch.bank && mid.embeddedSoundFont)
-        {
-            // maybe it doesn't exists becase RMIDI has a bank shift?
-            exists = soundfont.getPreset(ch.bank - 1, ch.program);
-        }
         ch.bank = exists.bank;
         ch.program = exists.program;
         ch.string = ch.bank + ":" + ch.program;
@@ -128,6 +123,7 @@ export function getUsedProgramsAndKeys(mid, soundfont)
                     continue;
                 }
                 const bank = event.messageData[1];
+                const realBank = Math.max(0, bank - mid.bankOffset);
                 if(system === "xg")
                 {
                     // check for xg drums
@@ -136,16 +132,16 @@ export function getUsedProgramsAndKeys(mid, soundfont)
                     {
                         // drum change is a program change
                         ch.drums = drumsBool;
-                        ch.bank = ch.drums ? 128 : bank;
+                        ch.bank = ch.drums ? 128 : realBank;
                         updateString(ch);
                     }
                     else
                     {
-                        ch.bank = ch.drums ? 128 : bank;
+                        ch.bank = ch.drums ? 128 : realBank;
                     }
                     continue;
                 }
-                channelPresets[channel].bank = bank;
+                channelPresets[channel].bank = realBank;
                 // do not update the data, bank change doesnt change the preset
                 break;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.10.0",
+  "version": "3.11.1",
   "description": "No compromise MIDI and SoundFont2 Synthesizer library",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/sequencer/worklet_sequencer/play.js

@@ -190,7 +190,7 @@ export function _playTo(time, ticks = undefined)
             });
 
             // restore programs
-            if(programs[channelNumber].program !== -1)
+            if(programs[channelNumber].program >= 0 && programs[channelNumber].actualBank >= 0)
             {
                 const bank = programs[channelNumber].actualBank;
                 this.sendMIDIMessage([messageTypes.controllerChange | (channelNumber % 16), midiControllers.bankSelect, bank]);
@@ -219,7 +219,7 @@ export function _playTo(time, ticks = undefined)
                 })
             }
             // restore programs
-            if(programs[channelNumber].program !== -1)
+            if(programs[channelNumber].program >= 0 && programs[channelNumber].actualBank >= 0)
             {
                 const bank = programs[channelNumber].actualBank;
                 this.synth.controllerChange(channelNumber, midiControllers.bankSelect, bank);

package/sequencer/worklet_sequencer/song_control.js

@@ -56,9 +56,10 @@ export function loadNewSequence(parsedMidi)
     // check for embedded soundfont
     if(this.midiData.embeddedSoundFont !== undefined)
     {
+        SpessaSynthInfo("%cEmbedded soundfont detected! Using it.", consoleColors.recognized);
         this.synth.reloadSoundFont(this.midiData.embeddedSoundFont);
         // set offet
-        this.synth.soundfontBankOffset = 1;
+        this.synth.soundfontBankOffset = this.midiData.bankOffset;
         // preload all samples
         this.synth.soundfont.samples.forEach(s => s.getAudioData());
     }

package/soundfont/read/riff_chunk.js

@@ -45,6 +45,11 @@ export function readRIFFChunk(dataArray, readData = true, forceShift = false) {
         dataArray.currentIndex += size;
     }
 
+    if(size % 2 !== 0)
+    {
+        dataArray.currentIndex++;
+    }
+
     return new RiffChunk(header, size, chunkData)
 }