spessasynth_lib 3.23.13 → 3.23.14

package/@types/midi_parser/midi_data.d.ts

@@ -21,6 +21,7 @@ export class MidiData extends MIDISequenceData {
     copyright: any;
     tracksAmount: any;
     lyrics: any;
+    lyricsTicks: any;
     firstNoteOn: any;
     keyRange: any;
     lastVoiceEventTick: any;
@@ -35,6 +36,7 @@ export class MidiData extends MIDISequenceData {
     format: any;
     RMIDInfo: any;
     bankOffset: any;
+    isKaraokeFile: any;
 }
 /**
  * Temporary MIDI data used when the MIDI is not loaded.

package/@types/midi_parser/midi_sequence.d.ts

@@ -40,6 +40,11 @@ export class MIDISequenceData {
      * @type {Uint8Array[]}
      */
     lyrics: Uint8Array[];
+    /**
+     * An array of tick positions where lyrics events occur in the sequence.
+     * @type {number[]}
+     */
+    lyricsTicks: number[];
     /**
      * The tick position of the first note-on event in the MIDI sequence.
      * @type {number}
@@ -121,4 +126,10 @@ export class MIDISequenceData {
      * @type {number}
      */
     bankOffset: number;
+    /**
+     * If the MIDI file is a Soft Karaoke file (.kar), this flag is set to true.
+     * https://www.mixagesoftware.com/en/midikit/help/HTML/karaoke_formats.html
+     * @type {boolean}
+     */
+    isKaraokeFile: boolean;
 }

package/@types/utils/other.d.ts

@@ -23,6 +23,11 @@ export function formatTitle(fileName: string): string;
  * @returns {string}
  */
 export function arrayToHexString(arr: number[]): string;
+/**
+ * @param eventData {Uint8Array}
+ * @returns {Uint8Array}
+ */
+export function sanitizeKarLyrics(eventData: Uint8Array): Uint8Array;
 export namespace consoleColors {
     let warn: string;
     let unrecognized: string;

package/midi_parser/basic_midi.js

@@ -45,10 +45,12 @@ export class BasicMIDI extends MIDISequenceData
         m.loop = { ...mid.loop }; // Deep copy of loop
         m.format = mid.format;
         m.bankOffset = mid.bankOffset;
+        m.isKaraokeFile = mid.isKaraokeFile;
         
         // Copying arrays
         m.tempoChanges = [...mid.tempoChanges]; // Shallow copy
         m.lyrics = mid.lyrics.map(arr => new Uint8Array(arr)); // Deep copy of each binary chunk
+        m.lyricsTicks = [...mid.lyricsTicks]; // Shallow copy
         m.midiPorts = [...mid.midiPorts]; // Shallow copy
         m.midiPortChannelOffsets = [...mid.midiPortChannelOffsets]; // Shallow copy
         m.usedChannelsOnTrack = mid.usedChannelsOnTrack.map(set => new Set(set)); // Deep copy

package/midi_parser/midi_data.js

@@ -28,6 +28,7 @@ export class MidiData extends MIDISequenceData
         this.copyright = midi.copyright;
         this.tracksAmount = midi.tracksAmount;
         this.lyrics = midi.lyrics;
+        this.lyricsTicks = midi.lyricsTicks;
         this.firstNoteOn = midi.firstNoteOn;
         this.keyRange = midi.keyRange;
         this.lastVoiceEventTick = midi.lastVoiceEventTick;
@@ -42,6 +43,7 @@ export class MidiData extends MIDISequenceData
         this.format = midi.format;
         this.RMIDInfo = midi.RMIDInfo;
         this.bankOffset = midi.bankOffset;
+        this.isKaraokeFile = midi.isKaraokeFile;
         
         // Set isEmbedded based on the presence of an embeddedSoundFont
         this.isEmbedded = midi.embeddedSoundFont !== undefined;

package/midi_parser/midi_loader.js

@@ -1,11 +1,11 @@
 import { dataBytesAmount, getChannel, messageTypes, MidiMessage } from "./midi_message.js";
 import { IndexedByteArray } from "../utils/indexed_array.js";
-import { consoleColors, formatTitle } from "../utils/other.js";
+import { consoleColors, formatTitle, sanitizeKarLyrics } from "../utils/other.js";
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn } from "../utils/loggin.js";
 import { readRIFFChunk } from "../soundfont/basic_soundfont/riff_chunk.js";
 import { readVariableLengthQuantity } from "../utils/byte_functions/variable_length_quantity.js";
 import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
