spessasynth_core 1.1.3 → 1.1.4

package/src/sequencer/song_control.js

@@ -0,0 +1,201 @@
+import { consoleColors, formatTime } from "../utils/other.js";
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from "../utils/loggin.js";
+import { BasicMIDI } from "../midi/basic_midi.js";
+
+/**
+ * @param trackNum {number}
+ * @param port {number}
+ * @this {SpessaSynthSequencer}
+ */
+export function assignMIDIPort(trackNum, port)
+{
+    // do not assign ports to empty tracks
+    if (this.midiData.usedChannelsOnTrack[trackNum].size === 0)
+    {
+        return;
+    }
+    
+    // assign new 16 channels if the port is not occupied yet
+    if (this.midiPortChannelOffset === 0)
+    {
+        this.midiPortChannelOffset += 16;
+        this.midiPortChannelOffsets[port] = 0;
+    }
+    
+    if (this.midiPortChannelOffsets[port] === undefined)
+    {
+        if (this.synth.midiAudioChannels.length < this.midiPortChannelOffset + 15)
+        {
+            this._addNewMidiPort();
+        }
+        this.midiPortChannelOffsets[port] = this.midiPortChannelOffset;
+        this.midiPortChannelOffset += 16;
+    }
+    
+    this.midiPorts[trackNum] = port;
+}
+
+/**
+ * Loads a new sequence
+ * @param parsedMidi {BasicMIDI}
+ * @param autoPlay {boolean}
+ * @this {SpessaSynthSequencer}
+ * @private
+ */
+export function loadNewSequence(parsedMidi, autoPlay = true)
+{
+    this.stop();
+    if (!parsedMidi.tracks)
+    {
+        throw new Error("This MIDI has no tracks!");
+    }
+    
+    this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision);
+    
+    /**
+     * @type {BasicMIDI}
+     */
+    this.midiData = parsedMidi;
+    
+    // check for embedded soundfont
+    if (this.midiData.embeddedSoundFont !== undefined)
+    {
+        SpessaSynthInfo("%cEmbedded soundfont detected! Using it.", consoleColors.recognized);
+        this.synth.setEmbeddedSoundFont(this.midiData.embeddedSoundFont, this.midiData.bankOffset);
+    }
+    else
+    {
+        if (this.synth.overrideSoundfont)
+        {
+            // clean up the embedded soundfont
+            this.synth.clearSoundFont(true, true);
+        }
+        SpessaSynthGroupCollapsed("%cPreloading samples...", consoleColors.info);
+        // smart preloading: load only samples used in the midi!
+        const used = this.midiData.getUsedProgramsAndKeys(this.synth.soundfontManager);
+        for (const [programBank, combos] of Object.entries(used))
+        {
+            const bank = parseInt(programBank.split(":")[0]);
+            const program = parseInt(programBank.split(":")[1]);
+            const preset = this.synth.getPreset(bank, program);
+            SpessaSynthInfo(
+                `%cPreloading used samples on %c${preset.presetName}%c...`,
+                consoleColors.info,
+                consoleColors.recognized,
+                consoleColors.info
+            );
+            for (const combo of combos)
+            {
+                const split = combo.split("-");
+                preset.preloadSpecific(parseInt(split[0]), parseInt(split[1]));
+            }
+        }
+        SpessaSynthGroupEnd();
+    }
+    
+    /**
+     * the midi track data
+     * @type {MIDIMessage[][]}
+     */
+    this.tracks = this.midiData.tracks;
+    
+    // copy over the port data
+    this.midiPorts = this.midiData.midiPorts.slice();
+    
+    // clear last port data
+    this.midiPortChannelOffset = 0;
+    this.midiPortChannelOffsets = {};
+    // assign port offsets
+    this.midiData.midiPorts.forEach((port, trackIndex) =>
+    {
+        this.assignMIDIPort(trackIndex, port);
+    });
+    
+    /**
+     * Same as "audio.duration" property (seconds)
+     * @type {number}
+     */
+    this.duration = this.midiData.duration;
+    this.firstNoteTime = this.midiData.MIDIticksToSeconds(this.midiData.firstNoteOn);
+    SpessaSynthInfo(`%cTotal song time: ${formatTime(Math.ceil(this.duration)).time}`, consoleColors.recognized);
+    this?.onSongChange?.(this.songIndex, autoPlay);
+    
+    if (this.duration <= 1)
+    {
+        SpessaSynthWarn(
+            `%cVery short song: (${formatTime(Math.round(this.duration)).time}). Disabling loop!`,
+            consoleColors.warn
+        );
+        this.loop = false;
+    }
+    if (autoPlay)
+    {
+        this.play(true);
+    }
+    else
+    {
+        // this shall not play: play to the first note and then wait
+        const targetTime = this.skipToFirstNoteOn ? this.midiData.firstNoteOn - 1 : 0;
+        this.setTimeTicks(targetTime);
+        this.pause();
+    }
+}
+
+/**
+ * @param midiBuffers {BasicMIDI[]}
+ * @param autoPlay {boolean}
+ * @this {SpessaSynthSequencer}
+ */
+export function loadNewSongList(midiBuffers, autoPlay = true)
+{
+    /**
+     * parse the MIDIs (only the array buffers, MIDI is unchanged)
+     * @type {BasicMIDI[]}
+     */
+    this.songs = midiBuffers.map(m => BasicMIDI.copyFrom(m));
+    if (this.songs.length < 1)
+    {
+        return;
+    }
+    this.songIndex = 0;
+    if (this.songs.length > 1)
+    {
+        this.loop = false;
+    }
+    this.shuffleSongIndexes();
+    this?.onSongListChange?.(this.songs);
+    this.loadCurrentSong(autoPlay);
+}
+
+/**
+ * @this {SpessaSynthSequencer}
+ */
+export function nextSong()
+{
+    if (this.songs.length === 1)
+    {
+        this.currentTime = 0;
+        return;
+    }
+    this.songIndex++;
+    this.songIndex %= this.songs.length;
+    this.loadCurrentSong();
+}
+
+/**
+ * @this {SpessaSynthSequencer}
+ */
+export function previousSong()
+{
+    if (this.songs.length === 1)
+    {
+        this.currentTime = 0;
+        return;
+    }
+    this.songIndex--;
+    if (this.songIndex < 0)
+    {
+        this.songIndex = this.songs.length - 1;
+    }
+    this.loadCurrentSong();
+}

