spessasynth_core 3.27.7 → 4.0.0

package/src/synthetizer/audio_engine/engine_components/modulation_envelope.js

@@ -1,181 +0,0 @@
-import { timecentsToSeconds } from "./unit_converter.js";
-import { getModulatorCurveValue } from "./modulator_curves.js";
-import { modulatorCurveTypes } from "../../../soundfont/basic_soundfont/modulator.js";
-import { generatorTypes } from "../../../soundfont/basic_soundfont/generator_types.js";
-
-/**
- * modulation_envelope.js
- * purpose: calculates the modulation envelope for the given voice
- */
-const MODENV_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);
-}
-
-export class ModulationEnvelope
-{
-    /**
-     * The attack duration, in seconds
-     * @type {number}
-     */
-    attackDuration = 0;
-    /**
-     * The decay duration, in seconds
-     * @type {number}
-     */
-    decayDuration = 0;
-    
-    /**
-     * The hold duration, in seconds
-     * @type {number}
-     */
-    holdDuration = 0;
-    
-    /**
-     * Release duration, in seconds
-     * @type {number}
-     */
-    releaseDuration = 0;
-    
-    /**
-     * The sustain level 0-1
-     * @type {number}
-     */
-    sustainLevel = 0;
-    
-    /**
-     * Delay phase end time in seconds, absolute (audio context time)
-     * @type {number}
-     */
-    delayEnd = 0;
-    /**
-     * Attack phase end time in seconds, absolute (audio context time)
-     * @type {number}
-     */
-    attackEnd = 0;
-    /**
-     * Hold phase end time in seconds, absolute (audio context time)
-     * @type {number}
-     */
-    holdEnd = 0;
-    /**
-     * Decay phase end time in seconds, absolute (audio context time)
-     * @type {number}
-     */
-    decayEnd = 0;
-    
-    /**
-     * The level of the envelope when the release phase starts
-     * @type {number}
-     */
-    releaseStartLevel = 0;
-    
-    /**
-     * The current modulation envelope value
-     * @type {number}
-     */
-    currentValue = 0;
-    
-    /**
-     * Starts the release phase in the envelope
-     * @param voice {Voice} the voice this envelope belongs to
-     */
-    static startRelease(voice)
-    {
-        ModulationEnvelope.recalculate(voice);
-    }
-    
-    /**
-     * @param voice {Voice} the voice to recalculate
-     */
-    static recalculate(voice)
-    {
-        const env = voice.modulationEnvelope;
-        
-        // in release? Might need to recalculate the value as it can be modulated
-        if (voice.isInRelease)
-        {
-            env.releaseStartLevel = ModulationEnvelope.getValue(voice, voice.releaseStartTime, true);
-        }
-        
-        env.sustainLevel = 1 - (voice.modulatedGenerators[generatorTypes.sustainModEnv] / 1000);
-        
-        env.attackDuration = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.attackModEnv]);
-        
-        const decayKeyExcursionCents = ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvDecay]);
-        const decayTime = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.decayModEnv] + decayKeyExcursionCents);
-        // according to the specification, the decay time is the time it takes to reach 0% from 100%.
-        // calculate the time to reach actual sustain level,
-        // for example, sustain 0.6 will be 0.4 of the decay time
-        env.decayDuration = decayTime * (1 - env.sustainLevel);
-        
-        const holdKeyExcursionCents = ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvHold]);
-        env.holdDuration = timecentsToSeconds(holdKeyExcursionCents + voice.modulatedGenerators[generatorTypes.holdModEnv]);
-        
-        const releaseTime = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.releaseModEnv]);
-        // release time is from the full level to 0%
-        // to get the actual time, multiply by the release start level
-        env.releaseDuration = releaseTime * env.releaseStartLevel;
-        
-        env.delayEnd = voice.startTime + timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayModEnv]);
-        env.attackEnd = env.delayEnd + env.attackDuration;
-        env.holdEnd = env.attackEnd + env.holdDuration;
-        env.decayEnd = env.holdEnd + env.decayDuration;
-    }
-    
-    /**
-     * Calculates the current modulation envelope value for the given time and voice
-     * @param voice {Voice} the voice we are working on
-     * @param currentTime {number} in seconds
-     * @param ignoreRelease {boolean} if true, it will compute the value as if the voice was not released
-     * @returns {number} modenv value, from 0 to 1
-     */
-    static getValue(voice, currentTime, ignoreRelease = false)
-    {
-        const env = voice.modulationEnvelope;
-        if (voice.isInRelease && !ignoreRelease)
-        {
-            // if the voice is still in the delay phase,
-            // start level will be 0 that will result in divide by zero
-            if (env.releaseStartLevel === 0)
-            {
-                return 0;
-            }
-            return Math.max(
-                0,
-                (1 - (currentTime - voice.releaseStartTime) / env.releaseDuration) * env.releaseStartLevel
-            );
-        }
-        
-        if (currentTime < env.delayEnd)
-        {
-            env.currentValue = 0; // delay
-        }
-        else if (currentTime < env.attackEnd)
-        {
-            // modulation envelope uses convex curve for attack
-            env.currentValue = CONVEX_ATTACK[~~((1 - (env.attackEnd - currentTime) / env.attackDuration) * 1000)];
-        }
-        else if (currentTime < env.holdEnd)
-        {
-            // hold: stay at 1
-            env.currentValue = MODENV_PEAK;
-        }
-        else if (currentTime < env.decayEnd)
-        {
-            // decay: linear ramp from 1 to sustain level
-            env.currentValue = (1 - (env.decayEnd - currentTime) / env.decayDuration) * (env.sustainLevel - MODENV_PEAK) + MODENV_PEAK;
-        }
-        else
-        {
-            // sustain: stay at sustain level
-            env.currentValue = env.sustainLevel;
-        }
-        return env.currentValue;
-    }
-}

