spessasynth_core 3.26.28 → 3.26.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_core",
-  "version": "3.26.28",
+  "version": "3.26.30",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "main": "index.js",
   "type": "module",

package/src/soundfont/basic_soundfont/basic_instrument.js

@@ -53,7 +53,7 @@ export class BasicInstrument
     linkTo(preset)
     {
         this.linkedPresets.push(preset);
-        this.instrumentZones.forEach(z => z.useCount = this.linkedPresets.length);
+        this.instrumentZones.forEach(z => z.useCount++);
     }
     
     /**
@@ -67,6 +67,20 @@ export class BasicInstrument
             throw new Error(`Cannot unlink ${preset.presetName} from ${this.instrumentName}: not linked.`);
         }
         this.linkedPresets.splice(index, 1);
+        this.instrumentZones.forEach(z => z.useCount--);
+    }
+    
+    deleteUnusedZones()
+    {
+        this.instrumentZones = this.instrumentZones.filter(z =>
+        {
+            const stays = z.useCount > 0;
+            if (!stays)
+            {
+                z.deleteZone();
+            }
+            return stays;
+        });
     }
     
     deleteInstrument()
@@ -86,6 +100,7 @@ export class BasicInstrument
     deleteZone(index)
     {
         const zone = this.instrumentZones[index];
+        zone.useCount -= 1;
         if (zone.useCount < 1)
         {
             zone.deleteZone();

package/src/soundfont/basic_soundfont/basic_instrument_zone.js

@@ -26,7 +26,7 @@ export class BasicInstrumentZone extends BasicZone
     {
         super();
         this.parentInstrument = instrument;
-        this.useCount = instrument.linkedPresets.length;
+        this.useCount = instrument.useCount;
     }
     
     /**

package/src/soundfont/basic_soundfont/basic_sample.js

@@ -4,6 +4,7 @@
  * loads sample data, handles async loading of sf3 compressed samples
  */
 import { SpessaSynthWarn } from "../../utils/loggin.js";
+import { IndexedByteArray } from "../../utils/indexed_array.js";
 
 // should be reasonable for most cases
 const RESAMPLE_RATE = 48000;
@@ -22,7 +23,6 @@ export const sampleTypes = {
     romLinkedSample: 32776
 };
 
-
 /**
  * @typedef {function} EncodeVorbisFunction
  * @param channelAudioData {Float32Array[]}
@@ -90,8 +90,8 @@ export class BasicSample
     isCompressed;
     
     /**
-     * The compressed sample data if it was compressed by spessasynth
-     * @type {Uint8Array}
+     * The compressed sample data if the sample has been compressed
+     * @type {Uint8Array|undefined}
      */
     compressedData = undefined;
     /**
@@ -107,7 +107,13 @@ export class BasicSample
     sampleData = undefined;
     
     /**
-     * The basic representation of a soundfont sample
+     * Indicates if the data was overriden, so it cannot be copied back unchanged
+     * @type {boolean}
+     */
+    dataOverriden = false;
+    
+    /**
+     * The basic representation of a sample
      * @param sampleName {string} The sample's name
      * @param sampleRate {number} The sample's rate in Hz
      * @param samplePitch {number} The sample's pitch as a MIDI note number
@@ -156,18 +162,14 @@ export class BasicSample
     }
     
     /**
-     * @returns {Uint8Array|IndexedByteArray}
+     * Get raw data for writing the file
+     * @param allowVorbis {boolean}
+     * @return {Uint8Array} either s16 or vorbis data
+     * @virtual
      */
-    getRawData()
+    getRawData(allowVorbis = true)
     {
-        const uint8 = new Uint8Array(this.sampleData.length * 2);
-        for (let i = 0; i < this.sampleData.length; i++)
-        {
-            const sample = Math.floor(this.sampleData[i] * 32768);
-            uint8[i * 2] = sample & 0xFF; // lower byte
-            uint8[i * 2 + 1] = (sample >> 8) & 0xFF; // upper byte
-        }
-        return uint8;
+        return this.encodeS16LE();
     }
     
     resampleData(newSampleRate)
@@ -210,14 +212,16 @@ export class BasicSample
             }
             this.compressedData = encodeVorbis([audioData], 1, this.sampleRate, quality);
             // flag as compressed
