spessasynth_lib 3.20.1 → 3.20.3

package/synthetizer/worklet_system/worklet_utilities/volume_envelope.js

@@ -6,49 +6,10 @@ import { generatorTypes } from '../../../soundfont/read_sf2/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;
+const PERCEIVED_DB_SILENCE = 96;
 
 /**
  * VOL ENV STATES:
@@ -60,207 +21,331 @@ const GAIN_SILENCE = 0.005;
  * release is indicated by isInRelease property
  */
 
-/**
- * Recalculates the times of the volume envelope
- * @param voice {WorkletVoice} the voice we're working on
- */
-export function recalculateVolumeEnvelope(voice)
+export class WorkletVolumeEnvelope
 {
-    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 absolute end time
-    env.delayEnd = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayVolEnv]) + voice.startTime;
-    env.attackEnd = env.attackDuration + env.delayEnd;
-
-    // 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)
+    /**
+     * @param sampleRate {number} Hz
+     */
+    constructor(sampleRate)
     {
-        // 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)
-        switch (env.state) {
-            case 0:
-                env.releaseStartDb = DB_SILENCE;
-                break;
-
-            case 1:
-                // attack phase: get linear gain of the attack phase when release started
-                // and turn it into db as we're ramping the db up linearly (to make volume go down exponentially)
-                // attack is linear (in gain) so we need to do get db from that
-                let elapsed = 1 - ((env.attackEnd - voice.releaseStartTime) / env.attackDuration);
-                // calculate the gain that the attack would have
-                let attackGain = elapsed * decibelAttenuationToGain(env.attenuation);
-
-                // turn that into db
-                env.releaseStartDb = 20 * Math.log10(attackGain) * -1;
-                break;
-
-            case 2:
-                env.releaseStartDb = env.attenuation;
-                break;
-
-            case 3:
-                env.releaseStartDb = (1 - (env.decayEnd - voice.releaseStartTime) / env.decayDuration) * (env.sustainDb - env.attenuation) + env.attenuation;
-                break;
-
-            case 4:
-                env.releaseStartDb = env.sustainDb;
-                break;
-
-            default:
-                env.releaseStartDb = env.currentAttenuationDb;
-        }
+        this.sampleRate = sampleRate;
     }
-}
 
-/**
- * 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;
+    /**
+     * The envelope's current time in samples
+     * @type {number}
+     */
+    currentSampleTime = 0;
+
+    /**
+     * The sample rate in Hz
+     * @type {number}
+     */
+    sampleRate;
+    /**
+     * The current attenuation of the envelope in dB
+     * @type {number}
+     */
+    currentAttenuationDb = DB_SILENCE;
+    /**
+     * The current stage of the volume envelope
+     * @type {0|1|2|3|4}
+     */
+    state = 0;
+    /**
+     * The dB attenuation of the envelope when it entered the release stage
+     * @type {number}
+     */
+    releaseStartDb = 100;
+    /**
+     * The time in samples relative to the start of the envelope
+     * @type {number}
+     */
+    releaseStartTimeSamples = 0;
+    /**
+     * The current gain applied to the voice in the release stage
+     * @type {number}
+     */
+    currentReleaseGain = 1;
+
+    /**
+     * The attack duration in samples
+     * @type {number}
+     */
+    attackDuration = 0;
+    /**
+     * The decay duration in samples
+     * @type {number}
+     */
+    decayDuration = 0;
+
+    /**
+     * The release duration in samples
+     * @type {number}
+     */
+    releaseDuration = 0;
+
+    /**
+     * The voice's absolute attenuation in dB
+     * @type {number}
+     */
+    attenuation = 0;
+
+    /**
+     * The voice's sustain amount in dB, absolute
+     * @type {number}
+     */
+    sustainDb = 0;
+
+    /**
+     * The time in samples to the end of delay stage, relative to start of the envelope
+     * @type {number}
+     */
+    delayEnd = 0;
+
+    /**
+     * The time in samples to the end of attack stage, relative to start of the envelope
+     * @type {number}
+     */
+    attackEnd = 0;
+
+    /**
+     * The time in samples to the end of hold stage, relative to start of the envelope
+     * @type {number}
+     */
+    holdEnd = 0;
+
+    /**
+     * The time in samples to the end of decay stage, relative to start of the envelope
+     * @type {number}
+     */
+    decayEnd = 0;
+
+    /**
+     * Starts the release phase in the envelope
+     * @param voice {WorkletVoice} the voice this envelope belongs to
+     */
+    static startRelease(voice)
+    {
+        voice.volumeEnvelope.releaseStartTimeSamples = voice.volumeEnvelope.currentSampleTime;
+        voice.volumeEnvelope.currentReleaseGain = decibelAttenuationToGain(voice.volumeEnvelope.currentAttenuationDb);
+        WorkletVolumeEnvelope.recalculate(voice);
+    }
 