-import { readBytesAsString } from "../utils/byte_functions/string.js";
+import { getStringBytes, readBytesAsString } from "../utils/byte_functions/string.js";
 import { readLittleEndian } from "../utils/byte_functions/little_endian.js";
 import { RMIDINFOChunks } from "./rmidi_writer.js";
 import { BasicMIDI, MIDIticksToSeconds } from "./basic_midi.js";
@@ -193,6 +193,13 @@ class MIDI extends BasicMIDI
         let loopStart = null;
         let loopEnd = null;
         
+        /**
+         * For karaoke files, text events starting with @T are considered titles
+         * usually the first one is the title, and the latter are things such as "sequenced by" etc.
+         * @type {boolean}
+         */
+        let karaokeHasTitle = false;
+        
         this.lastVoiceEventTick = 0;
         
         /**
@@ -332,6 +339,7 @@ class MIDI extends BasicMIDI
                 {
                     case -2:
                         // since this is a meta message
+                        const eventText = readBytesAsString(eventData, eventData.length);
                         switch (statusByte)
                         {
                             case messageTypes.setTempo:
@@ -344,7 +352,7 @@ class MIDI extends BasicMIDI
                             
                             case messageTypes.marker:
                                 // check for loop markers
-                                const text = readBytesAsString(eventData, eventData.length).trim().toLowerCase();
+                                const text = eventText.trim().toLowerCase();
                                 switch (text)
                                 {
                                     default:
@@ -384,7 +392,71 @@ class MIDI extends BasicMIDI
                                 break;
                             
                             case messageTypes.lyric:
-                                this.lyrics.push(eventData);
+                                
+                                // note here: .kar files sometimes just use...
+                                // lyrics instead of text because why not (of course)
+                                // perform the same check for @KMIDI KARAOKE FILE
+                                if (eventText.trim() === "@KMIDI KARAOKE FILE")
+                                {
+                                    this.isKaraokeFile = true;
+                                    SpessaSynthInfo("%cKaraoke MIDI detected!", consoleColors.recognized);
+                                }
+                                
+                                if (this.isKaraokeFile)
+                                {
+                                    // replace the type of the message with text
+                                    message.messageStatusByte = messageTypes.text;
+                                    statusByte = messageTypes.text;
+                                }
+                                else
+                                {
+                                    // add lyrics like a regular midi file
+                                    this.lyrics.push(eventData);
+                                    this.lyricsTicks.push(totalTicks);
+                                    break;
+                                }
+                            
+                            // kar: treat the same as text
+                            // fallthrough
+                            case messageTypes.text:
+                                // possibly Soft Karaoke MIDI file
+                                // it has a text event at the start of the file
+                                // "@KMIDI KARAOKE FILE"
+                                const checkedText = eventText.trim();
+                                if (checkedText === "@KMIDI KARAOKE FILE")
+                                {
+                                    this.isKaraokeFile = true;
+                                    
+                                    SpessaSynthInfo("%cKaraoke MIDI detected!", consoleColors.recognized);
+                                }
+                                else if (this.isKaraokeFile)
+                                {
+                                    // check for @T (title)
+                                    // or @A because it is a title too sometimes??? idk it's weird
+                                    if (checkedText.startsWith("@T") || checkedText.startsWith("@A"))
+                                    {
+                                        if (!karaokeHasTitle)
+                                        {
+                                            this.midiName = checkedText.substring(2).trim();
+                                            karaokeHasTitle = true;
+                                            nameDetected = true;
+                                            // encode to rawMidiName
+                                            this.rawMidiName = getStringBytes(this.midiName);
+                                        }
+                                        else
+                                        {
+                                            // append to copyright
+                                            this.copyright += checkedText.substring(2).trim() + " \n";
+                                        }
+                                    }
+                                    else if (checkedText[0] !== "@")
+                                    {
+                                        // non @: the lyrics
+                                        this.lyrics.push(sanitizeKarLyrics(eventData));
+                                        this.lyricsTicks.push(totalTicks);
+                                    }
+                                }
+                                break;
                         }
                         break;
                     
@@ -612,6 +684,38 @@ class MIDI extends BasicMIDI
                 consoleColors.recognized
             );
         }
+        
+        // lyrics fix:
+        // sometimes, all lyrics events lack spaces at the start or end of the lyric
+        // then, and only then, add space at the end of each lyric
+        // space ASCII is 32
+        let lacksSpaces = true;
+        for (const lyric of this.lyrics)
+        {
+            if (lyric[0] === 32 || lyric[lyric.length - 1] === 32)
+            {
+                lacksSpaces = false;
+                break;
+            }
+        }
+        
+        if (lacksSpaces)
+        {
+            this.lyrics = this.lyrics.map(lyric =>
+            {
+                // one exception: hyphens at the end. Don't add a space to them
+                if (lyric[lyric.length - 1] === 45)
+                {
+                    return lyric;
+                }
+                const withSpaces = new Uint8Array(lyric.length + 1);
+                withSpaces.set(lyric, 0);
+                withSpaces[lyric.length] = 32;
+                return withSpaces;
+            });
+        }
+        
+        
         // reverse the tempo changes
         this.tempoChanges.reverse();
         

package/midi_parser/midi_sequence.js

@@ -44,6 +44,12 @@ export class MIDISequenceData
      */
     lyrics = [];
     
