spessasynth_lib 3.24.7 → 3.24.9

package/synthetizer/worklet_system/main_processor.js

@@ -1,10 +1,8 @@
-// noinspection JSUnresolvedReference
-
 import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE, VOICE_CAP } from "../synthetizer.js";
 import { WorkletSequencer } from "../../sequencer/worklet_sequencer/worklet_sequencer.js";
 import { SpessaSynthInfo } from "../../utils/loggin.js";
 import { consoleColors } from "../../utils/other.js";
-import { PAN_SMOOTHING_FACTOR, releaseVoice, renderVoice, voiceKilling } from "./worklet_methods/voice_control.js";
+import { releaseVoice, renderVoice, voiceKilling } from "./worklet_methods/voice_control.js";
 import { ALL_CHANNELS_OR_DIFFERENT_ACTION, returnMessageType } from "./message_protocol/worklet_message.js";
 import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
 import { VOLUME_ENVELOPE_SMOOTHING_FACTOR } from "./worklet_utilities/volume_envelope.js";
@@ -51,7 +49,7 @@ import { WorkletSoundfontManager } from "./worklet_methods/worklet_soundfont_man
 import { interpolationTypes } from "./worklet_utilities/wavetable_oscillator.js";
 import { WorkletKeyModifierManager } from "./worklet_methods/worklet_key_modifier.js";
 import { getWorkletVoices } from "./worklet_utilities/worklet_voice.js";
-import { panVoice } from "./worklet_utilities/stereo_panner.js";
+import { PAN_SMOOTHING_FACTOR, panVoice } from "./worklet_utilities/stereo_panner.js";
 
 
 /**
@@ -68,6 +66,7 @@ export const MIN_EXCLUSIVE_LENGTH = 0.07;
 export const SYNTHESIZER_GAIN = 1.0;
 
 
+// noinspection JSUnresolvedReference
 class SpessaSynthProcessor extends AudioWorkletProcessor
 {
     /**
@@ -106,11 +105,6 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
          */
         this.interpolationType = interpolationTypes.fourthOrder;
         
-        /**
-         * @type {function}
-         */
-        this.processTickCallback = undefined;
-        
         this.sequencer = new WorkletSequencer(this);
         
         this.transposition = 0;
@@ -214,7 +208,7 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
         this.workletProcessorChannels[DEFAULT_PERCUSSION].preset = this.drumPreset;
         this.workletProcessorChannels[DEFAULT_PERCUSSION].drumChannel = true;
         
-        // these smoothing factors were tested on 44,100 Hz, adjust them here
+        // these smoothing factors were tested on 44,100 Hz, adjust them to target sample rate here
         this.volumeEnvelopeSmoothingFactor = VOLUME_ENVELOPE_SMOOTHING_FACTOR * (44100 / sampleRate);
         this.panSmoothingFactor = PAN_SMOOTHING_FACTOR * (44100 / sampleRate);
         
@@ -327,10 +321,8 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
         {
             return false;
         }
-        if (this.processTickCallback)
-        {
-            this.processTickCallback();
-        }
+        // process the sequencer playback
+        this.sequencer.processTick();
         
         // for every channel
         let totalCurrentVoices = 0;
@@ -365,13 +357,8 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
                 chorusChannels = outputs[1];
             }
             
-            const tempV = channel.voices;
-            
-            // reset voices
-            channel.voices = [];
-            
-            // for every voice
-            tempV.forEach(v =>
+            // for every voice, render it
+            channel.voices = channel.voices.filter(v =>
             {
                 // render voice
                 this.renderVoice(
@@ -381,11 +368,8 @@ class SpessaSynthProcessor extends AudioWorkletProcessor
                     reverbChannels,
                     chorusChannels
                 );
-                if (!v.finished)
-                {
-                    // if not finished, add it back
-                    channel.voices.push(v);
-                }
+                
+                return !v.finished;
             });
             
             totalCurrentVoices += channel.voices.length;
@@ -433,7 +417,7 @@ SpessaSynthProcessor.prototype.handleMessage = handleMessage;
 SpessaSynthProcessor.prototype.sendChannelProperties = sendChannelProperties;
 SpessaSynthProcessor.prototype.callEvent = callEvent;
 
-// system exlcusive related
+// system-exclusive related
 SpessaSynthProcessor.prototype.systemExclusive = systemExclusive;
 
 // note messages related

package/synthetizer/worklet_system/message_protocol/README.md

@@ -0,0 +1,13 @@
+# About the message protocol
+Since spessasynth runs in the audioWorklet thread, here is an explanation of how it works:
+
+There's one processor per synthesizer, with a `MessagePort` for communication.
+Each processor has a single `WorkletSequencer` instance that is idle by default.
+
+The `Synthetizer`, 
+`Sequencer` and `SoundFontManager` classes are all interfaces 
+that do not do anything except sending the commands to te processor.
+
+The synthesizer sends the commands (note on, off, etc.) directly to the processor where they are processed and executed.
+
+The sequencer sends the commands through the connected synthesizer's messagePort, which then get processed as sequencer messages and routed

package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -222,6 +222,7 @@ export function handleMessage(message)
         
         case workletMessageType.destroyWorklet:
             this.alive = false;
+            this.destroyWorkletProcessor();
             break;
         
         default:

package/synthetizer/worklet_system/worklet_methods/note_on.js

@@ -123,10 +123,7 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         // 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) / 1000); // 0 to 1
+        voice.currentPan = Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan])); //  -500 to 500
     });
     
     this.totalVoicesAmount += voices.length;

