spessasynth_core 3.26.34 → 3.26.35

package/package.json

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

package/src/soundfont/basic_soundfont/basic_sample.js

@@ -20,11 +20,10 @@ export const sampleTypes = {
 };
 
 /**
- * @typedef {function} EncodeVorbisFunction
- * @param channelAudioData {Float32Array[]}
+ * @typedef {function} SampleEncodingFunction
+ * @async
+ * @param audioData {Float32Array}
  * @param sampleRate {number}
- * @param channels {number}
- * @param quality {number} -0.1 to 1
  * @returns {Uint8Array}
  */
 
@@ -106,7 +105,7 @@ export class BasicSample
      * Indicates if the data was overriden, so it cannot be copied back unchanged
      * @type {boolean}
      */
-    dataOverriden = false;
+    dataOverriden = true;
     
     /**
      * The basic representation of a sample
@@ -163,7 +162,7 @@ export class BasicSample
      * @return {Uint8Array} either s16 or vorbis data
      * @virtual
      */
-    getRawData(allowVorbis = true)
+    getRawData(allowVorbis)
     {
         if (this.isCompressed && allowVorbis && !this.dataOverriden)
         {
@@ -190,10 +189,9 @@ export class BasicSample
     }
     
     /**
-     * @param quality {number}
-     * @param encodeVorbis {EncodeVorbisFunction}
+     * @param encodeVorbis {SampleEncodingFunction}
      */
-    compressSample(quality, encodeVorbis)
+    async compressSample(encodeVorbis)
     {
         // no need to compress
         if (this.isCompressed)
@@ -210,12 +208,12 @@ export class BasicSample
                 this.resampleData(RESAMPLE_RATE);
                 audioData = this.getAudioData();
             }
-            const compressed = encodeVorbis([audioData], 1, this.sampleRate, quality);
+            const compressed = await encodeVorbis(audioData, this.sampleRate);
             this.setCompressedData(compressed);
         }
         catch (e)
         {
-            SpessaSynthWarn(`Failed to compress ${this.sampleName}. Leaving as uncompressed!`);
+            SpessaSynthWarn(`Failed to compress ${this.sampleName}. Leaving as uncompressed!`, e);
             delete this.compressedData;
             // flag as uncompressed
             this.isCompressed = false;

package/src/soundfont/basic_soundfont/basic_soundbank.js

@@ -148,9 +148,9 @@ class BasicSoundBank
     
     /**
      * Creates a simple soundfont with one saw wave preset.
-     * @returns {ArrayBufferLike}
+     * @returns {Promise<ArrayBufferLike>}
      */
-    static getDummySoundfontFile()
+    static async getDummySoundfontFile()
     {
         const font = new BasicSoundBank();
         const sample = new BasicSample(
@@ -162,11 +162,12 @@ class BasicSoundBank
             0,
             127
         );
-        sample.sampleData = new Float32Array(128);
+        const sampleData = new Float32Array(128);
         for (let i = 0; i < 128; i++)
         {
-            sample.sampleData[i] = (i / 128) * 2 - 1;
+            sampleData[i] = (i / 128) * 2 - 1;
         }
+        sample.setAudioData(sampleData);
         font.addSamples(sample);
         
         const gZone = new BasicGlobalZone();
@@ -201,7 +202,8 @@ class BasicSoundBank
         font.soundFontInfo["isng"] = "E-mu 10K2";
         font.soundFontInfo["INAM"] = "Dummy";
         font.flush();
-        return font.write().buffer;
+        const f = await font.write();
+        return f.buffer;
     }
     
     /**
@@ -252,7 +254,6 @@ class BasicSoundBank
         if (sample.isCompressed)
         {
             newSample.setCompressedData(sample.compressedData.slice());
-            console.log(sample.compressedData.length);
         }
         else
         {

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

@@ -6,14 +6,30 @@ import { getStringBytes } from "../../../utils/byte_functions/string.js";
 import { writeWavePool } from "./wvpl.js";
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../../utils/loggin.js";
 import { consoleColors } from "../../../utils/other.js";
+import { fillWithDefaults } from "../../../utils/fill_with_defaults.js";
+
+/**
+ * @typedef {Object} DLSWriteOptions
+ * @property {ProgressFunction|undefined} progressFunction - a function to show progress for writing large banks. It can be undefined.
+ */
+
+
+/**
+ * @type {DLSWriteOptions}
+ */
+const DEFAULT_DLS_OPTIONS = {
+    progressFunction: undefined
+};
 
 /**
  * Write the soundfont as a .dls file. Experimental
  * @this {BasicSoundBank}
+ * @param {DLSWriteOptions|undefined} options - options for writing the file.
  * @returns {Uint8Array}
  */
-export function writeDLS()
+export async function writeDLS(options = DEFAULT_DLS_OPTIONS)
 {
+    options = fillWithDefaults(options, DEFAULT_DLS_OPTIONS);
     SpessaSynthGroupCollapsed(
         "%cSaving DLS...",
         consoleColors.info
@@ -40,7 +56,7 @@ export function writeDLS()
         "%cWriting WAVE samples...",
         consoleColors.info
     );
-    const wavepool = writeWavePool.apply(this);
+    const wavepool = await writeWavePool.call(this, options.progressFunction);
     const wvpl = wavepool.data;
     const ptblOffsets = wavepool.indexes;
     SpessaSynthInfo("%cSucceeded!", consoleColors.recognized);

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

@@ -3,22 +3,27 @@ import { writeRIFFChunkParts } from "../riff_chunk.js";
 
 /**
  * @this {BasicSoundBank}
- * @returns {{data: IndexedByteArray, indexes: number[] }}
+ * @param {ProgressFunction|undefined} progressFunction
+ * @returns {Promise<{data: IndexedByteArray, indexes: number[] }>}
  */
-export function writeWavePool()
+export async function writeWavePool(progressFunction)
 {
     let currentIndex = 0;
     const offsets = [];
     /**
      * @type {IndexedByteArray[]}
      */
-    const samples = this.samples.map(s =>
+    const samples = [];
+    let written = 0;
+    for (const s of this.samples)
     {
         const out = writeDLSSample(s);
+        await progressFunction?.(s.sampleName, written, this.samples.length);
         offsets.push(currentIndex);
         currentIndex += out.length;
-        return out;
-    });
+        samples.push(out);
+        written++;
+    }
     return {
         data: writeRIFFChunkParts(
             "wvpl",

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

@@ -1,8 +1,8 @@
-import { SpessaSynthInfo } from "../../../utils/loggin.js";
-import { consoleColors } from "../../../utils/other.js";
 import { IndexedByteArray } from "../../../utils/indexed_array.js";
 import { writeStringAsBytes } from "../../../utils/byte_functions/string.js";
 import { writeLittleEndian } from "../../../utils/byte_functions/little_endian.js";
+import { SpessaSynthInfo } from "../../../utils/loggin.js";
+import { consoleColors } from "../../../utils/other.js";
 
 /*
 Sdta structure:
@@ -26,25 +26,45 @@ const SDTA_TO_DATA_OFFSET =
  * @param smplStartOffsets {number[]}
  * @param smplEndOffsets {number[]}
  * @param compress {boolean}
- * @param quality {number}
- * @param vorbisFunc {EncodeVorbisFunction}
+ * @param decompress {boolean}
+ * @param vorbisFunc {SampleEncodingFunction}
+ * @param progressFunc {ProgressFunction|undefined}
  * @returns {Uint8Array}
  */
-export function getSDTA(smplStartOffsets, smplEndOffsets, compress, quality, vorbisFunc)
+export async function getSDTA(smplStartOffsets,
+                              smplEndOffsets,
+                              compress,
+                              decompress,
+                              vorbisFunc,
+                              progressFunc
+)
 {
     // write smpl: write int16 data of each sample linearly
     // get size (calling getAudioData twice doesn't matter since it gets cached)
+    let writtenCount = 0;
     let smplChunkSize = 0;
-    const sampleDatas = this.samples.map((s, i) =>
+    const sampleDatas = [];
+    
+    // linear async is faster here as the writing function usually uses a single wasm instance
+    for (const s of this.samples)
     {
         if (compress)
         {
-            s.compressSample(quality, vorbisFunc);
+            await s.compressSample(vorbisFunc);
+        }
+        if (decompress)
+        {
+            s.setAudioData(s.getAudioData());
         }
+        
         // raw data: either copy s16le or encoded vorbis or encode manually if overridden
-        const r = s.getRawData();
+        // use set timeout so the thread doesn't die
+        const r = s.getRawData(true);
+        writtenCount++;
+        progressFunc?.(s.sampleName, writtenCount, this.samples.length);
+        
         SpessaSynthInfo(
-            `%cEncoded sample %c${i}. ${s.sampleName}%c of %c${this.samples.length}%c. Compressed: %c${s.isCompressed}%c.`,
+            `%cEncoded sample %c${writtenCount}. ${s.sampleName}%c of %c${this.samples.length}%c. Compressed: %c${s.isCompressed}%c.`,
             consoleColors.info,
             consoleColors.recognized,
             consoleColors.info,
@@ -53,15 +73,16 @@ export function getSDTA(smplStartOffsets, smplEndOffsets, compress, quality, vor
             s.isCompressed ? consoleColors.recognized : consoleColors.unrecognized,
             consoleColors.info
         );
+        
         /* 6.1 Sample Data Format in the smpl Sub-chunk
         Each sample is followed by a minimum of forty-six zero
         valued sample data points. These zero valued data points are necessary to guarantee that any reasonable upward pitch shift
         using any reasonable interpolator can loop on zero data at the end of the sound.
         This doesn't apply to sf3 tho
          */
-        smplChunkSize += r.length + (s.isCompressed ? 0 : 92); // 92 = 46 sample data points
-        return r;
-    });
+        smplChunkSize += r.length + (s.isCompressed ? 0 : 92);
+        sampleDatas.push(r);
+    }
     
     if (smplChunkSize % 2 !== 0)
     {

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

@@ -16,16 +16,25 @@ import { writeLittleEndian, writeWord } from "../../../utils/byte_functions/litt
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../../utils/loggin.js";
 import { MOD_BYTE_SIZE } from "../modulator.js";
 import { fillWithDefaults } from "../../../utils/fill_with_defaults.js";
+
+/**
+ * @typedef {function} ProgressFunction
+ * @param {string} sampleName - the written sample name.
+ * @param {number} sampleIndex - the sample's index.
+ * @param {number} sampleCount - the total sample count for progress displaying.
+ */
+
 /**
  * @typedef {Object} SoundFont2WriteOptions
- * @property {boolean|undefined} compress - if the soundfont should be compressed with the Ogg Vorbis codec
- * @property {number|undefined} compressionQuality - the vorbis compression quality, from -0.1 to 1
- * @property {EncodeVorbisFunction|undefined} compressionFunction -
- * the encode vorbis function. Can be undefined if not compressed.
+ * @property {boolean|undefined} compress - if the soundfont should be compressed with a given function.
+ * @property {SampleEncodingFunction|undefined} compressionFunction -
+ * the encode vorbis function. It can be undefined if not compressed.
+ * @property {ProgressFunction|undefined} progressFunction - a function to show progress for writing large banks. It can be undefined.
  * @property {boolean|undefined} writeDefaultModulators - if the DMOD chunk should be written.
  * Recommended.
  * @property {boolean|undefined} writeExtendedLimits - if the xdta chunk should be written to allow virtually infinite parameters.
  * Recommended.
+ * @property {boolean|undefined} decompress - if an sf3 bank should be decompressed back to sf2. Not recommended.
  */
 
 
@@ -43,8 +52,10 @@ const DEFAULT_WRITE_OPTIONS = {
     compress: false,
     compressionQuality: 0.5,
     compressionFunction: undefined,
+    progressFunction: undefined,
     writeDefaultModulators: true,
-    writeExtendedLimits: true
+    writeExtendedLimits: true,
+    decompress: false
 };
 
 /**
@@ -53,14 +64,18 @@ const DEFAULT_WRITE_OPTIONS = {
  * @param {SoundFont2WriteOptions} options
  * @returns {Uint8Array}
  */
-export function write(options = DEFAULT_WRITE_OPTIONS)
+export async function write(options = DEFAULT_WRITE_OPTIONS)
 {
     options = fillWithDefaults(options, DEFAULT_WRITE_OPTIONS);
-    if (options.compress)
+    if (options?.compress)
     {
-        if (typeof options.compressionFunction !== "function")
+        if (typeof options?.compressionFunction !== "function")
         {
-            throw new TypeError("No compression function supplied but compression enabled.");
+            throw new Error("No compression function supplied but compression enabled.");
+        }
+        if (options?.decompress)
+        {
+            throw new Error("Decompressed and compressed at the same time.");
         }
     }
     SpessaSynthGroupCollapsed(
@@ -88,6 +103,10 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
     {
         this.soundFontInfo["ifil"] = "3.0"; // set version to 3
     }
+    if (options?.decompress)
+    {
+        this.soundFontInfo["ifil"] = "2.4"; // set version to 2.04
+    }
     
     if (options?.writeDefaultModulators)
     {
@@ -152,13 +171,14 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
     // write sdta
     const smplStartOffsets = [];
     const smplEndOffsets = [];
-    const sdtaChunk = getSDTA.call(
+    const sdtaChunk = await getSDTA.call(
         this,
         smplStartOffsets,
         smplEndOffsets,
-        options?.compress,
-        options?.compressionQuality ?? 0.5,
-        options.compressionFunction
+        options.compress,
+        options.decompress,
+        options?.compressionFunction,
+        options?.progressFunction
     );
     
     SpessaSynthInfo(

package/src/soundfont/dls/dls_sample.js

@@ -175,6 +175,7 @@ export class DLSSample extends BasicSample
             loopEnd
         );
         this.sampleDbAttenuation = sampleDbAttenuation;
+        this.dataOverriden = false;
         /**
          * @type {IndexedByteArray}
          */
@@ -221,11 +222,11 @@ export class DLSSample extends BasicSample
         super.setAudioData(audioData);
     }
     
-    getRawData(allowVorbis = true)
+    getRawData(allowVorbis)
     {
         if (this.dataOverriden || this.isCompressed)
         {
-            return super.getRawData();
+            return super.getRawData(allowVorbis);
         }
         if (this.wFormatTag === W_FORMAT_TAG.PCM && this.bytesPerSample === 2)
         {

package/src/soundfont/read_sf2/samples.js

@@ -22,21 +22,10 @@ export class SoundFontSample extends BasicSample
     linkedSampleIndex;
     
     /**
-     * The handle to the core sf2 file for dynamic sample reading
+     * The sliced sample from the smpl chunk
      * @type {Uint8Array}
      */
-    sf2FileArrayHandle;
-    
-    /**
-     * Start index of the sample in the file byte array
-     * @type {number}
-     */
-    s16leStart = 0;
-    /**
-     * End index of the sample in the file byte array
-     * @type {number}
-     */
-    s16leEnd = 0;
+    s16leData;
     
     /**
      * Creates a sample
@@ -83,6 +72,7 @@ export class SoundFontSample extends BasicSample
             sampleLoopStartIndex - (sampleStartIndex / 2),
             sampleLoopEndIndex - (sampleStartIndex / 2)
         );
+        this.dataOverriden = false;
         this.isCompressed = compressed;
         this.sampleName = sampleName;
         // in bytes
@@ -116,13 +106,15 @@ export class SoundFontSample extends BasicSample
                     this.startByteOffset / 2,
                     this.endByteOffset / 2
                 );
+                this.dataOverriden = true;
             }
             else
             {
                 // regular sf2 s16le
-                this.s16leStart = smplStart + this.startByteOffset;
-                this.s16leEnd = smplStart + this.endByteOffset;
-                this.sf2FileArrayHandle = sampleDataArray;
+                this.s16leData = sampleDataArray.slice(
+                    smplStart + this.startByteOffset,
+                    smplStart + this.endByteOffset
+                );
             }
             
         }
@@ -189,7 +181,7 @@ export class SoundFontSample extends BasicSample
         // read the sample data
         let audioData = new Float32Array(byteLength / 2);
         let convertedSigned16 = new Int16Array(
-            this.sf2FileArrayHandle.buffer.slice(this.s16leStart, this.s16leEnd)
+            this.s16leData.buffer
         );
         
         // convert to float
@@ -207,15 +199,15 @@ export class SoundFontSample extends BasicSample
      * @param allowVorbis
      * @returns {Uint8Array}
      */
-    getRawData(allowVorbis = true)
+    getRawData(allowVorbis)
     {
         if (this.dataOverriden || this.compressedData)
         {
             // return vorbis or encode manually
-            return super.getRawData();
+            return super.getRawData(allowVorbis);
         }
         // copy the smpl directly
-        return this.sf2FileArrayHandle.slice(this.s16leStart, this.s16leEnd);
+        return this.s16leData;
     }
 }