package/src/synthetizer/audio_engine/engine_components/modulator_curves.js

@@ -1,89 +0,0 @@
-import { modulatorCurveTypes } from "../../../soundfont/basic_soundfont/modulator.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 convex curves
-const concave = new Float32Array(MOD_PRECOMPUTED_LENGTH + 1);
-const convex = new Float32Array(MOD_PRECOMPUTED_LENGTH + 1);
-// the equation is taken from FluidSynth as it's the standard for soundFonts
-// more precisely, the gen_conv.c file
-concave[0] = 0;
-concave[concave.length - 1] = 1;
-
-convex[0] = 0;
-convex[convex.length - 1] = 1;
-for (let i = 1; i < MOD_PRECOMPUTED_LENGTH - 1; i++)
-{
-    let x = (-200 * 2 / 960) * Math.log(i / (concave.length - 1)) / Math.LN10;
-    convex[i] = 1 - x;
-    concave[concave.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 curve
-                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 -concave[~~(value * -MOD_PRECOMPUTED_LENGTH)];
-                }
-                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 -convex[~~(value * -MOD_PRECOMPUTED_LENGTH)];
-                }
-                return convex[~~(value * MOD_PRECOMPUTED_LENGTH)];
-            }
-            return convex[~~(value * MOD_PRECOMPUTED_LENGTH)];
-    }
-}

package/src/synthetizer/audio_engine/engine_components/soundfont_manager.js

