spessasynth_core 3.26.20 → 3.26.22

package/src/soundfont/dls/read_instrument.js

@@ -52,7 +52,7 @@ export function readDLSInstrument(chunk)
         presetName = readBytesAsString(info.chunkData, info.chunkData.length).trim();
     }
     preset.presetName = presetName;
-    preset.DLSInstrument.instrumentName = presetName;
+    preset.dlsInstrument.instrumentName = presetName;
     SpessaSynthGroupCollapsed(
         `%cParsing %c"${presetName}"%c...`,
         consoleColors.info,
@@ -69,7 +69,7 @@ export function readDLSInstrument(chunk)
     }
     
     // global articulation: essentially global zone
-    const globalZone = preset.DLSInstrument.globalZone;
+    const globalZone = preset.dlsInstrument.globalZone;
     
     // read articulators
     const globalLart = findRIFFListType(chunks, "lart");
@@ -105,14 +105,10 @@ export function readDLSInstrument(chunk)
         }
         
         
-        const zone = this.readRegion(chunk);
-        if (zone)
-        {
-            preset.DLSInstrument.addZones(zone);
-        }
+        const zone = preset.dlsInstrument.createZone();
+        this.readRegion(chunk, zone);
     }
-    
     this.addPresets(preset);
-    this.addInstruments(preset.DLSInstrument);
+    this.addInstruments(preset.dlsInstrument);
     SpessaSynthGroupEnd();
 }

package/src/soundfont/dls/read_region.js

@@ -1,15 +1,14 @@
 import { readLittleEndian, signedInt16 } from "../../utils/byte_functions/little_endian.js";
 import { findRIFFListType, readRIFFChunk } from "../basic_soundfont/riff_chunk.js";
-import { DLSZone } from "./dls_zone.js";
 import { Generator } from "../basic_soundfont/generator.js";
 import { generatorTypes } from "../basic_soundfont/generator_types.js";
 
 /**
  * @this {DLSSoundFont}
  * @param chunk {RiffChunk}
- * @returns {DLSZone}
+ * @param zone {DLSZone}
  */
-export function readRegion(chunk)
+export function readRegion(chunk, zone)
 {
     // regions are essentially instrument zones
     
@@ -40,10 +39,9 @@ export function readRegion(chunk)
     }
     // cannot do the same to key zones sadly
     
-    const zone = new DLSZone(
-        { min: keyMin, max: keyMax },
-        { min: velMin, max: velMax }
-    );
+    // apply ranges
+    zone.keyRange = { min: keyMin, max: keyMax };
+    zone.velRange = { min: velMin, max: velMax };
     
     // fusOptions: no idea about that one???
     readLittleEndian(regionHeader.chunkData, 2);
@@ -148,5 +146,4 @@ export function readRegion(chunk)
         sampleID,
         pitchCorrection
     );
-    return zone;
 }

package/src/soundfont/read_sf2/generators.js

@@ -37,10 +37,7 @@ export function readGenerators(generatorChunk)
     {
         gens.push(new ReadGenerator(generatorChunk.chunkData));
     }
-    if (gens.length > 1)
-    {
-        // remove terminal
-        gens.pop();
-    }
+    // remove terminal
+    gens.pop();
     return gens;
 }

package/src/soundfont/read_sf2/instrument_zones.js

