spessasynth_core 3.26.18 → 3.26.19

package/package.json

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

package/src/soundfont/basic_soundfont/basic_instrument.js

@@ -37,12 +37,12 @@ export class BasicInstrument
     }
     
     /**
-     * @param zone {BasicInstrumentZone}
+     * @param zones {BasicInstrumentZone}
      */
-    addZone(zone)
+    addZones(...zones)
     {
-        zone.useCount++;
-        this.instrumentZones.push(zone);
+        zones.forEach(z => z.useCount++);
+        this.instrumentZones.push(...zones);
     }
     
     addUseCount()

package/src/soundfont/basic_soundfont/basic_preset.js

@@ -75,6 +75,14 @@ export class BasicPreset
         this.parentSoundBank = parentSoundBank;
     }
     
+    /**
+     * @param zones {BasicPresetZone}
+     */
+    addZones(...zones)
+    {
+        this.presetZones.push(...zones);
+    }
+    
     /**
      * @param allowXG {boolean}
      * @param allowSFX {boolean}

package/src/soundfont/basic_soundfont/basic_soundbank.js

@@ -67,15 +67,47 @@ class BasicSoundBank
     isXGBank = false;
     
     /**
-     * Creates a new basic soundfont template
+     * Creates a new basic soundfont template (or copies)
      * @param data {undefined|{presets: BasicPreset[], info: Object<string, string>}}
      */
     constructor(data = undefined)
     {
         if (data?.presets)
         {
-            this.presets.push(...data.presets);
             this.soundFontInfo = data.info;
+            this.addPresets(...data.presets);
+            /**
+             * @type {BasicInstrument[]}
+             */
+            const instrumentList = [];
+            for (const preset of data.presets)
+            {
+                for (const zone of preset.presetZones)
+                {
+                    if (!instrumentList.includes(zone.instrument))
+                    {
+                        instrumentList.push(zone.instrument);
+                    }
+                }
+            }
+            this.addInstruments(...instrumentList);
+            
+            /**
+             * @type {BasicSample[]}
+             */
+            const sampleList = [];
+            
+            for (const instrument of instrumentList)
+            {
+                for (const zone of instrument.instrumentZones)
+                {
+                    if (!sampleList.includes(zone.sample))
+                    {
+                        sampleList.push(zone.sample);
+                    }
+                }
+            }
+            this.addSamples(...sampleList);
         }
     }
     
@@ -127,43 +159,74 @@ class BasicSoundBank
         {
             sample.sampleData[i] = (i / 128) * 2 - 1;
         }
-        font.samples.push(sample);
+        font.addSamples(sample);
         
         const gZone = new BasicGlobalZone();
-        gZone.generators.push(new Generator(generatorTypes.initialAttenuation, 375));
-        gZone.generators.push(new Generator(generatorTypes.releaseVolEnv, -1000));
-        gZone.generators.push(new Generator(generatorTypes.sampleModes, 1));
+        gZone.addGenerators(
+            new Generator(generatorTypes.initialAttenuation, 375),
+            new Generator(generatorTypes.releaseVolEnv, -1000),
+            new Generator(generatorTypes.sampleModes, 1)
+        );
         
         const zone1 = new BasicInstrumentZone();
         zone1.setSample(sample);
         
         const zone2 = new BasicInstrumentZone();
         zone2.setSample(sample);
-        zone2.generators.push(new Generator(generatorTypes.fineTune, -9));
+        zone2.addGenerators(new Generator(generatorTypes.fineTune, -9));
         
         
         const inst = new BasicInstrument();
         inst.instrumentName = "Saw Wave";
         inst.globalZone = gZone;
-        inst.addZone(zone1);
-        inst.addZone(zone2);
-        font.instruments.push(inst);
+        inst.addZones(zone1, zone2);
+        font.addInstruments(inst);
         
         const pZone = new BasicPresetZone();
         pZone.setInstrument(inst);
         
         const preset = new BasicPreset(font);
         preset.presetName = "Saw Wave";
-        preset.presetZones.push(pZone);
-        font.presets.push(preset);
+        preset.addZones(pZone);
+        font.addPresets(preset);
         
         font.soundFontInfo["ifil"] = "2.1";
         font.soundFontInfo["isng"] = "EMU8000";
         font.soundFontInfo["INAM"] = "Dummy";
