spessasynth_lib 3.12.2 → 3.13.0

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

@@ -1,6 +1,7 @@
 /**
  * @param mid {MIDI}
  * @param soundfont {SoundFont2}
+ * @returns {Object<string, Set<string>>}
  */
 export function getUsedProgramsAndKeys(mid: MIDI, soundfont: SoundFont2): {
     [x: string]: Set<string>;

package/@types/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.d.ts

@@ -15,6 +15,7 @@
  *
  * @property {Preset} preset - the channel's preset
  * @property {boolean} lockPreset - indicates whether the program on the channel is locked
+ * @property {boolean} presetUsesOverride - indcates if the channel uses a preset from the override soundfont.
  *
  * @property {boolean} lockVibrato - indicates whether the custom vibrato is locked
  * @property {Object} channelVibrato - vibrato settings for the channel
@@ -103,6 +104,10 @@ export type WorkletProcessorChannel = {
      * - indicates whether the program on the channel is locked
      */
     lockPreset: boolean;
+    /**
+     * - indcates if the channel uses a preset from the override soundfont.
+     */
+    presetUsesOverride: boolean;
     /**
      * - indicates whether the custom vibrato is locked
      */

package/@types/utils/buffer_to_wav.d.ts

@@ -1,28 +1,27 @@
-/**
- * @typedef {Object} WaveMetadata
- * @property {string} title - the song's title
- * @property {string} album - the song's album
- * @property {string} genre - the song's genre
- */
 /**
  *
  * @param audioBuffer {AudioBuffer}
  * @param normalizeAudio {boolean} find the max sample point and set it to 1, and scale others with it
  * @param channelOffset {number} channel offset and channel offset + 1 get saved
+ * @param metadata {WaveMetadata}
  * @returns {Blob}
  */
-export function audioBufferToWav(audioBuffer: AudioBuffer, normalizeAudio?: boolean, channelOffset?: number): Blob;
+export function audioBufferToWav(audioBuffer: AudioBuffer, normalizeAudio?: boolean, channelOffset?: number, metadata?: WaveMetadata): Blob;
 export type WaveMetadata = {
     /**
      * - the song's title
      */
-    title: string;
+    title: string | undefined;
+    /**
+     * - the song's artist
+     */
+    artist: string | undefined;
     /**
      * - the song's album
      */
-    album: string;
+    album: string | undefined;
     /**
      * - the song's genre
      */
-    genre: string;
+    genre: string | undefined;
 };

package/midi_parser/rmidi_writer.js

@@ -61,6 +61,7 @@ export function writeRMIDI(soundfontBinary, mid, soundfont, bankOffset = 0, enco
         consoleColors.info,
         consoleColors.value);
     SpessaSynthInfo("metadata", metadata);
+    SpessaSynthInfo("Initial bank offset", mid.bankOffset);
     // 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";
@@ -69,202 +70,252 @@ export function writeRMIDI(soundfontBinary, mid, soundfont, bankOffset = 0, enco
      * @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[]}
-         */
-        let hasBankSelects = Array(16).fill(true);
-        mid.usedChannelsOnTrack[trackNum].forEach(c => {
-            // fill with true, only the channels on this track are set to false
-            // (so we won't add banks for channels the track isn't refering to)
-            hasBankSelects[c] = false;
-        });
-        /**
-         * @type {MidiMessage[]}
-         */
-        let lastBankChanges = [];
-        /**
-         * @type {boolean[]}
-         */
-        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(
-                status !== messageTypes.controllerChange &&
-                status !== messageTypes.programChange &&
-                status !== messageTypes.systemExclusive
-            )
+    /**
+     * indexes for tracks
+     * @type {number[]}
+     */
+    const eventIndexes = Array(mid.tracks.length).fill(0);
+    let remainingTracks = mid.tracks.length;
+    function findFirstEventIndex()
+    {
+        let index = 0;
+        let ticks = Infinity;
+        mid.tracks.forEach((track, i) => {
+            if(eventIndexes[i] >= track.length)
             {
                 return;
             }
-
-            if(status === messageTypes.systemExclusive)
+            if(track[eventIndexes[i]].ticks < ticks)
             {
-                // 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
-                )
-                {
-                    // check for XG
-                    if(
-                        e.messageData[0] === 0x43 && // yamaha
-                        e.messageData[2] === 0x4C && // sXG ON
-                        e.messageData[5] === 0x7E &&
-                        e.messageData[6] === 0x00
-                    )
-                    {
-                        system = "xg";
-                    }
-                    else
-                    if(
-                        e.messageData[0] === 0x41    // roland
-                        && e.messageData[2] === 0x42 // GS
-                        && e.messageData[6] === 0x7F // Mode set
-                    )
-                    {
-                        system = "gs";
-                    }
-                    else
-                    if(
-                        e.messageData[0] === 0x7E // non realtime
-                        && e.messageData[2] === 0x09 // gm system
-                    )
-                    {
-                        system = "gm";
-                        unwantedSystems.push({
-                            tNum: trackNum,
-                            e: e
-                        });
-                    }
-                    return;
-                }
-                const sysexChannel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][e.messageData[5] & 0x0F];
-                drums[sysexChannel] = !!(e.messageData[7] > 0 && e.messageData[5] >> 4);
-                return;
+                index = i;
+                ticks = track[eventIndexes[i]].ticks;
             }
+        });
+        return index;
+    }
+    // it copies midiPorts everywhere else, but here 0 works so DO NOT CHANGE!!!!!!!
+    const ports = Array(mid.tracks.length).fill(0);
+    const channelsAmount = 16 + mid.midiPortChannelOffsets.reduce((max, cur) => cur > max ? cur: max);
+    /**
+     * @type {{
+     *     program: number,
+     *     drums: boolean,
+     *     lastBank: MidiMessage,
+     *     hasBankSelect: boolean
+     * }[]}
+     */
+    const channelsInfo = [];
+    for (let i = 0; i < channelsAmount; i++)
+    {
+        channelsInfo.push({
+            program: 0,
+            drums: i % 16 === DEFAULT_PERCUSSION, // drums appear on 9 every 16 channels,
+            lastBank: undefined,
+            hasBankSelect: false,
+        });
+    }
+    while(remainingTracks > 0)
+    {
+        let trackNum = findFirstEventIndex();
+        const track = mid.tracks[trackNum];
+        if(eventIndexes[trackNum] >= track.length)
+        {
+            remainingTracks--;
+            continue;
+        }
+        const e = track[eventIndexes[trackNum]];
+        eventIndexes[trackNum]++;
+
+        let portOffset = mid.midiPortChannelOffsets[ports[trackNum]];
+        if(e.messageStatusByte === messageTypes.midiPort)
+        {
+            ports[trackNum] = e.messageData[0];
+            continue;
+        }
+        const status = e.messageStatusByte & 0xF0;
+        if(
+            status !== messageTypes.controllerChange &&
+            status !== messageTypes.programChange &&
+            status !== messageTypes.systemExclusive
+        )
+        {
+            continue
+        }
 
-            const chNum = e.messageStatusByte & 0xF;
-            if(status === messageTypes.programChange)
+        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
+            )
             {
-                // check if the preset for this program exists
-                if(drums[chNum])
+                // check for XG
+                if(
+                    e.messageData[0] === 0x43 && // yamaha
+                    e.messageData[2] === 0x4C && // sXG ON
+                    e.messageData[5] === 0x7E &&
+                    e.messageData[6] === 0x00
+                )
                 {
-                    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;
-                    }
+                    system = "xg";
                 }
                 else