@@ -0,0 +1,88 @@
+/**
+ * instrument_zones.js
+ * purpose: reads instrument zones from soundfont and gets their respective samples and generators and modulators
+ */
+import { BasicInstrumentZone } from "../basic_soundfont/basic_instrument_zone.js";
+import { generatorTypes } from "../basic_soundfont/generator_types.js";
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+
+export class InstrumentZone extends BasicInstrumentZone
+{
+    /**
+     * Creates a zone (instrument)
+     * @param inst {Instrument}
+     */
+    constructor(inst)
+    {
+        super(inst);
+    }
+    
+    /**
+     * Loads the zone's sample
+     * @param samples {BasicSample[]}
+     */
+    getSample(samples)
+    {
+        let sampleID = this.generators.find(g => g.generatorType === generatorTypes.sampleID);
+        if (sampleID)
+        {
+            this.setSample(samples[sampleID.generatorValue]);
+        }
+    }
+}
+
+/**
+ * Reads the given instrument zone
+ * @param zonesChunk {RiffChunk}
+ * @param instrumentGenerators {Generator[]}
+ * @param instrumentModulators {Modulator[]}
+ * @param samples {BasicSample[]}
+ * @param instruments {Instrument[]}
+ */
+export function readInstrumentZones(zonesChunk, instrumentGenerators, instrumentModulators, samples, instruments)
+{
+    /**
+     * @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));
+    }
+    
+    let modIndex = 0;
+    let genIndex = 0;
+    for (const instrument of instruments)
+    {
+        for (let i = 0; i < instrument.zonesCount; i++)
+        {
+            const gensStart = genStartIndexes[genIndex++];
+            const gensEnd = genStartIndexes[genIndex];
+            const gens = instrumentGenerators.slice(gensStart, gensEnd);
+            const modsStart = modStartIndexes[modIndex++];
+            const modsEnd = modStartIndexes[modIndex];
+            const mods = instrumentModulators.slice(modsStart, modsEnd);
+            // check for global zone
+            if (gens.find(g => g.generatorType === generatorTypes.sampleID))
+            {
+                // regular zone
+                const zone = instrument.createZone();
+                zone.addGenerators(...gens);
+                zone.addModulators(...mods);
+                zone.getSample(samples);
+            }
+            else
+            {
+                // global zone
+                instrument.globalZone.addGenerators(...gens);
+                instrument.globalZone.addModulators(...mods);
+            }
+        }
+    }
+}

package/src/soundfont/read_sf2/instruments.js

@@ -1,9 +1,10 @@
 import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
-import { InstrumentZone } from "./zones.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";
 
+import { InstrumentZone } from "./instrument_zones.js";
+
 /**
  * instrument.js
  * purpose: parses soundfont instrument and stores them as a class
@@ -11,6 +12,15 @@ import { BasicInstrument } from "../basic_soundfont/basic_instrument.js";
 
 export class Instrument extends BasicInstrument
 {
+    /**
+     * @type {number}
+     */
+    zoneStartIndex;
+    /**
+     * @type {number}
+     */
+    zonesCount = 0;
+    
     /**
      * Creates an instrument
      * @param instrumentChunk {RiffChunk}
@@ -19,57 +29,43 @@ export class Instrument extends BasicInstrument
     {
         super();
         this.instrumentName = readBytesAsString(instrumentChunk.chunkData, 20).trim();
-        this.instrumentZoneIndex = readLittleEndian(instrumentChunk.chunkData, 2);
-        this.instrumentZonesAmount = 0;
+        this.zoneStartIndex = readLittleEndian(instrumentChunk.chunkData, 2);
     }
     
     /**
-     * Loads all the instrument zones, given the amount
-     * @param amount {number}
-     * @param zones {InstrumentZone[]}
+     * @returns {InstrumentZone}
      */
-    getInstrumentZones(amount, zones)
+    createZone()
     {
-        this.instrumentZonesAmount = amount;
-        for (let i = this.instrumentZoneIndex; i < this.instrumentZonesAmount + this.instrumentZoneIndex; i++)
-        {
-            const zone = zones[i];
-            if (zone.hasSample())
-            {
-                this.addZones(zone);
-            }
-            else
-            {
-                // global!
-                this.globalZone.copyFrom(zone);
-            }
-        }
+        const z = new InstrumentZone(this);
+        this.instrumentZones.push(z);
+        return z;
     }
 }
 
 /**
  * Reads the instruments
  * @param instrumentChunk {RiffChunk}
- * @param instrumentZones {InstrumentZone[]}
  * @returns {Instrument[]}
  */
