spessasynth_core 3.26.27 → 3.26.29

package/src/soundfont/read_sf2/soundfont.js

@@ -2,7 +2,7 @@ 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 { readPresetZones } from "./preset_zones.js";
+import { applyPresetZones } from "./preset_zones.js";
 import { readPresets } from "./presets.js";
 import { readInstruments } from "./instruments.js";
 import { readModulators } from "./modulators.js";
@@ -14,7 +14,8 @@ import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js"
 import { BasicSoundBank } from "../basic_soundfont/basic_soundbank.js";
 import { Generator } from "../basic_soundfont/generator.js";
 import { Modulator } from "../basic_soundfont/modulator.js";
-import { InstrumentZone, readInstrumentZones } from "./instrument_zones.js";
+import { applyInstrumentZones, InstrumentZone } from "./instrument_zones.js";
+import { readZoneIndexes } from "./zones.js";
 
 /**
  * soundfont.js
@@ -45,19 +46,19 @@ export class SoundFont2 extends BasicSoundBank
         {
             console.warn("Using the constructor directly is deprecated. Use loadSoundFont instead.");
         }
-        this.dataArray = new IndexedByteArray(arrayBuffer);
+        const mainFileArray = new IndexedByteArray(arrayBuffer);
         SpessaSynthGroup("%cParsing SoundFont...", consoleColors.info);
-        if (!this.dataArray)
+        if (!mainFileArray)
         {
             SpessaSynthGroupEnd();
             this.parsingError("No data provided!");
         }
         
         // read the main read
-        let firstChunk = readRIFFChunk(this.dataArray, false);
+        let firstChunk = readRIFFChunk(mainFileArray, false);
         this.verifyHeader(firstChunk, "riff");
         
-        const type = readBytesAsString(this.dataArray, 4).toLowerCase();
+        const type = readBytesAsString(mainFileArray, 4).toLowerCase();
         if (type !== "sfbk" && type !== "sfpk")
         {
             SpessaSynthGroupEnd();
@@ -71,9 +72,20 @@ export class SoundFont2 extends BasicSoundBank
         const isSF2Pack = type === "sfpk";
         
         // INFO
-        let infoChunk = readRIFFChunk(this.dataArray);
+        let infoChunk = readRIFFChunk(mainFileArray);
         this.verifyHeader(infoChunk, "list");
-        readBytesAsString(infoChunk.chunkData, 4);
+        const infoString = readBytesAsString(infoChunk.chunkData, 4);
+        if (infoString !== "INFO")
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid soundFont! Expected "INFO" or "${infoString}"`);
+        }
+        
+        /**
+         * @type {RiffChunk|undefined}
+         */
+        let xdtaChunk = undefined;
+        
         
         while (infoChunk.chunkData.length > infoChunk.chunkData.currentIndex)
         {
@@ -104,6 +116,16 @@ export class SoundFont2 extends BasicSoundBank
                     this.soundFontInfo[chunk.header] = text;
                     break;
                 
+                case "list":
+                    // possible xdta
+                    const listType = readBytesAsString(chunk.chunkData, 4);
+                    if (listType === "xdta")
+                    {
+                        SpessaSynthInfo("%cExtended SF2 found!", consoleColors.recognized);
+                        xdtaChunk = chunk;
+                    }
+                    break;
+                
                 default:
                     text = readBytesAsString(chunk.chunkData, chunk.chunkData.length);
                     this.soundFontInfo[chunk.header] = text;
@@ -115,15 +137,44 @@ export class SoundFont2 extends BasicSoundBank
                 consoleColors.recognized
             );
         }
+        // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+        const isExtended = xdtaChunk !== undefined;
+        /**
+         * @type {{
+         *     phdr: RiffChunk,
+         *     pbag: RiffChunk,
+         *     pmod: RiffChunk,
+         *     pgen: RiffChunk,
+         *     inst: RiffChunk,
+         *     ibag: RiffChunk,
+         *     imod: RiffChunk,
+         *     igen: RiffChunk,
+         *     shdr: RiffChunk,
+         * }}
+         */
+        let xChunks = {};
+        if (isExtended)
+        {
+            // read the hydra chunks
+            xChunks.phdr = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.pbag = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.pmod = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.pgen = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.inst = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.ibag = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.imod = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.igen = readRIFFChunk(xdtaChunk.chunkData);
+            xChunks.shdr = readRIFFChunk(xdtaChunk.chunkData);
+        }
         
         // SDTA
-        const sdtaChunk = readRIFFChunk(this.dataArray, false);
+        const sdtaChunk = readRIFFChunk(mainFileArray, false);
         this.verifyHeader(sdtaChunk, "list");
-        this.verifyText(readBytesAsString(this.dataArray, 4), "sdta");
+        this.verifyText(readBytesAsString(mainFileArray, 4), "sdta");
         
         // smpl
         SpessaSynthInfo("%cVerifying smpl chunk...", consoleColors.warn);
