spessasynth_core 1.1.3 → 1.1.5

package/src/midi/midi_builder.js

@@ -0,0 +1,202 @@
+import { BasicMIDI } from "./basic_midi.js";
+import { messageTypes, MIDIMessage } from "./midi_message.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
+import { SpessaSynthWarn } from "../utils/loggin.js";
+
+/**
+ * A class that helps to build a MIDI file from scratch.
+ */
+export class MIDIBuilder extends BasicMIDI
+{
+    /**
+     * @param name {string} The MIDI's name
+     * @param timeDivision {number} the file's time division
+     * @param initialTempo {number} the file's initial tempo
+     */
+    constructor(name, timeDivision = 480, initialTempo = 120)
+    {
+        super();
+        this.timeDivision = timeDivision;
+        this.midiName = name;
+        this.encoder = new TextEncoder();
+        this.rawMidiName = this.encoder.encode(name);
+        
+        // create the first track with the file name
+        this.addNewTrack(name);
+        this.addSetTempo(0, initialTempo);
+    }
+    
+    /**
+     * Adds a new Set Tempo event
+     * @param ticks {number} the tick number of the event
+     * @param tempo {number} the tempo in beats per minute (BPM)
+     */
+    addSetTempo(ticks, tempo)
+    {
+        const array = new IndexedByteArray(3);
+        
+        tempo = 60000000 / tempo;
+        
+        // Extract each byte in big-endian order
+        array[0] = (tempo >> 16) & 0xFF;
+        array[1] = (tempo >> 8) & 0xFF;
+        array[2] = tempo & 0xFF;
+        
+        this.addEvent(ticks, 0, messageTypes.setTempo, array);
+    }
+    
+    /**
+     * Adds a new MIDI track
+     * @param name {string} the new track's name
+     * @param port {number} the new track's port
+     */
+    addNewTrack(name, port = 0)
+    {
+        this.tracksAmount++;
+        if (this.tracksAmount > 1)
+        {
+            this.format = 1;
+        }
+        this.tracks.push([]);
+        this.tracks[this.tracksAmount - 1].push(
+            new MIDIMessage(0, messageTypes.endOfTrack, new IndexedByteArray(0))
+        );
+        this.addEvent(0, this.tracksAmount - 1, messageTypes.trackName, this.encoder.encode(name));
+        this.addEvent(0, this.tracksAmount - 1, messageTypes.midiPort, [port]);
+    }
+    
+    /**
+     * Adds a new MIDI Event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param event {number} the MIDI event number
+     * @param eventData {Uint8Array|Iterable<number>} the raw event data
+     */
+    addEvent(ticks, track, event, eventData)
+    {
+        if (!this.tracks[track])
+        {
+            throw new Error(`Track ${track} does not exist. Add it via addTrack method.`);
+        }
+        if (event === messageTypes.endOfTrack)
+        {
+            SpessaSynthWarn(
+                "The EndOfTrack is added automatically and does not influence the duration. Consider adding a voice event instead.");
+            return;
+        }
+        // remove the end of track
+        this.tracks[track].pop();
+        this.tracks[track].push(new MIDIMessage(
+            ticks,
+            event,
+            new IndexedByteArray(eventData)
+        ));
+        // add the end of track
+        this.tracks[track].push(new MIDIMessage(
+            ticks,
+            messageTypes.endOfTrack,
+            new IndexedByteArray(0)
+        ));
+    }
+    
+    /**
+     * Adds a new Note On event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the keypress
+     * @param velocity {number} the velocity of the keypress
+     */
+    addNoteOn(ticks, track, channel, midiNote, velocity)
+    {
+        channel %= 16;
+        midiNote %= 128;
+        velocity %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.noteOn | channel,
+            [midiNote, velocity]
+        );
+    }
+    
+    /**
+     * Adds a new Note Off event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the key release
+     */
+    addNoteOff(ticks, track, channel, midiNote)
+    {
+        channel %= 16;
+        midiNote %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.noteOff | channel,
+            [midiNote, 64]
+        );
+    }
+    
+    /**
+     * Adds a new Program Change event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param programNumber {number} the MIDI program to use
+     */
+    addProgramChange(ticks, track, channel, programNumber)
+    {
+        channel %= 16;
+        programNumber %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.programChange | channel,
+            [programNumber]
+        );
+    }
+    
+    /**
+     * Adds a new Controller Change event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param controllerNumber {number} the MIDI CC to use
+     * @param controllerValue {number} the new CC value
+     */
+    addControllerChange(ticks, track, channel, controllerNumber, controllerValue)
+    {
+        channel %= 16;
+        controllerNumber %= 128;
+        controllerValue %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.controllerChange | channel,
+            [controllerNumber, controllerValue]
+        );
+    }
+    
+    /**
+     * Adds a new Pitch Wheel event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track to use
+     * @param channel {number} the channel to use
+     * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+     * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+     */
+    addPitchWheel(ticks, track, channel, MSB, LSB)
+    {
+        channel %= 16;
+        MSB %= 128;
+        LSB %= 128;
+        this.addEvent(
+            ticks,
+            track,
+            messageTypes.pitchBend | channel,
+            [LSB, MSB]
+        );
+    }
+}

