spessasynth_core 1.1.2 → 1.1.4

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

@@ -1,222 +0,0 @@
-import { generatorTypes } from '../../../soundfont/chunk/generators.js'
-import { absCentsToHz, 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 { applyLowpassFilter } from '../worklet_utilities/lowpass_filter.js'
-import { MIN_NOTE_LENGTH } from '../../synthesizer.js'
-
-/**
- * Renders a voice to the stereo output buffer
- * @param channel {WorkletProcessorChannel} the voice's channel
- * @param voice {WorkletVoice} the voice to render
- * @param output {Float32Array[]} the output buffer
- * @param reverbOutput {Float32Array[]} output for reverb
- * @param chorusOutput {Float32Array[]} output for chorus
- * @this {Synthesizer}
- */
-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 not in release, check if the release time is
-        if (this.currentTime >= voice.releaseStartTime) {
-            voice.releaseStartModEnv = voice.currentModEnvValue;
-            voice.isInRelease = true;
-        }
-    }
-
-
-    // if the initial attenuation is more than 100dB, skip the voice (it's silent anyway)
-    if(voice.modulatedGenerators[generatorTypes.initialAttenuation] > 2500)
-    {
-        if(voice.isInRelease)
-        {
-            voice.finished = true;
-        }
-        return;
-    }
-
-    // TUNING
-
-    // calculate tuning
-    let cents = voice.modulatedGenerators[generatorTypes.fineTune]
-        + channel.customControllers[customControllers.channelTuning]
-        + channel.customControllers[customControllers.channelTranspose]
-        + channel.customControllers[customControllers.masterTuning];
-    let semitones = voice.modulatedGenerators[generatorTypes.coarseTune];
-
-    // calculate tuning by key
-    cents += (voice.targetKey - voice.sample.rootKey) * voice.modulatedGenerators[generatorTypes.scaleTuning];
-
-    // vibrato LFO
-    const vibratoDepth = voice.modulatedGenerators[generatorTypes.vibLfoToPitch];
-    if(vibratoDepth > 0)
-    {
-        const vibStart = voice.startTime + timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayVibLFO]);
-        const vibFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqVibLFO]);
-        const lfoVal = getLFOValue(vibStart, vibFreqHz, this.currentTime);
-        if(lfoVal)
-        {
-            cents += lfoVal * (vibratoDepth * channel.customControllers[customControllers.modulationMultiplier]);
-        }
-    }
-
-    // lowpass frequency
-    let lowpassCents = voice.modulatedGenerators[generatorTypes.initialFilterFc];
-
-    // mod LFO
-    const modPitchDepth = voice.modulatedGenerators[generatorTypes.modLfoToPitch];
-    const modVolDepth = voice.modulatedGenerators[generatorTypes.modLfoToVolume];
-    const modFilterDepth = voice.modulatedGenerators[generatorTypes.modLfoToFilterFc];
-    let modLfoCentibels = 0;
-    if(modPitchDepth + modFilterDepth + modVolDepth > 0)
-    {
-        const modStart = voice.startTime + timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayModLFO]);
-        const modFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqModLFO]);
-        const modLfoValue = getLFOValue(modStart, modFreqHz, this.currentTime);
-        cents += modLfoValue * (modPitchDepth * channel.customControllers[customControllers.modulationMultiplier]);
-        modLfoCentibels = modLfoValue * modVolDepth;
-        lowpassCents += modLfoValue * modFilterDepth;
-    }
-
-    // channel vibrato (GS NRPN)
-    if(channel.channelVibrato.depth > 0)
-    {
-        const channelVibrato = getLFOValue(voice.startTime + channel.channelVibrato.delay, channel.channelVibrato.rate, this.currentTime);
-        if(channelVibrato)
-        {
-            cents += channelVibrato * channel.channelVibrato.depth;
-        }
-    }
-
-    // mod env
-    const modEnvPitchDepth = voice.modulatedGenerators[generatorTypes.modEnvToPitch];
-    const modEnvFilterDepth = voice.modulatedGenerators[generatorTypes.modEnvToFilterFc];
-    const modEnv = getModEnvValue(voice, this.currentTime);
-    lowpassCents += modEnv * modEnvFilterDepth;
-    cents += modEnv * modEnvPitchDepth;
-
-    // finally calculate the playback rate
-    const centsTotal = ~~(cents + semitones * 100);
-    if(centsTotal !== voice.currentTuningCents)
-    {
-        voice.currentTuningCents = centsTotal;
-        voice.currentTuningCalculated = Math.pow(2, centsTotal / 1200);
-    }
-
-    // PANNING
-    const pan = ( (Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan] )) + 500) / 1000) ; // 0 to 1
-
-    // SYNTHESIS
-    const bufferOut = new Float32Array(output[0].length);
-
-    // wavetable oscillator
-    getOscillatorData(voice, this.workletDumpedSamplesList[voice.sample.sampleID], bufferOut);
-
-
-    // lowpass filter
-    applyLowpassFilter(voice, bufferOut, lowpassCents, this.sampleRate);
-
-    // volenv
-    applyVolumeEnvelope(voice, bufferOut, this.currentTime, modLfoCentibels, this.sampleTime);
-
-    // 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;
-    panVoice(
-        panLeft,
-        panRight,
-        bufferOut,
-        output,
-        reverbOutput, voice.modulatedGenerators[generatorTypes.reverbEffectsSend],
-        chorusOutput, voice.modulatedGenerators[generatorTypes.chorusEffectsSend]);
-}
-
-/**
- * @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.volumeEnvelopeState;
-    if(voice.isInRelease)
-    {
-        priority -= 5;
-    }
-    priority -= voice.currentAttenuationDb / 50;
-    return priority;
-}
-
-/**
- * @this {Synthesizer}
- * @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
- * @this {Synthesizer}
- */
-export function releaseVoice(voice)
-{
-    voice.releaseStartTime = this.currentTime;
-    // check if the note is shorter than the min note time, if so, extend it
-    if(voice.releaseStartTime - voice.startTime < MIN_NOTE_LENGTH)
-    {
-        voice.releaseStartTime = voice.startTime + MIN_NOTE_LENGTH;
-    }
-}

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

