spessasynth_lib 3.24.16 → 3.24.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.24.16",
+  "version": "3.24.18",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "type": "module",

package/sequencer/sequencer.js

@@ -3,6 +3,7 @@ import { Synthetizer } from "../synthetizer/synthetizer.js";
 import { messageTypes } from "../midi_parser/midi_message.js";
 import { workletMessageType } from "../synthetizer/worklet_system/message_protocol/worklet_message.js";
 import {
+    SongChangeType,
     WorkletSequencerMessageType,
     WorkletSequencerReturnMessageType
 } from "./worklet_sequencer/sequencer_message.js";
@@ -261,6 +262,38 @@ export class Sequencer
         this._playbackRate = value;
     }
     
+    /**
+     * @type {boolean}
+     * @private
+     */
+    _shuffleSongs = false;
+    
+    /**
+     * Indicates if the song order is random
+     * @returns {boolean}
+     */
+    get shuffleSongs()
+    {
+        return this._shuffleSongs;
+    }
+    
+    /**
+     * Indicates if the song order is random
+     * @param value {boolean}
+     */
+    set shuffleSongs(value)
+    {
+        this._shuffleSongs = value;
+        if (value)
+        {
+            this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.shuffleOn);
+        }
+        else
+        {
+            this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.shuffleOff);
+        }
+    }
+    
     /**
      * Indicates if the sequencer should skip to first note on
      * @return {boolean}
@@ -446,12 +479,12 @@ export class Sequencer
     
     nextSong()
     {
-        this._sendMessage(WorkletSequencerMessageType.changeSong, true);
+        this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.forwards);
     }
     
     previousSong()
     {
-        this._sendMessage(WorkletSequencerMessageType.changeSong, false);
+        this._sendMessage(WorkletSequencerMessageType.changeSong, SongChangeType.backwards);
     }
     
     /**

package/sequencer/worklet_sequencer/events.js

@@ -2,7 +2,7 @@ import {
     ALL_CHANNELS_OR_DIFFERENT_ACTION,
     returnMessageType
 } from "../../synthetizer/worklet_system/message_protocol/worklet_message.js";
-import { WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+import { SongChangeType, WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from "./sequencer_message.js";
 import { messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
 import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synthetizer.js";
 
@@ -60,13 +60,26 @@ export function processMessage(messageType, messageData)
             break;
         
         case WorkletSequencerMessageType.changeSong:
-            if (messageData)
+            switch (messageData)
             {
-                this.nextSong();
-            }
-            else
-            {
-                this.previousSong();
+                case SongChangeType.forwards:
+                    this.nextSong();
+                    break;
+                
+                case SongChangeType.backwards:
+                    this.previousSong();
+                    break;
+                
+                case SongChangeType.shuffleOff:
+                    this.shuffleMode = false;
+                    this.songIndex = this.shuffledSongIndexes[this.songIndex];
+                    break;
+                
+                case SongChangeType.shuffleOn:
+                    this.shuffleMode = true;
+                    this.shuffleSongIndexes();
+                    this.songIndex = 0;
+                    this.loadCurrentSong();
             }
             break;
         

package/sequencer/worklet_sequencer/process_event.js

@@ -13,10 +13,6 @@ import { readBytesAsUintBigEndian } from "../../utils/byte_functions/big_endian.
  */
 export function _processEvent(event, trackIndex)
 {
-    if (this.ignoreEvents)
-    {
-        return;
-    }
     if (this.sendMIDIMessages)
     {
         if (event.messageStatusByte >= 0x80)
@@ -100,7 +96,7 @@ export function _processEvent(event, trackIndex)
             }
             break;
         
-        // recongized but ignored
+        // recognized but ignored
         case messageTypes.timeSignature:
         case messageTypes.endOfTrack:
         case messageTypes.midiChannelPrefix:
@@ -123,7 +119,7 @@ export function _processEvent(event, trackIndex)
             if (statusByteData.status === messageTypes.lyric)
             {
                 lyricsIndex = Math.min(
-                    this.midiData.lyricsTicks.indexOf(event.ticks) + 1,
+                    this.midiData.lyricsTicks.indexOf(event.ticks),
                     this.midiData.lyrics.length - 1
                 );
             }

package/sequencer/worklet_sequencer/sequencer_message.js

@@ -1,3 +1,10 @@
+export const SongChangeType = {
+    backwards: 0,
+    forwards: 1,
+    shuffleOn: 2,
+    shuffleOff: 3
+};
+
 /**
  * @enum {number}
  * @property {number} loadNewSongList          - 0 -> [...song<MIDI>]
@@ -8,7 +15,7 @@
  * @property {number} changeMIDIMessageSending - 5 -> sendMIDIMessages<boolean>
  * @property {number} setPlaybackRate          - 6 -> playbackRate<number>
  * @property {number} setLoop                  - 7 -> [loop<boolean>, count<number]
- * @property {number} changeSong               - 8 -> goForwards<boolean> if true, next song, if false, previous
+ * @property {number} changeSong               - 8 -> changeType<number> 0 - back, 1 - forward, 2 - shuffle ON, 3 - shuffle OFF
  * @property {number} getMIDI                  - 9 -> (no data)
  * @property {number} setSkipToFirstNote       -10 -> skipToFirstNoteOn<boolean>
  * @property {number} setPreservePlaybackState -11 -> preservePlaybackState<boolean>

package/sequencer/worklet_sequencer/song_control.js

@@ -120,7 +120,7 @@ export function loadNewSequence(parsedMidi, autoPlay = true)
     });
     
     /**
-     * Same as Audio.duration (seconds)
+     * Same as "audio.duration" property (seconds)
      * @type {number}
      */
     this.duration = this.midiData.duration;
@@ -188,7 +188,8 @@ export function loadNewSongList(midiBuffers, autoPlay = true)
     {
         this.loop = false;
     }
-    this.loadNewSequence(this.songs[this.songIndex], autoPlay);
+    this.shuffleSongIndexes();
+    this.loadCurrentSong(autoPlay);
 }
 
 /**
@@ -203,7 +204,7 @@ export function nextSong()
     }
     this.songIndex++;
     this.songIndex %= this.songs.length;
-    this.loadNewSequence(this.songs[this.songIndex]);
+    this.loadCurrentSong();
 }
 
 /**
@@ -221,5 +222,5 @@ export function previousSong()
     {
         this.songIndex = this.songs.length - 1;
     }
-    this.loadNewSequence(this.songs[this.songIndex]);
+    this.loadCurrentSong();
 }

package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -18,100 +18,139 @@ import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synthetizer.js";
 
 class WorkletSequencer
 {
+    /**
+     * All the sequencer's songs
+     * @type {BasicMIDI[]}
+     */
+    songs = [];
+    
+    /**
+     * Current song index
+     * @type {number}
+     */
+    songIndex = 0;
+    
+    /**
+     * shuffled song indexes
+     * @type {number[]}
+     */
+    shuffledSongIndexes = [];
+    
+    /**
+     * the synth to use
+     * @type {SpessaSynthProcessor}
+     */
+    synth;
+    
+    /**
+     * if the sequencer is active
+     * @type {boolean}
+     */
+    isActive = false;
+    
+    /**
+     * If the event should instead be sent back to the main thread instead of synth
+     * @type {boolean}
+     */
+    sendMIDIMessages = false;
+    
+    /**
+     * sequencer's loop count
+     * @type {number}
+     */
+    loopCount = Infinity;
+    
+    /**
+     * event's number in this.events
+     * @type {number[]}
+     */
+    eventIndex = [];
+    
+    /**
+     * tracks the time that has already been played
+     * @type {number}
+     */
+    playedTime = 0;
+    
+    /**
+     * The (relative) time when the sequencer was paused. If it's not paused, then it's undefined.
+     * @type {number}
+     */
+    pausedTime = undefined;
+    
+    /**
+     * Absolute playback startTime, bases on the synth's time
+     * @type {number}
+     */
+    absoluteStartTime = currentTime;
+    /**
+     * Currently playing notes (for pausing and resuming)
+     * @type {{
+     *     midiNote: number,
+     *     channel: number,
+     *     velocity: number
+     * }[]}
+     */
+    playingNotes = [];
+    
+    /**
+     * controls if the sequencer loops (defaults to true)
+     * @type {boolean}
+     */
+    loop = true;
+    
+    /**
+     * controls if the songs are ordered randomly
+     * @type {boolean}
+     */
+    shuffleMode = false;
+    
+    /**
+     * the current track data
+     * @type {BasicMIDI}
+     */
+    midiData = undefined;
+    
+    /**
+     * midi port number for the corresponding track
+     * @type {number[]}
+     */
+    midiPorts = [];
+    midiPortChannelOffset = 0;
+    /**
+     * stored as:
+     * Object<midi port, channel offset>
+     * @type {Object<number, number>}
+     */
+    midiPortChannelOffsets = {};
+    
+    /**
+     * @type {boolean}
+     * @private
+     */
+    _skipToFirstNoteOn = true;
+    
+    /**
+     * If true, seq will stay paused when seeking or changing the playback rate
+     * @type {boolean}
+     */
+    preservePlaybackState = false;
+    
     /**
      * @param spessasynthProcessor {SpessaSynthProcessor}
      */
     constructor(spessasynthProcessor)
     {
         this.synth = spessasynthProcessor;
-        this.ignoreEvents = false;
-        this.isActive = false;
-        
-        /**
-         * If the event should instead be sent back to the main thread instead of synth
-         * @type {boolean}
-         */
-        this.sendMIDIMessages = false;
-        
-        this.loopCount = Infinity;
-        
-        // event's number in this.events
-        /**
-         * @type {number[]}
-         */
-        this.eventIndex = [];
-        this.songIndex = 0;
-        
-        // tracks the time that we have already played
-        /**
-         * @type {number}
-         */
-        this.playedTime = 0;
-        
-        /**
-         * The (relative) time when the sequencer was paused. If it's not paused then it's undefined.
-         * @type {number}
-         */
-        this.pausedTime = undefined;
-        
-        /**
-         * Absolute playback startTime, bases on the synth's time
-         * @type {number}
-         */
-        this.absoluteStartTime = currentTime;
-        
-        /**
-         * Controls the playback's rate
-         * @type {number}
-         */
-        this._playbackRate = 1;
-        
-        /**
-         * Currently playing notes (for pausing and resuming)
-         * @type {{
-         *     midiNote: number,
-         *     channel: number,
-         *     velocity: number
-         * }[]}
-         */
-        this.playingNotes = [];
-        
-        // controls if the sequencer loops (defaults to true)
-        this.loop = true;
-        
-        /**
-         * the current track data
-         * @type {BasicMIDI}
-         */
-        this.midiData = undefined;
-        
-        /**
-         * midi port number for the corresponding track
-         * @type {number[]}
-         */
-        this.midiPorts = [];
-        
-        this.midiPortChannelOffset = 0;
-        
-        /**
-         * midi port: channel offset
-         * @type {Object<number, number>}
-         */
-        this.midiPortChannelOffsets = {};
-        
-        /**
-         * @type {boolean}
-         * @private
-         */
-        this._skipToFirstNoteOn = true;
-        
-        /**
-         * If true, seq will stay paused when seeking or changing the playback rate
-         * @type {boolean}
-         */
-        this.preservePlaybackState = false;
     }
     
+    /**
+     * Controls the playback's rate
+     * @type {number}
+     * @private
+     */
+    _playbackRate = 1;
+    
     /**
      * @param value {number}
      */
@@ -229,6 +268,16 @@ class WorkletSequencer
         }
     }
     
+    loadCurrentSong(autoPlay = true)
+    {
+        let index = this.songIndex;
+        if (this.shuffleMode)
+        {
+            index = this.shuffledSongIndexes[this.songIndex];
+        }
+        this.loadNewSequence(this.songs[index], autoPlay);
+    }
+    
     _resetTimers()
     {
         this.playedTime = 0;
@@ -244,6 +293,18 @@ class WorkletSequencer
     {
         this.isActive = false;
     }
+    
+    shuffleSongIndexes()
+    {
+        const indexes = this.songs.map((_, i) => i);
+        this.shuffledSongIndexes = [];
+        while (indexes.length > 0)
+        {
+            const index = indexes[Math.floor(Math.random() * indexes.length)];
+            this.shuffledSongIndexes.push(index);
+            indexes.splice(indexes.indexOf(index), 1);
+        }
+    }
 }
 
 // Web MIDI sending