spessasynth_core 1.1.2 → 1.1.4

package/src/synthetizer/audio_engine/engine_methods/data_entry/data_entry_fine.js

@@ -0,0 +1,66 @@
+import { consoleColors } from "../../../../utils/other.js";
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
+import { customControllers, dataEntryStates, NON_CC_INDEX_OFFSET } from "../../engine_components/controller_tables.js";
+import { midiControllers } from "../../../../midi/midi_message.js";
+
+/**
+ * Executes a data entry for an RPN tuning
+ * @param dataValue {number} dataEntry LSB
+ * @this {MidiAudioChannel}
+ * @private
+ */
+export function dataEntryFine(dataValue)
+{
+    switch (this.dataEntryState)
+    {
+        default:
+            break;
+        
+        case dataEntryStates.RPCoarse:
+        case dataEntryStates.RPFine:
+            const rpnValue = this.midiControllers[midiControllers.RPNMsb] | (this.midiControllers[midiControllers.RPNLsb] >> 7);
+            switch (rpnValue)
+            {
+                default:
+                    break;
+                
+                // pitch bend range fine tune
+                case 0x0000:
+                    if (dataValue === 0)
+                    {
+                        break;
+                    }
+                    // 14-bit value, so upper 7 are coarse and lower 7 are fine!
+                    this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] |= dataValue;
+                    const actualTune = (this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] >> 7) + dataValue / 128;
+                    SpessaSynthInfo(
+                        `%cChannel ${this.channelNumber} bend range. Semitones: %c${actualTune}`,
+                        consoleColors.info,
+                        consoleColors.value
+                    );
+                    break;
+                
+                // fine-tuning
+                case 0x0001:
+                    // grab the data and shift
+                    const coarse = this.customControllers[customControllers.channelTuning];
+                    const finalTuning = (coarse << 7) | dataValue;
+                    this.setTuning(finalTuning * 0.01220703125); // multiply by 8192 / 100 (cent increments)
+                    break;
+                
+                // modulation depth
+                case 0x0005:
+                    const currentModulationDepthCents = this.customControllers[customControllers.modulationMultiplier] * 50;
+                    let cents = currentModulationDepthCents + (dataValue / 128) * 100;
+                    this.setModulationDepth(cents);
+                    break;
+                
+                case 0x3FFF:
+                    this.resetParameters();
+                    break;
+                
+            }
+        
+    }
+}

package/src/synthetizer/audio_engine/engine_methods/mute_channel.js

@@ -0,0 +1,17 @@
+/**
+ * @param isMuted {boolean}
+ * @this {MidiAudioChannel}
+ */
+export function muteChannel(isMuted)
+{
+    if (isMuted)
+    {
+        this.stopAllNotes(true);
+    }
+    this.isMuted = isMuted;
+    this.sendChannelProperty();
+    this.synth.callEvent("mutechannel", {
+        channel: this.channelNumber,
+        isMuted: isMuted
+    });
+}

package/src/synthetizer/audio_engine/engine_methods/note_on.js