+                if(
+                    e.messageData[0] === 0x41    // roland
+                    && e.messageData[2] === 0x42 // GS
+                    && e.messageData[6] === 0x7F // Mode set
+                )
                 {
-                    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 realBank = lastBankChanges[chNum]?.messageData[1] - mid.bankOffset; // make sure to take the previous bank offset into account
-                const bank = drums[chNum] ? 128 : realBank;
-                if(lastBankChanges[chNum] === undefined)
-                {
-                    return;
+                    system = "gs";
                 }
-                if(system === "xg" && drums[chNum])
+                else
+                if(
+                    e.messageData[0] === 0x7E // non realtime
+                    && e.messageData[2] === 0x09 // gm system
+                )
                 {
-                    // drums override: set bank to 127
-                    lastBankChanges[chNum].messageData[1] = 127;
-                    return;
+                    system = "gm";
+                    unwantedSystems.push({
+                        tNum: trackNum,
+                        e: e
+                    });
                 }
+                continue;
+            }
+            const sysexChannel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][e.messageData[5] & 0x0F] + portOffset;
+            channelsInfo[sysexChannel].drums = !!(e.messageData[7] > 0 && e.messageData[5] >> 4);
+            continue;
+        }
 
-                if(soundfont.presets.findIndex(p => p.bank === bank && p.program === e.messageData[0]) === -1)
+        // program change
+        const chNum = (e.messageStatusByte & 0xF) + portOffset;
+        const channel = channelsInfo[chNum];
+        if(status === messageTypes.programChange)
+        {
+            // check if the preset for this program exists
+            if(channel.drums)
+            {
+                if(soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank === 128) === -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);
+                    // doesn't exist. pick any preset that has the 128 bank.
+                    e.messageData[0] = soundfont.presets.find(p => p.bank === 128)?.program || 0;
                 }
