spessasynth_lib 3.23.13 → 3.24.0

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/synthetizer/synth_event_handler.d.ts

@@ -3,62 +3,68 @@
  * purpose: manages the synthesizer's event system, calling assinged functions when synthesizer requests dispatching the event
  */
 /**
- *
- * @typedef {{
- *     midiNote: number,
- *     channel: number,
- *     velocity: number
- * }} NoteOnCallback
- *
- * @typedef {{
- *     midiNote: number,
- *     channel: number
- * }} NoteOffCallback
- *
- * @typedef {{
- *     channel: number,
- *     isDrumChannel: boolean
- * }} DrumChangeCallback
- *
- * @typedef {{
- *     channel: number,
- *     program: number,
- *     bank: number,
- *     userCalled: boolean
- * }} ProgramChangeCallback
- *
- * @typedef {{
- *     channel: number,
- *     controllerNumber: number,
- *     controllerValue: number
- * }} ControllerChangeCallback
- *
- * @typedef {{
- *     channel:number,
- *     isMuted: boolean
- * }} MuteChannelCallback
- *
- * @typedef {{
- *     presetName: string,
- *     bank: number,
- *     program: number
- * }[]} PresetListChangeCallback
- *
- *
- * @typedef {{
- *     channel: number,
- *     MSB: number,
- *     LSB: number
- * }} PitchWheelCallback
- *
- * @typedef {{
- *     channel: number,
- *     pressure: number
- * }} ChannelPressureCallback
- *
- * @typedef {string} SoundfontErrorCallback
- *
- *
+ * @typedef {Object} NoteOnCallback
+ * @property {number} midiNote - The MIDI note number.
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} velocity - The velocity of the note.
+ */
+/**
+ * @typedef {Object} NoteOffCallback
+ * @property {number} midiNote - The MIDI note number.
+ * @property {number} channel - The MIDI channel number.
+ */
+/**
+ * @typedef {Object} DrumChangeCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {boolean} isDrumChannel - Indicates if the channel is a drum channel.
+ */
+/**
+ * @typedef {Object} ProgramChangeCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} program - The program number.
+ * @property {number} bank - The bank number.
+ * @property {boolean} userCalled - Indicates if the change was user-initiated.
+ */
+/**
+ * @typedef {Object} ControllerChangeCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} controllerNumber - The controller number.
+ * @property {number} controllerValue - The value of the controller.
+ */
+/**
+ * @typedef {Object} MuteChannelCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {boolean} isMuted - Indicates if the channel is muted.
+ */
+/**
+ * @typedef {Object} PresetListChangeCallbackSingle
+ * @property {string} presetName - The name of the preset.
+ * @property {number} bank - The bank number.
+ * @property {number} program - The program number.
+ */
+/**
+ * @typedef {PresetListChangeCallbackSingle[]} PresetListChangeCallback - A list of preset objects.
+ */
+/**
+ * @typedef {Object} SynthDisplayCallback
+ * @property {Uint8Array} displayData - The data to display.
+ * @property {SynthDisplayType} displayType - The type of display.
+ */
+/**
+ * @typedef {Object} PitchWheelCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} MSB - The most significant byte of the pitch wheel value.
+ * @property {number} LSB - The least significant byte of the pitch wheel value.
+ */
+/**
+ * @typedef {Object} ChannelPressureCallback
+ * @property {number} channel - The MIDI channel number.
+ * @property {number} pressure - The pressure value.
+ */
+/**
+ * @typedef {Error} SoundfontErrorCallback - The error message for soundfont errors.
+ */
+/**
  * @typedef {
  *     NoteOnCallback |
  *     NoteOffCallback |
@@ -70,6 +76,7 @@
  *     PitchWheelCallback |
  *     SoundfontErrorCallback |
  *     ChannelPressureCallback |
+ *     SynthDisplayCallback |
  *     undefined
  * } EventCallbackData
  */
@@ -88,7 +95,8 @@
  * "mutechannel"|
  * "presetlistchange"|
  * "allcontrollerreset"|