@@ -0,0 +1,175 @@
+import { computeModulators } from "../engine_components/compute_modulator.js";
+import { generatorTypes } from "../../../soundfont/basic_soundfont/generator.js";
+import { midiControllers } from "../../../midi/midi_message.js";
+import { portamentoTimeToSeconds } from "./portamento_time.js";
+
+/**
+ * sends a "MIDI Note on message"
+ * @param midiNote {number}
+ * @param velocity {number}
+ * @this {MidiAudioChannel}
+ */
+export function noteOn(midiNote, velocity)
+{
+    if (velocity < 1)
+    {
+        this.noteOff(midiNote);
+        return;
+    }
+    velocity = Math.min(127, velocity);
+    
+    if (
+        (this.synth.highPerformanceMode && this.synth.totalVoicesAmount > 200 && velocity < 40) ||
+        (this.synth.highPerformanceMode && velocity < 10) ||
+        (this.isMuted)
+    )
+    {
+        return;
+    }
+    
+    const realKey = midiNote + this.channelTransposeKeyShift;
+    let sentMidiNote = realKey;
+    
+    if (realKey > 127 || realKey < 0)
+    {
+        return;
+    }
+    const program = this.preset.program;
+    const tune = this.synth.tunings[program]?.[realKey]?.midiNote;
+    if (tune >= 0)
+    {
+        sentMidiNote = tune;
+    }
+    
+    // velocity override
+    if (this.velocityOverride > 0)
+    {
+        velocity = this.velocityOverride;
+    }
+    
+    // key velocity override
+    const keyVel = this.synth.keyModifierManager.getVelocity(this.channelNumber, realKey);
+    if (keyVel > -1)
+    {
+        velocity = keyVel;
+    }
+    
+    // gain
+    const voiceGain = this.synth.keyModifierManager.getGain(this.channelNumber, realKey);
+    
+    // portamento
+    let portamentoFromKey = -1;
+    let portamentoDuration = 0;
+    // note: the 14-bit value needs to go down to 7-bit
+    const portamentoTime = this.midiControllers[midiControllers.portamentoTime] >> 7;
+    const control = this.midiControllers[midiControllers.portamentoControl];
+    const currentFromKey = control >> 7;
+    if (
+        !this.drumChannel && // no portamento on drum channel
+        currentFromKey !== sentMidiNote && // if the same note, there's no portamento
+        this.midiControllers[midiControllers.portamentoOnOff] >= 8192 && // (64 << 7)
+        portamentoTime > 0 // 0 duration is no portamento
+    )
+    {
+        // a value of one means the initial portamento
+        if (control !== 1)
+        {
+            const diff = Math.abs(sentMidiNote - currentFromKey);
+            portamentoDuration = portamentoTimeToSeconds(portamentoTime, diff);
+            portamentoFromKey = currentFromKey;
+        }
+        // set portamento control to previous value
+        this.controllerChange(midiControllers.portamentoControl, sentMidiNote);
+    }
+    
+    // get voices
+    const voices = this.synth.getVoices(
+        this.channelNumber,
+        sentMidiNote,
+        velocity,
+        realKey
+    );
+    
+    // zero means disabled
+    let panOverride = 0;
+    if (this.randomPan)
+    {
+        // the range is -500 to 500
+        panOverride = Math.round(Math.random() * 1000 - 500);
+    }
+    
+    // add voices
+    const channelVoices = this.voices;
+    voices.forEach(voice =>
+    {
+        // apply portamento
+        voice.portamentoFromKey = portamentoFromKey;
+        voice.portamentoDuration = portamentoDuration;
+        
+        // apply pan override
+        voice.overridePan = panOverride;
+        
+        // apply gain override
+        voice.gain = voiceGain;
+        
+        // apply exclusive class
+        const exclusive = voice.exclusiveClass;
+        if (exclusive !== 0)
+        {
+            // kill all voices with the same exclusive class
+            channelVoices.forEach(v =>
+            {
+                if (v.exclusiveClass === exclusive)
+                {
+                    v.exclusiveRelease(this.synth.currentSynthTime);
+                }
+            });
+        }
+        // compute all modulators
+        computeModulators(voice, this.midiControllers);
+        // modulate sample offsets (these are not real time)
+        const cursorStartOffset = voice.modulatedGenerators[generatorTypes.startAddrsOffset] + voice.modulatedGenerators[generatorTypes.startAddrsCoarseOffset] * 32768;
+        const endOffset = voice.modulatedGenerators[generatorTypes.endAddrOffset] + voice.modulatedGenerators[generatorTypes.endAddrsCoarseOffset] * 32768;
+        const loopStartOffset = voice.modulatedGenerators[generatorTypes.startloopAddrsOffset] + voice.modulatedGenerators[generatorTypes.startloopAddrsCoarseOffset] * 32768;
+        const loopEndOffset = voice.modulatedGenerators[generatorTypes.endloopAddrsOffset] + voice.modulatedGenerators[generatorTypes.endloopAddrsCoarseOffset] * 32768;
+        const sm = voice.sample;
+        // apply them
+        const clamp = num => Math.max(0, Math.min(sm.sampleData.length - 1, num));
+        sm.cursor = clamp(sm.cursor + cursorStartOffset);
+        sm.end = clamp(sm.end + endOffset);
+        sm.loopStart = clamp(sm.loopStart + loopStartOffset);
+        sm.loopEnd = clamp(sm.loopEnd + loopEndOffset);
+        // swap loops if needed
+        if (sm.loopEnd < sm.loopStart)
+        {
+            const temp = sm.loopStart;
+            sm.loopStart = sm.loopEnd;
+            sm.loopEnd = temp;
+        }
+        if (sm.loopEnd - sm.loopStart < 1)
+        {
+            sm.loopingMode = 0;
+            sm.isLooping = false;
+        }
+        // set the current attenuation to target,
+        // as it's interpolated (we don't want 0 attenuation for even a split second)
+        voice.volumeEnvelope.attenuation = voice.volumeEnvelope.attenuationTargetGain;
+        // set initial pan to avoid split second changing from middle to the correct value
+        voice.currentPan = Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan])); //  -500 to 500
+    });
+    
+    this.synth.totalVoicesAmount += voices.length;
+    // cap the voices
+    if (this.synth.totalVoicesAmount > this.synth.voiceCap)
+    {
+        this.synth.voiceKilling(voices.length);
+    }
+    channelVoices.push(...voices);
+    this.sendChannelProperty();
+    this.synth.callEvent("noteon", {
+        midiNote: midiNote,
+        channel: this.channelNumber,
+        velocity: velocity
+    });
+    
+}