@@ -1,265 +0,0 @@
-import { SpessaSynthInfo, SpessaSynthWarn } from "../../../utils/loggin.js";
-import { isXGDrums } from "../../../utils/xg_hacks.js";
-import { EMBEDDED_SOUND_BANK_ID } from "../../synth_constants.js";
-
-/**
- * @typedef {Object} SoundFontType
- * @property {string} id - unique id for the soundfont
- * @property {BasicSoundBank} soundfont - the soundfont itself
- * @property {number} bankOffset - the soundfont's bank offset
- */
-
-export class SoundFontManager
-{
-    /**
-     * All the soundfonts, ordered from the most important to the least.
-     * @type {SoundFontType[]}
-     */
-    soundfontList = [];
-    /**
-     * @type {{bank: number, presetName: string, program: number}[]}
-     */
-    presetList = [];
-    
-    /**
-     * @param presetListChangeCallback {function} to call when stuff changes
-     */
-    constructor(presetListChangeCallback)
-    {
-        this.presetListChangeCallback = presetListChangeCallback;
-    }
-    
-    generatePresetList()
-    {
-        /**
-         * <"bank-program", "presetName">
-         * @type {Record<string, string>}
-         */
-        const presetList = {};
-        // gather the presets in reverse and replace if necessary
-        for (let i = this.soundfontList.length - 1; i >= 0; i--)
-        {
-            const font = this.soundfontList[i];
-            /**
-             * prevent preset names from the same soudfont from being overriden
-             * if the soundfont has two presets with matching bank and program
-             * @type {Set<string>}
-             */
-            const presets = new Set();
-            for (const p of font.soundfont.presets)
-            {
-                const bank = Math.min(128, p.bank + font.bankOffset);
-                const presetString = `${bank}-${p.program}`;
-                if (presets.has(presetString))
-                {
-                    continue;
-                }
-                presets.add(presetString);
-                presetList[presetString] = p.presetName;
-            }
-        }
-        
-        this.presetList = [];
-        for (const [string, name] of Object.entries(presetList))
-        {
-            const pb = string.split("-");
-            this.presetList.push({
-                presetName: name,
-                program: parseInt(pb[1]),
-                bank: parseInt(pb[0])
-            });
-        }
-        this.presetListChangeCallback();
-    }
-    
-    /**
-     * Get the final preset list
-     * @returns {{bank: number, presetName: string, program: number}[]}
-     */
-    getPresetList()
-    {
-        return this.presetList.slice();
-    }
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * Clears all soundfonts and adds a new one with an ID "main"
-     * @param soundFont {BasicSoundBank}
-     */
-    reloadManager(soundFont)
-    {
-        // do not clear the embedded bank
-        this.soundfontList = this.soundfontList.filter(sf => sf.id === EMBEDDED_SOUND_BANK_ID);
-        this.soundfontList.push({
-            id: "main",
-            bankOffset: 0,
-            soundfont: soundFont
-        });
-        this.generatePresetList();
-    }
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * Deletes a given soundfont.
-     * @param id {string}
-     */
-    deleteSoundFont(id)
-    {
-        if (this.soundfontList.length === 0)
-        {
-            SpessaSynthWarn("1 soundfont left. Aborting!");
-            return;
-        }
-        const index = this.soundfontList.findIndex(s => s.id === id);
-        if (index === -1)
-        {
-            SpessaSynthInfo(`No soundfont with id of "${id}" found. Aborting!`);
-            return;
-        }
-        this.soundfontList.splice(index, 1);
-        this.generatePresetList();
-    }
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * Adds a new soundfont with a given ID, or replaces an existing one.
-     * @param font {BasicSoundBank}
-     * @param id {string}
-     * @param bankOffset {number}
-     */
-    addNewSoundFont(font, id, bankOffset)
-    {
-        if (this.soundfontList.find(s => s.id === id) !== undefined)
-        {
-            // replace
-            const soundfont = this.soundfontList.find(s => s.id === id);
-            soundfont.soundfont = font;
-            soundfont.bankOffset = bankOffset;
-        }
-        else
-        {
-            this.soundfontList.push({
-                id: id,
-                soundfont: font,
-                bankOffset: bankOffset
-            });
-        }
-        this.generatePresetList();
-    }
-    
-    /**
-     * Gets the current soundfont order
-     * @returns {string[]}
-     */
-    getCurrentSoundFontOrder()
-    {
-        return this.soundfontList.map(s => s.id);
-    }
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * Rearranges the soundfonts
-     * @param newList {string[]} the order of soundfonts, a list of strings, first overwrites second
-     */
-    rearrangeSoundFonts(newList)
-    {
-        this.soundfontList.sort((a, b) =>
-            newList.indexOf(a.id) - newList.indexOf(b.id)
-        );
-        this.generatePresetList();
-    }
-    
-    /**
-     * Gets a given preset from the soundfont stack
-     * @param bankNumber {number}
-     * @param programNumber {number}
-     * @param allowXGDrums {boolean} if true, allows XG drum banks (120, 126 and 127) as drum preset
-     * @returns {{preset: BasicPreset, bankOffset: number}} the preset and its bank offset
-     */
-    getPreset(bankNumber, programNumber, allowXGDrums = false)
-    {
-        if (this.soundfontList.length < 1)
-        {
-            throw new Error("No soundfonts! Did you forget to add one?");
-        }
-        const isDrum = bankNumber === 128 || (allowXGDrums && isXGDrums(bankNumber));
-        for (const sf of this.soundfontList)
-        {
-            // check for the preset (with given offset)
-            const preset = sf.soundfont.getPresetNoFallback(
-                bankNumber === 128 ? 128 : bankNumber - sf.bankOffset,
-                programNumber,
-                allowXGDrums
-            );
-            if (preset !== undefined)
-            {
-                return {
-                    preset: preset,
-                    bankOffset: sf.bankOffset
-                };
-            }
-            // if not found, advance to the next soundfont
-        }
-        // if none found, return the first correct preset found
-        if (!isDrum)
-        {
-            for (const sf of this.soundfontList)
-            {
-                const preset = sf.soundfont.presets.find(p => p.program === programNumber && !p.isDrumPreset(
-                    allowXGDrums));
-                if (preset)
-                {
-                    return {
-                        preset: preset,
-                        bankOffset: sf.bankOffset
-                    };
-                }
-            }
-            // if nothing at all, use the first preset
-            const sf = this.soundfontList[0];
-            return {
-                preset: sf.soundfont.presets[0],
-                bankOffset: sf.bankOffset
-            };
-        }
-        else
-        {
-            for (const sf of this.soundfontList)
-            {
-                // check for any drum type (127/128) and matching program
-                const p = sf.soundfont.presets.find(p => p.isDrumPreset(allowXGDrums) && p.program === programNumber);
-                if (p)
-                {
-                    return {
-                        preset: p,
-                        bankOffset: sf.bankOffset
-                    };
-                }
-                // check for any drum preset
-                const preset = sf.soundfont.presets.find(p => p.isDrumPreset(allowXGDrums));
-                if (preset)
-                {
-                    return {
-                        preset: preset,
-                        bankOffset: sf.bankOffset
-                    };
-                }
-            }
-            // if nothing at all, use the first preset
-            const sf = this.soundfontList[0];
-            return {
-                preset: sf.soundfont.presets[0],
-                bankOffset: sf.bankOffset
-            };
-        }
-    }
-    
-    destroyManager()
-    {
-        this.soundfontList.forEach(s =>
-        {
-            s.soundfont.destroySoundBank();
-        });
-        delete this.soundfontList;
-    }
-}

