@karaplay/file-coder 1.5.0 → 1.5.2

package/demo-libs/MIDIFileTrack.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * MIDIFileTrack : Read and edit a MIDI track chunk in a given ArrayBuffer
+ */
+class MIDIFileTrack {
+    constructor(buffer, start, _strictMode) {
+        let a;
+        let trackLength;
+        // no buffer, creating him
+        if (!buffer) {
+            a = new Uint8Array(12);
+            // Adding the empty track header (MTrk)
+            a[0] = 0x4D;
+            a[1] = 0x54;
+            a[2] = 0x72;
+            a[3] = 0x6B;
+            // Adding the empty track size (4)
+            a[4] = 0x00;
+            a[5] = 0x00;
+            a[6] = 0x00;
+            a[7] = 0x04;
+            // Adding the track end event
+            a[8] = 0x00;
+            a[9] = 0xFF;
+            a[10] = 0x2F;
+            a[11] = 0x00;
+            // Saving the buffer
+            this.datas = new DataView(a.buffer, 0, MIDIFileTrack.HDR_LENGTH + 4);
+            // parsing the given buffer
+        }
+        else {
+            if (!(buffer instanceof ArrayBuffer)) {
+                throw new Error('Invalid buffer received.');
+            }
+            start = start || 0;
+            // Buffer length must size at least like an  empty track (8+3bytes)
+            if (12 > buffer.byteLength - start) {
+                throw new Error('Invalid MIDIFileTrack (0x' + start.toString(16) + ') :' +
+                    ' Buffer length must size at least 12bytes');
+            }
+            // Creating a temporary view to read the track header
+            this.datas = new DataView(buffer, start, MIDIFileTrack.HDR_LENGTH);
+            // Reading MIDI track header chunk
+            if (!('M' === String.fromCharCode(this.datas.getUint8(0)) &&
+                'T' === String.fromCharCode(this.datas.getUint8(1)) &&
+                'r' === String.fromCharCode(this.datas.getUint8(2)) &&
+                'k' === String.fromCharCode(this.datas.getUint8(3)))) {
+                throw new Error('Invalid MIDIFileTrack (0x' + start.toString(16) + ') :' +
+                    ' MTrk prefix not found');
+            }
+            // Reading the track length
+            trackLength = this.getTrackLength();
+            if (buffer.byteLength - start < trackLength + 8) {
+                throw new Error('Invalid MIDIFileTrack (0x' + start.toString(16) + ') :' +
+                    ' The track size exceed the buffer length.');
+            }
+            // Creating the final DataView
+            this.datas = new DataView(buffer, start, MIDIFileTrack.HDR_LENGTH + trackLength);
+            // Trying to find the end of track event
+            if (!(0xFF === this.datas.getUint8(MIDIFileTrack.HDR_LENGTH + trackLength - 3) &&
+                0x2F === this.datas.getUint8(MIDIFileTrack.HDR_LENGTH + trackLength - 2) &&
+                0x00 === this.datas.getUint8(MIDIFileTrack.HDR_LENGTH + trackLength - 1))) {
+                throw new Error('Invalid MIDIFileTrack (0x' + start.toString(16) + ') :' +
+                    ' No track end event found at the expected index' +
+                    ' (' + (MIDIFileTrack.HDR_LENGTH + trackLength - 1).toString(16) + ').');
+            }
+        }
+    }
+    // Track length
+    getTrackLength() {
+        return this.datas.getUint32(4);
+    }
+    setTrackLength(trackLength) {
+        this.datas.setUint32(4, trackLength);
+    }
+    // Read track contents
+    getTrackContent() {
+        return new DataView(this.datas.buffer, this.datas.byteOffset + MIDIFileTrack.HDR_LENGTH, this.datas.byteLength - MIDIFileTrack.HDR_LENGTH);
+    }
+    // Set track content
+    setTrackContent(dataView) {
+        let origin;
+        let destination;
+        let i;
+        let j;
+        // Calculating the track length
+        const trackLength = dataView.byteLength - dataView.byteOffset;
+        // Track length must size at least like an  empty track (4bytes)
+        if (4 > trackLength) {
+            throw new Error('Invalid track length, must size at least 4bytes');
+        }
+        this.datas = new DataView(new Uint8Array(MIDIFileTrack.HDR_LENGTH + trackLength).buffer);
+        // Adding the track header (MTrk)
+        this.datas.setUint8(0, 0x4D); // M
+        this.datas.setUint8(1, 0x54); // T
+        this.datas.setUint8(2, 0x72); // r
+        this.datas.setUint8(3, 0x6B); // k
+        // Adding the track size
+        this.datas.setUint32(4, trackLength);
+        // Copying the content
+        origin = new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength);
+        destination = new Uint8Array(this.datas.buffer, MIDIFileTrack.HDR_LENGTH, trackLength);
+        for (i = 0, j = origin.length; i < j; i++) {
+            destination[i] = origin[i];
+        }
+    }
+}
+module.exports = MIDIFileTrack;
+// Static constants
+MIDIFileTrack.HDR_LENGTH = 8;
+module.exports = MIDIFileTrack;