-        font._parseInternal();
+        font.flush();
         return font.write().buffer;
     }
     
+    /**
+     * @param preset {BasicPreset}
+     */
+    addPresets(...preset)
+    {
+        this.presets.push(...preset);
+    }
+    
+    flush()
+    {
+        this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
+        this._parseInternal();
+    }
+    
+    /**
+     * @param instrument {BasicInstrument}
+     */
+    addInstruments(...instrument)
+    {
+        this.instruments.push(...instrument);
+    }
+    
+    /**
+     * @param sample {BasicSample}
+     */
+    addSamples(...sample)
+    {
+        this.samples.push(...sample);
+    }
+    
     /**
      * parses the bank after loading is done
      * @protected

package/src/soundfont/basic_soundfont/basic_zone.js

@@ -3,6 +3,8 @@
  * @property {number} min - the minimum midi note
  * @property {number} max - the maximum midi note
  */
+import { generatorTypes } from "./generator_types.js";
+import { Generator } from "./generator.js";
 
 export class BasicZone
 {
@@ -47,6 +49,76 @@ export class BasicZone
         return this.velRange.min !== -1;
     }
     
+    /**
+     * Adds at the start
+     * @param generator {Generator}
+     */
+    prependGenerator(generator)
+    {
+        this.generators.unshift(generator);
+    }
+    
+    /**
+     * @param type {generatorTypes}
+     * @param value {number}
+     */
+    setGenerator(type, value)
+    {
+        switch (type)
+        {
+            case generatorTypes.sampleID:
+                throw new Error("Use setSample()");
+            case generatorTypes.instrument:
+                throw new Error("Use setInstrument()");
+            
+            case generatorTypes.velRange:
+            case generatorTypes.keyRange:
+                throw new Error("Set the range manually");
+        }
+        let generator = this.generators.find(g => g.generatorType === type);
+        if (generator)
+        {
+            generator.generatorValue = value;
+        }
+        else
+        {
+            this.addGenerators(new Generator(type, value));
+        }
+    }
+    
+    /**
+     * @param generators {Generator}
+     */
+    addGenerators(...generators)
+    {
+        generators.forEach(g =>
+        {
+            switch (g.generatorType)
+            {
+                default:
+                    this.generators.push(g);
+                    break;
+                
+                case generatorTypes.velRange:
+                    this.velRange.min = g.generatorValue & 0x7F;
+                    this.velRange.max = (g.generatorValue >> 8) & 0x7F;
+                    break;
+                
+                case generatorTypes.keyRange:
+                    this.keyRange.min = g.generatorValue & 0x7F;
+                    this.keyRange.max = (g.generatorValue >> 8) & 0x7F;
+            }
+        });
+    }
+    
+    /**
+     * @param modulators {Modulator}
+     */
+    addModulators(...modulators)
+    {
+        this.modulators.push(...modulators);
+    }
+    
     /**
      * @param generatorType {generatorTypes}
      * @param notFoundValue {number}

package/src/soundfont/basic_soundfont/generator.js

@@ -68,15 +68,6 @@ export function addAndClampGenerator(generatorType, presetGens, instrumentGens)
         instruValue = instruGen.generatorValue;
     }
     
-    let value = instruValue + presetValue;
-    
-    // Special case, initial attenuation.
-    // Shall get clamped in the volume envelope,
-    // so the modulators can be affected by negative generators (the "Brass" patch was problematic...)
-    if (generatorType === generatorTypes.initialAttenuation)
-    {
-        return value;
-    }
-    
-    return Math.max(limits.min, Math.min(limits.max, value));
+    // limits are applied in the compute_modulator function
+    return instruValue + presetValue;
 }

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

@@ -308,7 +308,7 @@ export function combineZones(preset, globalize = true)
                 // if the global value is the default value just remove it, no need to add it
                 if (targetValue !== defaultForChecked)
                 {
-                    globalZone.generators.push(new Generator(checkedType, targetValue));
+                    globalZone.addGenerators(new Generator(checkedType, targetValue));
                 }
                 // remove from the zones
                 finalZones.forEach(z =>
@@ -329,7 +329,7 @@ export function combineZones(preset, globalize = true)
                         // Since we're globalizing, we need to add the default here.
                         if (targetValue !== defaultForChecked)
                         {
-                            z.generators.push(new Generator(checkedType, defaultForChecked));
+                            z.addGenerators(new Generator(checkedType, defaultForChecked));
                         }
                     }
                 });
@@ -360,7 +360,7 @@ export function combineZones(preset, globalize = true)
             }
             if (existsForAllZones === true)
             {
-                globalZone.modulators.push(Modulator.copy(checkedModulator));
+                globalZone.addModulators(Modulator.copy(checkedModulator));
                 // delete it from local zones.
                 for (const zone of finalZones)
                 {

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

@@ -18,16 +18,16 @@ export function getIGEN()
         igensize += inst.instrumentZones.reduce((sum, z) =>
         {
             // clear sample and range generators before determining the size
-            z.generators = z.generators.filter(g =>
+            z.generators = (z.generators.filter(g =>
                 g.generatorType !== generatorTypes.sampleID &&
                 g.generatorType !== generatorTypes.keyRange &&
                 g.generatorType !== generatorTypes.velRange
-            );
+            ));
             // add sample and ranges if necessary
             // unshift vel then key (to make key first) and the sample is last
             if (z.hasVelRange)
             {
-                z.generators.unshift(new Generator(
+                z.prependGenerator(new Generator(
                     generatorTypes.velRange,
                     z.velRange.max << 8 | Math.max(z.velRange.min, 0),
                     false
@@ -35,14 +35,14 @@ export function getIGEN()
             }
             if (z.hasKeyRange)
             {
-                z.generators.unshift(new Generator(
+                z.prependGenerator(new Generator(
                     generatorTypes.keyRange,
                     z.keyRange.max << 8 | Math.max(z.keyRange.min, 0),
                     false
                 ));
             }
             // add sample id
-            z.generators.push(new Generator(
+            z.addGenerators(new Generator(
                 generatorTypes.sampleID,
                 this.samples.indexOf(z.sample),
                 false

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

@@ -16,7 +16,7 @@ export function getIMOD()
     {
         imodsize += inst.globalZone.modulators.length * MOD_BYTE_SIZE;
         // start with one mod for global
-        imodsize += inst.instrumentZones.reduce((sum, z) => z.modulators.length * 10 + sum, 0);
+        imodsize += inst.instrumentZones.reduce((sum, z) => z.modulators.length * MOD_BYTE_SIZE + sum, 0);
     }
     const imoddata = new IndexedByteArray(imodsize);
     
@@ -46,7 +46,7 @@ export function getIMOD()
     }
     
     // terminal modulator, is zero
-    writeLittleEndian(imoddata, 0, 10);
+    writeLittleEndian(imoddata, 0, MOD_BYTE_SIZE);
     
     return writeRIFFChunk(new RiffChunk(
         "imod",

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

@@ -28,7 +28,7 @@ export function getPGEN()
             // unshift vel then key and instrument is last
             if (z.hasVelRange)
             {
-                z.generators.unshift(new Generator(
+                z.prependGenerator(new Generator(
                     generatorTypes.velRange,
                     z.velRange.max << 8 | Math.max(z.velRange.min, 0),
                     false
@@ -36,14 +36,14 @@ export function getPGEN()
             }
             if (z.hasKeyRange)
             {
-                z.generators.unshift(new Generator(
+                z.prependGenerator(new Generator(
                     generatorTypes.keyRange,
                     z.keyRange.max << 8 | Math.max(z.keyRange.min, 0),
                     false
                 ));
             }
             // write the instrument id
-            z.generators.push(new Generator(
+            z.addGenerators(new Generator(
                 generatorTypes.instrument,
                 this.instruments.indexOf(z.instrument),
                 false

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

@@ -46,7 +46,7 @@ export function getPMOD()
     }
     
     // terminal modulator, is zero
-    writeLittleEndian(pmoddata, 0, 10);
+    writeLittleEndian(pmoddata, 0, MOD_BYTE_SIZE);
     
     return writeRIFFChunk(new RiffChunk(
         "pmod",

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

@@ -14,12 +14,16 @@ import { getPBAG } from "./pbag.js";
 import { getPHDR } from "./phdr.js";
 import { writeLittleEndian, writeWord } from "../../../utils/byte_functions/little_endian.js";
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../../../utils/loggin.js";
+import { MOD_BYTE_SIZE } from "../modulator.js";
+import { fillWithDefaults } from "../../../utils/fill_with_defaults.js";
 /**
  * @typedef {Object} SoundFont2WriteOptions
- * @property {boolean} compress - if the soundfont should be compressed with the Ogg Vorbis codec
- * @property {number} 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 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} writeDefaultModulators - if the DMOD chunk should be written.
+ * Recommended.
  */
 
 /**
@@ -28,7 +32,8 @@ import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from
 const DEFAULT_WRITE_OPTIONS = {
     compress: false,
     compressionQuality: 0.5,
-    compressionFunction: undefined
+    compressionFunction: undefined,
+    writeDefaultModulators: true
 };
 
 /**
@@ -39,6 +44,7 @@ const DEFAULT_WRITE_OPTIONS = {
  */
 export function write(options = DEFAULT_WRITE_OPTIONS)
 {
+    options = fillWithDefaults(options, DEFAULT_WRITE_OPTIONS);
     if (options.compress)
     {
         if (typeof options.compressionFunction !== "function")
@@ -72,7 +78,7 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
         this.soundFontInfo["ifil"] = "3.0"; // set version to 3
     }
     
-    if (this.defaultModulators.length > 0)
+    if (options?.writeDefaultModulators)
     {
         // trigger the DMOD write
         this.soundFontInfo["DMOD"] = `${this.defaultModulators.length} Modulators`;
@@ -108,7 +114,7 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
                 consoleColors.recognized,
                 consoleColors.info
             );
-            let dmodsize = 10 + mods.length * 10;
+            let dmodsize = MOD_BYTE_SIZE + mods.length * MOD_BYTE_SIZE;
             const dmoddata = new IndexedByteArray(dmodsize);
             for (const mod of mods)
             {
@@ -120,7 +126,7 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
             }
             
             // terminal modulator, is zero
-            writeLittleEndian(dmoddata, 0, 10);
+            writeLittleEndian(dmoddata, 0, MOD_BYTE_SIZE);
             
             infoArrays.push(writeRIFFChunk(new RiffChunk(
                 type,

package/src/soundfont/dls/dls_soundfont.js

@@ -114,8 +114,7 @@ class DLSSoundFont extends BasicSoundBank
         this.readDLSInstrumentList(instrumentListChunk);
         
         // sort presets
-        this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
-        this._parseInternal();
+        this.flush();
         SpessaSynthInfo(
             `%cParsing finished! %c"${this.soundFontInfo["INAM"] || "UNNAMED"}"%c has %c${this.presets.length} %cpresets,
         %c${this.instruments.length}%c instruments and %c${this.samples.length}%c samples.`,

package/src/soundfont/dls/dls_zone.js

@@ -36,22 +36,21 @@ export class DLSZone extends BasicInstrumentZone
     {
         if (loopingMode !== 0)
         {
-            this.generators.push(new Generator(generatorTypes.sampleModes, loopingMode));
+            this.addGenerators(new Generator(generatorTypes.sampleModes, loopingMode));
         }
-        this.generators.push(new Generator(generatorTypes.initialAttenuation, attenuationCb));
-        this.isGlobal = false;
+        this.addGenerators(new Generator(generatorTypes.initialAttenuation, attenuationCb));
         
         // correct tuning if needed
         samplePitchCorrection -= sample.samplePitchCorrection;
         const coarseTune = Math.trunc(samplePitchCorrection / 100);
         if (coarseTune !== 0)
         {
-            this.generators.push(new Generator(generatorTypes.coarseTune, coarseTune));
+            this.addGenerators(new Generator(generatorTypes.coarseTune, coarseTune));
         }
         const fineTune = samplePitchCorrection - (coarseTune * 100);
         if (fineTune !== 0)
         {
-            this.generators.push(new Generator(generatorTypes.fineTune, fineTune));
+            this.addGenerators(new Generator(generatorTypes.fineTune, fineTune));
         }
         
         // correct loop if needed
@@ -62,33 +61,32 @@ export class DLSZone extends BasicInstrumentZone
             if (diffStart !== 0)
             {
                 const fine = diffStart % 32768;
-                this.generators.push(new Generator(generatorTypes.startloopAddrsOffset, fine));
+                this.addGenerators(new Generator(generatorTypes.startloopAddrsOffset, fine));
                 // coarse generator uses 32768 samples per step
                 const coarse = Math.trunc(diffStart / 32768);
                 if (coarse !== 0)
                 {
-                    this.generators.push(new Generator(generatorTypes.startloopAddrsCoarseOffset, coarse));
+                    this.addGenerators(new Generator(generatorTypes.startloopAddrsCoarseOffset, coarse));
                 }
             }
             if (diffEnd !== 0)
             {
                 const fine = diffEnd % 32768;
-                this.generators.push(new Generator(generatorTypes.endloopAddrsOffset, fine));
+                this.addGenerators(new Generator(generatorTypes.endloopAddrsOffset, fine));
                 // coarse generator uses 32768 samples per step
                 const coarse = Math.trunc(diffEnd / 32768);
                 if (coarse !== 0)
                 {
-                    this.generators.push(new Generator(generatorTypes.endloopAddrsCoarseOffset, coarse));
+                    this.addGenerators(new Generator(generatorTypes.endloopAddrsCoarseOffset, coarse));
                 }
             }
         }
         // correct the key if needed
         if (sampleKey !== sample.samplePitch)
         {
-            this.generators.push(new Generator(generatorTypes.overridingRootKey, sampleKey));
+            this.addGenerators(new Generator(generatorTypes.overridingRootKey, sampleKey));
         }
         // add sample ID
-        this.generators.push(new Generator(generatorTypes.sampleID, sampleID));
         this.setSample(sample);
     }
 }

package/src/soundfont/dls/read_instrument.js

@@ -84,12 +84,12 @@ export function readDLSInstrument(chunk)
     // reverb
     if (globalZone.modulators.find(m => m.modulatorDestination === generatorTypes.reverbEffectsSend) === undefined)
     {
-        globalZone.modulators.push(Modulator.copy(DEFAULT_DLS_REVERB));
+        globalZone.addModulators(Modulator.copy(DEFAULT_DLS_REVERB));
     }
     // chorus
     if (globalZone.modulators.find(m => m.modulatorDestination === generatorTypes.chorusEffectsSend) === undefined)
     {
-        globalZone.modulators.push(Modulator.copy(DEFAULT_DLS_CHORUS));
+        globalZone.addModulators(Modulator.copy(DEFAULT_DLS_CHORUS));
     }
     
     // read regions
@@ -108,11 +108,11 @@ export function readDLSInstrument(chunk)
         const zone = this.readRegion(chunk);
         if (zone)
         {
-            preset.DLSInstrument.addZone(zone);
+            preset.DLSInstrument.addZones(zone);
         }
     }
     
-    this.presets.push(preset);
-    this.instruments.push(preset.DLSInstrument);
+    this.addPresets(preset);
+    this.addInstruments(preset.DLSInstrument);
     SpessaSynthGroupEnd();
 }

package/src/soundfont/dls/read_lart.js

@@ -16,8 +16,8 @@ export function readLart(lartChunk, lar2Chunk, zone)
             const art1 = readRIFFChunk(lartChunk.chunkData);
             this.verifyHeader(art1, "art1", "art2");
             const modsAndGens = readArticulation(art1, true);
-            zone.generators.push(...modsAndGens.generators);
-            zone.modulators.push(...modsAndGens.modulators);
+            zone.addGenerators(...modsAndGens.generators);
+            zone.addModulators(...modsAndGens.modulators);
         }
     }
     