package/src/soundfont/README.md

@@ -0,0 +1,13 @@
+## This is the SoundFont2 parsing library.
+
+The code here is responsible for parsing the SoundFont2 file and
+providing an easy way to get the data out.
+Default modulators are also stored here (in `modulators.js`)
+
+`basic_soundfont` folder contains the classes that represent the soundfont file.
+
+`read_sf2` folder contains the code for reading an `.sf2` file.
+
+`write` folder contains the code for writing out an `.sf2` file.
+
+`dls` folder contains the code for reading a `.dls` file (and converting in into a soundfont representation).

package/src/soundfont/basic_soundfont/basic_instrument.js

@@ -0,0 +1,77 @@
+export class BasicInstrument
+{
+    /**
+     * The instrument's name
+     * @type {string}
+     */
+    instrumentName = "";
+    
+    /**
+     * The instrument's zones
+     * @type {BasicInstrumentZone[]}
+     */
+    instrumentZones = [];
+    
+    /**
+     * Instrument's use count, used for trimming
+     * @type {number}
+     * @private
+     */
+    _useCount = 0;
+    
+    /**
+     * @returns {number}
+     */
+    get useCount()
+    {
+        return this._useCount;
+    }
+    
+    addUseCount()
+    {
+        this._useCount++;
+        this.instrumentZones.forEach(z => z.useCount++);
+    }
+    
+    removeUseCount()
+    {
+        this._useCount--;
+        for (let i = 0; i < this.instrumentZones.length; i++)
+        {
+            if (this.safeDeleteZone(i))
+            {
+                i--;
+            }
+        }
+    }
+    
+    deleteInstrument()
+    {
+        this.instrumentZones.forEach(z => z.deleteZone());
+        this.instrumentZones.length = 0;
+    }
+    
+    /**
+     * @param index {number}
+     * @returns {boolean} is the zone has been deleted
+     */
+    safeDeleteZone(index)
+    {
+        this.instrumentZones[index].useCount--;
+        if (this.instrumentZones[index].useCount < 1)
+        {
+            this.deleteZone(index);
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * @param index {number}
+     */
+    deleteZone(index)
+    {
+        this.instrumentZones[index].deleteZone();
+        this.instrumentZones.splice(index, 1);
+    }
+}

package/src/soundfont/basic_soundfont/basic_preset.js

@@ -0,0 +1,336 @@
+/**
+ * @typedef {{
+ *  instrumentGenerators: Generator[],
+ *  presetGenerators: Generator[],
+ *  modulators: Modulator[],
+ *  sample: BasicSample,
+ *  sampleID: number,
+ * }} SampleAndGenerators
+ */
+import { generatorTypes } from "./generator.js";
+import { Modulator } from "./modulator.js";
+import { isXGDrums } from "../../utils/xg_hacks.js";
+
+export class BasicPreset
+{
+    /**
+     * The parent soundbank instance
+     * Currently used for determining default modulators and XG status
+     * @type {BasicSoundBank}
+     */
+    parentSoundBank;
+    
+    /**
+     * The preset's name
+     * @type {string}
+     */
+    presetName = "";
+    
+    /**
+     * The preset's MIDI program number
+     * @type {number}
+     */
+    program = 0;
+    
+    /**
+     * The preset's MIDI bank number
+     * @type {number}
+     */
+    bank = 0;
+    
+    /**
+     * The preset's zones
+     * @type {BasicPresetZone[]}
+     */
+    presetZones = [];
+    
+    /**
+     * Stores already found getSamplesAndGenerators for reuse
+     * @type {SampleAndGenerators[][][]}
+     */
+    foundSamplesAndGenerators = [];
+    
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    library = 0;
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    genre = 0;
+    /**
+     * unused metadata
+     * @type {number}
+     */
+    morphology = 0;
+    
+    /**
+     * Creates a new preset representation
+     * @param parentSoundBank {BasicSoundBank}
+     */
+    constructor(parentSoundBank)
+    {
+        this.parentSoundBank = parentSoundBank;
+        for (let i = 0; i < 128; i++)
+        {
+            this.foundSamplesAndGenerators[i] = [];
+        }
+    }
+    
+    /**
+     * @param allowXG {boolean}
+     * @param allowSFX {boolean}
+     * @returns {boolean}
+     */
+    isDrumPreset(allowXG, allowSFX = false)
+    {
+        const xg = allowXG && this.parentSoundBank.isXGBank;
+        // sfx is not cool
+        return this.bank === 128 || (
+            xg &&
+            (isXGDrums(this.bank) && (this.bank !== 126 || allowSFX))
+        );
+    }
+    
+    deletePreset()
+    {
+        this.presetZones.forEach(z => z.deleteZone());
+        this.presetZones.length = 0;
+    }
+    
+    /**
+     * @param index {number}
+     */
+    deleteZone(index)
+    {
+        this.presetZones[index].deleteZone();
+        this.presetZones.splice(index, 1);
+    }
+    
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Preloads all samples (async)
+     */
+    preload(keyMin, keyMax)
+    {
+        for (let key = keyMin; key < keyMax + 1; key++)
+        {
+            for (let velocity = 0; velocity < 128; velocity++)
+            {
+                this.getSamplesAndGenerators(key, velocity).forEach(samandgen =>
+                {
+                    if (!samandgen.sample.isSampleLoaded)
+                    {
+                        samandgen.sample.getAudioData();
+                    }
+                });
+            }
+        }
+    }
+    
+    /**
+     * Preloads a specific key/velocity combo
+     * @param key {number}
+     * @param velocity {number}
+     */
+    preloadSpecific(key, velocity)
+    {
+        this.getSamplesAndGenerators(key, velocity).forEach(samandgen =>
+        {
+            if (!samandgen.sample.isSampleLoaded)
+            {
+                samandgen.sample.getAudioData();
+            }
+        });
+    }
+    
+    /**
+     * Returns generatorTranslator and generators for given note
+     * @param midiNote {number}
+     * @param velocity {number}
+     * @returns {SampleAndGenerators[]}
+     */
+    getSamplesAndGenerators(midiNote, velocity)
+    {
+        const memorized = this.foundSamplesAndGenerators[midiNote][velocity];
+        if (memorized)
+        {
+            return memorized;
+        }
+        
+        if (this.presetZones.length < 1)
+        {
+            return [];
+        }
+        
+        /**
+         * @param range {SoundFontRange}
+         * @param number {number}
+         * @returns {boolean}
+         */
+        function isInRange(range, number)
+        {
+            return number >= range.min && number <= range.max;
+        }
+        
+        /**
+         * @param main {Generator[]}
+         * @param adder {Generator[]}
+         */
+        function addUnique(main, adder)
+        {
+            main.push(...adder.filter(g => !main.find(mg => mg.generatorType === g.generatorType)));
+        }
+        
+        /**
+         * @param main {Modulator[]}
+         * @param adder {Modulator[]}
+         */
+        function addUniqueMods(main, adder)
+        {
+            main.push(...adder.filter(m => !main.find(mm => Modulator.isIdentical(m, mm))));
+        }
+        
+        /**
+         * @type {SampleAndGenerators[]}
+         */
+        let parsedGeneratorsAndSamples = [];
+        
+        /**
+         * global zone is always first, so it or nothing
+         * @type {Generator[]}
+         */
+        let globalPresetGenerators = this.presetZones[0].isGlobal ? [...this.presetZones[0].generators] : [];
+        
+        /**
+         * @type {Modulator[]}
+         */
+        let globalPresetModulators = this.presetZones[0].isGlobal ? [...this.presetZones[0].modulators] : [];
+        const globalKeyRange = this.presetZones[0].isGlobal ? this.presetZones[0].keyRange : { min: 0, max: 127 };
+        const globalVelRange = this.presetZones[0].isGlobal ? this.presetZones[0].velRange : { min: 0, max: 127 };
+        
+        // find the preset zones in range
+        let presetZonesInRange = this.presetZones.filter(currentZone =>
+            (
+                isInRange(
+                    currentZone.hasKeyRange ? currentZone.keyRange : globalKeyRange,
+                    midiNote
+                )
+                &&
+                isInRange(
+                    currentZone.hasVelRange ? currentZone.velRange : globalVelRange,
+                    velocity
+                )
+            ) && !currentZone.isGlobal);
+        
+        presetZonesInRange.forEach(zone =>
+        {
+            // the global zone is already taken into account earlier
+            if (zone.instrument.instrumentZones.length < 1)
+            {
+                return;
+            }
+            let presetGenerators = zone.generators;
+            let presetModulators = zone.modulators;
+            const firstZone = zone.instrument.instrumentZones[0];
+            /**
+             * global zone is always first, so it or nothing
+             * @type {Generator[]}
+             */
+            let globalInstrumentGenerators = firstZone.isGlobal ? [...firstZone.generators] : [];
+            let globalInstrumentModulators = firstZone.isGlobal ? [...firstZone.modulators] : [];
+            const globalKeyRange = firstZone.isGlobal ? firstZone.keyRange : { min: 0, max: 127 };
+            const globalVelRange = firstZone.isGlobal ? firstZone.velRange : { min: 0, max: 127 };
+            
+            
+            let instrumentZonesInRange = zone.instrument.instrumentZones
+                .filter(currentZone =>
+                    (
+                        isInRange(
+                            currentZone.hasKeyRange ? currentZone.keyRange : globalKeyRange,
+                            midiNote
+                        )
+                        &&
+                        isInRange(
+                            currentZone.hasVelRange ? currentZone.velRange : globalVelRange,
+                            velocity
+                        )
+                    ) && !currentZone.isGlobal
+                );
+            
+            instrumentZonesInRange.forEach(instrumentZone =>
+            {
+                let instrumentGenerators = [...instrumentZone.generators];
+                let instrumentModulators = [...instrumentZone.modulators];
+                
+                addUnique(
+                    presetGenerators,
+                    globalPresetGenerators
+                );
+                // add the unique global preset generators (local replace global(
+                
+                
+                // add the unique global instrument generators (local replace global)
+                addUnique(
+                    instrumentGenerators,
+                    globalInstrumentGenerators
+                );
+                
+                addUniqueMods(
+                    presetModulators,
+                    globalPresetModulators
+                );
+                addUniqueMods(
+                    instrumentModulators,
+                    globalInstrumentModulators
+                );
+                
+                // default mods
+                addUniqueMods(
+                    instrumentModulators,
+                    this.parentSoundBank.defaultModulators
+                );
+                
+                /**
+                 * sum preset modulators to instruments (amount) sf spec page 54
+                 * @type {Modulator[]}
+                 */
+                const finalModulatorList = [...instrumentModulators];
+                for (let i = 0; i < presetModulators.length; i++)
+                {
+                    let mod = presetModulators[i];
+                    const identicalInstrumentModulator = finalModulatorList.findIndex(
+                        m => Modulator.isIdentical(mod, m));
+                    if (identicalInstrumentModulator !== -1)
+                    {
+                        // sum the amounts
+                        // (this makes a new modulator because otherwise it would overwrite the one in the soundfont!
+                        finalModulatorList[identicalInstrumentModulator] = finalModulatorList[identicalInstrumentModulator].sumTransform(
+                            mod);
+                    }
+                    else
+                    {
+                        finalModulatorList.push(mod);
+                    }
+                }
+                
+                
+                // combine both generators and add to the final result
+                parsedGeneratorsAndSamples.push({
+                    instrumentGenerators: instrumentGenerators,
+                    presetGenerators: presetGenerators,
+                    modulators: finalModulatorList,
+                    sample: instrumentZone.sample,
+                    sampleID: instrumentZone.generators.find(
+                        g => g.generatorType === generatorTypes.sampleID).generatorValue
+                });
+            });
+        });
+        
+        // save and return
+        this.foundSamplesAndGenerators[midiNote][velocity] = parsedGeneratorsAndSamples;
+        return parsedGeneratorsAndSamples;
+    }
+}