package/demo-libs/TextEncoding.js

@@ -0,0 +1,275 @@
+"use strict";
+
+/**
+ * Text encoding utilities for MIDI/KAR files
+ * Supports UTF-8, TIS-620, and Windows-874 (cp874)
+ */
+
+var UTF8 = require("./UTF8");
+const TextEncoding = {
+    /**
+     * Detect encoding from bytes
+     */
+    detectEncoding: function (bytes, byteOffset, byteLength) {
+        byteOffset = byteOffset || 0;
+        byteLength = byteLength || (bytes.length - byteOffset);
+        // Try UTF-8 first
+        if (!UTF8.isNotUTF8(bytes, byteOffset, byteLength)) {
+            try {
+                UTF8.getStringFromBytes(bytes, byteOffset, byteLength, true);
+                return 'utf8';
+            }
+            catch (e) {
+                // Not UTF-8
+            }
+        }
+        // Check for TIS-620 or Windows-874 (Thai encodings)
+        // Both use similar byte ranges but have some differences
+        let hasThaiChars = false;
+        let hasWindows874Specific = false;
+        for (let i = byteOffset; i < byteOffset + byteLength && i < bytes.length; i++) {
+            const byte = bytes[i];
+            // TIS-620 range: 0xA1-0xDA, 0xDF-0xFB
+            // Windows-874 range: 0xA1-0xDA, 0xDF-0xFE
+            // Windows-874 has additional characters at 0x80-0x9F
+            if (byte >= 0x80 && byte <= 0x9F) {
+                hasWindows874Specific = true;
+            }
+            if ((byte >= 0xA1 && byte <= 0xDA) || (byte >= 0xDF && byte <= 0xFE)) {
+                hasThaiChars = true;
+            }
+        }
+        if (hasThaiChars || hasWindows874Specific) {
+            // Try to determine which one
+            // Windows-874 is more common and has more characters
+            // We'll try Windows-874 first, then TIS-620
+            return hasWindows874Specific ? 'windows874' : 'tis620';
+        }
+        // Default to latin1 (ISO-8859-1) for single-byte encoding
+        return 'latin1';
+    },
+    /**
+     * Decode bytes using specified encoding
+     */
+    decodeString: function (bytes, byteOffset, byteLength, encoding) {
+        byteOffset = byteOffset || 0;
+        byteLength = byteLength || (bytes.length - byteOffset);
+        // Handle empty data
+        if (byteLength <= 0) {
+            return '';
+        }
+        // Convert to Node.js Buffer for encoding support
+        let buffer;
+        try {
+            if (Buffer.isBuffer(bytes)) {
+                buffer = bytes.slice(byteOffset, byteOffset + byteLength);
+            }
+            else if (bytes instanceof Uint8Array) {
+                buffer = Buffer.from(bytes.buffer, bytes.byteOffset + byteOffset, byteLength);
+            }
+            else if (Array.isArray(bytes)) {
+                // Array
+                buffer = Buffer.from(bytes.slice(byteOffset, byteOffset + byteLength));
+            }
+            else {
+                throw new Error('Invalid bytes type');
+            }
+        }
+        catch (e) {
+            throw new Error('Failed to convert bytes to buffer: ' + e.message);
+        }
+        // Use Node.js Buffer's built-in encoding support
+        switch (encoding) {
+            case 'utf8':
+                try {
+                    return UTF8.getStringFromBytes(bytes, byteOffset, byteLength, true);
+                }
+                catch (e) {
+                    try {
+                        return buffer.toString('utf8');
+                    }
+                    catch (e2) {
+                        throw new Error('UTF-8 decoding failed');
+                    }
+                }
+            case 'tis620':
+                // TIS-620 is not directly supported by Node.js Buffer
+                // Use manual conversion (always succeeds)
+                return TextEncoding.decodeTIS620(buffer);
+            case 'windows874':
+            case 'cp874':
+                // Try Node.js built-in win874, fallback to manual decoding
+                try {
+                    return buffer.toString('win874');
+                }
+                catch (e) {
+                    // Fallback to manual decoding (always succeeds)
+                    return TextEncoding.decodeWindows874(buffer);
+                }
+            case 'latin1':
+            case 'binary':
+                try {
+                    return buffer.toString('latin1');
+                }
+                catch (e) {
+                    throw new Error('Latin1 decoding failed');
+                }
+            default:
+                // Try auto-detect
+                try {
+                    const detected = TextEncoding.detectEncoding(bytes, byteOffset, byteLength);
+                    return TextEncoding.decodeString(bytes, byteOffset, byteLength, detected);
+                }
+                catch (e) {
+                    throw new Error('Auto-detection failed: ' + e.message);
+                }
+        }
+    },
+    /**
+     * Decode TIS-620 encoding
+     * TIS-620 is Thai Industrial Standard 620-2533
+     */
+    decodeTIS620: function (bytes) {
+        // TIS-620 to Unicode mapping for Thai characters
+        // Range: 0xA1-0xDA, 0xDF-0xFB
+        // Convert to array if needed
+        const byteArray = bytes instanceof Uint8Array ? bytes :
+            Buffer.isBuffer(bytes) ? new Uint8Array(bytes) :
+                new Uint8Array(bytes);
+        let result = '';
+        for (let i = 0; i < byteArray.length; i++) {
+            const byte = byteArray[i];
+            if (byte < 0x80) {
+                // ASCII range
+                result += String.fromCharCode(byte);
+            }
+            else if (byte >= 0xA1 && byte <= 0xDA) {
+                // Thai characters: 0xA1-0xDA maps to U+0E01-U+0E3A
+                result += String.fromCharCode(0x0E01 + (byte - 0xA1));
+            }
+            else if (byte >= 0xDF && byte <= 0xFB) {
+                // Thai characters: 0xDF-0xFB maps to U+0E3F-U+0E5B
+                result += String.fromCharCode(0x0E3F + (byte - 0xDF));
+            }
+            else {
+                // Unknown byte, use replacement character or original
+                result += String.fromCharCode(byte);
+            }
+        }
+        return result;
+    },
+    /**
+     * Decode Windows-874 (CP874) encoding
+     * Windows-874 is similar to TIS-620 but has additional characters
+     */
+    decodeWindows874: function (bytes) {
+        // Windows-874 to Unicode mapping
+        // Similar to TIS-620 but with additional characters at 0x80-0x9F
+        // Convert to array if needed
+        const byteArray = bytes instanceof Uint8Array ? bytes :
+            Buffer.isBuffer(bytes) ? new Uint8Array(bytes) :
+                new Uint8Array(bytes);
+        let result = '';
+        for (let i = 0; i < byteArray.length; i++) {
+            const byte = byteArray[i];
+            if (byte < 0x80) {
+                // ASCII range
+                result += String.fromCharCode(byte);
+            }
+            else if (byte >= 0x80 && byte <= 0x9F) {
+                // Windows-874 specific characters (currency symbols, etc.)
+                // Map to Unicode equivalents
+                const win874Map = {
+                    0x80: 0x20AC, // Euro sign
+                    0x82: 0x201A, // Single low-9 quotation mark
+                    0x83: 0x0192, // Latin small letter f with hook
+                    0x84: 0x201E, // Double low-9 quotation mark
+                    0x85: 0x2026, // Horizontal ellipsis
+                    0x86: 0x2020, // Dagger
+                    0x87: 0x2021, // Double dagger
+                    0x88: 0x02C6, // Modifier letter circumflex accent
+                    0x89: 0x2030, // Per mille sign
+                    0x8A: 0x2039, // Single left-pointing angle quotation mark
+                    0x8B: 0x203A, // Single right-pointing angle quotation mark
+                    0x8C: 0x2018, // Left single quotation mark
+                    0x8D: 0x2019, // Right single quotation mark
+                    0x8E: 0x201C, // Left double quotation mark
+                    0x8F: 0x201D, // Right double quotation mark
+                    0x90: 0x2013, // En dash
+                    0x91: 0x2014, // Em dash
+                    0x92: 0x02DC, // Small tilde
+                    0x93: 0x2122, // Trade mark sign
+                    0x94: 0x0161, // Latin small letter s with caron
+                    0x95: 0x203A, // Single right-pointing angle quotation mark
+                    0x96: 0x0152, // Latin capital ligature OE
+                    0x97: 0x0153, // Latin small ligature oe
+                    0x98: 0x0160, // Latin capital letter S with caron
+                    0x99: 0x0178, // Latin capital letter Y with diaeresis
+                    0x9A: 0x017E, // Latin small letter z with caron
+                    0x9B: 0x017D, // Latin capital letter Z with caron
+                };
+                if (win874Map[byte]) {
+                    result += String.fromCharCode(win874Map[byte]);
+                }
+                else {
+                    result += String.fromCharCode(byte);
+                }
+            }
+            else if (byte >= 0xA1 && byte <= 0xDA) {
+                // Thai characters: 0xA1-0xDA maps to U+0E01-U+0E3A
+                result += String.fromCharCode(0x0E01 + (byte - 0xA1));
+            }
+            else if (byte >= 0xDF && byte <= 0xFE) {
+                // Thai characters: 0xDF-0xFE maps to U+0E3F-U+0E5E
+                result += String.fromCharCode(0x0E3F + (byte - 0xDF));
+            }
+            else {
+                // Unknown byte
+                result += String.fromCharCode(byte);
+            }
+        }
+        return result;
+    },
+    /**
+     * Auto-detect and decode string from bytes
+     */
+    autoDecode: function (bytes, byteOffset, byteLength) {
+        const encoding = TextEncoding.detectEncoding(bytes, byteOffset, byteLength);
+        return TextEncoding.decodeString(bytes, byteOffset, byteLength, encoding);
+    },
+    /**
+     * Decode with fallback chain: TIS-620 → Windows-874 → UTF-8
+     * This is the recommended method for lyrics decoding in MIDI/KAR files
+     */
+    decodeWithFallback: function (bytes, byteOffset, byteLength) {
+        byteOffset = byteOffset || 0;
+        byteLength = byteLength || (bytes.length - byteOffset);
+        // Try TIS-620 first (common for Thai karaoke files)
+        try {
+            return TextEncoding.decodeString(bytes, byteOffset, byteLength, 'tis620');
+        }
+        catch (e) {
+            // Continue to next encoding
+        }
+        // Try Windows-874 if TIS-620 failed
+        try {
+            return TextEncoding.decodeString(bytes, byteOffset, byteLength, 'windows874');
+        }
+        catch (e) {
+            // Continue to next encoding
+        }
+        // Try UTF-8 as final fallback
+        try {
+            return TextEncoding.decodeString(bytes, byteOffset, byteLength, 'utf8');
+        }
+        catch (e) {
+            // Ultimate fallback: simple character mapping
+            let result = '';
+            for (let i = byteOffset; i < byteOffset + byteLength && i < bytes.length; i++) {
+                result += String.fromCharCode(bytes[i]);
+            }
+            return result;
+        }
+    }
+};
+module.exports = TextEncoding;

