spessasynth_core 1.1.2 → 1.1.4

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

@@ -0,0 +1,31 @@
+/**
+ * @this {SpessaSynthProcessor}
+ */
+export function sendPresetList()
+{
+    /**
+     * @type {{bank: number, presetName: string, program: number}[]}
+     */
+    const mainFont = this.soundfontManager.getPresetList();
+    if (this.overrideSoundfont !== undefined)
+    {
+        this.overrideSoundfont.presets.forEach(p =>
+        {
+            const bankCheck = p.bank === 128 ? 128 : p.bank + this.soundfontBankOffset;
+            const exists = mainFont.find(pr => pr.bank === bankCheck && pr.program === p.program);
+            if (exists !== undefined)
+            {
+                exists.presetName = p.presetName;
+            }
+            else
+            {
+                mainFont.push({
+                    presetName: p.presetName,
+                    bank: bankCheck,
+                    program: p.program
+                });
+            }
+        });
+    }
+    this.callEvent("presetlistchange", mainFont);
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Sets the embedded (RMI soundfont)
+ * @param font {ArrayBuffer}
+ * @param offset {number}
+ * @this {SpessaSynthProcessor}
+ */
+export function setEmbeddedSoundFont(font, offset)
+{
+    // set offset
+    this.soundfontBankOffset = offset;
+    this.reloadSoundFont(font, true);
+    // preload all samples
+    this.overrideSoundfont.samples.forEach(s => s.getAudioData());
+    
+    // apply snapshot again if applicable
+    if (this._snapshot !== undefined)
+    {
+        this.applySynthesizerSnapshot(this._snapshot);
+        this.resetAllControllers();
+    }
+}

package/src/synthetizer/audio_engine/engine_methods/stopping_notes/kill_note.js

@@ -0,0 +1,20 @@
+import { generatorTypes } from "../../../../soundfont/basic_soundfont/generator.js";
+
+/**
+ * Stops a note nearly instantly
+ * @param midiNote {number}
+ * @param releaseTime {number} ticks
+ * @this {MidiAudioChannel}
+ */
+export function killNote(midiNote, releaseTime = -12000)
+{
+    this.voices.forEach(v =>
+    {
+        if (v.realKey !== midiNote)
+        {
+            return;
+        }
+        v.modulatedGenerators[generatorTypes.releaseVolEnv] = releaseTime; // set release to be very short
+        v.release(this.synth.currentSynthTime);
+    });
+}

package/src/synthetizer/audio_engine/engine_methods/stopping_notes/note_off.js

@@ -0,0 +1,55 @@
+import { SpessaSynthWarn } from "../../../../utils/loggin.js";
+
+/**
+ * Release a note
+ * @param midiNote {number}
+ * @this {MidiAudioChannel}
+ */
+export function noteOff(midiNote)
+{
+    if (midiNote > 127 || midiNote < 0)
+    {
+        SpessaSynthWarn(`Received a noteOn for note`, midiNote, "Ignoring.");
+        return;
+    }
+    
+    let realKey = midiNote + this.channelTransposeKeyShift;
+    
+    // if high performance mode, kill notes instead of stopping them
+    if (this.synth.highPerformanceMode)
+    {
+        // if the channel is percussion channel, do not kill the notes
+        if (!this.drumChannel)
+        {
+            this.killNote(realKey, -6950);
+            this.synth.callEvent("noteoff", {
+                midiNote: midiNote,
+                channel: this.channelNumber
+            });
+            return;
+        }
+    }
+    
+    const channelVoices = this.voices;
+    channelVoices.forEach(v =>
+    {
+        if (v.realKey !== realKey || v.isInRelease === true)
+        {
+            return;
+        }
+        // if hold pedal, move to sustain
+        if (this.holdPedal)
+        {
+            this.sustainedVoices.push(v);
+        }
+        else
+        {
+            v.release(this.synth.currentSynthTime);
+        }
+    });
+    this.synth.callEvent("noteoff", {
+        midiNote: midiNote,
+        channel: this.channelNumber
+    });
+}
+

package/src/synthetizer/audio_engine/engine_methods/stopping_notes/stop_all_channels.js

@@ -0,0 +1,16 @@
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { consoleColors } from "../../../../utils/other.js";
+
+/**
+ * @this {SpessaSynthProcessor}
+ * @param force {boolean}
+ */
+export function stopAllChannels(force = false)
+{
+    SpessaSynthInfo("%cStop all received!", consoleColors.info);
+    for (let i = 0; i < this.midiAudioChannels.length; i++)
+    {
+        this.midiAudioChannels[i].stopAllNotes(force);
+    }
+    this.callEvent("stopall", undefined);
+}

package/src/synthetizer/audio_engine/engine_methods/stopping_notes/stop_all_notes.js

@@ -0,0 +1,30 @@
+/**
+ * stops all notes on a given channel
+ * @param force {boolean}
+ * @this {MidiAudioChannel}
+ */
+export function stopAllNotes(force = false)
+{
+    if (force)
+    {
+        // force stop all
+        this.voices.length = 0;
+        this.sustainedVoices.length = 0;
+        this.sendChannelProperty();
+    }
+    else
+    {
+        this.voices.forEach(v =>
+        {
+            if (v.isInRelease)
+            {
+                return;
+            }
+            v.release(this.synth.currentSynthTime);
+        });
+        this.sustainedVoices.forEach(v =>
+        {
+            v.release(this.synth.currentSynthTime);
+        });
+    }
+}

package/src/synthetizer/audio_engine/engine_methods/stopping_notes/voice_killing.js

@@ -0,0 +1,63 @@
+/**
+ * @param channel {MidiAudioChannel}
+ * @param voice {Voice}
+ * @return {number}
+ */
+function getPriority(channel, voice)
+{
+    let priority = 0;
+    if (channel.drumChannel)
+    {
+        // important
+        priority += 5;
+    }
+    if (voice.isInRelease)
+    {
+        // not important
+        priority -= 5;
+    }
+    // less velocity = less important
+    priority += voice.velocity / 25; // map to 0-5
+    // the newer, more important
+    priority -= voice.volumeEnvelope.state;
+    if (voice.isInRelease)
+    {
+        priority -= 5;
+    }
+    priority -= voice.volumeEnvelope.currentAttenuationDb / 50;
+    return priority;
+}
+
+/**
+ * @this {SpessaSynthProcessor}
+ * @param amount {number}
+ */
+export function voiceKilling(amount)
+{
+    let allVoices = [];
+    for (const channel of this.midiAudioChannels)
+    {
+        for (const voice of channel.voices)
+        {
+            if (!voice.finished)
+            {
+                const priority = getPriority(channel, voice);
+                allVoices.push({ channel, voice, priority });
+            }
+        }
+    }
+    
+    // Step 2: Sort voices by priority (ascending order)
+    allVoices.sort((a, b) => a.priority - b.priority);
+    const voicesToRemove = allVoices.slice(0, amount);
+    
+    for (const { channel, voice } of voicesToRemove)
+    {
+        const index = channel.voices.indexOf(voice);
+        if (index > -1)
+        {
+            channel.voices.splice(index, 1);
+        }
+    }
+}
+