spessasynth_lib 3.16.5 → 3.20.0

package/soundfont/dls/read_region.js

@@ -0,0 +1,129 @@
+import { readLittleEndian } from '../../utils/byte_functions/little_endian.js'
+import { findRIFFListType, readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { Generator, generatorTypes } from '../read_sf2/generators.js'
+import { DLSZone } from './dls_zone.js'
+
+/**
+ * @this {DLSSoundFont}
+ * @param chunk {RiffChunk}
+ * @returns {DLSZone}
+ */
+export function readRegion(chunk)
+{
+    // regions are essentially instrument zones
+
+    /**
+     * read chunks in the region
+     * @type {RiffChunk[]}
+     */
+    const regionChunks = [];
+    while(chunk.chunkData.length > chunk.chunkData.currentIndex)
+    {
+        regionChunks.push(readRIFFChunk(chunk.chunkData));
+    }
+
+    // region header
+    const regionHeader = regionChunks.find(c => c.header === "rgnh");
+    // key range
+    const keyMin = readLittleEndian(regionHeader.chunkData, 2);
+    const keyMax = readLittleEndian(regionHeader.chunkData, 2);
+    // vel range
+    const velMin = readLittleEndian(regionHeader.chunkData, 2);
+    const velMax = readLittleEndian(regionHeader.chunkData, 2);
+
+    const zone = new DLSZone(
+        {min: keyMin, max: keyMax},
+        {min: velMin, max: velMax}
+    )
+
+    // fusOptions: no idea about that one???
+    readLittleEndian(regionHeader.chunkData, 2);
+
+    // keyGroup: essentially exclusive class
+    const exclusive = readLittleEndian(regionHeader.chunkData, 2);
+    if(exclusive !== 0)
+    {
+        zone.generators.push(new Generator(generatorTypes.exclusiveClass, exclusive));
+    }
+
+    // lart
+    const lart = findRIFFListType(regionChunks, "lart");
+    const lar2 = findRIFFListType(regionChunks, "lar2");
+    this.readLart(lart, lar2, zone);
+
+    // wsmpl: wave sample chunk
+    zone.isGlobal = false;
+    const waveSampleChunk = regionChunks.find(c => c.header === "wsmp");
+    // cbSize
+    readLittleEndian(waveSampleChunk.chunkData, 4);
+    const originalKey = readLittleEndian(waveSampleChunk.chunkData, 2);
+    // pitch correction is read from the wave wsmpl chunk
+    readLittleEndian(waveSampleChunk.chunkData, 2);
+
+    // gain correction:  Each unit of gain represents 1/655360 dB
+    const gainCorrection = readLittleEndian(waveSampleChunk.chunkData, 4);
+    // convert to signed and turn into attenuation (invert)
+    const dbCorrection = (gainCorrection | 0) / -655360;
+    // convert to centibels
+    const attenuation = (dbCorrection * 10) / 0.4; // make sure to apply EMU correction
+
+    // skip options
+    readLittleEndian(waveSampleChunk.chunkData, 4);
+
+    // read loop count (always one or zero)
+    const loopsAmount = readLittleEndian(waveSampleChunk.chunkData, 4);
+    let loopingMode;
+    const loop = {start: 0, end: 0};
+    if(loopsAmount === 0)
+    {
+        // no loop
+        loopingMode = 0;
+    }
+    else
+    {
+        // ignore cbSize
+        readLittleEndian(waveSampleChunk.chunkData, 4);
+        // loop type: loop normally or loop until release (like soundfont)
+        const loopType = readLittleEndian(waveSampleChunk.chunkData, 4); // why is it long???
+        if(loopType === 0)
+        {
+            loopingMode = 1;
+        }
+        else
+        {
+            loopingMode = 3;
+        }
+        loop.start = readLittleEndian(waveSampleChunk.chunkData, 4);
+        const loopLength = readLittleEndian(waveSampleChunk.chunkData, 4);
+        loop.end = loop.start + loopLength;
+    }
+
+    // wave link
+    const waveLinkChunk = regionChunks.find(c => c.header === "wlnk");
+    if(waveLinkChunk === undefined)
+    {
+        // no wave link = no sample. What? Why is it even here then????
+        return undefined;
+    }
+
+    // flags
+    readLittleEndian(waveLinkChunk.chunkData, 2);
+    // phasse group
+    readLittleEndian(waveLinkChunk.chunkData, 2);
+    // channel
+    readLittleEndian(waveLinkChunk.chunkData, 4);
+    // sampleID
+    const sampleID = readLittleEndian(waveLinkChunk.chunkData, 4);
+    const sample = this.samples[sampleID];
+    if(sample === undefined)
+    {
+        throw new Error("Invalid sample ID!");
+    }
+    zone.setWavesample(
+        attenuation, loopingMode,
+        loop,
+        originalKey,
+        sample,
+        sampleID);
+    return zone;
+}

package/soundfont/dls/read_samples.js

@@ -0,0 +1,174 @@
+import { findRIFFListType, readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { readBytesAsString } from '../../utils/byte_functions/string.js'
+import {
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo, SpessaSynthWarn,
+} from '../../utils/loggin.js'
+import { consoleColors } from '../../utils/other.js'
+import { readLittleEndian, signedInt16 } from '../../utils/byte_functions/little_endian.js'
+import { DLSSample } from './dls_sample.js'
+
+/**
+ * @this {DLSSoundFont}
+ * @param waveListChunk {RiffChunk}
+ */
+export function readDLSSamples(waveListChunk)
+{
+    SpessaSynthGroupCollapsed("%cLoading Wave samples...",
+        consoleColors.recognized);
+    let sampleID = 0;
+    while(waveListChunk.chunkData.currentIndex < waveListChunk.chunkData.length)
+    {
+        const waveChunk = readRIFFChunk(waveListChunk.chunkData);
+        this.verifyHeader(waveChunk, "LIST");
+        this.verifyText(readBytesAsString(waveChunk.chunkData, 4), "wave");
+
+        /**
+         * @type {RiffChunk[]}
+         */
+        const waveChunks = [];
+        while(waveChunk.chunkData.currentIndex < waveChunk.chunkData.length)
+        {
+            waveChunks.push(readRIFFChunk(waveChunk.chunkData));
+        }
+
+        const fmtChunk = waveChunks.find(c => c.header === "fmt ");
+        if(!fmtChunk)
+        {
+            throw new Error("No fmt chunk in the wave file!");
+        }
+        const waveFormat = readLittleEndian(fmtChunk.chunkData, 2);
+        if(waveFormat !== 1)
+        {
+            throw new Error("Only PCM format in WAVE is supported.");
+        }
+        const channelsAmount = readLittleEndian(fmtChunk.chunkData, 2);
+        if(channelsAmount !== 1)
+        {
+            throw new Error("Only mono samples are supported.");
+        }
+        const sampleRate = readLittleEndian(fmtChunk.chunkData, 4);
+        // skip avg bytes
+        readLittleEndian(fmtChunk.chunkData, 4);
+        // blockAlign
+        readLittleEndian(fmtChunk.chunkData, 2);
+        // it's bits per sample because one channel
+        const wBitsPerSample = readLittleEndian(fmtChunk.chunkData, 2);
+        const bytesPerSample = wBitsPerSample / 8;
+
+        const maxSampleValue = Math.pow(2, bytesPerSample * 8 - 1); // Max value for the sample
+        const maxUnsigned = Math.pow(2, bytesPerSample * 8);
+
+        let normalizationFactor;
+        let isUnsigned = false;
+
+        if (wBitsPerSample === 8)
+        {
+            normalizationFactor = 255; // For 8-bit normalize from 0-255
+            isUnsigned = true;
+        }
+        else
+        {
+            normalizationFactor = maxSampleValue; // For 16-bit normalize from -32768 to 32767
+        }
+        // read the data
+        const dataChunk = waveChunks.find(c => c.header === "data");
+        if(!dataChunk)
+        {
+            throw new Error("No data chunk in the wave chunk!");
+        }
+        const sampleLength = dataChunk.size / bytesPerSample;
+        const sampleData = new Float32Array(sampleLength);
+        for (let i = 0; i < sampleData.length; i++)
+        {
+            // read
+            let sample = readLittleEndian(dataChunk.chunkData, bytesPerSample);
+            // turn into signed
+            if (isUnsigned)
+            {
+                // normalize unsigned 8-bit sample
+                sampleData[i] = (sample / normalizationFactor) - 0.5;
+            }
+            else
+            {
+                // normalize signed 16-bit sample
+                if (sample >= maxSampleValue)
+                {
+                    sample -= maxUnsigned;
+                }
+                sampleData[i] = sample / normalizationFactor;
+            }
+        }
+
+        // sane defaults
+        let sampleKey = 60;
+        let samplePitch = 0;
+        let sampleLoopStart = 0;
+        let sampleLoopEnd = sampleData.length - 1;
+
+        // read wsmp
+        const wsmpChunk = waveChunks.find(c => c.header === "wsmp")
+        if(wsmpChunk)
+        {
+            // skip cbsize
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            sampleKey = readLittleEndian(wsmpChunk.chunkData, 2);
+            // section 1.14.2: Each relative pitch unit represents 1/65536 cents.
+            // but that doesn't seem to be true for this one: it's just cents.
+            samplePitch = signedInt16(
+                wsmpChunk.chunkData[wsmpChunk.chunkData.currentIndex++],
+                wsmpChunk.chunkData[wsmpChunk.chunkData.currentIndex++]
+            );
+            // gain is handled in regions as initialAttenuation
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            // no idea about ful options
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            const loopsAmount = readLittleEndian(wsmpChunk.chunkData, 4);
+            if(loopsAmount === 1)
+            {
+                // skip size and type
+                readLittleEndian(wsmpChunk.chunkData, 8);
+                sampleLoopStart = readLittleEndian(wsmpChunk.chunkData, 4);
+                const loopSize = readLittleEndian(wsmpChunk.chunkData, 4);
+                sampleLoopEnd = sampleLoopStart + loopSize;
+            }
+        }
+        else
+        {
+            SpessaSynthWarn("No wsmp chunk in wave... using sane defaults.")
+        }
+
+        // read sample name
+        const waveInfo = findRIFFListType(waveChunks, "INFO");
+        let sampleName = `Unnamed ${sampleID}`;
+        if(waveInfo)
+        {
+            let infoChunk = readRIFFChunk(waveInfo.chunkData);
+            while(infoChunk.header !== "INAM" && waveInfo.chunkData.currentIndex < waveInfo.chunkData.length)
+            {
+                infoChunk = readRIFFChunk(waveInfo.chunkData);
+            }
+            if(infoChunk.header === "INAM")
+            {
+                sampleName = readBytesAsString(infoChunk.chunkData, infoChunk.size).trim();
+            }
+        }
+
+        this.samples.push(new DLSSample(
+            sampleName,
+            sampleRate,
+            sampleKey,
+            samplePitch,
+            sampleLoopStart,
+            sampleLength,
+            sampleData
+        ));
+
+        sampleID++;
+        SpessaSynthInfo(`%cLoaded sample %c${sampleName}`,
+            consoleColors.info,
+            consoleColors.recognized);
+    }
+    SpessaSynthGroupEnd();
+}

package/soundfont/load_soundfont.js

@@ -0,0 +1,21 @@
+import { IndexedByteArray } from '../utils/indexed_array.js'
+import { readBytesAsString } from '../utils/byte_functions/string.js'
+import { DLSSoundFont } from './dls/dls_soundfont.js'
+import { SoundFont2 } from './soundfont.js'
+
+/**
+ * Loads a soundfont file
+ * @param buffer {ArrayBuffer}
+ * @returns {BasicSoundFont}
+ */
+export function loadSoundFont(buffer)
+{
+    const check = buffer.slice(8, 12);
+    const a = new IndexedByteArray(check);
+    const id = readBytesAsString(a, 4, undefined, false).toLowerCase();
+    if(id === "dls ")
+    {
+        return new DLSSoundFont(buffer);
+    }
+    return new SoundFont2(buffer, false);
+}

package/soundfont/read_sf2/generators.js

@@ -149,6 +149,39 @@ generatorLimits[generatorTypes.exclusiveClass] = {min: 0, max: 99999, def: 0};
 generatorLimits[generatorTypes.overridingRootKey] = {min: 0-1, max: 127, def: -1};
 
 
+export class Generator
+{
+    /**
+     * Constructs a new generator
+     * @param type {generatorTypes|number}
+     * @param value {number}
+     */
+    constructor(type = generatorTypes.INVALID, value = 0)
+    {
+        this.generatorType = type;
+        if(value === undefined)
+        {
+            throw new Error("No value provided.");
+        }
+        const lim = generatorLimits[type];
+        this.generatorValue = Math.round(value);
+        if(lim !== undefined)
+        {
+            this.generatorValue = Math.max(lim.min, Math.min(lim.max, this.generatorValue));
+        }
+    }
+    /**
+     * The generator's enum number
+     * @type {generatorTypes|number}
+     */
+    generatorType = generatorTypes.INVALID;
+    /**
+     * The generator's 16-bit value
+     * @type {number}
+     */
+    generatorValue = 0;
+}
+
 /**
  * @param generatorType {number}
  * @param presetGens {Generator[]}
@@ -173,19 +206,21 @@ export function addAndClampGenerator(generatorType, presetGens, instrumentGens)
     return Math.max(limits.min, Math.min(limits.max, instruValue + presetValue));
 }
 
-
-export class Generator{
+export class ReadGenerator extends Generator
+{
     /**
      * Creates a generator
      * @param dataArray {IndexedByteArray}
      */
-    constructor(dataArray) {
+    constructor(dataArray)
+    {
+        super();
         // 4 bytes:
         // type, type, type, value
         const i = dataArray.currentIndex;
         /**
-         * @type {generatorTypes}
-         **/
+         * @type {generatorTypes|number}
+         */
         this.generatorType = (dataArray[i + 1] << 8) | dataArray[i];
         this.generatorValue = signedInt16(dataArray[i + 2], dataArray[i + 3]);
         dataArray.currentIndex += 4;
@@ -202,7 +237,7 @@ export function readGenerators(generatorChunk)
     let gens = [];
     while(generatorChunk.chunkData.length > generatorChunk.chunkData.currentIndex)
     {
-        gens.push(new Generator(generatorChunk.chunkData));
+        gens.push(new ReadGenerator(generatorChunk.chunkData));
     }
     if(gens.length > 1)
     {

package/soundfont/read_sf2/instruments.js

@@ -1,6 +1,6 @@
 import {RiffChunk} from "../basic_soundfont/riff_chunk.js";
 import {InstrumentZone} from "./zones.js";
-import {readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import {readLittleEndian} from "../../utils/byte_functions/little_endian.js";
 import { readBytesAsString } from '../../utils/byte_functions/string.js'
 import { BasicInstrument } from '../basic_soundfont/basic_instrument.js'
 
@@ -19,7 +19,7 @@ export class Instrument extends BasicInstrument
     {
         super();
         this.instrumentName = readBytesAsString(instrumentChunk.chunkData, 20).trim();
-        this.instrumentZoneIndex = readBytesAsUintLittleEndian(instrumentChunk.chunkData, 2);
+        this.instrumentZoneIndex = readLittleEndian(instrumentChunk.chunkData, 2);
         this.instrumentZonesAmount = 0;
     }
 

package/soundfont/read_sf2/modulators.js

@@ -1,4 +1,4 @@
-import {signedInt16, readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import {signedInt16, readLittleEndian} 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'
@@ -15,7 +15,8 @@ export const modulatorSources = {
     channelPressure: 13,
     pitchWheel: 14,
     pitchWheelRange: 16,
-    link: 127
+    link: 127,
+
 }
 
 export const modulatorCurveTypes = {
@@ -54,11 +55,11 @@ export class Modulator{
         }
         else
         {
-            this.modulatorSource = readBytesAsUintLittleEndian(dataArray, 2);
-            this.modulatorDestination = readBytesAsUintLittleEndian(dataArray, 2);
+            this.modulatorSource = readLittleEndian(dataArray, 2);
+            this.modulatorDestination = readLittleEndian(dataArray, 2);
             this.transformAmount = signedInt16(dataArray[dataArray.currentIndex++], dataArray[dataArray.currentIndex++]);
-            this.modulationSecondarySrc = readBytesAsUintLittleEndian(dataArray, 2);
-            this.transformType = readBytesAsUintLittleEndian(dataArray, 2);
+            this.modulationSecondarySrc = readLittleEndian(dataArray, 2);
+            this.transformType = readLittleEndian(dataArray, 2);
         }
 
         if(this.modulatorDestination > 58)
@@ -142,7 +143,7 @@ export class Modulator{
     }
 }
 
-function getModSourceEnum(curveType, polarity, direction, isCC, index)
+export function getModSourceEnum(curveType, polarity, direction, isCC, index)
 {
     return (curveType << 10) | (polarity << 9) | (direction << 8) | (isCC << 7) | index;
 }
@@ -189,7 +190,6 @@ export const defaultModulators = [
     }),
 
     // 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

package/soundfont/read_sf2/presets.js

@@ -1,6 +1,6 @@
 import {RiffChunk} from "../basic_soundfont/riff_chunk.js";
 import {PresetZone} from "./zones.js";
-import {readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import {readLittleEndian} from "../../utils/byte_functions/little_endian.js";
 import { readBytesAsString } from '../../utils/byte_functions/string.js'
 import { BasicPreset } from '../basic_soundfont/basic_preset.js'
 
@@ -21,14 +21,14 @@ export class Preset extends BasicPreset
             .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.program = readLittleEndian(presetChunk.chunkData, 2);
+        this.bank = readLittleEndian(presetChunk.chunkData, 2);
+        this.presetZoneStartIndex = readLittleEndian(presetChunk.chunkData, 2);
 
         // read the dwords
-        this.library = readBytesAsUintLittleEndian(presetChunk.chunkData, 4);
-        this.genre = readBytesAsUintLittleEndian(presetChunk.chunkData, 4);
-        this.morphology = readBytesAsUintLittleEndian(presetChunk.chunkData, 4);
+        this.library = readLittleEndian(presetChunk.chunkData, 4);
+        this.genre = readLittleEndian(presetChunk.chunkData, 4);
+        this.morphology = readLittleEndian(presetChunk.chunkData, 4);
         this.presetZonesAmount = 0;
     }
 

package/soundfont/read_sf2/samples.js

@@ -1,6 +1,6 @@
 import { RiffChunk } from '../basic_soundfont/riff_chunk.js'
 import { IndexedByteArray } from '../../utils/indexed_array.js'
-import { readBytesAsUintLittleEndian, signedInt8 } from '../../utils/byte_functions/little_endian.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'
@@ -239,19 +239,19 @@ function readSample(index, sampleHeaderData, smplArrayData, isDataRaw) {
     let sampleName = readBytesAsString(sampleHeaderData, 20);
 
     // read the sample start index
-    let sampleStartIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
+    let sampleStartIndex = readLittleEndian(sampleHeaderData, 4) * 2;
 
     // read the sample end index
-    let sampleEndIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
+    let sampleEndIndex = readLittleEndian(sampleHeaderData, 4) * 2;
 
     // read the sample looping start index
-    let sampleLoopStartIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
+    let sampleLoopStartIndex = readLittleEndian(sampleHeaderData, 4) * 2;
 
     // read the sample looping end index
-    let sampleLoopEndIndex = readBytesAsUintLittleEndian(sampleHeaderData, 4) * 2;
+    let sampleLoopEndIndex = readLittleEndian(sampleHeaderData, 4) * 2;
 
     // read the sample rate
-    let sampleRate = readBytesAsUintLittleEndian(sampleHeaderData, 4);
+    let sampleRate = readLittleEndian(sampleHeaderData, 4);
 
     // read the original sample pitch
     let samplePitch = sampleHeaderData[sampleHeaderData.currentIndex++];
@@ -266,8 +266,8 @@ function readSample(index, sampleHeaderData, smplArrayData, isDataRaw) {
 
 
     // read the link to the other channel
-    let sampleLink = readBytesAsUintLittleEndian(sampleHeaderData, 2);
-    let sampleType = readBytesAsUintLittleEndian(sampleHeaderData, 2);
+    let sampleLink = readLittleEndian(sampleHeaderData, 2);
+    let sampleType = readLittleEndian(sampleHeaderData, 2);
 
 
 

package/soundfont/read_sf2/zones.js

@@ -1,4 +1,4 @@
-import {readBytesAsUintLittleEndian} from "../../utils/byte_functions/little_endian.js";
+import {readLittleEndian} from "../../utils/byte_functions/little_endian.js";
 import {IndexedByteArray} from "../../utils/indexed_array.js";
 import {RiffChunk} from "../basic_soundfont/riff_chunk.js";
 import {Generator, generatorTypes} from "./generators.js";
@@ -20,8 +20,8 @@ export class InstrumentZone extends BasicInstrumentZone
     constructor(dataArray)
     {
         super();
-        this.generatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
-        this.modulatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
+        this.generatorZoneStartIndex = readLittleEndian(dataArray, 2);
+        this.modulatorZoneStartIndex = readLittleEndian(dataArray, 2);
         this.modulatorZoneSize = 0;
         this.generatorZoneSize = 0;
         this.isGlobal = true;
@@ -146,8 +146,8 @@ export class PresetZone extends BasicPresetZone
     constructor(dataArray)
     {
         super();
-        this.generatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
-        this.modulatorZoneStartIndex = readBytesAsUintLittleEndian(dataArray, 2);
+        this.generatorZoneStartIndex = readLittleEndian(dataArray, 2);
+        this.modulatorZoneStartIndex = readLittleEndian(dataArray, 2);
         this.modulatorZoneSize = 0;
         this.generatorZoneSize = 0;
         this.isGlobal = true;

package/soundfont/soundfont.js

@@ -1,6 +1,6 @@
 import { IndexedByteArray } from '../utils/indexed_array.js'
 import {readSamples} from "./read_sf2/samples.js";
-import { readBytesAsUintLittleEndian } from '../utils/byte_functions/little_endian.js'
+import { readLittleEndian } from '../utils/byte_functions/little_endian.js'
 import { readGenerators, Generator } from './read_sf2/generators.js'
 import {readInstrumentZones, InstrumentZone, readPresetZones} from "./read_sf2/zones.js";
 import { readPresets } from "./read_sf2/presets.js";
@@ -23,10 +23,15 @@ export class SoundFont2 extends BasicSoundFont
     /**
      * Initializes a new SoundFont2 Parser and parses the given data array
      * @param arrayBuffer {ArrayBuffer}
+     * @param warnDeprecated {boolean}
      */
-    constructor(arrayBuffer)
+    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)
@@ -66,7 +71,7 @@ export class SoundFont2 extends BasicSoundFont
             {
                 case  "ifil":
                 case "iver":
-                    text = `${readBytesAsUintLittleEndian(chunk.chunkData, 2)}.${readBytesAsUintLittleEndian(chunk.chunkData, 2)}`;
+                    text = `${readLittleEndian(chunk.chunkData, 2)}.${readLittleEndian(chunk.chunkData, 2)}`;
                     break;
 
                 case "icmt":

package/synthetizer/synthetizer.js

@@ -21,7 +21,7 @@ import { SoundfontManager } from './synth_soundfont_manager.js'
 
 /**
  * @typedef {Object} StartRenderingDataConfig
- * @property {MIDI} parsedMIDI - the MIDI to render
+ * @property {BasicMIDI} parsedMIDI - the MIDI to render
  * @property {SynthesizerSnapshot} snapshot - the snapshot to apply
  * @property {boolean|undefined} oneOutput - if synth should use one output with 32 channels (2 audio channels for each midi channel). this disables chorus and reverb.
  */