-    // RELEASE PHASE
-    if(voice.isInRelease)
+    /**
+     * Recalculates the envelope
+     * @param voice {WorkletVoice} the voice this envelope belongs to
+     */
+    static recalculate(voice)
     {
-        // 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 = env.currentReleaseGain;
-        for (let i = 0; i < audioBuffer.length; i++)
+        const env = voice.volumeEnvelope;
+        const timecentsToSamples = tc =>
         {
-            let db = (elapsedRelease / env.releaseDuration) * dbDifference + releaseStartDb;
-            gain = decibelAttenuationToGain(db + decibelOffset);
-            env.currentReleaseGain += (gain - env.currentReleaseGain) * releaseSmoothingFactor;
-            audioBuffer[i] *= env.currentReleaseGain;
-            elapsedRelease += sampleTime;
+            return Math.floor(timecentsToSeconds(tc) * env.sampleRate);
         }
-
-        if(env.currentReleaseGain <= GAIN_SILENCE)
+        // 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 durations
+        env.attackDuration = timecentsToSamples(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
+
+        // decay: sfspec page 35: the time is for change from attenuation to -100dB
+        // therefore we need to calculate the real time
+        // (changing from attenuation to sustain instead of -100dB)
+        const fullChange = voice.modulatedGenerators[generatorTypes.decayVolEnv];
+        const keyNumAddition = ((60 - voice.targetKey) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay]);
+        const fraction = (env.sustainDb - env.attenuation) / (100 - env.attenuation);
+        env.decayDuration = timecentsToSamples(fullChange + keyNumAddition) * fraction;
+
+        env.releaseDuration = timecentsToSamples(voice.modulatedGenerators[generatorTypes.releaseVolEnv]);
+
+        // calculate absolute end times for the values
+        env.delayEnd = timecentsToSamples(voice.modulatedGenerators[generatorTypes.delayVolEnv]);
+        env.attackEnd = env.attackDuration + env.delayEnd;
+
+        // make sure to take keyNumToVolEnvHold into account!!!
+        const holdExcursion = (60 - voice.targetKey) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvHold];
+        env.holdEnd = timecentsToSamples(voice.modulatedGenerators[generatorTypes.holdVolEnv]
+                + holdExcursion)
+                + env.attackEnd;
+
+        env.decayEnd = env.decayDuration + env.holdEnd;
+        // check if voice is in release
+        if(voice.isInRelease)
         {
-            voice.finished = true;
+            switch (env.state)
+            {
+                case 0:
+                    env.releaseStartDb = DB_SILENCE;
+                    break;
+
+                case 1:
+                    // attack phase: get linear gain of the attack phase when release started
+                    // and turn it into db as we're ramping the db up linearly
+                    // (to make volume go down exponentially)
+                    // attack is linear (in gain) so we need to do get db from that
+                    let elapsed = 1 - ((env.attackEnd - env.releaseStartTimeSamples) / env.attackDuration);
+                    // calculate the gain that the attack would have
+                    let attackGain = elapsed * decibelAttenuationToGain(env.attenuation);
+
+                    // turn that into db
+                    env.releaseStartDb = 20 * Math.log10(attackGain) * -1;
+                    break;
+
+                case 2:
+                    env.releaseStartDb = env.attenuation;
+                    break;
+
+                case 3:
+                    env.releaseStartDb = (1 - (env.decayEnd - env.releaseStartTimeSamples) / env.decayDuration) * (env.sustainDb - env.attenuation) + env.attenuation;
+                    break;
+
+                case 4:
+                    env.releaseStartDb = env.sustainDb;
+                    break;
+
+                default:
+                    env.releaseStartDb = env.currentAttenuationDb;
+            }
         }