-export function readInstruments(instrumentChunk, instrumentZones)
+export function readInstruments(instrumentChunk)
 {
+    /**
+     * @type {Instrument[]}
+     */
     let instruments = [];
     while (instrumentChunk.chunkData.length > instrumentChunk.chunkData.currentIndex)
     {
         let instrument = new Instrument(instrumentChunk);
+        
         if (instruments.length > 0)
         {
-            let instrumentsAmount = instrument.instrumentZoneIndex - instruments[instruments.length - 1].instrumentZoneIndex;
-            instruments[instruments.length - 1].getInstrumentZones(instrumentsAmount, instrumentZones);
+            const previous = instruments[instruments.length - 1];
+            previous.zonesCount = instrument.zoneStartIndex - previous.zoneStartIndex;
         }
         instruments.push(instrument);
     }
-    if (instruments.length > 1)
-    {
-        // remove EOI
-        instruments.pop();
-    }
+    // remove EOI
+    instruments.pop();
     return instruments;
 }

package/src/soundfont/read_sf2/modulators.js

@@ -19,5 +19,7 @@ export function readModulators(modulatorChunk)
         const transformType = readLittleEndian(dataArray, 2);
         mods.push(new DecodedModulator(sourceEnum, secondarySourceEnum, destination, amount, transformType));
     }
+    // remove terminal
+    mods.pop();
     return mods;
 }

package/src/soundfont/read_sf2/preset_zones.js

@@ -0,0 +1,92 @@
+import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
+import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
+import { BasicPresetZone } from "../basic_soundfont/basic_preset_zone.js";
+import { Generator } from "../basic_soundfont/generator.js";
+import { Modulator } from "../basic_soundfont/modulator.js";
+import { generatorTypes } from "../basic_soundfont/generator_types.js";
+
+/**
+ * preset_zones.js
+ * purpose: reads preset zones from soundfont and gets their respective samples and generators and modulators
+ */
+
+export class PresetZone extends BasicPresetZone
+{
+    /**
+     * Creates a zone (preset)
+     * @param preset {BasicPreset}
+     */
+    constructor(preset)
+    {
+        super(preset);
+    }
+    
+    /**
+     * grab the instrument
+     * @param instruments {BasicInstrument[]}
+     */
+    getInstrument(instruments)
+    {
+        let instrumentID = this.generators.find(g => g.generatorType === generatorTypes.instrument);
+        if (instrumentID)
+        {
+            this.setInstrument(instruments[instrumentID.generatorValue]);
+        }
+    }
+}
+
+/**
+ * Reads the given preset zone read
+ * @param zonesChunk {RiffChunk}
+ * @param presetGens {Generator[]}
+ * @param instruments {BasicInstrument[]}
+ * @param presetMods {Modulator[]}
+ * @param presets {Preset[]}
+ */
+export function readPresetZones(zonesChunk, presetGens, presetMods, instruments, presets)
+{
+    /**
+     * @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));
+    }
+    
+    let modIndex = 0;
+    let genIndex = 0;
+    for (const preset of presets)
+    {
+        for (let i = 0; i < preset.zonesCount; i++)
+        {
+            const gensStart = genStartIndexes[genIndex++];
+            const gensEnd = genStartIndexes[genIndex];
+            const gens = presetGens.slice(gensStart, gensEnd);
+            const modsStart = modStartIndexes[modIndex++];
+            const modsEnd = modStartIndexes[modIndex];
+            const mods = presetMods.slice(modsStart, modsEnd);
+            // check for global zone
+            if (gens.find(g => g.generatorType === generatorTypes.instrument) !== undefined)
+            {
+                // regular zone
+                const zone = preset.createZone();
+                zone.addGenerators(...gens);
+                zone.addModulators(...mods);
+                zone.getInstrument(instruments);
+            }
+            else
+            {
+                // global zone
+                preset.globalZone.addGenerators(...gens);
+                preset.globalZone.addModulators(...mods);
+            }
+        }
+    }
+}

package/src/soundfont/read_sf2/presets.js

@@ -1,8 +1,8 @@
 import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
-import { PresetZone } from "./zones.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";
+import { PresetZone } from "./preset_zones.js";
 
 /**
  * parses soundfont presets, also includes function for getting the generators and samples from midi note and velocity
@@ -10,6 +10,16 @@ import { BasicPreset } from "../basic_soundfont/basic_preset.js";
 
 export class Preset extends BasicPreset
 {
+    
+    /**
+     * @type {number}
+     */
+    zoneStartIndex;
+    /**
+     * @type {number}
+     */
+    zonesCount = 0;
+    
     /**
      * Creates a preset
      * @param presetChunk {RiffChunk}
@@ -24,47 +34,32 @@ export class Preset extends BasicPreset
         
         this.program = readLittleEndian(presetChunk.chunkData, 2);
         this.bank = readLittleEndian(presetChunk.chunkData, 2);
-        this.presetZoneStartIndex = readLittleEndian(presetChunk.chunkData, 2);
+        this.zoneStartIndex = readLittleEndian(presetChunk.chunkData, 2);
         
         // read the dword
         this.library = readLittleEndian(presetChunk.chunkData, 4);
         this.genre = readLittleEndian(presetChunk.chunkData, 4);
         this.morphology = readLittleEndian(presetChunk.chunkData, 4);
-        this.presetZonesAmount = 0;
     }
     
     /**
-     * Loads all the preset zones, given the amount
-     * @param amount {number}
-     * @param zones {PresetZone[]}
+     * @returns {PresetZone}
      */
-    getPresetZones(amount, zones)
+    createZone()
     {
-        this.presetZonesAmount = amount;
-        for (let i = this.presetZoneStartIndex; i < this.presetZonesAmount + this.presetZoneStartIndex; i++)
-        {
-            const zone = zones[i];
-            if (zone.hasInstrument())
-            {
-                this.presetZones.push(zone);
-            }
-            else
-            {
-                // global!
-                this.globalZone.copyFrom(zone);
-            }
-        }
+        const z = new PresetZone(this);
+        this.presetZones.push(z);
+        return z;
     }
 }
 
 /**
  * Reads the presets
  * @param presetChunk {RiffChunk}
- * @param presetZones {PresetZone[]}
- * @param sf2 {BasicSoundBank}
+ * @param parent {BasicSoundBank}
  * @returns {Preset[]}
  */
