spessasynth_core 1.1.3 → 1.1.5

package/{spessasynth_core/synthetizer/worklet_system/worklet_utilities → src/synthetizer/audio_engine/engine_components}/modulator_curves.js

@@ -1,4 +1,4 @@
-import { modulatorCurveTypes } from '../../../soundfont/chunk/modulators.js'
+import { modulatorCurveTypes } from "../../../soundfont/basic_soundfont/modulator.js";
 
 /**
  * modulator_curves.js
@@ -8,22 +8,21 @@ import { modulatorCurveTypes } from '../../../soundfont/chunk/modulators.js'
 // the length of the precomputed curve tables
 export const MOD_PRECOMPUTED_LENGTH = 16384;
 
-// Precalculate lookup tables for concave and convers
-const concave = new Float32Array(MOD_PRECOMPUTED_LENGTH);
-const convex = new Float32Array(MOD_PRECOMPUTED_LENGTH);
+// 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, this:
-// https://github.com/FluidSynth/fluidsynth/blob/cb8da1e1e2c0a5cff2bab6a419755b598b793384/src/gentables/gen_conv.c#L55
+// more precisely, the gen_conv.c file
 concave[0] = 0;
-concave[MOD_PRECOMPUTED_LENGTH - 1] = 1;
+concave[concave.length - 1] = 1;
 
 convex[0] = 0;
-convex[MOD_PRECOMPUTED_LENGTH - 1] = 1;
-for(let i = 1; i < MOD_PRECOMPUTED_LENGTH - 1; i++)
+convex[convex.length - 1] = 1;
+for (let i = 1; i < MOD_PRECOMPUTED_LENGTH - 1; i++)
 {
-    let x = (-200 * 2 / 960) * Math.log(i / (MOD_PRECOMPUTED_LENGTH - 1)) / Math.LN10;
+    let x = (-200 * 2 / 960) * Math.log(i / (concave.length - 1)) / Math.LN10;
     convex[i] = 1 - x;
-    concave[MOD_PRECOMPUTED_LENGTH - 1 - i] = x;
+    concave[concave.length - 1 - i] = x;
 }
 
 /**
@@ -32,52 +31,56 @@ for(let i = 1; i < MOD_PRECOMPUTED_LENGTH - 1; i++)
  * @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
+ * @returns {number} the transformed value, 0 to 1, or -1 to 1
  */
