spessasynth_lib 0.0.1

package/package/midi_parser/midi_message.js

@@ -0,0 +1,234 @@
+import {IndexedByteArray} from "../utils/indexed_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 {IndexedByteArray}
+     */
+    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;
+        /**
+         * @type {IndexedByteArray}
+         */
+        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,
+    polyPressure: 0xA0,
+    controllerChange: 0xB0,
+    programChange: 0xC0,
+    channelPressure: 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
+    };
+}
+
+
+/**
+ * @enum {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
+};

package/package/midi_parser/midi_writer.js

@@ -0,0 +1,95 @@
+import { messageTypes } from './midi_message.js'
+import { writeVariableLengthQuantity } from '../utils/byte_functions/variable_length_quantity.js'
+import { writeBytesAsUintBigEndian } from '../utils/byte_functions/big_endian.js'
+
+/**
+ * Exports the midi as a .mid file
+ * @param midi {MIDI}
+ * @returns {Uint8Array} the binary .mid file data
+ */
+export function writeMIDIFile(midi)
+{
+    /**
+     * @type {Uint8Array[]}
+     */
+    const binaryTrackData = [];
+    for(const track of midi.tracks)
+    {
+        const binaryTrack = [];
+        let currentTick = 0;
+        let runningByte = undefined;
+        for(const event of track)
+        {
+            // ticks stored in MIDI are absolute, but .mid wants relative. Convert them here.
+            const deltaTicks = event.ticks - currentTick;
+            /**
+             * @type {number[]}
+             */
+            let messageData;
+            // determine the message
+            if(event.messageStatusByte <= messageTypes.keySignature || event.messageStatusByte === messageTypes.sequenceSpecific)
+            {
+                // this is a meta message
+                // syntax is FF<type><length><data>
+                messageData = [0xff, event.messageStatusByte, ...writeVariableLengthQuantity(event.messageData.length), ...event.messageData];
+            }
+            else if(event.messageStatusByte === messageTypes.systemExclusive)
+            {
+                // this is a system exclusive message
+                // syntax is F0<length><data>
+                messageData = [0xf0, ...writeVariableLengthQuantity(event.messageData.length), ...event.messageData];
+            }
+            else
+            {
+                // this is a midi message
+                messageData = [];
+                if(runningByte !== event.messageStatusByte)
+                {
+                    // running byte was not the byte we want. Add the byte here.
+                    runningByte = event.messageStatusByte;
+                    // add the status byte to the midi
+                    messageData.push(event.messageStatusByte);
+                }
+                // add the data
+                messageData.push(...event.messageData);
+            }
+            // write VLQ
+            binaryTrack.push(...writeVariableLengthQuantity(deltaTicks));
+            // write message
+            binaryTrack.push(...messageData);
+            currentTick += deltaTicks;
+        }
+        binaryTrackData.push(new Uint8Array(binaryTrack));
+    }
+
+    /**
+     * @param text {string}
+     * @param arr {number[]}
+     */
+    function writeText(text, arr)
+    {
+        for(let i = 0; i < text.length; i++)
+        {
+            arr.push(text.charCodeAt(i));
+        }
+    }
+
+    // write the file
+    const binaryData = [];
+    // write header
+    writeText("MThd", binaryData); // MThd
+    binaryData.push(...writeBytesAsUintBigEndian(6, 4)); // length
+    binaryData.push(0, midi.format); // format
+    binaryData.push(...writeBytesAsUintBigEndian(midi.tracksAmount, 2)); // num tracks
+    binaryData.push(...writeBytesAsUintBigEndian(midi.timeDivision, 2)); // time division
+
+    // write tracks
+    for(const track of binaryTrackData)
+    {
+        // write track header
+        writeText("MTrk", binaryData); // MTrk
+        binaryData.push(...writeBytesAsUintBigEndian(track.length, 4)); // length
+        binaryData.push(...track); // write data
+    }
+    return new Uint8Array(binaryData);
+}

package/package/midi_parser/rmidi_writer.js

