spessasynth_core 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_core",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "SoundFont2 synthesizer library for node.js",
   "main": "index.js",
   "type": "module",

package/spessasynth_core/synthetizer/synthesizer.js

@@ -30,8 +30,14 @@ import {
 import { disableAndLockVibrato, setVibrato } from './worklet_system/worklet_methods/vibrato_control.js'
 import { SpessaSynthInfo } from '../utils/loggin.js'
 import { consoleColors } from '../utils/other.js'
-import { releaseVoice, renderVoice, voiceKilling } from './worklet_system/worklet_methods/voice_control.js'
+import {
+    PAN_SMOOTHING_FACTOR,
+    releaseVoice,
+    renderVoice,
+    voiceKilling
+} from './worklet_system/worklet_methods/voice_control.js'
 import {stbvorbis} from "../utils/stbvorbis_sync.js";
+import {VOLUME_ENVELOPE_SMOOTHING_FACTOR} from "./worklet_system/worklet_utilities/volume_envelope.js";
 
 
 export const VOICE_CAP = 450;
@@ -125,6 +131,10 @@ class Synthesizer {
         // in seconds, time between two samples (very, very short)
         this.sampleTime = 1 / this.sampleRate;
 
+        // these smoothing factors were tested on 44100Hz, adjust them here
+        this.volumeEnvelopeSmoothingFactor = VOLUME_ENVELOPE_SMOOTHING_FACTOR * (sampleRate / 44100);
+        this.panSmoothingFactor = PAN_SMOOTHING_FACTOR * (sampleRate / 44100);
+
         /**
          * Controls the system
          * @typedef {"gm"|"gm2"|"gs"|"xg"} SynthSystem

package/spessasynth_core/synthetizer/worklet_system/worklet_methods/note_on.js

@@ -63,7 +63,9 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false)
         }
         computeModulators(voice, this.workletProcessorChannels[channel].midiControllers);
         voice.currentAttenuationDb = 100;
-    })
+        // 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
+    });
 
     this.totalVoicesAmount += voices.length;
     // cap the voices

package/spessasynth_core/synthetizer/worklet_system/worklet_methods/voice_control.js

@@ -1,14 +1,17 @@
 import { generatorTypes } from '../../../soundfont/chunk/generators.js'
-import { absCentsToHz, timecentsToSeconds } from '../worklet_utilities/unit_converter.js'
+import {absCentsToHz, decibelAttenuationToGain, timecentsToSeconds} from '../worklet_utilities/unit_converter.js'
 import { getLFOValue } from '../worklet_utilities/lfo.js'
 import { customControllers } from '../worklet_utilities/worklet_processor_channel.js'
 import { getModEnvValue } from '../worklet_utilities/modulation_envelope.js'
 import { getOscillatorData } from '../worklet_utilities/wavetable_oscillator.js'
 import { panVoice } from '../worklet_utilities/stereo_panner.js'
-import { applyVolumeEnvelope } from '../worklet_utilities/volume_envelope.js'
+import {applyVolumeEnvelope, recalculateVolumeEnvelope} from '../worklet_utilities/volume_envelope.js'
 import { applyLowpassFilter } from '../worklet_utilities/lowpass_filter.js'
 import { MIN_NOTE_LENGTH } from '../../synthesizer.js'
 
+const HALF_PI = Math.PI / 2;
+export const PAN_SMOOTHING_FACTOR = 0.01;
+
 /**
  * Renders a voice to the stereo output buffer
  * @param channel {WorkletProcessorChannel} the voice's channel
@@ -20,18 +23,16 @@ import { MIN_NOTE_LENGTH } from '../../synthesizer.js'
  */
 export function renderVoice(channel, voice, output, reverbOutput, chorusOutput)
 {
-    // if no matching sample, perhaps it's still being loaded...?
-    if(this.workletDumpedSamplesList[voice.sample.sampleID] === undefined)
-    {
-        return;
-    }
-
     // check if release
-    if(!voice.isInRelease) {
+    if(!voice.isInRelease)
+    {
         // if not in release, check if the release time is
-        if (this.currentTime >= voice.releaseStartTime) {
+        if (this.currentTime >= voice.releaseStartTime)
+        {
             voice.releaseStartModEnv = voice.currentModEnvValue;
             voice.isInRelease = true;
+            recalculateVolumeEnvelope(voice);
+            voice.volumeEnvelope.currentReleaseGain = decibelAttenuationToGain(voice.volumeEnvelope.releaseStartDb);
         }
     }
 
@@ -128,12 +129,12 @@ export function renderVoice(channel, voice, output, reverbOutput, chorusOutput)
     applyLowpassFilter(voice, bufferOut, lowpassCents, this.sampleRate);
 
     // volenv
-    applyVolumeEnvelope(voice, bufferOut, this.currentTime, modLfoCentibels, this.sampleTime);
+    applyVolumeEnvelope(voice, bufferOut, this.currentTime, modLfoCentibels, this.sampleTime, this.volumeEnvelopeSmoothingFactor);
 
     // pan the voice and write out
-    voice.currentPan += (pan - voice.currentPan) * 0.1; // smooth out pan to prevent clicking
-    const panLeft = (1 - voice.currentPan) * this.panLeft;
-    const panRight = voice.currentPan *  this.panRight;
+    voice.currentPan += (pan - voice.currentPan) * this.panSmoothingFactor; // smooth out pan to prevent clicking
+    const panLeft = Math.cos(HALF_PI * voice.currentPan) * this.panLeft;
+    const panRight = Math.sin(HALF_PI * voice.currentPan) *  this.panRight;
     panVoice(
         panLeft,
         panRight,
@@ -164,12 +165,12 @@ function getPriority(channel, voice)
     // less velocity = less important
     priority += voice.velocity / 25; // map to 0-5
     // the newer, more important
-    priority -= voice.volumeEnvelopeState;
+    priority -= voice.volumeEnvelope.state;
     if(voice.isInRelease)
     {
         priority -= 5;
     }
-    priority -= voice.currentAttenuationDb / 50;
+    priority -= voice.volumeEnvelope.currentAttenuationDb / 50;
     return priority;
 }
 

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/lowpass_filter.js

@@ -9,6 +9,44 @@ import { absCentsToHz, decibelAttenuationToGain } from './unit_converter.js'
  * Shoutout to them!
  */
 
+/**
+ * @typedef {Object} WorkletLowpassFilter
+ * @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
+ * @property {number} x1 - input history 1
+ * @property {number} x2 - input history 2
+ * @property {number} y1 - output history 1
+ * @property {number} y2 - output history 2
+ * @property {number} reasonanceCb - reasonance in centibels
+ * @property {number} reasonanceGain - resonance gain
+ * @property {number} cutoffCents - cutoff frequency in cents
+ * @property {number} cutoffHz - cutoff frequency in Hz
+ */
+
+/**
+ * @type {WorkletLowpassFilter}
+ */
+export const DEFAULT_WORKLET_LOWPASS_FILTER = {
+    a0: 0,
+    a1: 0,
+    a2: 0,
+    a3: 0,
+    a4: 0,
+
+    x1: 0,
+    x2: 0,
+    y1: 0,
+    y2: 0,
+
+    reasonanceCb: 0,
+    reasonanceGain: 1,
+    cutoffCents: 13500,
+    cutoffHz: 20000
+}
+
 
 /**
  * Applies a low-pass filter to the given buffer

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/volume_envelope.js

@@ -6,6 +6,47 @@ import { generatorTypes } from '../../../soundfont/chunk/generators.js'
  * purpose: applies a volume envelope for a given voice
  */
 
+/**
+ * @typedef {Object} WorkletVolumeEnvelope
+ * @property {number} currentAttenuationDb - current voice attenuation in dB (current sample)
+ * @property {0|1|2|3|4} state - state of the volume envelope. 0 is delay, 1 is attack, 2 is hold, 3 is decay, 4 is sustain
+ * @property {number} releaseStartDb - the dB attenuation of the voice when it was released
+ * @property {number} currentReleaseGain - the current linear gain of the release phase
+ *
+ * @property {number} attackDuration - the duration of the attack phase, in seconds
+ * @property {number} decayDuration - the duration of the decay phase, in seconds
+ *
+ * @property {number} attenuation - the absolute attenuation in dB
+ * @property {number} releaseDuration - the duration of the release phase in seconds
+ * @property {number} sustainDb - the sustain amount in dB
+ *
+ * @property {number} delayEnd - the time when delay ends, in absolute seconds
+ * @property {number} attackEnd - the time when the attack phase ends, in absolute seconds
+ * @property {number} holdEnd - the time when the hold phase ends, in absolute seconds
+ * @property {number} decayEnd - the time when the decay phase ends, in absolute seconds
+ */
+
+/**
+ * @type {WorkletVolumeEnvelope}
+ */
+export const DEFAULT_WORKLET_VOLUME_ENVELOPE = {
+    attenuation: 100,
+    currentAttenuationDb: 100,
+    state: 0,
+    releaseStartDb: 100,
+    attackDuration: 0,
+    decayDuration: 0,
+    releaseDuration: 0,
+    sustainDb: 0,
+    delayEnd: 0,
+    attackEnd: 0,
+    holdEnd: 0,
+    decayEnd: 0,
+    currentReleaseGain: 1,
+}
+
+export const VOLUME_ENVELOPE_SMOOTHING_FACTOR = 0.001;
+
 const DB_SILENCE = 100;
 const GAIN_SILENCE = 0.005;
 
@@ -20,175 +61,212 @@ const GAIN_SILENCE = 0.005;
  */
 
 /**
- * Applies volume envelope gain to the given output buffer
+ * Recalculates the times of the volume envelope
  * @param voice {WorkletVoice} the voice we're working on
- * @param audioBuffer {Float32Array} the audio buffer to modify
- * @param currentTime {number} the current audio time
- * @param centibelOffset {number} the centibel offset of volume, for modLFOtoVolume
- * @param sampleTime {number} single sample time in seconds, usually 1 / 44100 of a second
  */
-
-export function applyVolumeEnvelope(voice, audioBuffer, currentTime, centibelOffset, sampleTime)
+export function recalculateVolumeEnvelope(voice)
 {
-    // calculate values
-    let decibelOffset = centibelOffset / 10;
+    const env = voice.volumeEnvelope;
+    // calculate durations
+    env.attackDuration = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
+    env.decayDuration = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.decayVolEnv]
+        + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay]));
+    env.releaseDuration = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.releaseVolEnv]);
+
+    // calculate absolute times (they can change, so we have to recalculate every time
+    env.attenuation = voice.modulatedGenerators[generatorTypes.initialAttenuation] / 10; // divide by ten to get decibelts
+    env.sustainDb = voice.volumeEnvelope.attenuation + voice.modulatedGenerators[generatorTypes.sustainVolEnv] / 10;
 