-export function getModulatorCurveValue(direction, curveType, value, polarity) {
+export function getModulatorCurveValue(direction, curveType, value, polarity)
+{
     // inverse the value if needed
-    if(direction)
+    if (direction)
     {
-        value = 1 - value
+        value = 1 - value;
     }
-    switch (curveType) {
+    switch (curveType)
+    {
         case modulatorCurveTypes.linear:
-            if (polarity) {
-                // bipolar
+            if (polarity)
+            {
+                // bipolar curve
                 return value * 2 - 1;
             }
             return value;
-
+        
         case modulatorCurveTypes.switch:
             // switch
             value = value > 0.5 ? 1 : 0;
-            if (polarity) {
+            if (polarity)
+            {
                 // multiply
                 return value * 2 - 1;
             }
             return value;
-
+        
         case modulatorCurveTypes.concave:
             // look up the value
-            if(polarity)
+            if (polarity)
             {
                 value = value * 2 - 1;
-                if(value < 0)
+                if (value < 0)
                 {
-                    return 1 - concave[~~(value * -MOD_PRECOMPUTED_LENGTH)] - 1;
+                    return -concave[~~(value * -MOD_PRECOMPUTED_LENGTH)];
                 }
-                return concave[~~value * MOD_PRECOMPUTED_LENGTH];
+                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)
+            if (polarity)
             {
                 value = value * 2 - 1;
-                if(value < 0)
+                if (value < 0)
                 {
-                    return 1 - convex[~~(value * -MOD_PRECOMPUTED_LENGTH)] - 1;
+                    return -convex[~~(value * -MOD_PRECOMPUTED_LENGTH)];
                 }
                 return convex[~~(value * MOD_PRECOMPUTED_LENGTH)];
             }

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

@@ -0,0 +1,221 @@
+import { SpessaSynthWarn } from "../../../utils/loggin.js";
+import { loadSoundFont } from "../../../soundfont/load_soundfont.js";
+import { isXGDrums } from "../../../utils/xg_hacks.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 WorkletSoundfontManager
+{
+    /**
+     * Creates a new instance of worklet soundfont manager (worklet scope)
+     * @param initialSoundFontBuffer {ArrayBuffer} Array buffer of the soundfont. This soudfont always has the id "main"
+     */
+    constructor(initialSoundFontBuffer)
+    {
+        this.reloadManager(initialSoundFontBuffer);
+    }
+    
+    generatePresetList()
+    {
+        /**
+         * <"bank-program", "presetName">
+         * @type {Object<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 presetString = `${p.bank + font.bankOffset}-${p.program}`;
+                if (presets.has(presetString))
+                {
+                    continue;
+                }
+                presets.add(presetString);
+                presetList[presetString] = p.presetName;
+            }
+        }
+        
+        /**
+         * @type {{bank: number, presetName: string, program: number}[]}
+         */
+        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])
+            });
+        }
+    }
+    
+    /**
+     * Get the final preset list
+     * @returns {{bank: number, presetName: string, program: number}[]}
+     */
+    getPresetList()
+    {
+        return this.presetList.slice();
+    }
+    
+    /**
+     * Clears all soundfonts and adds a new one
+     * @param soundFontArrayBuffer {ArrayBuffer}
+     */
+    reloadManager(soundFontArrayBuffer)
+    {
+        const font = loadSoundFont(soundFontArrayBuffer);
+        /**
+         * All the soundfonts, ordered from the most important to the least.
+         * @type {SoundFontType[]}
+         */
+        this.soundfontList = [];
+        this.soundfontList.push({
+            id: "main",
+            bankOffset: 0,
+            soundfont: font
+        });
+        this.generatePresetList();
+    }
+    
+    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)
+        {
+            SpessaSynthWarn(`No soundfont with id of "${id}" found. Aborting!`);
+            return;
+        }
+        delete this.soundfontList[index].soundfont.presets;
+        delete this.soundfontList[index].soundfont.instruments;
+        delete this.soundfontList[index].soundfont.samples;
+        this.soundfontList.splice(index, 1);
+        this.generatePresetList();
+    }
+    
+    /**
+     * Adds a new soundfont buffer with a given ID
+     * @param buffer {ArrayBuffer}
+     * @param id {string}
+     * @param bankOffset {number}
+     */
+    addNewSoundFont(buffer, id, bankOffset)
+    {
+        if (this.soundfontList.find(s => s.id === id) !== undefined)
+        {
+            throw new Error("Cannot overwrite the existing soundfont. Use soundfontManager.delete(id) instead.");
+        }
+        this.soundfontList.push({
+            id: id,
+            soundfont: loadSoundFont(buffer),
+            bankOffset: bankOffset
+        });
+        this.generatePresetList();
+    }
+    
+    /**
+     * 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 {BasicPreset} the preset
+     */
+    getPreset(bankNumber, programNumber, allowXGDrums = false)
+    {
+        if (this.soundfontList.length < 1)
+        {
+            throw new Error("No soundfonts! This should never happen.");
+        }
+        for (const sf of this.soundfontList)
+        {
+            // check for the preset (with given offset)
+            const preset = sf.soundfont.getPresetNoFallback(
+                bankNumber - sf.bankOffset,
+                programNumber,
+                allowXGDrums
+            );
+            if (preset !== undefined)
+            {
+                return preset;
+            }
+            // if not found, advance to the next soundfont
+        }
+        const isDrum = bankNumber === 128 || (allowXGDrums && isXGDrums(bankNumber));
+        // 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;
+                }
+            }
+            // if nothing at all, use the first preset
+            return this.soundfontList[0].soundfont.presets[0];
+        }
+        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 p;
+                }
+                // check for any drum preset
+                const preset = sf.soundfont.presets.find(p => p.isDrumPreset(allowXGDrums));
+                if (preset)
+                {
+                    return preset;
+                }
+            }
+            // if nothing at all, use the first preset
+            return this.soundfontList[0].soundfont.presets[0];
+        }
+    }
+    
+    destroyManager()
+    {
+        this.soundfontList.forEach(s =>
+        {
+            s.soundfont.destroySoundBank();
+        });
+        delete this.soundfontList;
+    }
+}

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