-export function readPresets(presetChunk, presetZones, sf2)
+export function readPresets(presetChunk, parent)
 {
     /**
      * @type {Preset[]}
@@ -72,18 +67,15 @@ export function readPresets(presetChunk, presetZones, sf2)
     let presets = [];
     while (presetChunk.chunkData.length > presetChunk.chunkData.currentIndex)
     {
-        let preset = new Preset(presetChunk, sf2);
+        let preset = new Preset(presetChunk, parent);
         if (presets.length > 0)
         {
-            let presetZonesAmount = preset.presetZoneStartIndex - presets[presets.length - 1].presetZoneStartIndex;
-            presets[presets.length - 1].getPresetZones(presetZonesAmount, presetZones);
+            const previous = presets[presets.length - 1];
+            previous.zonesCount = preset.zoneStartIndex - previous.zoneStartIndex;
         }
         presets.push(preset);
     }
     // remove EOP
-    if (presets.length > 1)
-    {
-        presets.pop();
-    }
+    presets.pop();
     return presets;
 }

package/src/soundfont/read_sf2/samples.js

@@ -205,7 +205,10 @@ export class SoundFontSample extends BasicSample
          * read the sample data
          * @type {Float32Array}
          */
-        let audioData = this.sampleDataArray.slice(this.sampleStartIndex / 2, this.sampleEndIndex / 2);
+        let audioData = /**@type {Float32Array}*/ this.sampleDataArray.slice(
+            this.sampleStartIndex / 2,
+            this.sampleEndIndex / 2
+        );
         this.sampleData = audioData;
         this.isSampleLoaded = true;
         return audioData;
@@ -233,10 +236,7 @@ export function readSamples(sampleHeadersChunk, smplChunkData, isSmplDataRaw = t
         index++;
     }
     // remove EOS
-    if (samples.length > 1)
-    {
-        samples.pop();
-    }
+    samples.pop();
     return samples;
 }
 

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 { InstrumentZone, readInstrumentZones, readPresetZones } from "./zones.js";
+import { readPresetZones } from "./preset_zones.js";
 import { readPresets } from "./presets.js";
 import { readInstruments } from "./instruments.js";
 import { readModulators } from "./modulators.js";