package/src/synthetizer/audio_engine/engine_components/stereo_panner.js

@@ -1,124 +0,0 @@
-import { generatorTypes } from "../../../soundfont/basic_soundfont/generator_types.js";
-
-/**
- * stereo_panner.js
- * purpose: pans a given voice out to the stereo output and to the effects' outputs
- */
-
-export const PAN_SMOOTHING_FACTOR = 0.05;
-
-// optimized for spessasynth_lib's effects
-export const REVERB_DIVIDER = 3070;
-export const CHORUS_DIVIDER = 2000;
-const HALF_PI = Math.PI / 2;
-
-const MIN_PAN = -500;
-const MAX_PAN = 500;
-const PAN_RESOLUTION = MAX_PAN - MIN_PAN;
-
-// initialize pan lookup tables
-const panTableLeft = new Float32Array(PAN_RESOLUTION + 1);
-const panTableRight = new Float32Array(PAN_RESOLUTION + 1);
-for (let pan = MIN_PAN; pan <= MAX_PAN; pan++)
-{
-    // clamp to 0-1
-    const realPan = (pan - MIN_PAN) / PAN_RESOLUTION;
-    const tableIndex = pan - MIN_PAN;
-    panTableLeft[tableIndex] = Math.cos(HALF_PI * realPan);
-    panTableRight[tableIndex] = Math.sin(HALF_PI * realPan);
-}
-
-/**
- * Pans the voice to the given output buffers
- * @param voice {Voice} the voice to pan
- * @param inputBuffer {Float32Array} the input buffer in mono
- * @param outputLeft {Float32Array} left output buffer
- * @param outputRight {Float32Array} right output buffer
- * @param reverbLeft {Float32Array} left reverb input
- * @param reverbRight {Float32Array} right reverb input
- * @param chorusLeft {Float32Array} left chorus buffer
- * @param chorusRight {Float32Array} right chorus buffer
- * @param startIndex {number}
- * @this {MidiAudioChannel}
- */
-export function panAndMixVoice(voice,
-                               inputBuffer,
-                               outputLeft, outputRight,
-                               reverbLeft, reverbRight,
-                               chorusLeft, chorusRight,
-                               startIndex)
-{
-    if (isNaN(inputBuffer[0]))
-    {
-        return;
-    }
-    /**
-     * clamp -500 to 500
-     * @type {number}
-     */
-    let pan;
-    if (voice.overridePan)
-    {
-        pan = voice.overridePan;
-    }
-    else
-    {
-        // smooth out pan to prevent clicking
-        voice.currentPan += (voice.modulatedGenerators[generatorTypes.pan] - voice.currentPan) * this.synth.panSmoothingFactor;
-        pan = voice.currentPan;
-    }
-    
-    const gain = this.synth.currentGain * voice.gain;
-    const index = ~~(pan + 500);
-    // get voice's gain levels for each channel
-    const gainLeft = panTableLeft[index] * gain * this.synth.panLeft;
-    const gainRight = panTableRight[index] * gain * this.synth.panRight;
-    
-    // disable reverb and chorus if necessary
-    if (this.synth.effectsEnabled)
-    {
-        const reverbSend = voice.modulatedGenerators[generatorTypes.reverbEffectsSend];
-        if (reverbSend > 0)
-        {
-            // reverb is mono so we need to multiply by gain
-            const reverbGain = this.synth.reverbGain * this.synth.reverbSend * gain * (reverbSend / REVERB_DIVIDER);
-            for (let i = 0; i < inputBuffer.length; i++)
-            {
-                const idx = i + startIndex;
-                reverbLeft[idx] += reverbGain * inputBuffer[i];
-                reverbRight[idx] += reverbGain * inputBuffer[i];
-            }
-        }
-        
-        const chorusSend = voice.modulatedGenerators[generatorTypes.chorusEffectsSend];
-        if (chorusSend > 0)
-        {
-            // chorus is stereo so we do not need to
-            const chorusGain = this.synth.chorusGain * this.synth.chorusSend * (chorusSend / CHORUS_DIVIDER);
-            const chorusLeftGain = gainLeft * chorusGain;
-            const chorusRightGain = gainRight * chorusGain;
-            for (let i = 0; i < inputBuffer.length; i++)
-            {
-                const idx = i + startIndex;
-                chorusLeft[idx] += chorusLeftGain * inputBuffer[i];
-                chorusRight[idx] += chorusRightGain * inputBuffer[i];
-            }
-        }
-    }
-    
-    // mix down the audio data
-    if (gainLeft > 0)
-    {
-        for (let i = 0; i < inputBuffer.length; i++)
-        {
-            outputLeft[i + startIndex] += gainLeft * inputBuffer[i];
-        }
-    }
-    if (gainRight > 0)
-    {
-        for (let i = 0; i < inputBuffer.length; i++)
-        {
-            outputRight[i + startIndex] += gainRight * inputBuffer[i];
-        }
-    }
-}