spessasynth_core 1.1.2 → 1.1.4

package/spessasynth_core/soundfont/chunk/presets.js

@@ -1,264 +0,0 @@
-import {RiffChunk} from "./riff_chunk.js";
-import {PresetZone} from "./zones.js";
-import {readBytesAsString, readBytesAsUintLittleEndian} from "../../utils/byte_functions.js";
-import {Sample} from "./samples.js";
-import { Generator, generatorTypes } from './generators.js'
-import { defaultModulators } from './modulators.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] = [];
-        }
-
-        // skip the DWORDs (4bytes times 3)
-        readBytesAsUintLittleEndian(presetChunk.chunkData, 12);
-    }
-
-    /**
-     * 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]);
-        }
-    }
-
-    /**
-     * Preloads all samples (async)
-     */
-    preload(keyMin, keyMax)
-    {
-        for (let key = keyMin; key < keyMax + 1; key++)
-        {
-            for (let velocity = 0; velocity < 128; velocity++)
-            {
-                setTimeout(() => {
-                    this.getSamplesAndGenerators(key, velocity).forEach(samandgen => {
-                        if(!samandgen.sample.isSampleLoaded) {
-                            samandgen.sample.loadBufferData().then();
-                        }
-                    })
-                });
-            }
-        }
-    }
-
-    /**
-     * @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;
-}

package/spessasynth_core/soundfont/chunk/riff_chunk.js

@@ -1,46 +0,0 @@
-import { ShiftableByteArray } from '../../utils/shiftable_array.js'
-import { readBytesAsString, readBytesAsUintLittleEndian } from '../../utils/byte_functions.js'
-
-/**
- * riff_chunk.js
- * reads a riff chunk and stores it as a class
- */
-
-export class RiffChunk
-{
-    /**
-     * Creates a new riff chunk
-     * @constructor
-     * @param header {string}
-     * @param size {number}
-     * @param data {ShiftableByteArray}
-     */
-    constructor(header, size, data) {
-        this.header = header;
-        this.size = size;
-        this.chunkData = data;
-    }
-
-}
-
-/**
- * @param dataArray {ShiftableByteArray}
- * @param readData {boolean}
- * @returns {RiffChunk}
- */
-export function readRIFFChunk(dataArray, readData = true) {
-    let header = readBytesAsString(dataArray, 4)
-
-    let size = readBytesAsUintLittleEndian(dataArray, 4)
-    let chunkData = undefined
-    if (readData) {
-        chunkData = new ShiftableByteArray(size)
-        chunkData.set(dataArray.slice(dataArray.currentIndex, dataArray.currentIndex + size))
-        dataArray.currentIndex += size
-        // for (let i = 0; i < size; i++) {
-        //     chunkData[i] = readByte(dataArray);
-        // }
-    }
-
-    return new RiffChunk(header, size, chunkData)
-}

package/spessasynth_core/soundfont/chunk/samples.js

