spessasynth_lib 0.0.1

package/package/synthetizer/worklet_system/worklet_utilities/unit_converter.js

@@ -0,0 +1,66 @@
+/**
+ * unit_converter.js
+ * purpose: converts soundfont units into more useable values with the use of lookup tables to improve performance
+ */
+
+
+// timecent lookup table
+const MIN_TIMECENT = -15000;
+const MAX_TIMECENT = 15000;
+const timecentLookupTable = new Float32Array(MAX_TIMECENT - MIN_TIMECENT + 1);
+for (let i = 0; i < timecentLookupTable.length; i++) {
+    const timecents = MIN_TIMECENT + i;
+    timecentLookupTable[i] = Math.pow(2, timecents / 1200);
+}
+
+/**
+ * Converts timecents to seconds
+ * @param timecents {number} timecents
+ * @returns {number} seconds
+ */
+export function timecentsToSeconds(timecents)
+{
+    return timecentLookupTable[timecents - MIN_TIMECENT];
+}
+
+// abs cent lookup table
+const MIN_ABS_CENT = -20000; // freqVibLfo
+const MAX_ABS_CENT = 16500; // filterFc
+const absoluteCentLookupTable = new Float32Array(MAX_ABS_CENT - MIN_ABS_CENT + 1);
+for (let i = 0; i < absoluteCentLookupTable.length; i++) {
+    const absoluteCents = MIN_ABS_CENT + i;
+    absoluteCentLookupTable[i] = 440 * Math.pow(2, (absoluteCents - 6900) / 1200);
+}
+
+/**
+ * Converts absolute cents to hertz
+ * @param cents {number} absolute cents
+ * @returns {number} hertz
+ */
+export function absCentsToHz(cents)
+{
+    if(cents < MIN_ABS_CENT || cents > MAX_ABS_CENT)
+    {
+        return 440 * Math.pow(2, (cents - 6900) / 1200);
+    }
+    return absoluteCentLookupTable[~~(cents) - MIN_ABS_CENT];
+}
+
+// decibel lookup table (2 points of precision)
+const MIN_DECIBELS = -1660;
+const MAX_DECIBELS = 1600;
+const decibelLookUpTable = new Float32Array((MAX_DECIBELS - MIN_DECIBELS) * 100 + 1);
+for (let i = 0; i < decibelLookUpTable.length; i++) {
+    const decibels = (MIN_DECIBELS * 100 + i) / 100;
+    decibelLookUpTable[i] = Math.pow(10, -decibels / 20);
+}
+
+/**
+ * convers decibel attenuation to gain
+ * @param decibels {number} the decibel attenuation
+ * @returns {number} gain
+ */
+export function decibelAttenuationToGain(decibels)
+{
+    return decibelLookUpTable[Math.floor((decibels - MIN_DECIBELS) * 100)];
+}

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

@@ -0,0 +1,265 @@
+import { decibelAttenuationToGain, timecentsToSeconds } from './unit_converter.js'
+import { generatorTypes } from '../../../soundfont/read/generators.js'
+
+/**
+ * volume_envelope.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;
+
+/**
+ * VOL ENV STATES:
+ * 0 - delay
+ * 1 - attack
+ * 2 - hold/peak
+ * 3 - decay
+ * 4 - sustain
+ * 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)
+{
+    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)
+    {
+        // 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 = 0;
+                break;
+
+            case 1:
+                // attack phase
+                // 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;
+        }
+    }
+}
+
+/**
+ * Applies volume envelope gain to the given output buffer
+ * @param voice {WorkletVoice} the voice we're working on
+ * @param audioBuffer {Float32Array} the audio buffer to modify
+ * @param currentTime {number} the current audio time
+ * @param centibelOffset {number} the centibel offset of volume, for modLFOtoVolume
+ * @param sampleTime {number} single sample time in seconds, usually 1 / 44100 of a second
+ * @param smoothingFactor {number} the adjusted smoothing factor for the envelope
+ */
+
+export function applyVolumeEnvelope(voice, audioBuffer, currentTime, centibelOffset, sampleTime, smoothingFactor)
+{
+    let decibelOffset = centibelOffset / 10;
+    const env = voice.volumeEnvelope;
+
+    // RELEASE PHASE
+    if(voice.isInRelease)
+    {
+        // release needs a more aggressive smoothing factor as the instant notes don't end instantly when they should
+        const releaseSmoothingFactor = smoothingFactor * 10;
+        const releaseStartDb = env.releaseStartDb + decibelOffset;
+        let elapsedRelease = currentTime - voice.releaseStartTime;
+        let dbDifference = DB_SILENCE - releaseStartDb;
+        let gain = env.currentReleaseGain;
+        for (let i = 0; i < audioBuffer.length; i++)
+        {
+            let db = (elapsedRelease / env.releaseDuration) * dbDifference + releaseStartDb;
+            gain = decibelAttenuationToGain(db + decibelOffset);
+            env.currentReleaseGain += (gain - env.currentReleaseGain) * releaseSmoothingFactor;
+            audioBuffer[i] *= env.currentReleaseGain;
+            elapsedRelease += sampleTime;
+        }
+
+        if(env.currentReleaseGain <= GAIN_SILENCE)
+        {
+            voice.finished = true;
+        }
+        return;
+    }
+
+    let currentFrameTime = currentTime;
+    let filledBuffer = 0;
+    switch(env.state)
+    {
+        case 0:
+            // delay phase, no sound is produced
+            while(currentFrameTime < env.delayEnd)
+            {
+                env.currentAttenuationDb = DB_SILENCE;
+                audioBuffer[filledBuffer] = 0;
+
+                currentFrameTime += sampleTime;
+                if(++filledBuffer >= audioBuffer.length)
+                {
+                    return;
+                }
+            }
+            env.state++;
+        // fallthrough
+
+        case 1:
+            // attack phase: ramp from 0 to attenuation
+            while(currentFrameTime < env.attackEnd)
+            {
+                // Special case: linear gain ramp instead of linear db ramp
+                let linearAttenuation = 1 - (env.attackEnd - currentFrameTime) / env.attackDuration; // 0 to 1
+                const gain = linearAttenuation * decibelAttenuationToGain(env.attenuation + decibelOffset)
+                audioBuffer[filledBuffer] *= gain;
+
+                // set current attenuation to peak as its invalid during this phase
+                env.currentAttenuationDb = env.attenuation;
+
+                currentFrameTime += sampleTime;
+                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)
+                {
+                    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)
+                {
+                    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)
+                {
+                    return;
+                }
+            }
+
+    }
+}

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

