spessasynth_core 1.1.2 → 1.1.4

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

@@ -1,83 +0,0 @@
-/**
- * wavetable_oscillator.js
- * purpose: plays back raw audio data at an arbitrary playback rate
- */
-
-
-/**
- * Fills the output buffer with raw sample data
- * @param voice {WorkletVoice} the voice we're working on
- * @param sampleData {Float32Array} the sample data to write with
- * @param outputBuffer {Float32Array} the output buffer to write to
- */
-export function getOscillatorData(voice, sampleData, outputBuffer)
-{
-    let cur = voice.sample.cursor;
-    const loop = (voice.sample.loopingMode === 1) || (voice.sample.loopingMode === 3 && !voice.isInRelease);
-    const loopLength = voice.sample.loopEnd - voice.sample.loopStart;
-
-    if(loop)
-    {
-        for (let i = 0; i < outputBuffer.length; i++) {
-            // check for loop
-            while(cur >= voice.sample.loopEnd) {
-                cur -= loopLength;
-            }
-
-            // grab the 2 nearest points
-            const floor = ~~cur;
-            let ceil = floor + 1;
-
-            while(ceil >= voice.sample.loopEnd) {
-                ceil -= loopLength;
-            }
-
-            const fraction = cur - floor;
-
-            // grab the samples and interpolate
-            const upper = sampleData[ceil];
-            const lower = sampleData[floor];
-            outputBuffer[i] = (lower + (upper - lower) * fraction);
-
-            // commented code because it's probably gonna come handy... (it did like 6 times already :/)
-            // if(isNaN(outputBuffer[i]))
-            // {
-            //     console.error(voice, upper, lower, floor, ceil, cur)
-            //     throw "NAN ALERT";
-            // }
-
-            cur += voice.sample.playbackStep * voice.currentTuningCalculated;
-        }
-    }
-    else
-    {
-        // check and correct end errors
-        if(voice.sample.end >= sampleData.length)
-        {
-            voice.sample.end = sampleData.length - 1;
-        }
-        for (let i = 0; i < outputBuffer.length; i++) {
-
-            // linear interpolation
-            const floor = ~~cur;
-            const ceil = floor + 1;
-
-            // flag the voice as finished if needed
-            if(ceil >= voice.sample.end)
-            {
-                voice.finished = true;
-                return;
-            }
-
-            const fraction = cur - floor;
-
-            // grab the samples and interpolate
-            const upper = sampleData[ceil];
-            const lower = sampleData[floor];
-            outputBuffer[i] = (lower + (upper - lower) * fraction);
-
-            cur += voice.sample.playbackStep * voice.currentTuningCalculated;
-        }
-    }
-    voice.sample.cursor = cur;
-}

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

