spessasynth_core 1.1.3 → 1.1.4

package/src/soundfont/read_sf2/samples.js

@@ -0,0 +1,304 @@
+import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
+import { IndexedByteArray } from "../../utils/indexed_array.js";
+import { readLittleEndian, signedInt8 } from "../../utils/byte_functions/little_endian.js";
+import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
+import { SpessaSynthWarn } from "../../utils/loggin.js";
+import { readBytesAsString } from "../../utils/byte_functions/string.js";
+import { BasicSample } from "../basic_soundfont/basic_sample.js";
+
+export class SoundFontSample extends BasicSample
+{
+    /**
+     * 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 {IndexedByteArray|Float32Array}
+     * @param sampleIndex {number} initial sample index when loading the sfont
+     * @param isDataRaw {boolean} if false, the data is decoded as float32.
+     * Used for SF2Pack support
+     */
+    constructor(
+        sampleName,
+        sampleStartIndex,
+        sampleEndIndex,
+        sampleLoopStartIndex,
+        sampleLoopEndIndex,
+        sampleRate,
+        samplePitch,
+        samplePitchCorrection,
+        sampleLink,
+        sampleType,
+        smplArr,
+        sampleIndex,
+        isDataRaw
+    )
+    {
+        super(
+            sampleName,
+            sampleRate,
+            samplePitch,
+            samplePitchCorrection,
+            sampleLink,
+            sampleType,
+            sampleLoopStartIndex - (sampleStartIndex / 2),
+            sampleLoopEndIndex - (sampleStartIndex / 2)
+        );
+        this.sampleName = sampleName;
+        // in bytes
+        this.sampleStartIndex = sampleStartIndex;
+        this.sampleEndIndex = sampleEndIndex;
+        this.isSampleLoaded = false;
+        this.sampleID = sampleIndex;
+        // in bytes
+        this.sampleLength = this.sampleEndIndex - this.sampleStartIndex;
+        this.sampleDataArray = smplArr;
+        this.sampleData = new Float32Array(0);
+        if (this.isCompressed)
+        {
+            // correct loop points
+            this.sampleLoopStartIndex += this.sampleStartIndex / 2;
+            this.sampleLoopEndIndex += this.sampleStartIndex / 2;
+            this.sampleLength = 99999999; // set to 999,999 before we decode it
+        }
+        this.isDataRaw = isDataRaw;
+    }
+    
+    /**
+     * Get raw data, whether it's compressed or not as we simply write it to the file
+     * @return {Uint8Array} either s16 or vorbis data
+     */
+    getRawData()
+    {
+        const smplArr = this.sampleDataArray;
+        if (this.isCompressed)
+        {
+            if (this.compressedData)
+            {
+                return this.compressedData;
+            }
+            const smplStart = smplArr.currentIndex;
+            return smplArr.slice(this.sampleStartIndex / 2 + smplStart, this.sampleEndIndex / 2 + smplStart);
+        }
+        else
+        {
+            if (!this.isDataRaw)
+            {
+                // encode the f32 into s16 manually
+                super.getRawData();
+            }
+            const dataStartIndex = smplArr.currentIndex;
+            return smplArr.slice(dataStartIndex + this.sampleStartIndex, dataStartIndex + this.sampleEndIndex);
+        }
+    }
+    
+    /**
+     * Decode binary vorbis into a float32 pcm
+     */
+    decodeVorbis()
+    {
+        if (this.sampleLength < 1)
+        {
+            // eos, do not do anything
+            return;
+        }
+        // get the compressed byte stream
+        const smplArr = this.sampleDataArray;
+        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);
+        try
+        {
+            /**
+             * @type {{data: Float32Array[], error: (string|null), sampleRate: number, eof: boolean}}
+             */
+            const vorbis = stbvorbis.decode(buff.buffer);
+            this.sampleData = vorbis.data[0];
+            if (this.sampleData === undefined)
+            {
+                SpessaSynthWarn(`Error decoding sample ${this.sampleName}: Vorbis decode returned undefined.`);
+            }
+        }
+        catch (e)
+        {
+            // do not error out, fill with silence
+            SpessaSynthWarn(`Error decoding sample ${this.sampleName}: ${e}`);
+            this.sampleData = new Float32Array(this.sampleLoopEndIndex + 1);
+        }
+    }
+    
+    /**
+     * Loads the audio data and stores it for reuse
+     * @returns {Float32Array} The audioData
+     */
+    getAudioData()
+    {
+        if (!this.isSampleLoaded)
+        {
+            // start loading data if it is not loaded
+            if (this.sampleLength < 1)
+            {
+                SpessaSynthWarn(`Invalid sample ${this.sampleName}! Invalid length: ${this.sampleLength}`);
+                return new Float32Array(1);
+            }
+            
+            if (this.isCompressed)
+            {
+                // if compressed, decode
+                this.decodeVorbis();
+                this.isSampleLoaded = true;
+                return this.sampleData;
+            }
+            else if (!this.isDataRaw)
+            {
+                return this.getUncompressedReadyData();
+            }
+            return this.loadUncompressedData();
+        }
+        return this.sampleData;
+    }
+    
+    /**
+     * @returns {Float32Array}
+     */
+    loadUncompressedData()
+    {
+        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);
+        const dataStartIndex = this.sampleDataArray.currentIndex;
+        let convertedSigned16 = new Int16Array(
+            this.sampleDataArray.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}
+     */
+    getUncompressedReadyData()
+    {
+        /**
+         * read the sample data
+         * @type {Float32Array}
+         */
+        let audioData = this.sampleDataArray.slice(this.sampleStartIndex / 2, this.sampleEndIndex / 2);
+        this.sampleData = audioData;
+        this.isSampleLoaded = true;
+        return audioData;
+    }
+}
+
+/**
+ * Reads the generatorTranslator from the shdr read
+ * @param sampleHeadersChunk {RiffChunk}
+ * @param smplChunkData {IndexedByteArray|Float32Array}
+ * @param isSmplDataRaw {boolean}
+ * @returns {SoundFontSample[]}
+ */
+export function readSamples(sampleHeadersChunk, smplChunkData, isSmplDataRaw = true)
+{
+    /**
+     * @type {SoundFontSample[]}
+     */
+    let samples = [];
+    let index = 0;
+    while (sampleHeadersChunk.chunkData.length > sampleHeadersChunk.chunkData.currentIndex)
+    {
+        const sample = readSample(index, sampleHeadersChunk.chunkData, smplChunkData, isSmplDataRaw);
+        samples.push(sample);
+        index++;
+    }
+    // remove EOS
+    if (samples.length > 1)
+    {
+        samples.pop();
+    }
+    return samples;
+}
+
+/**
+ * Reads it into a sample
+ * @param index {number}
+ * @param sampleHeaderData {IndexedByteArray}
+ * @param smplArrayData {IndexedByteArray|Float32Array}
+ * @param isDataRaw {boolean} true means binary 16-bit data, false means float32
+ * @returns {SoundFontSample}
+ */
+function readSample(index, sampleHeaderData, smplArrayData, isDataRaw)
+{
+    
+    // read the sample name
+    let sampleName = readBytesAsString(sampleHeaderData, 20);
+    
+    // read the sample start index
+    let sampleStartIndex = readLittleEndian(sampleHeaderData, 4) * 2;
+    
+    // read the sample end index
+    let sampleEndIndex = readLittleEndian(sampleHeaderData, 4) * 2;
+    
+    // read the sample looping start index
+    let sampleLoopStartIndex = readLittleEndian(sampleHeaderData, 4);
+    
+    // read the sample looping end index
+    let sampleLoopEndIndex = readLittleEndian(sampleHeaderData, 4);
+    
+    // read the sample rate
+    let sampleRate = readLittleEndian(sampleHeaderData, 4);
+    
+    // read the original sample pitch
+    let samplePitch = sampleHeaderData[sampleHeaderData.currentIndex++];
+    if (samplePitch === 255)
+    {
+        // if it's 255, then default to 60
+        samplePitch = 60;
+    }
+    
+    // read the sample pitch correction
+    let samplePitchCorrection = signedInt8(sampleHeaderData[sampleHeaderData.currentIndex++]);
+    
+    
+    // read the link to the other channel
+    let sampleLink = readLittleEndian(sampleHeaderData, 2);
+    let sampleType = readLittleEndian(sampleHeaderData, 2);
+    
+    
+    return new SoundFontSample(
+        sampleName,
+        sampleStartIndex,
+        sampleEndIndex,
+        sampleLoopStartIndex,
+        sampleLoopEndIndex,
+        sampleRate,
+        samplePitch,
+        samplePitchCorrection,
+        sampleLink,
+        sampleType,
+        smplArrayData,
+        index,
+        isDataRaw
+    );
+}