package/demo-libs/UTF8.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * UTF8 : Manage UTF-8 strings in ArrayBuffers
+ */
+const UTF8 = {
+    // non UTF8 encoding detection (cf README file for details)
+    isNotUTF8: function (bytes, byteOffset, byteLength) {
+        try {
+            UTF8.getStringFromBytes(bytes, byteOffset, byteLength, true);
+        }
+        catch (e) {
+            return true;
+        }
+        return false;
+    },
+    // UTF8 decoding functions
+    getCharLength: function (theByte) {
+        // 4 bytes encoded char (mask 11110000)
+        if (0xF0 === (theByte & 0xF0)) {
+            return 4;
+            // 3 bytes encoded char (mask 11100000)
+        }
+        else if (0xE0 === (theByte & 0xE0)) {
+            return 3;
+            // 2 bytes encoded char (mask 11000000)
+        }
+        else if (0xC0 === (theByte & 0xC0)) {
+            return 2;
+            // 1 bytes encoded char
+        }
+        else if (theByte === (theByte & 0x7F)) {
+            return 1;
+        }
+        return 0;
+    },
+    getCharCode: function (bytes, byteOffset, charLength) {
+        let charCode = 0;
+        let mask = '';
+        byteOffset = byteOffset || 0;
+        // Retrieve charLength if not given
+        charLength = charLength || UTF8.getCharLength(bytes[byteOffset]);
+        if (charLength === 0) {
+            throw new Error(bytes[byteOffset].toString(2) + ' is not a significative' +
+                ' byte (offset:' + byteOffset + ').');
+        }
+        // Return byte value if charlength is 1
+        if (1 === charLength) {
+            return bytes[byteOffset];
+        }
+        // Test UTF8 integrity
+        mask = '00000000'.slice(0, charLength) + '1' + '00000000'.slice(charLength + 1);
+        if (bytes[byteOffset] & (parseInt(mask, 2))) {
+            throw new Error('Index ' + byteOffset + ': A ' + charLength + ' bytes' +
+                ' encoded char' + ' cannot encode the ' + (charLength + 1) + 'th rank bit to 1.');
+        }
+        // Reading the first byte
+        mask = '0000'.slice(0, charLength + 1) + '11111111'.slice(charLength + 1);
+        charCode += (bytes[byteOffset] & parseInt(mask, 2)) << ((--charLength) * 6);
+        // Reading the next bytes
+        while (charLength) {
+            if (0x80 !== (bytes[byteOffset + 1] & 0x80)
+                || 0x40 === (bytes[byteOffset + 1] & 0x40)) {
+                throw new Error('Index ' + (byteOffset + 1) + ': Next bytes of encoded char' +
+                    ' must begin with a "10" bit sequence.');
+            }
+            charCode += ((bytes[++byteOffset] & 0x3F) << ((--charLength) * 6));
+        }
+        return charCode;
+    },
+    getStringFromBytes: function (bytes, byteOffset, byteLength, strict) {
+        let charLength;
+        const chars = [];
+        const offset = byteOffset || 0;
+        const length = ('number' === typeof byteLength ?
+            byteLength :
+            (bytes instanceof Uint8Array ? bytes.byteLength : bytes.length));
+        for (let i = offset; i < length; i++) {
+            charLength = UTF8.getCharLength(bytes[i]);
+            if (i + charLength > length) {
+                if (strict) {
+                    throw new Error('Index ' + i + ': Found a ' + charLength +
+                        ' bytes encoded char declaration but only ' +
+                        (length - i) + ' bytes are available.');
+                }
+            }
+            else {
+                chars.push(String.fromCodePoint(UTF8.getCharCode(bytes, i, charLength)));
+            }
+            i += charLength - 1;
+        }
+        return chars.join('');
+    },
+    // UTF8 encoding functions
+    getBytesForCharCode: function (charCode) {
+        if (charCode < 128) {
+            return 1;
+        }
+        else if (charCode < 2048) {
+            return 2;
+        }
+        else if (charCode < 65536) {
+            return 3;
+        }
+        else if (charCode < 2097152) {
+            return 4;
+        }
+        throw new Error('CharCode ' + charCode + ' cannot be encoded with UTF8.');
+    },
+    setBytesFromCharCode: function (charCode, bytes, byteOffset, neededBytes) {
+        charCode = charCode | 0;
+        bytes = bytes || [];
+        const offset = byteOffset || 0;
+        const needed = neededBytes || UTF8.getBytesForCharCode(charCode);
+        // Setting the charCode as it to bytes if the byte length is 1
+        let currentOffset = offset;
+        if (1 === needed) {
+            bytes[currentOffset] = charCode;
+        }
+        else {
+            let remainingBytes = needed;
+            // Computing the first byte
+            bytes[currentOffset++] =
+                (parseInt('1111'.slice(0, remainingBytes), 2) << (8 - remainingBytes)) +
+                    (charCode >>> ((--remainingBytes) * 6));
+            // Computing next bytes
+            for (; remainingBytes > 0;) {
+                bytes[currentOffset++] = ((charCode >>> ((--remainingBytes) * 6)) & 0x3F) | 0x80;
+            }
+        }
+        return bytes;
+    },
+    setBytesFromString: function (string, bytes, byteOffset, byteLength, strict) {
+        string = string || '';
+        bytes = bytes || [];
+        let offset = byteOffset || 0;
+        const length = ('number' === typeof byteLength ?
+            byteLength :
+            Infinity);
+        for (let i = 0, j = string.length; i < j; i++) {
+            const neededBytes = UTF8.getBytesForCharCode(string[i].codePointAt(0));
+            if (strict && offset + neededBytes > length) {
+                throw new Error('Not enought bytes to encode the char "' + string[i] +
+                    '" at the offset "' + offset + '".');
+            }
+            UTF8.setBytesFromCharCode(string[i].codePointAt(0), bytes, offset, neededBytes);
+            offset += neededBytes;
+        }
+        return bytes;
+    }
+};
+module.exports = UTF8;