@@ -1,250 +0,0 @@
-import {RiffChunk} from "./riff_chunk.js";
-import {ShiftableByteArray} from "../../utils/shiftable_array.js";
-import {readByte, readBytesAsUintLittleEndian, readBytesAsString, signedInt8} from "../../utils/byte_functions.js";
-import { stbvorbis } from '../../utils/stbvorbis_sync.js'
-import { SpessaSynthWarn } from '../../utils/loggin.js'
-
-/**
- * samples.js
- * purpose: parses soundfont samples, resamples if needed.
- * loads sample data, handles async loading of sf3 compressed samples
- */
-
-/**
- * Reads the generatorTranslator from the shdr chunk
- * @param sampleHeadersChunk {RiffChunk}
- * @param smplChunkData {ShiftableByteArray}
- * @returns {Sample[]}
- */
-export function readSamples(sampleHeadersChunk, smplChunkData)
-{
-    /**
-     * @type {Sample[]}
-     */
-    let samples = [];
-    while(sampleHeadersChunk.chunkData.length > sampleHeadersChunk.chunkData.currentIndex)
-    {
-        const sample = readSample(sampleHeadersChunk.chunkData, smplChunkData);
-        samples.push(sample);
-    }
-    return samples;
-}
-
-/**
- * Reads it into a sample
- * @param sampleHeaderData {ShiftableByteArray}
- * @param smplArrayData {ShiftableByteArray}
- * @returns {Sample}
- */
-function readSample(sampleHeaderData, smplArrayData) {
-
-    // read the sample name
-    let sampleName = readBytesAsString(sampleHeaderData, 20);
-
-    // read the sample start index
-    let sampleStartIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
-
-    // read the sample end index
-    let sampleEndIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
-
-    // read the sample looping start index
-    let sampleLoopStartIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
-
-    // read the sample looping end index
-    let sampleLoopEndIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
-
-    // read the sample rate
-    let sampleRate = readBytesAsUintLittleEndian(sampleHeaderData, 4);
-
-    // read the original sample pitch
-    let samplePitch = readByte(sampleHeaderData);
-    if(samplePitch === 255)
-    {
-        // if it's 255, then default to 60
-        samplePitch = 60;
-    }
-
-    // readt the sample pitch correction
-    let samplePitchCorrection = signedInt8(readByte(sampleHeaderData));
-
-
-    // read the link to the other channel
-    let sampleLink = readBytesAsUintLittleEndian(sampleHeaderData, 2);
-    let sampleType = readBytesAsUintLittleEndian(sampleHeaderData, 2);
-
-
-
-    return new Sample(sampleName,
-        sampleStartIndex,
-        sampleEndIndex,
-        sampleLoopStartIndex,
-        sampleLoopEndIndex,
-        sampleRate,
-        samplePitch,
-        samplePitchCorrection,
-        sampleLink,
-        sampleType,
-        smplArrayData);
-}
-
-export class Sample {
-    /**
-     * Creates a sample
-     * @param sampleName {string}
-     * @param sampleStartIndex {number}
-     * @param sampleEndIndex {number}
-     * @param sampleLoopStartIndex {number}
-     * @param sampleLoopEndIndex {number}
-     * @param sampleRate {number}
-     * @param samplePitch {number}
-     * @param samplePitchCorrection {number}
-     * @param sampleLink {number}
-     * @param sampleType {number}
-     * @param smplArr {ShiftableByteArray}
-     */
-    constructor(sampleName,
-                sampleStartIndex,
-                sampleEndIndex,
-                sampleLoopStartIndex,
-                sampleLoopEndIndex,
-                sampleRate,
-                samplePitch,
-                samplePitchCorrection,
-                sampleLink,
-                sampleType,
-                smplArr) {
-        this.sampleName = sampleName
-        // in bytes
-        this.sampleStartIndex = sampleStartIndex;
-        this.sampleEndIndex = sampleEndIndex;
-        this.isSampleLoaded = false;
-
-        this.sampleLoopStartIndex = sampleLoopStartIndex - sampleStartIndex;
-        this.sampleLoopEndIndex = sampleLoopEndIndex - sampleStartIndex;
-        this.sampleRate = sampleRate;
-        this.samplePitch = samplePitch;
-        this.samplePitchCorrection = samplePitchCorrection;
-        this.sampleLink = sampleLink;
-        this.sampleType = sampleType;
-        // in bytes
-        this.sampleLength = this.sampleEndIndex - this.sampleStartIndex;
-        this.indexRatio = 1;
-        this.sampleDataArray = smplArr;
-        this.sampleData = new Float32Array(0);
-        this.sampleLengthSeconds = this.sampleLength / (this.sampleRate * 2);
-        this.loopAllowed = this.sampleLoopStartIndex !== this.sampleLoopEndIndex;
-        this.isCompressed = (this.sampleType & 0x10) > 0;
-
-        if (this.sampleLength < 1 || this.sampleName.substring(0, 3).toLowerCase() === "eos") {
-            return;
-        }
-
-        if(this.isCompressed)
-        {
-            // correct loop points
-            this.sampleLoopStartIndex += this.sampleStartIndex;
-            this.sampleLoopEndIndex += this.sampleStartIndex;
-            this.sampleLength = 99999999; // set to 999999 before we decode it
-        }
-
-    }
-
-    /**
-     * @param smplArr {ShiftableByteArray}
-     */
-    decodeVorbis(smplArr)
-    {
-        if (this.sampleLength < 1) {
-            // eos, do not do anything
-            return;
-        }
-        // get the compressed byte stream
-        const smplStart = smplArr.currentIndex;
-        const buff = smplArr.slice(this.sampleStartIndex / 2 + smplStart, this.sampleEndIndex / 2 + smplStart);
-        // reset array and being decoding
-        this.sampleData = new Float32Array(0);
-        /**
-         * @type {{data: Float32Array[], error: (string|null), sampleRate: number, eof: boolean}}
-         */
-        const vorbis = stbvorbis.decode(buff.buffer);
-        this.sampleData = vorbis.data[0];
-    }
-
-    /**
-     * creates a sample sampleData and stores it for reuse
-     * @param startAddrOffset {number}
-     * @param endAddrOffset {number}
-     * @returns {Float32Array} The audioData
-     */
-     getAudioData(startAddrOffset = 0, endAddrOffset = 0) {
-        if (!this.isSampleLoaded) {
-            // start loading data if not loaded
-            return this.loadBufferData();
-        }
-        // if no offset, return saved sampleData
-        if (this.sampleData && startAddrOffset === 0 && endAddrOffset === 0) {
-            return this.sampleData;
-        }
-
-        return this.getOffsetData(startAddrOffset, endAddrOffset);
-    }
-
-    /**
-     * @param smplArr {ShiftableByteArray}
-     * @returns {Float32Array}
-     */
-    loadUncompressedData(smplArr)
-    {
-        if(this.isCompressed)
-        {
-            SpessaSynthWarn("Trying to load a compressed sample via loadUncompressedData()... aborting!");
-            return new Float32Array(0);
-        }
-
-        // read the sample data
-        let audioData = new Float32Array(this.sampleLength / 2 + 1);
-        const dataStartIndex = smplArr.currentIndex;
-        let convertedSigned16 = new Int16Array(
-            smplArr.slice(dataStartIndex + this.sampleStartIndex, dataStartIndex + this.sampleEndIndex)
-                .buffer
-        );
-
-        // convert to float
-        for(let i = 0; i < convertedSigned16.length; i++)
-        {
-            audioData[i] = convertedSigned16[i] / 32768;
-        }
-
-        this.sampleData = audioData;
-        this.isSampleLoaded = true;
-        return audioData;
-    }
-
-    /**
-     * @returns {Float32Array}
-     */
-    loadBufferData() {
-        if (this.sampleLength < 1) {
-            // eos, do not do anything
-            return new Float32Array(1);
-        }
-
-        if(this.isCompressed)
-        {
-            this.decodeVorbis(this.sampleDataArray);
-            this.isSampleLoaded = true;
-            return this.sampleData;
-        }
-        return this.loadUncompressedData(this.sampleDataArray);
-    }
-
-    /**
-     * Creates a sample sampleData
-     * @param startOffset {number}
-     * @param endOffset {number}
-     * @returns {Float32Array}
-     */
-    getOffsetData(startOffset, endOffset) {
-        return this.sampleData.subarray(startOffset, this.sampleData.length - endOffset + 1);
-    }
-}