spessasynth_core 3.26.32 → 3.26.33

package/package.json

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

package/src/soundfont/basic_soundfont/basic_instrument_zone.js

@@ -42,16 +42,4 @@ export class BasicInstrumentZone extends BasicZone
     {
         this.sample.unlinkFrom(this.parentInstrument);
     }
-    
-    /**
-     * @param zone {BasicZone}
-     */
-    copyFrom(zone)
-    {
-        super.copyFrom(zone);
-        if (zone instanceof BasicInstrumentZone)
-        {
-            this.sample = zone.sample;
-        }
-    }
 }

package/src/soundfont/basic_soundfont/basic_preset_zone.js

@@ -36,16 +36,4 @@ export class BasicPresetZone extends BasicZone
         this.instrument = instrument;
         this.instrument.linkTo(this.parentPreset);
     }
-    
-    /**
-     * @param zone {BasicZone}
-     */
-    copyFrom(zone)
-    {
-        super.copyFrom(zone);
-        if (zone instanceof BasicPresetZone)
-        {
-            this.instrument = zone.instrument;
-        }
-    }
 }

package/src/soundfont/basic_soundfont/basic_sample.js

@@ -1,10 +1,6 @@
-/**
- * samples.js
- * purpose: parses soundfont samples, resamples if needed.
- * loads sample data, handles async loading of sf3 compressed samples
- */
 import { SpessaSynthWarn } from "../../utils/loggin.js";
 import { IndexedByteArray } from "../../utils/indexed_array.js";
+import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
 
 // should be reasonable for most cases
 const RESAMPLE_RATE = 48000;
@@ -87,7 +83,7 @@ export class BasicSample
      * Indicates if the sample is compressed using vorbis SF3
      * @type {boolean}
      */
-    isCompressed;
+    isCompressed = false;
     
     /**
      * The compressed sample data if the sample has been compressed
@@ -102,7 +98,7 @@ export class BasicSample
     linkedInstruments = [];
     /**
      * The sample's audio data
-     * @type {Float32Array}
+     * @type {Float32Array|undefined}
      */
     sampleData = undefined;
     
@@ -169,6 +165,10 @@ export class BasicSample
      */
     getRawData(allowVorbis = true)
     {
+        if (this.isCompressed && allowVorbis && !this.dataOverriden)
+        {
+            return this.compressedData;
+        }
         return this.encodeS16LE();
     }
     
@@ -210,11 +210,8 @@ export class BasicSample
                 this.resampleData(RESAMPLE_RATE);
                 audioData = this.getAudioData();
             }
-            this.compressedData = encodeVorbis([audioData], 1, this.sampleRate, quality);
-            // flag as compressed
-            this.isCompressed = true;
-            // allow the data to be copied from the compressedData chunk during the write operation
-            this.dataOverriden = false;
+            const compressed = encodeVorbis([audioData], 1, this.sampleRate, quality);
+            this.setCompressedData(compressed);
         }
         catch (e)
         {
@@ -320,17 +317,69 @@ export class BasicSample
         this.linkedInstruments.splice(index, 1);
     }
     
