spessasynth_core 1.1.3 → 1.1.5

package/src/soundfont/basic_soundfont/generator.js

@@ -0,0 +1,220 @@
+/**
+ * @enum {number}
+ */
+export const generatorTypes = {
+    INVALID: -1,                        // invalid generator
+    startAddrsOffset: 0,                // sample control - moves sample start point
+    endAddrOffset: 1,                   // sample control - moves sample end point
+    startloopAddrsOffset: 2,            // loop control - moves loop start point
+    endloopAddrsOffset: 3,              // loop control - moves loop end point
+    startAddrsCoarseOffset: 4,          // sample control - moves sample start point in 32,768 increments
+    modLfoToPitch: 5,                   // pitch modulation - modulation lfo pitch modulation in cents
+    vibLfoToPitch: 6,                   // pitch modulation - vibrato lfo pitch modulation in cents
+    modEnvToPitch: 7,                   // pitch modulation - modulation envelope pitch modulation in cents
+    initialFilterFc: 8,                 // filter - lowpass filter cutoff in cents
+    initialFilterQ: 9,                  // filter - lowpass filter resonance
+    modLfoToFilterFc: 10,               // filter modulation - modulation lfo lowpass filter cutoff in cents
+    modEnvToFilterFc: 11,               // filter modulation - modulation envelope lowpass filter cutoff in cents
+    endAddrsCoarseOffset: 12,           // ample control - move sample end point in 32,768 increments
+    modLfoToVolume: 13,                 // modulation lfo - volume (tremolo), where 100 = 10dB
+    unused1: 14,                        // unused
+    chorusEffectsSend: 15,              // effect send - how much is sent to chorus 0 - 1000
+    reverbEffectsSend: 16,              // effect send - how much is sent to reverb 0 - 1000
+    pan: 17,                            // panning - where -500 = left, 0 = center, 500 = right
+    unused2: 18,                        // unused
+    unused3: 19,                        // unused
+    unused4: 20,                        // unused
+    delayModLFO: 21,                    // mod lfo - delay for mod lfo to start from zero
+    freqModLFO: 22,                     // mod lfo - frequency of mod lfo, 0 = 8.176 Hz, units: f => 1200log2(f/8.176)
+    delayVibLFO: 23,                    // vib lfo - delay for vibrato lfo to start from zero
+    freqVibLFO: 24,                     // vib lfo - frequency of vibrato lfo, 0 = 8.176Hz, unit: f => 1200log2(f/8.176)
+    delayModEnv: 25,                    // mod env - 0 = 1 s decay till mod env starts
+    attackModEnv: 26,                   // mod env - attack of mod env
+    holdModEnv: 27,                     // mod env - hold of mod env
+    decayModEnv: 28,                    // mod env - decay of mod env
+    sustainModEnv: 29,                  // mod env - sustain of mod env
+    releaseModEnv: 30,                  // mod env - release of mod env
+    keyNumToModEnvHold: 31,             // mod env - also modulating mod envelope hold with key number
+    keyNumToModEnvDecay: 32,            // mod env - also modulating mod envelope decay with key number
+    delayVolEnv: 33,                    // vol env - delay of envelope from zero (weird scale)
+    attackVolEnv: 34,                   // vol env - attack of envelope
+    holdVolEnv: 35,                     // vol env - hold of envelope
+    decayVolEnv: 36,                    // vol env - decay of envelope
+    sustainVolEnv: 37,                  // vol env - sustain of envelope
+    releaseVolEnv: 38,                  // vol env - release of envelope
+    keyNumToVolEnvHold: 39,             // vol env - key number to volume envelope hold
+    keyNumToVolEnvDecay: 40,            // vol env - key number to volume envelope decay
+    instrument: 41,                     // zone - instrument index to use for preset zone
+    reserved1: 42,                      // reserved
+    keyRange: 43,                       // zone - key range for which preset / instrument zone is active
+    velRange: 44,                       // zone - velocity range for which preset / instrument zone is active
+    startloopAddrsCoarseOffset: 45,     // sample control - moves sample loop start point in 32,768 increments
+    keyNum: 46,                         // zone - instrument only: always use this midi number (ignore what's pressed)
+    velocity: 47,                       // zone - instrument only: always use this velocity (ignore what's pressed)
+    initialAttenuation: 48,             // zone - allows turning down the volume, 10 = -1dB
+    reserved2: 49,                      // reserved
+    endloopAddrsCoarseOffset: 50,       // sample control - moves sample loop end point in 32,768 increments
+    coarseTune: 51,                     // tune - pitch offset in semitones
+    fineTune: 52,                       // tune - pitch offset in cents
+    sampleID: 53,                       // sample - instrument zone only: which sample to use
+    sampleModes: 54,                    // sample - 0 = no loop, 1 = loop, 2 = reserved, 3 = loop and play till the end in release phase
+    reserved3: 55,                      // reserved
+    scaleTuning: 56,                    // sample - the degree to which MIDI key number influences pitch, 100 = default
+    exclusiveClass: 57,                 // sample - = cut = choke group
+    overridingRootKey: 58,              // sample - can override the sample's original pitch
+    unused5: 59,                        // unused
+    endOper: 60                         // end marker
+};
+/**
+ * @type {{min: number, max: number, def: number}[]}
+ */
+export const generatorLimits = [];
+// offsets
+generatorLimits[generatorTypes.startAddrsOffset] = { min: 0, max: 32768, def: 0 };
+generatorLimits[generatorTypes.endAddrOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.startloopAddrsOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.endloopAddrsOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.startAddrsCoarseOffset] = { min: 0, max: 32768, def: 0 };
+
+// pitch influence
+generatorLimits[generatorTypes.modLfoToPitch] = { min: -12000, max: 12000, def: 0 };
+generatorLimits[generatorTypes.vibLfoToPitch] = { min: -12000, max: 12000, def: 0 };
+generatorLimits[generatorTypes.modEnvToPitch] = { min: -12000, max: 12000, def: 0 };
+
+// lowpass
+generatorLimits[generatorTypes.initialFilterFc] = { min: 1500, max: 13500, def: 13500 };
+generatorLimits[generatorTypes.initialFilterQ] = { min: 0, max: 960, def: 0 };
+generatorLimits[generatorTypes.modLfoToFilterFc] = { min: -12000, max: 12000, def: 0 };
+generatorLimits[generatorTypes.modEnvToFilterFc] = { min: -12000, max: 12000, def: 0 };
+
+generatorLimits[generatorTypes.endAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
+
+generatorLimits[generatorTypes.modLfoToVolume] = { min: -960, max: 960, def: 0 };
+
+// effects, pan
+generatorLimits[generatorTypes.chorusEffectsSend] = { min: 0, max: 1000, def: 0 };
+generatorLimits[generatorTypes.reverbEffectsSend] = { min: 0, max: 1000, def: 0 };
+generatorLimits[generatorTypes.pan] = { min: -500, max: 500, def: 0 };
+
+// lfo
+generatorLimits[generatorTypes.delayModLFO] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.freqModLFO] = { min: -16000, max: 4500, def: 0 };
+generatorLimits[generatorTypes.delayVibLFO] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.freqVibLFO] = { min: -16000, max: 4500, def: 0 };
+
+// mod env
+generatorLimits[generatorTypes.delayModEnv] = { min: -32768, max: 5000, def: -32768 }; // -32,768 indicates instant phase,
+// this is done to prevent click at the start of filter modenv
+generatorLimits[generatorTypes.attackModEnv] = { min: -32768, max: 8000, def: -32768 };
+generatorLimits[generatorTypes.holdModEnv] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.decayModEnv] = { min: -12000, max: 8000, def: -12000 };
+generatorLimits[generatorTypes.sustainModEnv] = { min: 0, max: 1000, def: 0 };
+generatorLimits[generatorTypes.releaseModEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200 to prevent lowpass clicks
+// key num to mod env
+generatorLimits[generatorTypes.keyNumToModEnvHold] = { min: -1200, max: 1200, def: 0 };
+generatorLimits[generatorTypes.keyNumToModEnvDecay] = { min: -1200, max: 1200, def: 0 };
+
+// vol env
+generatorLimits[generatorTypes.delayVolEnv] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.attackVolEnv] = { min: -12000, max: 8000, def: -12000 };
+generatorLimits[generatorTypes.holdVolEnv] = { min: -12000, max: 5000, def: -12000 };
+generatorLimits[generatorTypes.decayVolEnv] = { min: -12000, max: 8000, def: -12000 };
+generatorLimits[generatorTypes.sustainVolEnv] = { min: 0, max: 1440, def: 0 };
+generatorLimits[generatorTypes.releaseVolEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200 prevent clicks
+// key num to vol env
+generatorLimits[generatorTypes.keyNumToVolEnvHold] = { min: -1200, max: 1200, def: 0 };
+generatorLimits[generatorTypes.keyNumToVolEnvDecay] = { min: -1200, max: 1200, def: 0 };
+
+generatorLimits[generatorTypes.startloopAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
+generatorLimits[generatorTypes.keyNum] = { min: -1, max: 127, def: -1 };
+generatorLimits[generatorTypes.velocity] = { min: -1, max: 127, def: -1 };
+
+generatorLimits[generatorTypes.initialAttenuation] = { min: 0, max: 1440, def: 0 };
+
+generatorLimits[generatorTypes.endloopAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
+
+generatorLimits[generatorTypes.coarseTune] = { min: -120, max: 120, def: 0 };
+generatorLimits[generatorTypes.fineTune] = { min: -12700, max: 12700, def: 0 }; // this generator is used as initial pitch, hence this range
+generatorLimits[generatorTypes.scaleTuning] = { min: 0, max: 1200, def: 100 };
+generatorLimits[generatorTypes.exclusiveClass] = { min: 0, max: 99999, def: 0 };
+generatorLimits[generatorTypes.overridingRootKey] = { min: 0 - 1, max: 127, def: -1 };
+generatorLimits[generatorTypes.sampleModes] = { min: 0, max: 3, def: 0 };
+
+export class Generator
+{
+    /**
+     * The generator's enum number
+     * @type {generatorTypes|number}
+     */
+    generatorType = generatorTypes.INVALID;
+    /**
+     * The generator's 16-bit value
+     * @type {number}
+     */
+    generatorValue = 0;
+    
+    /**
+     * Constructs a new generator
+     * @param type {generatorTypes|number}
+     * @param value {number}
+     * @param validate {boolean}
+     */
+    constructor(type = generatorTypes.INVALID, value = 0, validate = true)
+    {
+        this.generatorType = type;
+        if (value === undefined)
+        {
+            throw new Error("No value provided.");
+        }
+        this.generatorValue = Math.round(value);
+        if (validate)
+        {
+            const lim = generatorLimits[type];
+            
+            if (lim !== undefined)
+            {
+                this.generatorValue = Math.max(lim.min, Math.min(lim.max, this.generatorValue));
+            }
+        }
+    }
+}
+
+/**
+ * generator.js
+ * purpose: contains enums for generators,
+ * and their limis parses reads soundfont generators, sums them and applies limits
+ */
+/**
+ * @param generatorType {number}
+ * @param presetGens {Generator[]}
+ * @param instrumentGens {Generator[]}
+ */
+export function addAndClampGenerator(generatorType, presetGens, instrumentGens)
+{
+    const limits = generatorLimits[generatorType] || { min: 0, max: 32768, def: 0 };
+    let presetGen = presetGens.find(g => g.generatorType === generatorType);
+    let presetValue = 0;
+    if (presetGen)
+    {
+        presetValue = presetGen.generatorValue;
+    }
+    
+    let instruGen = instrumentGens.find(g => g.generatorType === generatorType);
+    let instruValue = limits.def;
+    if (instruGen)
+    {
+        instruValue = instruGen.generatorValue;
+    }
+    
+    let value = instruValue + presetValue;
+    
+    // Special case, initial attenuation.
+    // Shall get clamped in the volume envelope,
+    // so the modulators can be affected by negative generators (the "Brass" patch was problematic...)
+    if (generatorType === generatorTypes.initialAttenuation)
+    {
+        return value;
+    }
+    
+    return Math.max(limits.min, Math.min(limits.max, value));
+}

package/src/soundfont/basic_soundfont/modulator.js

@@ -0,0 +1,378 @@
+import { generatorTypes } from "./generator.js";
+import { midiControllers } from "../../midi/midi_message.js";
+
+/**
+ * modulators.js
+ * purpose: parses soundfont modulators and the source enums, also includes the default modulators list
+ **/
+
+export const modulatorSources = {
+    noController: 0,
+    noteOnVelocity: 2,
+    noteOnKeyNum: 3,
+    polyPressure: 10,
+    channelPressure: 13,
+    pitchWheel: 14,
+    pitchWheelRange: 16,
+    link: 127
+    
+};
+export const modulatorCurveTypes = {
+    linear: 0,
+    concave: 1,
+    convex: 2,
+    switch: 3
+};
+
+export class Modulator
+{
+    /**
+     * The current computed value of this modulator
+     * @type {number}
+     */
+    currentValue = 0;
+    
+    /**
+     * The source enumeration for this modulator
+     * @type {number}
+     */
+    sourceEnum;
+    
+    /**
+     * The secondary source enumeration for this modulator
+     * @type {number}
+     */
+    secondarySourceEnum;
+    
+    /**
+     * The generator destination of this modulator
+     * @type {generatorTypes}
+     */
+    modulatorDestination;
+    
+    /**
+     * The transform amount for this modulator
+     * @type {number}
+     */
+    transformAmount;
+    
+    /**
+     * The transform type for this modulator
+     * @type {0|2}
+     */
+    transformType;
+    
+    /**
+     * creates a modulator
+     * @param srcEnum {number}
+     * @param secSrcEnum {number}
+     * @param destination {generatorTypes|number}
+     * @param amount {number}
+     * @param transformType {number}
+     */
+    constructor(srcEnum, secSrcEnum, destination, amount, transformType)
+    {
+        this.sourceEnum = srcEnum;
+        this.modulatorDestination = destination;
+        this.secondarySourceEnum = secSrcEnum;
+        this.transformAmount = amount;
+        this.transformType = transformType;
+        
+        
+        if (this.modulatorDestination > 58)
+        {
+            this.modulatorDestination = generatorTypes.INVALID; // flag as invalid (for linked ones)
+        }
+        
+        // decode the source
+        this.sourcePolarity = this.sourceEnum >> 9 & 1;
+        this.sourceDirection = this.sourceEnum >> 8 & 1;
+        this.sourceUsesCC = this.sourceEnum >> 7 & 1;
+        this.sourceIndex = this.sourceEnum & 127;
+        this.sourceCurveType = this.sourceEnum >> 10 & 3;
+        
+        // decode the secondary source
+        this.secSrcPolarity = this.secondarySourceEnum >> 9 & 1;
+        this.secSrcDirection = this.secondarySourceEnum >> 8 & 1;
+        this.secSrcUsesCC = this.secondarySourceEnum >> 7 & 1;
+        this.secSrcIndex = this.secondarySourceEnum & 127;
+        this.secSrcCurveType = this.secondarySourceEnum >> 10 & 3;
+        
+        /**
+         * Indicates if the given modulator is chorus or reverb effects modulator.
+         * This is done to simulate BASSMIDI effects behavior:
+         * - defaults to 1000 transform amount rather than 200
+         * - values can be changed, but anything above 200 is 1000
+         * (except for values above 1000, they are copied directly)
+         * - all values below are multiplied by 5 (200 * 5 = 1000)
+         * - still can be disabled if the soundfont has its own modulator curve
+         * - this fixes the very low amount of reverb by default and doesn't break soundfonts
+         * @type {boolean}
+         */
+        this.isEffectModulator =
+            (
+                this.sourceEnum === 0x00DB
+                || this.sourceEnum === 0x00DD
+            )
+            && this.secondarySourceEnum === 0x0
+            && (
+                this.modulatorDestination === generatorTypes.reverbEffectsSend
+                || this.modulatorDestination === generatorTypes.chorusEffectsSend
+            );
+    }
+    
+    /**
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    static copy(modulator)
+    {
+        return new Modulator(
+            modulator.sourceEnum,
+            modulator.secondarySourceEnum,
+            modulator.modulatorDestination,
+            modulator.transformAmount,
+            modulator.transformType
+        );
+    }
+    
+    /**
+     * @param mod1 {Modulator}
+     * @param mod2 {Modulator}
+     * @param checkAmount {boolean}
+     * @returns {boolean}
+     */
+    static isIdentical(mod1, mod2, checkAmount = false)
+    {
+        return (mod1.sourceEnum === mod2.sourceEnum)
+            && (mod1.modulatorDestination === mod2.modulatorDestination)
+            && (mod1.secondarySourceEnum === mod2.secondarySourceEnum)
+            && (mod1.transformType === mod2.transformType)
+            && (!checkAmount || (mod1.transformAmount === mod2.transformAmount));
+    }
+    
+    /**
+     * @param mod {Modulator}
+     * @returns {string}
+     */
+    static debugString(mod)
+    {
+        function getKeyByValue(object, value)
+        {
+            return Object.keys(object).find(key => object[key] === value);
+        }
+        
+        let sourceString = getKeyByValue(modulatorCurveTypes, mod.sourceCurveType);
+        sourceString += mod.sourcePolarity === 0 ? " unipolar " : " bipolar ";
+        sourceString += mod.sourceDirection === 0 ? "forwards " : "backwards ";
+        if (mod.sourceUsesCC)
+        {
+            sourceString += getKeyByValue(midiControllers, mod.sourceIndex);
+        }
+        else
+        {
+            sourceString += getKeyByValue(modulatorSources, mod.sourceIndex);
+        }
+        
+        let secSrcString = getKeyByValue(modulatorCurveTypes, mod.secSrcCurveType);
+        secSrcString += mod.secSrcPolarity === 0 ? " unipolar " : " bipolar ";
+        secSrcString += mod.secSrcCurveType === 0 ? "forwards " : "backwards ";
+        if (mod.secSrcUsesCC)
+        {
+            secSrcString += getKeyByValue(midiControllers, mod.secSrcIndex);
+        }
+        else
+        {
+            secSrcString += getKeyByValue(modulatorSources, mod.secSrcIndex);
+        }
+        return `Modulator:
+        Source: ${sourceString}
+        Secondary source: ${secSrcString}
+        Destination: ${getKeyByValue(generatorTypes, mod.modulatorDestination)}
+        Trasform amount: ${mod.transformAmount}
+        Transform type: ${mod.transformType}
+        \n\n`;
+    }
+    
+    /**
+     * Sum transform and create a NEW modulator
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    sumTransform(modulator)
+    {
+        return new Modulator(
+            this.sourceEnum,
+            this.secondarySourceEnum,
+            this.modulatorDestination,
+            this.transformAmount + modulator.transformAmount,
+            this.transformType
+        );
+    }
+}
+
+export const DEFAULT_ATTENUATION_MOD_AMOUNT = 960;
+export const DEFAULT_ATTENUATION_MOD_CURVE_TYPE = modulatorCurveTypes.concave;
+
+export function getModSourceEnum(curveType, polarity, direction, isCC, index)
+{
+    return (curveType << 10) | (polarity << 9) | (direction << 8) | (isCC << 7) | index;
+}
+
+const soundFontModulators = [
+    // vel to attenuation
+    new Modulator(
+        getModSourceEnum(
+            DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
+            0,
+            1,
+            0,
+            modulatorSources.noteOnVelocity
+        ),
+        0x0,
+        generatorTypes.initialAttenuation,
+        DEFAULT_ATTENUATION_MOD_AMOUNT,
+        0
+    ),
+    
+    // mod wheel to vibrato
+    new Modulator(0x0081, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    
+    // vol to attenuation
+    new Modulator(
+        getModSourceEnum(
+            DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
+            0,
+            1,
+            1,
+            midiControllers.mainVolume
+        ),
+        0x0,
+        generatorTypes.initialAttenuation,
+        DEFAULT_ATTENUATION_MOD_AMOUNT,
+        0
+    ),
+    
+    // channel pressure to vibrato
+    new Modulator(0x000D, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    
+    // pitch wheel to tuning
+    new Modulator(0x020E, 0x0010, generatorTypes.fineTune, 12700, 0),
+    
+    // pan to uhh, pan
+    // amount is 500 instead of 1000, see #59
+    new Modulator(0x028A, 0x0, generatorTypes.pan, 500, 0),
+    
+    // expression to attenuation
+    new Modulator(
+        getModSourceEnum(
+            DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
+            0,
+            1,
+            1,
+            midiControllers.expressionController
+        ),
+        0x0,
+        generatorTypes.initialAttenuation,
+        DEFAULT_ATTENUATION_MOD_AMOUNT,
+        0
+    ),
+    
+    // reverb effects to send
+    new Modulator(0x00DB, 0x0, generatorTypes.reverbEffectsSend, 200, 0),
+    
+    // chorus effects to send
+    new Modulator(0x00DD, 0x0, generatorTypes.chorusEffectsSend, 200, 0)
+];
+
+const customModulators = [
+    // custom modulators heck yeah
+    // poly pressure to vibrato
+    new Modulator(
+        getModSourceEnum(modulatorCurveTypes.linear, 0, 0, 0, modulatorSources.polyPressure),
+        0x0,
+        generatorTypes.vibLfoToPitch,
+        50,
+        0
+    ),
+    
+    // cc 92 (tremolo) to modLFO volume
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            0,
+            0,
+            1,
+            midiControllers.tremoloDepth
+        ), /*linear forward unipolar cc 92 */
+        0x0, // no controller
+        generatorTypes.modLfoToVolume,
+        24,
+        0
+    ),
+    
+    // cc 73 (attack time) to volEnv attack
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.convex,
+            1,
+            0,
+            1,
+            midiControllers.attackTime
+        ), // linear forward bipolar cc 72
+        0x0, // no controller
+        generatorTypes.attackVolEnv,
+        6000,
+        0
+    ),
+    
+    // cc 72 (release time) to volEnv release
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            1,
+            0,
+            1,
+            midiControllers.releaseTime
+        ), // linear forward bipolar cc 72
+        0x0, // no controller
+        generatorTypes.releaseVolEnv,
+        3600,
+        0
+    ),
+    
+    // cc 74 (brightness) to filterFc
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            1,
+            0,
+            1,
+            midiControllers.brightness
+        ), // linear forwards bipolar cc 74
+        0x0, // no controller
+        generatorTypes.initialFilterFc,
+        6000,
+        0
+    ),
+    
+    // cc 71 (filter Q) to filter Q
+    new Modulator(
+        getModSourceEnum(
+            modulatorCurveTypes.linear,
+            1,
+            0,
+            1,
+            midiControllers.filterResonance
+        ), // linear forwards bipolar cc 74
+        0x0, // no controller
+        generatorTypes.initialFilterQ,
+        250,
+        0
+    )
+];
+
+/**
+ * @type {Modulator[]}
+ */
+export const defaultModulators = soundFontModulators.concat(customModulators);