spessasynth_lib 0.0.1

package/package/soundfont/read/zones.js

@@ -0,0 +1,310 @@
+import {readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import {IndexedByteArray} from "../../utils/indexed_array.js";
+import {RiffChunk} from "./riff_chunk.js";
+import {Generator, generatorTypes} from "./generators.js";
+import {Sample} from "./samples.js";
+import {Instrument} from "./instruments.js";
+import {Modulator} from "./modulators.js";
+
+/**
+ * zones.js
+ * purpose: reads instrumend and preset zones from soundfont and gets their respective samples and generators and modulators
+ */
+
+export class InstrumentZone {
+    /**
+     * Creates a zone (instrument)
+     * @param dataArray {IndexedByteArray}
+     * @param index {number}
+     */
+    constructor(dataArray, index)
+    {
+        this.generatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
+        this.modulatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
+        this.modulatorZoneSize = 0;
+        this.generatorZoneSize = 0;
+        this.zoneID = index;
+        this.keyRange = {min: 0, max: 127};
+        this.velRange = {min: 0, max: 127}
+        this.isGlobal = true;
+        this.useCount = 0;
+
+        /**
+         * @type {Generator[]}
+         */
+        this.generators = [];
+        /**
+         * @type {Modulator[]}
+         */
+        this.modulators = [];
+    }
+
+    deleteZone()
+    {
+        this.useCount--;
+        if(this.isGlobal)
+        {
+            return;
+        }
+        this.sample.useCount--;
+    }
+
+    setZoneSize(modulatorZoneSize, generatorZoneSize)
+    {
+        this.modulatorZoneSize = modulatorZoneSize;
+        this.generatorZoneSize = generatorZoneSize;
+    }
+
+    /**
+     * grab the generators
+     * @param generators {Generator[]}
+     */
+    getGenerators(generators)
+    {
+        for(let i = this.generatorZoneStartIndex; i < this.generatorZoneStartIndex + this.generatorZoneSize; i++)
+        {
+            this.generators.push(generators[i]);
+        }
+    }
+
+    /**
+     * grab the modulators
+     * @param modulators {Modulator[]}
+     */
+    getModulators(modulators)
+    {
+        for(let i = this.modulatorZoneStartIndex; i < this.modulatorZoneStartIndex + this.modulatorZoneSize; i++)
+        {
+            this.modulators.push(modulators[i]);
+        }
+    }
+
+    /**
+     * Loads the zone's sample
+     * @param samples {Sample[]}
+     */
+    getSample(samples)
+    {
+        let sampleID = this.generators.find(g => g.generatorType === generatorTypes.sampleID);
+        if (sampleID)
+        {
+            this.sample = samples[sampleID.generatorValue];
+            this.isGlobal = false;
+            this.sample.useCount++;
+        }
+    }
+
+    /**
+     * Reads the keyRange of the zone
+     */
+    getKeyRange()
+    {
+        let range = this.generators.find(g => g.generatorType === generatorTypes.keyRange);
+        if(range)
+        {
+            this.keyRange.min = range.generatorValue & 0x7F;
+            this.keyRange.max = (range.generatorValue >> 8) & 0x7F;
+        }
+    }
+
+    /**
+     * reads the velolicty range of the zone
+     */
+    getVelRange()
+    {
+        let range = this.generators.find(g => g.generatorType === generatorTypes.velRange);
+        if(range)
+        {
+            this.velRange.min = range.generatorValue & 0x7F;
+            this.velRange.max = (range.generatorValue >> 8) & 0x7F;
+        }
+    }
+}
+
+/**
+ * Reads the given instrument zone read
+ * @param zonesChunk {RiffChunk}
+ * @param instrumentGenerators {Generator[]}
+ * @param instrumentModulators {Modulator[]}
+ * @param instrumentSamples {Sample[]}
+ * @returns {InstrumentZone[]}
+ */
+export function readInstrumentZones(zonesChunk, instrumentGenerators, instrumentModulators, instrumentSamples)
+{
+    /**
+     * @type {InstrumentZone[]}
+     */
+    let zones = [];
+    let index = 0;
+    while(zonesChunk.chunkData.length > zonesChunk.chunkData.currentIndex)
+    {
+        let zone = new InstrumentZone(zonesChunk.chunkData, index);
+        if(zones.length > 0)
+        {
+            let modulatorZoneSize = zone.modulatorZoneStartIndex - zones[zones.length - 1].modulatorZoneStartIndex;
+            let generatorZoneSize = zone.generatorZoneStartIndex - zones[zones.length - 1].generatorZoneStartIndex;
+            zones[zones.length - 1].setZoneSize(modulatorZoneSize, generatorZoneSize);
+            zones[zones.length - 1].getGenerators(instrumentGenerators);
+            zones[zones.length - 1].getModulators(instrumentModulators);
+            zones[zones.length - 1].getSample(instrumentSamples);
+            zones[zones.length - 1].getKeyRange();
+            zones[zones.length - 1].getVelRange();
+        }
+        zones.push(zone);
+        index++;
+    }
+    if(zones.length > 1)
+    {
+        // remove terminal
+        zones.pop();
+    }
+    return zones;
+}
+
+export class
+PresetZone
+{
+    /**
+     * Creates a zone (preset)
+     * @param dataArray {IndexedByteArray}
+     * @param index {number}
+     */
+    constructor(dataArray, index) {
+        this.generatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
+        this.modulatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
+        this.modulatorZoneSize = 0;
+        this.generatorZoneSize = 0;
+        this.zoneID = index;
+        this.keyRange = {min: 0, max: 127};
+        this.velRange = {min: 0, max: 127}
+        this.isGlobal = true;
+        /**
+         * @type {Generator[]}
+         */
+        this.generators = [];
+        /**
+         * @type {Modulator[]}
+         */
+        this.modulators = [];
+    }
+
+    setZoneSize(modulatorZoneSize, generatorZoneSize)
+    {
+        this.modulatorZoneSize = modulatorZoneSize;
+        this.generatorZoneSize = generatorZoneSize;
+    }
+
+    deleteZone()
+    {
+        if(this.isGlobal)
+        {
+            return;
+        }
+        this.instrument.removeUseCount();
+    }
+
+    /**
+     * grab the generators
+     * @param generators {Generator[]}
+     */
+    getGenerators(generators)
+    {
+        for(let i = this.generatorZoneStartIndex; i < this.generatorZoneStartIndex + this.generatorZoneSize; i++)
+        {
+            this.generators.push(generators[i]);
+        }
+    }
+
+    /**
+     * grab the modulators
+     * @param modulators {Modulator[]}
+     */
+    getModulators(modulators)
+    {
+        for(let i = this.modulatorZoneStartIndex; i < this.modulatorZoneStartIndex + this.modulatorZoneSize; i++)
+        {
+            this.modulators.push(modulators[i]);
+        }
+    }
+
+    /**
+     * grab the instrument
+     * @param instruments {Instrument[]}
+     */
+    getInstrument(instruments)
+    {
+        let instrumentID = this.generators.find(g => g.generatorType === generatorTypes.instrument);
+        if(instrumentID)
+        {
+            this.instrument = instruments[instrumentID.generatorValue];
+            this.instrument.addUseCount();
+            this.isGlobal = false;
+        }
+    }
+
+    /**
+     * Reads the keyRange of the zone
+     */
+    getKeyRange()
+    {
+        let range = this.generators.find(g => g.generatorType === generatorTypes.keyRange);
+        if(range)
+        {
+            this.keyRange.min = range.generatorValue & 0x7F;
+            this.keyRange.max = (range.generatorValue >> 8) & 0x7F;
+        }
+    }
+
+    /**
+     * reads the velolicty range of the zone
+     */
+    getVelRange()
+    {
+        let range = this.generators.find(g => g.generatorType === generatorTypes.velRange);
+        if(range)
+        {
+            this.velRange.min = range.generatorValue & 0x7F;
+            this.velRange.max = (range.generatorValue >> 8) & 0x7F;
+        }
+    }
+}
+
+/**
+ * Reads the given preset zone read
+ * @param zonesChunk {RiffChunk}
+ * @param presetGenerators {Generator[]}
+ * @param instruments {Instrument[]}
+ * @param presetModulators {Modulator[]}
+ * @returns {PresetZone[]}
+ */
+export function readPresetZones(zonesChunk, presetGenerators, presetModulators, instruments)
+{
+    /**
+     * @type {PresetZone[]}
+     */
+    let zones = [];
+    let index = 0;
+    while(zonesChunk.chunkData.length > zonesChunk.chunkData.currentIndex)
+    {
+        let zone = new PresetZone(zonesChunk.chunkData, index);
+        if(zones.length > 0)
+        {
+            let modulatorZoneSize = zone.modulatorZoneStartIndex - zones[zones.length - 1].modulatorZoneStartIndex;
+            let generatorZoneSize = zone.generatorZoneStartIndex - zones[zones.length - 1].generatorZoneStartIndex;
+            zones[zones.length - 1].setZoneSize(modulatorZoneSize, generatorZoneSize);
+            zones[zones.length - 1].getGenerators(presetGenerators);
+            zones[zones.length - 1].getModulators(presetModulators);
+            zones[zones.length - 1].getInstrument(instruments);
+            zones[zones.length - 1].getKeyRange();
+            zones[zones.length - 1].getVelRange();
+        }
+        zones.push(zone);
+        index++;
+    }
+    if(zones.length > 1)
+    {
+        // remove terminal
+        zones.pop();
+    }
+    return zones;
+}

package/package/soundfont/soundfont.js

@@ -0,0 +1,357 @@
+import { IndexedByteArray } from '../utils/indexed_array.js'
+import {readSamples} from "./read/samples.js";
+import { readBytesAsUintLittleEndian } from '../utils/byte_functions/little_endian.js'
+import { readGenerators, Generator } from './read/generators.js'
+import {readInstrumentZones, InstrumentZone, readPresetZones} from "./read/zones.js";
+import {Preset, readPresets} from "./read/presets.js";
+import {readInstruments, Instrument} from "./read/instruments.js";
+import {readModulators, Modulator} from "./read/modulators.js";
+import { readRIFFChunk, RiffChunk } from './read/riff_chunk.js'
+import { consoleColors } from '../utils/other.js'
+import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from '../utils/loggin.js'
+import { readBytesAsString } from '../utils/byte_functions/string.js'
+import { write } from './write/write.js'
+
+/**
+ * soundfont.js
+ * purpose: parses a soundfont2 file
+ */
+
+class SoundFont2
+{
+    /**
+     * Initializes a new SoundFont2 Parser and parses the given data array
+     * @param arrayBuffer {ArrayBuffer|{presets: Preset[], info: Object<string, string>}}
+     */
+    constructor(arrayBuffer) {
+        if(arrayBuffer.presets)
+        {
+            this.presets = arrayBuffer.presets;
+            this.soundFontInfo = arrayBuffer.info;
+            return;
+        }
+        this.dataArray = new IndexedByteArray(arrayBuffer);
+        SpessaSynthGroup("%cParsing SoundFont...", consoleColors.info);
+        if(!this.dataArray)
+        {
+            SpessaSynthGroupEnd();
+            throw new TypeError("No data!");
+        }
+
+        // read the main read
+        let firstChunk = readRIFFChunk(this.dataArray, false);
+        this.verifyHeader(firstChunk, "riff");
+
+        this.verifyText(readBytesAsString(this.dataArray,4), "sfbk");
+
+        // INFO
+        let infoChunk = readRIFFChunk(this.dataArray);
+        this.verifyHeader(infoChunk, "list");
+        readBytesAsString(infoChunk.chunkData, 4);
+
+        /**
+         * @type {Object<string, string>}
+         */
+        this.soundFontInfo = {};
+
+        while(infoChunk.chunkData.length > infoChunk.chunkData.currentIndex) {
+            let chunk = readRIFFChunk(infoChunk.chunkData);
+            let text;
+            // special case: ifil
+            switch (chunk.header.toLowerCase())
+            {
+                case  "ifil":
+                case "iver":
+                    text = `${readBytesAsUintLittleEndian(chunk.chunkData, 2)}.${readBytesAsUintLittleEndian(chunk.chunkData, 2)}`;
+                    break;
+
+                case "icmt":
+                    text = readBytesAsString(chunk.chunkData, chunk.chunkData.length, undefined, false);
+                    break;
+
+                default:
+                    text = readBytesAsString(chunk.chunkData, chunk.chunkData.length);
+            }
+
+            SpessaSynthInfo(`%c"${chunk.header}": %c"${text}"`,
+                consoleColors.info,
+                consoleColors.recognized);
+            this.soundFontInfo[chunk.header] = text;
+        }
+
+        // SDTA
+        const sdtaChunk = readRIFFChunk(this.dataArray, false);
+        this.verifyHeader(sdtaChunk, "list")
+        this.verifyText(readBytesAsString(this.dataArray, 4), "sdta");
+
+        // smpl
+        SpessaSynthInfo("%cVerifying smpl chunk...", consoleColors.warn)
+        let sampleDataChunk = readRIFFChunk(this.dataArray, false);
+        this.verifyHeader(sampleDataChunk, "smpl");
+        this.sampleDataStartIndex = this.dataArray.currentIndex;
+
+        SpessaSynthInfo(`%cSkipping sample chunk, length: %c${sdtaChunk.size - 12}`,
+            consoleColors.info,
+            consoleColors.value);
+        this.dataArray.currentIndex += sdtaChunk.size - 12;
+
+        // PDTA
+        SpessaSynthInfo("%cLoading preset data chunk...", consoleColors.warn)
+        let presetChunk = readRIFFChunk(this.dataArray);
+        this.verifyHeader(presetChunk, "list");
+        readBytesAsString(presetChunk.chunkData, 4);
+
+        // read the hydra chunks
+        const presetHeadersChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetHeadersChunk, "phdr");
+
+        const presetZonesChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetZonesChunk, "pbag");
+
+        const presetModulatorsChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetModulatorsChunk, "pmod");
+
+        const presetGeneratorsChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetGeneratorsChunk, "pgen");
+
+        const presetInstrumentsChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetInstrumentsChunk, "inst");
+
+        const presetInstrumentZonesChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetInstrumentZonesChunk, "ibag");
+
+        const presetInstrumentModulatorsChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetInstrumentModulatorsChunk, "imod");
+
+        const presetInstrumentGeneratorsChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetInstrumentGeneratorsChunk, "igen");
+
+        const presetSamplesChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(presetSamplesChunk, "shdr");
+
+        /**
+         * read all the samples
+         * (the current index points to start of the smpl read)
+         */
+        this.dataArray.currentIndex = this.sampleDataStartIndex
+        this.samples = readSamples(presetSamplesChunk, this.dataArray);
+
+        /**
+         * read all the instrument generators
+         * @type {Generator[]}
+         */
+        let instrumentGenerators = readGenerators(presetInstrumentGeneratorsChunk);
+
+        /**
+         * read all the instrument modulators
+         * @type {Modulator[]}
+         */
+        let instrumentModulators = readModulators(presetInstrumentModulatorsChunk);
+
+        /**
+         * read all the instrument zones
+         * @type {InstrumentZone[]}
+         */
+        let instrumentZones = readInstrumentZones(presetInstrumentZonesChunk,
+            instrumentGenerators,
+            instrumentModulators,
+            this.samples);
+
+        /**
+         * read all the instruments
+         * @type {Instrument[]}
+         */
+       this.instruments = readInstruments(presetInstrumentsChunk, instrumentZones);
+
+        /**
+         * read all the preset generators
+         * @type {Generator[]}
+         */
+        let presetGenerators = readGenerators(presetGeneratorsChunk);
+
+        /**
+         * Read all the preset modulatorrs
+         * @type {Modulator[]}
+         */
+        let presetModulators = readModulators(presetModulatorsChunk);
+
+        let presetZones = readPresetZones(presetZonesChunk, presetGenerators, presetModulators, this.instruments);
+        /**
+         * Finally, read all the presets
+         * @type {Preset[]}
+         */
+        this.presets = readPresets(presetHeadersChunk, presetZones);
+        this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
+        // preload the first preset
+        SpessaSynthInfo(`%cParsing finished! %c"${this.soundFontInfo["INAM"]}"%c has %c${this.presets.length} %cpresets,
+        %c${this.instruments.length}%c instruments and %c${this.samples.length}%c samples.`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info);
+        SpessaSynthGroupEnd();
+    }
+
+    removeUnusedElements()
+    {
+        this.instruments.forEach(i => {
+            if(i.useCount < 1)
+            {
+                i.instrumentZones.forEach(z => {if(!z.isGlobal) z.sample.useCount--});
+            }
+        })
+        this.instruments = this.instruments.filter(i => i.useCount > 0);
+        this.samples = this.samples.filter(s => s.useCount > 0);
+    }
+
+    /**
+     * @param instrument {Instrument}
+     */
+    deleteInstrument(instrument)
+    {
+        if(instrument.useCount > 0)
+        {
+            throw new Error(`Cannot delete an instrument that has ${instrument.useCount} usages.`);
+        }
+        this.instruments.splice(this.instruments.indexOf(instrument), 1);
+        instrument.deleteInstrument();
+        this.removeUnusedElements();
+    }
+
+    /**
+     * @param sample {Sample}
+     */
+    deleteSample(sample)
+    {
+        if(sample.useCount > 0)
+        {
+            throw new Error(`Cannot delete sample that has ${sample.useCount} usages.`);
+        }
+        this.samples.splice(this.samples.indexOf(sample), 1);
+        this.removeUnusedElements();
+    }
+
+    /**
+     * @param preset {Preset}
+     */
+    deletePreset(preset)
+    {
+        preset.deletePreset();
+        this.presets.splice(this.presets.indexOf(preset), 1);
+        this.removeUnusedElements();
+    }
+
+    /**
+     * @param chunk {RiffChunk}
+     * @param expected {string}
+     */
+    verifyHeader(chunk, expected)
+    {
+        if(chunk.header.toLowerCase() !== expected.toLowerCase())
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid chunk header! Expected "${expected.toLowerCase()}" got "${chunk.header.toLowerCase()}"`);
+        }
+    }
+
+    /**
+     * @param text {string}
+     * @param expected {string}
+     */
+    verifyText(text, expected)
+    {
+        if(text.toLowerCase() !== expected.toLowerCase())
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid soundFont! Expected "${expected.toLowerCase()}" got "${text.toLowerCase()}"`);
+        }
+    }
+
+    /**
+     * Get the appropriate preset
+     * @param bankNr {number}
+     * @param presetNr {number}
+     * @returns {Preset}
+     */
+    getPreset(bankNr, presetNr)
+    {
+        let preset = this.presets.find(p => p.bank === bankNr && p.program === presetNr);
+        if (!preset)
+        {
+            preset = this.presets.find(p => p.program === presetNr && p.bank !== 128);
+            if(bankNr === 128)
+            {
+                preset = this.presets.find(p => p.bank === 128 && p.program === presetNr);
+                if(!preset)
+                {
+                    preset = this.presets.find(p => p.bank === 128);
+                }
+            }
+            if(preset)
+            {
+                SpessaSynthWarn(`%cPreset ${bankNr}.${presetNr} not found. Replaced with %c${preset.presetName} (${preset.bank}.${preset.program})`,
+                    consoleColors.warn,
+                    consoleColors.recognized);
+            }
+        }
+        if(!preset)
+        {
+            SpessaSynthWarn(`Preset ${presetNr} not found. Defaulting to`, this.presets[0].presetName);
+            preset = this.presets[0];
+        }
+        return preset;
+    }
+
+    /**
+     * gets preset by name
+     * @param presetName {string}
+     * @returns {Preset}
+     */
+    getPresetByName(presetName)
+    {
+        let preset = this.presets.find(p => p.presetName === presetName);
+        if(!preset)
+        {
+            SpessaSynthWarn("Preset not found. Defaulting to:", this.presets[0].presetName);
+            preset = this.presets[0];
+        }
+        return preset;
+    }
+
+
+    /**
+     * Merges soundfonts with the given order. Keep in mind that the info read is copied from the first one
+     * @param soundfonts {...SoundFont2} the soundfonts to merge, the first overwrites the last
+     * @returns {SoundFont2}
+     */
+    static mergeSoundfonts(...soundfonts)
+    {
+        const mainSf = soundfonts.shift();
+        /**
+         * @type {Preset[]}
+         */
+        const presets = mainSf.presets;
+        while(soundfonts.length)
+        {
+            const newPresets = soundfonts.shift().presets;
+            newPresets.forEach(newPreset => {
+                if(
+                    presets.find(existingPreset => existingPreset.bank === newPreset.bank && existingPreset.program === newPreset.program) === undefined
+                )
+                {
+                    presets.push(newPreset);
+                }
+            })
+        }
+
+        return new SoundFont2({presets: presets, info: mainSf.soundFontInfo});
+    }
+}
+SoundFont2.prototype.write = write;
+
+export { SoundFont2 }

