spessasynth_lib 3.25.22 → 3.26.0

package/midi/midi_builder.js

@@ -1,202 +0,0 @@
-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/midi/midi_data.js

@@ -1,63 +0,0 @@
-import { MIDISequenceData } from "./midi_sequence.js";
-
-/**
- * A simplified version of the MIDI, accessible at all times from the Sequencer.
- * Use getMIDI() to get the actual sequence.
- * This class contains all properties that MIDI does, except for tracks and the embedded soundfont.
- */
-export class MIDIData extends MIDISequenceData
-{
-    
-    /**
-     * A boolean indicating if the MIDI file contains an embedded soundfont.
-     * If the embedded soundfont is undefined, this will be false.
-     * @type {boolean}
-     */
-    isEmbedded = false;
-    
-    /**
-     * Constructor that copies data from a BasicMIDI instance.
-     * @param {BasicMIDI} midi - The BasicMIDI instance to copy data from.
-     */
-    constructor(midi)
-    {
-        super();
-        this._copyFromSequence(midi);
-        
-        // Set isEmbedded based on the presence of an embeddedSoundFont
-        this.isEmbedded = midi.embeddedSoundFont !== undefined;
-    }
-}
-
-
-/**
- * Temporary MIDI data used when the MIDI is not loaded.
- * @type {MIDIData}
- */
-export const DUMMY_MIDI_DATA = {
-    duration: 99999,
-    firstNoteOn: 0,
-    loop: {
-        start: 0,
-        end: 123456
-    },
-    
-    lastVoiceEventTick: 123456,
-    lyrics: [],
-    copyright: "",
-    midiPorts: [],
-    midiPortChannelOffsets: [],
-    tracksAmount: 0,
-    tempoChanges: [{ ticks: 0, tempo: 120 }],
-    fileName: "NOT_LOADED.mid",
-    midiName: "Loading...",
-    rawMidiName: new Uint8Array([76, 111, 97, 100, 105, 110, 103, 46, 46, 46]), // "Loading..."
-    usedChannelsOnTrack: [],
-    timeDivision: 0,
-    keyRange: { min: 0, max: 127 },
-    isEmbedded: false,
-    RMIDInfo: {},
-    bankOffset: 0,
-    midiNameUsesFileName: false,
-    format: 0
-};

package/midi/midi_loader.js

@@ -1,324 +0,0 @@
-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 };