package/demo-server.js

@@ -170,6 +170,83 @@ app.post('/api/convert', express.json(), async (req, res) => {
   }
 });
 
+// API: Get MIDI events for playback
+app.post('/api/parse-kar', express.json(), async (req, res) => {
+  try {
+    const { karData } = req.body;
+    
+    if (!karData) {
+      return res.status(400).json({ success: false, error: 'KAR data required' });
+    }
+    
+    console.log('Parsing KAR for playback...');
+    
+    // Decode base64 to buffer
+    const karBuffer = Buffer.from(karData, 'base64');
+    
+    // Use karaoke-player to get lyrics
+    const KarFile = require('./demo-libs/KarFile');
+    const karFile = new KarFile();
+    karFile.readBuffer(karBuffer);
+    const lyrics = karFile.getLyrics();
+    
+    // Use Tone.js for accurate MIDI parsing (handles tempo correctly!)
+    const midi = new Midi(karBuffer);
+    
+    // Extract all note events with accurate timing from Tone.js
+    const allEvents = [];
+    
+    midi.tracks.forEach((track, trackIdx) => {
+      track.notes.forEach(note => {
+        // Note ON
+        allEvents.push({
+          track: trackIdx,
+          time: note.time * 1000, // Convert seconds to milliseconds
+          type: 9, // NOTE_ON
+          channel: 0,
+          note: note.midi,
+          velocity: Math.round(note.velocity * 127)
+        });
+        
+        // Note OFF
+        allEvents.push({
+          track: trackIdx,
+          time: (note.time + note.duration) * 1000, // Convert seconds to milliseconds
+          type: 8, // NOTE_OFF
+          channel: 0,
+          note: note.midi,
+          velocity: 0
+        });
+      });
+    });
+    
+    // Sort events by time
+    allEvents.sort((a, b) => a.time - b.time);
+    
+    res.json({
+      success: true,
+      midiData: {
+        format: midi.header.format,
+        trackCount: midi.tracks.length,
+        ticksPerBeat: midi.header.ppq,
+        timeDivision: 2
+      },
+      events: allEvents,
+      lyrics: lyrics,
+      totalEvents: allEvents.length,
+      duration: midi.duration * 1000 // milliseconds
+    });
+    
+  } catch (error) {
+    console.error('Parse error:', error);
+    res.status(500).json({ 
+      success: false, 
+      error: error.message,
+      stack: error.stack
+    });
+  }
+});
+
 // Start server
 app.listen(PORT, () => {
   console.log('='.repeat(80));
@@ -177,7 +254,7 @@ app.listen(PORT, () => {
   console.log('='.repeat(80));
   console.log('');
   console.log(`Server running at: http://localhost:${PORT}`);
-  console.log(`Demo page: http://localhost:${PORT}/demo-client.html`);
+  console.log(`Demo page: http://localhost:${PORT}/demo-simple.html`);
   console.log('');
   console.log('Press Ctrl+C to stop');
   console.log('');