-        return;
     }
 
-    let currentFrameTime = currentTime;
-    let filledBuffer = 0;
-    switch(env.state)
+    /**
+     * Gets interpolated gain
+     * @param env {WorkletVolumeEnvelope}
+     * @param attenuationDb {number} in decibels
+     * @param smoothingFactor {number}
+     * @returns {number} the gain value
+     */
+    static getInterpolatedGain(env, attenuationDb, smoothingFactor)
     {
-        case 0:
-            // delay phase, no sound is produced
-            while(currentFrameTime < env.delayEnd)
-            {
-                env.currentAttenuationDb = DB_SILENCE;
-                audioBuffer[filledBuffer] = 0;
+        // interpolate attenuation to prevent clicking
+        env.currentAttenuationDb += (attenuationDb - env.currentAttenuationDb) * smoothingFactor;
+        return decibelAttenuationToGain(env.currentAttenuationDb);
+    }
 
-                currentFrameTime += sampleTime;
-                if(++filledBuffer >= audioBuffer.length)
-                {
-                    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 centibelOffset {number} the centibel offset of volume, for modLFOtoVolume
+     * @param smoothingFactor {number} the adjusted smoothing factor for the envelope
+     */
+    static apply(voice, audioBuffer,  centibelOffset, smoothingFactor)
+    {
+        const env = voice.volumeEnvelope;
+        let decibelOffset = centibelOffset / 10;
+    
+        // 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;
+            let elapsedRelease = env.currentSampleTime - env.releaseStartTimeSamples;
+            let dbDifference = DB_SILENCE - env.releaseStartDb;
+            let db = 0;
+            for (let i = 0; i < audioBuffer.length; i++)
+            {
+                db = (elapsedRelease / env.releaseDuration) * dbDifference + env.releaseStartDb;
+                let gain = decibelAttenuationToGain(db + decibelOffset);
+                env.currentReleaseGain += (gain - env.currentReleaseGain) * releaseSmoothingFactor;
+                audioBuffer[i] *= env.currentReleaseGain;
+                env.currentSampleTime++;
+                elapsedRelease++;
             }
-            env.state++;
-        // fallthrough
-
-        case 1:
-            // attack phase: ramp from 0 to attenuation
-            while(currentFrameTime < env.attackEnd)
+    
+            if(db >= PERCEIVED_DB_SILENCE)
             {
-                // 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;
-
-                // set current attenuation to peak as its invalid during this phase
-                env.currentAttenuationDb = env.attenuation;
+                voice.finished = true;
+            }
+            return;
+        }
 
-                currentFrameTime += sampleTime;
-                if(++filledBuffer >= audioBuffer.length)
+        let filledBuffer = 0;
+        switch(env.state)
+        {
+            case 0:
+                // delay phase, no sound is produced
+                while(env.currentSampleTime < env.delayEnd)
                 {
-                    return;
+                    env.currentAttenuationDb = DB_SILENCE;
+                    audioBuffer[filledBuffer] = 0;
+    
+                    env.currentSampleTime++
+                    if(++filledBuffer >= audioBuffer.length)
+                    {
+                        return;
+                    }
                 }
-            }
-            env.state++;
-        // fallthrough
-
-        case 2:
-            // hold/peak phase: stay at attenuation
-            while(currentFrameTime < env.holdEnd)
-            {
-                const newAttenuation = 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)
+                env.state++;
+            // fallthrough
+    
+            case 1:
+                // attack phase: ramp from 0 to attenuation
+                while(env.currentSampleTime < env.attackEnd)
                 {
-                    return;
+                    // Special case: linear gain ramp instead of linear db ramp
+                    let linearAttenuation = 1 - (env.attackEnd - env.currentSampleTime) / env.attackDuration; // 0 to 1
+                    audioBuffer[filledBuffer] *= linearAttenuation * decibelAttenuationToGain(env.attenuation + decibelOffset)
+    
+                    // set current attenuation to peak as its invalid during this phase
+                    env.currentAttenuationDb = env.attenuation;
+    
+                    env.currentSampleTime++;
+                    if(++filledBuffer >= audioBuffer.length)
+                    {
+                        return;
+                    }
                 }
-            }
-            env.state++;
-        // fallthrough
-
-        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)
+                env.state++;
+            // fallthrough
+    
+            case 2:
+                // hold/peak phase: stay at attenuation
+                while(env.currentSampleTime < env.holdEnd)
                 {
-                    return;
+                    audioBuffer[filledBuffer] *= WorkletVolumeEnvelope.getInterpolatedGain(env, env.attenuation + decibelOffset, smoothingFactor);
+    
+                    env.currentSampleTime++;
+                    if(++filledBuffer >= audioBuffer.length)
+                    {
+                        return;
+                    }
                 }
