spessasynth_core 4.0.15 → 4.0.17

package/dist/index.d.ts

@@ -3743,6 +3743,7 @@ interface SequencerEventData {
     };
     /**
      * Called when the playback stops.
+     * @deprecated use songEnded instead.
      */
     pause: {
         /**
@@ -3750,6 +3751,10 @@ interface SequencerEventData {
          */
         isFinished: boolean;
     };
+    /**
+     * Called when the playback stops.
+     */
+    songEnded: object;
     /**
      * Called when the song changes.
      */
@@ -3817,6 +3822,11 @@ declare class SpessaSynthSequencer {
      * This is used by spessasynth_lib to pass them over to Web MIDI API.
      */
     externalMIDIPlayback: boolean;
+    /**
+     * If the notes that were playing when the sequencer was paused should be re-triggered.
+     * Defaults to true.
+     */
+    retriggerPausedNotes: boolean;
     /**
      * The loop count of the sequencer.
      * If infinite, it will loop forever.
@@ -3828,6 +3838,15 @@ declare class SpessaSynthSequencer {
      * Defaults to true.
      */
     skipToFirstNoteOn: boolean;
+    /**
+     * Indicates if the sequencer has finished playing.
+     */
+    isFinished: boolean;
+    /**
+     * Indicates if the synthesizer should preload the voices for the newly loaded sequence.
+     * Recommended.
+     */
+    preload: boolean;
     /**
      * Called when the sequencer calls an event.
      * @param event The event
@@ -3987,18 +4006,10 @@ declare class SpessaSynthSequencer {
      */
     protected addNewMIDIPort(): void;
     protected sendMIDIMessage(message: number[]): void;
+    protected sendMIDIAllOff(): void;
     protected sendMIDIReset(): void;
     protected loadCurrentSong(): void;
     protected shuffleSongIndexes(): void;
-    protected sendMIDICC(channel: number, type: number, value: number): void;
-    protected sendMIDIProgramChange(channel: number, program: number): void;
-    /**
-     * Sets the pitch of the given channel
-     * @param channel usually 0-15: the channel to change pitch
-     * @param MSB SECOND byte of the MIDI pitchWheel message
-     * @param LSB FIRST byte of the MIDI pitchWheel message
-     */
-    protected sendMIDIPitchWheel(channel: number, MSB: number, LSB: number): void;
     /**
      * Sets the time in MIDI ticks.
      * @param ticks the MIDI ticks to set the time to.
@@ -4009,6 +4020,16 @@ declare class SpessaSynthSequencer {
      * @param time the time in seconds to recalculate the start time for.
      */
     protected recalculateStartTime(time: number): void;
+    protected sendMIDINoteOn(channel: number, midiNote: number, velocity: number): void;
+    protected sendMIDINoteOff(channel: number, midiNote: number): void;
+    protected sendMIDICC(channel: number, type: MIDIController, value: number): void;
+    protected sendMIDIProgramChange(channel: number, program: number): void;
+    /**
+     * Sets the pitch of the given channel
+     * @param channel usually 0-15: the channel to change pitch
+     * @param pitch the 14-bit pitch value
+     */
+    protected sendMIDIPitchWheel(channel: number, pitch: number): void;
 }
 
 declare const DEFAULT_MASTER_PARAMETERS: MasterParameterType;

package/dist/index.js