+    
     /**
+     * @private
+     * Decode binary vorbis into a float32 pcm
+     * @returns {Float32Array}
+     */
+    decodeVorbis()
+    {
+        if (this.sampleData)
+        {
+            return this.sampleData;
+        }
+        // get the compressed byte stream
+        // reset array and being decoding
+        try
+        {
+            /**
+             * @type {{data: Float32Array[], error: (string|null), sampleRate: number, eof: boolean}}
+             */
+            const vorbis = stbvorbis.decode(this.compressedData);
+            const decoded = vorbis.data[0];
+            if (decoded === undefined)
+            {
+                SpessaSynthWarn(`Error decoding sample ${this.sampleName}: Vorbis decode returned undefined.`);
+                return new Float32Array(0);
+            }
+            // clip
+            // because vorbis can go above 1 sometimes
+            for (let i = 0; i < decoded.length; i++)
+            {
+                // magic number is 32,767 / 32,768
+                decoded[i] = Math.max(-1, Math.min(decoded[i], 0.999969482421875));
+            }
+            return decoded;
+        }
+        catch (e)
+        {
+            // do not error out, fill with silence
+            SpessaSynthWarn(`Error decoding sample ${this.sampleName}: ${e}`);
+            return new Float32Array(this.sampleLoopEndIndex + 1);
+        }
+    }
+    
+    /**
+     * Get the float32 audio data.
+     * Note that this either decodes the compressed data or passes the ready sampleData.
+     * If neither are set then it will throw an error!
      * @returns {Float32Array}
-     * @virtual
      */
     getAudioData()
     {
-        if (!this.sampleData)
+        if (this.sampleData)
         {
-            throw new Error("Error! Sample data is undefined. Is the method overriden properly?");
+            return this.sampleData;
         }
-        return this.sampleData;
+        if (this.isCompressed)
+        {
+            // SF3
+            // if compressed, decode
+            this.sampleData = this.decodeVorbis();
+            return this.sampleData;
+        }
+        throw new Error("Sample data is undefined for a BasicSample instance.");
     }
     
     /**
@@ -372,4 +421,16 @@ export class BasicSample
         this.sampleData = audioData;
         this.dataOverriden = true;
     }
+    
+    /**
+     * Replaces the audio with a compressed data sample
+     * @param data {Uint8Array}
+     */
+    setCompressedData(data)
+    {
+        this.sampleData = undefined;
+        this.compressedData = data;
+        this.isCompressed = true;
+        this.dataOverriden = false;
+    }
 }

package/src/soundfont/basic_soundfont/basic_soundbank.js

@@ -39,18 +39,21 @@ class BasicSoundBank
     /**
      * The soundfont's presets
      * @type {BasicPreset[]}
+     * @readonly
      */
     presets = [];
     
     /**
      * The soundfont's samples
      * @type {BasicSample[]}
+     * @readonly
      */
     samples = [];
     
     /**
      * The soundfont's instruments
      * @type {BasicInstrument[]}
+     * @readonly
      */
     instruments = [];
     
@@ -202,40 +205,137 @@ class BasicSoundBank
     }
     
     /**
-     * @param preset {BasicPreset}
+     * @param presets {BasicPreset}
      */
-    addPresets(...preset)
+    addPresets(...presets)
     {
-        this.presets.push(...preset);
+        this.presets.push(...presets);
     }
     
-    flush()
+    /**
+     * @param instruments {BasicInstrument}
+     */
+    addInstruments(...instruments)
     {
-        this.presets.sort((a, b) =>
+        this.instruments.push(...instruments);
+    }
+    
+    /**
+     * @param samples {BasicSample}
+     */
+    addSamples(...samples)
+    {
+        this.samples.push(...samples);
+    }
+    
+    /**
+     * Clones samples into this bank
+     * @param sample {BasicSample} samples to copy
+     * @returns {BasicSample} copied sample, if a sample exists with that name, it is returned instead
+     */
+    cloneSample(sample)
+    {
+        const duplicate = this.samples.find(s => s.sampleName === sample.sampleName);
+        if (duplicate)
         {
-            if (a.bank !== b.bank)
-            {
-                return a.bank - b.bank;
-            }
-            return a.program - b.program;
-        });
-        this._parseInternal();
+            return duplicate;
+        }
+        const newSample = new BasicSample(
+            sample.sampleName,
+            sample.sampleRate,
+            sample.samplePitch,
+            sample.samplePitchCorrection,
+            sample.sampleType,
+            sample.sampleLoopStartIndex,
+            sample.sampleLoopEndIndex
+        );
+        if (sample.isCompressed)
+        {
+            newSample.setCompressedData(sample.compressedData.slice());
+            console.log(sample.compressedData.length);
+        }
+        else
+        {
+            newSample.setAudioData(sample.getAudioData());
+        }
+        this.addSamples(newSample);
+        if (sample.linkedSample)
+        {
+            const clonedLinked = this.cloneSample(sample.linkedSample);
+            newSample.setLinkedSample(clonedLinked, newSample.sampleType);
+        }
+        return newSample;
     }
     