@@ -1,173 +0,0 @@
-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'
-
-/**
- * worklet_modulator.js
- * purpose: precomputes all curve types and computes modulators
- */
-
-/**
- * Computes a given modulator
- * @param controllerTable {Int16Array} all midi controllers as 14bit values + the non controller indexes, starting at 128
- * @param modulator {Modulator} the modulator to compute
- * @param midiNote {number} the midiNote of the voice belonging to the modulator
- * @param velocity {number} the velocity of the voice belonging to the modulator
- * @returns {number} the computed value
- */
-export function computeWorkletModulator(controllerTable, modulator, midiNote, velocity)
-{
-    if(modulator.transformAmount === 0)
-    {
-        return 0;
-    }
-    // mapped to 0-16384
-    let rawSourceValue = 0;
-    if(modulator.sourceUsesCC)
-    {
-        rawSourceValue = controllerTable[modulator.sourceIndex];
-    }
-    else
-    {
-        const index = modulator.sourceIndex + NON_CC_INDEX_OFFSET;
-        switch (modulator.sourceIndex)
-        {
-            case modulatorSources.noController:
-                return 0;// fluid_mod.c line 374 (0 times secondary times amount is still zero)
-
-            case modulatorSources.noteOnKeyNum:
-                rawSourceValue = midiNote << 7;
-                break;
-
-            case modulatorSources.noteOnVelocity:
-            case modulatorSources.polyPressure:
-                rawSourceValue = velocity << 7;
-                break;
-
-            default:
-                rawSourceValue = controllerTable[index]; // use the 7 bit value
-                break;
-        }
-
-    }
-
-    const sourceValue = transforms[modulator.sourceCurveType][modulator.sourcePolarity][modulator.sourceDirection][rawSourceValue];
-
-    // mapped to 0-127
-    let rawSecondSrcValue;
-    if(modulator.secSrcUsesCC)
-    {
-        rawSecondSrcValue = controllerTable[modulator.secSrcIndex];
-    }
-    else
-    {
-        const index = modulator.secSrcIndex + NON_CC_INDEX_OFFSET;
-        switch (modulator.secSrcIndex)
-        {
-            case modulatorSources.noController:
-                rawSecondSrcValue = 16383;// fluid_mod.c line 376
-                break;
-
-            case modulatorSources.noteOnKeyNum:
-                rawSecondSrcValue = midiNote << 7;
-                break;
-
-            case modulatorSources.noteOnVelocity:
-            case modulatorSources.polyPressure:
-                rawSecondSrcValue = velocity << 7;
-                break;
-
-            default:
-                rawSecondSrcValue = controllerTable[index];
-        }
-
-    }
-    const secondSrcValue = transforms[modulator.secSrcCurveType][modulator.secSrcPolarity][modulator.secSrcDirection][rawSecondSrcValue];
-
-
-    // compute the modulator
-    const computedValue = sourceValue * secondSrcValue * modulator.transformAmount;
-
-    if(modulator.transformType === 2)
-    {
-        // abs value
-        return Math.abs(computedValue);
-    }
-    return computedValue;
-}
-
-/**
- * Computes all modulators of a given voice
- * @param voice {WorkletVoice} the voice to compute modulators for
- * @param controllerTable {Int16Array} all midi controllers as 14bit values + the non controller indexes, starting at 128
- */
-export function computeModulators(voice, controllerTable)
-{
-    voice.modulatedGenerators.set(voice.generators);
-    voice.modulators.forEach(mod => {
-        voice.modulatedGenerators[mod.modulatorDestination] += computeWorkletModulator(controllerTable, mod, voice.midiNote, voice.velocity);
-    });
-}
-
-/**
- * as follows: transforms[curveType][polarity][direction] is an array
- * @type {Float32Array[][][]}
- */
-const transforms = [];
-
-for(let curve = 0; curve < 4; curve++)
-{
-    transforms[curve] =
-    [
-        [
-            new Float32Array(MOD_PRECOMPUTED_LENGTH),
-            new Float32Array(MOD_PRECOMPUTED_LENGTH)
-        ],
-        [
-            new Float32Array(MOD_PRECOMPUTED_LENGTH),
-            new Float32Array(MOD_PRECOMPUTED_LENGTH)
-        ]
-    ];
-    for (let i = 0; i < MOD_PRECOMPUTED_LENGTH; i++) {
-
-        // polarity 0 dir 0
-        transforms[curve][0][0][i] = getModulatorCurveValue(
-            0,
-            curve,
-            i / MOD_PRECOMPUTED_LENGTH,
-            0);
-        if (isNaN(transforms[curve][0][0][i])) {
-            transforms[curve][0][0][i] = 1;
-        }
-
-        // polarity 1 dir 0
-        transforms[curve][1][0][i] = getModulatorCurveValue(
-            0,
-            curve,
-            i / MOD_PRECOMPUTED_LENGTH,
-            1);
-        if (isNaN(transforms[curve][1][0][i])) {
-            transforms[curve][1][0][i] = 1;
-        }
-
-        // polarity 0 dir 1
-        transforms[curve][0][1][i] = getModulatorCurveValue(
-            1,
-            curve,
-            i / MOD_PRECOMPUTED_LENGTH,
-            0);
-        if (isNaN(transforms[curve][0][1][i])) {
-            transforms[curve][0][1][i] = 1;
-        }
-
-        // polarity 1 dir 1
-        transforms[curve][1][1][i] = getModulatorCurveValue(
-            1,
-            curve,
-            i / MOD_PRECOMPUTED_LENGTH,
-            1);
-        if (isNaN(transforms[curve][1][1][i])) {
-            transforms[curve][1][1][i] = 1;
-        }
-    }
-}

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