@@ -0,0 +1,83 @@
+/**
+ * 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/package/synthetizer/worklet_system/worklet_utilities/worklet_modulator.js

@@ -0,0 +1,234 @@
+import { modulatorSources } from '../../../soundfont/read/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/generators.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 voice {WorkletVoice} the voice belonging to the modulator
+ * @returns {number} the computed value
+ */
+export function computeWorkletModulator(controllerTable, modulator, voice)
+{
+    if(modulator.transformAmount === 0)
+    {
+        return 0;
+    }
+    // mapped to 0-16384
+    let rawSourceValue;
+    if(modulator.sourceUsesCC)
+    {
+        rawSourceValue = controllerTable[modulator.sourceIndex];
+    }
+    else
+    {
+        const index = modulator.sourceIndex + NON_CC_INDEX_OFFSET;
+        switch (modulator.sourceIndex)
+        {
+            case modulatorSources.noController:
+                rawSourceValue = 16383; // equals to 1
+                break;
+
+            case modulatorSources.noteOnKeyNum:
+                rawSourceValue = voice.midiNote << 7;
+                break;
+
+            case modulatorSources.noteOnVelocity:
+                rawSourceValue = voice.velocity << 7;
+                break;
+
+            case modulatorSources.polyPressure:
+                rawSourceValue = voice.pressure << 7;
+                break;
+
+            default:
+                rawSourceValue = controllerTable[index]; // pitch bend and range are stored in the cc table
+                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; // equals to 1
+                break;
+
+            case modulatorSources.noteOnKeyNum:
+                rawSecondSrcValue = voice.midiNote << 7;
+                break;
+
+            case modulatorSources.noteOnVelocity:
+                rawSecondSrcValue = voice.velocity << 7;
+                break;
+
+            case modulatorSources.polyPressure:
+                rawSecondSrcValue = voice.pressure << 7;
+                break;
+
+            default:
+                rawSecondSrcValue = controllerTable[index]; // pitch bend and range are stored in the cc table
+        }
+
+    }
+    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 modulators of a given voice. Source and index indicate what modulators shall be computed
+ * @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
+ * @param sourceUsesCC {number} what modulators should be computed, -1 means all, 0 means modulator source enum 1 means midi controller
+ * @param sourceIndex {number} enum for the source
+ */
+export function computeModulators(voice, controllerTable, sourceUsesCC = -1, sourceIndex = 0) {
+    const { modulators, generators, modulatedGenerators } = voice;
+
+    if (sourceUsesCC === -1)
+    {
+        // All modulators mode: compute all modulators
+        modulatedGenerators.set(generators);
+        modulators.forEach(mod => {
+            modulatedGenerators[mod.modulatorDestination] += computeWorkletModulator(controllerTable, mod, voice);
+        });
+        recalculateVolumeEnvelope(voice);
+        return;
+    }
+
+    // Optimized mode: calculate only modulators that use the given source
+    const volenvNeedsRecalculation = new Set([
+        generatorTypes.initialAttenuation,
+        generatorTypes.delayVolEnv,
+        generatorTypes.attackVolEnv,
+        generatorTypes.holdVolEnv,
+        generatorTypes.decayVolEnv,
+        generatorTypes.sustainVolEnv,
+        generatorTypes.releaseVolEnv,
+        generatorTypes.keyNumToVolEnvHold,
+        generatorTypes.keyNumToVolEnvDecay
+    ]);
+
+    const computedDestinations = new Set();
+
+    modulators.forEach(mod => {
+        if (
+            (mod.sourceUsesCC === sourceUsesCC && mod.sourceIndex === sourceIndex) ||
+            (mod.secSrcUsesCC === sourceUsesCC && mod.secSrcIndex === sourceIndex)
+        ) {
+            const destination = mod.modulatorDestination;
+            if (!computedDestinations.has(destination))
+            {
+                // Reset this destination
+                modulatedGenerators[destination] = generators[destination];
+                // Compute all modulators for this destination
+                modulators.forEach(m => {
+                    if (m.modulatorDestination === destination)
+                    {
+                        modulatedGenerators[destination] += computeWorkletModulator(controllerTable, m, voice);
+                    }
+                });
+                computedDestinations.add(destination);
+            }
+        }
+    });
+
+    // Recalculate volume envelope if necessary
+    if ([...computedDestinations].some(dest => volenvNeedsRecalculation.has(dest)))
+    {
+        recalculateVolumeEnvelope(voice);
+    }
+}
+
+
+/**
+ * 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;
+        }
+    }
+}