@@ -1,95 +0,0 @@
-import { generatorTypes } from '../../../soundfont/chunk/generators.js'
-import { absCentsToHz, decibelAttenuationToGain } from './unit_converter.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.
- * Shoutout to them!
- */
-
-
-/**
- * Applies a low-pass filter to the given buffer
- * @param voice {WorkletVoice} the voice we're working on
- * @param outputBuffer {Float32Array} the buffer to apply the filter to
- * @param cutoffCents {number} cutoff frequency in cents
- * @param sampleRate {number} in hertz
- * @this {Synthesizer}
- */
-export function applyLowpassFilter(voice, outputBuffer, cutoffCents, sampleRate)
-{
-    if(cutoffCents > 13499)
-    {
-        return; // filter is open
-    }
-
-    // check if the frequency has changed. if so, calculate new coefficients
-    if(voice.filter.cutoffCents !== cutoffCents || voice.filter.reasonanceCb !== voice.modulatedGenerators[generatorTypes.initialFilterQ])
-    {
-        voice.filter.cutoffCents = cutoffCents;
-        voice.filter.reasonanceCb = voice.modulatedGenerators[generatorTypes.initialFilterQ];
-        calculateCoefficients(voice, sampleRate);
-    }
-
-    // filter the input
-    for (let i = 0; i < outputBuffer.length; i++) {
-        let input = outputBuffer[i];
-        let filtered = voice.filter.a0 * input
-            + voice.filter.a1 * voice.filter.x1
-            + voice.filter.a2 * voice.filter.x2
-            - voice.filter.a3 * voice.filter.y1
-            - voice.filter.a4 * voice.filter.y2;
-
-        // set buffer
-        voice.filter.x2 = voice.filter.x1;
-        voice.filter.x1 = input;
-        voice.filter.y2 = voice.filter.y1;
-        voice.filter.y1 = filtered;
-
-        outputBuffer[i] = filtered;
-    }
-}
-
-/**
- * @param voice {WorkletVoice}
- * @param sampleRate {number}
- */
-function calculateCoefficients(voice, sampleRate)
-{
-    voice.filter.cutoffHz = absCentsToHz(voice.filter.cutoffCents);
-
-    // fix cutoff on low frequencies (fluid_iir_filter.c line 392)
-    if(voice.filter.cutoffHz > 0.45 * sampleRate)
-    {
-        voice.filter.cutoffHz = 0.45 * sampleRate;
-    }
-
-    // adjust the filterQ (fluid_iir_filter.c line 204)
-    const qDb = (voice.filter.reasonanceCb / 10) - 3.01;
-    voice.filter.reasonanceGain = decibelAttenuationToGain(-1 * qDb); // -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(voice.filter.reasonanceGain);
-
-
-    // code is ported from https://github.com/sinshu/meltysynth/ to work with js. I'm too dumb to understand the math behind this...
-    let w = 2 * Math.PI * voice.filter.cutoffHz / sampleRate;
-    let cosw = Math.cos(w);
-    let alpha = Math.sin(w) / (2 * voice.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
-    voice.filter.a0 = b0 / a0;
-    voice.filter.a1 = b1 / a0;
-    voice.filter.a2 = b2 / a0;
-    voice.filter.a3 = a1 / a0;
-    voice.filter.a4 = a2 / a0;
-}

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

@@ -1,73 +0,0 @@
-import { timecentsToSeconds } from './unit_converter.js'
-import { generatorTypes } from '../../../soundfont/chunk/generators.js'
-import { getModulatorCurveValue } from './modulator_curves.js'
-import { modulatorCurveTypes } from '../../../soundfont/chunk/modulators.js'
-
-/**
- * modulation_envelope.js
- * purpose: calculates the modulation envelope for the given voice
- */
-const PEAK = 1;
-
-// 1000 should be precise enough
-const CONVEX_ATTACK = new Float32Array(1000);
-for (let i = 0; i < CONVEX_ATTACK.length; i++) {
-    // this makes the db linear ( i think
-    CONVEX_ATTACK[i] = getModulatorCurveValue(0, modulatorCurveTypes.convex, i / 1000, 0);
-}
-
-/**
- * Calculates the current modulation envelope value for the given time and voice
- * @param voice {WorkletVoice} the voice we're working on
- * @param currentTime {number} in seconds
- * @returns {number} modenv value, from 0 to 1
- */
-export function getModEnvValue(voice, currentTime)
-{
-    // calculate env times
-    let attack = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.attackModEnv]);
-    let decay = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.decayModEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvDecay]));
-    let hold = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.holdModEnv] + ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvHold]));
-
-    // calculate absolute times
-    if(voice.isInRelease && voice.releaseStartTime < currentTime)
-    {
-        let release = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.releaseModEnv]);
-        if(voice.modulatedGenerators[generatorTypes.releaseModEnv] < -7199)
-        {
-            // prevent lowpass bugs if release is instant
-            return voice.releaseStartModEnv;
-        }
-        return (1 - (currentTime - voice.releaseStartTime) / release) * voice.releaseStartModEnv;
-    }
-
-    let sustain = 1 - (voice.modulatedGenerators[generatorTypes.sustainModEnv] / 1000);
-    let delayEnd  = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayModEnv]) + voice.startTime;
-    let attackEnd = attack + delayEnd;
-    let holdEnd = hold + attackEnd;
-    let decayEnd = decay + holdEnd;
-
-    let modEnvVal
-    if(currentTime < delayEnd)
-    {
-        modEnvVal = 0; // delay
-    }
-    else if(currentTime < attackEnd)
-    {
-        modEnvVal = CONVEX_ATTACK[~~((1 - (attackEnd - currentTime) / attack) * 1000)]; // convex attack
-    }
-    else if(currentTime < holdEnd)
-    {
-        modEnvVal = PEAK; // peak
-    }
-    else if(currentTime < decayEnd)
-    {
-        modEnvVal = (1 - (decayEnd - currentTime) / decay) * (sustain - PEAK) + PEAK; // decay
-    }
-    else
-    {
-        modEnvVal = sustain; // sustain
-    }
-    voice.currentModEnvValue = modEnvVal;
-    return modEnvVal;
-}

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