-            this.setSampleType(this.sampleType | 0x10);
+            this.isCompressed = true;
+            // allow the data to be copied from the compressedData chunk during the write operation
+            this.dataOverriden = false;
         }
         catch (e)
         {
             SpessaSynthWarn(`Failed to compress ${this.sampleName}. Leaving as uncompressed!`);
-            this.compressedData = undefined;
+            delete this.compressedData;
             // flag as uncompressed
-            this.setSampleType(this.sampleType & 0xEF);
+            this.isCompressed = false;
         }
         
     }
@@ -329,8 +333,25 @@ export class BasicSample
         return this.sampleData;
     }
     
+    /**
+     * Encodes s16le sample
+     * @return {IndexedByteArray}
+     */
+    encodeS16LE()
+    {
+        const data = this.getAudioData();
+        const data16 = new Int16Array(data.length);
+        
+        for (let i = 0; i < data.length; i++)
+        {
+            data16[i] = data[i] * 32768;
+        }
+        return new IndexedByteArray(data16.buffer);
+    }
+    
     // noinspection JSUnusedGlobalSymbols
     /**
+     * REPLACES the audio data
      * @param audioData {Float32Array}
      * @virtual
      */
@@ -339,5 +360,6 @@ export class BasicSample
         this.isCompressed = false;
         delete this.compressedData;
         this.sampleData = audioData;
+        this.dataOverriden = true;
     }
 }

package/src/soundfont/basic_soundfont/basic_soundbank.js

@@ -358,7 +358,6 @@ class BasicSoundBank
                     consoleColors.info
                 );
                 soundfont.deletePreset(p);
-                soundfont.removeUnusedElements();
                 presetIndex--;
             }
             else
@@ -444,12 +443,13 @@ class BasicSoundBank
     {
         this.instruments = this.instruments.filter(i =>
         {
+            i.deleteUnusedZones();
             const deletable = i.useCount < 1;
             if (deletable)
             {
                 i.deleteInstrument();
             }
-            return deletable;
+            return !deletable;
         });
         this.samples = this.samples.filter(s =>
         {
@@ -458,7 +458,7 @@ class BasicSoundBank
             {
                 s.deleteSample();
             }
-            return deletable;
+            return !deletable;
         });
     }
     

package/src/soundfont/basic_soundfont/riff_chunk.js

@@ -36,10 +36,13 @@ export function readRIFFChunk(dataArray, readData = true, forceShift = false)
     let header = readBytesAsString(dataArray, 4);
     
     let size = readLittleEndian(dataArray, 4);
