spessasynth_lib 3.9.20 → 3.9.22

package/@types/externals/libvorbis/OggVorbisEncoder.min.d.ts

@@ -0,0 +1,3 @@
+export namespace libvorbis {
+    function init(...args: any[]): void;
+}

package/@types/sequencer/sequencer.d.ts

@@ -1,22 +1,11 @@
-/**
- * sequencer.js
- * purpose: plays back the midi file decoded by midi_loader.js, including support for multi-channel midis (adding channels when more than 1 midi port is detected)
- */
-/**
- * @typedef MidFile {Object}
- * @property {ArrayBuffer} binary - the binary data of the file.
- * @property {string|undefined} altName - the alternative name for the file
- */
-/**
- * @typedef {MIDI|MidFile} MIDIFile
- */
 export class Sequencer {
     /**
      * Creates a new Midi sequencer for playing back MIDI files
      * @param midiBinaries {MIDIFile[]} List of the buffers of the MIDI files
      * @param synth {Synthetizer} synth to send events to
+     * @param options {SequencerOptions} the sequencer's options
      */
-    constructor(midiBinaries: MIDIFile[], synth: Synthetizer);
+    constructor(midiBinaries: MIDIFile[], synth: Synthetizer, options?: SequencerOptions);
     ignoreEvents: boolean;
     synth: Synthetizer;
     highResTimeOffset: number;
@@ -47,6 +36,21 @@ export class Sequencer {
      * @type {number}
      */
     duration: number;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private _skipToFirstNoteOn;
+    /**
+     * Indicates if the sequencer should skip to first note on
+     * @param val {boolean}
+     */
+    set skipToFirstNoteOn(val: boolean);
+    /**
+     * Indicates if the sequencer should skip to first note on
+     * @return {boolean}
+     */
+    get skipToFirstNoteOn(): boolean;
     resetMIDIOut(): void;
     set loop(value: boolean);
     get loop(): boolean;
@@ -186,6 +190,12 @@ export type MidFile = {
     altName: string | undefined;
 };
 export type MIDIFile = MIDI | MidFile;
+export type SequencerOptions = {
+    /**
+     * - if true, the sequencer will skip to the first note
+     */
+    skipToFirstNoteOn: boolean;
+};
 import { Synthetizer } from '../synthetizer/synthetizer.js';
 import { MidiData } from '../midi_parser/midi_data.js';
 import { MIDI } from '../midi_parser/midi_loader.js';

package/@types/sequencer/worklet_sequencer/sequencer_message.d.ts

@@ -13,6 +13,7 @@ export namespace WorkletSequencerMessageType {
     let setLoop: number;
     let changeSong: number;
     let getMIDI: number;
+    let setSkipToFirstNote: number;
 }
 export type WorkletSequencerReturnMessageType = number;
 export namespace WorkletSequencerReturnMessageType {

package/index.js

@@ -26,6 +26,7 @@ import { NON_CC_INDEX_OFFSET } from './synthetizer/worklet_system/worklet_utilit
 import { modulatorSources } from './soundfont/read/modulators.js';
 import { ALL_CHANNELS_OR_DIFFERENT_ACTION } from './synthetizer/worklet_system/message_protocol/worklet_message.js';
 import { trimSoundfont } from './soundfont/write/soundfont_trimmer.js';
+import { OggVorbisEncoder } from './externals/libvorbis/OggVorbisEncoder.min.js';
 import { WORKLET_URL_ABSOLUTE } from './synthetizer/worklet_url.js'
 
 // Export modules

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.9.20",
+  "version": "3.9.22",
   "description": "No compromise MIDI and SoundFont2 Synthesizer library",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/sequencer/sequencer.js

@@ -24,14 +24,26 @@ import { DUMMY_MIDI_DATA, MidiData } from '../midi_parser/midi_data.js'
  * @typedef {MIDI|MidFile} MIDIFile
  */
 
+/**
+ * @typedef {Object} SequencerOptions
+ * @property {boolean} skipToFirstNoteOn - if true, the sequencer will skip to the first note
+ */
+
+/**
+ * @type {SequencerOptions}
+ */
+const DEFAULT_OPTIONS = {
+    skipToFirstNoteOn: true,
+}
 export class Sequencer
 {
     /**
      * Creates a new Midi sequencer for playing back MIDI files
      * @param midiBinaries {MIDIFile[]} List of the buffers of the MIDI files
      * @param synth {Synthetizer} synth to send events to
+     * @param options {SequencerOptions} the sequencer's options
      */
-    constructor(midiBinaries, synth)
+    constructor(midiBinaries, synth, options = DEFAULT_OPTIONS)
     {
         this.ignoreEvents = false;
         this.synth = synth;
@@ -73,11 +85,42 @@ export class Sequencer
 
         this.synth.sequencerCallbackFunction = this._handleMessage.bind(this);
 
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._skipToFirstNoteOn = options?.skipToFirstNoteOn ?? true;
+
+        if(this._skipToFirstNoteOn === false)
+        {
+            // setter sends message
+            this._sendMessage(WorkletSequencerMessageType.setSkipToFirstNote, false);
+        }
+
         this.loadNewSongList(midiBinaries);
 
         window.addEventListener("beforeunload", this.resetMIDIOut.bind(this))
     }
 
+    /**
+     * Indicates if the sequencer should skip to first note on
+     * @return {boolean}
+     */
+    get skipToFirstNoteOn()
+    {
+        return this._skipToFirstNoteOn;
+    }
+
+    /**
+     * Indicates if the sequencer should skip to first note on
+     * @param val {boolean}
+     */
+    set skipToFirstNoteOn(val)
+    {
+        this._skipToFirstNoteOn = val;
+        this._sendMessage(WorkletSequencerMessageType.setSkipToFirstNote, this._skipToFirstNoteOn);
+    }
+
     resetMIDIOut()
     {
         if(!this.MIDIout)

package/sequencer/worklet_sequencer/events.js

@@ -58,6 +58,11 @@ export function processMessage(messageType, messageData)
 
         case WorkletSequencerMessageType.getMIDI:
             this.post(WorkletSequencerReturnMessageType.getMIDI, this.midiData);
+            break;
+
+        case WorkletSequencerMessageType.setSkipToFirstNote:
+            this._skipToFirstNoteOn = messageData;
+            break;
     }
 }
 

package/sequencer/worklet_sequencer/play.js

@@ -45,9 +45,32 @@ export function _playTo(time, ticks = undefined)
 
     /**
      * Save programs here and send them only after
-     * @type {number[]}
+     * @type {{program: number, bank: number, actualBank: number}[]}
      */
-    const programs = Array(channelsToSave).fill(-1  );
+    const programs = [];
+    for (let i = 0; i < channelsToSave; i++)
+    {
+        programs.push({
+            program: -1,
+            bank: 0,
+            actualBank: 0,
+        });
+    }
+
+    const isCCNonSkippable = controllerNumber => (
+        controllerNumber === midiControllers.dataDecrement           ||
+        controllerNumber === midiControllers.dataIncrement           ||
+        controllerNumber === midiControllers.dataEntryMsb            ||
+        controllerNumber === midiControllers.dataDecrement           ||
+        controllerNumber === midiControllers.lsbForControl6DataEntry ||
+        controllerNumber === midiControllers.RPNLsb                  ||
+        controllerNumber === midiControllers.RPNMsb                  ||
+        controllerNumber === midiControllers.NRPNLsb                 ||
+        controllerNumber === midiControllers.NRPNMsb                 ||
+        controllerNumber === midiControllers.bankSelect              ||
+        controllerNumber === midiControllers.lsbForControl0BankSelect||
+        controllerNumber === midiControllers.resetAllControllers
+    );
 
     /**
      * Save controllers here and send them only after
@@ -97,26 +120,15 @@ export function _playTo(time, ticks = undefined)
                 break;
 
             case messageTypes.programChange:
-                programs[channel] = event.messageData[0];
+                const p = programs[channel];
+                p.program = event.messageData[0];
+                p.actualBank = p.bank;
                 break;
 
             case messageTypes.controllerChange:
                 // do not skip data entries
                 const controllerNumber = event.messageData[0];
-                if(
-                    controllerNumber === midiControllers.dataDecrement           ||
-                    controllerNumber === midiControllers.dataIncrement           ||
-                    controllerNumber === midiControllers.dataEntryMsb            ||
-                    controllerNumber === midiControllers.dataDecrement           ||
-                    controllerNumber === midiControllers.lsbForControl6DataEntry ||
-                    controllerNumber === midiControllers.RPNLsb                  ||
-                    controllerNumber === midiControllers.RPNMsb                  ||
-                    controllerNumber === midiControllers.NRPNLsb                 ||
-                    controllerNumber === midiControllers.NRPNMsb                 ||
-                    controllerNumber === midiControllers.bankSelect              ||
-                    controllerNumber === midiControllers.lsbForControl0BankSelect||
-                    controllerNumber === midiControllers.resetAllControllers
-                )
+                if(isCCNonSkippable(controllerNumber))
                 {
                     if(this.sendMIDIMessages)
                     {
@@ -125,10 +137,16 @@ export function _playTo(time, ticks = undefined)
                     else
                     {
                         let ccV = event.messageData[1];
-                        if(this.midiData.embeddedSoundFont !== undefined && controllerNumber === midiControllers.bankSelect)
+                        if(controllerNumber === midiControllers.bankSelect)
                         {
-                            // special case if the RMID is embedded: subtract 1 from bank. See wiki About-RMIDI
-                            ccV--;
+                            if(this.midiData.embeddedSoundFont !== undefined)
+                            {
+                                // special case if the RMID is embedded: subtract 1 from bank. See wiki About-RMIDI
+                                ccV--;
+                            }
+                            // add the bank to saved
+                            programs[channel].bank = ccV;
+                            break;
                         }
                         this.synth.controllerChange(channel, controllerNumber, ccV);
                     }
@@ -170,16 +188,18 @@ export function _playTo(time, ticks = undefined)
 
             // every controller that has changed
             savedControllers[channelNumber].forEach((value, index) => {
-                if(value !== defaultControllerArray[index])
+                if(value !== defaultControllerArray[index] && !isCCNonSkippable(index))
                 {
                     this.sendMIDIMessage([messageTypes.controllerChange | (channelNumber % 16), index, value])
                 }
             });
 
             // restore programs
-            if(programs[channelNumber] !== 0)
+            if(programs[channelNumber].program !== -1)
             {
-                this.sendMIDIMessage([messageTypes.programChange | (channelNumber % 16), programs[channelNumber]]);
+                const bank = programs[channelNumber].actualBank;
+                this.sendMIDIMessage([messageTypes.controllerChange | (channelNumber % 16), midiControllers.bankSelect, bank]);
+                this.sendMIDIMessage([messageTypes.programChange | (channelNumber % 16), programs[channelNumber].program]);
             }
         }
     }
@@ -197,16 +217,18 @@ export function _playTo(time, ticks = undefined)
             {
                 // every controller that has changed
                 savedControllers[channelNumber].forEach((value, index) => {
-                    if(value !== defaultControllerArray[index])
+                    if(value !== defaultControllerArray[index] && !isCCNonSkippable(index))
                     {
                         this.synth.controllerChange(channelNumber, index, value);
                     }
                 })
             }
             // restore programs
-            if(programs[channelNumber] !== -1)
+            if(programs[channelNumber].program !== -1)
             {
-                this.synth.programChange(channelNumber, programs[channelNumber]);
+                const bank = programs[channelNumber].actualBank;
+                this.synth.controllerChange(channelNumber, midiControllers.bankSelect, bank);
+                this.synth.programChange(channelNumber, programs[channelNumber].program);
             }
         }
     }

package/sequencer/worklet_sequencer/sequencer_message.js

@@ -10,6 +10,7 @@
  * @property {number} setLoop                  - 7 -> loop<boolean>
  * @property {number} changeSong               - 8 -> goForwards<boolean> if true, next song, if false, previous
  * @property {number} getMIDI                  - 9 -> (no data)
+ * @property {number} setSkipToFirstNote       -10 -> skipToFirstNoteOn<boolean>
  */
 export const WorkletSequencerMessageType = {
     loadNewSongList: 0,
@@ -21,7 +22,8 @@ export const WorkletSequencerMessageType = {
     setPlaybackRate: 6,
     setLoop: 7,
     changeSong: 8,
-    getMIDI: 9
+    getMIDI: 9,
+    setSkipToFirstNote: 10
 }
 
 /**

package/sequencer/worklet_sequencer/song_control.js

@@ -148,7 +148,6 @@ export function loadNewSongList(midiBuffers)
     }, []);
     if(this.songs.length < 1)
     {
-        console.log("no valid songs!")
         return;
     }
     this.songIndex = 0;

package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -88,6 +88,12 @@ class WorkletSequencer
          * @type {Object<number, number>}
          */
         this.midiPortChannelOffsets = {};
+
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._skipToFirstNoteOn = true;
     }
 
     /**
@@ -113,12 +119,27 @@ class WorkletSequencer
 
     set currentTime(time)
     {
-        if(time < this.firstNoteTime || time > this.duration)
+        if(time > this.duration || time < 0)
         {
             // time is 0
-            this.setTimeTicks(this.midiData.firstNoteOn - 1);
+            if(this._skipToFirstNoteOn)
+            {
+                this.setTimeTicks(this.midiData.firstNoteOn - 1);
+            }
+            else
+            {
+                this.setTimeTicks(0);
+            }
             return;
         }
+        if(this._skipToFirstNoteOn)
+        {
+            if(time < this.firstNoteTime)
+            {
+                this.setTimeTicks(this.midiData.firstNoteOn - 1);
+                return;
+            }
+        }
         this.stop();
         this.playingNotes = [];
         this.pausedTime = undefined;