package/src/synthetizer/audio_engine/engine_methods/portamento_time.js

@@ -0,0 +1,92 @@
+// Tests were performed by John Novak
+// https://github.com/dosbox-staging/dosbox-staging/pull/2705
+
+/*
+CC 5 value  Portamento time
+----------  ---------------
+     0          0.000 s
+     1          0.006 s
+     2          0.023 s
+     4          0.050 s
+     8          0.110 s
+    16          0.250 s
+    32          0.500 s
+    64          2.060 s
+    80          4.200 s
+    96          8.400 s
+   112         19.500 s
+   116         26.700 s
+   120         40.000 s
+   124         80.000 s
+   127        480.000 s
+*/
+
+const portamentoLookup = {
+    0: 0.000,
+    1: 0.006,
+    2: 0.023,
+    4: 0.050,
+    8: 0.110,
+    16: 0.250,
+    32: 0.500,
+    64: 2.060,
+    80: 4.200,
+    96: 8.400,
+    112: 19.500,
+    116: 26.700,
+    120: 40.000,
+    124: 80.000,
+    127: 480.000
+};
+
+/**
+ * @param value {number}
+ * @returns {number}
+ */
+function getLookup(value)
+{
+    if (portamentoLookup[value] !== undefined)
+    {
+        return portamentoLookup[value];
+    }
+    // get the nearest lower and upper points from the lookup table
+    let lower = null;
+    let upper = null;
+    
+    for (let key of Object.keys(portamentoLookup))
+    {
+        key = parseInt(key);
+        if (key < value && (lower === null || key > lower))
+        {
+            lower = key;
+        }
+        if (key > value && (upper === null || key < upper))
+        {
+            upper = key;
+        }
+    }
+    
+    // if we have found both lower and upper points, perform linear interpolation
+    if (lower !== null && upper !== null)
+    {
+        let lowerTime = portamentoLookup[lower];
+        let upperTime = portamentoLookup[upper];
+        
+        // linear interpolation
+        return lowerTime + ((value - lower) * (upperTime - lowerTime)) / (upper - lower);
+    }
+    return 0;
+}
+
+
+/**
+ * Converts portamento time to seconds
+ * @param time {number} 0 - 127
+ * @param distance {number} distance in keys
+ * @returns {number} seconds
+ */
+export function portamentoTimeToSeconds(time, distance)
+{
+    // this seems to work fine for the MIDIs I have
+    return getLookup(time) * (distance / 30);
+}

package/src/synthetizer/audio_engine/engine_methods/program_change.js

