spessasynth_core 1.0.0

package/spessasynth_core/midi_parser/midi_loader.js

@@ -0,0 +1,381 @@
+import { dataBytesAmount, getChannel, messageTypes, MidiMessage } from './midi_message.js'
+import {ShiftableByteArray} from "../utils/shiftable_array.js";
+import {
+    readByte,
+    readBytesAsString,
+    readBytesAsUintBigEndian,
+    readVariableLengthQuantity
+} from "../utils/byte_functions.js";
+import { arrayToHexString, consoleColors, formatTitle } from '../utils/other.js'
+import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from '../utils/loggin.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.
+ */
+export class MIDI{
+    /**
+     * Parses a given midi file
+     * @param arrayBuffer {Buffer}
+     * @param fileName {string} optional, replaces the decoded title if empty
+     */
+    constructor(arrayBuffer, fileName="") {
+        SpessaSynthGroupCollapsed(`%cParsing MIDI File...`, consoleColors.info);
+
+        const fileByteArray = new ShiftableByteArray(arrayBuffer);
+        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 (ignore)
+        readBytesAsUintBigEndian(headerChunk.data, 2);
+        // tracks count
+        this.tracksAmount = readBytesAsUintBigEndian(headerChunk.data, 2);
+        // time division
+        this.timeDivision = readBytesAsUintBigEndian(headerChunk.data, 2);
+
+        const decoder = new TextDecoder('shift-jis');
+
+        // read the copyright
+        this.copyright = "";
+
+        /**
+         * Contains all the tempo changes in the file. (Ordered from last to first)
+         * @type {{
+         *     ticks: number,
+         *     tempo: number
+         * }[]}
+         */
+        this.tempoChanges = [{ticks: 0, tempo: 120}];
+
+        let loopStart = null;
+        let loopEnd = null;
+
+        this.lastVoiceEventTick = 0;
+
+        /**
+         * Midi port numbers for each tracks
+         * @type {number[]}
+         */
+        this.midiPorts = [];
+
+        /**
+         * Read all the tracks
+         * @type {MidiMessage[][]}
+         */
+        this.tracks = [];
+        for(let i = 0; i < this.tracksAmount; i++)
+        {
+            /**
+             * @type {MidiMessage[]}
+             */
+            const track = [];
+            const trackChunk = this.readMIDIChunk(fileByteArray);
+            this.midiPorts.push(0)
+
+            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;
+            // 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 if(!runningByte && 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, just use that
+                    statusByte = readByte(trackChunk.data);
+                }
+                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 = readByte(trackChunk.data);
+                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
+                        break;
+                    case -3:
+                        // sysex
+                        eventDataLength = readVariableLengthQuantity(trackChunk.data);
+                        break;
+                    default:
+                        // voice message
+                        // get the midi message length
+                        if(totalTicks > this.lastVoiceEventTick)
+                        {
+                            this.lastVoiceEventTick = totalTicks;
+                        }
+                        eventDataLength = dataBytesAmount[statusByte >> 4];
+                        break;
+                }
+
+                // put the event data into the array
+                const eventData = new ShiftableByteArray(eventDataLength);
+                const messageData = trackChunk.data.slice(trackChunk.data.currentIndex, trackChunk.data.currentIndex + eventDataLength);
+                trackChunk.data.currentIndex += eventDataLength;
+                eventData.set(messageData, 0);
+
+                runningByte = statusByte;
+
+                const message = new MidiMessage(totalTicks, statusByte, eventData);
+                track.push(message);
+
+                // check for tempo change
+                if(statusByte === messageTypes.setTempo)
+                {
+                    this.tempoChanges.push({
+                        ticks: totalTicks,
+                        tempo: 60000000 / readBytesAsUintBigEndian(messageData, 3)
+                    });
+                }
+                else
+                // check for loop start (Marker "start")
+
+                if(statusByte === messageTypes.marker)
+                {
+                    const text = readBytesAsString(eventData, eventData.length).trim().toLowerCase();
+                    switch (text)
+                    {
+                        default:
+                            break;
+
+                        case "start":
+                        case "loopstart":
+                            loopStart = totalTicks;
+                            break;
+
+                        case "loopend":
+                            loopEnd = totalTicks;
+                    }
+                    eventData.currentIndex = 0;
+
+                }
+                else
+                // check for loop (CC 2/4)
+                if((statusByte & 0xF0) === messageTypes.controllerChange)
+                {
+                    switch(eventData[0])
+                    {
+                        case 2:
+                        case 116:
+                            loopStart = totalTicks;
+                            break;
+
+                        case 4:
+                        case 117:
+                            if(loopEnd === null)
+                            {
+                                loopEnd = totalTicks;
+                            }
+                            else
+                            {
+                                // this controller has occured more than once, this means that it doesn't indicate the loop
+                                loopEnd = 0;
+                            }
+                            break;
+                    }
+                }
+                else
+                // check for midi port
+                if(statusByte === messageTypes.midiPort)
+                {
+                    this.midiPorts[i] = eventData[0];
+                }
+                else
+                // check for copyright
+                if(statusByte === messageTypes.copyright)
+                {
+                    this.copyright += decoder.decode(eventData) + "\n";
+                }
+
+                // check for embedded copyright (roland SC display sysex) http://www.bandtrax.com.au/sysex.htm
+                if(statusByte === messageTypes.systemExclusive)
+                {
+                    // header goes like this: 41 10 45 12 10 00 00
+                    if(arrayToHexString(messageData.slice(0, 7)).trim() === "41 10 45 12 10 00 00")
+                    {
+                        const decoded = decoder.decode(messageData.slice(7, messageData.length - 3)) + "\n";
+                        this.copyright += decoded;
+                        SpessaSynthInfo(`%cDecoded Roland SC message! %c${decoded}`,
+                            consoleColors.recognized,
+                            consoleColors.value)
+                    }
+                }
+            }
+            this.tracks.push(track);
+            SpessaSynthInfo(`%cParsed %c${this.tracks.length}%c / %c${this.tracksAmount}`,
+                consoleColors.info,
+                consoleColors.value,
+                consoleColors.info,
+                consoleColors.value);
+        }
+
+        //this.lastVoiceEventTick = Math.max(...this.tracks.map(track =>
+        //track[track.length - 1].ticks));
+        const firstNoteOns = [];
+        for(const t of this.tracks)
+        {
+            const firstNoteOn = t.find(e => (e.messageStatusByte & 0xF0) === messageTypes.noteOn);
+            if(firstNoteOn)
+            {
+                firstNoteOns.push(firstNoteOn.ticks);
+            }
+        }
+        this.firstNoteOn = Math.min(...firstNoteOns);
+
+        SpessaSynthInfo(`%cMIDI file parsed. Total tick time: %c${this.lastVoiceEventTick}`,
+            consoleColors.info,
+            consoleColors.recognized);
+        SpessaSynthGroupEnd();
+        
+        if(loopStart !== null && loopEnd === null)
+        {
+            // not a loop
+            loopStart = this.firstNoteOn;
+            loopEnd = this.lastVoiceEventTick;
+        }
+        else {
+            if (loopStart === null) {
+                loopStart = this.firstNoteOn;
+            }
+
+            if (loopEnd === null || loopEnd === 0) {
+                loopEnd = this.lastVoiceEventTick;
+            }
+        }
+
+        /**
+         *
+         * @type {{start: number, end: number}}
+         */
+        this.loop = {start: loopStart, end: loopEnd};
+
+        // get track name
+        this.midiName = "";
+
+        // midi name
+        if(this.tracks.length > 1)
+        {
+            // if more than 1 track and the first track has no notes, just find the first trackName in the first track
+            if(this.tracks[0].find(
+                message => message.messageStatusByte >= messageTypes.noteOn
+                &&
+                message.messageStatusByte < messageTypes.systemExclusive
+            ) === undefined)
+            {
+                let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
+                if(name)
+                {
+                    this.midiName = decoder.decode(name.messageData);
+                }
+            }
+        }
+        else
+        {
+            // if only 1 track, find the first "track name" event
+            let name = this.tracks[0].find(message => message.messageStatusByte === messageTypes.trackName);
+            if(name)
+            {
+                this.midiName = decoder.decode(name.messageData);
+            }
+        }
+
+        this.fileName = fileName;
+
+        // if midiName is "", use the file name
+        if(this.midiName.trim().length === 0 && fileName.length > 0)
+        {
+            this.midiName = formatTitle(fileName);
+        }
+
+        // reverse the tempo changes
+        this.tempoChanges.reverse();
+
+        /**
+         * The total playback time, in seconds
+         * @type {number}
+         */
+        this.duration = this._ticksToSeconds(this.lastVoiceEventTick);
+    }
+
+    /**
+     * @param fileByteArray {ShiftableByteArray}
+     * @returns {{type: string, size: number, data: ShiftableByteArray}}
+     */
+    readMIDIChunk(fileByteArray)
+    {
+        const chunk = {};
+        // type
+        chunk.type = readBytesAsString(fileByteArray, 4);
+        // size
+        chunk.size = readBytesAsUintBigEndian(fileByteArray, 4);
+        // data
+        chunk.data = new ShiftableByteArray(chunk.size);
+        const dataSlice = fileByteArray.slice(fileByteArray.currentIndex, fileByteArray.currentIndex + chunk.size);
+        chunk.data.set(dataSlice, 0);
+        fileByteArray.currentIndex += chunk.size;
+        return chunk;
+    }
+
+
+    /**
+     * Coverts ticks to time in seconds
+     * @param ticks {number}
+     * @returns {number}
+     * @private
+     */
+    _ticksToSeconds(ticks)
+    {
+        if (ticks <= 0) {
+            return 0;
+        }
+
+        // find the last tempo change that has occured
+        let tempo = this.tempoChanges.find(v => v.ticks < ticks);
+
+        let timeSinceLastTempo = ticks - tempo.ticks;
+        return this._ticksToSeconds(ticks - timeSinceLastTempo) + (timeSinceLastTempo * 60) / (tempo.tempo * this.timeDivision);
+    }
+}

