@karaplay/file-coder 1.5.0 → 1.5.2

package/demo-libs/MIDIEvents.js

@@ -0,0 +1,325 @@
+"use strict";
+/**
+ * MIDIEvents : Read and edit events from various sources (ArrayBuffer, Stream)
+ */
+// MIDIEvents is a namespace-like object with static constants and methods
+class MIDIEvents {
+    // Prevent instantiation
+    constructor() {
+        throw new Error('MIDIEvents function not intended to be run.');
+    }
+    // Create an event stream parser
+    static createParser(stream, startAt, strictMode) {
+        let eventTypeByte;
+        let event;
+        // MIDI events vars
+        let MIDIEventType;
+        let MIDIEventChannel;
+        let MIDIEventParam1;
+        // Wrap DataView into a data stream
+        let wrappedStream;
+        if (stream instanceof DataView) {
+            wrappedStream = {
+                position: startAt || 0,
+                buffer: stream,
+                readUint8: function () {
+                    return this.buffer.getUint8(this.position++);
+                },
+                readUint16: function () {
+                    const v = this.buffer.getUint16(this.position);
+                    this.position = this.position + 2;
+                    return v;
+                },
+                readUint32: function () {
+                    const v = this.buffer.getUint32(this.position);
+                    this.position = this.position + 4;
+                    return v;
+                },
+                readVarInt: function () {
+                    let v = 0;
+                    let i = 0;
+                    let b;
+                    while (4 > i++) {
+                        b = this.readUint8();
+                        if (b & 0x80) {
+                            v += (b & 0x7f);
+                            v <<= 7;
+                        }
+                        else {
+                            return v + b;
+                        }
+                    }
+                    throw new Error('0x' + this.position.toString(16) + ':' +
+                        ' Variable integer length cannot exceed 4 bytes');
+                },
+                readBytes: function (length) {
+                    const bytes = [];
+                    for (; 0 < length; length--) {
+                        bytes.push(this.readUint8());
+                    }
+                    return bytes;
+                },
+                pos: function () {
+                    return '0x' + (this.buffer.byteOffset + this.position).toString(16);
+                },
+                end: function () {
+                    return this.position === this.buffer.byteLength;
+                },
+            };
+            startAt = 0;
+        }
+        else {
+            wrappedStream = stream;
+        }
+        // Consume stream till not at start index
+        if (startAt && 0 < startAt) {
+            while (startAt--) {
+                wrappedStream.readUint8();
+            }
+        }
+        // creating the parser object
+        return {
+            // Read the next event
+            next: function () {
+                // Check available datas
+                if (wrappedStream.end()) {
+                    return null;
+                }
+                // Creating the event
+                event = {
+                    // Memoize the event index
+                    index: wrappedStream.pos(),
+                    // Read the delta time
+                    delta: wrappedStream.readVarInt(),
+                    type: 0, // Will be set below
+                };
+                // Read the eventTypeByte
+                eventTypeByte = wrappedStream.readUint8();
+                if (0xF0 === (eventTypeByte & 0xF0)) {
+                    // Meta events
+                    if (eventTypeByte === MIDIEvents.EVENT_META) {
+                        event.type = MIDIEvents.EVENT_META;
+                        event.subtype = wrappedStream.readUint8();
+                        event.length = wrappedStream.readVarInt();
+                        switch (event.subtype) {
+                            case MIDIEvents.EVENT_META_SEQUENCE_NUMBER:
+                                if (strictMode && 2 !== event.length) {
+                                    throw new Error(wrappedStream.pos() + ' Bad metaevent length.');
+                                }
+                                event.msb = wrappedStream.readUint8();
+                                event.lsb = wrappedStream.readUint8();
+                                return event;
+                            case MIDIEvents.EVENT_META_TEXT:
+                            case MIDIEvents.EVENT_META_COPYRIGHT_NOTICE:
+                            case MIDIEvents.EVENT_META_TRACK_NAME:
+                            case MIDIEvents.EVENT_META_INSTRUMENT_NAME:
+                            case MIDIEvents.EVENT_META_LYRICS:
+                            case MIDIEvents.EVENT_META_MARKER:
+                            case MIDIEvents.EVENT_META_CUE_POINT:
+                                event.data = wrappedStream.readBytes(event.length);
+                                return event;
+                            case MIDIEvents.EVENT_META_MIDI_CHANNEL_PREFIX:
+                                if (strictMode && 1 !== event.length) {
+                                    throw new Error(wrappedStream.pos() + ' Bad metaevent length.');
+                                }
+                                event.prefix = wrappedStream.readUint8();
+                                return event;
+                            case MIDIEvents.EVENT_META_END_OF_TRACK:
+                                if (strictMode && 0 !== event.length) {
+                                    throw new Error(wrappedStream.pos() + ' Bad metaevent length.');
+                                }
+                                return event;
+                            case MIDIEvents.EVENT_META_SET_TEMPO:
+                                if (strictMode && 3 !== event.length) {
+                                    throw new Error(wrappedStream.pos() + ' Tempo meta event length must be 3.');
+                                }
+                                event.tempo = ((wrappedStream.readUint8() << 16) +
+                                    (wrappedStream.readUint8() << 8) +
+                                    wrappedStream.readUint8());
+                                event.tempoBPM = 60000000 / event.tempo;
+                                return event;
+                            case MIDIEvents.EVENT_META_SMTPE_OFFSET:
+                                if (strictMode && 5 !== event.length) {
+                                    throw new Error(wrappedStream.pos() + ' Bad metaevent length.');
+                                }
+                                event.hour = wrappedStream.readUint8();
+                                if (strictMode && 23 < event.hour) {
+                                    throw new Error(wrappedStream.pos() + ' SMTPE offset hour value must' +
+                                        ' be part of 0-23.');
+                                }
+                                event.minutes = wrappedStream.readUint8();
+                                if (strictMode && 59 < event.minutes) {
+                                    throw new Error(wrappedStream.pos() + ' SMTPE offset minutes value' +
+                                        ' must be part of 0-59.');
+                                }
+                                event.seconds = wrappedStream.readUint8();
+                                if (strictMode && 59 < event.seconds) {
+                                    throw new Error(wrappedStream.pos() + ' SMTPE offset seconds value' +
+                                        ' must be part of 0-59.');
+                                }
+                                event.frames = wrappedStream.readUint8();
+                                if (strictMode && 30 < event.frames) {
+                                    throw new Error(wrappedStream.pos() + ' SMTPE offset frames value must' +
+                                        ' be part of 0-30.');
+                                }
+                                event.subframes = wrappedStream.readUint8();
+                                if (strictMode && 99 < event.subframes) {
+                                    throw new Error(wrappedStream.pos() + ' SMTPE offset subframes value must' +
+                                        ' be part of 0-99.');
+                                }
+                                return event;
+                            case MIDIEvents.EVENT_META_KEY_SIGNATURE:
+                                if (strictMode && 2 !== event.length) {
+                                    throw new Error(wrappedStream.pos() + ' Bad metaevent length.');
+                                }
+                                event.key = wrappedStream.readUint8();
+                                if (strictMode && (-7 > event.key || 7 < event.key)) {
+                                    throw new Error(wrappedStream.pos() + ' Bad metaevent length.');
+                                }
+                                event.scale = wrappedStream.readUint8();
+                                if (strictMode && 0 !== event.scale && 1 !== event.scale) {
+                                    throw new Error(wrappedStream.pos() + ' Key signature scale value must' +
+                                        ' be 0 or 1.');
+                                }
+                                return event;
+                            case MIDIEvents.EVENT_META_TIME_SIGNATURE:
+                                if (strictMode && 4 !== event.length) {
+                                    throw new Error(wrappedStream.pos() + ' Bad metaevent length.');
+                                }
+                                event.data = wrappedStream.readBytes(event.length);
+                                event.param1 = event.data[0];
+                                event.param2 = event.data[1];
+                                event.param3 = event.data[2];
+                                event.param4 = event.data[3];
+                                return event;
+                            case MIDIEvents.EVENT_META_SEQUENCER_SPECIFIC:
+                                event.data = wrappedStream.readBytes(event.length);
+                                return event;
+                            default:
+                                if (strictMode) {
+                                    throw new Error(wrappedStream.pos() + ' Unknown meta event type ' +
+                                        '(' + event.subtype.toString(16) + ').');
+                                }
+                                event.data = wrappedStream.readBytes(event.length);
+                                return event;
+                        }
+                        // System events
+                    }
+                    else if (eventTypeByte === MIDIEvents.EVENT_SYSEX ||
+                        eventTypeByte === MIDIEvents.EVENT_DIVSYSEX) {
+                        event.type = eventTypeByte;
+                        event.length = wrappedStream.readVarInt();
+                        event.data = wrappedStream.readBytes(event.length);
+                        return event;
+                        // Unknown event, assuming it's system like event
+                    }
+                    else {
+                        if (strictMode) {
+                            throw new Error(wrappedStream.pos() + ' Unknown event type ' +
+                                eventTypeByte.toString(16) + ', Delta: ' + event.delta + '.');
+                        }
+                        event.type = eventTypeByte;
+                        event.badsubtype = wrappedStream.readVarInt();
+                        event.length = wrappedStream.readUint8();
+                        event.data = wrappedStream.readBytes(event.length);
+                        return event;
+                    }
+                    // MIDI events
+                }
+                else {
+                    // running status
+                    if (0 === (eventTypeByte & 0x80)) {
+                        if (!MIDIEventType) {
+                            throw new Error(wrappedStream.pos() + ' Running status without previous event');
+                        }
+                        MIDIEventParam1 = eventTypeByte;
+                    }
+                    else {
+                        MIDIEventType = eventTypeByte >> 4;
+                        MIDIEventChannel = eventTypeByte & 0x0F;
+                        MIDIEventParam1 = wrappedStream.readUint8();
+                    }
+                    event.type = MIDIEvents.EVENT_MIDI;
+                    event.subtype = MIDIEventType;
+                    event.channel = MIDIEventChannel;
+                    event.param1 = MIDIEventParam1;
+                    switch (MIDIEventType) {
+                        case MIDIEvents.EVENT_MIDI_NOTE_OFF:
+                            event.param2 = wrappedStream.readUint8();
+                            return event;
+                        case MIDIEvents.EVENT_MIDI_NOTE_ON:
+                            event.param2 = wrappedStream.readUint8();
+                            // If velocity is 0, it's a note off event in fact
+                            if (!event.param2) {
+                                event.subtype = MIDIEvents.EVENT_MIDI_NOTE_OFF;
+                                event.param2 = 127; // Find a standard telling what to do here
+                            }
+                            return event;
+                        case MIDIEvents.EVENT_MIDI_NOTE_AFTERTOUCH:
+                            event.param2 = wrappedStream.readUint8();
+                            return event;
+                        case MIDIEvents.EVENT_MIDI_CONTROLLER:
+                            event.param2 = wrappedStream.readUint8();
+                            return event;
+                        case MIDIEvents.EVENT_MIDI_PROGRAM_CHANGE:
+                            return event;
+                        case MIDIEvents.EVENT_MIDI_CHANNEL_AFTERTOUCH:
+                            return event;
+                        case MIDIEvents.EVENT_MIDI_PITCH_BEND:
+                            event.param2 = wrappedStream.readUint8();
+                            return event;
+                        default:
+                            if (strictMode) {
+                                throw new Error(wrappedStream.pos() + ' Unknown MIDI event type ' +
+                                    '(' + MIDIEventType.toString(16) + ').');
+                            }
+                            return event;
+                    }
+                }
+            },
+        };
+    }
+}
+// Static constants
+// Event types
+MIDIEvents.EVENT_META = 0xFF;
+MIDIEvents.EVENT_SYSEX = 0xF0;
+MIDIEvents.EVENT_DIVSYSEX = 0xF7;
+MIDIEvents.EVENT_MIDI = 0x8;
+// Meta event types
+MIDIEvents.EVENT_META_SEQUENCE_NUMBER = 0x00;
+MIDIEvents.EVENT_META_TEXT = 0x01;
+MIDIEvents.EVENT_META_COPYRIGHT_NOTICE = 0x02;
+MIDIEvents.EVENT_META_TRACK_NAME = 0x03;
+MIDIEvents.EVENT_META_INSTRUMENT_NAME = 0x04;
+MIDIEvents.EVENT_META_LYRICS = 0x05;
+MIDIEvents.EVENT_META_MARKER = 0x06;
+MIDIEvents.EVENT_META_CUE_POINT = 0x07;
+MIDIEvents.EVENT_META_MIDI_CHANNEL_PREFIX = 0x20;
+MIDIEvents.EVENT_META_END_OF_TRACK = 0x2F;
+MIDIEvents.EVENT_META_SET_TEMPO = 0x51;
+MIDIEvents.EVENT_META_SMTPE_OFFSET = 0x54;
+MIDIEvents.EVENT_META_TIME_SIGNATURE = 0x58;
+MIDIEvents.EVENT_META_KEY_SIGNATURE = 0x59;
+MIDIEvents.EVENT_META_SEQUENCER_SPECIFIC = 0x7F;
+// MIDI event types
+MIDIEvents.EVENT_MIDI_NOTE_OFF = 0x8;
+MIDIEvents.EVENT_MIDI_NOTE_ON = 0x9;
+MIDIEvents.EVENT_MIDI_NOTE_AFTERTOUCH = 0xA;
+MIDIEvents.EVENT_MIDI_CONTROLLER = 0xB;
+MIDIEvents.EVENT_MIDI_PROGRAM_CHANGE = 0xC;
+MIDIEvents.EVENT_MIDI_CHANNEL_AFTERTOUCH = 0xD;
+MIDIEvents.EVENT_MIDI_PITCH_BEND = 0xE;
+// MIDI event sizes
+MIDIEvents.MIDI_1PARAM_EVENTS = [
+    MIDIEvents.EVENT_MIDI_PROGRAM_CHANGE,
+    MIDIEvents.EVENT_MIDI_CHANNEL_AFTERTOUCH,
+];
+MIDIEvents.MIDI_2PARAMS_EVENTS = [
+    MIDIEvents.EVENT_MIDI_NOTE_OFF,
+    MIDIEvents.EVENT_MIDI_NOTE_ON,
+    MIDIEvents.EVENT_MIDI_NOTE_AFTERTOUCH,
+    MIDIEvents.EVENT_MIDI_CONTROLLER,
+    MIDIEvents.EVENT_MIDI_PITCH_BEND,
+];
+module.exports = MIDIEvents;