spessasynth_lib 3.24.13 → 3.24.15

package/synthetizer/worklet_system/worklet_methods/{voice_control.js → render_voice.js}

@@ -1,34 +1,29 @@
-import { absCentsToHz, timecentsToSeconds } from "../worklet_utilities/unit_converter.js";
-import { getLFOValue } from "../worklet_utilities/lfo.js";
-import { WorkletModulationEnvelope } from "../worklet_utilities/modulation_envelope.js";
-import {
-    getSampleCubic,
-    getSampleLinear,
-    getSampleNearest,
-    interpolationTypes
-} from "../worklet_utilities/wavetable_oscillator.js";
-import { MIN_NOTE_LENGTH } from "../main_processor.js";
 import { WorkletVolumeEnvelope } from "../worklet_utilities/volume_envelope.js";
+import { WorkletModulationEnvelope } from "../worklet_utilities/modulation_envelope.js";
 import { generatorTypes } from "../../../soundfont/basic_soundfont/generator.js";
 import { customControllers } from "../worklet_utilities/controller_tables.js";
+import { absCentsToHz, timecentsToSeconds } from "../worklet_utilities/unit_converter.js";
+import { getLFOValue } from "../worklet_utilities/lfo.js";
+import { interpolationTypes, WavetableOscillator } from "../worklet_utilities/wavetable_oscillator.js";
 import { WorkletLowpassFilter } from "../worklet_utilities/lowpass_filter.js";
 
 /**
  * Renders a voice to the stereo output buffer
- * @param channel {WorkletProcessorChannel} the voice's channel
  * @param voice {WorkletVoice} the voice to render
  * @param outputLeft {Float32Array} the left output buffer
  * @param outputRight {Float32Array} the right output buffer
- * @param reverbOutput {Float32Array[]} output for reverb
- * @param chorusOutput {Float32Array[]} output for chorus
- * @this {SpessaSynthProcessor}
+ * @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 {WorkletProcessorChannel}
+ * @returns {boolean} true if the voice is finished
  */
 export function renderVoice(
-    channel,
     voice,
     outputLeft, outputRight,
-    reverbOutput,
-    chorusOutput
+    reverbOutputLeft, reverbOutputRight,
+    chorusOutputLeft, chorusOutputRight
 )
 {
     // check if release
@@ -56,7 +51,7 @@ export function renderVoice(
         {
             voice.finished = true;
         }
-        return;
+        return voice.finished;
     }
     
     // TUNING
@@ -64,16 +59,16 @@ export function renderVoice(
     
     // calculate tuning
     let cents = voice.modulatedGenerators[generatorTypes.fineTune]             // soundfont fine tune
-        + channel.customControllers[customControllers.channelTuning]           // RPN channel fine tuning
-        + channel.customControllers[customControllers.channelTransposeFine]    // custom tuning (synth.transpose)
-        + channel.customControllers[customControllers.masterTuning]            // master tuning, set by sysEx
-        + channel.channelOctaveTuning[voice.midiNote % 12]                     // MTS octave tuning
-        + channel.keyCentTuning[voice.midiNote];                           // SysEx key tuning
+        + this.customControllers[customControllers.channelTuning]           // RPN channel fine tuning
+        + this.customControllers[customControllers.channelTransposeFine]    // custom tuning (synth.transpose)
+        + this.customControllers[customControllers.masterTuning]            // master tuning, set by sysEx
+        + this.channelOctaveTuning[voice.midiNote % 12]                     // MTS octave tuning
+        + this.keyCentTuning[voice.midiNote];                           // SysEx key tuning
     let semitones = voice.modulatedGenerators[generatorTypes.coarseTune]       // soundfont coarse tuning
-        + channel.customControllers[customControllers.channelTuningSemitones]; // RPN channel coarse tuning
+        + this.customControllers[customControllers.channelTuningSemitones]; // RPN channel coarse tuning
     
     // midi tuning standard
-    const tuning = this.tunings[channel.preset.program]?.[voice.realKey];
+    const tuning = this.synth.tunings[this.preset.program]?.[voice.realKey];
     if (tuning?.midiNote >= 0)
     {
         // override key
@@ -104,7 +99,7 @@ export function renderVoice(
         const vibFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqVibLFO]);
         const lfoVal = getLFOValue(vibStart, vibFreqHz, currentTime);
         // use modulation multiplier (RPN modulation depth)
-        cents += lfoVal * (vibratoDepth * channel.customControllers[customControllers.modulationMultiplier]);
+        cents += lfoVal * (vibratoDepth * this.customControllers[customControllers.modulationMultiplier]);
     }
     
     // low pass frequency
@@ -123,7 +118,7 @@ export function renderVoice(
         const modFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqModLFO]);
         const modLfoValue = getLFOValue(modStart, modFreqHz, currentTime);
         // use modulation multiplier (RPN modulation depth)