-    // calculate env times
-    let attack = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
-    let decay = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.decayVolEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay]));
+    // calculate absolute end time
+    env.delayEnd = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayVolEnv]) + voice.startTime;
+    env.attackEnd = env.attackDuration + env.delayEnd;
 
-    // calculate absolute times
-    let attenuation = voice.modulatedGenerators[generatorTypes.initialAttenuation] / 10; // divide by ten to get decibelts
-    let release = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.releaseVolEnv]);
-    let sustain = attenuation + voice.modulatedGenerators[generatorTypes.sustainVolEnv] / 10;
-    let delayEnd  = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayVolEnv]) + voice.startTime;
-    let attackEnd = attack + delayEnd;
-    let holdEnd = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.holdVolEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvHold])) + attackEnd;
-    let decayEnd = decay + holdEnd;
+    // make sure to take keyNumToVolEnvHold into account!!!
+    env.holdEnd = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.holdVolEnv]
+        + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvHold]))
+        + env.attackEnd;
 
+    env.decayEnd = env.decayDuration + env.holdEnd;
     // check if voice is in release
     if(voice.isInRelease)
     {
         // calculate the db attenuation at the time of release (not a constant because it can change (ex, volume set to 0, the sound should cut off)
-        let releaseStartDb;
-        switch (voice.volumeEnvelopeState)
-        {
+        switch (env.state) {
             case 0:
-                // no sound: fill with zero and skip!
-                for (let i = 0; i < audioBuffer.length; i++) {
-                    audioBuffer[i] = 0;
-                }
-                return;
+                env.releaseStartDb = 0;
+                break;
 
             case 1:
                 // attack phase
                 // attack is linear (in gain) so we need to do get db from that
-                let elapsed = 1 - ((attackEnd - voice.releaseStartTime) / attack);
+                let elapsed = 1 - ((env.attackEnd - voice.releaseStartTime) / env.attackDuration);
                 // calculate the gain that the attack would have
-                let attackGain = elapsed * decibelAttenuationToGain(attenuation + decibelOffset);
+                let attackGain = elapsed * decibelAttenuationToGain(env.attenuation);
 
                 // turn that into db
-                releaseStartDb = 20 * Math.log10(attackGain) * -1;
+                env.releaseStartDb = 20 * Math.log10(attackGain) * -1;
                 break;
 
             case 2:
-                // hold
-                releaseStartDb = attenuation;
+                env.releaseStartDb = env.attenuation;
                 break;
 
             case 3:
-                // decay
-                releaseStartDb = (1 - (decayEnd - voice.releaseStartTime) / decay) * (sustain - attenuation) + attenuation;
+                env.releaseStartDb = (1 - (env.decayEnd - voice.releaseStartTime) / env.decayDuration) * (env.sustainDb - env.attenuation) + env.attenuation;
                 break;
 
             case 4:
-                // sustain
-                releaseStartDb = sustain;
+                env.releaseStartDb = env.sustainDb;
                 break;
 
+            default:
+                env.releaseStartDb = env.currentAttenuationDb;
         }
+    }
+}
 
