spessasynth_core 3.27.7 → 4.0.0

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

@@ -1,289 +0,0 @@
-import { getModulatorCurveValue, MOD_PRECOMPUTED_LENGTH } from "./modulator_curves.js";
-import { VolumeEnvelope } from "./volume_envelope.js";
-import { ModulationEnvelope } from "./modulation_envelope.js";
-import { Modulator, modulatorSources } from "../../../soundfont/basic_soundfont/modulator.js";
-import { NON_CC_INDEX_OFFSET } from "./controller_tables.js";
-import { generatorLimits, generatorTypes } from "../../../soundfont/basic_soundfont/generator_types.js";
-
-/**
- * compute_modulator.js
- * purpose: precomputes all curve types and computes modulators
- */
-
-const EFFECT_MODULATOR_TRANSFORM_MULTIPLIER = 1000 / 200;
-
-/**
- * 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 {Voice} the voice belonging to the modulator
- * @returns {number} the computed value
- */
-export function computeModulator(controllerTable, modulator, voice)
-{
-    if (modulator.transformAmount === 0)
-    {
-        modulator.currentValue = 0;
-        return 0;
-    }
-    // mapped to 0-16,384
-    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];
-    
-    // see the comment for isEffectModulator (modulator.js in basic_soundfont) for explanation
-    let transformAmount = modulator.transformAmount;
-    if (modulator.isEffectModulator && transformAmount <= 1000)
-    {
-        transformAmount *= EFFECT_MODULATOR_TRANSFORM_MULTIPLIER;
-        transformAmount = Math.min(transformAmount, 1000);
-    }
-    
-    // compute the modulator
-    let computedValue = sourceValue * secondSrcValue * transformAmount;
-    
-    if (modulator.transformType === 2)
-    {
-        // abs value
-        computedValue = Math.abs(computedValue);
-    }
-    
-    // resonant modulator: take its value and ensure that it won't change the final gain
-    if (modulator.isDefaultResonantModulator)
-    {
-        // half the gain, negates the filter
-        voice.resonanceOffset = Math.max(0, computedValue / 2);
-    }
-    
-    modulator.currentValue = computedValue;
-    return computedValue;
-}
-
-/**
- * Computes modulators of a given voice. Source and index indicate what modulators shall be computed
- * @param voice {Voice} the voice to compute modulators for
- * @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
- * @this {MidiAudioChannel}
- */
-export function computeModulators(voice, sourceUsesCC = -1, sourceIndex = 0)
-{
-    const modulators = voice.modulators;
-    let generators = voice.generators;
-    // apply offsets if enabled
-    if (this.generatorOffsetsEnabled)
-    {
-        generators = new Int16Array(generators);
-        for (let i = 0; i < generators.length; i++)
-        {
-            generators[i] += this.generatorOffsets[i];
-        }
-    }
-    const modulatedGenerators = voice.modulatedGenerators;
-    
-    if (sourceUsesCC === -1)
-    {
-        // All modulators mode: compute all modulators
-        modulatedGenerators.set(generators);
-        modulators.forEach(mod =>
-        {
-            modulatedGenerators[mod.modulatorDestination] += computeModulator(
-                this.midiControllers,
-                mod,
-                voice
-            );
-        });
-        // apply limits
-        for (let gen = 0; gen < modulatedGenerators.length; gen++)
-        {
-            const limit = generatorLimits[gen];
-            if (!limit)
-            {
-                // skip unused
-                continue;
-            }
-            modulatedGenerators[gen] = Math.min(limit.max, Math.max(limit.min, modulatedGenerators[gen]));
-        }
-        VolumeEnvelope.recalculate(voice);
-        ModulationEnvelope.recalculate(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 our modulator
-                computeModulator(this.midiControllers, mod, voice);
-                // sum the values of all modulators for this destination
-                modulators.forEach(m =>
-                {
-                    if (m.modulatorDestination === destination)
-                    {
-                        modulatedGenerators[destination] += m.currentValue;
-                    }
-                });
-                // apply limits
-                const limits = generatorLimits[destination];
-                modulatedGenerators[destination] = Math.max(
-                    limits.min,
-                    Math.min(modulatedGenerators[destination], limits.max)
-                );
-                computedDestinations.add(destination);
-            }
-        }
-    });
-    
-    // Recalculate volume envelope if necessary
-    if ([...computedDestinations].some(dest => volenvNeedsRecalculation.has(dest)))
-    {
-        VolumeEnvelope.recalculate(voice);
-    }
-    
-    ModulationEnvelope.recalculate(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
-        );
-        
-        // polarity 1 dir 0
-        transforms[curve][1][0][i] = getModulatorCurveValue(
-            0,
-            curve,
-            i / MOD_PRECOMPUTED_LENGTH,
-            1
-        );
-        
-        // polarity 0 dir 1
-        transforms[curve][0][1][i] = getModulatorCurveValue(
-            1,
-            curve,
-            i / MOD_PRECOMPUTED_LENGTH,
-            0
-        );
-        
-        // polarity 1 dir 1
-        transforms[curve][1][1][i] = getModulatorCurveValue(
-            1,
-            curve,
-            i / MOD_PRECOMPUTED_LENGTH,
-            1
-        );
-    }
-}

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