-        let sampleDataChunk = readRIFFChunk(this.dataArray, false);
+        let sampleDataChunk = readRIFFChunk(mainFileArray, false);
         this.verifyHeader(sampleDataChunk, "smpl");
         /**
          * @type {IndexedByteArray|Float32Array}
@@ -141,9 +192,9 @@ export class SoundFont2 extends BasicSoundBank
                 /**
                  * @type {Float32Array}
                  */
-                sampleData = stbvorbis.decode(this.dataArray.buffer.slice(
-                    this.dataArray.currentIndex,
-                    this.dataArray.currentIndex + sdtaChunk.size - 12
+                sampleData = stbvorbis.decode(mainFileArray.buffer.slice(
+                    mainFileArray.currentIndex,
+                    mainFileArray.currentIndex + sdtaChunk.size - 12
                 )).data[0];
             }
             catch (e)
@@ -162,8 +213,8 @@ export class SoundFont2 extends BasicSoundBank
             /**
              * @type {IndexedByteArray}
              */
-            sampleData = this.dataArray;
-            this.sampleDataStartIndex = this.dataArray.currentIndex;
+            sampleData = mainFileArray;
+            this.sampleDataStartIndex = mainFileArray.currentIndex;
         }
         
         SpessaSynthInfo(
@@ -171,68 +222,128 @@ export class SoundFont2 extends BasicSoundBank
             consoleColors.info,
             consoleColors.value
         );
-        this.dataArray.currentIndex += sdtaChunk.size - 12;
+        mainFileArray.currentIndex += sdtaChunk.size - 12;
         
         // PDTA
         SpessaSynthInfo("%cLoading preset data chunk...", consoleColors.warn);
-        let presetChunk = readRIFFChunk(this.dataArray);
+        let presetChunk = readRIFFChunk(mainFileArray);
         this.verifyHeader(presetChunk, "list");
         readBytesAsString(presetChunk.chunkData, 4);
         
         // read the hydra chunks
-        const pHdrChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(pHdrChunk, "phdr");
+        const phdrChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(phdrChunk, "phdr");
         
-        const pBagChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(pBagChunk, "pbag");
+        const pbagChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(pbagChunk, "pbag");
         
-        const pModChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(pModChunk, "pmod");
+        const pmodChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(pmodChunk, "pmod");
         
-        const pGenChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(pGenChunk, "pgen");
+        const pgenChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(pgenChunk, "pgen");
         
         const instChunk = readRIFFChunk(presetChunk.chunkData);
         this.verifyHeader(instChunk, "inst");
         
-        const iBagChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(iBagChunk, "ibag");
+        const ibagChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(ibagChunk, "ibag");
         
-        const iModChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(iModChunk, "imod");
+        const imodChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(imodChunk, "imod");
         
-        const iGenChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(iGenChunk, "igen");
+        const igenChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(igenChunk, "igen");
         
-        const sHdrChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(sHdrChunk, "shdr");
+        const shdrChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(shdrChunk, "shdr");
         
         /**
          * read all the samples
          * (the current index points to start of the smpl read)
          */
-        this.dataArray.currentIndex = this.sampleDataStartIndex;
-        this.samples.push(...readSamples(sHdrChunk, sampleData, !isSF2Pack));
+        mainFileArray.currentIndex = this.sampleDataStartIndex;
+        const samples = readSamples(shdrChunk, sampleData, !isExtended);
+        
+        if (isExtended)
+        {
+            // apply extensions to samples
+            const xSamples = readSamples(xChunks.shdr, new Float32Array(1), false);
+            if (xSamples.length === samples.length)
+            {
+                samples.forEach((s, i) =>
+                {
+                    s.sampleName += xSamples[i].sampleName;
+                    s.linkedSampleIndex |= xSamples[i].linkedSampleIndex << 16;
+                });
+            }
+            
+        }
+        // trim names
+        samples.forEach(s => s.sampleName = s.sampleName.trim());
+        this.samples.push(...samples);
         
         /**
          * read all the instrument generators
          * @type {Generator[]}
          */
-        let instrumentGenerators = readGenerators(iGenChunk);
+        let instrumentGenerators = readGenerators(igenChunk);
         
         /**
          * read all the instrument modulators
          * @type {Modulator[]}
          */
-        let instrumentModulators = readModulators(iModChunk);
+        let instrumentModulators = readModulators(imodChunk);
+        
+        const instruments = readInstruments(instChunk);
+        
+        if (isExtended)
+        {
+            // apply extensions to instruments
+            const xInst = readInstruments(xChunks.inst);
+            if (xInst.length === instruments.length)
+            {
+                instruments.forEach((inst, i) =>
+                {
+                    inst.instrumentName += xInst[i].instrumentName;
+                    inst.zoneStartIndex |= xInst[i].zoneStartIndex;
+                });
+                // adjust zone counts
+                instruments.forEach((inst, i) =>
+                {
+                    if (i < instruments.length - 1)
+                    {
+                        inst.zonesCount = instruments[i + 1].zoneStartIndex - inst.zoneStartIndex;
+                    }
+                });
+            }
+            
+        }
+        // trim names
+        instruments.forEach(i => i.instrumentName = i.instrumentName.trim());
+        this.instruments.push(...instruments);
+        
+        const ibagIndexes = readZoneIndexes(ibagChunk);
+        
+        if (isExtended)
+        {
+            const extraIndexes = readZoneIndexes(xChunks.ibag);
+            for (let i = 0; i < ibagIndexes.mod.length; i++)
+            {
+                ibagIndexes.mod[i] |= extraIndexes.mod[i] << 16;
+            }
+            for (let i = 0; i < ibagIndexes.gen.length; i++)
+            {
+                ibagIndexes.gen[i] |= extraIndexes.gen[i] << 16;
+            }
+        }
         