@@ -1,106 +0,0 @@
-import { midiControllers } from '../../../midi_parser/midi_message.js'
-import { modulatorSources } from '../../../soundfont/chunk/modulators.js'
-/**
- * @typedef {Object} WorkletProcessorChannel
- * @property {Int16Array} midiControllers - array of MIDI controller values
- * @property {boolean[]} lockedControllers - array indicating if a controller is locked
- * @property {Float32Array} customControllers - array of custom (not sf2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
- * @property {boolean} holdPedal - indicates whether the hold pedal is active
- * @property {boolean} drumChannel - indicates whether the channel is a drum channel
- * @property {dataEntryStates} dataEntryState - the current state of the data entry
- * @property {number} NRPCoarse - the current coarse value of the Non-Registered Parameter
- * @property {number} NRPFine - the current fine value of the Non-Registered Parameter
- * @property {number} RPValue - the current value of the Registered Parameter
- *
- * @property {Preset} preset - the channel's preset
- * @property {boolean} lockPreset - indicates whether the program on the channel is locked
- *
- * @property {boolean} lockVibrato - indicates whether the custom vibrato is locked
- * @property {Object} channelVibrato - vibrato settings for the channel
- * @property {number} channelVibrato.depth - depth of the vibrato effect (cents)
- * @property {number} channelVibrato.delay - delay before the vibrato effect starts (seconds)
- * @property {number} channelVibrato.rate - rate of the vibrato oscillation (Hz)
-
- * @property {boolean} isMuted - indicates whether the channel is muted
- * @property {WorkletVoice[]} voices - array of voices currently active on the channel
- * @property {WorkletVoice[]} sustainedVoices - array of voices that are sustained on the channel
- * @property {WorkletVoice[][][]} cachedVoices - first is midi note, second is velocity. output is an array of WorkletVoices
- */
-
-/**
- * Adds a new channel
- * @this {Synthesizer}
- */
-export function addNewChannel()
-{
-    /**
-     * @type {WorkletProcessorChannel}
-     */
-    const channel = {
-        midiControllers: new Int16Array(CONTROLLER_TABLE_SIZE),
-        lockedControllers: Array(CONTROLLER_TABLE_SIZE).fill(false),
-        customControllers: new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE),
-
-        NRPCoarse: 0,
-        NRPFine: 0,
-        RPValue: 0,
-        dataEntryState: dataEntryStates.Idle,
-
-        voices: [],
-        sustainedVoices: [],
-        cachedVoices: [],
-        preset: this.defaultPreset,
-
-        channelVibrato: {delay: 0, depth: 0, rate: 0},
-        lockVibrato: false,
-        holdPedal: false,
-        isMuted: false,
-        drumChannel: false,
-        lockPreset: false,
-
-    }
-    for (let i = 0; i < 128; i++) {
-        channel.cachedVoices.push([]);
-    }
-    this.workletProcessorChannels.push(channel);
-    this.resetControllers(this.workletProcessorChannels.length - 1);
-}
-
-export const NON_CC_INDEX_OFFSET = 128;
-export const CONTROLLER_TABLE_SIZE = 147;
-// an array with preset default values so we can quickly use set() to reset the controllers
-export const resetArray = new Int16Array(CONTROLLER_TABLE_SIZE);
-// default values (the array is 14 bit so shift the 7 bit values by 7 bits)
-resetArray[midiControllers.mainVolume] = 100 << 7;
-resetArray[midiControllers.expressionController] = 127 << 7;
-resetArray[midiControllers.pan] = 64 << 7;
-resetArray[midiControllers.releaseTime] = 64 << 7;
-resetArray[midiControllers.brightness] = 64 << 7;
-resetArray[midiControllers.effects1Depth] = 40 << 7;
-resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] = 8192;
-resetArray[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = 2 << 7;
-resetArray[NON_CC_INDEX_OFFSET + modulatorSources.channelPressure] = 127 << 7;
-
-/**
- * @enum {number}
- */
-export const dataEntryStates = {
-    Idle: 0,
-    RPCoarse: 1,
-    RPFine: 2,
-    NRPCoarse: 3,
-    NRPFine: 4,
-    DataCoarse: 5,
-    DataFine: 6
-};
-
-
-export const customControllers = {
-    channelTuning: 0, // cents
-    channelTranspose: 1, // cents
-    modulationMultiplier: 2, // cents
-    masterTuning: 3, // cents
-}
-export const CUSTOM_CONTROLLER_TABLE_SIZE = Object.keys(customControllers).length;
-export const customResetArray = new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE);
-customResetArray[customControllers.modulationMultiplier] = 1;

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