@@ -1,76 +0,0 @@
-export const WORKLET_SYSTEM_REVERB_DIVIDER = 200;
-export const WORKLET_SYSTEM_CHORUS_DIVIDER = 500;
-/**
- * stereo_panner.js
- * purpose: pans a given voice out to the stereo output and to the effects' outputs
- */
-
-/**
- * Pans the voice to the given output buffers
- * @param gainLeft {number} the left channel gain
- * @param gainRight {number} the right channel gain
- * @param inputBuffer {Float32Array} the input buffer in mono
- * @param output {Float32Array[]} stereo output buffer
- * @param reverb {Float32Array[]} stereo reverb input
- * @param reverbLevel {number} 0 to 1000, the level of reverb to send
- * @param chorus {Float32Array[]} stereo chorus buttfer
- * @param chorusLevel {number} 0 to 1000, the level of chorus to send
- */
-export function panVoice(gainLeft,
-                         gainRight,
-                         inputBuffer,
-                         output,
-                         reverb,
-                         reverbLevel,
-                         chorus,
-                         chorusLevel)
-{
-    if(isNaN(inputBuffer[0]))
-    {
-        return;
-    }
-
-    if(reverbLevel > 0 && reverb !== undefined)
-    {
-        const reverbLeft = reverb[0];
-        const reverbRight = reverb[1];
-        // cap reverb
-        reverbLevel = Math.min(reverbLevel, 1000);
-        const reverbGain = reverbLevel / WORKLET_SYSTEM_REVERB_DIVIDER;
-        const reverbLeftGain = gainLeft * reverbGain;
-        const reverbRightGain = gainRight * reverbGain;
-        for (let i = 0; i < inputBuffer.length; i++) {
-            reverbLeft[i] += reverbLeftGain * inputBuffer[i];
-            reverbRight[i] += reverbRightGain * inputBuffer[i];
-        }
-    }
-
-    if(chorusLevel > 0 && chorus !== undefined)
-    {
-        const chorusLeft = chorus[0];
-        const chorusRight = chorus[1];
-        // cap chorus
-        chorusLevel = Math.min(chorusLevel, 1000);
-        const chorusGain = chorusLevel / WORKLET_SYSTEM_CHORUS_DIVIDER;
-        const chorusLeftGain = gainLeft * chorusGain;
-        const chorusRightGain = gainRight * chorusGain;
-        for (let i = 0; i < inputBuffer.length; i++) {
-            chorusLeft[i] += chorusLeftGain * inputBuffer[i];
-            chorusRight[i] += chorusRightGain * inputBuffer[i];
-        }
-    }
-
-    const leftChannel = output[0];
-    const rightChannel = output[1];
-    if(gainLeft > 0)
-    {
-        for (let i = 0; i < inputBuffer.length; i++) {
-            leftChannel[i] += gainLeft * inputBuffer[i];
-        }
-    }
-    if(gainRight > 0) {
-        for (let i = 0; i < inputBuffer.length; i++) {
-            rightChannel[i] += gainRight * inputBuffer[i];
-        }
-    }
-}

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