@@ -28,8 +28,8 @@ export function readLart(lartChunk, lar2Chunk, zone)
             const art2 = readRIFFChunk(lar2Chunk.chunkData);
             this.verifyHeader(art2, "art2", "art1");
             const modsAndGens = readArticulation(art2, false);
-            zone.generators.push(...modsAndGens.generators);
-            zone.modulators.push(...modsAndGens.modulators);
+            zone.addGenerators(...modsAndGens.generators);
+            zone.addModulators(...modsAndGens.modulators);
         }
     }
 }

package/src/soundfont/dls/read_region.js

@@ -52,7 +52,7 @@ export function readRegion(chunk)
     const exclusive = readLittleEndian(regionHeader.chunkData, 2);
     if (exclusive !== 0)
     {
-        zone.generators.push(new Generator(generatorTypes.exclusiveClass, exclusive));
+        zone.addGenerators(new Generator(generatorTypes.exclusiveClass, exclusive));
     }
     
     // lart
@@ -61,7 +61,6 @@ export function readRegion(chunk)
     this.readLart(lart, lar2, zone);
     
     // wsmp: wave sample chunk
-    zone.isGlobal = false;
     const waveSampleChunk = regionChunks.find(c => c.header === "wsmp");
     // cbSize
     readLittleEndian(waveSampleChunk.chunkData, 4);