package/package/soundfont/write/ibag.js

@@ -0,0 +1,39 @@
+import { IndexedByteArray } from '../../utils/indexed_array.js'
+import { writeWord } from '../../utils/byte_functions/little_endian.js'
+import { RiffChunk, writeRIFFChunk } from '../read/riff_chunk.js'
+
+/**
+ * @this {SoundFont2}
+ * @returns {IndexedByteArray}
+ */
+export function getIBAG()
+{
+    // write all ibags with their start indexes as they were changed in getIGEN() and getIMOD()
+    const ibagsize = this.instruments.reduce((sum, i) => i.instrumentZones.length * 4 + sum, 4);
+    const ibagdata = new IndexedByteArray(ibagsize);
+    let zoneID = 0;
+    let generatorIndex = 0;
+    let modulatorIndex = 0;
+    for(const inst of this.instruments)
+    {
+        inst.instrumentZoneIndex = zoneID;
+        for(const ibag of inst.instrumentZones)
+        {
+            ibag.zoneID = zoneID;
+            writeWord(ibagdata, generatorIndex);
+            writeWord(ibagdata, modulatorIndex);
+            generatorIndex += ibag.generators.length;
+            modulatorIndex += ibag.modulators.length;
+            zoneID++;
+        }
+    }
+    // write the terminal IBAG
+    writeWord(ibagdata, generatorIndex);
+    writeWord(ibagdata, modulatorIndex);
+
+    return writeRIFFChunk(new RiffChunk(
+        "ibag",
+        ibagdata.length,
+        ibagdata
+    ));
+}