spessasynth_core 1.1.3 → 1.1.5

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

@@ -1,272 +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
- */
-
-/**
- * @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;
-    }
-
-    if(!voice.hasStarted)
-    {
-        voice.startTime = currentTime;
-        recalculateVolumeEnvelope(voice);
-        voice.hasStarted = true;
-    }
-
-    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/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,175 +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'
-import {recalculateVolumeEnvelope} from "./volume_envelope.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);
-    });
-    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;
-        }
-    }
-}

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;