@@ -14,6 +14,7 @@ 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";
 
 /**
  * soundfont.js
@@ -22,6 +23,16 @@ import { Modulator } from "../basic_soundfont/modulator.js";
 
 export class SoundFont2 extends BasicSoundBank
 {
+    /**
+     * @type {Instrument[]}
+     */
+    instruments = [];
+    
+    /**
+     * @type {Preset[]}
+     */
+    presets = [];
+    
     /**
      * Initializes a new SoundFont2 Parser and parses the given data array
      * @param arrayBuffer {ArrayBuffer}
@@ -170,79 +181,80 @@ export class SoundFont2 extends BasicSoundBank
         readBytesAsString(presetChunk.chunkData, 4);
         
         // read the hydra chunks
-        const presetHeadersChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetHeadersChunk, "phdr");
+        const pHdrChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(pHdrChunk, "phdr");
         
-        const presetZonesChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetZonesChunk, "pbag");
+        const pBagChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(pBagChunk, "pbag");
         
-        const presetModulatorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetModulatorsChunk, "pmod");
+        const pModChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(pModChunk, "pmod");
         
-        const presetGeneratorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetGeneratorsChunk, "pgen");
+        const pGenChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(pGenChunk, "pgen");
         
-        const presetInstrumentsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentsChunk, "inst");
+        const instChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(instChunk, "inst");
         
-        const presetInstrumentZonesChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentZonesChunk, "ibag");
+        const iBagChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(iBagChunk, "ibag");
         
-        const presetInstrumentModulatorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentModulatorsChunk, "imod");
+        const iModChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(iModChunk, "imod");
         
-        const presetInstrumentGeneratorsChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetInstrumentGeneratorsChunk, "igen");
+        const iGenChunk = readRIFFChunk(presetChunk.chunkData);
+        this.verifyHeader(iGenChunk, "igen");
         
-        const presetSamplesChunk = readRIFFChunk(presetChunk.chunkData);
-        this.verifyHeader(presetSamplesChunk, "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(presetSamplesChunk, sampleData, !isSF2Pack));
+        this.samples.push(...readSamples(sHdrChunk, sampleData, !isSF2Pack));
         
         /**
          * read all the instrument generators
          * @type {Generator[]}
          */
-        let instrumentGenerators = readGenerators(presetInstrumentGeneratorsChunk);
+        let instrumentGenerators = readGenerators(iGenChunk);
         
         /**
          * read all the instrument modulators
          * @type {Modulator[]}
          */
-        let instrumentModulators = readModulators(presetInstrumentModulatorsChunk);
+        let instrumentModulators = readModulators(iModChunk);
+        
+        this.instruments = readInstruments(instChunk);
         /**
-         * read all the instrument zones
+         * read all the instrument zones (and apply them)
          * @type {InstrumentZone[]}
          */
-        let instrumentZones = readInstrumentZones(
-            presetInstrumentZonesChunk,
+        readInstrumentZones(
+            iBagChunk,
             instrumentGenerators,
             instrumentModulators,
-            this.samples
+            this.samples,
+            this.instruments
         );
         
-        this.instruments = readInstruments(presetInstrumentsChunk, instrumentZones);
-        
         /**
          * read all the preset generators
          * @type {Generator[]}
          */
-        let presetGenerators = readGenerators(presetGeneratorsChunk);
+        let presetGenerators = readGenerators(pGenChunk);
         
         /**
          * Read all the preset modulatorrs
          * @type {Modulator[]}
          */
-        let presetModulators = readModulators(presetModulatorsChunk);
+        let presetModulators = readModulators(pModChunk);
         
-        let presetZones = readPresetZones(presetZonesChunk, presetGenerators, presetModulators, this.instruments);
+        this.addPresets(...readPresets(pHdrChunk, this));
         
-        this.addPresets(...readPresets(presetHeadersChunk, presetZones, this));
+        readPresetZones(pBagChunk, presetGenerators, presetModulators, this.instruments, this.presets);
         this.flush();
         SpessaSynthInfo(
             `%cParsing finished! %c"${this.soundFontInfo["INAM"]}"%c has %c${this.presets.length} %cpresets,