spessasynth_core 1.1.3 → 1.1.4

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

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

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

@@ -1,133 +0,0 @@
-import { generatorTypes } from '../../../soundfont/chunk/generators.js'
-import { absCentsToHz, decibelAttenuationToGain } from './unit_converter.js'
-
-/**
- * lowpass_filter.js
- * purpose: applies a low pass filter to a voice
- * note to self: most of this is code is just javascript version of the C code from fluidsynth,
- * they are the real smart guys.
- * Shoutout to them!
- */
-
-/**
- * @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
- * @param sampleRate {number} in hertz
- * @this {Synthesizer}
- */
-export function applyLowpassFilter(voice, outputBuffer, cutoffCents, sampleRate)
-{
-    if(cutoffCents > 13499)
-    {
-        return; // filter is open
-    }
-
-    // check if the frequency has changed. if so, calculate new coefficients
-    if(voice.filter.cutoffCents !== cutoffCents || voice.filter.reasonanceCb !== voice.modulatedGenerators[generatorTypes.initialFilterQ])
-    {
-        voice.filter.cutoffCents = cutoffCents;
-        voice.filter.reasonanceCb = voice.modulatedGenerators[generatorTypes.initialFilterQ];
-        calculateCoefficients(voice, sampleRate);
-    }
-
-    // filter the input
-    for (let i = 0; i < outputBuffer.length; i++) {
-        let input = outputBuffer[i];
-        let filtered = voice.filter.a0 * input
-            + voice.filter.a1 * voice.filter.x1
-            + voice.filter.a2 * voice.filter.x2
-            - voice.filter.a3 * voice.filter.y1
-            - voice.filter.a4 * voice.filter.y2;
-
-        // set buffer
-        voice.filter.x2 = voice.filter.x1;
-        voice.filter.x1 = input;
-        voice.filter.y2 = voice.filter.y1;
-        voice.filter.y1 = filtered;
-
-        outputBuffer[i] = filtered;
-    }
-}
-
-/**
- * @param voice {WorkletVoice}
- * @param sampleRate {number}
- */
-function calculateCoefficients(voice, sampleRate)
-{
-    voice.filter.cutoffHz = absCentsToHz(voice.filter.cutoffCents);
-
-    // fix cutoff on low frequencies (fluid_iir_filter.c line 392)
-    if(voice.filter.cutoffHz > 0.45 * sampleRate)
-    {
-        voice.filter.cutoffHz = 0.45 * sampleRate;
-    }
-
-    // adjust the filterQ (fluid_iir_filter.c line 204)
-    const qDb = (voice.filter.reasonanceCb / 10) - 3.01;
-    voice.filter.reasonanceGain = decibelAttenuationToGain(-1 * qDb); // -1 because it's attenuation, and we don't want attenuation
-
-    // reduce the gain by the Q factor (fluid_iir_filter.c line 250)
-    const qGain = 1 / Math.sqrt(voice.filter.reasonanceGain);
-
-
-    // code is ported from https://github.com/sinshu/meltysynth/ to work with js. I'm too dumb to understand the math behind this...
-    let w = 2 * Math.PI * voice.filter.cutoffHz / sampleRate;
-    let cosw = Math.cos(w);
-    let alpha = Math.sin(w) / (2 * voice.filter.reasonanceGain);
-
-    let b1 = (1 - cosw) * qGain;
-    let b0 = b1 / 2;
-    let b2 = b0;
-    let a0 = 1 + alpha;
-    let a1 = -2 * cosw;
-    let a2 = 1 - alpha;
-
-    // set coefficients
-    voice.filter.a0 = b0 / a0;
-    voice.filter.a1 = b1 / a0;
-    voice.filter.a2 = b2 / a0;
-    voice.filter.a3 = a1 / a0;
-    voice.filter.a4 = a2 / a0;
-}

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

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

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

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