- * "soundfonterror"} EventTypes
+ * "soundfonterror"|
+ * "synthdisplay"} EventTypes
  */
 export class EventHandler {
     /**
@@ -122,45 +130,134 @@ export class EventHandler {
     callEvent(name: EventTypes, eventData: EventCallbackData): void;
 }
 export type NoteOnCallback = {
+    /**
+     * - The MIDI note number.
+     */
     midiNote: number;
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
+    /**
+     * - The velocity of the note.
+     */
     velocity: number;
 };
 export type NoteOffCallback = {
+    /**
+     * - The MIDI note number.
+     */
     midiNote: number;
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
 };
 export type DrumChangeCallback = {
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
+    /**
+     * - Indicates if the channel is a drum channel.
+     */
     isDrumChannel: boolean;
 };
 export type ProgramChangeCallback = {
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
+    /**
+     * - The program number.
+     */
     program: number;
+    /**
+     * - The bank number.
+     */
     bank: number;
+    /**
+     * - Indicates if the change was user-initiated.
+     */
     userCalled: boolean;
 };
 export type ControllerChangeCallback = {
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
+    /**
+     * - The controller number.
+     */
     controllerNumber: number;
+    /**
+     * - The value of the controller.
+     */
     controllerValue: number;
 };
 export type MuteChannelCallback = {
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
+    /**
+     * - Indicates if the channel is muted.
+     */
     isMuted: boolean;
 };
-export type PresetListChangeCallback = {
+export type PresetListChangeCallbackSingle = {
+    /**
+     * - The name of the preset.
+     */
     presetName: string;
+    /**
+     * - The bank number.
+     */
     bank: number;
+    /**
+     * - The program number.
+     */
     program: number;
-}[];
+};
+/**
+ * - A list of preset objects.
+ */
+export type PresetListChangeCallback = PresetListChangeCallbackSingle[];
+export type SynthDisplayCallback = {
+    /**
+     * - The data to display.
+     */
+    displayData: Uint8Array;
+    /**
+     * - The type of display.
+     */
+    displayType: SynthDisplayType;
+};
 export type PitchWheelCallback = {
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
+    /**
+     * - The most significant byte of the pitch wheel value.
+     */
     MSB: number;
+    /**
+     * - The least significant byte of the pitch wheel value.
+     */
     LSB: number;
 };
 export type ChannelPressureCallback = {
+    /**
+     * - The MIDI channel number.
+     */
     channel: number;
+    /**
+     * - The pressure value.
+     */
     pressure: number;
 };
-export type SoundfontErrorCallback = string;
+/**
+ * - The error message for soundfont errors.
+ */
+export type SoundfontErrorCallback = Error;

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/README.md