+    
     /**
+     * Clones an instruments into this bank
      * @param instrument {BasicInstrument}
+     * @returns {BasicInstrument} the copied instrument, if an instrument exists with that name, it is returned instead
      */
-    addInstruments(...instrument)
+    cloneInstrument(instrument)
     {
-        this.instruments.push(...instrument);
+        const duplicate = this.instruments.find(i => i.instrumentName === instrument.instrumentName);
+        if (duplicate)
+        {
+            return duplicate;
+        }
+        const newInstrument = new BasicInstrument();
+        newInstrument.instrumentName = instrument.instrumentName;
+        newInstrument.globalZone.copyFrom(instrument.globalZone);
+        for (const zone of instrument.instrumentZones)
+        {
+            const copiedZone = newInstrument.createZone();
+            copiedZone.copyFrom(zone);
+            copiedZone.setSample(this.cloneSample(zone.sample));
+        }
+        this.addInstruments(newInstrument);
+        return newInstrument;
     }
     
+    // noinspection JSUnusedGlobalSymbols
     /**
-     * @param sample {BasicSample}
+     * Clones presets into this sound bank
+     * @param preset {BasicPreset}
+     * @returns {BasicPreset} the copied preset, if a preset exists with that name, it is returned instead
      */
-    addSamples(...sample)
+    clonePreset(preset)
+    {
+        const duplicate = this.presets.find(p => p.presetName === preset.presetName);
+        if (duplicate)
+        {
+            return duplicate;
+        }
+        const newPreset = new BasicPreset(this);
+        newPreset.presetName = preset.presetName;
+        newPreset.bank = preset.bank;
+        newPreset.program = preset.program;
+        newPreset.library = preset.library;
+        newPreset.genre = preset.genre;
+        newPreset.morphology = preset.morphology;
+        newPreset.globalZone.copyFrom(preset.globalZone);
+        for (const zone of preset.presetZones)
+        {
+            const copiedZone = newPreset.createZone();
+            copiedZone.copyFrom(zone);
+            copiedZone.setInstrument(this.cloneInstrument(zone.instrument));
+        }
+        
+        this.addPresets(newPreset);
+        return newPreset;
+    }
+    
+    flush()
     {
-        this.samples.push(...sample);
+        this.presets.sort((a, b) =>
+        {
+            if (a.bank !== b.bank)
+            {
+                return a.bank - b.bank;
+            }
+            return a.program - b.program;
+        });
+        this._parseInternal();
     }
     
     /**

package/src/soundfont/basic_soundfont/basic_zone.js

@@ -5,6 +5,7 @@
  */
 import { generatorTypes } from "./generator_types.js";
 import { Generator } from "./generator.js";