-                else
+            }
+            else
+            {
+                if (soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank !== 128) === -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,
-                        consoleColors.info);
+                    // 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;
                 }
-                return;
             }
-            if(e.messageData[0] !== midiControllers.bankSelect)
+            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;
+            if(channel.lastBank === undefined)
             {
-                return;
+                continue;
             }
-            // bank select
-            hasBankSelects[chNum] = true;
-            channelHasBankSelects[chNum + portOffset] = true;
-            if(system === "xg")
+            if(system === "xg" && channel.drums)
             {
-                // check for xg drums
-                drums[chNum] = e.messageData[1] === 120 || e.messageData[1] === 126 || e.messageData[1] === 127;
+                // drums override: set bank to 127
+                channelsInfo[chNum].lastBank.messageData[1] = 127;
             }
-            lastBankChanges[chNum] = e;
-        });
-        // add all bank selects that are missing for this track
-        hasBankSelects.forEach((has, ch) => {
-            if(has === true)
+
+            if(soundfont.presets.findIndex(p => p.bank === bank && p.program === e.messageData[0]) === -1)
             {
-                return;
+                // 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;
+                SpessaSynthInfo(`%cNo preset %c${bank}:${e.messageData[0]}%c. Changing bank to ${targetBank}.`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info);
             }
-            // if this channel has bank selects but not in this track specifically, ignore too
-            if(channelHasBankSelects[ch + portOffset] === true)
+            else
             {
-                return;
+                // there is a preset with this bank. add offset. For drums add the normal offset.
+                const newBank = (bank === 128 ? 0 : realBank) + bankOffset;
+                channel.lastBank.messageData[1] = newBank;
+                SpessaSynthInfo(`%cPreset %c${bank}:${e.messageData[0]}%c exists. Changing bank to ${newBank}.`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info);
             }
-            // find first program change (for the given channel)
-            const status = messageTypes.programChange | ch;
-            let indexToAdd = t.findIndex(e => e.messageStatusByte === status);
-            if(indexToAdd === -1)
+            continue;
+        }
+        // we only care about bank select
+        if(e.messageData[0] !== midiControllers.bankSelect)
+        {
+            continue;
+        }
+        // bank select
+        channel.hasBankSelect = true;
+        if(system === "xg")
+        {
+            // check for xg drums
+            channel.drums = e.messageData[1] === 120 || e.messageData[1] === 126 || e.messageData[1] === 127;
+        }
+        channel.lastBank = e;
+    }
+
+    // add missing bank selects
+    // add all bank selects that are missing for this track
+    channelsInfo.forEach((has, ch) => {
+        if(has.hasBankSelect === true)
+        {
+            return;
+        }
+        // find first program change (for the given channel)
+        const midiChannel = ch % 16;
+        const status = messageTypes.programChange | midiChannel;
+        // find track with this channel being used
+        const portOffset = Math.floor(ch / 16) * 16;
+        const port = mid.midiPortChannelOffsets.indexOf(portOffset);
+        const track = mid.tracks.find((t, tNum) => mid.midiPorts[tNum] === port && mid.usedChannelsOnTrack[tNum].has(midiChannel));
+        if(track === undefined)
+        {
+            // this channel is not used at all
+            return;
+        }
+        let indexToAdd = track.findIndex(e => e.messageStatusByte === status);
+        if(indexToAdd === -1)
+        {
+            // no program change...
+            // add programs if they are missing from the track (need them to activate bank 1 for the embedded sfont)
+            const programIndex = track.findIndex(e => (e.messageStatusByte > 0x80 && e.messageStatusByte < 0xF0) && (e.messageStatusByte & 0xF) === midiChannel);
+            if(programIndex === -1)
             {
-                // no program change...
-                    // add programs if they are missing from the track (need them to activate bank 1 for the embedded sfont)
-                const programIndex = t.findIndex(e => (e.messageStatusByte > 0x80 && e.messageStatusByte < 0xF0) && (e.messageStatusByte & 0xF) === ch);
-                if(programIndex === -1)
-                {
-                    // no voices??? skip
-                    return;
-                }
-                const programTicks = t[programIndex].ticks;
-                const targetProgram = soundfont.getPreset(0, 0).program;
-                t.splice(programIndex, 0, new MidiMessage(
-                    programTicks,
-                    messageTypes.programChange | ch,
-                    new IndexedByteArray([targetProgram])
-                ));
-                indexToAdd = programIndex;
+                // no voices??? skip
+                return;
             }
-            const ticks = t[indexToAdd].ticks;
-            const targetBank = (soundfont.getPreset(0, programs[ch])?.bank + bankOffset) || bankOffset;
-            t.splice(indexToAdd,0, new MidiMessage(
-                ticks,
-                messageTypes.controllerChange | ch,
-                new IndexedByteArray([midiControllers.bankSelect, targetBank])
+            const programTicks = track[programIndex].ticks;
+            const targetProgram = soundfont.getPreset(0, 0).program;
+            track.splice(programIndex, 0, new MidiMessage(
+                programTicks,
+                messageTypes.programChange | midiChannel,
+                new IndexedByteArray([targetProgram])
             ));
-        });
+            indexToAdd = programIndex;
+        }
+        SpessaSynthInfo(`%cAdding bank select for %c${ch}`,
+            consoleColors.info,
+            consoleColors.recognized)
+        const ticks = track[indexToAdd].ticks;
+        const targetBank = (soundfont.getPreset(0, has.program)?.bank + bankOffset) || bankOffset;
+        track.splice(indexToAdd,0, new MidiMessage(
+            ticks,
+            messageTypes.controllerChange | midiChannel,
+            new IndexedByteArray([midiControllers.bankSelect, targetBank])
+        ));
     });
