spessasynth_lib 3.25.22 → 3.26.0

package/synthetizer/audio_effects/reverb.js

@@ -1,35 +0,0 @@
-import { reverbBufferBinary } from "./reverb_as_binary.js";
-
-/**
- * Creates a reverb processor
- * @param context {BaseAudioContext}
- * @param reverbBuffer {AudioBuffer}
- * @returns {{conv: ConvolverNode, promise: Promise<AudioBuffer>}}
- */
-export function getReverbProcessor(context, reverbBuffer = undefined)
-{
-    let solve;
-    /**
-     * @type {Promise<AudioBuffer>}
-     */
-    let promise = new Promise(r => solve = r);
-    const convolver = context.createConvolver();
-    if (reverbBuffer)
-    {
-        convolver.buffer = reverbBuffer;
-        solve();
-    }
-    else
-    {
-        // decode
-        promise = context.decodeAudioData(reverbBufferBinary.slice(0));
-        promise.then(b =>
-        {
-            convolver.buffer = b;
-        });
-    }
-    return {
-        conv: convolver,
-        promise: promise
-    };
-}

package/synthetizer/audio_effects/reverb_as_binary.js

@@ -1,18 +0,0 @@
-import { rbCompressed } from "./rb_compressed.min.js";
-import { inflateSync } from "../../externals/fflate/fflate.min.js";
-
-// convert the base64 string to array buffer
-const binaryString = atob(rbCompressed);
-const binary = new Uint8Array(binaryString.length);
-for (let i = 0; i < binaryString.length; i++)
-{
-    binary[i] = binaryString.charCodeAt(i);
-}
-
-
-/**
- * the reverb is zlib compressed, decompress here
- * @type {ArrayBuffer}
- */
-const reverbBufferBinary = inflateSync(binary).buffer;
-export { reverbBufferBinary };

package/synthetizer/audio_engine/README.md

@@ -1,25 +0,0 @@
-## This is the synthesis engine folder.
-
-The code here is responsible for a single midi channel, synthesizing the sound to it.
-
-- `engine_methods` contains the methods for the `main_processor.js`
-- `engine_components` contains the various digital signal processing functions such as the wavetable oscillator, low
-  pass filter, etc.
-
-For those interested, `render_voice.js` file contains the actual DSP synthesis code.
-
-`minify_processor.js` uses esbuild to minify the processor code. Importing this instead of `worklet_processor.js` is
-recommended.
-
-## How it works in spessasynth_lib
-Both `Synthetizer` and `Sequencer` are essentially "remote control"
-for the actual sequencer and synthesizer in the audio worklet thread (here)
-These core components are wrapped in the AudioWorkletProcessor, which is receiving both commands and data (MIDIs, sound banks)
-through the message port, and sends data back (events, time changes, status changes, etc.).
-
-For example,
-the playback to WebMIDIAPI is actually the sequencer in the worklet thread
-playing back the sequence and then postMessaging the commands through the synthesizer to the sequencer
-which actually sends them to the specified output.
-
-The wonders of separate audio thread...

package/synthetizer/audio_engine/engine_components/compute_modulator.js

@@ -1,266 +0,0 @@
-import { getModulatorCurveValue, MOD_PRECOMPUTED_LENGTH } from "./modulator_curves.js";
-import { VolumeEnvelope } from "./volume_envelope.js";
-import { ModulationEnvelope } from "./modulation_envelope.js";
-import { generatorLimits, generatorTypes } from "../../../soundfont/basic_soundfont/generator.js";
-import { Modulator, modulatorSources } from "../../../soundfont/basic_soundfont/modulator.js";
-import { NON_CC_INDEX_OFFSET } from "./controller_tables.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-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];
-    
-    // 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);
-    }
-    
-    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 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 = voice.modulators;
-    const generators = voice.generators;
-    const modulatedGenerators = voice.modulatedGenerators;
-    
-    if (sourceUsesCC === -1)
-    {
-        // All modulators mode: compute all modulators
-        modulatedGenerators.set(generators);
-        modulators.forEach(mod =>
-        {
-            const limits = generatorLimits[mod.modulatorDestination];
-            const newValue = modulatedGenerators[mod.modulatorDestination] + computeModulator(
-                controllerTable,
-                mod,
-                voice
-            );
-            modulatedGenerators[mod.modulatorDestination] = Math.max(
-                limits.min,
-                Math.min(newValue, limits.max)
-            );
-        });
-        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(controllerTable, mod, voice);
-                // sum the values of all modulators for this destination
-                modulators.forEach(m =>
-                {
-                    if (m.modulatorDestination === destination)
-                    {
-                        const limits = generatorLimits[mod.modulatorDestination];
-                        const newValue = modulatedGenerators[mod.modulatorDestination] + m.currentValue;
-                        modulatedGenerators[mod.modulatorDestination] = Math.max(
-                            limits.min,
-                            Math.min(newValue, 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/synthetizer/audio_engine/engine_components/controller_tables.js

@@ -1,88 +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
-};
-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/synthetizer/audio_engine/engine_components/key_modifier_manager.js

@@ -1,149 +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;
-    }
-}
-
-/**
- * @enum {number}
- */
-export const workletKeyModifierMessageType = {
-    addMapping: 0,    // [channel<number>, midiNote<number>, mapping<KeyModifier>]
-    deleteMapping: 1, // [channel<number>, midiNote<number>]
-    clearMappings: 2 // <no data>
-};
-
-export class KeyModifierManager
-{
-    /**
-     * The velocity override mappings for MIDI keys
-     * @type {KeyModifier[][]}
-     * @private
-     */
-    _keyMappings = [];
-    
-    /**
-     * @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;
-    }
-    
-    deleteMapping(channel, midiNote)
-    {
-        if (this._keyMappings[channel]?.[midiNote] === undefined)
-        {
-            return;
-        }
-        this._keyMappings[channel][midiNote] = undefined;
-    }
-    
-    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/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;
-}