spessasynth_lib 3.9.9

package/soundfont/read/instruments.js

@@ -0,0 +1,125 @@
+import {RiffChunk} from "./riff_chunk.js";
+import {InstrumentZone} from "./zones.js";
+import {readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import { readBytesAsString } from '../../utils/byte_functions/string.js'
+
+/**
+ * instrument.js
+ * purpose: parses soundfont instrument and stores them as a class
+ */
+
+export class Instrument
+{
+    /**
+     * Creates an instrument
+     * @param instrumentChunk {RiffChunk}
+     */
+    constructor(instrumentChunk)
+    {
+        this.instrumentName = readBytesAsString(instrumentChunk.chunkData, 20).trim();
+        this.instrumentZoneIndex = readBytesAsUintLittleEndian(instrumentChunk.chunkData, 2);
+        this.instrumentZonesAmount = 0;
+        /**
+         * @type {InstrumentZone[]}
+         */
+        this.instrumentZones = [];
+        this._useCount = 0;
+    }
+
+    addUseCount()
+    {
+        this._useCount++;
+        this.instrumentZones.forEach(z => z.useCount++);
+    }
+
+    removeUseCount()
+    {
+        this._useCount--;
+        for(let i = 0; i < this.instrumentZones.length; i++)
+        {
+            if(this.safeDeleteZone(i))
+            {
+                i--;
+            }
+        }
+    }
+
+    /**
+     * @returns {number}
+     */
+    get useCount()
+    {
+        return this._useCount;
+    }
+
+    deleteInstrument()
+    {
+        this.instrumentZones.forEach(z => z.deleteZone());
+        this.instrumentZones.length = 0;
+    }
+
+    /**
+     * @param index {number}
+     * @returns {boolean} is the zone has been deleted
+     */
+    safeDeleteZone(index)
+    {
+        this.instrumentZones[index].useCount--;
+        if(this.instrumentZones[index].useCount < 1)
+        {
+            this.deleteZone(index);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @param index {number}
+     */
+    deleteZone(index)
+    {
+        this.instrumentZones[index].deleteZone();
+        this.instrumentZones.splice(index, 1);
+    }
+
+    /**
+     * Loads all the instrument zones, given the amount
+     * @param amount {number}
+     * @param zones {InstrumentZone[]}
+     */
+    getInstrumentZones(amount, zones)
+    {
+        this.instrumentZonesAmount = amount;
+        for(let i = this.instrumentZoneIndex; i < this.instrumentZonesAmount + this.instrumentZoneIndex; i++)
+        {
+            this.instrumentZones.push(zones[i]);
+        }
+    }
+}
+
+/**
+ * Reads the instruments
+ * @param instrumentChunk {RiffChunk}
+ * @param instrumentZones {InstrumentZone[]}
+ * @returns {Instrument[]}
+ */
+export function readInstruments(instrumentChunk, instrumentZones)
+{
+    let instruments = [];
+    while(instrumentChunk.chunkData.length > instrumentChunk.chunkData.currentIndex)
+    {
+        let instrument = new Instrument(instrumentChunk);
+        if(instruments.length > 0)
+        {
+            let instrumentsAmount = instrument.instrumentZoneIndex - instruments[instruments.length - 1].instrumentZoneIndex;
+            instruments[instruments.length - 1].getInstrumentZones(instrumentsAmount, instrumentZones);
+        }
+        instruments.push(instrument);
+    }
+    if(instruments.length > 1)
+    {
+        // remove EOI
+        instruments.pop();
+    }
+    return instruments;
+}

package/soundfont/read/modulators.js

@@ -0,0 +1,249 @@
+import {signedInt16, readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import { IndexedByteArray } from '../../utils/indexed_array.js';
+import { generatorTypes } from './generators.js'
+import { midiControllers } from '../../midi_parser/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
+}
+
+/**
+ *
+ * type, polarity, direction
+ * @type {Float32Array[][][]}
+ */
+export const precomputedTransforms = [];
+for (let i = 0; i < 4; i++) {
+    precomputedTransforms.push([[], []]);
+}
+
+export class Modulator{
+    /**
+     * Creates a modulator
+     * @param dataArray {IndexedByteArray|{srcEnum: number, secSrcEnum: number, dest:number, amt: number, transform: number}}
+     */
+    constructor(dataArray) {
+        if(dataArray.srcEnum)
+        {
+            this.modulatorSource = dataArray.srcEnum;
+            /**
+             * @type {generatorTypes}
+             */
+            this.modulatorDestination = dataArray.dest;
+            this.modulationSecondarySrc = dataArray.secSrcEnum;
+            this.transformAmount = dataArray.amt;
+            this.transformType = dataArray.transform;
+        }
+        else
+        {
+            this.modulatorSource = readBytesAsUintLittleEndian(dataArray, 2);
+            this.modulatorDestination = readBytesAsUintLittleEndian(dataArray, 2);
+            this.transformAmount = signedInt16(dataArray[dataArray.currentIndex++], dataArray[dataArray.currentIndex++]);
+            this.modulationSecondarySrc = readBytesAsUintLittleEndian(dataArray, 2);
+            this.transformType = readBytesAsUintLittleEndian(dataArray, 2);
+        }
+
+        if(this.modulatorDestination > 58)
+        {
+            this.modulatorDestination = -1; // flag as invalid (for linked ones)
+        }
+
+        // decode the source
+        this.sourcePolarity = this.modulatorSource >> 9 & 1;
+        this.sourceDirection = this.modulatorSource >> 8 & 1;
+        this.sourceUsesCC = this.modulatorSource >> 7 & 1;
+        this.sourceIndex = this.modulatorSource & 127;
+        this.sourceCurveType = this.modulatorSource >> 10 & 3;
+
+        // decode the secondary source
+        this.secSrcPolarity = this.modulationSecondarySrc >> 9 & 1;
+        this.secSrcDirection = this.modulationSecondarySrc >> 8 & 1;
+        this.secSrcUsesCC = this.modulationSecondarySrc >> 7 & 1;
+        this.secSrcIndex = this.modulationSecondarySrc & 127;
+        this.secSrcCurveType = this.modulationSecondarySrc >> 10 & 3;
+
+        //this.precomputeModulatorTransform();
+    }
+
+    /**
+     * Sums transform and creates a NEW modulator
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    sumTransform(modulator)
+    {
+        return new Modulator({
+            srcEnum: this.modulatorSource,
+            secSrcEnum: this.modulationSecondarySrc,
+            dest: this.modulatorDestination,
+            transform: this.transformType,
+            amt: this.transformAmount + modulator.transformAmount
+        });
+    }
+
+    /**
+     * @returns {string}
+     */
+    debugString()
+    {
+        function getKeyByValue(object, value)
+        {
+            return Object.keys(object).find(key => object[key] === value);
+        }
+
+        let sourceString = getKeyByValue(modulatorCurveTypes, this.sourceCurveType);
+        sourceString += this.sourcePolarity === 0 ? " unipolar " : " bipolar ";
+        sourceString += this.sourceDirection === 0 ? "forwards " : "backwards ";
+        if(this.sourceUsesCC)
+        {
+            sourceString += getKeyByValue(midiControllers, this.sourceIndex);
+        }
+        else
+        {
+            sourceString += getKeyByValue(modulatorSources, this.sourceIndex);
+        }
+
+        let secSrcString = getKeyByValue(modulatorCurveTypes, this.secSrcCurveType);
+        secSrcString += this.secSrcPolarity === 0 ? " unipolar " : " bipolar ";
+        secSrcString += this.secSrcCurveType === 0 ? "forwards " : "backwards ";
+        if(this.secSrcUsesCC)
+        {
+            secSrcString += getKeyByValue(midiControllers, this.secSrcIndex);
+        }
+        else
+        {
+            secSrcString += getKeyByValue(modulatorSources, this.secSrcIndex);
+        }
+        return `Modulator:
+        Source: ${sourceString}
+        Secondary source: ${secSrcString}
+        Destination: ${getKeyByValue(generatorTypes, this.modulatorDestination)}
+        Trasform amount: ${this.transformAmount}
+        Transform type: ${this.transformType}
+        \n\n`;
+    }
+}
+
+function getModSourceEnum(curveType, polarity, direction, isCC, index)
+{
+    return (curveType << 10) | (polarity << 9) | (direction << 8) | (isCC << 7) | index;
+}
+
+const DEFAULT_ATTENUATION_MOD_AMOUNT = 960;
+const DEFAULT_ATTENUATION_MOD_CURVE_TYPE = modulatorCurveTypes.concave;
+
+export const defaultModulators = [
+    // vel to attenuation
+    new Modulator({
+        srcEnum: getModSourceEnum(DEFAULT_ATTENUATION_MOD_CURVE_TYPE, 0, 1, 0, modulatorSources.noteOnVelocity),
+        dest: generatorTypes.initialAttenuation,
+        amt: DEFAULT_ATTENUATION_MOD_AMOUNT,
+        secSrcEnum: 0x0,
+        transform: 0}),
+
+    // mod wheel to vibrato
+    new Modulator({srcEnum: 0x0081, dest: generatorTypes.vibLfoToPitch, amt: 50, secSrcEnum: 0x0, transform: 0}),
+
+    // vol to attenuation
+    new Modulator({
+        srcEnum: getModSourceEnum(DEFAULT_ATTENUATION_MOD_CURVE_TYPE, 0, 1, 1, midiControllers.mainVolume),
+        dest: generatorTypes.initialAttenuation,
+        amt: DEFAULT_ATTENUATION_MOD_AMOUNT,
+        secSrcEnum: 0x0,
+        transform: 0}),
+
+    // channel pressure to vibrato
+    new Modulator({srcEnum: 0x000D, dest: generatorTypes.vibLfoToPitch, amt: 50, secSrcEnum: 0x0, transform: 0}),
+
+    // pitch wheel to tuning
+    new Modulator({srcEnum: 0x020E, dest: generatorTypes.fineTune, amt: 12700, secSrcEnum: 0x0010, transform: 0}),
+
+    // pan to uhh, pan
+    new Modulator({srcEnum: 0x028A, dest: generatorTypes.pan, amt: 1000, secSrcEnum: 0x0, transform: 0}),
+
+    // expression to attenuation
+    new Modulator({
+        srcEnum: getModSourceEnum(DEFAULT_ATTENUATION_MOD_CURVE_TYPE, 0, 1, 1, midiControllers.expressionController),
+        dest: generatorTypes.initialAttenuation,
+        amt: DEFAULT_ATTENUATION_MOD_AMOUNT,
+        secSrcEnum: 0x0,
+        transform: 0
+    }),
+
+    // reverb effects to send
+    // 1000 to align with the reverbSend (overriding it works anyways)
+    new Modulator({srcEnum: 0x00DB, dest: generatorTypes.reverbEffectsSend, amt: 200, secSrcEnum: 0x0, transform: 0}),
+
+    // chorus effects to send
+    new Modulator({srcEnum: 0x00DD, dest: generatorTypes.chorusEffectsSend, amt: 200, secSrcEnum: 0x0, transform: 0}),
+
+    // custom modulators heck yeah
+    // poly pressure to vibrato
+    new Modulator({
+        srcEnum: getModSourceEnum(modulatorCurveTypes.linear, 0, 0, 0, modulatorSources.polyPressure),
+        dest: generatorTypes.vibLfoToPitch,
+        amt: 50,
+        secSrcEnum: 0x0,
+        transform: 0
+    }),
+
+    // cc 92 (tremolo) to modLFO volume
+    new Modulator({
+        srcEnum: getModSourceEnum(modulatorCurveTypes.linear, 0, 0, 1, midiControllers.effects2Depth), /*linear forward unipolar cc 92 */
+        dest: generatorTypes.modLfoToVolume,
+        amt: 24,
+        secSrcEnum: 0x0, // no controller
+        transform: 0
+    }),
+
+    // cc 72 (release time) to volEnv release
+    new Modulator({
+        srcEnum: getModSourceEnum(modulatorCurveTypes.linear, 1, 0, 1, midiControllers.releaseTime), // linear forward bipolar cc 72
+        dest: generatorTypes.releaseVolEnv,
+        amt: 1200,
+        secSrcEnum: 0x0, // no controller
+        transform: 0
+    }),
+
+    // cc 74 (brightness) to filterFc
+    new Modulator({
+        srcEnum: getModSourceEnum(modulatorCurveTypes.linear, 1, 0  , 1, midiControllers.brightness), // linear forwards bipolar cc 74
+        dest: generatorTypes.initialFilterFc,
+        amt: 4000,
+        secSrcEnum: 0x0, // no controller
+        transform: 0
+    })
+];
+
+/**
+ * Reads the modulator read
+ * @param modulatorChunk {RiffChunk}
+ * @returns {Modulator[]}
+ */
+export function readModulators(modulatorChunk)
+{
+    let gens = [];
+    while(modulatorChunk.chunkData.length > modulatorChunk.chunkData.currentIndex)
+    {
+        gens.push(new Modulator(modulatorChunk.chunkData));
+    }
+    return gens;
+}

package/soundfont/read/presets.js

@@ -0,0 +1,300 @@
+import {RiffChunk} from "./riff_chunk.js";
+import {PresetZone} from "./zones.js";
+import {readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import {Sample} from "./samples.js";
+import { Generator, generatorTypes } from './generators.js'
+import { defaultModulators } from './modulators.js'
+import { readBytesAsString } from '../../utils/byte_functions/string.js'
+
+/**
+ * parses soundfont presets, also includes function for getting the generators and samples from midi note and velocity
+ */
+
+export class Preset {
+    /**
+     * Creates a preset
+     * @param presetChunk {RiffChunk}
+     */
+    constructor(presetChunk)
+    {
+        this.presetName = readBytesAsString(presetChunk.chunkData, 20)
+            .trim()
+            .replace(/\d{3}:\d{3}/, ""); // remove those pesky "000:001"
+
+        this.program = readBytesAsUintLittleEndian(presetChunk.chunkData, 2);
+        this.bank = readBytesAsUintLittleEndian(presetChunk.chunkData, 2);
+        this.presetZoneStartIndex = readBytesAsUintLittleEndian(presetChunk.chunkData, 2);
+        this.presetZonesAmount = 0;
+        /**
+         * @type {PresetZone[]}
+         */
+        this.presetZones = [];
+
+        /**
+         * Stores already found getSamplesAndGenerators for reuse
+         * @type {SampleAndGenerators[][][]}
+         */
+        this.foundSamplesAndGenerators = [];
+        for(let i = 0; i < 128; i++)
+        {
+            this.foundSamplesAndGenerators[i] = [];
+        }
+
+        // read the dwords
+        this.library = readBytesAsUintLittleEndian(presetChunk.chunkData, 4);
+        this.genre = readBytesAsUintLittleEndian(presetChunk.chunkData, 4);
+        this.morphology = readBytesAsUintLittleEndian(presetChunk.chunkData, 4);
+    }
+
+    /**
+     * Loads all the preset zones, given the amount
+     * @param amount {number}
+     * @param zones {PresetZone[]}
+     */
+    getPresetZones(amount, zones)
+    {
+        this.presetZonesAmount = amount;
+        for (let i = this.presetZoneStartIndex; i < this.presetZonesAmount + this.presetZoneStartIndex; i++)
+        {
+            this.presetZones.push(zones[i]);
+        }
+    }
+
+    deletePreset()
+    {
+        this.presetZones.forEach(z => z.deleteZone());
+        this.presetZones.length = 0;
+    }
+
+    /**
+     * @param index {number}
+     */
+    deleteZone(index)
+    {
+        this.presetZones[index].deleteZone();
+        this.presetZones.splice(index, 1);
+    }
+
+    /**
+     * Preloads all samples (async)
+     */
+    preload(keyMin, keyMax)
+    {
+        for (let key = keyMin; key < keyMax + 1; key++)
+        {
+            for (let velocity = 0; velocity < 128; velocity++)
+            {
+                this.getSamplesAndGenerators(key, velocity).forEach(samandgen => {
+                    if(!samandgen.sample.isSampleLoaded)
+                    {
+                        samandgen.sample.getAudioData();
+                    }
+                })
+            }
+        }
+    }
+
+    /**
+     * Preloads a specific key/velocity combo
+     * @param key {number}
+     * @param velocity {number}
+     */
+    preloadSpecific(key, velocity)
+    {
+        this.getSamplesAndGenerators(key, velocity).forEach(samandgen => {
+            if(!samandgen.sample.isSampleLoaded)
+            {
+                samandgen.sample.getAudioData();
+            }
+        })
+    }
+
+    /**
+     * @typedef {{
+     *  instrumentGenerators: Generator[],
+     *  presetGenerators: Generator[],
+     *  modulators: Modulator[],
+     *  sample: Sample,
+     *  sampleID: number,
+     * }} SampleAndGenerators
+     */
+
+    /**
+     * Returns generatorTranslator and generators for given note
+     * @param midiNote {number}
+     * @param velocity {number}
+     * @returns {SampleAndGenerators[]}
+     */
+    getSamplesAndGenerators(midiNote, velocity)
+    {
+        const memorized = this.foundSamplesAndGenerators[midiNote][velocity];
+        if(memorized)
+        {
+            return memorized;
+        }
+
+        function isInRange(min, max, number) {
+            return number >= min && number <= max;
+        }
+
+        /**
+         * @param mod1 {Modulator}
+         * @param mod2 {Modulator}
+         * @returns {boolean}
+         */
+        function identicalMod(mod1, mod2)
+        {
+            return (mod1.modulatorSource === mod2.modulatorSource)
+                && (mod1.modulatorDestination === mod2.modulatorDestination)
+                && (mod1.modulationSecondarySrc === mod2.modulationSecondarySrc)
+                && (mod1.transformType === mod2.transformType);
+        }
+
+        /**
+         * @param main {Generator[]}
+         * @param adder {Generator[]}
+         */
+        function addUnique(main, adder)
+        {
+            main.push(...adder.filter(g => !main.find(mg => mg.generatorType === g.generatorType)));
+        }
+
+        /**
+         * @param main {Modulator[]}
+         * @param adder {Modulator[]}
+         */
+        function addUniqueMods(main, adder)
+        {
+            main.push(...adder.filter(m => !main.find(mm => identicalMod(m, mm))));
+        }
+
+        /**
+         * @type {SampleAndGenerators[]}
+         */
+        let parsedGeneratorsAndSamples = [];
+
+        /**
+         * global zone is always first, so it or nothing
+         * @type {Generator[]}
+         */
+        let globalPresetGenerators = this.presetZones[0].isGlobal ? [...this.presetZones[0].generators] : [];
+
+        let globalPresetModulators = this.presetZones[0].isGlobal ? [...this.presetZones[0].modulators] : [];
+
+        // find the preset zones in range
+        let presetZonesInRange = this.presetZones.filter(currentZone =>
+            (
+                isInRange(currentZone.keyRange.min, currentZone.keyRange.max, midiNote)
+                &&
+                isInRange(currentZone.velRange.min, currentZone.velRange.max, velocity)
+            ) && !currentZone.isGlobal);
+
+        presetZonesInRange.forEach(zone =>
+        {
+            let presetGenerators = zone.generators;
+            let presetModulators = zone.modulators;
+            /**
+             * global zone is always first, so it or nothing
+             * @type {Generator[]}
+             */
+            let globalInstrumentGenerators = zone.instrument.instrumentZones[0].isGlobal ? [...zone.instrument.instrumentZones[0].generators] : [];
+            let globalInstrumentModulators = zone.instrument.instrumentZones[0].isGlobal ? [...zone.instrument.instrumentZones[0].modulators] : [];
+
+            let instrumentZonesInRange = zone.instrument.instrumentZones
+                .filter(currentZone =>
+                    (
+                        isInRange(currentZone.keyRange.min,
+                        currentZone.keyRange.max,
+                        midiNote)
+                    &&
+                    isInRange(currentZone.velRange.min,
+                        currentZone.velRange.max,
+                        velocity)
+                    ) && !currentZone.isGlobal
+                );
+
+            instrumentZonesInRange.forEach(instrumentZone =>
+            {
+                let instrumentGenerators = [...instrumentZone.generators];
+                let instrumentModulators = [...instrumentZone.modulators];
+
+                addUnique(presetGenerators, globalPresetGenerators);
+                // add the unique global preset generators (local replace global(
+
+
+                // add the unique global instrument generators (local replace global)
+                addUnique(instrumentGenerators, globalInstrumentGenerators);
+
+                addUniqueMods(presetModulators, globalPresetModulators);
+                addUniqueMods(instrumentModulators, globalInstrumentModulators);
+
+                // default mods
+                addUniqueMods(instrumentModulators, defaultModulators);
+
+                /**
+                 * sum preset modulators to instruments (amount) sf spec page 54
+                 * @type {Modulator[]}
+                 */
+                const finalModulatorList = [...instrumentModulators];
+                for(let i = 0; i < presetModulators.length; i++)
+                {
+                    let mod = presetModulators[i];
+                    const identicalInstrumentModulator = finalModulatorList.findIndex(m => identicalMod(mod, m));
+                    if(identicalInstrumentModulator !== -1)
+                    {
+                        // sum the amounts (this makes a new modulator because otherwise it would overwrite the one in the soundfont!!!
+                        finalModulatorList[identicalInstrumentModulator] = finalModulatorList[identicalInstrumentModulator].sumTransform(mod);
+                    }
+                    else
+                    {
+                        finalModulatorList.push(mod);
+                    }
+                }
+
+
+                // combine both generators and add to the final result
+                parsedGeneratorsAndSamples.push({
+                    instrumentGenerators: instrumentGenerators,
+                    presetGenerators: presetGenerators,
+                    modulators: finalModulatorList,
+                    sample: instrumentZone.sample,
+                    sampleID: instrumentZone.generators.find(g => g.generatorType === generatorTypes.sampleID).generatorValue
+                });
+            });
+        });
+
+        // save and return
+        this.foundSamplesAndGenerators[midiNote][velocity] = parsedGeneratorsAndSamples;
+        return parsedGeneratorsAndSamples;
+    }
+}
+
+/**
+ * Reads the presets
+ * @param presetChunk {RiffChunk}
+ * @param presetZones {PresetZone[]}
+ * @returns {Preset[]}
+ */
+export function readPresets(presetChunk, presetZones)
+{
+    /**
+     * @type {Preset[]}
+     */
+    let presets = [];
+    while(presetChunk.chunkData.length > presetChunk.chunkData.currentIndex)
+    {
+        let preset = new Preset(presetChunk);
+        if(presets.length > 0)
+        {
+            let presetZonesAmount = preset.presetZoneStartIndex - presets[presets.length - 1].presetZoneStartIndex;
+            presets[presets.length - 1].getPresetZones(presetZonesAmount, presetZones);
+        }
+        presets.push(preset);
+    }
+    // remove EOP
+    if (presets.length > 1)
+    {
+        presets.pop();
+    }
+    return presets;
+}