@@ -0,0 +1,61 @@
+/**
+ * executes a program change
+ * @param programNumber {number}
+ * @this {MidiAudioChannel}
+ */
+export function programChange(programNumber)
+{
+    if (this.lockPreset)
+    {
+        return;
+    }
+    // always 128 for percussion
+    let bank = this.getBankSelect();
+    let sentBank;
+    /**
+     * @type {BasicPreset}
+     */
+    let preset;
+    
+    const isXG = this.isXGChannel;
+    // check if override
+    if (this.synth.overrideSoundfont)
+    {
+        const bankWithOffset = bank === 128 ? 128 : bank - this.synth.soundfontBankOffset;
+        const p = this.synth.overrideSoundfont.getPresetNoFallback(
+            bankWithOffset,
+            programNumber,
+            isXG
+        );
+        if (p)
+        {
+            sentBank = p.bank === 128 ? 128 : p.bank + this.synth.soundfontBankOffset;
+            preset = p;
+            this.presetUsesOverride = true;
+        }
+        else
+        {
+            preset = this.synth.soundfontManager.getPreset(bank, programNumber, isXG);
+            const offset = this.synth.soundfontManager.soundfontList
+                .find(s => s.soundfont === preset.parentSoundBank).bankOffset;
+            sentBank = preset.bank - offset;
+            this.presetUsesOverride = false;
+        }
+    }
+    else
+    {
+        preset = this.synth.soundfontManager.getPreset(bank, programNumber, isXG);
+        const offset = this.synth.soundfontManager.soundfontList
+            .find(s => s.soundfont === preset.parentSoundBank).bankOffset;
+        sentBank = preset.bank - offset;
+        this.presetUsesOverride = false;
+    }
+    this.setPreset(preset);
+    this.sentBank = sentBank;
+    this.synth.callEvent("programchange", {
+        channel: this.channelNumber,
+        program: preset.program,
+        bank: sentBank
+    });
+    this.sendChannelProperty();
+}

package/src/synthetizer/audio_engine/engine_methods/render_voice.js