-            }
-            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)
+                env.state++;
+            // fallthrough
+    
+            case 3:
+                // decay phase: linear ramp from attenuation to sustain
+                const dbDifference = env.sustainDb - env.attenuation;
+                while(env.currentSampleTime++ < env.decayEnd)
                 {
-                    return;
+                    const newAttenuation = (1 - (env.decayEnd - env.currentSampleTime) / env.decayDuration) * dbDifference + env.attenuation;
+                    audioBuffer[filledBuffer] *= WorkletVolumeEnvelope.getInterpolatedGain(env, newAttenuation + decibelOffset, smoothingFactor);
+    
+                    env.currentSampleTime++;
+                    if(++filledBuffer >= audioBuffer.length)
+                    {
+                        return;
+                    }
                 }
-            }
-
+                env.state++;
+            // fallthrough
+    
+            case 4:
+                // sustain phase: stay at sustain
+                while(true)
+                {
+                    audioBuffer[filledBuffer] *= WorkletVolumeEnvelope.getInterpolatedGain(env, env.sustainDb + decibelOffset, smoothingFactor);
+                    env.currentSampleTime++;
+                    if(++filledBuffer >= audioBuffer.length)
+                    {
+                        return;
+                    }
+                }
+    
+        }
     }
 }

package/synthetizer/worklet_system/worklet_utilities/worklet_modulator.js

@@ -1,8 +1,9 @@
 import { modulatorSources } from '../../../soundfont/read_sf2/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'
 import { generatorTypes } from '../../../soundfont/read_sf2/generators.js'