+import { Modulator } from "./modulator.js";
 
 export class BasicZone
 {
@@ -136,7 +137,7 @@ export class BasicZone
     copyFrom(zone)
     {
         this.generators = [...zone.generators];
-        this.modulators = [...zone.modulators];
+        this.modulators = zone.modulators.map(m => Modulator.copy(m));
         this.velRange = { ...zone.velRange };
         this.keyRange = { ...zone.keyRange };
     }

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

@@ -84,7 +84,7 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
      */
     const infoArrays = [];
     this.soundFontInfo["ISFT"] = "SpessaSynth"; // ( ͡° ͜ʖ ͡°)
-    if (options?.compress)
+    if (options?.compress || this.samples.some(s => s.isCompressed))
     {
         this.soundFontInfo["ifil"] = "3.0"; // set version to 3
     }
@@ -113,7 +113,6 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
         }
         else if (type === "DMOD")
         {
-            
             const mods = this.defaultModulators;
             SpessaSynthInfo(
                 `%cWriting %c${mods.length}%c default modulators...`,

package/src/soundfont/dls/dls_sample.js

@@ -223,21 +223,15 @@ export class DLSSample extends BasicSample
     
     getRawData(allowVorbis = true)
     {
-        if (this.dataOverriden)
+        if (this.dataOverriden || this.isCompressed)
         {
-            return this.encodeS16LE();
+            return super.getRawData();
         }
-        else
+        if (this.wFormatTag === W_FORMAT_TAG.PCM && this.bytesPerSample === 2)
         {
-            if (this.compressedData && allowVorbis)
-            {
-                return this.compressedData;
-            }
-            if (this.wFormatTag === W_FORMAT_TAG.PCM && this.bytesPerSample === 2)
-            {
-                return this.rawData;
-            }
-            return this.encodeS16LE();
+            // copy straight away
+            return this.rawData;
         }
+        return this.encodeS16LE();
     }
 }

package/src/soundfont/read_sf2/samples.js

@@ -1,12 +1,16 @@
 import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
 import { IndexedByteArray } from "../../utils/indexed_array.js";
 import { readLittleEndian, signedInt8 } from "../../utils/byte_functions/little_endian.js";
-import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
 import { SpessaSynthInfo, SpessaSynthWarn } from "../../utils/loggin.js";
 import { readBytesAsString } from "../../utils/byte_functions/string.js";
 import { BasicSample, sampleTypes } from "../basic_soundfont/basic_sample.js";
 import { consoleColors } from "../../utils/other.js";
 
+/**
+ * samples.js
+ * purpose: parses soundfont samples
+ */
+
 export const SF3_BIT_FLIT = 0x10;
 
 export class SoundFontSample extends BasicSample
@@ -82,11 +86,9 @@ export class SoundFontSample extends BasicSample
         this.isCompressed = compressed;
         this.sampleName = sampleName;
         // in bytes
-        this.sampleStartIndex = sampleStartIndex;
-        this.sampleEndIndex = sampleEndIndex;
+        this.startByteOffset = sampleStartIndex;
+        this.endByteOffset = sampleEndIndex;
         this.sampleID = sampleIndex;
-        // in bytes
-        this.sampleLength = this.sampleEndIndex - this.sampleStartIndex;
         const smplStart = sampleDataArray.currentIndex;
         
         // three data types in:
@@ -96,14 +98,13 @@ export class SoundFontSample extends BasicSample
         if (this.isCompressed)
         {
             // correct loop points
-            this.sampleLoopStartIndex += this.sampleStartIndex / 2;
-            this.sampleLoopEndIndex += this.sampleStartIndex / 2;
-            this.sampleLength = 99999999; // set to 999,999 before we decode it
+            this.sampleLoopStartIndex += this.startByteOffset / 2;
+            this.sampleLoopEndIndex += this.startByteOffset / 2;
             
             // copy the compressed data, it can be preserved during writing
             this.compressedData = sampleDataArray.slice(
-                this.sampleStartIndex / 2 + smplStart,
-                this.sampleEndIndex / 2 + smplStart
+                this.startByteOffset / 2 + smplStart,
+                this.endByteOffset / 2 + smplStart
             );
         }
         else
@@ -112,15 +113,15 @@ export class SoundFontSample extends BasicSample
             {
                 // float32 array from SF2pack, copy directly
                 this.sampleData = sampleDataArray.slice(
-                    this.sampleStartIndex / 2,
-                    this.sampleEndIndex / 2
+                    this.startByteOffset / 2,
+                    this.endByteOffset / 2
                 );
             }
             else
             {
                 // regular sf2 s16le
-                this.s16leStart = smplStart + this.sampleStartIndex;
-                this.s16leEnd = smplStart + this.sampleEndIndex;
+                this.s16leStart = smplStart + this.startByteOffset;
+                this.s16leEnd = smplStart + this.endByteOffset;
                 this.sf2FileArrayHandle = sampleDataArray;
             }
             
@@ -150,53 +151,6 @@ export class SoundFontSample extends BasicSample
         }
     }
     
