spessasynth_core 4.0.7 → 4.0.9

package/dist/index.js

@@ -1706,14 +1706,6 @@ var interpolationTypes = {
   nearestNeighbor: 1,
   hermite: 2
 };
-var synthDisplayTypes = {
-  // This message type is used to display text on the SoundCanvas display.
-  soundCanvasText: 0,
-  // This message type is used to display text on a Yamaha XG synthesizer.
-  yamahaXGText: 1,
-  // This message type is used to display a dot matrix display (pixelated graphics) on a SoundCanvas synthesizer.
-  soundCanvasDotMatrix: 2
-};
 var dataEntryStates = {
   Idle: 0,
   RPCoarse: 1,
@@ -6966,10 +6958,9 @@ var Generator = class {
       }
     }
   }
-  write(genData, indexes) {
+  write(genData) {
     writeWord(genData, this.generatorType);
     writeWord(genData, this.generatorValue);
-    indexes.gen++;
   }
   toString() {
     return `${Object.keys(generatorTypes).find((k) => generatorTypes[k] === this.generatorType)}: ${this.generatorValue}`;
@@ -7114,30 +7105,6 @@ var BasicZone = class {
     this.velRange = { ...zone.velRange };
     this.keyRange = { ...zone.keyRange };
   }
-  getGenCount() {
-    let count = this.generators.filter(
-      (g) => g.generatorType !== generatorTypes.sampleID && g.generatorType !== generatorTypes.instrument && g.generatorType !== generatorTypes.keyRange && g.generatorType !== generatorTypes.velRange
-    ).length;
-    if (this.hasVelRange) {
-      count++;
-    }
-    if (this.hasKeyRange) {
-      count++;
-    }
-    return count;
-  }
-  write(genData, modData, bagData, indexes, bank) {
-    const generatorIndex = indexes.gen;
-    const modulatorIndex = indexes.mod;
-    writeWord(bagData.pdta, generatorIndex & 65535);
-    writeWord(bagData.pdta, modulatorIndex & 65535);
-    writeWord(bagData.xdta, generatorIndex >> 16);
-    writeWord(bagData.xdta, modulatorIndex >> 16);
-    indexes.bag++;
-    const gens = this.getWriteGenerators(bank);
-    gens.forEach((g) => g.write(genData, indexes));
-    this.modulators.forEach((m) => m.write(modData, indexes));
-  }
   /**
    * Filters the generators and prepends the range generators.
    */
@@ -7214,9 +7181,6 @@ var BasicPresetZone = class extends BasicZone {
     this._instrument = instrument;
     this._instrument.linkTo(this.parentPreset);
   }
-  getGenCount() {
-    return super.getGenCount() + 1;
-  }
   getWriteGenerators(bank) {
     const gens = super.getWriteGenerators(bank);
     if (!bank) {
@@ -7281,9 +7245,6 @@ var BasicInstrumentZone = class extends BasicZone {
     this._sample = sample;
     sample.linkTo(this.parentInstrument);
   }
-  getGenCount() {
-    return super.getGenCount() + 1;
-  }
   getWriteGenerators(bank) {
     const gens = super.getWriteGenerators(bank);
     const sampleID = bank.samples.indexOf(this.sample);
@@ -7536,31 +7497,12 @@ var BasicInstrument = class {
       }
     }
   }
-  getSize() {
-    const modCount = this.zones.reduce(
-      (count, zone) => zone.modulators.length + count,
-      0
-    ) + this.globalZone.modulators.length;
-    const genCount = this.zones.reduce((count, zone) => zone.getGenCount() + count, 0) + this.globalZone.getGenCount();
-    return {
-      mod: modCount * MOD_BYTE_SIZE,
-      bag: (this.zones.length + 1) * BAG_BYTE_SIZE,
-      // global zone
-      gen: genCount * GEN_BYTE_SIZE,
-      hdr: INST_BYTE_SIZE
-    };
-  }
-  write(genData, modData, bagData, instData, indexes, bank) {
+  write(instData, index) {
     SpessaSynthInfo(`%cWriting ${this.name}...`, consoleColors.info);
     writeBinaryStringIndexed(instData.pdta, this.name.substring(0, 20), 20);
     writeBinaryStringIndexed(instData.xdta, this.name.substring(20), 20);
-    writeWord(instData.pdta, indexes.hdr & 65535);
-    writeWord(instData.xdta, indexes.hdr >>> 16);
-    indexes.hdr += this.zones.length + 1;
-    this.globalZone.write(genData, modData, bagData, indexes, bank);
-    this.zones.forEach(
-      (z) => z.write(genData, modData, bagData, indexes, bank)
-    );
+    writeWord(instData.pdta, index & 65535);
+    writeWord(instData.xdta, index >>> 16);
   }
 };
 
@@ -7665,20 +7607,6 @@ var BasicPreset = class {
   matches(preset) {
     return MIDIPatchTools.matches(this, preset);
   }
-  getSize() {
-    const modCount = this.zones.reduce(
-      (count, zone) => zone.modulators.length + count,
-      0
-    ) + this.globalZone.modulators.length;
-    const genCount = this.zones.reduce((count, zone) => zone.getGenCount() + count, 0) + this.globalZone.getGenCount();
-    return {
-      mod: modCount * MOD_BYTE_SIZE,
-      bag: (this.zones.length + 1) * BAG_BYTE_SIZE,
-      // global zone
-      gen: genCount * GEN_BYTE_SIZE,
-      hdr: PHDR_BYTE_SIZE
-    };
-  }
   /**
    * Returns the synthesis data from this preset
    * @param midiNote the MIDI note number
@@ -7936,7 +7864,13 @@ var BasicPreset = class {
     }
     return outputInstrument;
   }
-  write(genData, modData, bagData, phdrData, indexes, bank) {
+  // noinspection JSUnusedGlobalSymbols
+  /**
+   * Writes the SF2 header
+   * @param phdrData
+   * @param index
+   */
+  write(phdrData, index) {
     SpessaSynthInfo(`%cWriting ${this.name}...`, consoleColors.info);
     writeBinaryStringIndexed(phdrData.pdta, this.name.substring(0, 20), 20);
     writeBinaryStringIndexed(phdrData.xdta, this.name.substring(20), 20);
@@ -7949,17 +7883,12 @@ var BasicPreset = class {
     }
     writeWord(phdrData.pdta, wBank);
     phdrData.xdta.currentIndex += 4;
-    writeWord(phdrData.pdta, indexes.hdr & 65535);
-    writeWord(phdrData.xdta, indexes.hdr >> 16);
+    writeWord(phdrData.pdta, index & 65535);
+    writeWord(phdrData.xdta, index >> 16);
     writeDword(phdrData.pdta, this.library);
     writeDword(phdrData.pdta, this.genre);
     writeDword(phdrData.pdta, this.morphology);
     phdrData.xdta.currentIndex += 12;
-    indexes.hdr += this.zones.length + 1;
-    this.globalZone.write(genData, modData, bagData, indexes, bank);
-    this.zones.forEach(
-      (z) => z.write(genData, modData, bagData, indexes, bank)
-    );
   }
 };
 
@@ -8971,7 +8900,7 @@ function getTuning(byte1, byte2, byte3) {
   return { midiNote, centTuning: fraction * 61e-4 };
 }
 function systemExclusiveInternal(syx, channelOffset = 0) {
-  const type = syx[0];
+  const manufacturer = syx[0];
   if (this.privateProps.masterParameters.deviceID !== ALL_CHANNELS_OR_DIFFERENT_ACTION && syx[1] !== 127) {
     if (this.privateProps.masterParameters.deviceID !== syx[1]) {
       return;
@@ -8988,16 +8917,7 @@ function systemExclusiveInternal(syx, channelOffset = 0) {
       consoleColors.value
     );
   }
-  function notRecognized() {
-    SpessaSynthInfo(
-      `%cUnrecognized Roland %cGS %cSysEx: %c${arrayToHexString(syx)}`,
-      consoleColors.warn,
-      consoleColors.recognized,
-      consoleColors.warn,
-      consoleColors.unrecognized
-    );
-  }
-  switch (type) {
+  switch (manufacturer) {
     default:
       SpessaSynthInfo(
         `%cUnrecognized SysEx: %c${arrayToHexString(syx)}`,
@@ -9005,8 +8925,9 @@ function systemExclusiveInternal(syx, channelOffset = 0) {
         consoleColors.unrecognized
       );
       break;
-    // Non realtime
+    // Non realtime GM
     case 126:
+    // Realtime GM
     case 127:
       switch (syx[2]) {
         case 4: {
@@ -9204,501 +9125,514 @@ function systemExclusiveInternal(syx, channelOffset = 0) {
     // http://www.bandtrax.com.au/sysex.htm
     // https://cdn.roland.com/assets/media/pdf/AT-20R_30R_MI.pdf
     case 65:
-      if (syx[2] === 66 && syx[3] === 18) {
-        const messageValue = syx[7];
-        if (syx[4] === 64 || syx[4] === 0 && syx[6] === 127) {
-          if ((syx[5] & 16) > 0) {
-            const channel = [
-              9,
-              0,
-              1,
-              2,
-              3,
-              4,
-              5,
-              6,
-              7,
-              8,
-              10,
-              11,
-              12,
-              13,
-              14,
-              15
-            ][syx[5] & 15] + channelOffset;
-            const channelObject = this.midiChannels[channel];
-            switch (syx[6]) {
-              default:
-                notRecognized();
-                break;
-              case 21: {
-                const isDrums = messageValue > 0 && syx[5] >> 4 > 0;
-                channelObject.setGSDrums(isDrums);
-                SpessaSynthInfo(
-                  `%cChannel %c${channel}%c ${isDrums ? "is now a drum channel" : "now isn't a drum channel"}%c via: %c${arrayToHexString(syx)}`,
-                  consoleColors.info,
-                  consoleColors.value,
-                  consoleColors.recognized,
-                  consoleColors.info,
-                  consoleColors.value
-                );
-                return;
-              }
-              case 22: {
-                const keyShift = messageValue - 64;
-                channelObject.setCustomController(
-                  customControllers.channelKeyShift,
-                  keyShift
-                );
-                niceLogging(
-                  channel,
-                  keyShift,
-                  "key shift",
-                  "keys"
-                );
-                return;
-              }
-              // Pan position
-              case 28: {
-                const panPosition = messageValue;
-                if (panPosition === 0) {
-                  channelObject.randomPan = true;
-                  SpessaSynthInfo(
-                    `%cRandom pan is set to %cON%c for %c${channel}`,
-                    consoleColors.info,
-                    consoleColors.recognized,
-                    consoleColors.info,
-                    consoleColors.value
-                  );
-                } else {
-                  channelObject.randomPan = false;
-                  channelObject.controllerChange(
-                    midiControllers.pan,
-                    panPosition
-                  );
-                }
-                break;
-              }
-              // Chorus send
-              case 33:
-                channelObject.controllerChange(
-                  midiControllers.chorusDepth,
-                  messageValue
-                );
-                break;
-              // Reverb send
-              case 34:
-                channelObject.controllerChange(
-                  midiControllers.reverbDepth,
-                  messageValue
-                );
-                break;
-              case 64:
-              case 65:
-              case 66:
-              case 67:
-              case 68:
-              case 69:
-              case 70:
-              case 71:
-              case 72:
-              case 73:
-              case 74:
-              case 75: {
-                const tuningBytes = syx.length - 9;
-                const newTuning = new Int8Array(12);
-                for (let i = 0; i < tuningBytes; i++) {
-                  newTuning[i] = syx[i + 7] - 64;
-                }
-                channelObject.setOctaveTuning(newTuning);
-                const cents = messageValue - 64;
-                niceLogging(
-                  channel,
-                  newTuning.join(" "),
-                  "octave scale tuning",
-                  "cents"
-                );
-                channelObject.setTuning(cents);
-                break;
-              }
-            }
-            return;
-          } else if ((syx[5] & 32) > 0) {
-            const channel = [
-              9,
-              0,
-              1,
-              2,
-              3,
-              4,
-              5,
-              6,
-              7,
-              8,
-              10,
-              11,
-              12,
-              13,
-              14,
-              15
-            ][syx[5] & 15] + channelOffset;
-            const channelObject = this.midiChannels[channel];
-            const centeredValue = messageValue - 64;
-            const normalizedValue = centeredValue / 64;
-            const normalizedNotCentered = messageValue / 128;
-            const setupReceivers = (source, sourceName, bipolar = false) => {
-              switch (syx[6] & 15) {
-                case 0:
-                  if (source === NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel) {
-                    channelObject.controllerChange(
-                      midiControllers.registeredParameterMSB,
-                      0
+      if (syx[3] === 18) {
+        let notRecognized2 = function() {
+          SpessaSynthInfo(
+            `%cUnrecognized Roland %cGS %cSysEx: %c${arrayToHexString(syx)}`,
+            consoleColors.warn,
+            consoleColors.recognized,
+            consoleColors.warn,
+            consoleColors.unrecognized
+          );
+        };
+        var notRecognized = notRecognized2;
+        switch (syx[2]) {
+          case 66: {
+            const messageValue = syx[7];
+            if (syx[4] === 64 || syx[4] === 0 && syx[6] === 127) {
+              if ((syx[5] & 16) > 0) {
+                const channel = [
+                  9,
+                  0,
+                  1,
+                  2,
+                  3,
+                  4,
+                  5,
+                  6,
+                  7,
+                  8,
+                  10,
+                  11,
+                  12,
+                  13,
+                  14,
+                  15
+                ][syx[5] & 15] + channelOffset;
+                const channelObject = this.midiChannels[channel];
+                switch (syx[6]) {
+                  default:
+                    notRecognized2();
+                    break;
+                  case 21: {
+                    const isDrums = messageValue > 0 && syx[5] >> 4 > 0;
+                    channelObject.setGSDrums(isDrums);
+                    SpessaSynthInfo(
+                      `%cChannel %c${channel}%c ${isDrums ? "is now a drum channel" : "now isn't a drum channel"}%c via: %c${arrayToHexString(syx)}`,
+                      consoleColors.info,
+                      consoleColors.value,
+                      consoleColors.recognized,
+                      consoleColors.info,
+                      consoleColors.value
+                    );
+                    return;
+                  }
+                  case 22: {
+                    const keyShift = messageValue - 64;
+                    channelObject.setCustomController(
+                      customControllers.channelKeyShift,
+                      keyShift
+                    );
+                    niceLogging(
+                      channel,
+                      keyShift,
+                      "key shift",
+                      "keys"
                     );
+                    return;
+                  }
+                  // Pan position
+                  case 28: {
+                    const panPosition = messageValue;
+                    if (panPosition === 0) {
+                      channelObject.randomPan = true;
+                      SpessaSynthInfo(
+                        `%cRandom pan is set to %cON%c for %c${channel}`,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.value
+                      );
+                    } else {
+                      channelObject.randomPan = false;
+                      channelObject.controllerChange(
+                        midiControllers.pan,
+                        panPosition
+                      );
+                    }
+                    break;
+                  }
+                  // Chorus send
+                  case 33:
                     channelObject.controllerChange(
-                      midiControllers.registeredParameterLSB,
-                      0
+                      midiControllers.chorusDepth,
+                      messageValue
                     );
+                    break;
+                  // Reverb send
+                  case 34:
                     channelObject.controllerChange(
-                      midiControllers.dataEntryMSB,
-                      Math.floor(centeredValue)
+                      midiControllers.reverbDepth,
+                      messageValue
                     );
-                  } else {
-                    channelObject.sysExModulators.setModulator(
-                      source,
-                      generatorTypes.fineTune,
-                      centeredValue * 100,
-                      bipolar
+                    break;
+                  case 64:
+                  case 65:
+                  case 66:
+                  case 67:
+                  case 68:
+                  case 69:
+                  case 70:
+                  case 71:
+                  case 72:
+                  case 73:
+                  case 74:
+                  case 75: {
+                    const tuningBytes = syx.length - 9;
+                    const newTuning = new Int8Array(12);
+                    for (let i = 0; i < tuningBytes; i++) {
+                      newTuning[i] = syx[i + 7] - 64;
+                    }
+                    channelObject.setOctaveTuning(
+                      newTuning
                     );
+                    const cents = messageValue - 64;
                     niceLogging(
                       channel,
-                      centeredValue,
-                      `${sourceName} pitch control`,
-                      "semitones"
+                      newTuning.join(" "),
+                      "octave scale tuning",
+                      "cents"
                     );
+                    channelObject.setTuning(cents);
+                    break;
                   }
-                  break;
-                case 1:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.initialFilterFc,
-                    normalizedValue * 9600,
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedValue * 9600,
-                    `${sourceName} pitch control`,
-                    "cents"
-                  );
-                  break;
-                case 2:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.initialAttenuation,
-                    normalizedValue * 960,
-                    // Spec says "100%" so 960cB in sf2
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedValue * 960,
-                    `${sourceName} amplitude`,
-                    "cB"
-                  );
-                  break;
-                // Rate control is ignored as it is in hertz
-                case 4:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.vibLfoToPitch,
-                    normalizedNotCentered * 600,
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedNotCentered * 600,
-                    `${sourceName} LFO1 pitch depth`,
-                    "cents"
-                  );
-                  break;
-                case 5:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.vibLfoToFilterFc,
-                    normalizedNotCentered * 2400,
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedNotCentered * 2400,
-                    `${sourceName} LFO1 filter depth`,
-                    "cents"
-                  );
-                  break;
-                case 6:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.vibLfoToVolume,
-                    normalizedValue * 960,
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedValue * 960,
-                    `${sourceName} LFO1 amplitude depth`,
-                    "cB"
-                  );
-                  break;
-                // Rate control is ignored as it is in hertz
-                case 8:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.modLfoToPitch,
-                    normalizedNotCentered * 600,
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedNotCentered * 600,
-                    `${sourceName} LFO2 pitch depth`,
-                    "cents"
-                  );
-                  break;
-                case 9:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.modLfoToFilterFc,
-                    normalizedNotCentered * 2400,
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedNotCentered * 2400,
-                    `${sourceName} LFO2 filter depth`,
-                    "cents"
-                  );
-                  break;
-                case 10:
-                  channelObject.sysExModulators.setModulator(
-                    source,
-                    generatorTypes.modLfoToVolume,
-                    normalizedValue * 960,
-                    bipolar
-                  );
-                  niceLogging(
-                    channel,
-                    normalizedValue * 960,
-                    `${sourceName} LFO2 amplitude depth`,
-                    "cB"
-                  );
-                  break;
+                }
+                return;
+              } else if ((syx[5] & 32) > 0) {
+                const channel = [
+                  9,
+                  0,
+                  1,
+                  2,
+                  3,
+                  4,
+                  5,
+                  6,
+                  7,
+                  8,
+                  10,
+                  11,
+                  12,
+                  13,
+                  14,
+                  15
+                ][syx[5] & 15] + channelOffset;
+                const channelObject = this.midiChannels[channel];
+                const centeredValue = messageValue - 64;
+                const normalizedValue = centeredValue / 64;
+                const normalizedNotCentered = messageValue / 128;
+                const setupReceivers = (source, sourceName, bipolar = false) => {
+                  switch (syx[6] & 15) {
+                    case 0:
+                      if (source === NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel) {
+                        channelObject.controllerChange(
+                          midiControllers.registeredParameterMSB,
+                          0
+                        );
+                        channelObject.controllerChange(
+                          midiControllers.registeredParameterLSB,
+                          0
+                        );
+                        channelObject.controllerChange(
+                          midiControllers.dataEntryMSB,
+                          Math.floor(centeredValue)
+                        );
+                      } else {
+                        channelObject.sysExModulators.setModulator(
+                          source,
+                          generatorTypes.fineTune,
+                          centeredValue * 100,
+                          bipolar
+                        );
+                        niceLogging(
+                          channel,
+                          centeredValue,
+                          `${sourceName} pitch control`,
+                          "semitones"
+                        );
+                      }
+                      break;
+                    case 1:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.initialFilterFc,
+                        normalizedValue * 9600,
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedValue * 9600,
+                        `${sourceName} pitch control`,
+                        "cents"
+                      );
+                      break;
+                    case 2:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.initialAttenuation,
+                        normalizedValue * 960,
+                        // Spec says "100%" so 960cB in sf2
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedValue * 960,
+                        `${sourceName} amplitude`,
+                        "cB"
+                      );
+                      break;
+                    // Rate control is ignored as it is in hertz
+                    case 4:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.vibLfoToPitch,
+                        normalizedNotCentered * 600,
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedNotCentered * 600,
+                        `${sourceName} LFO1 pitch depth`,
+                        "cents"
+                      );
+                      break;
+                    case 5:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.vibLfoToFilterFc,
+                        normalizedNotCentered * 2400,
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedNotCentered * 2400,
+                        `${sourceName} LFO1 filter depth`,
+                        "cents"
+                      );
+                      break;
+                    case 6:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.vibLfoToVolume,
+                        normalizedValue * 960,
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedValue * 960,
+                        `${sourceName} LFO1 amplitude depth`,
+                        "cB"
+                      );
+                      break;
+                    // Rate control is ignored as it is in hertz
+                    case 8:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.modLfoToPitch,
+                        normalizedNotCentered * 600,
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedNotCentered * 600,
+                        `${sourceName} LFO2 pitch depth`,
+                        "cents"
+                      );
+                      break;
+                    case 9:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.modLfoToFilterFc,
+                        normalizedNotCentered * 2400,
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedNotCentered * 2400,
+                        `${sourceName} LFO2 filter depth`,
+                        "cents"
+                      );
+                      break;
+                    case 10:
+                      channelObject.sysExModulators.setModulator(
+                        source,
+                        generatorTypes.modLfoToVolume,
+                        normalizedValue * 960,
+                        bipolar
+                      );
+                      niceLogging(
+                        channel,
+                        normalizedValue * 960,
+                        `${sourceName} LFO2 amplitude depth`,
+                        "cB"
+                      );
+                      break;
+                  }
+                };
+                switch (syx[6] & 240) {
+                  default:
+                    notRecognized2();
+                    break;
+                  case 0:
+                    setupReceivers(
+                      midiControllers.modulationWheel,
+                      "mod wheel"
+                    );
+                    break;
+                  case 16:
+                    setupReceivers(
+                      NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel,
+                      "pitch wheel",
+                      true
+                    );
+                    break;
+                  case 32:
+                    setupReceivers(
+                      NON_CC_INDEX_OFFSET + modulatorSources.channelPressure,
+                      "channel pressure"
+                    );
+                    break;
+                  case 48:
+                    setupReceivers(
+                      NON_CC_INDEX_OFFSET + modulatorSources.polyPressure,
+                      "poly pressure"
+                    );
+                    break;
+                }
+                return;
+              } else if (syx[5] === 0) {
+                switch (syx[6]) {
+                  default:
+                    notRecognized2();
+                    break;
+                  case 127:
+                    if (messageValue === 0) {
+                      SpessaSynthInfo(
+                        "%cGS Reset received!",
+                        consoleColors.info
+                      );
+                      this.resetAllControllers(false);
+                      this.setMasterParameter(
+                        "midiSystem",
+                        "gs"
+                      );
+                    } else if (messageValue === 127) {
+                      SpessaSynthInfo(
+                        "%cGS system off, switching to GM",
+                        consoleColors.info
+                      );
+                      this.resetAllControllers(false);
+                      this.setMasterParameter(
+                        "midiSystem",
+                        "gm"
+                      );
+                    }
+                    break;
+                  case 6:
+                    SpessaSynthInfo(
+                      `%cRoland GS Master Pan set to: %c${messageValue}%c with: %c${arrayToHexString(
+                        syx
+                      )}`,
+                      consoleColors.info,
+                      consoleColors.value,
+                      consoleColors.info,
+                      consoleColors.value
+                    );
+                    this.setMasterParameter(
+                      "masterPan",
+                      (messageValue - 64) / 64
+                    );
+                    break;
+                  case 4:
+                    SpessaSynthInfo(
+                      `%cRoland GS Master Volume set to: %c${messageValue}%c with: %c${arrayToHexString(
+                        syx
+                      )}`,
+                      consoleColors.info,
+                      consoleColors.value,
+                      consoleColors.info,
+                      consoleColors.value
+                    );
+                    this.setMIDIVolume(messageValue / 127);
+                    break;
+                  case 5: {
+                    const transpose = messageValue - 64;
+                    SpessaSynthInfo(
+                      `%cRoland GS Master Key-Shift set to: %c${transpose}%c with: %c${arrayToHexString(
+                        syx
+                      )}`,
+                      consoleColors.info,
+                      consoleColors.value,
+                      consoleColors.info,
+                      consoleColors.value
+                    );
+                    this.setMasterTuning(transpose * 100);
+                    break;
+                  }
+                }
+                return;
+              } else if (syx[5] === 1) {
+                switch (syx[6]) {
+                  default:
+                    notRecognized2();
+                    break;
+                  case 0: {
+                    const patchName = readBinaryString(
+                      syx,
+                      16,
+                      7
+                    );
+                    SpessaSynthInfo(
+                      `%cGS Patch name: %c${patchName}`,
+                      consoleColors.info,
+                      consoleColors.value
+                    );
+                    break;
+                  }
+                  case 51:
+                    SpessaSynthInfo(
+                      `%cGS Reverb level: %c${messageValue}`,
+                      consoleColors.info,
+                      consoleColors.value
+                    );
+                    this.privateProps.reverbSend = messageValue / 64;
+                    break;
+                  // Unsupported reverb params
+                  case 48:
+                  case 49:
+                  case 50:
+                  case 52:
+                  case 53:
+                  case 55:
+                    SpessaSynthInfo(
+                      `%cUnsupported GS Reverb Parameter: %c${syx[6].toString(16)}`,
+                      consoleColors.warn,
+                      consoleColors.unrecognized
+                    );
+                    break;
+                  case 58:
+                    SpessaSynthInfo(
+                      `%cGS Chorus level: %c${messageValue}`,
+                      consoleColors.info,
+                      consoleColors.value
+                    );
+                    this.privateProps.chorusSend = messageValue / 64;
+                    break;
+                  // Unsupported chorus params
+                  case 56:
+                  case 57:
+                  case 59:
+                  case 60:
+                  case 61:
+                  case 62:
+                  case 63:
+                  case 64:
+                    SpessaSynthInfo(
+                      `%cUnsupported GS Chorus Parameter: %c${syx[6].toString(16)}`,
+                      consoleColors.warn,
+                      consoleColors.unrecognized
+                    );
+                    break;
+                }
               }
-            };
-            switch (syx[6] & 240) {
-              default:
-                notRecognized();
-                break;
-              case 0:
-                setupReceivers(
-                  midiControllers.modulationWheel,
-                  "mod wheel"
-                );
-                break;
-              case 16:
-                setupReceivers(
-                  NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel,
-                  "pitch wheel",
-                  true
-                );
-                break;
-              case 32:
-                setupReceivers(
-                  NON_CC_INDEX_OFFSET + modulatorSources.channelPressure,
-                  "channel pressure"
-                );
-                break;
-              case 48:
-                setupReceivers(
-                  NON_CC_INDEX_OFFSET + modulatorSources.polyPressure,
-                  "poly pressure"
-                );
-                break;
+            } else {
+              notRecognized2();
             }
             return;
-          } else if (syx[5] === 0) {
-            switch (syx[6]) {
-              default:
-                notRecognized();
-                break;
-              case 127:
-                if (messageValue === 0) {
-                  SpessaSynthInfo(
-                    "%cGS Reset received!",
-                    consoleColors.info
-                  );
-                  this.resetAllControllers(false);
-                  this.setMasterParameter("midiSystem", "gs");
-                } else if (messageValue === 127) {
-                  SpessaSynthInfo(
-                    "%cGS system off, switching to GM2",
-                    consoleColors.info
-                  );
-                  this.resetAllControllers(false);
-                  this.setMasterParameter(
-                    "midiSystem",
-                    "gm2"
-                  );
-                }
-                break;
-              case 6:
-                SpessaSynthInfo(
-                  `%cRoland GS Master Pan set to: %c${messageValue}%c with: %c${arrayToHexString(
-                    syx
-                  )}`,
-                  consoleColors.info,
-                  consoleColors.value,
-                  consoleColors.info,
-                  consoleColors.value
-                );
-                this.setMasterParameter(
-                  "masterPan",
-                  (messageValue - 64) / 64
-                );
-                break;
-              case 4:
-                SpessaSynthInfo(
-                  `%cRoland GS Master Volume set to: %c${messageValue}%c with: %c${arrayToHexString(
-                    syx
-                  )}`,
-                  consoleColors.info,
-                  consoleColors.value,
-                  consoleColors.info,
-                  consoleColors.value
+          }
+          case 69: {
+            if (syx[4] === 16) {
+              if (syx[5] === 0) {
+                this.privateProps.callEvent(
+                  "synthDisplay",
+                  Array.from(syx)
                 );
-                this.setMIDIVolume(messageValue / 127);
-                break;
-              case 5: {
-                const transpose = messageValue - 64;
-                SpessaSynthInfo(
-                  `%cRoland GS Master Key-Shift set to: %c${transpose}%c with: %c${arrayToHexString(
-                    syx
-                  )}`,
-                  consoleColors.info,
-                  consoleColors.value,
-                  consoleColors.info,
-                  consoleColors.value
+              } else if (syx[5] === 1) {
+                this.privateProps.callEvent(
+                  "synthDisplay",
+                  Array.from(syx)
                 );
-                this.setMasterTuning(transpose * 100);
-                break;
+              } else {
+                notRecognized2();
               }
             }
             return;
-          } else if (syx[5] === 1) {
-            switch (syx[6]) {
-              default:
-                notRecognized();
-                break;
-              case 0: {
-                const patchName = readBinaryString(syx, 16, 7);
-                SpessaSynthInfo(
-                  `%cGS Patch name: %c${patchName}`,
-                  consoleColors.info,
-                  consoleColors.value
-                );
-                break;
-              }
-              case 51:
-                SpessaSynthInfo(
-                  `%cGS Reverb level: %c${messageValue}`,
-                  consoleColors.info,
-                  consoleColors.value
-                );
-                this.privateProps.reverbSend = messageValue / 64;
-                break;
-              // Unsupported reverb params
-              case 48:
-              case 49:
-              case 50:
-              case 52:
-              case 53:
-              case 55:
-                SpessaSynthInfo(
-                  `%cUnsupported GS Reverb Parameter: %c${syx[6].toString(16)}`,
-                  consoleColors.warn,
-                  consoleColors.unrecognized
-                );
-                break;
-              case 58:
-                SpessaSynthInfo(
-                  `%cGS Chorus level: %c${messageValue}`,
-                  consoleColors.info,
-                  consoleColors.value
-                );
-                this.privateProps.chorusSend = messageValue / 64;
-                break;
-              // Unsupported chorus params
-              case 56:
-              case 57:
-              case 59:
-              case 60:
-              case 61:
-              case 62:
-              case 63:
-              case 64:
-                SpessaSynthInfo(
-                  `%cUnsupported GS Chorus Parameter: %c${syx[6].toString(16)}`,
-                  consoleColors.warn,
-                  consoleColors.unrecognized
-                );
-                break;
-            }
-          }
-        } else {
-          notRecognized();
-        }
-        return;
-      } else if (syx[2] === 69 && syx[3] === 18) {
-        if (syx[4] === 16 && // Sound Canvas Display
-        syx[6] === 0) {
-          if (syx[5] === 0) {
-            const text = new Uint8Array(
-              syx.slice(7, syx.length - 2)
-            );
-            this.privateProps.callEvent("synthDisplay", {
-              displayData: text,
-              displayType: synthDisplayTypes.soundCanvasText
-            });
-          } else if (syx[5] === 1) {
-            const dotMatrixData = new Uint8Array(
-              syx.slice(7, syx.length - 3)
-            );
-            this.privateProps.callEvent("synthDisplay", {
-              displayData: dotMatrixData,
-              displayType: synthDisplayTypes.soundCanvasDotMatrix
-            });
-            SpessaSynthInfo(
-              `%cRoland SC Display Dot Matrix via: %c${arrayToHexString(
-                syx
-              )}`,
-              consoleColors.info,
-              consoleColors.value
-            );
-          } else {
-            notRecognized();
           }
+          case 22:
+            if (syx[4] === 16) {
+              this.setMIDIVolume(syx[7] / 100);
+              SpessaSynthInfo(
+                `%cRoland Master Volume control set to: %c${syx[7]}%c via: %c${arrayToHexString(
+                  syx
+                )}`,
+                consoleColors.info,
+                consoleColors.value,
+                consoleColors.info,
+                consoleColors.value
+              );
+              return;
+            }
         }
-      } else if (syx[2] === 22 && syx[3] === 18 && syx[4] === 16) {
-        this.setMIDIVolume(syx[7] / 100);
-        SpessaSynthInfo(
-          `%cRoland Master Volume control set to: %c${syx[7]}%c via: %c${arrayToHexString(
-            syx
-          )}`,
-          consoleColors.info,
-          consoleColors.value,
-          consoleColors.info,
-          consoleColors.value
-        );
-        return;
       } else {
         SpessaSynthInfo(
           `%cUnrecognized Roland SysEx: %c${arrayToHexString(syx)}`,
@@ -9835,13 +9769,10 @@ function systemExclusiveInternal(syx, channelOffset = 0) {
           }
         } else if (syx[3] === 6 && // XG System parameter
         syx[4] === 0) {
-          const textData = new Uint8Array(
-            syx.slice(5, syx.length - 1)
+          this.privateProps.callEvent(
+            "synthDisplay",
+            Array.from(syx)
           );
-          this.privateProps.callEvent("synthDisplay", {
-            displayData: textData,
-            displayType: synthDisplayTypes.yamahaXGText
-          });
         } else if (BankSelectHacks.isSystemXG(
           this.privateProps.masterParameters.midiSystem
         )) {
@@ -11506,10 +11437,12 @@ function computeModulators(voice, sourceUsesCC = -1, sourceIndex = 0) {
   if (sourceUsesCC === -1) {
     modulatedGenerators.set(generators);
     modulators.forEach((mod) => {
-      modulatedGenerators[mod.destination] += computeModulator(
-        this.midiControllers,
-        mod,
-        voice
+      modulatedGenerators[mod.destination] = Math.min(
+        32767,
+        Math.max(
+          -32768,
+          modulatedGenerators[mod.destination] + computeModulator(this.midiControllers, mod, voice)
+        )
       );
     });
     for (let gen = 0; gen < modulatedGenerators.length; gen++) {
@@ -11543,17 +11476,17 @@ function computeModulators(voice, sourceUsesCC = -1, sourceIndex = 0) {
     if (mod.primarySource.isCC === sourceCC && mod.primarySource.index === sourceIndex || mod.secondarySource.isCC === sourceCC && mod.secondarySource.index === sourceIndex) {
       const destination = mod.destination;
       if (!computedDestinations.has(destination)) {
-        modulatedGenerators[destination] = generators[destination];
+        let outputValue = generators[destination];
         computeModulator(this.midiControllers, mod, voice);
         modulators.forEach((m) => {
           if (m.destination === destination) {
-            modulatedGenerators[destination] += m.currentValue;
+            outputValue += m.currentValue;
           }
         });
         const limits = generatorLimits[destination];
         modulatedGenerators[destination] = Math.max(
           limits.min,
-          Math.min(modulatedGenerators[destination], limits.max)
+          Math.min(outputValue, limits.max)
         );
         computedDestinations.add(destination);
       }
@@ -12824,62 +12757,76 @@ function writeSF2Elements(bank, isPreset = false) {
   const bagHeader = isPreset ? "pbag" : "ibag";
   const hdrHeader = isPreset ? "phdr" : "inst";
   const hdrByteSize = isPreset ? PHDR_BYTE_SIZE : INST_BYTE_SIZE;
-  const sizes = elements.map(
-    (i) => i instanceof BasicPreset ? i.getSize() : i.getSize()
-  );
-  const genSize = sizes.reduce((l, s) => l + s.gen, 0) + GEN_BYTE_SIZE;
+  let currentGenIndex = 0;
+  const generatorIndexes = new Array();
+  let currentModIndex = 0;
+  const modulatorIndexes = new Array();
+  const generators = new Array();
+  const modulators = new Array();
+  let zoneIndex = 0;
+  const zoneIndexes = new Array();
+  const writeZone = (z) => {
+    generatorIndexes.push(currentGenIndex);
+    const gens = z.getWriteGenerators(bank);
+    currentGenIndex += gens.length;
+    generators.push(...gens);
+    modulatorIndexes.push(currentModIndex);
+    const mods = z.modulators;
+    currentModIndex += mods.length;
+    modulators.push(...mods);
+  };
+  elements.forEach((el) => {
+    zoneIndexes.push(zoneIndex);
+    writeZone(el.globalZone);
+    el.zones.forEach(writeZone);
+    zoneIndex += el.zones.length + 1;
+  });
+  generators.push(new Generator(0, 0, false));
+  modulators.push(new DecodedModulator(0, 0, 0, 0, 0));
+  generatorIndexes.push(currentGenIndex);
+  modulatorIndexes.push(currentModIndex);
+  zoneIndexes.push(zoneIndex);
+  const genSize = generators.length * GEN_BYTE_SIZE;
   const genData = new IndexedByteArray(genSize);
-  const modSize = sizes.reduce((l, s) => l + s.mod, 0) + MOD_BYTE_SIZE;
+  generators.forEach((g) => g.write(genData));
+  const modSize = modulators.length * MOD_BYTE_SIZE;
   const modData = new IndexedByteArray(modSize);
-  const bagSize = sizes.reduce((l, s) => l + s.bag, 0) + BAG_BYTE_SIZE;
+  modulators.forEach((m) => m.write(modData));
+  const bagSize = modulatorIndexes.length * BAG_BYTE_SIZE;
   const bagData = {
     pdta: new IndexedByteArray(bagSize),
     xdta: new IndexedByteArray(bagSize)
   };
-  const hdrSize = sizes.reduce((l, s) => s.hdr + l, 0) + hdrByteSize;
+  modulatorIndexes.forEach((modulatorIndex, i) => {
+    const generatorIndex = generatorIndexes[i];
+    writeWord(bagData.pdta, generatorIndex & 65535);
+    writeWord(bagData.pdta, modulatorIndex & 65535);
+    writeWord(bagData.xdta, generatorIndex >> 16);
+    writeWord(bagData.xdta, modulatorIndex >> 16);
+  });
+  const hdrSize = (elements.length + 1) * hdrByteSize;
   const hdrData = {
     pdta: new IndexedByteArray(hdrSize),
     xdta: new IndexedByteArray(hdrSize)
   };
-  const indexes = {
-    gen: 0,
-    bag: 0,
-    mod: 0,
-    hdr: 0
-  };
-  elements.forEach((element) => {
-    if (element instanceof BasicPreset) {
-      element.write(genData, modData, bagData, hdrData, indexes, bank);
-    } else {
-      element.write(genData, modData, bagData, hdrData, indexes, bank);
-    }
-  });
+  elements.forEach((el, i) => el.write(hdrData, zoneIndexes[i]));
   if (isPreset) {
     writeBinaryStringIndexed(hdrData.pdta, "EOP", 20);
     hdrData.pdta.currentIndex += 4;
-    writeWord(hdrData.pdta, indexes.hdr & 65535);
+    writeWord(hdrData.pdta, zoneIndex & 65535);
     hdrData.pdta.currentIndex += 12;
     writeBinaryStringIndexed(hdrData.xdta, "", 20);
     hdrData.xdta.currentIndex += 4;
-    writeWord(hdrData.xdta, indexes.hdr >> 16);
+    writeWord(hdrData.xdta, zoneIndex >> 16);
     hdrData.xdta.currentIndex += 12;
   } else {
     writeBinaryStringIndexed(hdrData.pdta, "EOI", 20);
+    writeWord(hdrData.pdta, zoneIndex & 65535);
     writeBinaryStringIndexed(hdrData.xdta, "", 20);
-    writeWord(hdrData.pdta, indexes.hdr & 65535);
-    writeWord(hdrData.xdta, indexes.hdr >> 16);
+    writeWord(hdrData.xdta, zoneIndex >> 16);
   }
-  writeWord(bagData.pdta, indexes.gen & 65535);
-  writeWord(bagData.xdta, indexes.gen >> 16);
-  writeWord(bagData.pdta, indexes.mod & 65535);
-  writeWord(bagData.xdta, indexes.mod >> 16);
   return {
-    writeXdta: Math.max(
-      genSize / GEN_BYTE_SIZE,
-      modSize / MOD_BYTE_SIZE,
-      bagSize / BAG_BYTE_SIZE,
-      hdrSize / hdrByteSize
-    ) > 65535,
+    writeXdta: Math.max(currentGenIndex, currentModIndex, zoneIndex) > 65535,
     gen: {
       pdta: writeRIFFChunkRaw(genHeader, genData),
       // Same as pmod, this chunk includes only the terminal generator record to allow reuse of the pdta parser.
@@ -17174,7 +17121,6 @@ export {
   modulatorSources,
   modulatorTransformTypes,
   sampleTypes,
-  setResetValue,
-  synthDisplayTypes
+  setResetValue
 };
 //# sourceMappingURL=index.js.map