-        // uncommented because doesn't seem to be needed but just in case
-        // // if the voice is not released, but state set to true (due to min note length, simply use the release db)
-        // if(voice.releaseStartTime > currentTime)
-        // {
-        //     const gain = decibelAttenuationToGain(releaseStartDb + decibelOffset);
-        //     for (let i = 0; i < audioBuffer.length; i++) {
-        //         audioBuffer[i] = gain * audioBuffer[i];
-        //     }
-        //     return;
-        // }
+/**
+ * Applies volume envelope gain to the given output buffer
+ * @param voice {WorkletVoice} the voice we're working on
+ * @param audioBuffer {Float32Array} the audio buffer to modify
+ * @param currentTime {number} the current audio time
+ * @param centibelOffset {number} the centibel offset of volume, for modLFOtoVolume
+ * @param sampleTime {number} single sample time in seconds, usually 1 / 44100 of a second
+ * @param smoothingFactor {number} the adjusted smoothing factor for the envelope
+ */
 
+export function applyVolumeEnvelope(voice, audioBuffer, currentTime, centibelOffset, sampleTime, smoothingFactor)
+{
+    let decibelOffset = centibelOffset / 10;
+    const env = voice.volumeEnvelope;
+
+    // RELEASE PHASE
+    if(voice.isInRelease)
+    {
+        // release needs a more aggressive smoothing factor as the instant notes don't end instantly when they should
+        const releaseSmoothingFactor = smoothingFactor * 10;
+        const releaseStartDb = env.releaseStartDb + decibelOffset;
         let elapsedRelease = currentTime - voice.releaseStartTime;
         let dbDifference = DB_SILENCE - releaseStartDb;
-        let gain;
-        for (let i = 0; i < audioBuffer.length; i++) {
-            let db = (elapsedRelease / release) * dbDifference + releaseStartDb;
+        let gain = env.currentReleaseGain;
+        for (let i = 0; i < audioBuffer.length; i++)
+        {
+            let db = (elapsedRelease / env.releaseDuration) * dbDifference + releaseStartDb;
             gain = decibelAttenuationToGain(db + decibelOffset);
-            audioBuffer[i] = gain * audioBuffer[i];
+            env.currentReleaseGain += (gain - env.currentReleaseGain) * releaseSmoothingFactor;
+            audioBuffer[i] *= env.currentReleaseGain;
             elapsedRelease += sampleTime;
         }
 
-        if(gain <= GAIN_SILENCE)
+        if(env.currentReleaseGain <= GAIN_SILENCE)
         {
             voice.finished = true;
         }
         return;
     }
+
+    if(!voice.hasStarted)
+    {
+        voice.startTime = currentTime;
+        recalculateVolumeEnvelope(voice);
+        voice.hasStarted = true;
+    }
+
     let currentFrameTime = currentTime;
-    let dbAttenuation;
-    for (let i = 0; i < audioBuffer.length; i++) {
-        switch(voice.volumeEnvelopeState)
-        {
-            case 0:
-                // delay phase, no sound is produced
-                if(currentFrameTime >= delayEnd)
+    let filledBuffer = 0;
+    switch(env.state)
+    {
+        case 0:
+            // delay phase, no sound is produced
+            while(currentFrameTime < env.delayEnd)
+            {
+                env.currentAttenuationDb = DB_SILENCE;
+                audioBuffer[filledBuffer] = 0;
+
+                currentFrameTime += sampleTime;
+                if(++filledBuffer >= audioBuffer.length)
                 {
-                    voice.volumeEnvelopeState++;
+                    return;
                 }
-                else
-                {
-                    dbAttenuation = DB_SILENCE;
-                    audioBuffer[i] = 0;
+            }
+            env.state++;
+        // fallthrough
 
-                    // no need to go through the hassle of converting. Skip
-                    currentFrameTime += sampleTime;
-                    continue;
-                }
-            // fallthrough
+        case 1:
+            // attack phase: ramp from 0 to attenuation
+            while(currentFrameTime < env.attackEnd)
+            {
+                // Special case: linear gain ramp instead of linear db ramp
+                let linearAttenuation = 1 - (env.attackEnd - currentFrameTime) / env.attackDuration; // 0 to 1
+                const gain = linearAttenuation * decibelAttenuationToGain(env.attenuation + decibelOffset)
+                audioBuffer[filledBuffer] *= gain;
 
-            case 1:
-                // attack phase: ramp from 0 to attenuation
-                if(currentFrameTime >= attackEnd)
+                // set current attenuation to peak as its invalid during this phase
+                env.currentAttenuationDb = env.attenuation;
+
+                currentFrameTime += sampleTime;
+                if(++filledBuffer >= audioBuffer.length)
                 {
-                    voice.volumeEnvelopeState++;
+                    return;
                 }
-                else {
-                    // Special case: linear gain ramp instead of linear db ramp
-                    const elapsed = (attackEnd - currentFrameTime) / attack;
-                    dbAttenuation = 10 * Math.log10((elapsed * (attenuation - DB_SILENCE) + DB_SILENCE) * -1);
-                    audioBuffer[i] = audioBuffer[i] * (1 - elapsed) * decibelAttenuationToGain(attenuation + decibelOffset);
-                    currentFrameTime += sampleTime;
-                    continue
+            }
+            env.state++;
+        // fallthrough
 
-                }
-            // fallthrough
+        case 2:
+            // hold/peak phase: stay at attenuation
+            while(currentFrameTime < env.holdEnd)
+            {
+                const newAttenuation = env.attenuation
+                    + decibelOffset;
 
-            case 2:
-                // hold/peak phase: stay at attenuation
-                if(currentFrameTime >= holdEnd)
-                {
-                    voice.volumeEnvelopeState++;
-                }
-                else
+                // interpolate attenuation to prevent clicking
+                env.currentAttenuationDb += (newAttenuation - env.currentAttenuationDb) * smoothingFactor;
+                audioBuffer[filledBuffer] *= decibelAttenuationToGain(env.currentAttenuationDb);
+
+                currentFrameTime += sampleTime;
+                if(++filledBuffer >= audioBuffer.length)
                 {
-                    dbAttenuation = attenuation;
-                    break;
+                    return;
                 }
-            // fallthrough
+            }
+            env.state++;
+        // fallthrough
 
-            case 3:
-                // decay phase: linear ramp from attenuation to sustain
-                if(currentFrameTime >= decayEnd)
+        case 3:
+            // decay phase: linear ramp from attenuation to sustain
+            while(currentFrameTime < env.decayEnd)
+            {
+                const newAttenuation = (1 - (env.decayEnd - currentFrameTime) / env.decayDuration) * (env.sustainDb - env.attenuation) + env.attenuation
+                    + decibelOffset;
+
+                // interpolate attenuation to prevent clicking
+                env.currentAttenuationDb += (newAttenuation - env.currentAttenuationDb) * smoothingFactor;
+                audioBuffer[filledBuffer] *= decibelAttenuationToGain(env.currentAttenuationDb);
+
+                currentFrameTime += sampleTime;
+                if(++filledBuffer >= audioBuffer.length)
                 {
-                    voice.volumeEnvelopeState++;
+                    return;
                 }
-                else
+            }
+            env.state++;
+        // fallthrough
+
+        case 4:
+            // sustain phase: stay at sustain
+            while(true)
+            {
+                // interpolate attenuation to prevent clicking
+                const newAttenuation = env.sustainDb
+                    + decibelOffset;
+                env.currentAttenuationDb += (newAttenuation - env.currentAttenuationDb) * smoothingFactor;
+                audioBuffer[filledBuffer] *= decibelAttenuationToGain(env.currentAttenuationDb);
+                if(++filledBuffer >= audioBuffer.length)
                 {
-                    dbAttenuation = (1 - (decayEnd - currentFrameTime) / decay) * (sustain - attenuation) + attenuation;
-                    break
+                    return;
                 }
-            // fallthrough
+            }
 
-            case 4:
-                // sustain phase: stay at sustain
-                dbAttenuation = sustain;
-
-        }
-        // apply gain and advance the time
-        const gain = decibelAttenuationToGain(dbAttenuation + decibelOffset);
-        audioBuffer[i] = audioBuffer[i] * gain;
-        currentFrameTime += sampleTime;
     }
-    voice.currentAttenuationDb = dbAttenuation;
 }

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/worklet_modulator.js

@@ -1,6 +1,7 @@
 import { modulatorSources } from '../../../soundfont/chunk/modulators.js'
 import { getModulatorCurveValue, MOD_PRECOMPUTED_LENGTH } from './modulator_curves.js'
 import { NON_CC_INDEX_OFFSET } from './worklet_processor_channel.js'
+import {recalculateVolumeEnvelope} from "./volume_envelope.js";
 
 /**
  * worklet_modulator.js
@@ -107,6 +108,7 @@ export function computeModulators(voice, controllerTable)
     voice.modulators.forEach(mod => {
         voice.modulatedGenerators[mod.modulatorDestination] += computeWorkletModulator(controllerTable, mod, voice.midiNote, voice.velocity);
     });
+    recalculateVolumeEnvelope(voice);
 }
 
 /**

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -16,23 +16,6 @@
  * @property {0|1|2} loopingMode - looping mode of the sample
  */
 
-/**
- * @typedef {Object} WorkletLowpassFilter
- * @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
- * @property {number} x1 - input history 1
- * @property {number} x2 - input history 2
- * @property {number} y1 - output history 1
- * @property {number} y2 - output history 2
- * @property {number} reasonanceCb - reasonance in centibels
- * @property {number} reasonanceGain - resonance gain
- * @property {number} cutoffCents - cutoff frequency in cents
- * @property {number} cutoffHz - cutoff frequency in Hz
- */
-
 /**
  * @typedef {Object} WorkletVoice
  * @property {WorkletSample} sample - sample ID for voice.
@@ -43,19 +26,20 @@
  *
  * @property {boolean} finished - indicates if the voice has finished
  * @property {boolean} isInRelease - indicates if the voice is in the release phase
+ * @property {boolean} hasStarted - indicates if the voice has started rendering
  *
  * @property {number} channelNumber - MIDI channel number
  * @property {number} velocity - velocity of the note
  * @property {number} midiNote - MIDI note number
  * @property {number} targetKey - target key for the note
  *
- * @property {number} currentAttenuationDb - current attenuation in dB (used for calculating start of the release phase)
- * @property {0|1|2|3|4} volumeEnvelopeState - state of the volume envelope.
+ * @property {WorkletVolumeEnvelope} volumeEnvelope
+ *
  * @property {number} currentModEnvValue - current value of the modulation envelope
+ * @property {number} releaseStartModEnv - modenv value at the start of the release phase
  *
  * @property {number} startTime - start time of the voice
  * @property {number} releaseStartTime - start time of the release phase
- * @property {number} releaseStartModEnv - modenv value at the start of the release phase
  *
  * @property {number} currentTuningCents - current tuning adjustment in cents
  * @property {number} currentTuningCalculated - calculated tuning adjustment
@@ -64,6 +48,8 @@
 
 import { addAndClampGenerator, generatorTypes } from '../../../soundfont/chunk/generators.js'
 import { SpessaSynthTable } from '../../../utils/loggin.js'
+import { DEFAULT_WORKLET_VOLUME_ENVELOPE } from './volume_envelope.js'
+import { DEFAULT_WORKLET_LOWPASS_FILTER } from './lowpass_filter.js'
 
 
 /**
@@ -260,22 +246,7 @@ export function getWorkletVoices(channel,
             }
 
             return {
-                filter: {
-                    a0: 0,
-                    a1: 0,
-                    a2: 0,
-                    a3: 0,
-                    a4: 0,
-
-                    x1: 0,
-                    x2: 0,
-                    y1: 0,
-                    y2: 0,
-                    reasonanceCb: 0,
-                    reasonanceGain: 1,
-                    cutoffCents: 13500,
-                    cutoffHz: 20000
-                },
+                filter: deepClone(DEFAULT_WORKLET_LOWPASS_FILTER),
                 // generators and modulators
                 generators: generators,
                 modulators: sampleAndGenerators.modulators,
@@ -295,11 +266,12 @@ export function getWorkletVoices(channel,
                 // envelope data
                 finished: false,
                 isInRelease: false,
-                currentAttenuationDb: 100,
+                hasStarted: false,
                 currentModEnvValue: 0,
                 releaseStartModEnv: 1,
-                volumeEnvelopeState: 0,
-                currentPan: 0.5
+                currentPan: 0.5,
+
+                volumeEnvelope: deepClone(DEFAULT_WORKLET_VOLUME_ENVELOPE)
             };
 
         });