+
     // make sure to put xg if gm
     if(system !== "gs" && system !== "xg")
     {

package/midi_parser/used_keys_loaded.js

@@ -6,6 +6,7 @@ import { messageTypes, midiControllers } from './midi_message.js'
 /**
  * @param mid {MIDI}
  * @param soundfont {SoundFont2}
+ * @returns {Object<string, Set<string>>}
  */
 export function getUsedProgramsAndKeys(mid, soundfont)
 {

package/package.json

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

package/sequencer/worklet_sequencer/song_control.js

@@ -57,14 +57,19 @@ export function loadNewSequence(parsedMidi)
     if(this.midiData.embeddedSoundFont !== undefined)
     {
         SpessaSynthInfo("%cEmbedded soundfont detected! Using it.", consoleColors.recognized);
-        this.synth.reloadSoundFont(this.midiData.embeddedSoundFont);
         // set offet
         this.synth.soundfontBankOffset = this.midiData.bankOffset;
+        this.synth.reloadSoundFont(this.midiData.embeddedSoundFont, true);
         // preload all samples
-        this.synth.soundfont.samples.forEach(s => s.getAudioData());
+        this.synth.overrideSoundfont.samples.forEach(s => s.getAudioData());
     }
     else
     {
+        if(this.synth.overrideSoundfont)
+        {
+            // clean up the emdeeded soundfont
+            this.synth.clearSoundFont();
+        }
         SpessaSynthGroupCollapsed("%cPreloading samples...", consoleColors.info);
         // smart preloading: load only samples used in the midi!
         const used = getUsedProgramsAndKeys(this.midiData, this.synth.soundfont);
@@ -72,7 +77,7 @@ export function loadNewSequence(parsedMidi)
         {
             const bank = parseInt(programBank.split(":")[0]);
             const program = parseInt(programBank.split(":")[1]);
-            const preset = this.synth.soundfont.getPreset(bank, program);
+            const preset = this.synth.getPreset(bank, program);
             SpessaSynthInfo(`%cPreloading used samples on %c${preset.presetName}%c...`,
                 consoleColors.info,
                 consoleColors.recognized,