package/src/soundfont/read_sf2/instruments.js

@@ -36,7 +36,7 @@ export class Instrument extends BasicInstrument
             const zone = zones[i];
             if (zone.hasSample())
             {
-                this.addZone(zone);
+                this.addZones(zone);
             }
             else
             {

package/src/soundfont/read_sf2/soundfont.js

@@ -242,9 +242,8 @@ export class SoundFont2 extends BasicSoundBank
         
         let presetZones = readPresetZones(presetZonesChunk, presetGenerators, presetModulators, this.instruments);
         
-        this.presets.push(...readPresets(presetHeadersChunk, presetZones, this));
-        this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
-        this._parseInternal();
+        this.addPresets(...readPresets(presetHeadersChunk, presetZones, this));
+        this.flush();
         SpessaSynthInfo(
             `%cParsing finished! %c"${this.soundFontInfo["INAM"]}"%c has %c${this.presets.length} %cpresets,
         %c${this.instruments.length}%c instruments and %c${this.samples.length}%c samples.`,

package/src/soundfont/read_sf2/zones.js

@@ -46,7 +46,7 @@ export class InstrumentZone extends BasicInstrumentZone
             {
                 throw new Error("Missing generator in instrument zone! The file may corrupted.");
             }
-            this.generators.push(g);
+            this.addGenerators(g);
         }
     }
     