-        this.instruments = readInstruments(instChunk);
         /**
          * read all the instrument zones (and apply them)
          * @type {InstrumentZone[]}
          */
-        readInstrumentZones(
-            iBagChunk,
+        applyInstrumentZones(
+            ibagIndexes,
             instrumentGenerators,
             instrumentModulators,
             this.samples,
@@ -243,17 +354,59 @@ export class SoundFont2 extends BasicSoundBank
          * read all the preset generators
          * @type {Generator[]}
          */
-        let presetGenerators = readGenerators(pGenChunk);
+        let presetGenerators = readGenerators(pgenChunk);
         
         /**
          * Read all the preset modulatorrs
          * @type {Modulator[]}
          */
-        let presetModulators = readModulators(pModChunk);
+        let presetModulators = readModulators(pmodChunk);
+        
+        const presets = readPresets(phdrChunk, this);
+        
+        if (isExtended)
+        {
+            // apply extensions to presets
+            const xPreset = readPresets(xChunks.phdr, this);
+            if (xPreset.length === presets.length)
+            {
+                presets.forEach((pres, i) =>
+                {
+                    pres.presetName += xPreset[i].presetName;
+                    pres.zoneStartIndex |= xPreset[i].zoneStartIndex;
+                });
+                // adjust zone counts
+                presets.forEach((preset, i) =>
+                {
+                    if (i < instruments.length - 1)
+                    {
+                        preset.zonesCount = presets[i + 1].zoneStartIndex - preset.zoneStartIndex;
+                    }
+                });
+            }
+            
+        }
+        
+        // trim names
+        presets.forEach(p => p.presetName === p.presetName.trim());
+        this.addPresets(...presets);
         
-        this.addPresets(...readPresets(pHdrChunk, this));
+        const pbagIndexes = readZoneIndexes(pbagChunk);
         
-        readPresetZones(pBagChunk, presetGenerators, presetModulators, this.instruments, this.presets);
+        if (isExtended)
+        {
+            const extraIndexes = readZoneIndexes(xChunks.pbag);
+            for (let i = 0; i < pbagIndexes.mod.length; i++)
+            {
+                pbagIndexes.mod[i] |= extraIndexes.mod[i] << 16;
+            }
+            for (let i = 0; i < pbagIndexes.gen.length; i++)
+            {
+                pbagIndexes.gen[i] |= extraIndexes.gen[i] << 16;
+            }
+        }
+        
+        applyPresetZones(pbagIndexes, presetGenerators, presetModulators, this.instruments, this.presets);
         this.flush();
         SpessaSynthInfo(
             `%cParsing finished! %c"${this.soundFontInfo["INAM"]}"%c has %c${this.presets.length} %cpresets,
@@ -269,11 +422,6 @@ export class SoundFont2 extends BasicSoundBank
             consoleColors.info
         );
         SpessaSynthGroupEnd();
-        
-        if (isSF2Pack)
-        {
-            delete this.dataArray;
-        }
     }
     
     /**
@@ -301,10 +449,4 @@ export class SoundFont2 extends BasicSoundBank
             this.parsingError(`Invalid FourCC: Expected "${expected.toLowerCase()}" got "${text.toLowerCase()}"\``);
         }
     }
-    
-    destroySoundBank()
-    {
-        super.destroySoundBank();
-        delete this.dataArray;
-    }
 }

package/src/soundfont/read_sf2/zones.js

@@ -0,0 +1,28 @@
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+
+/**
+ *
+ * @param zonesChunk {RiffChunk} both pbag and ibag work
+ * @returns {{mod: number[], gen: number[]}}
+ */
+export function readZoneIndexes(zonesChunk)
+{
+    /**
+     * @type {number[]}
+     */
+    const modStartIndexes = [];
+    /**
+     * @type {number[]}
+     */
+    const genStartIndexes = [];
+    
+    while (zonesChunk.chunkData.length > zonesChunk.chunkData.currentIndex)
+    {
+        genStartIndexes.push(readLittleEndian(zonesChunk.chunkData, 2));
+        modStartIndexes.push(readLittleEndian(zonesChunk.chunkData, 2));
+    }
+    return {
+        mod: modStartIndexes,
+        gen: genStartIndexes
+    };
+}