spessasynth_lib 3.24.6 → 3.24.7

package/package.json

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

package/sequencer/sequencer.js

@@ -9,11 +9,15 @@ import {
 import { SpessaSynthWarn } from "../utils/loggin.js";
 import { DUMMY_MIDI_DATA, MidiData } from "../midi_parser/midi_data.js";
 import { BasicMIDI } from "../midi_parser/basic_midi.js";
+import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
 
 /**
  * sequencer.js
  * purpose: plays back the midi file decoded by midi_loader.js, including support for multichannel midis
  * (adding channels when more than one midi port is detected)
+ * note: this is the sequencer class that runs on the main thread
+ * and only communicates with the worklet sequencer which does the actual playback
  */
 
 /**
@@ -43,6 +47,7 @@ const DEFAULT_OPTIONS = {
     preservePlaybackState: false
 };
 
+// noinspection JSUnusedGlobalSymbols
 export class Sequencer
 {
     /**
@@ -50,30 +55,35 @@ export class Sequencer
      * @type {function(string)}
      */
     onError;
+    
+    /**
+     * Fires on text event
+     * @type {function}
+     * @param data {Uint8Array} the data text
+     * @param type {number} the status byte of the message (the meta-status byte)
+     * @param lyricsIndex {number} if the text is a lyric, the index of the lyric in midiData.lyrics, otherwise -1
+     */
+    onTextEvent;
+    
     /**
      * The sequence's data, except for the track data.
      *  @type {MidiData}
      */
     midiData;
+    
     /**
      * @type {Object<string, function(MidiData)>}
      * @private
      */
     onSongChange = {};
-    /**
-     * Fires on text event
-     * @type {function}
-     * @param data {Uint8Array} the data text
-     * @param type {number} the status byte of the message (the meta-status byte)
-     * @param lyricsIndex {number} if the text is a lyric, the index of the lyric in midiData.lyrics, otherwise -1
-     */
-    onTextEvent;
+    
     /**
      * Fires when CurrentTime changes
      * @type {Object<string, function(number)>} the time that was changed to
      * @private
      */
     onTimeChange = {};
+    
     /**
      * @type {Object<string, function>}
      * @private
@@ -86,6 +96,12 @@ export class Sequencer
      */
     onTempoChange = {};
     
+    /**
+     * Fires on meta-event
+     * @type {Object<string, function([number, Uint8Array])>}
+     */
+    onMetaEvent = {};
+    
     /**
      * Current song's tempo in BPM
      * @type {number}
@@ -179,6 +195,10 @@ export class Sequencer
      */
     _loop = true;
     
+    /**
+     * Indicates if the sequencer is currently looping
+     * @returns {boolean}
+     */
     get loop()
     {
         return this._loop;
@@ -186,10 +206,36 @@ export class Sequencer
     
     set loop(value)
     {
-        this._sendMessage(WorkletSequencerMessageType.setLoop, value);
+        this._sendMessage(WorkletSequencerMessageType.setLoop, [value, this._loopsRemaining]);
         this._loop = value;
     }
     
+    /**
+     * Internal loop count marker (-1 is infinite)
+     * @type {number}
+     * @private
+     */
+    _loopsRemaining = -1;
+    
+    /**
+     * The current remaining number of loops. -1 means infinite looping
+     * @returns {number}
+     */
+    get loopsRemaining()
+    {
+        return this._loopsRemaining;
+    }
+    
+    /**
+     * The current remaining number of loops. -1 means infinite looping
+     * @param val {number}
+     */
+    set loopsRemaining(val)
+    {
+        this._loopsRemaining = val;
+        this._sendMessage(WorkletSequencerMessageType.setLoop, [this._loop, val]);
+    }
+    
     /**
      * Controls the playback's rate
      * @type {number}
@@ -357,6 +403,16 @@ export class Sequencer
         this.onTempoChange[id] = callback;
     }
     
+    /**
+     * Adds a new event that gets called when a meta-event occurs
+     * @param callback {function([number, Uint8Array])} the meta-event type and its data
+     * @param id {string} must be unique
+     */
+    addOnMetaEvent(callback, id)
+    {
+        this.onMetaEvent[id] = callback;
+    }
+    
     resetMIDIOut()
     {
         if (!this.MIDIout)
@@ -405,17 +461,18 @@ export class Sequencer
      */
     _callEvents(type, params)
     {
-        Object.entries(type).forEach((callback) =>
+        for (const key in type)
         {
+            const callback = type[key];
             try
             {
-                callback[1](params);
+                callback(params);
             }
             catch (e)
             {
                 SpessaSynthWarn(`Failed to execute callback for ${callback[0]}:`, e);
             }
-        });
+        }
     }
     
     /**
@@ -431,9 +488,6 @@ export class Sequencer
         }
         switch (messageType)
         {
-            default:
-                break;
-            
             case WorkletSequencerReturnMessageType.midiEvent:
                 /**
                  * @type {number[]}
@@ -517,12 +571,31 @@ export class Sequencer
                 }
                 break;
             
-            case WorkletSequencerReturnMessageType.tempoChange:
-                this.currentTempo = messageData;
-                if (this.onTempoChange)
+            case WorkletSequencerReturnMessageType.metaEvent:
+                const type = messageData[0];
+                if (type === messageTypes.setTempo)
+                {
+                    const arr = new IndexedByteArray(messageData[1]);
+                    const bpm = 60000000 / readBytesAsUintBigEndian(arr, 3);
+                    this.currentTempo = Math.round(bpm * 100) / 100;
+                    if (this.onTempoChange)
+                    {
+                        this._callEvents(this.onTempoChange, this.currentTempo);
+                    }
+                }
+                this._callEvents(this.onMetaEvent, messageData);
+                break;
+            
+            case WorkletSequencerReturnMessageType.loopCountChange:
+                this._loopsRemaining = messageData;
+                if (this._loopsRemaining === 0)
                 {
-                    this._callEvents(this.onTempoChange, this.currentTempo);
+                    this._loop = false;
                 }
+                break;
+            
+            default:
+                break;
         }
     }
     

package/sequencer/worklet_sequencer/events.js

@@ -1,4 +1,7 @@
-import { returnMessageType } from "../../synthetizer/worklet_system/message_protocol/worklet_message.js";
+import {
+    ALL_CHANNELS_OR_DIFFERENT_ACTION,
+    returnMessageType
+} from "../../synthetizer/worklet_system/message_protocol/worklet_message.js";
 import { WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from "./sequencer_message.js";
 import { messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
 import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synthetizer.js";
@@ -44,7 +47,13 @@ export function processMessage(messageType, messageData)
             break;
         
         case WorkletSequencerMessageType.setLoop:
-            this.loop = messageData;
+            const [loop, count] = messageData;
+            this.loop = loop;
+            if (count === ALL_CHANNELS_OR_DIFFERENT_ACTION)
+            {
+                this.loopCount = Infinity;
+            }
+            this.loopCount = count;
             break;
         
         case WorkletSequencerMessageType.changeSong:

package/sequencer/worklet_sequencer/process_event.js

@@ -90,7 +90,8 @@ export function _processEvent(event, trackIndex)
             break;
         
         case messageTypes.setTempo:
-            let tempoBPM = getTempo(event);
+            event.messageData.currentIndex = 0;
+            let tempoBPM = 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
             this.oneTickToSeconds = 60 / (tempoBPM * this.midiData.timeDivision);
             if (this.oneTickToSeconds === 0)
             {
@@ -98,7 +99,6 @@ export function _processEvent(event, trackIndex)
                 SpessaSynthWarn("invalid tempo! falling back to 120 BPM");
                 tempoBPM = 120;
             }
-            this.post(WorkletSequencerReturnMessageType.tempoChange, Math.floor(tempoBPM * 100) / 100);
             break;
         
         // recongized but ignored
@@ -131,12 +131,12 @@ export function _processEvent(event, trackIndex)
             let sentStatus = statusByteData.status;
             // if MIDI is a karaoke file, it uses the "text" event type or "lyrics" for lyrics (duh)
             // why?
-            // because the MIDI standard is a messy pile of garbage and it's not my fault that it's like this :(
-            // I'm just trying to make the best out of a bad situation
+            // because the MIDI standard is a messy pile of garbage, and it's not my fault that it's like this :(
+            // I'm just trying to make the best out of a bad situation.
             // I'm sorry
-            // okay i should get back to work
-            // anyways,
-            // check for karaoke file and change the status byte to "lyric" if it's a karaoke file
+            // okay I should get back to work
+            // anyway,
+            // check for a karaoke file and change the status byte to "lyric" if it's a karaoke file
             if (this.midiData.isKaraokeFile && (
                 statusByteData.status === messageTypes.text ||
                 statusByteData.status === messageTypes.lyric
@@ -174,6 +174,10 @@ export function _processEvent(event, trackIndex)
             );
             break;
     }
+    if (statusByteData.status >= 0 && statusByteData.status < 0x80)
+    {
+        this.post(WorkletSequencerReturnMessageType.metaEvent, [event.messageStatusByte, event.messageData]);
+    }
 }
 
 /**
@@ -191,15 +195,4 @@ export function _addNewMidiPort()
             this.synth.setDrums(this.synth.workletProcessorChannels.length - 1, true);
         }
     }
-}
-
-/**
- * gets tempo from the midi message
- * @param event {MidiMessage}
- * @return {number} the tempo in bpm
- */
-function getTempo(event)
-{
-    event.messageData.currentIndex = 0;
-    return 60000000 / readBytesAsUintBigEndian(event.messageData, 3);
 }

package/sequencer/worklet_sequencer/process_tick.js

@@ -1,3 +1,5 @@
+import { WorkletSequencerReturnMessageType } from "./sequencer_message.js";
+
 /**
  * Processes a single tick
  * @private
@@ -36,22 +38,35 @@ export function _processTick()
         let eventNext = this.tracks[trackIndex][this.eventIndex[trackIndex]];
         this.playedTime += this.oneTickToSeconds * (eventNext.ticks - event.ticks);
         
-        // loop
-        if ((this.midiData.loop.end <= event.ticks) && this.loop && this.currentLoopCount > 0)
+        const canLoop = this.loop && this.loopCount > 0;
+        
+        // if we reached loop.end
+        if ((this.midiData.loop.end <= event.ticks) && canLoop)
         {
-            this.currentLoopCount--;
+            // loop
+            if (this.loopCount !== Infinity)
+            {
+                this.loopCount--;
+                this.post(WorkletSequencerReturnMessageType.loopCountChange, this.loopCount);
+            }
             this.setTimeTicks(this.midiData.loop.start);
             return;
         }
-        // if the song has ended
+        // if the song has endeed
         else if (current >= this.duration)
         {
-            if (this.loop && this.currentLoopCount > 0)
+            if (canLoop)
             {
-                this.currentLoopCount--;
+                // loop
+                if (this.loopCount !== Infinity)
+                {
+                    this.loopCount--;
+                    this.post(WorkletSequencerReturnMessageType.loopCountChange, this.loopCount);
+                }
                 this.setTimeTicks(this.midiData.loop.start);
                 return;
             }
+            // stop the playback
             this.eventIndex[trackIndex]--;
             this.pause(true);
             if (this.songs.length > 1)

package/sequencer/worklet_sequencer/sequencer_message.js

@@ -7,7 +7,7 @@
  * @property {number} setTime                  - 4 -> time<number>
  * @property {number} changeMIDIMessageSending - 5 -> sendMIDIMessages<boolean>
  * @property {number} setPlaybackRate          - 6 -> playbackRate<number>
- * @property {number} setLoop                  - 7 -> loop<boolean>
+ * @property {number} setLoop                  - 7 -> [loop<boolean>, count<number]
  * @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>
@@ -40,5 +40,6 @@ export const WorkletSequencerReturnMessageType = {
     pause: 4,                   // no data
     getMIDI: 5,                 // midiData<MIDI>
     midiError: 6,               // errorMSG<string>
-    tempoChange: 7              // newTempoBPM<number>
+    metaEvent: 7,               // [messageType<number>, messageData<Uint8Array>]
+    loopCountChange: 8          // newLoopCount<number>
 };

package/sequencer/worklet_sequencer/song_control.js

@@ -65,8 +65,6 @@ export function loadNewSequence(parsedMidi, autoPlay = true)
      */
     this.midiData = parsedMidi;
     
-    this.currentLoopCount = this.loopCount;
-    
     // check for embedded soundfont
     if (this.midiData.embeddedSoundFont !== undefined)
     {

package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -33,7 +33,6 @@ class WorkletSequencer
         this.sendMIDIMessages = false;
         
         this.loopCount = Infinity;
-        this.currentLoopCount = this.loopCount;
         
         // event's number in this.events
         /**

package/soundfont/dls/dls_soundfont.js

@@ -136,13 +136,17 @@ class DLSSoundFont extends BasicSoundFont
      * @param chunk {RiffChunk}
      * @param expected {string}
      */
-    verifyHeader(chunk, expected)
+    verifyHeader(chunk, ...expected)
     {
-        if (chunk.header.toLowerCase() !== expected.toLowerCase())
+        for (const expect of expected)
         {
-            SpessaSynthGroupEnd();
-            this.parsingError(`Invalid DLS chunk header! Expected "${expected.toLowerCase()}" got "${chunk.header.toLowerCase()}"`);
+            if (chunk.header.toLowerCase() === expect.toLowerCase())
+            {
+                return;
+            }
         }
+        SpessaSynthGroupEnd();
+        this.parsingError(`Invalid DLS chunk header! Expected "${expected.toString()}" got "${chunk.header.toLowerCase()}"`);
     }
     
     /**

package/soundfont/dls/read_lart.js

@@ -14,7 +14,7 @@ export function readLart(lartChunk, lar2Chunk, zone)
         while (lartChunk.chunkData.currentIndex < lartChunk.chunkData.length)
         {
             const art1 = readRIFFChunk(lartChunk.chunkData);
-            this.verifyHeader(art1, "art1");
+            this.verifyHeader(art1, "art1", "art2");
             const modsAndGens = readArticulation(art1, true);
             zone.generators.push(...modsAndGens.generators);
             zone.modulators.push(...modsAndGens.modulators);
@@ -26,7 +26,7 @@ export function readLart(lartChunk, lar2Chunk, zone)
         while (lar2Chunk.chunkData.currentIndex < lar2Chunk.chunkData.length)
         {
             const art2 = readRIFFChunk(lar2Chunk.chunkData);
-            this.verifyHeader(art2, "art2");
+            this.verifyHeader(art2, "art2", "art1");
             const modsAndGens = readArticulation(art2, false);
             zone.generators.push(...modsAndGens.generators);
             zone.modulators.push(...modsAndGens.modulators);