@@ -63,7 +63,7 @@ export class InstrumentZone extends BasicInstrumentZone
             {
                 throw new Error("Missing modulator in instrument zone! The file may corrupted.");
             }
-            this.modulators.push(m);
+            this.addModulators(m);
         }
     }
     
@@ -79,32 +79,6 @@ export class InstrumentZone extends BasicInstrumentZone
             this.setSample(samples[sampleID.generatorValue]);
         }
     }
-    
-    /**
-     * Reads the keyRange of the zone
-     */
-    getKeyRange()
-    {
-        let range = this.generators.find(g => g.generatorType === generatorTypes.keyRange);
-        if (range)
-        {
-            this.keyRange.min = range.generatorValue & 0x7F;
-            this.keyRange.max = (range.generatorValue >> 8) & 0x7F;
-        }
-    }
-    
-    /**
-     * reads the velolicty range of the zone
-     */
-    getVelRange()
-    {
-        let range = this.generators.find(g => g.generatorType === generatorTypes.velRange);
-        if (range)
-        {
-            this.velRange.min = range.generatorValue & 0x7F;
-            this.velRange.max = (range.generatorValue >> 8) & 0x7F;
-        }
-    }
 }
 
 /**
@@ -132,8 +106,6 @@ export function readInstrumentZones(zonesChunk, instrumentGenerators, instrument
             zones[zones.length - 1].getGenerators(instrumentGenerators);
             zones[zones.length - 1].getModulators(instrumentModulators);
             zones[zones.length - 1].getSample(instrumentSamples);
-            zones[zones.length - 1].getKeyRange();
-            zones[zones.length - 1].getVelRange();
         }
         zones.push(zone);
     }
@@ -179,7 +151,7 @@ export class PresetZone extends BasicPresetZone
             {
                 throw new Error("Missing generator in preset zone! The file may corrupted.");
             }
-            this.generators.push(g);
+            this.addGenerators(g);
         }
     }
     
@@ -196,7 +168,7 @@ export class PresetZone extends BasicPresetZone
             {
                 throw new Error("Missing modulator in preset zone! The file may corrupted.");
             }
-            this.modulators.push(m);
+            this.addModulators(m);
         }
     }
     
@@ -212,32 +184,6 @@ export class PresetZone extends BasicPresetZone
             this.setInstrument(instruments[instrumentID.generatorValue]);
         }
     }
-    
-    /**
-     * Reads the keyRange of the zone
-     */
-    getKeyRange()
-    {
-        let range = this.generators.find(g => g.generatorType === generatorTypes.keyRange);
-        if (range)
-        {
-            this.keyRange.min = range.generatorValue & 0x7F;
-            this.keyRange.max = (range.generatorValue >> 8) & 0x7F;
-        }
-    }
-    
-    /**
-     * reads the velolicty range of the zone
-     */
-    getVelRange()
-    {
-        let range = this.generators.find(g => g.generatorType === generatorTypes.velRange);
-        if (range)
-        {
-            this.velRange.min = range.generatorValue & 0x7F;
-            this.velRange.max = (range.generatorValue >> 8) & 0x7F;
-        }
-    }
 }
 
 /**
@@ -265,8 +211,6 @@ export function readPresetZones(zonesChunk, presetGenerators, presetModulators,
             zones[zones.length - 1].getGenerators(presetGenerators);
             zones[zones.length - 1].getModulators(presetModulators);
             zones[zones.length - 1].getInstrument(instruments);
-            zones[zones.length - 1].getKeyRange();
-            zones[zones.length - 1].getVelRange();
         }
         zones.push(zone);
     }

package/src/synthetizer/audio_engine/engine_components/compute_modulator.js

@@ -3,7 +3,6 @@ import { VolumeEnvelope } from "./volume_envelope.js";
 import { ModulationEnvelope } from "./modulation_envelope.js";
 import { Modulator, modulatorSources } from "../../../soundfont/basic_soundfont/modulator.js";
 import { NON_CC_INDEX_OFFSET } from "./controller_tables.js";
-import { SpessaSynthWarn } from "../../../utils/loggin.js";
 import { generatorLimits, generatorTypes } from "../../../soundfont/basic_soundfont/generator_types.js";
 
 /**
@@ -146,22 +145,23 @@ export function computeModulators(voice, sourceUsesCC = -1, sourceIndex = 0)
         modulatedGenerators.set(generators);
         modulators.forEach(mod =>
         {
-            const limits = generatorLimits[mod.modulatorDestination];
-            if (!limits)
-            {
-                SpessaSynthWarn(`Invalid modulator: ${mod.modulatorDestination}`);
-                return;
-            }
-            const newValue = modulatedGenerators[mod.modulatorDestination] + computeModulator(
+            modulatedGenerators[mod.modulatorDestination] += computeModulator(
                 this.midiControllers,
                 mod,
                 voice
             );
-            modulatedGenerators[mod.modulatorDestination] = Math.max(
-                limits.min,
-                Math.min(newValue, limits.max)
-            );
         });
+        // apply limits
+        for (let gen = 0; gen < modulatedGenerators.length; gen++)
+        {
+            const limit = generatorLimits[gen];
+            if (!limit)
+            {
+                // skip unused
+                continue;
+            }
+            modulatedGenerators[gen] = Math.min(limit.max, Math.max(limit.min, modulatedGenerators[gen]));
+        }
         VolumeEnvelope.recalculate(voice);
         ModulationEnvelope.recalculate(voice);
         return;
@@ -201,14 +201,15 @@ export function computeModulators(voice, sourceUsesCC = -1, sourceIndex = 0)
                 {
                     if (m.modulatorDestination === destination)
                     {
-                        const limits = generatorLimits[mod.modulatorDestination];
-                        const newValue = modulatedGenerators[mod.modulatorDestination] + m.currentValue;
-                        modulatedGenerators[mod.modulatorDestination] = Math.max(
-                            limits.min,
-                            Math.min(newValue, limits.max)
-                        );
+                        modulatedGenerators[destination] += m.currentValue;
                     }
                 });
+                // apply limits
+                const limits = generatorLimits[destination];
+                modulatedGenerators[destination] = Math.max(
+                    limits.min,
+                    Math.min(modulatedGenerators[destination], limits.max)
+                );
                 computedDestinations.add(destination);
             }
         }

package/src/synthetizer/audio_engine/engine_methods/controller_control/reset_controllers.js

@@ -238,8 +238,4 @@ export function resetParameters()
     this.midiControllers[midiControllers.RPNMsb] = 127 << 7;
     this.resetGeneratorOverrides();
     this.resetGeneratorOffsets();
-    SpessaSynthInfo(
-        "%cResetting Registered and Non-Registered Parameters!",
-        consoleColors.info
-    );
 }