@@ -0,0 +1,120 @@
+import { generatorTypes } from "../../../soundfont/basic_soundfont/generator.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;
+
+export const WORKLET_SYSTEM_REVERB_DIVIDER = 4600;
+export const WORKLET_SYSTEM_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
+ * @this {MidiAudioChannel}
+ */
+export function panVoice(voice,
+                         inputBuffer,
+                         outputLeft, outputRight,
+                         reverbLeft, reverbRight,
+                         chorusLeft, chorusRight)
+{
+    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 * gain * (reverbSend / WORKLET_SYSTEM_REVERB_DIVIDER);
+            for (let i = 0; i < inputBuffer.length; i++)
+            {
+                reverbLeft[i] += reverbGain * inputBuffer[i];
+            }
+            // copy as its mono
+            reverbRight.set(reverbLeft);
+        }
+        
+        const chorusSend = voice.modulatedGenerators[generatorTypes.chorusEffectsSend];
+        if (chorusSend > 0)
+        {
+            // chorus is stereo so we do not need to
+            const chorusGain = this.synth.chorusGain * chorusSend / 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];
+            }
+        }
+    }
+    
+    // mix down the audio data
+    if (gainLeft > 0)
+    {
+        for (let i = 0; i < inputBuffer.length; i++)
+        {
+            outputLeft[i] += gainLeft * inputBuffer[i];
+        }
+    }
+    if (gainRight > 0)
+    {
+        for (let i = 0; i < inputBuffer.length; i++)
+        {
+            outputRight[i] += gainRight * inputBuffer[i];
+        }
+    }
+}

package/{spessasynth_core/synthetizer/worklet_system/worklet_utilities → src/synthetizer/audio_engine/engine_components}/unit_converter.js

@@ -8,7 +8,8 @@
 const MIN_TIMECENT = -15000;
 const MAX_TIMECENT = 15000;
 const timecentLookupTable = new Float32Array(MAX_TIMECENT - MIN_TIMECENT + 1);
-for (let i = 0; i < timecentLookupTable.length; i++) {
+for (let i = 0; i < timecentLookupTable.length; i++)
+{
     const timecents = MIN_TIMECENT + i;
     timecentLookupTable[i] = Math.pow(2, timecents / 1200);
 }
@@ -20,6 +21,10 @@ for (let i = 0; i < timecentLookupTable.length; i++) {
  */
 export function timecentsToSeconds(timecents)
 {
+    if (timecents <= -32767)
+    {
+        return 0;
+    }
     return timecentLookupTable[timecents - MIN_TIMECENT];
 }
 
@@ -27,7 +32,8 @@ export function timecentsToSeconds(timecents)
 const MIN_ABS_CENT = -20000; // freqVibLfo
 const MAX_ABS_CENT = 16500; // filterFc
 const absoluteCentLookupTable = new Float32Array(MAX_ABS_CENT - MIN_ABS_CENT + 1);
-for (let i = 0; i < absoluteCentLookupTable.length; i++) {
+for (let i = 0; i < absoluteCentLookupTable.length; i++)
+{
     const absoluteCents = MIN_ABS_CENT + i;
     absoluteCentLookupTable[i] = 440 * Math.pow(2, (absoluteCents - 6900) / 1200);
 }
@@ -39,7 +45,7 @@ for (let i = 0; i < absoluteCentLookupTable.length; i++) {
  */
 export function absCentsToHz(cents)
 {
-    if(cents < MIN_ABS_CENT || cents > MAX_ABS_CENT)
+    if (cents < MIN_ABS_CENT || cents > MAX_ABS_CENT)
     {
         return 440 * Math.pow(2, (cents - 6900) / 1200);
     }
@@ -50,7 +56,8 @@ export function absCentsToHz(cents)
 const MIN_DECIBELS = -1660;
 const MAX_DECIBELS = 1600;
 const decibelLookUpTable = new Float32Array((MAX_DECIBELS - MIN_DECIBELS) * 100 + 1);
-for (let i = 0; i < decibelLookUpTable.length; i++) {
+for (let i = 0; i < decibelLookUpTable.length; i++)
+{
     const decibels = (MIN_DECIBELS * 100 + i) / 100;
     decibelLookUpTable[i] = Math.pow(10, -decibels / 20);
 }