@@ -1,90 +0,0 @@
-import { midiControllers } from "../../../midi/midi_message.js";
-import { modulatorSources } from "../../../soundfont/basic_soundfont/modulator.js";
-
-/*
- * A bit of explanation:
- * The controller table is stored as an int16 array, it stores 14-bit values.
- * This controller table is then extended with the modulatorSources section,
- * for example, pitch range and pitch range depth.
- * This allows us for precise control range and supports full pitch-wheel resolution.
- */
-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).fill(0);
-export const setResetValue = (i, v) => resetArray[i] = v << 7;
-
-// values come from Falcosoft MidiPlayer 6
-setResetValue(midiControllers.mainVolume, 100);
-setResetValue(midiControllers.balance, 64);
-setResetValue(midiControllers.expressionController, 127);
-setResetValue(midiControllers.pan, 64);
-
-setResetValue(midiControllers.portamentoOnOff, 127);
-
-setResetValue(midiControllers.filterResonance, 64);
-setResetValue(midiControllers.releaseTime, 64);
-setResetValue(midiControllers.attackTime, 64);
-setResetValue(midiControllers.brightness, 64);
-
-setResetValue(midiControllers.decayTime, 64);
-setResetValue(midiControllers.vibratoRate, 64);
-setResetValue(midiControllers.vibratoDepth, 64);
-setResetValue(midiControllers.vibratoDelay, 64);
-setResetValue(midiControllers.generalPurposeController6, 64);
-setResetValue(midiControllers.generalPurposeController8, 64);
-
-setResetValue(midiControllers.RPNLsb, 127);
-setResetValue(midiControllers.RPNMsb, 127);
-setResetValue(midiControllers.NRPNLsb, 127);
-setResetValue(midiControllers.NRPNMsb, 127);
-
-
-export const PORTAMENTO_CONTROL_UNSET = 1;
-// special case: portamento control
-// since it is only 7-bit, only the values at multiple of 128 are allowed.
-// a value of just 1 indicates no key set, hence no portamento.
-// this is the "initial unset portamento key" flag.
-resetArray[midiControllers.portamentoControl] = PORTAMENTO_CONTROL_UNSET;
-
-// pitch wheel
-setResetValue(NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel, 64);
-setResetValue(NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange, 2);
-
-/**
- * @enum {number}
- */
-export const customControllers = {
-    channelTuning: 0,              // cents, RPN for fine tuning
-    channelTransposeFine: 1,       // cents, only the decimal tuning, (e.g., transpose is 4.5,
-    // then shift by 4 keys + tune by 50 cents)
-    modulationMultiplier: 2,       // cents, set by modulation depth RPN
-    masterTuning: 3,               // cents, set by system exclusive
-    channelTuningSemitones: 4,     // semitones, for RPN coarse tuning
-    channelKeyShift: 5,            // key shift: for system exclusive
-    sf2NPRNGeneratorLSB: 6         // sf2 NPRN LSB for selecting a generator value
-};
-export const CUSTOM_CONTROLLER_TABLE_SIZE = Object.keys(customControllers).length;
-export const customResetArray = new Float32Array(CUSTOM_CONTROLLER_TABLE_SIZE);
-customResetArray[customControllers.modulationMultiplier] = 1;
-/**
- * @enum {number}
- */
-export const dataEntryStates = {
-    Idle: 0,
-    RPCoarse: 1,
-    RPFine: 2,
-    NRPCoarse: 3,
-    NRPFine: 4,
-    DataCoarse: 5,
-    DataFine: 6
-};
-/**
- * This is a channel configuration enum, it is internally sent from Synthetizer via controller change
- * @enum {number}
- */
-export const channelConfiguration = {
-    velocityOverride: 128 // overrides velocity for the given channel
-};

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