+    /**
+     * @type {IndexedByteArray}
+     */
     let chunkData = undefined;
     if (readData)
     {
-        chunkData = new IndexedByteArray(dataArray.buffer.slice(dataArray.currentIndex, dataArray.currentIndex + size));
+        chunkData = dataArray.slice(dataArray.currentIndex, dataArray.currentIndex + size);
     }
     if (readData || forceShift)
     {

package/src/soundfont/basic_soundfont/write_dls/wave.js

@@ -60,7 +60,7 @@ export function writeDLSSample(sample)
     {
         data = writeRIFFOddSize(
             "data",
-            sample.getRawData()
+            sample.getRawData(false) // no vorbis allowed
         );
     }
     

package/src/soundfont/basic_soundfont/write_sf2/ibag.js

@@ -6,18 +6,20 @@ const BAG_SIZE = 4;
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getIBAG()
 {
     // write all ibag with their start indexes as they were changed in getIGEN() and getIMOD()
-    const ibagsize = this.instruments.reduce(
+    const ibagSize = this.instruments.reduce(
         (sum, i) =>
             // +1 because global zone
             (i.instrumentZones.length + 1) * BAG_SIZE + sum,
         BAG_SIZE
     );
-    const ibagdata = new IndexedByteArray(ibagsize);
+    const ibagData = new IndexedByteArray(ibagSize);
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xibagData = new IndexedByteArray(ibagSize);
     let generatorIndex = 0;
     let modulatorIndex = 0;
     /**
@@ -25,8 +27,12 @@ export function getIBAG()
      */
     const writeZone = z =>
     {
-        writeWord(ibagdata, generatorIndex);
-        writeWord(ibagdata, modulatorIndex);
+        // bottom WORD: regular ibag
+        writeWord(ibagData, generatorIndex & 0xFFFF);
+        writeWord(ibagData, modulatorIndex & 0xFFFF);
+        // top WORD: extended ibag
+        writeWord(xibagData, generatorIndex >> 16);
+        writeWord(xibagData, modulatorIndex >> 16);
         generatorIndex += z.generators.length;
         modulatorIndex += z.modulators.length;
     };
@@ -40,11 +46,23 @@ export function getIBAG()
         }
     }
     // write the terminal IBAG
-    writeWord(ibagdata, generatorIndex);
-    writeWord(ibagdata, modulatorIndex);
-    return writeRIFFChunk(new RiffChunk(
+    writeWord(ibagData, generatorIndex & 0xFFFF);
+    writeWord(ibagData, modulatorIndex & 0xFFFF);
+    writeWord(xibagData, generatorIndex >> 16);
+    writeWord(xibagData, modulatorIndex >> 16);
+    const ibag = writeRIFFChunk(new RiffChunk(
         "ibag",
-        ibagdata.length,
-        ibagdata
+        ibagData.length,
+        ibagData
     ));
+    const xibag = writeRIFFChunk(new RiffChunk(
+        "ibag",
+        xibagData.length,
+        xibagData
+    ));
+    return {
+        pdta: ibag,
+        xdta: xibag,
+        highestIndex: Math.max(generatorIndex, modulatorIndex)
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/igen.js

@@ -6,16 +6,16 @@ import { generatorTypes } from "../generator_types.js";
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getIGEN()
 {
     // go through all instruments -> zones and write generators sequentially (add 4 for terminal)
-    let igensize = GEN_BYTE_SIZE;
+    let igenSize = GEN_BYTE_SIZE;
     for (const inst of this.instruments)
     {
-        igensize += inst.globalZone.generators.length * GEN_BYTE_SIZE;
-        igensize += inst.instrumentZones.reduce((sum, z) =>
+        igenSize += inst.globalZone.generators.length * GEN_BYTE_SIZE;
+        igenSize += inst.instrumentZones.reduce((sum, z) =>
         {
             // clear sample and range generators before determining the size
             z.generators = (z.generators.filter(g =>
@@ -50,7 +50,7 @@ export function getIGEN()
             return z.generators.length * GEN_BYTE_SIZE + sum;
         }, 0);
     }
-    const igendata = new IndexedByteArray(igensize);
+    const igenData = new IndexedByteArray(igenSize);
     
     /**
      * @param z {BasicZone}
@@ -60,8 +60,8 @@ export function getIGEN()
         for (const gen of z.generators)
         {
             // name is deceptive, it works on negatives
-            writeWord(igendata, gen.generatorType);
-            writeWord(igendata, gen.generatorValue);
+            writeWord(igenData, gen.generatorType);
+            writeWord(igenData, gen.generatorValue);
         }
     };
     
@@ -75,10 +75,25 @@ export function getIGEN()
         }
     }
     // terminal generator, is zero
-    writeDword(igendata, 0);
-    return writeRIFFChunk(new RiffChunk(
+    writeDword(igenData, 0);
+    
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xigenData = new IndexedByteArray(GEN_BYTE_SIZE);
+    writeDword(xigenData, 0);
+    
+    const igen = writeRIFFChunk(new RiffChunk(
         "igen",
-        igendata.length,
-        igendata
+        igenData.length,
+        igenData
     ));
+    const xigen = writeRIFFChunk(new RiffChunk(
+        "igen",
+        xigenData.length,
+        xigenData
+    ));
+    return {
+        pdta: igen,
+        xdta: xigen,
+        highestIndex: 0 // not applicable
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/imod.js

@@ -5,20 +5,20 @@ import { MOD_BYTE_SIZE } from "../modulator.js";
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getIMOD()
 {
     // very similar to igen,
     // go through all instruments -> zones and write modulators sequentially
-    let imodsize = MOD_BYTE_SIZE; // terminal
+    let imodSize = MOD_BYTE_SIZE; // terminal
     for (const inst of this.instruments)
     {
-        imodsize += inst.globalZone.modulators.length * MOD_BYTE_SIZE;
+        imodSize += inst.globalZone.modulators.length * MOD_BYTE_SIZE;
         // start with one mod for global
-        imodsize += inst.instrumentZones.reduce((sum, z) => z.modulators.length * MOD_BYTE_SIZE + sum, 0);
+        imodSize += inst.instrumentZones.reduce((sum, z) => z.modulators.length * MOD_BYTE_SIZE + sum, 0);
     }
-    const imoddata = new IndexedByteArray(imodsize);
+    const imodData = new IndexedByteArray(imodSize);
     
     /**
      * @param z {BasicZone}
@@ -27,11 +27,11 @@ export function getIMOD()
     {
         for (const mod of z.modulators)
         {
-            writeWord(imoddata, mod.getSourceEnum());
-            writeWord(imoddata, mod.modulatorDestination);
-            writeWord(imoddata, mod.transformAmount);
-            writeWord(imoddata, mod.getSecSrcEnum());
-            writeWord(imoddata, mod.transformType);
+            writeWord(imodData, mod.getSourceEnum());
+            writeWord(imodData, mod.modulatorDestination);
+            writeWord(imodData, mod.transformAmount);
+            writeWord(imodData, mod.getSecSrcEnum());
+            writeWord(imodData, mod.transformType);
         }
     };
     
@@ -46,11 +46,25 @@ export function getIMOD()
     }
     
     // terminal modulator, is zero
-    writeLittleEndian(imoddata, 0, MOD_BYTE_SIZE);
+    writeLittleEndian(imodData, 0, MOD_BYTE_SIZE);
     
-    return writeRIFFChunk(new RiffChunk(
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const ximodData = new IndexedByteArray(MOD_BYTE_SIZE);
+    writeLittleEndian(ximodData, 0, MOD_BYTE_SIZE);
+    
+    const imod = writeRIFFChunk(new RiffChunk(
+        "imod",
+        imodData.length,
+        imodData
+    ));
+    const ximod = writeRIFFChunk(new RiffChunk(
         "imod",
-        imoddata.length,
-        imoddata
+        ximodData.length,
+        ximodData
     ));
+    return {
+        pdta: imod,
+        xdta: ximod,
+        highestIndex: 0 // not applicable
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/inst.js

@@ -7,27 +7,45 @@ const INST_SIZE = 22;
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getINST()
 {
-    const instsize = this.instruments.length * INST_SIZE + INST_SIZE;
-    const instdata = new IndexedByteArray(instsize);
+    const instSize = this.instruments.length * INST_SIZE + INST_SIZE;
+    const instData = new IndexedByteArray(instSize);
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xinstData = new IndexedByteArray(instSize);
     // the instrument start index is adjusted in ibag, write it here
     let instrumentStart = 0;
     for (const inst of this.instruments)
     {
-        writeStringAsBytes(instdata, inst.instrumentName, 20);
-        writeWord(instdata, instrumentStart);
+        writeStringAsBytes(instData, inst.instrumentName.substring(0, 20), 20);
+        writeStringAsBytes(xinstData, inst.instrumentName.substring(20), 20);
+        writeWord(instData, instrumentStart & 0xFFFF);
+        writeWord(xinstData, instrumentStart >> 16);
         instrumentStart += inst.instrumentZones.length + 1; // global
     }
     // write EOI
-    writeStringAsBytes(instdata, "EOI", 20);
-    writeWord(instdata, instrumentStart);
+    writeStringAsBytes(instData, "EOI", 20);
+    writeStringAsBytes(xinstData, "EOI", 20);
+    writeWord(instData, instrumentStart & 0xFFFF);
+    writeWord(xinstData, instrumentStart >> 16);
     
-    return writeRIFFChunk(new RiffChunk(
+    const inst = writeRIFFChunk(new RiffChunk(
         "inst",
-        instdata.length,
-        instdata
+        instData.length,
+        instData
     ));
+    
+    const xinst = writeRIFFChunk(new RiffChunk(
+        "inst",
+        xinstData.length,
+        xinstData
+    ));
+    
+    return {
+        pdta: inst,
+        xdta: xinst,
+        highestIndex: instrumentStart
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/pbag.js

@@ -6,15 +6,17 @@ const BAG_SIZE = 4;
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getPBAG()
 {
     // write all pbag with their start indexes as they were changed in getPGEN() and getPMOD()
-    const pbagsize = this.presets.reduce((sum, i) =>
+    const pbagSize = this.presets.reduce((sum, i) =>
         // +1 because global zone
         (i.presetZones.length + 1) * BAG_SIZE + sum, BAG_SIZE);
-    const pbagdata = new IndexedByteArray(pbagsize);
+    const pbagData = new IndexedByteArray(pbagSize);
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xpbagData = new IndexedByteArray(pbagSize);
     let generatorIndex = 0;
     let modulatorIndex = 0;
     
@@ -23,8 +25,10 @@ export function getPBAG()
      */
     const writeZone = z =>
     {
-        writeWord(pbagdata, generatorIndex);
-        writeWord(pbagdata, modulatorIndex);
+        writeWord(pbagData, generatorIndex & 0xFFFF);
+        writeWord(pbagData, modulatorIndex & 0xFFFF);
+        writeWord(xpbagData, generatorIndex >> 16);
+        writeWord(xpbagData, modulatorIndex >> 16);
         generatorIndex += z.generators.length;
         modulatorIndex += z.modulators.length;
     };
@@ -39,12 +43,23 @@ export function getPBAG()
         }
     }
     // write the terminal PBAG
-    writeWord(pbagdata, generatorIndex);
-    writeWord(pbagdata, modulatorIndex);
-    
-    return writeRIFFChunk(new RiffChunk(
+    writeWord(pbagData, generatorIndex);
+    writeWord(pbagData, modulatorIndex);
+    writeWord(xpbagData, generatorIndex);
+    writeWord(xpbagData, modulatorIndex);
+    const pbag = writeRIFFChunk(new RiffChunk(
+        "pbag",
+        pbagData.length,
+        pbagData
+    ));
+    const xbag = writeRIFFChunk(new RiffChunk(
         "pbag",
-        pbagdata.length,
-        pbagdata
+        xpbagData.length,
+        xpbagData
     ));
+    return {
+        pdta: pbag,
+        xdta: xbag,
+        highestIndex: Math.max(generatorIndex, modulatorIndex)
+    };
 }

package/src/soundfont/basic_soundfont/write_sf2/pgen.js

@@ -7,17 +7,17 @@ import { generatorTypes } from "../generator_types.js";
 
 /**
  * @this {BasicSoundBank}
- * @returns {IndexedByteArray}
+ * @returns {ReturnedExtendedSf2Chunks}
  */
 export function getPGEN()
 {
     // almost identical to igen, except the correct instrument instead of sample gen
     // goes through all preset zones and writes generators sequentially (add 4 for terminal)
-    let pgensize = GEN_BYTE_SIZE;
+    let pgenSize = GEN_BYTE_SIZE;
     for (const preset of this.presets)
     {
-        pgensize += preset.globalZone.generators.length * GEN_BYTE_SIZE;
-        pgensize += preset.presetZones.reduce((size, z) =>
+        pgenSize += preset.globalZone.generators.length * GEN_BYTE_SIZE;
+        pgenSize += preset.presetZones.reduce((size, z) =>
         {
             // clear instrument and range generators before determining the size
             z.generators = z.generators.filter(g =>
@@ -51,7 +51,7 @@ export function getPGEN()
             return z.generators.length * GEN_BYTE_SIZE + size;
         }, 0);
     }
-    const pgendata = new IndexedByteArray(pgensize);
+    const pgenData = new IndexedByteArray(pgenSize);
     
     /**
      * @param z {BasicZone}
@@ -61,8 +61,8 @@ export function getPGEN()
         for (const gen of z.generators)
         {
             // name is deceptive, it works on negatives
-            writeWord(pgendata, gen.generatorType);
-            writeWord(pgendata, gen.generatorValue);
+            writeWord(pgenData, gen.generatorType);
+            writeWord(pgenData, gen.generatorValue);
         }
     };
     for (const preset of this.presets)
@@ -75,11 +75,25 @@ export function getPGEN()
         }
     }
     // terminal generator, is zero
-    writeDword(pgendata, 0);
+    writeDword(pgenData, 0);
     
-    return writeRIFFChunk(new RiffChunk(
+    // https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md
+    const xpgenData = new IndexedByteArray(GEN_BYTE_SIZE);
+    writeDword(xpgenData, 0);
+    
+    const pgen = writeRIFFChunk(new RiffChunk(
+        "pgen",
+        pgenData.length,
+        pgenData
+    ));
+    const xpgen = writeRIFFChunk(new RiffChunk(
         "pgen",
-        pgendata.length,
-        pgendata
+        xpgenData.length,
+        xpgenData
     ));
+    return {
+        pdta: pgen,
+        xdta: xpgen,
+        highestIndex: 0 // not applicable
+    };
 }