@@ -1,194 +0,0 @@
-import { decibelAttenuationToGain, timecentsToSeconds } from './unit_converter.js'
-import { generatorTypes } from '../../../soundfont/chunk/generators.js'
-
-/**
- * volume_envelope.js
- * purpose: applies a volume envelope for a given voice
- */
-
-const DB_SILENCE = 100;
-const GAIN_SILENCE = 0.005;
-
-/**
- * VOL ENV STATES:
- * 0 - delay
- * 1 - attack
- * 2 - hold/peak
- * 3 - decay
- * 4 - sustain
- * release is indicated by isInRelease property
- */
-
-/**
- * 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
- */
-
-export function applyVolumeEnvelope(voice, audioBuffer, currentTime, centibelOffset, sampleTime)
-{
-    // calculate values
-    let decibelOffset = centibelOffset / 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 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;
-
-    // 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)
-        {
-            case 0:
-                // no sound: fill with zero and skip!
-                for (let i = 0; i < audioBuffer.length; i++) {
-                    audioBuffer[i] = 0;
-                }
-                return;
-
-            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);
-                // calculate the gain that the attack would have
-                let attackGain = elapsed * decibelAttenuationToGain(attenuation + decibelOffset);
-
-                // turn that into db
-                releaseStartDb = 20 * Math.log10(attackGain) * -1;
-                break;
-
-            case 2:
-                // hold
-                releaseStartDb = attenuation;
-                break;
-
-            case 3:
-                // decay
-                releaseStartDb = (1 - (decayEnd - voice.releaseStartTime) / decay) * (sustain - attenuation) + attenuation;
-                break;
-
-            case 4:
-                // sustain
-                releaseStartDb = sustain;
-                break;
-
-        }
-
-        // 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;
-        // }
-
-        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;
-            gain = decibelAttenuationToGain(db + decibelOffset);
-            audioBuffer[i] = gain * audioBuffer[i];
-            elapsedRelease += sampleTime;
-        }
-
-        if(gain <= GAIN_SILENCE)
-        {
-            voice.finished = true;
-        }
-        return;
-    }
-    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)
-                {
-                    voice.volumeEnvelopeState++;
-                }
-                else
-                {
-                    dbAttenuation = DB_SILENCE;
-                    audioBuffer[i] = 0;
-
-                    // no need to go through the hassle of converting. Skip
-                    currentFrameTime += sampleTime;
-                    continue;
-                }
-            // fallthrough
-
-            case 1:
-                // attack phase: ramp from 0 to attenuation
-                if(currentFrameTime >= attackEnd)
-                {
-                    voice.volumeEnvelopeState++;
-                }
-                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
-
-                }
-            // fallthrough
-
-            case 2:
-                // hold/peak phase: stay at attenuation
-                if(currentFrameTime >= holdEnd)
-                {
-                    voice.volumeEnvelopeState++;
-                }
-                else
-                {
-                    dbAttenuation = attenuation;
-                    break;
-                }
-            // fallthrough
-
-            case 3:
-                // decay phase: linear ramp from attenuation to sustain
-                if(currentFrameTime >= decayEnd)
-                {
-                    voice.volumeEnvelopeState++;
-                }
-                else
-                {
-                    dbAttenuation = (1 - (decayEnd - currentFrameTime) / decay) * (sustain - attenuation) + attenuation;
-                    break
-                }
-            // 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;
-}