@@ -1,95 +0,0 @@
-import { Modulator, modulatorCurveTypes, modulatorSources } from "../../../soundfont/basic_soundfont/modulator.js";
-import { NON_CC_INDEX_OFFSET } from "./controller_tables.js";
-
-/**
- * A class for dynamic modulators
- * that are assigned for more complex system exclusive messages
- */
-export class DynamicModulatorSystem
-{
-    /**
-     * the current dynamic modulator list
-     * @type {{mod: Modulator, id: string}[]}
-     */
-    modulatorList = [];
-    
-    resetModulators()
-    {
-        this.modulatorList = [];
-    }
-    
-    /**
-     * @param source {number}
-     * @param destination {generatorTypes}
-     * @param isBipolar {boolean}
-     * @param isNegative {boolean}
-     */
-    _getModulatorId(source, destination, isBipolar, isNegative)
-    {
-        return `${source}-${destination}-${isBipolar}-${isNegative}`;
-    }
-    
-    /**
-     * @param id {string}
-     * @private
-     */
-    _deleteModulator(id)
-    {
-        this.modulatorList = this.modulatorList.filter(m => m.id !== id);
-    }
-    
-    /**
-     * @param source {number} like in midiControllers: values below NON_CC_INDEX_OFFSET are CCs,
-     * above are regular modulator sources
-     * @param destination {generatorTypes}
-     * @param amount {number}
-     * @param isBipolar {boolean}
-     * @param isNegative {boolean}
-     */
-    setModulator(source, destination, amount, isBipolar = false, isNegative = false)
-    {
-        const id = this._getModulatorId(source, destination, isBipolar, isNegative);
-        if (amount === 0)
-        {
-            this._deleteModulator(id);
-        }
-        const mod = this.modulatorList.find(m => m.id === id);
-        if (mod)
-        {
-            mod.mod.transformAmount = amount;
-        }
-        else
-        {
-            let srcNum, isCC;
-            if (source >= NON_CC_INDEX_OFFSET)
-            {
-                srcNum = source - NON_CC_INDEX_OFFSET;
-                isCC = false;
-            }
-            else
-            {
-                srcNum = source;
-                isCC = true;
-            }
-            const modulator = new Modulator(
-                srcNum,
-                modulatorCurveTypes.linear,
-                isCC ? 1 : 0,
-                isBipolar ? 1 : 0,
-                0,
-                modulatorSources.noController,
-                modulatorCurveTypes.linear,
-                0,
-                0,
-                0,
-                destination,
-                amount,
-                0
-            );
-            this.modulatorList.push({
-                mod: modulator,
-                id: id
-            });
-        }
-    }
-}

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

@@ -1,18 +0,0 @@
-/**
- *
- * @enum {number}
- */
-export const interpolationTypes = {
-    linear: 0,
-    nearestNeighbor: 1,
-    fourthOrder: 2
-};
-/**
- * The text types for the synth display
- * @enum {number}
- */
-export const synthDisplayTypes = {
-    SoundCanvasText: 0,
-    XGText: 1,
-    SoundCanvasDotDisplay: 2
-};

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

