@karaplay/file-coder 1.5.0 → 1.5.2

package/demo-libs/MIDIFile.js

@@ -0,0 +1,450 @@
+"use strict";
+
+/**
+ * MIDIFile : Read (and soon edit) a MIDI file in a given ArrayBuffer
+ */
+
+const MIDIFileHeader = require("./MIDIFileHeader");
+const MIDIFileTrack = require("./MIDIFileTrack");
+const MIDIEvents = require("./MIDIEvents");
+const UTF8 = require("./UTF8");
+const TextEncoding = require("./TextEncoding");
+class MIDIFile {
+    constructor(buffer, strictMode) {
+        let track;
+        let curIndex;
+        let i;
+        let j;
+        let arrayBuffer;
+        // If not buffer given, creating a new MIDI file
+        if (!buffer) {
+            // Creating the content
+            this.header = new MIDIFileHeader();
+            this.tracks = [new MIDIFileTrack()];
+            // if a buffer is provided, parsing him
+        }
+        else {
+            // Convert Node.js Buffer to ArrayBuffer if needed
+            if (Buffer.isBuffer(buffer)) {
+                // Convert Node.js Buffer to ArrayBuffer
+                arrayBuffer = new Uint8Array(buffer).buffer;
+            }
+            else if (buffer instanceof Uint8Array) {
+                const slice = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+                arrayBuffer = slice instanceof ArrayBuffer ? slice : new Uint8Array(slice).buffer;
+            }
+            else if (buffer instanceof ArrayBuffer) {
+                arrayBuffer = buffer;
+            }
+            else {
+                throw new Error('Invalid buffer received. Expected Buffer, ArrayBuffer, or Uint8Array.');
+            }
+            // Minimum MIDI file size is a headerChunk size (14bytes)
+            // and an empty track (8+3bytes)
+            if (25 > arrayBuffer.byteLength) {
+                throw new Error('A buffer of a valid MIDI file must have, at least, a' +
+                    ' size of 25bytes.');
+            }
+            // Reading header
+            this.header = new MIDIFileHeader(arrayBuffer, strictMode);
+            this.tracks = [];
+            curIndex = MIDIFileHeader.HEADER_LENGTH;
+            // Reading tracks
+            for (i = 0, j = this.header.getTracksCount(); i < j; i++) {
+                // Testing the buffer length
+                if (strictMode && curIndex >= arrayBuffer.byteLength - 1) {
+                    throw new Error('Couldn\'t find datas corresponding to the track #' + i + '.');
+                }
+                // Creating the track object
+                track = new MIDIFileTrack(arrayBuffer, curIndex, strictMode);
+                this.tracks.push(track);
+                // Updating index to the track end
+                curIndex += track.getTrackLength() + 8;
+            }
+            // Testing integrity : curIndex should be at the end of the buffer
+            if (strictMode && curIndex !== arrayBuffer.byteLength) {
+                throw new Error('It seems that the buffer contains too much datas.');
+            }
+        }
+    }
+    // Events reading helpers
+    getEvents(type, subtype) {
+        let events;
+        let event;
+        let playTime = 0;
+        const filteredEvents = [];
+        const format = this.header.getFormat();
+        let tickResolution = this.header.getTickResolution();
+        let i;
+        let j;
+        let trackParsers;
+        let smallestDelta;
+        // Reading events
+        // if the read is sequential
+        if (1 !== format || 1 === this.tracks.length) {
+            for (i = 0, j = this.tracks.length; i < j; i++) {
+                // reset playtime if format is 2
+                playTime = (2 === format && playTime ? playTime : 0);
+                events = MIDIEvents.createParser(this.tracks[i].getTrackContent(), 0, false);
+                // loooping through events
+                event = events.next();
+                while (event) {
+                    playTime += event.delta ? (event.delta * tickResolution) / 1000 : 0;
+                    if (event.type === MIDIEvents.EVENT_META) {
+                        // tempo change events
+                        if (event.subtype === MIDIEvents.EVENT_META_SET_TEMPO) {
+                            tickResolution = this.header.getTickResolution(event.tempo);
+                        }
+                    }
+                    // push the asked events
+                    if (((!type) || event.type === type) &&
+                        ((!subtype) || (event.subtype && event.subtype === subtype))) {
+                        event.playTime = playTime;
+                        filteredEvents.push(event);
+                    }
+                    event = events.next();
+                }
+            }
+            // the read is concurrent
+        }
+        else {
+            trackParsers = [];
+            smallestDelta = -1;
+            // Creating parsers
+            for (i = 0, j = this.tracks.length; i < j; i++) {
+                trackParsers[i] = {
+                    parser: MIDIEvents.createParser(this.tracks[i].getTrackContent(), 0, false),
+                    curEvent: null
+                };
+                trackParsers[i].curEvent = trackParsers[i].parser.next();
+            }
+            // Filling events
+            do {
+                smallestDelta = -1;
+                // finding the smallest event
+                for (i = 0, j = trackParsers.length; i < j; i++) {
+                    if (trackParsers[i].curEvent) {
+                        if (-1 === smallestDelta || trackParsers[i].curEvent.delta <
+                            trackParsers[smallestDelta].curEvent.delta) {
+                            smallestDelta = i;
+                        }
+                    }
+                }
+                if (-1 !== smallestDelta) {
+                    // removing the delta of previous events
+                    for (i = 0, j = trackParsers.length; i < j; i++) {
+                        if (i !== smallestDelta && trackParsers[i].curEvent) {
+                            trackParsers[i].curEvent.delta -= trackParsers[smallestDelta].curEvent.delta;
+                        }
+                    }
+                    // filling values
+                    event = trackParsers[smallestDelta].curEvent;
+                    playTime += (event.delta ? (event.delta * tickResolution) / 1000 : 0);
+                    if (event.type === MIDIEvents.EVENT_META) {
+                        // tempo change events
+                        if (event.subtype === MIDIEvents.EVENT_META_SET_TEMPO) {
+                            tickResolution = this.header.getTickResolution(event.tempo);
+                        }
+                    }
+                    // push midi events
+                    if (((!type) || event.type === type) &&
+                        ((!subtype) || (event.subtype && event.subtype === subtype))) {
+                        event.playTime = playTime;
+                        event.track = smallestDelta;
+                        filteredEvents.push(event);
+                    }
+                    // getting next event
+                    trackParsers[smallestDelta].curEvent = trackParsers[smallestDelta].parser.next();
+                }
+            } while (-1 !== smallestDelta);
+        }
+        return filteredEvents;
+    }
+    getMidiEvents() {
+        return this.getEvents(MIDIEvents.EVENT_MIDI);
+    }
+    getLyrics() {
+        const events = this.getEvents(MIDIEvents.EVENT_META);
+        let texts = [];
+        const lyrics = [];
+        let event;
+        let i;
+        let j;
+        for (i = 0, j = events.length; i < j; i++) {
+            event = events[i];
+            // Lyrics
+            if (event.subtype === MIDIEvents.EVENT_META_LYRICS) {
+                lyrics.push(event);
+                // Texts
+            }
+            else if (event.subtype === MIDIEvents.EVENT_META_TEXT) {
+                // Ignore special texts
+                if (event.data && event.data.length > 0 && '@' === String.fromCharCode(event.data[0])) {
+                    if (event.data.length > 1 && 'T' === String.fromCharCode(event.data[1])) {
+                        // console.log('Title : ' + event.text.substring(2));
+                    }
+                    else if (event.data.length > 1 && 'I' === String.fromCharCode(event.data[1])) {
+                        // console.log('Info : ' + event.text.substring(2));
+                    }
+                    else if (event.data.length > 1 && 'L' === String.fromCharCode(event.data[1])) {
+                        // console.log('Lang : ' + event.text.substring(2));
+                    }
+                    // karaoke text follows, remove all previous text
+                }
+                else if (event.data && 0 === String.fromCharCode.apply(String, event.data).indexOf('words')) {
+                    texts.length = 0;
+                    // console.log('Word marker found');
+                    // Karaoke texts
+                    // If playtime is greater than 0
+                }
+                else if (event.playTime && 0 !== event.playTime) {
+                    texts.push(event);
+                }
+            }
+        }
+        // Choosing the right lyrics
+        if (2 < lyrics.length) {
+            texts = lyrics;
+        }
+        else if (!texts.length) {
+            texts = [];
+        }
+        // Convert texts with fallback encoding chain: TIS-620 → Windows-874 → UTF-8
+        // Get TextEncoding from global scope if not available locally
+        let textEncoder = TextEncoding;
+        if (!textEncoder && typeof globalThis.window !== 'undefined') {
+            textEncoder = globalThis.window.TextEncoding;
+        }
+        if (!textEncoder && typeof globalThis !== 'undefined') {
+            textEncoder = globalThis.TextEncoding;
+        }
+        texts.forEach(function (event) {
+            if (textEncoder && textEncoder.decodeWithFallback) {
+                event.text = textEncoder.decodeWithFallback(event.data, 0, event.length);
+            }
+            else {
+                // Fallback: try to decode as UTF-8 or use simple character mapping
+                try {
+                    let utf8Decoder = UTF8;
+                    if (!utf8Decoder && typeof globalThis.window !== 'undefined') {
+                        utf8Decoder = globalThis.window.UTF8;
+                    }
+                    if (!utf8Decoder && typeof globalThis !== 'undefined') {
+                        utf8Decoder = globalThis.UTF8;
+                    }
+                    if (utf8Decoder && utf8Decoder.getStringFromBytes) {
+                        event.text = utf8Decoder.getStringFromBytes(event.data, 0, event.length, false);
+                    }
+                    else {
+                        // Ultimate fallback: simple character mapping
+                        let text = '';
+                        for (let i = 0; i < event.length && i < event.data.length; i++) {
+                            text += String.fromCharCode(event.data[i]);
+                        }
+                        event.text = text;
+                    }
+                }
+                catch (e) {
+                    // If all fails, use simple character mapping
+                    let text = '';
+                    for (let i = 0; i < event.length && i < event.data.length; i++) {
+                        text += String.fromCharCode(event.data[i]);
+                    }
+                    event.text = text;
+                }
+            }
+        });
+        return texts;
+    }
+    // Basic events reading
+    getTrackEvents(index) {
+        let event;
+        const events = [];
+        let parser;
+        if (index > this.tracks.length || 0 > index) {
+            throw new Error('Invalid track index (' + index + ')');
+        }
+        parser = MIDIEvents.createParser(this.tracks[index].getTrackContent(), 0, false);
+        event = parser.next();
+        do {
+            if (event) {
+                events.push(event);
+                event = parser.next();
+            }
+        } while (event);
+        return events;
+    }
+    // Retrieve the content in a buffer
+    getContent() {
+        let bufferLength;
+        let destination;
+        let origin;
+        let i;
+        let j;
+        let k;
+        let l;
+        let m;
+        let n;
+        // Calculating the buffer content
+        // - initialize with the header length
+        bufferLength = MIDIFileHeader.HEADER_LENGTH;
+        // - add tracks length
+        for (i = 0, j = this.tracks.length; i < j; i++) {
+            bufferLength += this.tracks[i].getTrackLength() + 8;
+        }
+        // Creating the destination buffer
+        destination = new Uint8Array(bufferLength);
+        // Adding header
+        origin = new Uint8Array(this.header.datas.buffer, this.header.datas.byteOffset, MIDIFileHeader.HEADER_LENGTH);
+        for (i = 0, j = MIDIFileHeader.HEADER_LENGTH; i < j; i++) {
+            destination[i] = origin[i];
+        }
+        // Adding tracks
+        for (k = 0, l = this.tracks.length; k < l; k++) {
+            origin = new Uint8Array(this.tracks[k].datas.buffer, this.tracks[k].datas.byteOffset, this.tracks[k].datas.byteLength);
+            for (m = 0, n = this.tracks[k].datas.byteLength; m < n; m++) {
+                destination[i++] = origin[m];
+            }
+        }
+        return destination.buffer;
+    }
+    // parseSong method for MIDIPlayer compatibility
+    parseSong() {
+        const song = {
+            duration: 0,
+            tracks: [],
+            beats: []
+        };
+        const events = this.getMidiEvents();
+        for (let i = 0; i < events.length; i++) {
+            if (song.duration < events[i].playTime / 1000) {
+                song.duration = events[i].playTime / 1000;
+            }
+            if (events[i].subtype === MIDIEvents.EVENT_MIDI_NOTE_ON) {
+                if (events[i].channel === 9) {
+                    if (events[i].param1 >= 35 && events[i].param1 <= 81) {
+                        this.startDrum(events[i], song);
+                    }
+                    else {
+                        console.log('wrong drum', events[i]);
+                    }
+                }
+                else {
+                    if (events[i].param1 >= 0 && events[i].param1 <= 127) {
+                        this.startNote(events[i], song);
+                    }
+                    else {
+                        console.log('wrong tone', events[i]);
+                    }
+                }
+            }
+            else {
+                if (events[i].subtype === MIDIEvents.EVENT_MIDI_NOTE_OFF) {
+                    if (events[i].channel !== 9) {
+                        this.closeNote(events[i], song);
+                    }
+                }
+                else {
+                    if (events[i].subtype === MIDIEvents.EVENT_MIDI_PROGRAM_CHANGE) {
+                        if (events[i].channel !== 9) {
+                            const track = this.takeTrack(events[i].channel, song);
+                            track.program = events[i].param1;
+                        }
+                        else {
+                            console.log('skip program for drums');
+                        }
+                    }
+                    else {
+                        if (events[i].subtype === MIDIEvents.EVENT_MIDI_CONTROLLER) {
+                            if (events[i].param1 === 7) {
+                                if (events[i].channel !== 9) {
+                                    const track = this.takeTrack(events[i].channel, song);
+                                    track.volume = events[i].param2 / 127 || 0.000001;
+                                }
+                            }
+                        }
+                        else {
+                            if (events[i].subtype === MIDIEvents.EVENT_MIDI_PITCH_BEND) {
+                                this.addSlide(events[i], song);
+                            }
+                            else {
+                                console.log('unknown', events[i].channel, events[i]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return song;
+    }
+    startNote(event, song) {
+        const track = this.takeTrack(event.channel, song);
+        track.notes.push({
+            when: event.playTime / 1000,
+            pitch: event.param1,
+            duration: 0.0000001,
+            slides: []
+        });
+    }
+    closeNote(event, song) {
+        const track = this.takeTrack(event.channel, song);
+        for (let i = 0; i < track.notes.length; i++) {
+            if (track.notes[i].duration === 0.0000001 &&
+                track.notes[i].pitch === event.param1 &&
+                track.notes[i].when < event.playTime / 1000) {
+                track.notes[i].duration = event.playTime / 1000 - track.notes[i].when;
+                break;
+            }
+        }
+    }
+    addSlide(event, song) {
+        const track = this.takeTrack(event.channel, song);
+        for (let i = 0; i < track.notes.length; i++) {
+            if (track.notes[i].duration === 0.0000001 &&
+                track.notes[i].when < event.playTime / 1000) {
+                track.notes[i].slides.push({
+                    pitch: track.notes[i].pitch + (event.param2 - 64) / 6,
+                    when: event.playTime / 1000 - track.notes[i].when
+                });
+            }
+        }
+    }
+    startDrum(event, song) {
+        const beat = this.takeBeat(event.param1, song);
+        beat.notes.push({
+            when: event.playTime / 1000
+        });
+    }
+    takeTrack(n, song) {
+        for (let i = 0; i < song.tracks.length; i++) {
+            if (song.tracks[i].n === n) {
+                return song.tracks[i];
+            }
+        }
+        const track = {
+            n: n,
+            notes: [],
+            volume: 1,
+            program: 0
+        };
+        song.tracks.push(track);
+        return track;
+    }
+    takeBeat(n, song) {
+        for (let i = 0; i < song.beats.length; i++) {
+            if (song.beats[i].n === n) {
+                return song.beats[i];
+            }
+        }
+        const beat = {
+            n: n,
+            notes: [],
+            volume: 1
+        };
+        song.beats.push(beat);
+        return beat;
+    }
+}
+MIDIFile.Header = MIDIFileHeader;
+MIDIFile.Track = MIDIFileTrack;
+module.exports = MIDIFile;

package/demo-libs/MIDIFileHeader.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * MIDIFileHeader : Read and edit a MIDI header chunk in a given ArrayBuffer
+ */
+class MIDIFileHeader {
+    constructor(buffer, _strictMode) {
+        let a;
+        // No buffer creating him
+        if (!buffer) {
+            a = new Uint8Array(MIDIFileHeader.HEADER_LENGTH);
+            // Adding the header id (MThd)
+            a[0] = 0x4D;
+            a[1] = 0x54;
+            a[2] = 0x68;
+            a[3] = 0x64;
+            // Adding the header chunk size
+            a[4] = 0x00;
+            a[5] = 0x00;
+            a[6] = 0x00;
+            a[7] = 0x06;
+            // Adding the file format (1 here cause it's the most commonly used)
+            a[8] = 0x00;
+            a[9] = 0x01;
+            // Adding the track count (1 cause it's a new file)
+            a[10] = 0x00;
+            a[11] = 0x01;
+            // Adding the time division (192 ticks per beat)
+            a[12] = 0x00;
+            a[13] = 0xC0;
+            // saving the buffer
+            this.datas = new DataView(a.buffer, 0, MIDIFileHeader.HEADER_LENGTH);
+            // Parsing the given buffer
+        }
+        else {
+            if (!(buffer instanceof ArrayBuffer)) {
+                throw new Error('Invalid buffer received.');
+            }
+            this.datas = new DataView(buffer, 0, MIDIFileHeader.HEADER_LENGTH);
+            // Reading MIDI header chunk
+            if (!('M' === String.fromCharCode(this.datas.getUint8(0)) &&
+                'T' === String.fromCharCode(this.datas.getUint8(1)) &&
+                'h' === String.fromCharCode(this.datas.getUint8(2)) &&
+                'd' === String.fromCharCode(this.datas.getUint8(3)))) {
+                throw new Error('Invalid MIDIFileHeader : MThd prefix not found');
+            }
+            // Reading chunk length
+            if (6 !== this.datas.getUint32(4)) {
+                throw new Error('Invalid MIDIFileHeader : Chunk length must be 6');
+            }
+        }
+    }
+    // MIDI file format
+    getFormat() {
+        const format = this.datas.getUint16(8);
+        if (0 !== format && 1 !== format && 2 !== format) {
+            throw new Error('Invalid MIDI file : MIDI format (' + format + '),' +
+                ' format can be 0, 1 or 2 only.');
+        }
+        return format;
+    }
+    setFormat(format) {
+        if (0 !== format && 1 !== format && 2 !== format) {
+            throw new Error('Invalid MIDI format given (' + format + '),' +
+                ' format can be 0, 1 or 2 only.');
+        }
+        this.datas.setUint16(8, format);
+    }
+    // Number of tracks
+    getTracksCount() {
+        return this.datas.getUint16(10);
+    }
+    setTracksCount(n) {
+        this.datas.setUint16(10, n);
+    }
+    // Tick compute
+    getTickResolution(tempo) {
+        // Frames per seconds
+        if (this.datas.getUint16(12) & 0x8000) {
+            return 1000000 / (this.getSMPTEFrames() * this.getTicksPerFrame());
+            // Ticks per beat
+        }
+        // Default MIDI tempo is 120bpm, 500ms per beat
+        tempo = tempo || 500000;
+        return tempo / this.getTicksPerBeat();
+    }
+    // Time division type
+    getTimeDivision() {
+        if (this.datas.getUint16(12) & 0x8000) {
+            return MIDIFileHeader.FRAMES_PER_SECONDS;
+        }
+        return MIDIFileHeader.TICKS_PER_BEAT;
+    }
+    // Ticks per beat
+    getTicksPerBeat() {
+        const divisionWord = this.datas.getUint16(12);
+        if (divisionWord & 0x8000) {
+            throw new Error('Time division is not expressed as ticks per beat.');
+        }
+        return divisionWord;
+    }
+    setTicksPerBeat(ticksPerBeat) {
+        this.datas.setUint16(12, ticksPerBeat & 0x7FFF);
+    }
+    // Frames per seconds
+    getSMPTEFrames() {
+        const divisionWord = this.datas.getUint16(12);
+        let smpteFrames;
+        if (!(divisionWord & 0x8000)) {
+            throw new Error('Time division is not expressed as frames per seconds.');
+        }
+        smpteFrames = divisionWord & 0x7F00;
+        if (-1 === [24, 25, 29, 30].indexOf(smpteFrames)) {
+            throw new Error('Invalid SMPTE frames value (' + smpteFrames + ').');
+        }
+        return 29 === smpteFrames ? 29.97 : smpteFrames;
+    }
+    getTicksPerFrame() {
+        const divisionWord = this.datas.getUint16(12);
+        if (!(divisionWord & 0x8000)) {
+            throw new Error('Time division is not expressed as frames per seconds.');
+        }
+        return divisionWord & 0x00FF;
+    }
+    setSMTPEDivision(smpteFrames, ticksPerFrame) {
+        let frames = smpteFrames;
+        if (29.97 === frames) {
+            frames = 29;
+        }
+        if (-1 === [24, 25, 29, 30].indexOf(frames)) {
+            throw new Error('Invalid SMPTE frames value given (' + frames + ').');
+        }
+        if (0 > ticksPerFrame || 0xFF < ticksPerFrame) {
+            throw new Error('Invalid ticks per frame value given (' + frames + ').');
+        }
+        this.datas.setUint8(12, 0x80 | frames);
+        this.datas.setUint8(13, ticksPerFrame);
+    }
+}
+module.exports = MIDIFileHeader;
+// Static constants
+MIDIFileHeader.HEADER_LENGTH = 14;
+MIDIFileHeader.FRAMES_PER_SECONDS = 1;
+MIDIFileHeader.TICKS_PER_BEAT = 2;
+module.exports = MIDIFileHeader;