-    /**
-     * @private
-     * Decode binary vorbis into a float32 pcm
-     * @returns {Float32Array}
-     */
-    decodeVorbis()
-    {
-        if (this.sampleData)
-        {
-            return this.sampleData;
-        }
-        if (this.sampleLength < 1)
-        {
-            // eos, do not do anything
-            return new Float32Array(0);
-        }
-        // get the compressed byte stream
-        // reset array and being decoding
-        try
-        {
-            /**
-             * @type {{data: Float32Array[], error: (string|null), sampleRate: number, eof: boolean}}
-             */
-            const vorbis = stbvorbis.decode(this.compressedData);
-            const decoded = vorbis.data[0];
-            if (decoded === undefined)
-            {
-                SpessaSynthWarn(`Error decoding sample ${this.sampleName}: Vorbis decode returned undefined.`);
-                return new Float32Array(0);
-            }
-            // clip
-            // because vorbis can go above 1 sometimes
-            for (let i = 0; i < decoded.length; i++)
-            {
-                // magic number is 32,767 / 32,768
-                decoded[i] = Math.max(-1, Math.min(decoded[i], 0.999969482421875));
-            }
-            return decoded;
-        }
-        catch (e)
-        {
-            // do not error out, fill with silence
-            SpessaSynthWarn(`Error decoding sample ${this.sampleName}: ${e}`);
-            return new Float32Array(this.sampleLoopEndIndex + 1);
-        }
-    }
-    
     /**
      * @param audioData {Float32Array}
      */
@@ -216,24 +170,24 @@ export class SoundFontSample extends BasicSample
             return this.sampleData;
         }
         // SF2Pack is decoded during load time
+        // SF3 is decoded in BasicSample
+        if (this.isCompressed)
+        {
+            return super.getAudioData();
+        }
         
         // start loading data if it is not loaded
-        if (this.sampleLength < 1)
+        const byteLength = this.endByteOffset - this.startByteOffset;
+        if (byteLength < 1)
         {
-            SpessaSynthWarn(`Invalid sample ${this.sampleName}! Invalid length: ${this.sampleLength}`);
+            SpessaSynthWarn(`Invalid sample ${this.sampleName}! Invalid length: ${byteLength}`);
             return new Float32Array(1);
         }
         
-        if (this.isCompressed)
-        {
-            // SF3
-            // if compressed, decode
-            this.sampleData = this.decodeVorbis();
-            return this.sampleData;
-        }
+        
         // SF2
         // read the sample data
-        let audioData = new Float32Array(this.sampleLength / 2);
+        let audioData = new Float32Array(byteLength / 2);
         let convertedSigned16 = new Int16Array(
             this.sf2FileArrayHandle.buffer.slice(this.s16leStart, this.s16leEnd)
         );
@@ -255,22 +209,13 @@ export class SoundFontSample extends BasicSample
      */
     getRawData(allowVorbis = true)
     {
-        if (this.dataOverriden)
+        if (this.dataOverriden || this.compressedData)
         {
-            return this.encodeS16LE();
-        }
-        else
-        {
-            if (this.compressedData)
-            {
-                if (allowVorbis)
-                {
-                    return this.compressedData;
-                }
-                return this.encodeS16LE();
-            }
-            return this.sf2FileArrayHandle.slice(this.s16leStart, this.s16leEnd);
+            // return vorbis or encode manually
+            return super.getRawData();
         }
+        // copy the smpl directly
+        return this.sf2FileArrayHandle.slice(this.s16leStart, this.s16leEnd);
     }
 }