package/src/soundfont/read_sf2/soundfont.js

@@ -0,0 +1,305 @@
+import { IndexedByteArray } from "../../utils/indexed_array.js";
+import { readSamples } from "./samples.js";
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+import { readGenerators } from "./generators.js";
+import { InstrumentZone, readInstrumentZones, readPresetZones } from "./zones.js";
+import { readPresets } from "./presets.js";
+import { readInstruments } from "./instruments.js";
+import { readModulators } from "./modulators.js";
+import { readRIFFChunk, RiffChunk } from "../basic_soundfont/riff_chunk.js";
+import { consoleColors } from "../../utils/other.js";
+import { SpessaSynthGroup, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../utils/loggin.js";
+import { readBytesAsString } from "../../utils/byte_functions/string.js";
+import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
+import { BasicSoundBank } from "../basic_soundfont/basic_soundfont.js";
+import { Generator } from "../basic_soundfont/generator.js";
+import { Modulator } from "../basic_soundfont/modulator.js";
+
+/**
+ * soundfont.js
+ * purpose: parses a soundfont2 file
+ */
+
+export class SoundFont2 extends BasicSoundBank
+{
+    /**
+     * Initializes a new SoundFont2 Parser and parses the given data array
+     * @param arrayBuffer {ArrayBuffer}
+     * @param warnDeprecated {boolean}
+     */
+    constructor(arrayBuffer, warnDeprecated = true)
+    {
+        super();
+        if (warnDeprecated)
+        {
+            console.warn("Using the constructor directly is deprecated. Use loadSoundFont instead.");
+        }
+        this.dataArray = new IndexedByteArray(arrayBuffer);
+        SpessaSynthGroup("%cParsing SoundFont...", consoleColors.info);
+        if (!this.dataArray)
+        {
+            SpessaSynthGroupEnd();
+            this.parsingError("No data provided!");
+        }
+        
+        // read the main read
+        let firstChunk = readRIFFChunk(this.dataArray, false);
+        this.verifyHeader(firstChunk, "riff");
+        
+        const type = readBytesAsString(this.dataArray, 4).toLowerCase();
+        if (type !== "sfbk" && type !== "sfpk")
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid soundFont! Expected "sfbk" or "sfpk" got "${type}"`);
+        }
+        /*
+        Some SF2Pack description:
+        this is essentially sf2, but the entire smpl chunk is compressed (we only support Ogg Vorbis here)
+        and the only other difference is that the main chunk isn't "sfbk" but rather "sfpk"
+         */
+        const isSF2Pack = type === "sfpk";
+        
+        // INFO
+        let infoChunk = readRIFFChunk(this.dataArray);
+        this.verifyHeader(infoChunk, "list");
+        readBytesAsString(infoChunk.chunkData, 4);
+        
+        while (infoChunk.chunkData.length > infoChunk.chunkData.currentIndex)
+        {
+            let chunk = readRIFFChunk(infoChunk.chunkData);
+            let text;
+            // special cases
+            switch (chunk.header.toLowerCase())
+            {
+                case  "ifil":
+                case "iver":
+                    text = `${readLittleEndian(chunk.chunkData, 2)}.${readLittleEndian(chunk.chunkData, 2)}`;
+                    this.soundFontInfo[chunk.header] = text;
+                    break;
+                
+                case "icmt":
+                    text = readBytesAsString(chunk.chunkData, chunk.chunkData.length, undefined, false);
+                    this.soundFontInfo[chunk.header] = text;
+                    break;
+                
+                // dmod: default modulators
+                case "dmod":
+                    const newModulators = readModulators(chunk);
+                    newModulators.pop(); // remove the terminal record
+                    text = `Modulators: ${newModulators.length}`;
+                    // override default modulators
+                    const oldDefaults = this.defaultModulators;
+                    
+                    this.defaultModulators = newModulators;
+                    this.defaultModulators.push(...oldDefaults.filter(m => !this.defaultModulators.find(mm => Modulator.isIdentical(
+                        m,
+                        mm
+                    ))));
+                    this.soundFontInfo[chunk.header] = chunk.chunkData;
+                    break;
+                
+                default:
+                    text = readBytesAsString(chunk.chunkData, chunk.chunkData.length);
+                    this.soundFontInfo[chunk.header] = text;
+            }
+            
+            SpessaSynthInfo(
+                `%c"${chunk.header}": %c"${text}"`,
+                consoleColors.info,
+                consoleColors.recognized
+            );
+        }
+        
+        // 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");
+        /**
+         * @type {IndexedByteArray|Float32Array}
+         */
+        let sampleData;
+        // SF2Pack: the entire data is compressed
+        if (isSF2Pack)
+        {
+            SpessaSynthInfo(
+                "%cSF2Pack detected, attempting to decode the smpl chunk...",
+                consoleColors.info
+            );
+            try
+            {
+                /**
+                 * @type {Float32Array}
+                 */
+                sampleData = stbvorbis.decode(this.dataArray.buffer.slice(
+                    this.dataArray.currentIndex,
+                    this.dataArray.currentIndex + sdtaChunk.size - 12
+                )).data[0];
+            }
+            catch (e)
+            {
+                SpessaSynthGroupEnd();
+                throw new Error(`SF2Pack Ogg Vorbis decode error: ${e}`);
+            }
+            SpessaSynthInfo(
+                `%cDecoded the smpl chunk! Length: %c${sampleData.length}`,
+                consoleColors.info,
+                consoleColors.value
+            );
+        }
+        else
+        {
+            /**
+             * @type {IndexedByteArray}
+             */
+            sampleData = this.dataArray;
+            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.push(...readSamples(presetSamplesChunk, sampleData, !isSF2Pack));
+        
+        /**
+         * 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
+        );
+        
+        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);
+        
+        this.presets.push(...readPresets(presetHeadersChunk, presetZones, this));
+        this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
+        this._parseInternal();
+        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();
+        
+        if (isSF2Pack)
+        {
+            delete this.dataArray;
+        }
+    }
+    
+    /**
+     * @param chunk {RiffChunk}
+     * @param expected {string}
+     */
+    verifyHeader(chunk, expected)
+    {
+        if (chunk.header.toLowerCase() !== expected.toLowerCase())
+        {
+            SpessaSynthGroupEnd();
+            this.parsingError(`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();
+            this.parsingError(`Invalid FourCC: Expected "${expected.toLowerCase()}" got "${text.toLowerCase()}"\``);
+        }
+    }
+    
+    destroySoundBank()
+    {
+        super.destroySoundBank();
+        delete this.dataArray;
+    }
+}