+    /**
+     * An array of tick positions where lyrics events occur in the sequence.
+     * @type {number[]}
+     */
+    lyricsTicks = [];
+    
     /**
      * The tick position of the first note-on event in the MIDI sequence.
      * @type {number}
@@ -130,4 +136,11 @@ export class MIDISequenceData
      * @type {number}
      */
     bankOffset = 0;
+    
+    /**
+     * If the MIDI file is a Soft Karaoke file (.kar), this flag is set to true.
+     * https://www.mixagesoftware.com/en/midikit/help/HTML/karaoke_formats.html
+     * @type {boolean}
+     */
+    isKaraokeFile = false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.23.13",
+  "version": "3.23.14",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/sequencer/worklet_sequencer/process_event.js

@@ -121,13 +121,33 @@ export function _processEvent(event, trackIndex)
             if (statusByteData.status === messageTypes.lyric)
             {
                 lyricsIndex = Math.min(
-                    this.midiData.lyrics.indexOf(event.messageData) + 1,
+                    this.midiData.lyricsTicks.indexOf(event.ticks) + 1,
                     this.midiData.lyrics.length - 1
                 );
             }
+            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
+            // 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
+            if (this.midiData.isKaraokeFile && (
+                statusByteData.status === messageTypes.text ||
+                statusByteData.status === messageTypes.lyric
+            ))
+            {
+                lyricsIndex = Math.min(
+                    this.midiData.lyricsTicks.indexOf(event.ticks) + 1,
+                    this.midiData.lyricsTicks.length
+                );
+                sentStatus = messageTypes.lyric;
+            }
             this.post(
                 WorkletSequencerReturnMessageType.textEvent,
-                [event.messageData, statusByteData.status, lyricsIndex]
+                [event.messageData, sentStatus, lyricsIndex]
             );
             break;