@@ -0,0 +1,271 @@
+import { combineArrays, IndexedByteArray } from '../utils/indexed_array.js'
+import { writeMIDIFile } from './midi_writer.js'
+import { RiffChunk, writeRIFFChunk } from '../soundfont/read/riff_chunk.js'
+import { getStringBytes } from '../utils/byte_functions/string.js'
+import { messageTypes, midiControllers, MidiMessage } from './midi_message.js'
+import { DEFAULT_PERCUSSION } from '../synthetizer/synthetizer.js'
+import { getGsOn } from './midi_editor.js'
+import { SpessaSynthInfo } from '../utils/loggin.js'
+import { consoleColors } from '../utils/other.js'
+
+/**
+ *
+ * @param soundfontBinary {Uint8Array}
+ * @param mid {MIDI}
+ * @param soundfont {SoundFont2}
+ * @returns {IndexedByteArray}
+ */
+export function writeRMIDI(soundfontBinary, mid, soundfont)
+{
+    // add 1 to bank. See wiki About-RMIDI
+    // also fix presets that don't exists since midiplayer6 doesn't seem to default to 0 when nonextistent...
+    let system = "gm";
+    /**
+     * The unwanted system messages such as gm/gm2 on
+     * @type {{tNum: number, e: MidiMessage}[]}
+     */
+    let unwantedSystems = [];
+    mid.tracks.forEach((t, trackNum) => {
+        /**
+         * @type {boolean[]}
+         */
+        let hasBankSelects = Array(16).fill(true);
+        mid.usedChannelsOnTrack[trackNum].forEach(c => {
+            // fill with true, only the channels on this track are set to false
+            // (so we won't add banks for channels the track isn't refering to)
+            hasBankSelects[c] = false;
+        });
+        /**
+         * @type {MidiMessage[]}
+         */
+        let lastBankChanges = [];
+        /**
+         * @type {boolean[]}
+         */
+        let drums = Array(16).fill(false);
+        drums[DEFAULT_PERCUSSION] = true;
+        let programs = Array(16).fill(0);
+        t.forEach(e => {
+            const status = e.messageStatusByte & 0xF0;
+            if(
+                status !== messageTypes.controllerChange &&
+                status !== messageTypes.programChange &&
+                status !== messageTypes.systemExclusive
+            )
+            {
+                return;
+            }
+
+            if(status === messageTypes.systemExclusive)
+            {
+                // check for drum sysex
+                if(
+                    e.messageData[0] !== 0x41 || // roland
+                    e.messageData[2] !== 0x42 || // GS
+                    e.messageData[3] !== 0x12 || // GS
+                    e.messageData[4] !== 0x40 || // system parameter
+                    (e.messageData[5] & 0x10 ) === 0 || // part parameter
+                    e.messageData[6] !== 0x15 // drum part
+                )
+                {
+                    // check for XG
+                    if(
+                        e.messageData[0] === 0x43 && // yamaha
+                        e.messageData[2] === 0x4C && // sXG ON
+                        e.messageData[5] === 0x7E &&
+                        e.messageData[6] === 0x00
+                    )
+                    {
+                        system = "xg";
+                    }
+                    else
+                    if(
+                        e.messageData[0] === 0x41    // roland
+                        && e.messageData[2] === 0x42 // GS
+                        && e.messageData[6] === 0x7F // Mode set
+                    )
+                    {
+                        system = "gs";
+                    }
+                    else
+                    if(
+                        e.messageData[0] === 0x7E // non realtime
+                        && e.messageData[2] === 0x09 // gm system
+                    )
+                    {
+                        system = "gm";
+                        unwantedSystems.push({
+                            tNum: trackNum,
+                            e: e
+                        });
+                    }
+                    return;
+                }
+                const sysexChannel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][e.messageData[5] & 0x0F];
+                drums[sysexChannel] = !!(e.messageData[7] > 0 && e.messageData[5] >> 4);
+                return;
+            }
+
+            const chNum = e.messageStatusByte & 0xF;
+            if(status === messageTypes.programChange)
+            {
+                // check if the preset for this program exists
+                if(drums[chNum])
+                {
+                    if(soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank === 128) === -1)
+                    {
+                        e.messageData[0] = soundfont.presets.find(p => p.bank === 128)?.program || 0;
+                    }
+                }
+                else
+                {
+                    if (soundfont.presets.findIndex(p => p.program === e.messageData[0] && p.bank !== 128) === -1)
+                    {
+                        e.messageData[0] = soundfont.presets.find(p => p.bank !== 128)?.program || 0;
+                    }
+                }
+                programs[e.messageStatusByte & 0xf] = e.messageData[0];
+                // check if this preset exists for program and bank
+                const bank = lastBankChanges[chNum]?.messageData[1];
+                if(bank === undefined)
+                {
+                    return;
+                }
+                if(system === "xg" && drums[chNum])
+                {
+                    // drums override: set bank to 127
+                    lastBankChanges[chNum].messageData[1] = 127;
+                    return;
+                }
+
+                if(soundfont.presets.findIndex(p => p.bank === bank && p.program === e.messageData[0]) === -1)
+                {
+                    // no preset with this bank. set to 1 (0)
+                    lastBankChanges[chNum].messageData[1] = 1;
+                    SpessaSynthInfo(`%cNo preset %c${bank}:${e.messageData[0]}%c. Changing bank to 1.`,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info);
+                }
+                else
+                {
+                    // there is a preset with this bank. add 1
+                    lastBankChanges[chNum].messageData[1]++;
+                    SpessaSynthInfo(`%cPreset %c${bank}:${e.messageData[0]}%c exists. Changing bank to ${lastBankChanges[chNum].messageData[1]}.`,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info);
+                }
+                return;
+            }
+            if(e.messageData[0] !== midiControllers.bankSelect)
+            {
+                return;
+            }
+            // bank select
+            hasBankSelects[chNum] = true;
+            if(system === "xg")
+            {
+                // check for xg drums
+                drums[chNum] = e.messageData[1] === 120 || e.messageData[1] === 126 || e.messageData[1] === 127;
+            }
+            lastBankChanges[chNum] = e;
+        });
+        // add all bank selects that are missing for this track
+        hasBankSelects.forEach((has, ch) => {
+            if(has === true)
+            {
+                return;
+            }
+            // find first program change (for the given channel)
+            const status = messageTypes.programChange | ch;
+            let indexToAdd = t.findIndex(e => e.messageStatusByte === status);
+            if(indexToAdd === -1)
+            {
+                // no program change...
+                    // add programs if they are missing from the track (need them to activate bank 1 for the embedded sfont)
+                const programIndex = t.findIndex(e => (e.messageStatusByte > 0x80 && e.messageStatusByte < 0xF0) && (e.messageStatusByte & 0xF) === ch);
+                if(programIndex === -1)
+                {
+                    // no voices??? skip
+                    return;
+                }
+                const programTicks = t[programIndex].ticks;
+                const targetProgram = soundfont.getPreset(0, 0).program;
+                t.splice(programIndex, 0, new MidiMessage(
+                    programTicks,
+                    messageTypes.programChange | ch,
+                    new IndexedByteArray([targetProgram])
+                ));
+                indexToAdd = programIndex;
+            }
+            const ticks = t[indexToAdd].ticks;
+            const targetBank = (soundfont.getPreset(0, programs[ch])?.bank + 1) || 1;
+            t.splice(indexToAdd,0, new MidiMessage(
+                ticks,
+                messageTypes.controllerChange | ch,
+                new IndexedByteArray([midiControllers.bankSelect, targetBank])
+            ));
+        });
+    });
+    // make sure to put xg if gm
+    if(system !== "gs" && system !== "xg")
+    {
+        for(const m of unwantedSystems)
+        {
+            mid.tracks[m.tNum].splice(mid.tracks[m.tNum].indexOf(m.e), 1);
+        }
+        let index = 0;
+        if(mid.tracks[0][0].messageStatusByte === messageTypes.trackName)
+            index++;
+            mid.tracks[0].splice(index, 0, getGsOn(0));
+    }
+    const newMid = new IndexedByteArray(writeMIDIFile(mid).buffer);
+
+    // infodata for MidiPlayer6
+    const today = new Date().toLocaleString();
+    const infodata = combineArrays([
+        writeRIFFChunk(
+            new RiffChunk(
+                "ICOP",
+                11,
+                getStringBytes("SpessaSynth")
+            ),
+            new IndexedByteArray([73, 78, 70, 79]) // "INFO"
+        ),
+        writeRIFFChunk(
+            new RiffChunk(
+                "INAM",
+                mid.rawMidiName.length,
+                new IndexedByteArray(mid.rawMidiName.buffer)
+            ),
+        ),
+        writeRIFFChunk(
+            new RiffChunk(
+                "ICRD",
+                today.length,
+                getStringBytes(today)
+            )
+        )
+    ]);
+
+    const rmiddata = combineArrays([
+        new Uint8Array([82, 77, 73, 68]), // "RMID"
+        writeRIFFChunk(new RiffChunk(
+            "data",
+            newMid.length, // "data", size, midi binary
+            newMid
+        )),
+        writeRIFFChunk(new RiffChunk(
+            "LIST",
+            infodata.length,
+            infodata
+        )),
+        soundfontBinary
+    ]);
+    return writeRIFFChunk(new RiffChunk(
+        "RIFF",
+        rmiddata.length,
+        rmiddata
+    ));
+}