@@ -0,0 +1,196 @@
+import { VolumeEnvelope } from "../engine_components/volume_envelope.js";
+import { ModulationEnvelope } from "../engine_components/modulation_envelope.js";
+import { generatorTypes } from "../../../soundfont/basic_soundfont/generator.js";
+import { customControllers } from "../engine_components/controller_tables.js";
+import { absCentsToHz, timecentsToSeconds } from "../engine_components/unit_converter.js";
+import { getLFOValue } from "../engine_components/lfo.js";
+import { interpolationTypes, WavetableOscillator } from "../engine_components/wavetable_oscillator.js";
+import { WorkletLowpassFilter } from "../engine_components/lowpass_filter.js";
+
+/**
+ * Renders a voice to the stereo output buffer
+ * @param voice {Voice} the voice to render
+ * @param timeNow {number} current time in seconds
+ * @param outputLeft {Float32Array} the left output buffer
+ * @param outputRight {Float32Array} the right output buffer
+ * @param reverbOutputLeft {Float32Array} left output for reverb
+ * @param reverbOutputRight {Float32Array} right output for reverb
+ * @param chorusOutputLeft {Float32Array} left output for chorus
+ * @param chorusOutputRight {Float32Array} right output for chorus
+ * @this {MidiAudioChannel}
+ * @returns {boolean} true if the voice is finished
+ */
+export function renderVoice(
+    voice, timeNow,
+    outputLeft, outputRight,
+    reverbOutputLeft, reverbOutputRight,
+    chorusOutputLeft, chorusOutputRight
+)
+{
+    // check if release
+    if (!voice.isInRelease)
+    {
+        // if not in release, check if the release time is
+        if (timeNow >= voice.releaseStartTime)
+        {
+            // release the voice here
+            voice.isInRelease = true;
+            VolumeEnvelope.startRelease(voice);
+            ModulationEnvelope.startRelease(voice);
+            if (voice.sample.loopingMode === 3)
+            {
+                voice.sample.isLooping = false;
+            }
+        }
+    }
+    
+    
+    // if the initial attenuation is more than 100dB, skip the voice (it's silent anyway)
+    if (voice.modulatedGenerators[generatorTypes.initialAttenuation] > 2500)
+    {
+        if (voice.isInRelease)
+        {
+            voice.finished = true;
+        }
+        return voice.finished;
+    }
+    
+    // TUNING
+    let targetKey = voice.targetKey;
+    
+    // calculate tuning
+    let cents = voice.modulatedGenerators[generatorTypes.fineTune]         // soundfont fine tune
+        + this.channelOctaveTuning[voice.midiNote]                         // MTS octave tuning
+        + this.channelTuningCents;                                         // channel tuning
+    let semitones = voice.modulatedGenerators[generatorTypes.coarseTune];  // soundfont coarse tuning
+    
+    // midi tuning standard
+    const tuning = this.synth.tunings[this.preset.program]?.[voice.realKey];
+    if (tuning !== undefined && tuning?.midiNote >= 0)
+    {
+        // override key
+        targetKey = tuning.midiNote;
+        // add micro-tonal tuning
+        cents += tuning.centTuning;
+    }
+    
+    // portamento
+    if (voice.portamentoFromKey > -1)
+    {
+        // 0 to 1
+        const elapsed = Math.min((timeNow - voice.startTime) / voice.portamentoDuration, 1);
+        const diff = targetKey - voice.portamentoFromKey;
+        // zero progress means the pitch being in fromKey, full progress means the normal pitch
+        semitones -= diff * (1 - elapsed);
+    }
+    
+    // calculate tuning by key using soundfont's scale tuning
+    cents += (targetKey - voice.sample.rootKey) * voice.modulatedGenerators[generatorTypes.scaleTuning];
+    
+    // vibrato LFO
+    const vibratoDepth = voice.modulatedGenerators[generatorTypes.vibLfoToPitch];
+    if (vibratoDepth !== 0)
+    {
+        // calculate start time and lfo value
+        const vibStart = voice.startTime + timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayVibLFO]);
+        const vibFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqVibLFO]);
+        const lfoVal = getLFOValue(vibStart, vibFreqHz, timeNow);
+        // use modulation multiplier (RPN modulation depth)
+        cents += lfoVal * (vibratoDepth * this.customControllers[customControllers.modulationMultiplier]);
+    }
+    
+    // low pass excursion with LFO and mod envelope
+    let lowpassExcursion = 0;
+    
+    // mod LFO
+    const modPitchDepth = voice.modulatedGenerators[generatorTypes.modLfoToPitch];
+    const modVolDepth = voice.modulatedGenerators[generatorTypes.modLfoToVolume];
+    const modFilterDepth = voice.modulatedGenerators[generatorTypes.modLfoToFilterFc];
+    let modLfoCentibels = 0;
+    // don't compute mod lfo unless necessary
+    if (modPitchDepth !== 0 || modFilterDepth !== 0 || modVolDepth !== 0)
+    {
+        // calculate start time and lfo value
+        const modStart = voice.startTime + timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayModLFO]);
+        const modFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqModLFO]);
+        const modLfoValue = getLFOValue(modStart, modFreqHz, timeNow);
+        // use modulation multiplier (RPN modulation depth)
+        cents += modLfoValue * (modPitchDepth * this.customControllers[customControllers.modulationMultiplier]);
+        // vole nv volume offset
+        // negate the lfo value because audigy starts with increase rather than decrease
+        modLfoCentibels = -modLfoValue * modVolDepth;
+        // low pass frequency
+        lowpassExcursion += modLfoValue * modFilterDepth;
+    }
+    
+    // channel vibrato (GS NRPN)
+    if (this.channelVibrato.depth > 0)
+    {
+        // same as others
+        const channelVibrato = getLFOValue(
+            voice.startTime + this.channelVibrato.delay,
+            this.channelVibrato.rate,
+            timeNow
+        );
+        if (channelVibrato)
+        {
+            cents += channelVibrato * this.channelVibrato.depth;
+        }
+    }
+    
+    // mod env
+    const modEnvPitchDepth = voice.modulatedGenerators[generatorTypes.modEnvToPitch];
+    const modEnvFilterDepth = voice.modulatedGenerators[generatorTypes.modEnvToFilterFc];
+    // don't compute mod env unless necessary
+    if (modEnvFilterDepth !== 0 || modEnvPitchDepth !== 0)
+    {
+        const modEnv = ModulationEnvelope.getValue(voice, timeNow);
+        // apply values
+        lowpassExcursion += modEnv * modEnvFilterDepth;
+        cents += modEnv * modEnvPitchDepth;
+    }
+    
+    // finally, calculate the playback rate
+    const centsTotal = ~~(cents + semitones * 100);
+    if (centsTotal !== voice.currentTuningCents)
+    {
+        voice.currentTuningCents = centsTotal;
+        voice.currentTuningCalculated = Math.pow(2, centsTotal / 1200);
+    }
+    
+    
+    // SYNTHESIS
+    const bufferOut = new Float32Array(outputLeft.length);
+    
+    // wave table oscillator
+    switch (this.synth.interpolationType)
+    {
+        case interpolationTypes.fourthOrder:
+            WavetableOscillator.getSampleCubic(voice, bufferOut);
+            break;
+        
+        case interpolationTypes.linear:
+        default:
+            WavetableOscillator.getSampleLinear(voice, bufferOut);
+            break;
+        
+        case interpolationTypes.nearestNeighbor:
+            WavetableOscillator.getSampleNearest(voice, bufferOut);
+            break;
+    }
+    
+    // low pass filter
+    WorkletLowpassFilter.apply(voice, bufferOut, lowpassExcursion, this.synth.filterSmoothingFactor);
+    
+    // vol env
+    VolumeEnvelope.apply(voice, bufferOut, modLfoCentibels, this.synth.volumeEnvelopeSmoothingFactor);
+    
+    this.panVoice(
+        voice,
+        bufferOut,
+        outputLeft, outputRight,
+        reverbOutputLeft, reverbOutputRight,
+        chorusOutputLeft, chorusOutputRight
+    );
+    return voice.finished;
+}

