spessasynth_lib 3.9.9

package/synthetizer/worklet_system/worklet_methods/voice_control.js

@@ -0,0 +1,233 @@
+import { generatorTypes } from '../../../soundfont/read/generators.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, recalculateVolumeEnvelope } from '../worklet_utilities/volume_envelope.js'
+import { applyLowpassFilter } from '../worklet_utilities/lowpass_filter.js'
+import { MIN_NOTE_LENGTH } from '../main_processor.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
+ * @param voice {WorkletVoice} the voice to render
+ * @param outputLeft {Float32Array} the left output buffer
+ * @param outputRight {Float32Array} the right output buffer
+ * @param reverbOutput {Float32Array[]} output for reverb
+ * @param chorusOutput {Float32Array[]} output for chorus
+ * @this {SpessaSynthProcessor}
+ */
+export function renderVoice(
+    channel,
+    voice,
+    outputLeft, outputRight,
+    reverbOutput,
+    chorusOutput
+)
+{
+    // check if release
+    if(!voice.isInRelease)
+    {
+        // if not in release, check if the release time is
+        if (currentTime >= voice.releaseStartTime)
+        {
+            voice.releaseStartModEnv = voice.currentModEnvValue;
+            voice.isInRelease = true;
+            recalculateVolumeEnvelope(voice);
+            voice.volumeEnvelope.currentReleaseGain = decibelAttenuationToGain(voice.volumeEnvelope.currentAttenuationDb);
+        }
+    }
+
+
+    // if the initial attenuation is more than 100dB, skip the voice (it's silent anyways)
+    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.channelTransposeFine]
+        + channel.customControllers[customControllers.masterTuning];
+    let semitones = voice.modulatedGenerators[generatorTypes.coarseTune]
+        + channel.customControllers[customControllers.channelTuningSemitones];
+
+    // 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, 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, 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, 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, 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(outputLeft.length);
+
+    // wavetable oscillator
+    getOscillatorData(voice, this.workletDumpedSamplesList[voice.sample.sampleID], bufferOut);
+
+    // lowpass filter
+    applyLowpassFilter(voice, bufferOut, lowpassCents);
+
+    // volenv
+    applyVolumeEnvelope(voice, bufferOut, currentTime, modLfoCentibels, this.sampleTime, this.volumeEnvelopeSmoothingFactor);
+
+    // pan the voice and write out
+    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;
+    const reverb = this.oneOutputMode ? 0 : voice.modulatedGenerators[generatorTypes.reverbEffectsSend];
+    const chorus = this.oneOutputMode ? 0 : voice.modulatedGenerators[generatorTypes.chorusEffectsSend];
+    panVoice(
+        panLeft,
+        panRight,
+        bufferOut,
+        outputLeft, outputRight,
+        reverbOutput, reverb,
+        chorusOutput, chorus);
+}
+
+
+/**
+ * @param channel {WorkletProcessorChannel}
+ * @param voice {WorkletVoice}
+ * @return {number}
+ */
+function getPriority(channel, voice)
+{
+    let priority = 0;
+    if(channel.drumChannel)
+    {
+        // important
+        priority += 5;
+    }
+    if(voice.isInRelease)
+    {
+        // not important
+        priority -= 5;
+    }
+    // less velocity = less important
+    priority += voice.velocity / 25; // map to 0-5
+    // the newer, more important
+    priority -= voice.volumeEnvelope.state;
+    if(voice.isInRelease)
+    {
+        priority -= 5;
+    }
+    priority -= voice.volumeEnvelope.currentAttenuationDb / 50;
+    return priority;
+}
+
+/**
+ * @this {SpessaSynthProcessor}
+ * @param amount {number}
+ */
+export function voiceKilling(amount)
+{
+    let allVoices = [];
+    for (const channel of this.workletProcessorChannels)
+    {
+        for (const voice of channel.voices)
+        {
+            if (!voice.finished)
+            {
+                const priority = getPriority(channel, voice);
+                allVoices.push({ channel, voice, priority });
+            }
+        }
+    }
+
+    // Step 2: Sort voices by priority (ascending order)
+    allVoices.sort((a, b) => a.priority - b.priority);
+    const voicesToRemove = allVoices.slice(0, amount);
+
+    for (const { channel, voice } of voicesToRemove)
+    {
+        const index = channel.voices.indexOf(voice);
+        if (index > -1)
+        {
+            channel.voices.splice(index, 1);
+        }
+    }
+}
+
+/**
+ * Stops the voice
+ * @param voice {WorkletVoice} the voice to stop
+ * @this {SpessaSynthProcessor}
+ */
+export function releaseVoice(voice)
+{
+    voice.releaseStartTime = 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/synthetizer/worklet_system/worklet_processor.js

@@ -0,0 +1,9 @@
+import { WORKLET_PROCESSOR_NAME } from '../synthetizer.js'
+import { consoleColors } from '../../utils/other.js'
+import { SpessaSynthProcessor } from './main_processor.js'
+import { SpessaSynthInfo } from '../../utils/loggin.js'
+
+
+// noinspection JSUnresolvedReference
+registerProcessor(WORKLET_PROCESSOR_NAME, SpessaSynthProcessor);
+SpessaSynthInfo("%cProcessor succesfully registered!", consoleColors.recognized);

package/synthetizer/worklet_system/worklet_utilities/lfo.js

@@ -0,0 +1,23 @@
+/**
+ * lfo.js
+ * purpose: low frequency triangel oscillator
+ */
+
+/**
+ * Calculates a triangular wave value for the given time
+ * @param startTime {number} seconds
+ * @param frequency {number} Hz
+ * @param currentTime {number} seconds
+ * @return {number} the value from -1 to 1
+ */
+export function getLFOValue(startTime, frequency, currentTime) {
+    if (currentTime < startTime) {
+        return 0;
+    }
+
+    const xVal = (currentTime - startTime) / (1 / frequency) - 0.25;
+    // offset by -0.25, otherwise we start at -1 and can have unexpected jump in pitch or lowpass (happened with Synth Strings 2)
+
+    // triangle, not sine
+    return Math.abs(xVal - (~~(xVal + 0.5))) * 4 - 1;
+}

package/synthetizer/worklet_system/worklet_utilities/lowpass_filter.js

@@ -0,0 +1,130 @@
+import { generatorTypes } from '../../../soundfont/read/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!
+ */
+
+
+/**
+ * @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
+ * @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
+ */
+export function applyLowpassFilter(voice, outputBuffer, cutoffCents)
+{
+    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);
+    }
+
+    // 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}
+ */
+function calculateCoefficients(voice)
+{
+    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; // we're in the audioworkletglobalscope so we can use 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/synthetizer/worklet_system/worklet_utilities/modulation_envelope.js

@@ -0,0 +1,73 @@
+import { timecentsToSeconds } from './unit_converter.js'
+import { generatorTypes } from '../../../soundfont/read/generators.js'
+import { getModulatorCurveValue } from './modulator_curves.js'
+import { modulatorCurveTypes } from '../../../soundfont/read/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/synthetizer/worklet_system/worklet_utilities/modulator_curves.js

@@ -0,0 +1,86 @@
+import { modulatorCurveTypes } from '../../../soundfont/read/modulators.js'
+
+/**
+ * modulator_curves.js
+ * precomputes modulator concave and conves curves and calculates a curve value for a given polarity, direction and type
+ */
+
+// the length of the precomputed curve tables
+export const MOD_PRECOMPUTED_LENGTH = 16384;
+
+// Precalculate lookup tables for concave and convers
+const concave = new Float32Array(MOD_PRECOMPUTED_LENGTH);
+const convex = new Float32Array(MOD_PRECOMPUTED_LENGTH);
+// the equation is taken from FluidSynth as it's the standard for soundFonts
+// more precisely, this:
+// https://github.com/FluidSynth/fluidsynth/blob/cb8da1e1e2c0a5cff2bab6a419755b598b793384/src/gentables/gen_conv.c#L55
+concave[0] = 0;
+concave[MOD_PRECOMPUTED_LENGTH - 1] = 1;
+
+convex[0] = 0;
+convex[MOD_PRECOMPUTED_LENGTH - 1] = 1;
+for(let i = 1; i < MOD_PRECOMPUTED_LENGTH - 1; i++)
+{
+    let x = (-200 * 2 / 960) * Math.log(i / (MOD_PRECOMPUTED_LENGTH - 1)) / Math.LN10;
+    convex[i] = 1 - x;
+    concave[MOD_PRECOMPUTED_LENGTH - 1 - i] = x;
+}
+
+/**
+ * Transforms a value with a given curve type
+ * @param polarity {number} 0 or 1
+ * @param direction {number} 0 or 1
+ * @param curveType {number} see modulatorCurveTypes in modulators.js
+ * @param value {number} the linear value, 0 to 1
+ * @returns {number} the transformed value, 0 to 1 or -1 to 1
+ */
+export function getModulatorCurveValue(direction, curveType, value, polarity) {
+    // inverse the value if needed
+    if(direction)
+    {
+        value = 1 - value
+    }
+    switch (curveType) {
+        case modulatorCurveTypes.linear:
+            if (polarity) {
+                // bipolar
+                return value * 2 - 1;
+            }
+            return value;
+
+        case modulatorCurveTypes.switch:
+            // switch
+            value = value > 0.5 ? 1 : 0;
+            if (polarity) {
+                // multiply
+                return value * 2 - 1;
+            }
+            return value;
+
+        case modulatorCurveTypes.concave:
+            // look up the value
+            if(polarity)
+            {
+                value = value * 2 - 1;
+                if(value < 0)
+                {
+                    return 1 - concave[~~(value * -MOD_PRECOMPUTED_LENGTH)] - 1;
+                }
+                return concave[~~value * MOD_PRECOMPUTED_LENGTH];
+            }
+            return concave[~~(value * MOD_PRECOMPUTED_LENGTH)]
+
+        case modulatorCurveTypes.convex:
+            // look up the value
+            if(polarity)
+            {
+                value = value * 2 - 1;
+                if(value < 0)
+                {
+                    return 1 - convex[~~(value * -MOD_PRECOMPUTED_LENGTH)] - 1;
+                }
+                return convex[~~(value * MOD_PRECOMPUTED_LENGTH)];
+            }
+            return convex[~~(value * MOD_PRECOMPUTED_LENGTH)];
+    }
+}

package/synthetizer/worklet_system/worklet_utilities/stereo_panner.js

@@ -0,0 +1,81 @@
+export const WORKLET_SYSTEM_REVERB_DIVIDER = 500;
+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 outputLeft {Float32Array} left output buffer
+ * @param outputRight {Float32Array} right 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,
+                         outputLeft, outputRight,
+                         reverb,
+                         reverbLevel,
+                         chorus,
+                         chorusLevel)
+{
+    if(isNaN(inputBuffer[0]))
+    {
+        return;
+    }
+
+    if(reverbLevel > 0)
+    {
+        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)
+    {
+        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];
+        }
+    }
+
+    // mix out the audio data
+    if(gainLeft > 0)
+    {
+        for (let i = 0; i < inputBuffer.length; i++)
+        {
+            outputLeft[i] += gainLeft * inputBuffer[i];
+        }
+    }
+    if(gainRight > 0)
+    {
+        for (let i = 0; i < inputBuffer.length; i++)
+        {
+            outputRight[i] += gainRight * inputBuffer[i];
+        }
+    }
+}