@@ -1,151 +0,0 @@
-/**
- * A manager for custom key overrides for channels
- */
-
-export class KeyModifier
-{
-    
-    /**
-     * The new override velocity. -1 means unchanged
-     * @type {number}
-     */
-    velocity = -1;
-    /**
-     * The patch this key uses. -1 on either means default
-     * @type {{bank: number, program: number}}
-     */
-    patch = { bank: -1, program: -1 };
-    
-    /**
-     * Linear gain override for the voice
-     */
-    gain = 1;
-    
-    /**
-     * @param velocity {number}
-     * @param bank {number}
-     * @param program {number}
-     * @param gain {number}
-     */
-    constructor(velocity = -1, bank = -1, program = -1, gain = 1)
-    {
-        this.velocity = velocity;
-        this.patch = {
-            bank: bank,
-            program: program
-        };
-        this.gain = gain;
-    }
-}
-
-export class KeyModifierManager
-{
-    /**
-     * The velocity override mappings for MIDI keys
-     * stored as [channelNumber][midiNote]
-     * @type {KeyModifier[][]}
-     * @private
-     */
-    _keyMappings = [];
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @param channel {number}
-     * @param midiNote {number}
-     * @param mapping {KeyModifier}
-     */
-    addMapping(channel, midiNote, mapping)
-    {
-        if (this._keyMappings[channel] === undefined)
-        {
-            this._keyMappings[channel] = [];
-        }
-        this._keyMappings[channel][midiNote] = mapping;
-    }
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @param channel {number}
-     * @param midiNote {number}
-     */
-    deleteMapping(channel, midiNote)
-    {
-        if (this._keyMappings[channel]?.[midiNote] === undefined)
-        {
-            return;
-        }
-        this._keyMappings[channel][midiNote] = undefined;
-    }
-    
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * Clear all mappings
-     */
-    clearMappings()
-    {
-        this._keyMappings = [];
-    }
-    
-    /**
-     * @param mappings {KeyModifier[][]}
-     */
-    setMappings(mappings)
-    {
-        this._keyMappings = mappings;
-    }
-    
-    /**
-     * @returns {KeyModifier[][]}
-     */
-    getMappings()
-    {
-        return this._keyMappings;
-    }
-    
-    /**
-     * @param channel {number}
-     * @param midiNote {number}
-     * @returns {number} velocity, -1 if unchanged
-     */
-    getVelocity(channel, midiNote)
-    {
-        return this._keyMappings[channel]?.[midiNote]?.velocity ?? -1;
-    }
-    
-    /**
-     * @param channel {number}
-     * @param midiNote {number}
-     * @returns {number} linear gain
-     */
-    getGain(channel, midiNote)
-    {
-        return this._keyMappings[channel]?.[midiNote]?.gain ?? 1;
-    }
-    
-    /**
-     * @param channel {number}
-     * @param midiNote {number}
-     * @returns {boolean}
-     */
-    hasOverridePatch(channel, midiNote)
-    {
-        const bank = this._keyMappings[channel]?.[midiNote]?.patch?.bank;
-        return bank !== undefined && bank >= 0;
-    }
-    
-    /**
-     * @param channel {number}
-     * @param midiNote {number}
-     * @returns {{bank: number, program: number}} -1 if unchanged
-     */
-    getPatch(channel, midiNote)
-    {
-        const modifier = this._keyMappings[channel]?.[midiNote];
-        if (modifier)
-        {
-            return modifier.patch;
-        }
-        throw new Error("No modifier.");
-    }
-    
-}

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

@@ -1,26 +0,0 @@
-/**
- * lfo.js
- * purpose: low frequency triangel oscillator
- */
-
-/**
- * Calculates a triangular wave value for the given time
- * @param startTime {number} seconds
- * @param frequency {number} Hz
- * @param currentTime {number} seconds
- * @return {number} the value from -1 to 1
- */
-export function getLFOValue(startTime, frequency, currentTime)
-{
-    if (currentTime < startTime)
-    {
-        return 0;
-    }
-    
-    const xVal = (currentTime - startTime) / (1 / frequency) + 0.25;
-    // offset by -0.25, otherwise we start at -1 and can have unexpected jump in pitch or low-pass
-    // (happened with Synth Strings 2)
-    
-    // triangle, not sine
-    return Math.abs(xVal - (~~(xVal + 0.5))) * 4 - 1;
-}