@@ -1,313 +0,0 @@
-/**
- * worklet_voice.js
- * purpose: prepares workletvoices from sample and generator data and manages sample dumping
- * note: sample dumping means sending it over to the AudioWorkletGlobalScope
- */
-
-/**
- * @typedef {Object} WorkletSample
- * @property {number} sampleID - ID of the sample
- * @property {number} playbackStep - current playback step (rate)
- * @property {number} cursor - current position in the sample
- * @property {number} rootKey - root key of the sample
- * @property {number} loopStart - start position of the loop
- * @property {number} loopEnd - end position of the loop
- * @property {number} end - end position of the sample
- * @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.
- * @property {WorkletLowpassFilter} filter - lowpass filter applied to the voice
- * @property {Int16Array} generators - the unmodulated (constant) generators of the voice
- * @property {Modulator[]} modulators - the voice's modulators
- * @property {Int16Array} modulatedGenerators - the generators modulated by the modulators
- *
- * @property {boolean} finished - indicates if the voice has finished
- * @property {boolean} isInRelease - indicates if the voice is in the release phase
- *
- * @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 {number} currentModEnvValue - current value of the modulation envelope
- *
- * @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
- * @property {number} currentPan - from 0 to 1
- */
-
-import { addAndClampGenerator, generatorTypes } from '../../../soundfont/chunk/generators.js'
-import { SpessaSynthTable } from '../../../utils/loggin.js'
-
-
-/**
- * the sampleID is the index
- * @type {boolean[]}
- */
-let globalDumpedSamplesList = [];
-
-export function clearSamplesList()
-{
-    globalDumpedSamplesList = [];
-}
-
-function /**
- * This is how the logic works: since sf3 is compressed, we rely on an async decoder.
- * So, if the sample isn't loaded yet:
- * send the workletVoice (generators, modulators, etc) and the WorkletSample(sampleID + end offset + loop)
- * once the voice is done, then we dump it.
- *
- * on the WorkletScope side:
- * skip the voice if sampleID isn't valid
- * once we receive a sample dump, adjust all voice endOffsets (loop is already correct in sf3)
- * now the voice starts playing, yay!
- * @param channel {number} channel hint for the processor to recalculate cursor positions
- * @param sample {Sample}
- * @param id {number}
- * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
- */
-dumpSample(channel, sample, id, sampleDumpCallback)
-{
-    // flag as defined, so it's currently being dumped
-    globalDumpedSamplesList[id] = false;
-
-    // load the data
-    sampleDumpCallback({
-        channel: channel,
-        sampleID: id,
-        sampleData: sample.getAudioData()
-    });
-    globalDumpedSamplesList[id] = true;
-}
-
-/**
- * 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.
- */
-function deepClone(obj) {
-    if (obj === null || typeof obj !== 'object') {
-        return obj;
-    }
-
-    // Handle Int16Array separately
-    if (obj instanceof Int16Array) {
-        return new Int16Array(obj);
-    }
-
-    // Handle objects and arrays
-    const clonedObj = Array.isArray(obj) ? [] : {};
-    for (let key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            if (typeof obj[key] === 'object' && obj[key] !== null) {
-                clonedObj[key] = deepClone(obj[key]); // Recursively clone nested objects
-            } else if (obj[key] instanceof Int16Array) {
-                clonedObj[key] = new Int16Array(obj[key]); // Clone Int16Array
-            } else {
-                clonedObj[key] = obj[key]; // Copy primitives
-            }
-        }
-    }
-    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 currentTime {number}
- * @param sampleRate {number}
- * @param sampleDumpCallback {function({channel: number, sampleID: number, sampleData: Float32Array})}
- * @param cachedVoices {WorkletVoice[][][]} first is midi note, second is velocity. output is an array of WorkletVoices
- * @param debug {boolean}
- * @returns {WorkletVoice[]}
- */
-export function getWorkletVoices(channel,
-                                 midiNote,
-                                 velocity,
-                                 preset,
-                                 currentTime,
-                                 sampleRate,
-                                 sampleDumpCallback,
-                                 cachedVoices,
-                                 debug=false)
-{
-    /**
-     * @type {WorkletVoice[]}
-     */
-    let workletVoices;
-
-    const cached = cachedVoices[midiNote][velocity];
-    if(cached)
-    {
-        workletVoices = cached.map(deepClone);
-        workletVoices.forEach(v => {
-            v.startTime = currentTime;
-        });
-    }
-    else
-    {
-        let canCache = true;
-        /**
-         * @returns {WorkletVoice}
-         */
-        workletVoices = preset.getSamplesAndGenerators(midiNote, velocity).map(sampleAndGenerators => {
-            // dump the sample if haven't already
-            if (globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true) {
-                // if the sample is currently being loaded, don't dump again (undefined means not loaded, false means is being loaded)
-                if(globalDumpedSamplesList[sampleAndGenerators.sampleID] === undefined) {
-                    dumpSample(channel, sampleAndGenerators.sample, sampleAndGenerators.sampleID, sampleDumpCallback);
-                }
-
-                // can't cache the voice as the end in workletSample maybe is incorrect (the sample is still loading)
-                if(globalDumpedSamplesList[sampleAndGenerators.sampleID] !== true)
-                {
-                    canCache = false;
-                }
-            }
-
-            // create the generator list
-            const generators = new Int16Array(60);
-            // apply and sum the gens
-            for (let i = 0; i < 60; i++) {
-                generators[i] = addAndClampGenerator(i, sampleAndGenerators.presetGenerators, sampleAndGenerators.instrumentGenerators);
-            }
-
-            // !! EMU initial attenuation correction, multiply initial attenuation by 0.4
-            generators[generatorTypes.initialAttenuation] = Math.floor(generators[generatorTypes.initialAttenuation] * 0.4);
-
-            // key override
-            let rootKey = sampleAndGenerators.sample.samplePitch;
-            if (generators[generatorTypes.overridingRootKey] > -1) {
-                rootKey = generators[generatorTypes.overridingRootKey];
-            }
-
-            let targetKey = midiNote;
-            if (generators[generatorTypes.keyNum] > -1) {
-                targetKey = generators[generatorTypes.keyNum];
-            }
-
-            // determine looping mode now. if the loop is too small, disable
-            const loopStart = (sampleAndGenerators.sample.sampleLoopStartIndex / 2) + (generators[generatorTypes.startloopAddrsOffset] + (generators[generatorTypes.startloopAddrsCoarseOffset] * 32768));
-            const loopEnd = (sampleAndGenerators.sample.sampleLoopEndIndex / 2) + (generators[generatorTypes.endloopAddrsOffset] + (generators[generatorTypes.endloopAddrsCoarseOffset] * 32768));
-            let loopingMode = generators[generatorTypes.sampleModes];
-            if (loopEnd - loopStart < 1) {
-                loopingMode = 0;
-            }
-
-            // determine end
-            /**
-             * create the worklet sample
-             * @type {WorkletSample}
-             */
-            const workletSample = {
-                sampleID: sampleAndGenerators.sampleID,
-                playbackStep: (sampleAndGenerators.sample.sampleRate / sampleRate) * Math.pow(2, sampleAndGenerators.sample.samplePitchCorrection / 1200),// cent tuning
-                cursor: generators[generatorTypes.startAddrsOffset] + (generators[generatorTypes.startAddrsCoarseOffset] * 32768),
-                rootKey: rootKey,
-                loopStart: loopStart,
-                loopEnd: loopEnd,
-                end: Math.floor( sampleAndGenerators.sample.sampleData.length) - 1 + (generators[generatorTypes.endAddrOffset] + (generators[generatorTypes.endAddrsCoarseOffset] * 32768)),
-                loopingMode: loopingMode
-            };
-
-            // velocity override
-            if (generators[generatorTypes.velocity] > -1) {
-                velocity = generators[generatorTypes.velocity];
-            }
-
-            if(debug)
-            {
-                SpessaSynthTable([{
-                    Sample: sampleAndGenerators.sample.sampleName,
-                    Generators: generators,
-                    Modulators: sampleAndGenerators.modulators.map(m => m.debugString()),
-                    Velocity: velocity,
-                    TargetKey: targetKey,
-                    MidiNote: midiNote,
-                    WorkletSample: workletSample
-                }]);
-            }
-
-            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
-                },
-                // generators and modulators
-                generators: generators,
-                modulators: sampleAndGenerators.modulators,
-                modulatedGenerators: new Int16Array(60),
-
-                // sample and playback data
-                sample: workletSample,
-                velocity: velocity,
-                midiNote: midiNote,
-                channelNumber: channel,
-                startTime: currentTime,
-                targetKey: targetKey,
-                currentTuningCalculated: 1,
-                currentTuningCents: 0,
-                releaseStartTime: Infinity,
-
-                // envelope data
-                finished: false,
-                isInRelease: false,
-                currentAttenuationDb: 100,
-                currentModEnvValue: 0,
-                releaseStartModEnv: 1,
-                volumeEnvelopeState: 0,
-                currentPan: 0.5
-            };
-
-        });
-        // cache the voice
-        if(canCache) {
-            // clone it so the system won't mess with it!
-            cachedVoices[midiNote][velocity] = workletVoices.map(deepClone);
-        }
-    }
-    return workletVoices;
-}