-        cents += modLfoValue * (modPitchDepth * channel.customControllers[customControllers.modulationMultiplier]);
+        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;
@@ -132,17 +127,17 @@ export function renderVoice(
     }
     
     // channel vibrato (GS NRPN)
-    if (channel.channelVibrato.depth > 0)
+    if (this.channelVibrato.depth > 0)
     {
         // same as others
         const channelVibrato = getLFOValue(
-            voice.startTime + channel.channelVibrato.delay,
-            channel.channelVibrato.rate,
+            voice.startTime + this.channelVibrato.delay,
+            this.channelVibrato.rate,
             currentTime
         );
         if (channelVibrato)
         {
-            cents += channelVibrato * channel.channelVibrato.depth;
+            cents += channelVibrato * this.channelVibrato.depth;
         }
     }
     
@@ -167,19 +162,20 @@ export function renderVoice(
     const bufferOut = new Float32Array(outputLeft.length);
     
     // wave table oscillator
-    switch (this.interpolationType)
+    switch (this.synth.interpolationType)
     {
+        case interpolationTypes.fourthOrder:
+            WavetableOscillator.getSampleCubic(voice, bufferOut);
+            break;
+        
         case interpolationTypes.linear:
         default:
-            getSampleLinear(voice, bufferOut);
+            WavetableOscillator.getSampleLinear(voice, bufferOut);
             break;
         
         case interpolationTypes.nearestNeighbor:
-            getSampleNearest(voice, bufferOut);
+            WavetableOscillator.getSampleNearest(voice, bufferOut);
             break;
-        
-        case interpolationTypes.fourthOrder:
-            getSampleCubic(voice, bufferOut);
     }
     
     /* low pass filter
@@ -190,93 +186,14 @@ export function renderVoice(
     WorkletLowpassFilter.apply(voice, bufferOut, lowpassCents, initialFc > 13499);
     
     // vol env
-    WorkletVolumeEnvelope.apply(voice, bufferOut, modLfoCentibels, this.volumeEnvelopeSmoothingFactor);
+    WorkletVolumeEnvelope.apply(voice, bufferOut, modLfoCentibels, this.synth.volumeEnvelopeSmoothingFactor);
     
     this.panVoice(
         voice,
         bufferOut,
         outputLeft, outputRight,
-        reverbOutput,
-        chorusOutput
+        reverbOutputLeft, reverbOutputRight,
+        chorusOutputLeft, chorusOutputRight
     );
-}
-
-
-/**
- * @param channel {WorkletProcessorChannel}
- * @param voice {WorkletVoice}
- * @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.workletProcessorChannels)
-    {
-        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);
-        }
-    }
-}
-
-/**
- * Stops the voice
- * @param voice {WorkletVoice} the voice to stop
- * @param minNoteLength {number} minimum note length in seconds
- * @this {SpessaSynthProcessor}
- */
-export function releaseVoice(voice, minNoteLength = MIN_NOTE_LENGTH)
-{
-    voice.releaseStartTime = currentTime;
-    // check if the note is shorter than the min note time, if so, extend it
-    if (voice.releaseStartTime - voice.startTime < minNoteLength)
-    {
-        voice.releaseStartTime = voice.startTime + minNoteLength;
-    }
+    return voice.finished;
 }

package/synthetizer/worklet_system/worklet_methods/soundfont_management/clear_sound_font.js

@@ -0,0 +1,35 @@
+/**
+ * @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.defaultPreset = this.getPreset(0, 0);
+    this.drumPreset = this.getPreset(128, 0);
+    
+    for (let i = 0; i < this.workletProcessorChannels.length; i++)
+    {
+        const channelObject = this.workletProcessorChannels[i];
+        channelObject.cachedVoices = [];
+        for (let j = 0; j < 128; j++)
+        {
+            channelObject.cachedVoices.push([]);
+        }
+        if (!clearOverride || (clearOverride && channelObject.presetUsesOverride))
+        {
+            channelObject.lockPreset = false;
+        }
+        channelObject.programChange(channelObject.preset.program);
+    }
+    if (sendPresets)
+    {
+        this.sendPresetList();
+    }
+}

package/synthetizer/worklet_system/worklet_methods/soundfont_management/get_preset.js

@@ -0,0 +1,20 @@
+/**
+ * @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);
+        if (preset)
+        {
+            return preset;
+        }
+    }
+    return this.soundfontManager.getPreset(bank, program);
+}

package/synthetizer/worklet_system/worklet_methods/soundfont_management/reload_sound_font.js

@@ -0,0 +1,43 @@
+import { loadSoundFont } from "../../../../soundfont/load_soundfont.js";
+import { returnMessageType } from "../../message_protocol/worklet_message.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);
+    try
+    {
+        if (isOverride)
+        {
+            this.overrideSoundfont = loadSoundFont(buffer);
+            // assign sample offset
+            this.overrideSoundfont.setSampleIDOffset(this.soundfontManager.totalSoundfontOffset);
+        }
+        else
+        {
+            this.soundfontManager.reloadManager(buffer);
+        }
+    }
+    catch (e)
+    {
+        this.post({
+            messageType: returnMessageType.soundfontError,
+            messageData: e
+        });
+        return;
+    }
+    this.defaultPreset = this.getPreset(0, 0);
+    this.drumPreset = this.getPreset(128, 0);
+    this.workletProcessorChannels.forEach(c =>
+        c.programChange(c.preset.program)
+    );
+    this.post({ messageType: returnMessageType.ready, messageData: undefined });
+    this.sendPresetList();
+    SpessaSynthInfo("%cSpessaSynth is ready!", consoleColors.recognized);
+}

package/synthetizer/worklet_system/worklet_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/synthetizer/worklet_system/worklet_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/synthetizer/worklet_system/worklet_methods/stopping_notes/kill_note.js

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

package/synthetizer/worklet_system/worklet_methods/stopping_notes/note_off.js

@@ -0,0 +1,51 @@
+import { SpessaSynthWarn } from "../../../../utils/loggin.js";
+
+/**
+ * Release a note
+ * @param midiNote {number}
+ * @this {WorkletProcessorChannel}
+ */
+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);
+            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.callEvent("noteoff", {
+        midiNote: midiNote,
+        channel: this.channelNumber
+    });
+}
+

package/synthetizer/worklet_system/worklet_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.workletProcessorChannels.length; i++)
+    {
+        this.workletProcessorChannels[i].stopAllNotes(force);
+    }
+    this.callEvent("stopall", undefined);
+}

package/synthetizer/worklet_system/worklet_methods/stopping_notes/stop_all_notes.js

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

package/synthetizer/worklet_system/worklet_methods/stopping_notes/voice_killing.js

@@ -0,0 +1,63 @@
+/**
+ * @param channel {WorkletProcessorChannel}
+ * @param voice {WorkletVoice}
+ * @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.workletProcessorChannels)
+    {
+        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);
+        }
+    }
+}
+