package/synthetizer/worklet_system/worklet_methods/voice_control.js

@@ -13,8 +13,6 @@ import { generatorTypes } from "../../../soundfont/basic_soundfont/generator.js"
 import { customControllers } from "../worklet_utilities/controller_tables.js";
 import { WorkletLowpassFilter } from "../worklet_utilities/lowpass_filter.js";
 
-export const PAN_SMOOTHING_FACTOR = 0.05;
-
 /**
  * Renders a voice to the stereo output buffer
  * @param channel {WorkletProcessorChannel} the voice's channel

package/synthetizer/worklet_system/worklet_utilities/lowpass_filter.js

@@ -4,13 +4,29 @@ import { generatorTypes } from "../../../soundfont/basic_soundfont/generator.js"
 /**
  * lowpass_filter.js
  * purpose: applies a low pass filter to a voice
- * note to self: most of this is code is just javascript version of the C code from fluidsynth,
- * they are the real smart guys.
+ * note to self: a lot of tricks and fixes come from fluidsynth.
+ * They are the real smart guys.
  * Shoutout to them!
  */
 
+/**
+ * @typedef {Object} CachedCoefficient
+ * @property {number} a0 - Filter coefficient 1
+ * @property {number} a1 - Filter coefficient 2
+ * @property {number} a2 - Filter coefficient 3
+ * @property {number} a3 - Filter coefficient 4
+ * @property {number} a4 - Filter coefficient 5
+ */
+
 export class WorkletLowpassFilter
 {
+    /**
+     * Cached coefficient calculations
+     * stored as cachedCoefficients[reasonanceCb][cutoffCents]
+     * @type {CachedCoefficient[][]}
+     * @private
+     */
+    static cachedCoefficients = [];
     /**
      * Filter coefficient 1
      * @type {number}
@@ -71,25 +87,13 @@ export class WorkletLowpassFilter
      */
     reasonanceCb = 0;
     
-    /**
-     * Resonance gain
-     * @type {number}
-     */
-    reasonanceGain = 1;
-    
     /**
      * Cutoff frequency in cents
-     * Note: defaults to 13501 to cause a recalculation even at initial fc being 13500
+     * Note: defaults to 13,501 to cause a recalculation even at initial fc being 13,500
      * @type {number}
      */
     cutoffCents = 13501;
     
-    /**
-     * Cutoff frequency in Hz
-     * @type {number}
-     */
-    cutoffHz = 20001;
-    
     /**
      * Applies a low-pass filter to the given buffer
      * @param voice {WorkletVoice} the voice we're working on
@@ -139,36 +143,58 @@ export class WorkletLowpassFilter
      */
     static calculateCoefficients(filter)
     {
-        filter.cutoffHz = absCentsToHz(filter.cutoffCents);
-        
-        // fix cutoff on low frequencies (fluid_iir_filter.c line 392)
-        filter.cutoffHz = Math.min(filter.cutoffHz, 0.45 * sampleRate);
-        
-        const qDb = filter.reasonanceCb / 10;
-        // correct the filter gain, like fluid does
-        filter.reasonanceGain = decibelAttenuationToGain(-1 * (qDb - 3.01)); // -1 because it's attenuation and we don't want attenuation
-        
-        // reduce the gain by the Q factor (fluid_iir_filter.c line 250)
-        const qGain = 1 / Math.sqrt(decibelAttenuationToGain(-qDb));
-        
-        
-        // code is ported from https://github.com/sinshu/meltysynth/ to work with js.
-        let w = 2 * Math.PI * filter.cutoffHz / sampleRate; // we're in the audioworkletglobalscope so we can use sampleRate
-        let cosw = Math.cos(w);
-        let alpha = Math.sin(w) / (2 * filter.reasonanceGain);
-        
-        let b1 = (1 - cosw) * qGain;
-        let b0 = b1 / 2;
-        let b2 = b0;
-        let a0 = 1 + alpha;
-        let a1 = -2 * cosw;
-        let a2 = 1 - alpha;
-        
-        // set coefficients
-        filter.a0 = b0 / a0;
-        filter.a1 = b1 / a0;
-        filter.a2 = b2 / a0;
-        filter.a3 = a1 / a0;
-        filter.a4 = a2 / a0;
+        const cutoffCents = ~~filter.cutoffCents; // Math.floor
+        const qCb = filter.reasonanceCb;
+        // check if these coefficients were already cached
+        if (WorkletLowpassFilter.cachedCoefficients?.[qCb]?.[cutoffCents] === undefined)
+        {
+            let cutoffHz = absCentsToHz(cutoffCents);
+            
+            // fix cutoff on low frequencies (fluid_iir_filter.c line 392)
+            cutoffHz = Math.min(cutoffHz, 0.45 * sampleRate);
+            
+            const qDb = qCb / 10;
+            // correct the filter gain, like fluid does
+            const reasonanceGain = decibelAttenuationToGain(-1 * (qDb - 3.01)); // -1 because it's attenuation, and we don't want attenuation
+            
+            // reduce the gain by the Q factor (fluid_iir_filter.c line 250)
+            const qGain = 1 / Math.sqrt(decibelAttenuationToGain(-qDb));
+            
+            
+            // initial filtering code was ported from meltysynth created by sinshu.
+            let w = 2 * Math.PI * cutoffHz / sampleRate; // we're in the AudioWorkletGlobalScope so we can use sampleRate
+            let cosw = Math.cos(w);
+            let alpha = Math.sin(w) / (2 * reasonanceGain);
+            
+            let b1 = (1 - cosw) * qGain;
+            let b0 = b1 / 2;
+            let b2 = b0;
+            let a0 = 1 + alpha;
+            let a1 = -2 * cosw;
+            let a2 = 1 - alpha;
+            
+            /**
+             * set coefficients
+             * @type {CachedCoefficient}
+             */
+            const toCache = {};
+            toCache.a0 = b0 / a0;
+            toCache.a1 = b1 / a0;
+            toCache.a2 = b2 / a0;
+            toCache.a3 = a1 / a0;
+            toCache.a4 = a2 / a0;
+            
+            if (WorkletLowpassFilter.cachedCoefficients[qCb] === undefined)
+            {
+                WorkletLowpassFilter.cachedCoefficients[qCb] = [];
+            }
+            WorkletLowpassFilter.cachedCoefficients[qCb][cutoffCents] = toCache;
+        }
+        const cached = WorkletLowpassFilter.cachedCoefficients[qCb][cutoffCents];
+        filter.a0 = cached.a0;
+        filter.a1 = cached.a1;
+        filter.a2 = cached.a2;
+        filter.a3 = cached.a3;
+        filter.a4 = cached.a4;
     }
 }