@@ -3942,10 +3942,12 @@ function loadNewSequenceInternal(parsedMidi) {
   if (parsedMidi.duration === 0) {
     SpessaSynthWarn("This MIDI file has a duration of exactly 0 seconds.");
     this.pausedTime = 0;
+    this.isFinished = true;
     return;
   }
   this.oneTickToSeconds = 60 / (120 * parsedMidi.timeDivision);
   this._midiData = parsedMidi;
+  this.isFinished = false;
   this.synth.clearEmbeddedBank();
   if (this._midiData.embeddedSoundBank !== void 0) {
     SpessaSynthInfo(
@@ -3957,23 +3959,33 @@ function loadNewSequenceInternal(parsedMidi) {
       this._midiData.bankOffset
     );
   }
-  SpessaSynthGroupCollapsed("%cPreloading samples...", consoleColors.info);
-  const used = this._midiData.getUsedProgramsAndKeys(
-    this.synth.soundBankManager
-  );
-  used.forEach((combos, preset) => {
-    SpessaSynthInfo(
-      `%cPreloading used samples on %c${preset.name}%c...`,
-      consoleColors.info,
-      consoleColors.recognized,
+  if (this.preload) {
+    SpessaSynthGroupCollapsed(
+      "%cPreloading samples...",
       consoleColors.info
     );
-    for (const combo of combos) {
-      const [midiNote, velocity] = combo.split("-").map(Number);
-      this.synth.getVoicesForPreset(preset, midiNote, velocity, midiNote);
-    }
-  });
-  SpessaSynthGroupEnd();
+    const used = this._midiData.getUsedProgramsAndKeys(
+      this.synth.soundBankManager
+    );
+    used.forEach((combos, preset) => {
+      SpessaSynthInfo(
+        `%cPreloading used samples on %c${preset.name}%c...`,
+        consoleColors.info,
+        consoleColors.recognized,
+        consoleColors.info
+      );
+      for (const combo of combos) {
+        const [midiNote, velocity] = combo.split("-").map(Number);
+        this.synth.getVoicesForPreset(
+          preset,
+          midiNote,
+          velocity,
+          midiNote
+        );
+      }
+    });
+    SpessaSynthGroupEnd();
+  }
   this.currentMIDIPorts = this._midiData.tracks.map((t) => t.port);
   this.midiPortChannelOffset = 0;
   this.midiPortChannelOffsets = {};
@@ -4722,12 +4734,7 @@ function setTimeToInternal(time, ticks = void 0) {
     return false;
   }
   this.oneTickToSeconds = 60 / (120 * this._midiData.timeDivision);
-  if (this.externalMIDIPlayback) {
-    this.sendMIDIReset();
-  } else {
-    this.synth.resetAllControllers();
-    this.synth.stopAllChannels(false);
-  }
+  this.sendMIDIReset();
   this.playedTime = 0;
   this.eventIndexes = Array(this._midiData.tracks.length).fill(0);
   const channelsToSave = this.synth.midiChannels.length;
@@ -4811,15 +4818,7 @@ function setTimeToInternal(time, ticks = void 0) {
           } else if (controllerNumber === midiControllers.resetAllControllers) {
             resetAllControllers(channel);
           }
-          if (this.externalMIDIPlayback) {
-            this.sendMIDICC(channel, controllerNumber, ccV);
-          } else {
-            this.synth.controllerChange(
-              channel,
-              controllerNumber,
-              ccV
-            );
-          }
+          this.sendMIDICC(channel, controllerNumber, ccV);
         } else {
           savedControllers[channel] ??= Array.from(
             defaultControllerArray
@@ -4847,70 +4846,28 @@ function setTimeToInternal(time, ticks = void 0) {
     }
     this.playedTime += this.oneTickToSeconds * (nextEvent.ticks - event.ticks);
   }
-  if (this.externalMIDIPlayback) {
-    for (let channelNumber = 0; channelNumber < channelsToSave; channelNumber++) {
-      if (pitchWheels[channelNumber] !== void 0) {
-        this.sendMIDIPitchWheel(
-          channelNumber,
-          pitchWheels[channelNumber] >> 7,
-          pitchWheels[channelNumber] & 127
-        );
-      }
-      if (savedControllers[channelNumber] !== void 0) {
-        savedControllers[channelNumber].forEach((value, index) => {
-          if (value !== defaultControllerArray[index] && !isCCNonSkippable(index)) {
-            this.sendMIDICC(channelNumber, index, value);
-          }
-        });
-      }
-      if (programs[channelNumber].program >= 0 && programs[channelNumber].actualBank >= 0) {
-        const bank = programs[channelNumber].actualBank;
+  for (let channel = 0; channel < channelsToSave; channel++) {
+    if (pitchWheels[channel] !== void 0) {
+      this.sendMIDIPitchWheel(channel, pitchWheels[channel]);
+    }
+    if (savedControllers[channel] !== void 0) {
+      savedControllers[channel].forEach((value, index) => {
+        if (value !== defaultControllerArray[index] && !isCCNonSkippable(index)) {
+          this.sendMIDICC(channel, index, value);
+        }
+      });
+    }
+    if (programs[channel].actualBank >= 0) {
+      const p = programs[channel];
+      if (p.program !== -1) {
         this.sendMIDICC(
-          channelNumber,
+          channel,
           midiControllers.bankSelect,
-          bank
-        );
-        this.sendMIDIProgramChange(
-          channelNumber,
-          programs[channelNumber].program
-        );
-      }
-    }
-  } else {
-    for (let channelNumber = 0; channelNumber < channelsToSave; channelNumber++) {
-      if (pitchWheels[channelNumber] !== void 0) {
-        this.synth.pitchWheel(
-          channelNumber,
-          pitchWheels[channelNumber]
+          p.actualBank
         );
-      }
-      if (savedControllers[channelNumber] !== void 0) {
-        savedControllers[channelNumber].forEach((value, index) => {
-          if (value !== defaultControllerArray[index] && !isCCNonSkippable(index)) {
-            this.synth.controllerChange(
-              channelNumber,
-              index,
-              value
-            );
-          }
-        });
-      }
-      if (programs[channelNumber].actualBank >= 0) {
-        const p = programs[channelNumber];
-        if (p.program !== -1) {
-          this.synth.controllerChange(
-            channelNumber,
-            midiControllers.bankSelect,
-            p.actualBank
-          );
-          this.synth.programChange(channelNumber, p.program);
-        } else {
-          this.synth.controllerChange(
-            channelNumber,
-            midiControllers.bankSelect,
-            p.bank
-          );
-        }
+        this.sendMIDIProgramChange(channel, p.program);
+      } else {
+        this.sendMIDICC(channel, midiControllers.bankSelect, p.bank);
       }
     }
   }
@@ -4946,6 +4903,11 @@ var SpessaSynthSequencer = class {
    * This is used by spessasynth_lib to pass them over to Web MIDI API.
    */
   externalMIDIPlayback = false;
+  /**
+   * If the notes that were playing when the sequencer was paused should be re-triggered.
+   * Defaults to true.
+   */
+  retriggerPausedNotes = false;
   /**
    * The loop count of the sequencer.
    * If infinite, it will loop forever.
@@ -4957,6 +4919,15 @@ var SpessaSynthSequencer = class {
    * Defaults to true.
    */
   skipToFirstNoteOn = true;
+  /**
+   * Indicates if the sequencer has finished playing.
+   */
+  isFinished = false;
+  /**
+   * Indicates if the synthesizer should preload the voices for the newly loaded sequence.
+   * Recommended.
+   */
+  preload = false;
   /**
    * Called when the sequencer calls an event.
    * @param event The event
@@ -5168,9 +5139,9 @@ var SpessaSynthSequencer = class {
     if (this.paused) {
       this.recalculateStartTime(this.pausedTime ?? 0);
     }
-    if (!this.externalMIDIPlayback) {
+    if (this.retriggerPausedNotes) {
       this.playingNotes.forEach((n) => {
-        this.synth.noteOn(n.channel, n.midiNote, n.velocity);
+        this.sendMIDINoteOn(n.channel, n.midiNote, n.velocity);
       });
     }
     this.pausedTime = void 0;
@@ -5208,8 +5179,12 @@ var SpessaSynthSequencer = class {
     }
     this.stop();
     this.callEvent("pause", { isFinished });
+    if (isFinished) {
+      this.callEvent("songEnded", {});
+    }
   }
   songIsFinished() {
+    this.isFinished = true;
     if (this.songs.length === 1) {
       this.pauseInternal(true);
       return;
@@ -5223,21 +5198,7 @@ var SpessaSynthSequencer = class {
    */
   stop() {
     this.pausedTime = this.currentTime;
-    for (let i = 0; i < 16; i++) {
-      this.synth.controllerChange(i, midiControllers.sustainPedal, 0);
-    }
-    this.synth.stopAllChannels();
-    if (this.externalMIDIPlayback) {
-      for (const note of this.playingNotes) {
-        this.sendMIDIMessage([
-          midiMessageTypes.noteOff | note.channel % 16,
-          note.midiNote
-        ]);
-      }
-      for (let c = 0; c < MIDI_CHANNEL_COUNT; c++) {
-        this.sendMIDICC(c, midiControllers.allNotesOff, 0);
-      }
-    }
+    this.sendMIDIAllOff();
   }
   /**
    * @returns the index of the first to the current played time
@@ -5267,24 +5228,36 @@ var SpessaSynthSequencer = class {
   }
   sendMIDIMessage(message) {
     if (!this.externalMIDIPlayback) {
+      SpessaSynthWarn(
+        `Attempting to send ${arrayToHexString(message)} to the synthesizer via sendMIDIMessage. This shouldn't happen!`
+      );
       return;
     }
     this.callEvent("midiMessage", { message });
   }
+  sendMIDIAllOff() {
+    for (let i = 0; i < 16; i++) {
+      this.sendMIDICC(i, midiControllers.sustainPedal, 0);
+    }
+    if (!this.externalMIDIPlayback) {
+      this.synth.stopAllChannels();
+      return;
+    }
+    this.playingNotes.forEach((note) => {
+      this.sendMIDINoteOff(note.channel, note.midiNote);
+    });
+    for (let c = 0; c < MIDI_CHANNEL_COUNT; c++) {
+      this.sendMIDICC(c, midiControllers.allNotesOff, 0);
+      this.sendMIDICC(c, midiControllers.allSoundOff, 0);
+    }
+  }
   sendMIDIReset() {
-    this.sendMIDIMessage([midiMessageTypes.reset]);
-    for (let ch = 0; ch < MIDI_CHANNEL_COUNT; ch++) {
-      this.sendMIDIMessage([
-        midiMessageTypes.controllerChange | ch,
-        midiControllers.allSoundOff,
-        0
-      ]);
-      this.sendMIDIMessage([
-        midiMessageTypes.controllerChange | ch,
-        midiControllers.resetAllControllers,
-        0
-      ]);
+    this.sendMIDIAllOff();
+    if (!this.externalMIDIPlayback) {
+      this.synth.resetAllControllers();
+      return;
     }
+    this.sendMIDIMessage([midiMessageTypes.reset]);
   }
   loadCurrentSong() {
     let index = this._songIndex;
@@ -5302,11 +5275,65 @@ var SpessaSynthSequencer = class {
       indexes.splice(indexes.indexOf(index), 1);
     }
   }
-  sendMIDICC(channel, type, value) {
+  /**
+   * Sets the time in MIDI ticks.
+   * @param ticks the MIDI ticks to set the time to.
+   */
+  setTimeTicks(ticks) {
+    if (!this._midiData) {
+      return;
+    }
+    this.playingNotes = [];
+    const seconds = this._midiData.midiTicksToSeconds(ticks);
+    this.callEvent("timeChange", { newTime: seconds });
+    const isNotFinished = this.setTimeTo(0, ticks);
+    this.recalculateStartTime(this.playedTime);
+    if (!isNotFinished) {
+      return;
+    }
+  }
+  /**
+   * Recalculates the absolute start time of the sequencer.
+   * @param time the time in seconds to recalculate the start time for.
+   */
+  recalculateStartTime(time) {
+    this.absoluteStartTime = this.synth.currentSynthTime - time / this._playbackRate;
+  }
+  /*
+  SEND MIDI METHOD ABSTRACTIONS
+  These abstract the difference between spessasynth and external MIDI
+   */
+  sendMIDINoteOn(channel, midiNote, velocity) {
+    if (!this.externalMIDIPlayback) {
+      this.synth.noteOn(channel, midiNote, velocity);
+      return;
+    }
+    channel %= 16;
+    this.sendMIDIMessage([
+      midiMessageTypes.noteOn | channel,
+      midiNote,
+      velocity
+    ]);
+  }
+  sendMIDINoteOff(channel, midiNote) {
+    if (!this.externalMIDIPlayback) {
+      this.synth.noteOff(channel, midiNote);
+      return;
+    }
     channel %= 16;
+    this.sendMIDIMessage([
+      midiMessageTypes.noteOff | channel,
+      midiNote,
+      64
+      // Make sure to send velocity as well
+    ]);
+  }
+  sendMIDICC(channel, type, value) {
     if (!this.externalMIDIPlayback) {
+      this.synth.controllerChange(channel, type, value);
       return;
     }
+    channel %= 16;
     this.sendMIDIMessage([
       midiMessageTypes.controllerChange | channel,
       type,
@@ -5314,10 +5341,11 @@ var SpessaSynthSequencer = class {
     ]);
   }
   sendMIDIProgramChange(channel, program) {
-    channel %= 16;
     if (!this.externalMIDIPlayback) {
+      this.synth.programChange(channel, program);
       return;
     }
+    channel %= 16;
     this.sendMIDIMessage([
       midiMessageTypes.programChange | channel,
       program
@@ -5326,39 +5354,19 @@ var SpessaSynthSequencer = class {
   /**
    * Sets the pitch of the given channel
    * @param channel usually 0-15: the channel to change pitch
-   * @param MSB SECOND byte of the MIDI pitchWheel message
-   * @param LSB FIRST byte of the MIDI pitchWheel message
+   * @param pitch the 14-bit pitch value
    */
-  sendMIDIPitchWheel(channel, MSB, LSB) {
-    channel %= 16;
+  sendMIDIPitchWheel(channel, pitch) {
     if (!this.externalMIDIPlayback) {
+      this.synth.pitchWheel(channel, pitch);
       return;
     }
-    this.sendMIDIMessage([midiMessageTypes.pitchWheel | channel, LSB, MSB]);
-  }
-  /**
-   * Sets the time in MIDI ticks.
-   * @param ticks the MIDI ticks to set the time to.
-   */
-  setTimeTicks(ticks) {
-    if (!this._midiData) {
-      return;
-    }
-    this.playingNotes = [];
-    const seconds = this._midiData.midiTicksToSeconds(ticks);
-    this.callEvent("timeChange", { newTime: seconds });
-    const isNotFinished = this.setTimeTo(0, ticks);
-    this.recalculateStartTime(this.playedTime);
-    if (!isNotFinished) {
-      return;
-    }
-  }
-  /**
-   * Recalculates the absolute start time of the sequencer.
-   * @param time the time in seconds to recalculate the start time for.
-   */
-  recalculateStartTime(time) {
-    this.absoluteStartTime = this.synth.currentSynthTime - time / this._playbackRate;
+    channel %= 16;
+    this.sendMIDIMessage([
+      midiMessageTypes.pitchWheel | channel,
+      pitch & 127,
+      pitch >> 7
+    ]);
   }
 };