package/src/synthetizer/audio_engine/engine_methods/soundfont_management/clear_sound_font.js

@@ -0,0 +1,30 @@
+/**
+ * @this {SpessaSynthProcessor}
+ * @param sendPresets {boolean}
+ * @param clearOverride {boolean}
+ */
+export function clearSoundFont(sendPresets = true, clearOverride = true)
+{
+    this.stopAllChannels(true);
+    if (clearOverride)
+    {
+        delete this.overrideSoundfont;
+        this.overrideSoundfont = undefined;
+    }
+    this.getDefaultPresets();
+    this.cachedVoices = [];
+    
+    for (let i = 0; i < this.midiAudioChannels.length; i++)
+    {
+        const channelObject = this.midiAudioChannels[i];
+        if (!clearOverride || (clearOverride && channelObject.presetUsesOverride))
+        {
+            channelObject.setPresetLock(false);
+        }
+        channelObject.programChange(channelObject.preset.program);
+    }
+    if (sendPresets)
+    {
+        this.sendPresetList();
+    }
+}

package/src/synthetizer/audio_engine/engine_methods/soundfont_management/get_preset.js

@@ -0,0 +1,22 @@
+import { isSystemXG } from "../../../../utils/xg_hacks.js";
+
+/**
+ * @this {SpessaSynthProcessor}
+ * @param program {number}
+ * @param bank {number}
+ * @returns {BasicPreset}
+ */
+export function getPreset(bank, program)
+{
+    if (this.overrideSoundfont)
+    {
+        // if override soundfont
+        const bankWithOffset = bank === 128 ? 128 : bank - this.soundfontBankOffset;
+        const preset = this.overrideSoundfont.getPresetNoFallback(bankWithOffset, program, isSystemXG(this.system));
+        if (preset)
+        {
+            return preset;
+        }
+    }
+    return this.soundfontManager.getPreset(bank, program, isSystemXG(this.system));
+}

package/src/synthetizer/audio_engine/engine_methods/soundfont_management/reload_sound_font.js

@@ -0,0 +1,28 @@
+import { loadSoundFont } from "../../../../soundfont/load_soundfont.js";
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { consoleColors } from "../../../../utils/other.js";
+
+/**
+ * @param buffer {ArrayBuffer}
+ * @param isOverride {Boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function reloadSoundFont(buffer, isOverride = false)
+{
+    this.clearSoundFont(false, isOverride);
+    if (isOverride)
+    {
+        this.overrideSoundfont = loadSoundFont(buffer);
+    }
+    else
+    {
+        this.soundfontManager.reloadManager(buffer);
+    }
+    this.getDefaultPresets();
+    this.midiAudioChannels.forEach(c =>
+        c.programChange(c.preset.program)
+    );
+    this.postReady();
+    this.sendPresetList();
+    SpessaSynthInfo("%cSpessaSynth is ready!", consoleColors.recognized);
+}