spessasynth_core 3.26.17 → 3.26.18

package/src/soundfont/basic_soundfont/modulator.js

@@ -1,11 +1,16 @@
-import { generatorTypes, MAX_GENERATOR } from "./generator.js";
 import { midiControllers } from "../../midi/midi_message.js";
+import { generatorTypes, MAX_GENERATOR } from "./generator_types.js";
 
 /**
  * modulators.js
  * purpose: parses soundfont modulators and the source enums, also includes the default modulators list
  **/
 
+export const MOD_BYTE_SIZE = 10;
+
+/**
+ * @enum {number}
+ */
 export const modulatorSources = {
     noController: 0,
     noteOnVelocity: 2,
@@ -17,6 +22,11 @@ export const modulatorSources = {
     link: 127
     
 };
+
+/**
+ *
+ * @enum {number}
+ */
 export const modulatorCurveTypes = {
     linear: 0,
     concave: 1,
@@ -27,7 +37,7 @@ export const modulatorCurveTypes = {
 export class Modulator
 {
     /**
-     * The current computed value of this modulator
+     * The current computed value of this modulator. Only used in the synthesis engine for local voices
      * @type {number}
      */
     currentValue = 0;
@@ -51,18 +61,123 @@ export class Modulator
     transformType;
     
     /**
-     * creates a modulator
-     * @param srcEnum {number}
-     * @param secSrcEnum {number}
-     * @param destination {generatorTypes|number}
+     * Indicates if the given modulator is chorus or reverb effects modulator.
+     * This is done to simulate BASSMIDI effects behavior:
+     * - defaults to 1000 transform amount rather than 200
+     * - values can be changed, but anything above 200 is 1000
+     * (except for values above 1000, they are copied directly)
+     * - all values below are multiplied by 5 (200 * 5 = 1000)
+     * - still can be disabled if the soundfont has its own modulator curve
+     * - this fixes the very low amount of reverb by default and doesn't break soundfonts
+     * @type {boolean}
+     */
+    isEffectModulator = false;
+    
+    /**
+     * 1 if the source is bipolar (min is -1, max is 1)
+     * otherwise min is 0 and max is 1
+     * @type {0|1}
+     */
+    sourcePolarity;
+    
+    /**
+     * 1 if the source is negative (from 1 to 0)
+     * @type {0|1}
+     */
+    sourceDirection;
+    
+    /**
+     * 1 if the source uses a MIDI CC
+     * @type {0|1}
+     */
+    sourceUsesCC;
+    
+    /**
+     * source index/CC number
+     * @type {modulatorSources|midiControllers}
+     */
+    sourceIndex;
+    
+    /**
+     * source curve type
+     * @type {modulatorCurveTypes}
+     */
+    sourceCurveType;
+    
+    /**
+     * 1 if the source is bipolar (min is -1, max is 1)
+     * otherwise min is 0 and max is 1
+     * @type {0|1}
+     */
+    secSrcPolarity;
+    
+    /**
+     * 1 if the source is negative (from 1 to 0)
+     * @type {0|1}
+     */
+    secSrcDirection;
+    
+    /**
+     * 1 if the source uses a MIDI CC
+     * @type {0|1}
+     */
+    secSrcUsesCC;
+    
+    /**
+     * source index/CC number
+     * @type {modulatorSources|midiControllers}
+     */
+    secSrcIndex;
+    
+    /**
+     * source curve type
+     * @type {modulatorCurveTypes}
+     */
+    secSrcCurveType;
+    
+    /**
+     * Creates a new SF2 Modulator
+     * @param sourceIndex {modulatorSources|midiControllers}
+     * @param sourceCurveType {modulatorCurveTypes}
+     * @param sourceUsesCC {0|1}
+     * @param sourcePolarity {0|1}
+     * @param sourceDirection {0|1}
+     * @param secSrcIndex {modulatorSources|midiControllers}
+     * @param secSrcCurveType {modulatorCurveTypes}
+     * @param secSrcUsesCC {0|1}
+     * @param secSrcPolarity {0|1}
+     * @param secSrcDirection {0|1}
+     * @param destination {generatorTypes}
      * @param amount {number}
-     * @param transformType {number}
+     * @param transformType {0|2}
      */
-    constructor(srcEnum, secSrcEnum, destination, amount, transformType)
+    constructor(sourceIndex,
+                sourceCurveType,
+                sourceUsesCC,
+                sourcePolarity,
+                sourceDirection,
+                secSrcIndex,
+                secSrcCurveType,
+                secSrcUsesCC,
+                secSrcPolarity,
+                secSrcDirection,
+                destination,
+                amount,
+                transformType)
     {
-        const sourceEnum = srcEnum;
+        this.sourcePolarity = sourcePolarity;
+        this.sourceDirection = sourceDirection;
+        this.sourceUsesCC = sourceUsesCC;
+        this.sourceIndex = sourceIndex;
+        this.sourceCurveType = sourceCurveType;
+        
+        this.secSrcPolarity = secSrcPolarity;
+        this.secSrcDirection = secSrcDirection;
+        this.secSrcUsesCC = secSrcUsesCC;
+        this.secSrcIndex = secSrcIndex;
+        this.secSrcCurveType = secSrcCurveType;
+        
         this.modulatorDestination = destination;
-        const secondarySourceEnum = secSrcEnum;
         this.transformAmount = amount;
         this.transformType = transformType;
         
@@ -72,41 +187,6 @@ export class Modulator
             this.modulatorDestination = generatorTypes.INVALID; // flag as invalid (for linked ones)
         }
         
-        // decode the source
-        this.sourcePolarity = sourceEnum >> 9 & 1;
-        this.sourceDirection = sourceEnum >> 8 & 1;
-        this.sourceUsesCC = sourceEnum >> 7 & 1;
-        this.sourceIndex = sourceEnum & 127;
-        this.sourceCurveType = sourceEnum >> 10 & 3;
-        
-        // decode the secondary source
-        this.secSrcPolarity = secondarySourceEnum >> 9 & 1;
-        this.secSrcDirection = secondarySourceEnum >> 8 & 1;
-        this.secSrcUsesCC = secondarySourceEnum >> 7 & 1;
-        this.secSrcIndex = secondarySourceEnum & 127;
-        this.secSrcCurveType = secondarySourceEnum >> 10 & 3;
-        
-        /**
-         * Indicates if the given modulator is chorus or reverb effects modulator.
-         * This is done to simulate BASSMIDI effects behavior:
-         * - defaults to 1000 transform amount rather than 200
-         * - values can be changed, but anything above 200 is 1000
-         * (except for values above 1000, they are copied directly)
-         * - all values below are multiplied by 5 (200 * 5 = 1000)
-         * - still can be disabled if the soundfont has its own modulator curve
-         * - this fixes the very low amount of reverb by default and doesn't break soundfonts
-         * @type {boolean}
-         */
-        this.isEffectModulator =
-            (
-                sourceEnum === 0x00DB
-                || sourceEnum === 0x00DD
-            )
-            && secondarySourceEnum === 0x0
-            && (
-                this.modulatorDestination === generatorTypes.reverbEffectsSend
-                || this.modulatorDestination === generatorTypes.chorusEffectsSend
-            );
     }
     
     /**
@@ -116,8 +196,16 @@ export class Modulator
     static copy(modulator)
     {
         return new Modulator(
-            modulator.getSourceEnum(),
-            modulator.getSecSrcEnum(),
+            modulator.sourceIndex,
+            modulator.sourceCurveType,
+            modulator.sourceUsesCC,
+            modulator.sourcePolarity,
+            modulator.sourceDirection,
+            modulator.secSrcIndex,
+            modulator.secSrcCurveType,
+            modulator.secSrcUsesCC,
+            modulator.secSrcPolarity,
+            modulator.secSrcDirection,
             modulator.modulatorDestination,
             modulator.transformAmount,
             modulator.transformType
@@ -174,7 +262,7 @@ export class Modulator
         
         let secSrcString = getKeyByValue(modulatorCurveTypes, mod.secSrcCurveType);
         secSrcString += mod.secSrcPolarity === 0 ? " unipolar " : " bipolar ";
-        secSrcString += mod.secSrcCurveType === 0 ? "forwards " : "backwards ";
+        secSrcString += mod.secSrcDirection === 0 ? "forwards " : "backwards ";
         if (mod.secSrcUsesCC)
         {
             secSrcString += getKeyByValue(midiControllers, mod.secSrcIndex);
@@ -222,8 +310,16 @@ export class Modulator
     sumTransform(modulator)
     {
         return new Modulator(
-            this.getSourceEnum(),
-            this.getSecSrcEnum(),
+            this.sourceIndex,
+            this.sourceCurveType,
+            this.sourceUsesCC,
+            this.sourcePolarity,
+            this.sourceDirection,
+            this.secSrcIndex,
+            this.secSrcCurveType,
+            this.secSrcUsesCC,
+            this.secSrcPolarity,
+            this.secSrcDirection,
             this.modulatorDestination,
             this.transformAmount + modulator.transformAmount,
             this.transformType
@@ -231,6 +327,62 @@ export class Modulator
     }
 }
 
+export class DecodedModulator extends Modulator
+{
+    /**
+     * reads an SF2 modulator
+     * @param sourceEnum {number} SF2 source enum
+     * @param secondarySourceEnum {number} SF2 secondary source enum
+     * @param destination {generatorTypes|number} destination
+     * @param amount {number} amount
+     * @param transformType {number} transform type
+     */
+    constructor(sourceEnum, secondarySourceEnum, destination, amount, transformType)
+    {
+        // decode the source
+        const sourcePolarity = sourceEnum >> 9 & 1;
+        const sourceDirection = sourceEnum >> 8 & 1;
+        const sourceUsesCC = sourceEnum >> 7 & 1;
+        const sourceIndex = /** @type {modulatorSources} **/ sourceEnum & 127;
+        const sourceCurveType = /** @type {modulatorCurveTypes} **/ sourceEnum >> 10 & 3;
+        
+        // decode the secondary source
+        const secSrcPolarity = secondarySourceEnum >> 9 & 1;
+        const secSrcDirection = secondarySourceEnum >> 8 & 1;
+        const secSrcUsesCC = secondarySourceEnum >> 7 & 1;
+        const secSrcIndex = /** @type {modulatorSources} **/ secondarySourceEnum & 127;
+        const secSrcCurveType = /** @type {modulatorCurveTypes} **/ secondarySourceEnum >> 10 & 3;
+        
+        super(
+            sourceIndex,
+            sourceCurveType,
+            sourceUsesCC,
+            sourcePolarity,
+            sourceDirection,
+            secSrcIndex,
+            secSrcCurveType,
+            secSrcUsesCC,
+            secSrcPolarity,
+            secSrcDirection,
+            destination,
+            amount,
+            transformType
+        );
+        
+        
+        this.isEffectModulator =
+            (
+                sourceEnum === 0x00DB
+                || sourceEnum === 0x00DD
+            )
+            && secondarySourceEnum === 0x0
+            && (
+                this.modulatorDestination === generatorTypes.reverbEffectsSend
+                || this.modulatorDestination === generatorTypes.chorusEffectsSend
+            );
+    }
+}
+
 export const DEFAULT_ATTENUATION_MOD_AMOUNT = 960;
 export const DEFAULT_ATTENUATION_MOD_CURVE_TYPE = modulatorCurveTypes.concave;
 
@@ -241,7 +393,7 @@ export function getModSourceEnum(curveType, polarity, direction, isCC, index)
 
 const soundFontModulators = [
     // vel to attenuation
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
             0,
@@ -256,10 +408,10 @@ const soundFontModulators = [
     ),
     
     // mod wheel to vibrato
-    new Modulator(0x0081, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    new DecodedModulator(0x0081, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
     
     // vol to attenuation
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
             0,
@@ -274,17 +426,17 @@ const soundFontModulators = [
     ),
     
     // channel pressure to vibrato
-    new Modulator(0x000D, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    new DecodedModulator(0x000D, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
     
     // pitch wheel to tuning
-    new Modulator(0x020E, 0x0010, generatorTypes.fineTune, 12700, 0),
+    new DecodedModulator(0x020E, 0x0010, generatorTypes.fineTune, 12700, 0),
     
     // pan to uhh, pan
     // amount is 500 instead of 1000, see #59
-    new Modulator(0x028A, 0x0, generatorTypes.pan, 500, 0),
+    new DecodedModulator(0x028A, 0x0, generatorTypes.pan, 500, 0),
     
     // expression to attenuation
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
             0,
@@ -299,16 +451,16 @@ const soundFontModulators = [
     ),
     
     // reverb effects to send
-    new Modulator(0x00DB, 0x0, generatorTypes.reverbEffectsSend, 200, 0),
+    new DecodedModulator(0x00DB, 0x0, generatorTypes.reverbEffectsSend, 200, 0),
     
     // chorus effects to send
-    new Modulator(0x00DD, 0x0, generatorTypes.chorusEffectsSend, 200, 0)
+    new DecodedModulator(0x00DD, 0x0, generatorTypes.chorusEffectsSend, 200, 0)
 ];
 
 const customModulators = [
     // custom modulators heck yeah
     // poly pressure to vibrato
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(modulatorCurveTypes.linear, 0, 0, 0, modulatorSources.polyPressure),
         0x0,
         generatorTypes.vibLfoToPitch,
@@ -317,7 +469,7 @@ const customModulators = [
     ),
     
     // cc 92 (tremolo) to modLFO volume
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             0,
@@ -332,7 +484,7 @@ const customModulators = [
     ),
     
     // cc 73 (attack time) to volEnv attack
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.convex,
             1,
@@ -347,7 +499,7 @@ const customModulators = [
     ),
     
     // cc 72 (release time) to volEnv release
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             1,
@@ -362,7 +514,7 @@ const customModulators = [
     ),
     
     // cc 74 (brightness) to filterFc
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             1,
@@ -377,7 +529,7 @@ const customModulators = [
     ),
     
     // cc 71 (filter Q) to filter Q
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             1,

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

@@ -1,7 +1,7 @@
 import { getDLSArticulatorFromSf2Generator, getDLSArticulatorFromSf2Modulator } from "./modulator_converter.js";
 import { writeRIFFOddSize } from "../riff_chunk.js";
 import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
-import { Generator, generatorTypes } from "../generator.js";
+import { Generator } from "../generator.js";
 import { writeDword } from "../../../utils/byte_functions/little_endian.js";
 import { consoleColors } from "../../../utils/other.js";
 import { SpessaSynthInfo, SpessaSynthWarn } from "../../../utils/loggin.js";
@@ -12,6 +12,7 @@ import {
     DLS_1_NO_VIBRATO_MOD,
     DLS_1_NO_VIBRATO_PRESSURE
 } from "../../dls/dls_sources.js";
+import { generatorTypes } from "../generator_types.js";
 
 const invalidGeneratorTypes = new Set([
     generatorTypes.sampleModes,
@@ -34,7 +35,7 @@ const invalidGeneratorTypes = new Set([
 ]);
 
 /**
- * @param zone {BasicInstrumentZone}
+ * @param zone {BasicZone}
  * @returns {IndexedByteArray}
  */
 export function writeArticulator(zone)

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

@@ -1,6 +1,8 @@
 import { Modulator } from "../modulator.js";
-import { BasicInstrumentZone } from "../basic_zones.js";
-import { Generator, generatorLimits, generatorTypes } from "../generator.js";
+import { Generator } from "../generator.js";
+import { generatorLimits, generatorTypes } from "../generator_types.js";
+import { BasicInstrumentZone } from "../basic_instrument_zone.js";
+import { BasicGlobalZone } from "../basic_global_zone.js";
 
 const notGlobalizedTypes = new Set([
     generatorTypes.velRange,
@@ -30,7 +32,7 @@ const notGlobalizedTypes = new Set([
  * Combines preset zones
  * @param preset {BasicPreset}
  * @param globalize {boolean}
- * @returns {BasicInstrumentZone[]}
+ * @returns {{global: BasicGlobalZone, zones: BasicInstrumentZone[]}}
  */
 export function combineZones(preset, globalize = true)
 {
@@ -75,25 +77,16 @@ export function combineZones(preset, globalize = true)
      * @type {Modulator[]}
      */
     const globalPresetModulators = [];
-    let globalPresetKeyRange = { min: 0, max: 127 };
-    let globalPresetVelRange = { min: 0, max: 127 };
     
     // find the global zone and apply ranges, generators, and modulators
-    const globalPresetZone = preset.presetZones.find(z => z.isGlobal);
-    if (globalPresetZone)
-    {
-        globalPresetGenerators.push(...globalPresetZone.generators);
-        globalPresetModulators.push(...globalPresetZone.modulators);
-        globalPresetKeyRange = globalPresetZone.keyRange;
-        globalPresetVelRange = globalPresetZone.velRange;
-    }
+    const globalPresetZone = preset.globalZone;
+    globalPresetGenerators.push(...globalPresetZone.generators);
+    globalPresetModulators.push(...globalPresetZone.modulators);
+    let globalPresetKeyRange = globalPresetZone.keyRange;
+    let globalPresetVelRange = globalPresetZone.velRange;
     // for each non-global preset zone
     for (const presetZone of preset.presetZones)
     {
-        if (presetZone.isGlobal)
-        {
-            continue;
-        }
         // use global ranges if not provided
         let presetZoneKeyRange = presetZone.keyRange;
         if (!presetZone.hasKeyRange)
@@ -110,8 +103,8 @@ export function combineZones(preset, globalize = true)
         addUnique(presetGenerators, globalPresetGenerators);
         const presetModulators = [...presetZone.modulators];
         addUniqueMods(presetModulators, globalPresetModulators);
-        
-        const iZones = presetZone.instrument.instrumentZones;
+        const instrument = presetZone.instrument;
+        const iZones = instrument.instrumentZones;
         /**
          * @type {Generator[]}
          */
@@ -120,23 +113,14 @@ export function combineZones(preset, globalize = true)
          * @type {Modulator[]}
          */
         const globalInstModulators = [];
-        let globalInstKeyRange = { min: 0, max: 127 };
-        let globalInstVelRange = { min: 0, max: 127 };
-        const globalInstZone = iZones.find(z => z.isGlobal);
-        if (globalInstZone)
-        {
-            globalInstGenerators.push(...globalInstZone.generators);
-            globalInstModulators.push(...globalInstZone.modulators);
-            globalInstKeyRange = globalInstZone.keyRange;
-            globalInstVelRange = globalInstZone.velRange;
-        }
+        const globalInstZone = instrument.globalZone;
+        globalInstGenerators.push(...globalInstZone.generators);
+        globalInstModulators.push(...globalInstZone.modulators);
+        let globalInstKeyRange = globalInstZone.keyRange;
+        let globalInstVelRange = globalInstZone.velRange;
         // for each non-global instrument zone
         for (const instZone of iZones)
         {
-            if (instZone.isGlobal)
-            {
-                continue;
-            }
             // use global ranges if not provided
             let instZoneKeyRange = instZone.keyRange;
             if (!instZone.hasKeyRange)
@@ -236,20 +220,17 @@ export function combineZones(preset, globalize = true)
             {
                 zone.velRange.min = -1;
             }
-            zone.isGlobal = false;
-            zone.sample = instZone.sample;
+            zone.setSample(instZone.sample);
             zone.generators = finalGenList;
             zone.modulators = finalModList;
             finalZones.push(zone);
         }
     }
-    
+    const globalZone = new BasicGlobalZone();
     if (globalize)
     {
         // create a global zone and add repeating generators to it
         // also modulators
-        const globalZone = new BasicInstrumentZone();
-        globalZone.isGlobal = true;
         // iterate over every type of generator
         for (let checkedType = 0; checkedType < 58; checkedType++)
         {
@@ -356,14 +337,14 @@ export function combineZones(preset, globalize = true)
         }
         
         // globalize only modulators that exist in all zones
-        const firstZone = finalZones.find(z => !z.isGlobal);
+        const firstZone = finalZones[0];
         const modulators = firstZone.modulators.map(m => Modulator.copy(m));
         for (const checkedModulator of modulators)
         {
             let existsForAllZones = true;
             for (const zone of finalZones)
             {
-                if (zone.isGlobal || !existsForAllZones)
+                if (!existsForAllZones)
                 {
                     continue;
                 }
@@ -394,7 +375,9 @@ export function combineZones(preset, globalize = true)
                 }
             }
         }
-        finalZones.splice(0, 0, globalZone);
     }
-    return finalZones;
+    return {
+        zones: finalZones,
+        global: globalZone
+    };
 }

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

@@ -22,20 +22,12 @@ export function writeIns(preset)
         consoleColors.info
     );
     // combine preset and instrument zones into a single instrument zone (region) list
-    const combined = combineZones(preset);
+    const { global, zones } = combineZones(preset);
     
-    const nonGlobalRegionsCount = combined.reduce((sum, z) =>
-    {
-        if (!z.isGlobal)
-        {
-            return sum + 1;
-        }
-        return sum;
-    }, 0);
     
     // insh: instrument header
     const inshData = new IndexedByteArray(12);
-    writeDword(inshData, nonGlobalRegionsCount); // cRegions
+    writeDword(inshData, zones.length); // cRegions
     // bank MSB is in bits 8-14
     let ulBank = (preset.bank & 127) << 8;
     // bit 32 means drums
@@ -52,26 +44,18 @@ export function writeIns(preset)
     );
     
     // write global zone
-    let lar2 = new IndexedByteArray(0);
-    const globalZone = combined.find(z => z.isGlobal === true);
-    if (globalZone)
-    {
-        const art2 = writeArticulator(globalZone);
-        lar2 = writeRIFFOddSize(
-            "lar2",
-            art2,
-            false,
-            true
-        );
-    }
+    const art2 = writeArticulator(global);
+    let lar2 = writeRIFFOddSize(
+        "lar2",
+        art2,
+        false,
+        true
+    );
     
     // write the region list
-    const lrgnData = combineArrays(combined.reduce((arrs, z) =>
+    const lrgnData = combineArrays(zones.reduce((arrs, z) =>
     {
-        if (!z.isGlobal)
-        {
-            arrs.push(writeDLSRegion.apply(this, [z, globalZone]));
-        }
+        arrs.push(writeDLSRegion.apply(this, [z, global]));
         return arrs;
     }, []));
     const lrgn = writeRIFFOddSize(

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

@@ -1,14 +1,14 @@
 import { midiControllers } from "../../../midi/midi_message.js";
 import { DLSSources } from "../../dls/dls_sources.js";
 import { modulatorCurveTypes, modulatorSources } from "../modulator.js";
-import { generatorTypes } from "../generator.js";
 import { DLSDestinations } from "../../dls/dls_destinations.js";
 import { Articulator } from "./articulator.js";
 import { SpessaSynthWarn } from "../../../utils/loggin.js";
+import { generatorTypes } from "../generator_types.js";
 
 
 /**
- * @param cc {boolean}
+ * @param cc {0|1}
  * @param index {number}
  * @returns {number|undefined}
  */

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

@@ -1,13 +1,13 @@
 import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
 import { writeDword, writeWord } from "../../../utils/byte_functions/little_endian.js";
-import { generatorTypes } from "../generator.js";
 import { writeRIFFOddSize } from "../riff_chunk.js";
 import { writeWavesample } from "./wsmp.js";
 import { writeArticulator } from "./art2.js";
+import { generatorTypes } from "../generator_types.js";
 
 /**
  * @param zone {BasicInstrumentZone}
- * @param globalZone {BasicInstrumentZone}
+ * @param globalZone {BasicGlobalZone}
  * @this {BasicSoundBank}
  * @returns {IndexedByteArray}
  */