package/src/midi/midi_loader.js

@@ -0,0 +1,324 @@
+import { dataBytesAmount, getChannel, MIDIMessage } from "./midi_message.js";
+import { IndexedByteArray } from "../utils/indexed_array.js";
+import { consoleColors } 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 { readLittleEndian } from "../utils/byte_functions/little_endian.js";
+import { RMIDINFOChunks } from "./midi_tools/rmidi_writer.js";
+import { BasicMIDI } from "./basic_midi.js";
+import { loadXMF } from "./xmf_loader.js";
+
+/**
+ * midi_loader.js
+ * purpose:
+ * parses a midi file for the seqyencer,
+ * including things like marker or CC 2/4 loop detection, copyright detection, etc.
+ */
+
+/**
+ * The MIDI class is a MIDI file parser that reads a MIDI file and extracts all the necessary information from it.
+ * Supported formats are .mid and .rmi files.
+ */
+class MIDI extends BasicMIDI
+{
+    /**
+     * Parses a given midi file
+     * @param arrayBuffer {ArrayBuffer}
+     * @param fileName {string} optional, replaces the decoded title if empty
+     */
+    constructor(arrayBuffer, fileName = "")
+    {
+        super();
+        SpessaSynthGroupCollapsed(`%cParsing MIDI File...`, consoleColors.info);
+        this.fileName = fileName;
+        const binaryData = new IndexedByteArray(arrayBuffer);
+        let fileByteArray;
+        
+        // check for rmid
+        const initialString = readBytesAsString(binaryData, 4);
+        binaryData.currentIndex -= 4;
+        if (initialString === "RIFF")
+        {
+            // possibly an RMID file (https://github.com/spessasus/sf2-rmidi-specification#readme)
+            // skip size
+            binaryData.currentIndex += 8;
+            const rmid = readBytesAsString(binaryData, 4, undefined, false);
+            if (rmid !== "RMID")
+            {
+                SpessaSynthGroupEnd();
+                throw new SyntaxError(`Invalid RMIDI Header! Expected "RMID", got "${rmid}"`);
+            }
+            const riff = readRIFFChunk(binaryData);
+            if (riff.header !== "data")
+            {
+                SpessaSynthGroupEnd();
+                throw new SyntaxError(`Invalid RMIDI Chunk header! Expected "data", got "${rmid}"`);
+            }
+            // this is a rmid, load the midi into an array for parsing
+            fileByteArray = riff.chunkData;
+            
+            // keep loading chunks until we get the "SFBK" header
+            while (binaryData.currentIndex <= binaryData.length)
+            {
+                const startIndex = binaryData.currentIndex;
+                const currentChunk = readRIFFChunk(binaryData, true);
+                if (currentChunk.header === "RIFF")
+                {
+                    const type = readBytesAsString(currentChunk.chunkData, 4).toLowerCase();
+                    if (type === "sfbk" || type === "sfpk" || type === "dls ")
+                    {
+                        SpessaSynthInfo("%cFound embedded soundfont!", consoleColors.recognized);
+                        this.embeddedSoundFont = binaryData.slice(startIndex, startIndex + currentChunk.size).buffer;
+                    }
+                    else
+                    {
+                        SpessaSynthWarn(`Unknown RIFF chunk: "${type}"`);
+                    }
+                    if (type === "dls ")
+                    {
+                        // Assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                        this.isDLSRMIDI = true;
+                    }
+                }
+                else if (currentChunk.header === "LIST")
+                {
+                    const type = readBytesAsString(currentChunk.chunkData, 4);
+                    if (type === "INFO")
+                    {
+                        SpessaSynthInfo("%cFound RMIDI INFO chunk!", consoleColors.recognized);
+                        this.RMIDInfo = {};
+                        while (currentChunk.chunkData.currentIndex <= currentChunk.size)
+                        {
+                            const infoChunk = readRIFFChunk(currentChunk.chunkData, true);
+                            this.RMIDInfo[infoChunk.header] = infoChunk.chunkData;
+                        }
+                        if (this.RMIDInfo["ICOP"])
+                        {
+                            // special case, overwrites the copyright components array
+                            this.copyright = readBytesAsString(
+                                this.RMIDInfo["ICOP"],
+                                this.RMIDInfo["ICOP"].length,
+                                undefined,
+                                false
+                            ).replaceAll("\n", " ");
+                        }
+                        if (this.RMIDInfo["INAM"])
+                        {
+                            this.rawMidiName = this.RMIDInfo[RMIDINFOChunks.name];
+                            // noinspection JSCheckFunctionSignatures
+                            this.midiName = readBytesAsString(
+                                this.rawMidiName,
+                                this.rawMidiName.length,
+                                undefined,
+                                false
+                            ).replaceAll("\n", " ");
+                        }
+                        // these can be used interchangeably
+                        if (this.RMIDInfo["IALB"] && !this.RMIDInfo["IPRD"])
+                        {
+                            this.RMIDInfo["IPRD"] = this.RMIDInfo["IALB"];
+                        }
+                        if (this.RMIDInfo["IPRD"] && !this.RMIDInfo["IALB"])
+                        {
+                            this.RMIDInfo["IALB"] = this.RMIDInfo["IPRD"];
+                        }
+                        this.bankOffset = 1; // defaults to 1
+                        if (this.RMIDInfo[RMIDINFOChunks.bankOffset])
+                        {
+                            this.bankOffset = readLittleEndian(this.RMIDInfo[RMIDINFOChunks.bankOffset], 2);
+                        }
+                    }
+                }
+            }
+            
+            if (this.isDLSRMIDI)
+            {
+                // Assume bank offset of 0 by default. If we find any bank selects, then the offset is 1.
+                this.bankOffset = 0;
+            }
+            
+            // if no embedded bank, assume 0
+            if (this.embeddedSoundFont === undefined)
+            {
+                this.bankOffset = 0;
+            }
+        }
+        else if (initialString === "XMF_")
+        {
+            // XMF file
+            fileByteArray = loadXMF(this, binaryData);
+        }
+        else
+        {
+            fileByteArray = binaryData;
+        }
+        const headerChunk = this._readMIDIChunk(fileByteArray);
+        if (headerChunk.type !== "MThd")
+        {
+            SpessaSynthGroupEnd();
+            throw new SyntaxError(`Invalid MIDI Header! Expected "MThd", got "${headerChunk.type}"`);
+        }
+        
+        if (headerChunk.size !== 6)
+        {
+            SpessaSynthGroupEnd();
+            throw new RangeError(`Invalid MIDI header chunk size! Expected 6, got ${headerChunk.size}`);
+        }
+        
+        // format
+        this.format = readBytesAsUintBigEndian(headerChunk.data, 2);
+        // tracks count
+        this.tracksAmount = readBytesAsUintBigEndian(headerChunk.data, 2);
+        // time division
+        this.timeDivision = readBytesAsUintBigEndian(headerChunk.data, 2);
+        // read all the tracks
+        for (let i = 0; i < this.tracksAmount; i++)
+        {
+            /**
+             * @type {MIDIMessage[]}
+             */
+            const track = [];
+            const trackChunk = this._readMIDIChunk(fileByteArray);
+            
+            if (trackChunk.type !== "MTrk")
+            {
+                SpessaSynthGroupEnd();
+                throw new SyntaxError(`Invalid track header! Expected "MTrk" got "${trackChunk.type}"`);
+            }
+            
+            
+            /**
+             * MIDI running byte
+             * @type {number}
+             */
+            let runningByte = undefined;
+            
+            let totalTicks = 0;
+            // format 2 plays sequentially
+            if (this.format === 2 && i > 0)
+            {
+                totalTicks += this.tracks[i - 1][this.tracks[i - 1].length - 1].ticks;
+            }
+            // loop until we reach the end of track
+            while (trackChunk.data.currentIndex < trackChunk.size)
+            {
+                totalTicks += readVariableLengthQuantity(trackChunk.data);
+                
+                // check if the status byte is valid (IE. larger than 127)
+                const statusByteCheck = trackChunk.data[trackChunk.data.currentIndex];
+                
+                let statusByte;
+                // if we have a running byte and the status byte isn't valid
+                if (runningByte !== undefined && statusByteCheck < 0x80)
+                {
+                    statusByte = runningByte;
+                }
+                else
+                { // noinspection PointlessBooleanExpressionJS
+                    if (runningByte === undefined && statusByteCheck < 0x80)
+                    {
+                        // if we don't have a running byte and the status byte isn't valid, it's an error.
+                        SpessaSynthGroupEnd();
+                        throw new SyntaxError(`Unexpected byte with no running byte. (${statusByteCheck})`);
+                    }
+                    else
+                    {
+                        // if the status byte is valid, use that
+                        statusByte = trackChunk.data[trackChunk.data.currentIndex++];
+                    }
+                }
+                const statusByteChannel = getChannel(statusByte);
+                
+                let eventDataLength;
+                
+                // determine the message's length;
+                switch (statusByteChannel)
+                {
+                    case -1:
+                        // system common/realtime (no length)
+                        eventDataLength = 0;
+                        break;
+                    
+                    case -2:
+                        // meta (the next is the actual status byte)
+                        statusByte = trackChunk.data[trackChunk.data.currentIndex++];
+                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
+                        break;
+                    
+                    case -3:
+                        // sysex
+                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
+                        break;
+                    
+                    default:
+                        // voice message
+                        // gets the midi message length
+                        eventDataLength = dataBytesAmount[statusByte >> 4];
+                        // save the status byte
+                        runningByte = statusByte;
+                        break;
+                }
+                
+                // put the event data into the array
+                const eventData = new IndexedByteArray(eventDataLength);
+                eventData.set(trackChunk.data.slice(
+                    trackChunk.data.currentIndex,
+                    trackChunk.data.currentIndex + eventDataLength
+                ), 0);
+                const event = new MIDIMessage(totalTicks, statusByte, eventData);
+                track.push(event);
+                // advance the track chunk
+                trackChunk.data.currentIndex += eventDataLength;
+            }
+            this.tracks.push(track);
+            
+            SpessaSynthInfo(
+                `%cParsed %c${this.tracks.length}%c / %c${this.tracksAmount}`,
+                consoleColors.info,
+                consoleColors.value,
+                consoleColors.info,
+                consoleColors.value
+            );
+        }
+        
+        SpessaSynthInfo(
+            `%cAll tracks parsed correctly!`,
+            consoleColors.recognized
+        );
+        // parse the events
+        this._parseInternal();
+        SpessaSynthGroupEnd();
+        SpessaSynthInfo(
+            `%cMIDI file parsed. Total tick time: %c${this.lastVoiceEventTick}%c, total seconds time: %c${this.duration}`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.recognized
+        );
+    }
+    
+    /**
+     * @param fileByteArray {IndexedByteArray}
+     * @returns {{type: string, size: number, data: IndexedByteArray}}
+     * @private
+     */
+    _readMIDIChunk(fileByteArray)
+    {
+        const chunk = {};
+        // type
+        chunk.type = readBytesAsString(fileByteArray, 4);
+        // size
+        chunk.size = readBytesAsUintBigEndian(fileByteArray, 4);
+        // data
+        chunk.data = new IndexedByteArray(chunk.size);
+        const dataSlice = fileByteArray.slice(fileByteArray.currentIndex, fileByteArray.currentIndex + chunk.size);
+        chunk.data.set(dataSlice, 0);
+        fileByteArray.currentIndex += chunk.size;
+        return chunk;
+    }
+}
+
+export { MIDI };