+import { WorkletVolumeEnvelope } from './volume_envelope.js'
+import { WorkletModulationEnvelope } from './modulation_envelope.js'
 
 /**
  * worklet_modulator.js
@@ -114,6 +115,9 @@ export function computeWorkletModulator(controllerTable, modulator, voice)
 export function computeModulators(voice, controllerTable, sourceUsesCC = -1, sourceIndex = 0) {
     const { modulators, generators, modulatedGenerators } = voice;
 
+    // Modulation envelope is cheap to recalculate
+    WorkletModulationEnvelope.recalculate(voice);
+
     if (sourceUsesCC === -1)
     {
         // All modulators mode: compute all modulators
@@ -121,7 +125,7 @@ export function computeModulators(voice, controllerTable, sourceUsesCC = -1, sou
         modulators.forEach(mod => {
             modulatedGenerators[mod.modulatorDestination] += computeWorkletModulator(controllerTable, mod, voice);
         });
-        recalculateVolumeEnvelope(voice);
+        WorkletVolumeEnvelope.recalculate(voice);
         return;
     }
 
@@ -165,7 +169,7 @@ export function computeModulators(voice, controllerTable, sourceUsesCC = -1, sou
     // Recalculate volume envelope if necessary
     if ([...computedDestinations].some(dest => volenvNeedsRecalculation.has(dest)))
     {
-        recalculateVolumeEnvelope(voice);
+        WorkletVolumeEnvelope.recalculate(voice);
     }
 }
 

package/synthetizer/worklet_system/worklet_utilities/worklet_voice.js

@@ -33,13 +33,11 @@
  * @property {number} pressure - the pressure of the note
  * @property {number} targetKey - target key for the note
  *
+ * @property {WorkletModulationEnvelope} modulationEnvelope
  * @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} startTime - start time of the voice absolute
+ * @property {number} releaseStartTime - start time of the release phase absolute
  *
  * @property {number} currentTuningCents - current tuning adjustment in cents
  * @property {number} currentTuningCalculated - calculated tuning adjustment
@@ -48,8 +46,9 @@
 
 import { addAndClampGenerator, generatorTypes } from '../../../soundfont/read_sf2/generators.js'
 import { SpessaSynthTable, SpessaSynthWarn } from '../../../utils/loggin.js'
-import { DEFAULT_WORKLET_VOLUME_ENVELOPE } from './volume_envelope.js'
 import { DEFAULT_WORKLET_LOWPASS_FILTER } from './lowpass_filter.js'
+import { WorkletVolumeEnvelope } from './volume_envelope.js'
+import { WorkletModulationEnvelope } from './modulation_envelope.js'
 
 
 /**
@@ -87,8 +86,9 @@ dumpSample(channel, sample, id, sampleDumpCallback)
  * Deep clone function for the WorkletVoice object and its nested structures.
  * This function handles Int16Array, objects, arrays, and primitives.
  * It does not handle circular references.
- * @param {WorkletVoice} obj - The object to clone.
- * @returns {WorkletVoice} - Cloned object.
+ * @template T
+ * @param {T} obj - The object to clone.
+ * @returns {T} - Cloned object.
  */
 function deepClone(obj) {
     if (obj === null || typeof obj !== 'object') {
@@ -116,12 +116,11 @@ function deepClone(obj) {
     return clonedObj;
 }
 
-
 /**
  * @param channel {number} a hint for the processor to recalculate sample cursors when sample dumping
  * @param midiNote {number}
  * @param velocity {number}
- * @param preset {Preset}
+ * @param preset {BasicPreset}
  * @param currentTime {number}
  * @param sampleRate {number}
  * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
@@ -246,7 +245,7 @@ export function getWorkletVoices(channel,
                 // generators and modulators
                 generators: generators,
                 modulators: sampleAndGenerators.modulators,
-                modulatedGenerators: new Int16Array(60),
+                modulatedGenerators: new Int16Array(generators),
 
                 // sample and playback data
                 sample: workletSample,
@@ -263,11 +262,10 @@ export function getWorkletVoices(channel,
                 // envelope data
                 finished: false,
                 isInRelease: false,
-                currentModEnvValue: 0,
-                releaseStartModEnv: 1,
                 currentPan: 0.5,
 
-                volumeEnvelope: deepClone(DEFAULT_WORKLET_VOLUME_ENVELOPE)
+                volumeEnvelope: new WorkletVolumeEnvelope(sampleRate),
+                modulationEnvelope: new WorkletModulationEnvelope()
             });
             return voices;
         }, []);