package/spessasynth_core/midi_parser/midi_message.js

@@ -0,0 +1,231 @@
+import {ShiftableByteArray} from "../utils/shiftable_array.js";
+
+/**
+ * midi_message.js
+ * purpose: contains enums for midi events and controllers and functions to parse them
+ */
+
+export class MidiMessage
+{
+    /**
+     * @param ticks {number}
+     * @param byte {number} the message status byte
+     * @param data {ShiftableByteArray}
+     */
+    constructor(ticks, byte, data) {
+        // absolute ticks from the start
+        this.ticks = ticks;
+        // message status byte (for meta it's the second byte)
+        this.messageStatusByte = byte;
+        this.messageData = data;
+    }
+}
+
+/**
+ * Gets the status byte's channel
+ * @param statusByte
+ * @returns {number} channel is -1 for system messages -2 for meta and -3 for sysex
+ */
+export function getChannel(statusByte) {
+    const eventType = statusByte & 0xF0;
+    const channel = statusByte & 0x0F;
+
+    let resultChannel = channel;
+
+    switch (eventType) {
+        // midi (and meta and sysex headers)
+        case 0x80:
+        case 0x90:
+        case 0xA0:
+        case 0xB0:
+        case 0xC0:
+        case 0xD0:
+        case 0xE0:
+            break;
+
+        case 0xF0:
+            switch (channel) {
+                case 0x0:
+                    resultChannel = -3;
+                    break;
+
+                case 0x1:
+                case 0x2:
+                case 0x3:
+                case 0x4:
+                case 0x5:
+                case 0x6:
+                case 0x7:
+                case 0x8:
+                case 0x9:
+                case 0xA:
+                case 0xB:
+                case 0xC:
+                case 0xD:
+                case 0xE:
+                    resultChannel = -1;
+                    break;
+
+                case 0xF:
+                    resultChannel = -2;
+                    break;
+            }
+            break;
+
+        default:
+            resultChannel = -1;
+    }
+
+    return resultChannel;
+}
+
+// all the midi statuses dictionary
+export const messageTypes = {
+    noteOff: 0x80,
+    noteOn: 0x90,
+    noteAftertouch: 0xA0,
+    controllerChange: 0xB0,
+    programChange: 0xC0,
+    channelAftertouch: 0xD0,
+    pitchBend: 0xE0,
+    systemExclusive: 0xF0,
+    timecode: 0xF1,
+    songPosition: 0xF2,
+    songSelect: 0xF3,
+    tuneRequest: 0xF6,
+    clock: 0xF8,
+    start: 0xFA,
+    continue: 0xFB,
+    stop: 0xFC,
+    activeSensing: 0xFE,
+    reset: 0xFF,
+    sequenceNumber: 0x00,
+    text: 0x01,
+    copyright: 0x02,
+    trackName: 0x03,
+    instrumentName: 0x04,
+    lyric: 0x05,
+    marker: 0x06,
+    cuePoint: 0x07,
+    midiChannelPrefix: 0x20,
+    midiPort: 0x21,
+    endOfTrack: 0x2F,
+    setTempo: 0x51,
+    smpteOffset: 0x54,
+    timeSignature: 0x58,
+    keySignature: 0x59,
+    sequenceSpecific: 0x7F
+};
+
+
+/**
+ * Gets the event's status and channel from the status byte
+ * @param statusByte {number} the status byte
+ * @returns {{channel: number, status: number}} channel will be -1 for sysex and meta
+ */
+export function getEvent(statusByte) {
+    const status = statusByte & 0xF0;
+    const channel = statusByte & 0x0F;
+
+    let eventChannel = -1;
+    let eventStatus = statusByte;
+
+    if (status >= 0x80 && status <= 0xE0) {
+        eventChannel = channel;
+        eventStatus = status;
+    }
+
+    return {
+        status: eventStatus,
+        channel: eventChannel
+    };
+}
+
+
+/**
+ * @type {{timbreHarmonicContent: number, omniModeOn: number, polyModeOn: number, localControlOnOff: number, NRPNLsb: number, allNotesOff: number, footController: number, effects2Depth: number, lsbForControl7MainVolume: number, expressionController: number, monoModeOn: number, balance: number, effectControl1: number, effectControl2: number, modulationWheel: number, lsbForControl1ModulationWheel: number, allSoundOff: number, pan: number, effects1Depth: number, effects3Depth: number, attackTime: number, dataEntryMsb: number, portamentoControl: number, sostenutoPedal: number, lsbForControl5PortamentoTime: number, RPNLsb: number, bankSelect: number, portamentoTime: number, mainVolume: number, hold2Pedal: number, releaseTime: number, dataDecrement: number, NRPNMsb: number, legatoFootswitch: number, sustainPedal: number, portamentoOnOff: number, lsbForControl0BankSelect: number, lsbForControl13EffectControl2: number, effects5Depth: number, generalPurposeController2: number, lsbForControl6DataEntry: number, resetAllControllers: number, generalPurposeController3: number, generalPurposeController4: number, generalPurposeController5: number, softPedal: number, generalPurposeController6: number, lsbForControl4FootController: number, lsbForControl12EffectControl1: number, generalPurposeController7: number, generalPurposeController8: number, effects4Depth: number, lsbForControl8Balance: number, soundController9: number, soundVariation: number, soundController8: number, soundController7: number, soundController6: number, soundController10: number, dataIncrement: number, generalPurposeController1: number, lsbForControl2BreathController: number, lsbForControl11ExpressionController: number, brightness: number, lsbForControl10Pan: number, RPNMsb: number, breathController: number, omniModeOff: number}}
+ */
+export const midiControllers = {
+    bankSelect: 0,
+    modulationWheel: 1,
+    breathController: 2,
+    footController: 4,
+    portamentoTime: 5,
+    dataEntryMsb: 6,
+    mainVolume: 7,
+    balance: 8,
+    pan: 10,
+    expressionController: 11,
+    effectControl1: 12,
+    effectControl2: 13,
+    generalPurposeController1: 16,
+    generalPurposeController2: 17,
+    generalPurposeController3: 18,
+    generalPurposeController4: 19,
+    lsbForControl0BankSelect: 32,
+    lsbForControl1ModulationWheel: 33,
+    lsbForControl2BreathController: 34,
+    lsbForControl4FootController: 36,
+    lsbForControl5PortamentoTime: 37,
+    lsbForControl6DataEntry: 38,
+    lsbForControl7MainVolume: 39,
+    lsbForControl8Balance: 40,
+    lsbForControl10Pan: 42,
+    lsbForControl11ExpressionController: 43,
+    lsbForControl12EffectControl1: 44,
+    lsbForControl13EffectControl2: 45,
+    sustainPedal: 64,
+    portamentoOnOff: 65,
+    sostenutoPedal: 66,
+    softPedal: 67,
+    legatoFootswitch: 68,
+    hold2Pedal: 69,
+    soundVariation: 70,
+    timbreHarmonicContent: 71,
+    releaseTime: 72,
+    attackTime: 73,
+    brightness: 74,
+    soundController6: 75,
+    soundController7: 76,
+    soundController8: 77,
+    soundController9: 78,
+    soundController10: 79,
+    generalPurposeController5: 80,
+    generalPurposeController6: 81,
+    generalPurposeController7: 82,
+    generalPurposeController8: 83,
+    portamentoControl: 84,
+    effects1Depth: 91,
+    effects2Depth: 92,
+    effects3Depth: 93,
+    effects4Depth: 94,
+    effects5Depth: 95,
+    dataIncrement: 96,
+    dataDecrement: 97,
+    NRPNLsb: 98,
+    NRPNMsb: 99,
+    RPNLsb: 100,
+    RPNMsb: 101,
+    allSoundOff: 120,
+    resetAllControllers: 121,
+    localControlOnOff: 122,
+    allNotesOff: 123,
+    omniModeOff: 124,
+    omniModeOn: 125,
+    monoModeOn: 126,
+    polyModeOn: 127
+};
+
+
+/**
+ * @type {{"11": number, "12": number, "13": number, "14": number, "8": number, "9": number, "10": number}}
+ */
+export const dataBytesAmount = {
+    0x8: 2, // note off
+    0x9: 2, // note on
+    0xA: 2, // note at
+    0xB: 2, // cc change
+    0xC: 1, // pg change
+    0xD: 1, // channel aftertouch
+    0xE: 2  // pitch wheel
+};