@@ -82,6 +82,7 @@ document.getElementById("button").onclick = async () =>
   - **Easy MIDI editing:** Use [helper functions](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#modifymidi) to modify the song to your needs!
   - **Loop detection:** Automatically detects loops in MIDIs (e.g., from _Touhou Project_)
   - **First note detection:** Skip unnecessary silence at the start by jumping to the first note!
+  - **Lyrics support:** Both regular MIDI and .kar files!
   - **[Write MIDI files from scratch](https://github.com/spessasus/SpessaSynth/wiki/Creating-MIDI-Files)**
   - **Easy saving:** Save with just [one function!](https://github.com/spessasus/SpessaSynth/wiki/Writing-MIDI-Files#writemidifile)
 
@@ -122,7 +123,6 @@ document.getElementById("button").onclick = async () =>
   - **Loop multiple times:** *Render two (or more) loops into the file for seamless transitions!*
   - *That's right, saving as WAV is also [just one function!](https://github.com/spessasus/SpessaSynth/wiki/Writing-Wave-Files#audiobuffertowav)*
 
-
 # License
 
 MIT License, except for the stbvorbis_sync.js in the `externals` folder which is licensed under the Apache-2.0 license.

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,18 +1,15 @@
 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";
 
-
-const GS_TEXT_HEADER = new Uint8Array([0x41, 0x10, 0x45, 0x12, 0x10, 0x00, 0x00]);
-
 /**
  * midi_loader.js
  * purpose: parses a midi file for the seqyencer, including things like marker or CC 2/4 loop detection, copyright detection etc.
@@ -43,6 +40,12 @@ class MIDI extends BasicMIDI
         
         let DLSRMID = false;
         
+        /**
+         * Will be joined with "\n" to form the final string
+         * @type {string[]}
+         */
+        let copyrightComponents = [];
+        
         const initialString = readBytesAsString(binaryData, 4);
         binaryData.currentIndex -= 4;
         if (initialString === "RIFF")
@@ -102,6 +105,7 @@ class MIDI extends BasicMIDI
                         }
                         if (this.RMIDInfo["ICOP"])
                         {
+                            // special case, overwrites the copyright components array
                             copyrightDetected = true;
                             this.copyright = readBytesAsString(
                                 this.RMIDInfo["ICOP"],
@@ -193,6 +197,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;
         
         /**
@@ -235,6 +246,8 @@ class MIDI extends BasicMIDI
                 throw new SyntaxError(`Invalid track header! Expected "MTrk" got "${trackChunk.type}"`);
             }
             
+            let trackHasVoiceMessages = false;
+            
             /**
              * MIDI running byte
              * @type {number}
@@ -332,6 +345,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 +358,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:
@@ -374,44 +388,95 @@ class MIDI extends BasicMIDI
                             case messageTypes.copyright:
                                 if (!copyrightDetected)
                                 {
-                                    this.copyright += readBytesAsString(
+                                    
+                                    eventData.currentIndex = 0;
+                                    copyrightComponents.push(readBytesAsString(
                                         eventData,
                                         eventData.length,
                                         undefined,
                                         false
-                                    ) + "\n";
+                                    ));
                                 }
                                 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
+                                            copyrightComponents.push(checkedText.substring(2).trim());
+                                        }
+                                    }
+                                    else if (checkedText[0] !== "@")
+                                    {
+                                        // non @: the lyrics
+                                        this.lyrics.push(sanitizeKarLyrics(eventData));
+                                        this.lyricsTicks.push(totalTicks);
+                                    }
+                                }
+                                break;
                         }
                         break;
                     
                     case -3:
-                        // since this is a sysex message
-                        // check for embedded copyright (roland SC display sysex) http://www.bandtrax.com.au/sysex.htm
-                        // header goes like this: 41 10 45 12 10 00 00
-                        if (eventData.slice(0, 7).every((n, i) => GS_TEXT_HEADER[i] === n))
-                        {
-                            /**
-                             * @type {IndexedByteArray}
-                             */
-                            const cutText = eventData.slice(7, messageData.length - 3);
-                            const decoded = readBytesAsString(cutText, cutText.length) + "\n";
-                            this.copyright += decoded;
-                            SpessaSynthInfo(
-                                `%cDecoded Roland SC message! %c${decoded}`,
-                                consoleColors.recognized,
-                                consoleColors.value
-                            );
-                        }
+                        // since this is a sysex message, do nothing
                         break;
                     
                     
                     default:
                         // since this is a voice message
                         // check for loop (CC 2/4)
+                        trackHasVoiceMessages = true;
                         if ((statusByte & 0xF0) === messageTypes.controllerChange)
                         {
                             switch (eventData[0])
@@ -450,6 +515,20 @@ class MIDI extends BasicMIDI
             }
             this.tracks.push(track);
             this.usedChannelsOnTrack.push(usedChannels);
+            
+            // if the track has no voice messages, its "track name" event (if it has any)
+            // is some metadata. Add it to copyright
+            if (!trackHasVoiceMessages)
+            {
+                const trackName = track.find(e => e.messageStatusByte === messageTypes.trackName);
+                if (trackName)
+                {
+                    trackName.messageData.currentIndex = 0;
+                    const name = readBytesAsString(trackName.messageData, trackName.messageData.length);
+                    copyrightComponents.push(name);
+                }
+            }
+            
             SpessaSynthInfo(
                 `%cParsed %c${this.tracks.length}%c / %c${this.tracksAmount}`,
                 consoleColors.info,
@@ -569,6 +648,7 @@ class MIDI extends BasicMIDI
                     if (name)
                     {
                         this.rawMidiName = name.messageData;
+                        name.messageData.currentIndex = 0;
                         this.midiName = readBytesAsString(name.messageData, name.messageData.length, undefined, false);
                     }
                 }
@@ -580,11 +660,23 @@ class MIDI extends BasicMIDI
                 if (name)
                 {
                     this.rawMidiName = name.messageData;
+                    name.messageData.currentIndex = 0;
                     this.midiName = readBytesAsString(name.messageData, name.messageData.length, undefined, false);
                 }
             }
         }
         
+        if (!copyrightDetected)
+        {
+            this.copyright = copyrightComponents
+                // trim and group newlines into one
+                .map(c => c.trim().replace(/(\r?\n)+/g, "\n"))
+                // remove empty strings
+                .filter(c => c.length > 0)
+                // join with newlines
+                .join("\n") || "";
+        }
+        
         this.fileName = fileName;
         this.midiName = this.midiName.trim();
         this.midiNameUsesFileName = false;
@@ -612,6 +704,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();