package/synthetizer/worklet_system/worklet_utilities/stereo_panner.js

@@ -1,14 +1,32 @@
 import { generatorTypes } from "../../../soundfont/basic_soundfont/generator.js";
 
-export const WORKLET_SYSTEM_REVERB_DIVIDER = 4600;
-export const WORKLET_SYSTEM_CHORUS_DIVIDER = 2000;
-const HALF_PI = Math.PI / 2;
-
 /**
  * stereo_panner.js
  * purpose: pans a given voice out to the stereo output and to the effects' outputs
  */
 
+export const PAN_SMOOTHING_FACTOR = 0.1;
+
+export const WORKLET_SYSTEM_REVERB_DIVIDER = 4600;
+export const WORKLET_SYSTEM_CHORUS_DIVIDER = 2000;
+const HALF_PI = Math.PI / 2;
+
+const MIN_PAN = -500;
+const MAX_PAN = 500;
+const PAN_RESOLUTION = MAX_PAN - MIN_PAN;
+
+// initialize pan lookup tables
+const panTableLeft = new Float32Array(PAN_RESOLUTION + 1);
+const panTableRight = new Float32Array(PAN_RESOLUTION + 1);
+for (let pan = MIN_PAN; pan <= MAX_PAN; pan++)
+{
+    // clamp to 0-1
+    const realPan = (pan - MIN_PAN) / PAN_RESOLUTION;
+    const tableIndex = pan - MIN_PAN;
+    panTableLeft[tableIndex] = Math.cos(HALF_PI * realPan);
+    panTableRight[tableIndex] = Math.sin(HALF_PI * realPan);
+}
+
 /**
  * Pans the voice to the given output buffers
  * @param voice {WorkletVoice} the voice to pan
@@ -29,43 +47,51 @@ export function panVoice(voice,
     {
         return;
     }
-    const pan = ((Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan])) + 500) / 1000); // 0 to 1
-    voice.currentPan += (pan - voice.currentPan) * this.panSmoothingFactor; // smooth out pan to prevent clicking
+    // clamp -500 to 500
+    const pan = Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan]));
+    // smooth out pan to prevent clicking
+    voice.currentPan += (pan - voice.currentPan) * this.panSmoothingFactor;
     
     const gain = this.currentGain;
-    // pan the voice and write out
-    const gainLeft = Math.cos(HALF_PI * voice.currentPan) * gain * this.panLeft;
-    const gainRight = Math.sin(HALF_PI * voice.currentPan) * gain * this.panRight;
-    // disable reverb and chorus in one output mode
+    const index = ~~(pan + 500);
+    // get voice's gain levels for each channel
+    const gainLeft = panTableLeft[index] * gain * this.panLeft;
+    const gainRight = panTableRight[index] * gain * this.panRight;
     
-    const reverbLevel = this.reverbGain * voice.modulatedGenerators[generatorTypes.reverbEffectsSend] / WORKLET_SYSTEM_REVERB_DIVIDER * gain;
-    const chorusLevel = this.chorusGain * voice.modulatedGenerators[generatorTypes.chorusEffectsSend] / WORKLET_SYSTEM_CHORUS_DIVIDER;
-    
-    if (reverbLevel > 0 && !this.oneOutputMode)
+    // disable reverb and chorus in one output mode
+    if (!this.oneOutputMode)
     {
-        const reverbLeft = reverb[0];
-        const reverbRight = reverb[1];
-        for (let i = 0; i < inputBuffer.length; i++)
+        // reverb is mono so we need to multiply by gain
+        const reverbLevel = this.reverbGain * voice.modulatedGenerators[generatorTypes.reverbEffectsSend] / WORKLET_SYSTEM_REVERB_DIVIDER * gain;
+        // chorus is stereo so we do not need to
+        const chorusLevel = this.chorusGain * voice.modulatedGenerators[generatorTypes.chorusEffectsSend] / WORKLET_SYSTEM_CHORUS_DIVIDER;
+        
+        if (reverbLevel > 0)
         {
-            reverbLeft[i] += reverbLevel * inputBuffer[i];
-            reverbRight[i] += reverbLevel * inputBuffer[i];
+            const reverbLeft = reverb[0];
+            const reverbRight = reverb[1];
+            for (let i = 0; i < inputBuffer.length; i++)
+            {
+                reverbLeft[i] += reverbLevel * inputBuffer[i];
+                reverbRight[i] += reverbLevel * inputBuffer[i];
+            }
         }
-    }
-    
-    if (chorusLevel > 0 && !this.oneOutputMode)
-    {
-        const chorusLeft = chorus[0];
-        const chorusRight = chorus[1];
-        const chorusLeftGain = gainLeft * chorusLevel;
-        const chorusRightGain = gainRight * chorusLevel;
-        for (let i = 0; i < inputBuffer.length; i++)
+        
+        if (chorusLevel > 0)
         {
-            chorusLeft[i] += chorusLeftGain * inputBuffer[i];
-            chorusRight[i] += chorusRightGain * inputBuffer[i];
+            const chorusLeft = chorus[0];
+            const chorusRight = chorus[1];
+            const chorusLeftGain = gainLeft * chorusLevel;
+            const chorusRightGain = gainRight * chorusLevel;
+            for (let i = 0; i < inputBuffer.length; i++)
+            {
+                chorusLeft[i] += chorusLeftGain * inputBuffer[i];
+                chorusRight[i] += chorusRightGain * inputBuffer[i];
+            }
         }
     }
     
-    // mix out the audio data
+    // mix down the audio data
     if (gainLeft > 0)
     {
         for (let i = 0; i < inputBuffer.length; i++)

package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -220,10 +220,10 @@ class WorkletVoice
     currentTuningCalculated = 1;
     
     /**
-     * From 0 to 1.
+     * From -500 to 500.
      * @param {number}
      */
-    currentPan = 0.5;
+    currentPan = 0;
     
     /**
      * If MIDI Tuning Standard is already applied (at note-on time),
@@ -337,7 +337,7 @@ export function getWorkletVoices(channel,
     // override patch
     const overridePatch = this.keyModifierManager.hasOverridePatch(channel, midiNote);
     
-    // overriden patch is not cached
+    // override patch is not cached
     if (cached !== undefined && !overridePatch)
     {
         return cached.map(v => WorkletVoice.copy(v, currentTime));