@karaplay/file-coder 1.5.0 → 1.5.2

package/demo-libs/KarFile.js

@@ -0,0 +1,391 @@
+"use strict";
+/**
+ * KarFile : Read and parse KAR (karaoke) files
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const MIDIFile_1 = __importDefault(require("./MIDIFile"));
+const TextEncoding_1 = __importDefault(require("./TextEncoding"));
+class KarFile {
+    constructor() {
+        this.fileName = null;
+        this.midiFile = null;
+        this.midiData = null;
+    }
+    /**
+     * Decode bytes with fallback: TIS-620 -> Windows-874 -> UTF-8 (validated)
+     * TIS-620 is a single-byte Thai encoding used in NCN KAR files
+     * This matches the logic from KarFileTIS.js
+     */
+    decodeTIS620(bytes) {
+        if (!bytes || bytes.length === 0) {
+            return '';
+        }
+        // Convert to Buffer if needed
+        let buffer;
+        if (Buffer.isBuffer(bytes)) {
+            buffer = bytes;
+        }
+        else if (bytes instanceof Uint8Array) {
+            buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        }
+        else if (Array.isArray(bytes)) {
+            buffer = Buffer.from(bytes);
+        }
+        else {
+            buffer = Buffer.from(bytes);
+        }
+        // Strategy 1: Try Windows-874 first (for Thai KAR files)
+        // Windows-874 is compatible with TIS-620 for Thai characters
+        try {
+            const decoded = buffer.toString('win874');
+            // Check if result looks valid (has Thai characters or is readable)
+            if (decoded && !decoded.includes('\ufffd')) {
+                // Check if it contains Thai characters (U+0E00-U+0E7F range)
+                const hasThai = /[\u0E00-\u0E7F]/.test(decoded);
+                // Check if it's not garbled (no weird control chars except common ones)
+                const isReadable = !/[^\x20-\x7E\u0E00-\u0E7F\n\r\t]/.test(decoded) || hasThai;
+                if (isReadable) {
+                    console.log('  ✓ Decoded as Windows-874 (TIS-620)');
+                    return decoded;
+                }
+            }
+        }
+        catch (e) {
+            // Continue to next strategy
+        }
+        // Strategy 2: Try UTF-8 with validation
+        try {
+            const utf8Decoded = buffer.toString('utf8');
+            // Validate UTF-8: check for replacement characters and valid UTF-8 sequences
+            if (utf8Decoded && !utf8Decoded.includes('\ufffd')) {
+                // Additional validation: check if it's valid UTF-8
+                // Try encoding back to see if it's valid
+                try {
+                    const reencoded = Buffer.from(utf8Decoded, 'utf8');
+                    // Compare byte-by-byte (allow some tolerance for multi-byte sequences)
+                    let isValid = true;
+                    if (reencoded.length === buffer.length) {
+                        // Same length, check if bytes match
+                        for (let i = 0; i < Math.min(reencoded.length, buffer.length); i++) {
+                            if (reencoded[i] !== buffer[i]) {
+                                isValid = false;
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        // Different length - might be valid UTF-8 but different encoding
+                        // Check if decoded text is readable
+                        isValid = /^[\x20-\x7E\u00A0-\uFFFF\n\r\t]*$/.test(utf8Decoded);
+                    }
+                    if (isValid && utf8Decoded.length > 0) {
+                        console.log('  ✓ Decoded as UTF-8 (validated)');
+                        return utf8Decoded;
+                    }
+                }
+                catch (e) {
+                    // Validation failed, continue
+                }
+            }
+        }
+        catch (e) {
+            // Continue to next strategy
+        }
+        // Strategy 3: Manual TIS-620 to Unicode conversion (fallback)
+        console.log('  ⚠️ Using manual TIS-620 conversion (fallback)');
+        return TextEncoding_1.default.decodeTIS620(buffer);
+    }
+    readFile(filePath, callback) {
+        fs.readFile(filePath, (err, buffer) => {
+            if (err) {
+                return callback(err);
+            }
+            this.fileName = path.basename(filePath, path.extname(filePath));
+            this.readBuffer(buffer);
+            callback(null, this);
+        });
+    }
+    readBuffer(buffer) {
+        console.log("=== KarFile.readBuffer() ===");
+        console.log("Buffer size:", buffer.byteLength || buffer.length, "bytes");
+        // Convert Node.js Buffer to ArrayBuffer if needed
+        let arrayBuffer;
+        if (Buffer.isBuffer(buffer)) {
+            // Convert Node.js Buffer to ArrayBuffer
+            arrayBuffer = new Uint8Array(buffer).buffer;
+        }
+        else if (buffer instanceof ArrayBuffer) {
+            arrayBuffer = 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 {
+            throw new Error('Invalid buffer type');
+        }
+        const midiFile = new MIDIFile_1.default(arrayBuffer);
+        this.midiFile = midiFile;
+        console.log("MIDI File created:", midiFile);
+        this.midiData = {
+            format: midiFile.header.getFormat(), // 0, 1 or 2
+            trackCount: midiFile.header.getTracksCount(), // n
+            timeDivision: midiFile.header.getTimeDivision(),
+        };
+        console.log("MIDI Data:", this.midiData);
+        // Time division
+        if (midiFile.header.getTimeDivision() === MIDIFile_1.default.Header.TICKS_PER_BEAT) {
+            this.midiData.ticksPerBeat = midiFile.header.getTicksPerBeat();
+            console.log("Ticks per beat:", this.midiData.ticksPerBeat);
+        }
+        else {
+            this.midiData.frames = midiFile.header.getSMPTEFrames();
+            this.midiData.ticksPerFrame = midiFile.header.getTicksPerFrame();
+            console.log("SMPTE Frames:", this.midiData.frames);
+            console.log("Ticks per frame:", this.midiData.ticksPerFrame);
+        }
+        console.log("=== End readBuffer() ===\n");
+    }
+    readEvents() {
+        this.MIDIEvents = this.midiFile.getMidiEvents();
+        this.trackEvents = [];
+        for (const idx in this.MIDIEvents) {
+            const ev = this.MIDIEvents[idx];
+            if (!this.trackEvents[ev.track]) {
+                this.trackEvents[ev.track] = [];
+            }
+            this.trackEvents[ev.track].push(ev);
+        }
+        return this.trackEvents;
+    }
+    convertText(txt) {
+        return txt.replace(/\\/g, "\n").replace(/\//g, "\n");
+    }
+    getText() {
+        console.log("=== KarFile.getText() ===");
+        this.textEvents = this.midiFile.getLyrics();
+        console.log("Text Events count:", this.textEvents.length);
+        this.text = [];
+        for (const idx in this.textEvents) {
+            const ev = this.textEvents[idx];
+            // ALWAYS decode from raw data as TIS-620 (NCN KAR files use TIS-620)
+            let decodedText = '';
+            if (ev.data) {
+                try {
+                    let bytes = null;
+                    if (ev.data instanceof Uint8Array) {
+                        bytes = ev.data;
+                    }
+                    else if (Array.isArray(ev.data)) {
+                        bytes = new Uint8Array(ev.data);
+                    }
+                    else if (Buffer.isBuffer(ev.data)) {
+                        bytes = ev.data;
+                    }
+                    if (bytes && bytes.length > 0) {
+                        // Always decode as TIS-620
+                        decodedText = this.decodeTIS620(bytes);
+                    }
+                    else {
+                        decodedText = ev.text || '';
+                    }
+                }
+                catch (e) {
+                    console.warn(`  Event ${idx}: Failed to decode TIS-620:`, e.message);
+                    decodedText = ev.text || '';
+                }
+            }
+            else {
+                decodedText = ev.text || '';
+            }
+            if (!this.text[ev.track]) {
+                this.text[ev.track] = "";
+            }
+            this.text[ev.track] += this.convertText(decodedText);
+        }
+        console.log("Text by track:");
+        for (const trackIdx in this.text) {
+            console.log(`  Track ${trackIdx}: ${this.text[trackIdx].substring(0, 100)}${this.text[trackIdx].length > 100 ? '...' : ''}`);
+        }
+        console.log("=== End getText() ===\n");
+        return this.text;
+    }
+    addLyrics(stime, line, trk, parts) {
+        if (!this.trackLines) {
+            this.trackLines = [];
+        }
+        if (this.trackLines.length === 0) {
+            const itime = Math.max(1, stime - 5000);
+            const diff = Math.floor((stime - itime) / 5);
+            const introParts = [
+                { time: itime, text: "*" },
+                { time: itime + diff * 1, text: "*" },
+                { time: itime + diff * 2, text: "*" },
+                { time: itime + diff * 3, text: "*" },
+                { time: itime + diff * 4, text: "*" }
+            ];
+            if (line.trim() === "") {
+                stime = itime;
+                line = "*****";
+                parts = introParts;
+            }
+            else {
+                this.trackLines.push({ time: itime, text: "*****", track: trk, parts: introParts });
+            }
+        }
+        this.trackLines.push({ time: stime, text: line, track: trk, parts: parts });
+    }
+    getLyrics() {
+        console.log("=== KarFile.getLyrics() ===");
+        if (!this.textEvents) {
+            this.textEvents = this.midiFile.getLyrics();
+        }
+        console.log("Text Events:", this.textEvents.length);
+        const trackLyrics = [];
+        for (const idx in this.textEvents) {
+            const ev = this.textEvents[idx];
+            // ALWAYS decode from raw data as TIS-620 (NCN KAR files use TIS-620)
+            // Library's getLyrics() decodes as UTF-8 which is wrong for Thai KAR files
+            let decodedText = '';
+            // Priority: decode from ev.data (raw bytes) as TIS-620
+            if (ev.data) {
+                try {
+                    let bytes = null;
+                    if (ev.data instanceof Uint8Array) {
+                        bytes = ev.data;
+                    }
+                    else if (Array.isArray(ev.data)) {
+                        bytes = new Uint8Array(ev.data);
+                    }
+                    else if (Buffer.isBuffer(ev.data)) {
+                        bytes = ev.data;
+                    }
+                    if (bytes && bytes.length > 0) {
+                        // Always decode as TIS-620 for NCN KAR files
+                        decodedText = this.decodeTIS620(bytes);
+                        console.log(`  Event ${idx}: Decoded from TIS-620, bytes=${bytes.length}, result="${decodedText.substring(0, 30)}${decodedText.length > 30 ? '...' : ''}"`);
+                    }
+                    else {
+                        // Fallback to ev.text if no data
+                        decodedText = ev.text || '';
+                        console.log(`  Event ${idx}: No raw data, using ev.text="${decodedText.substring(0, 30)}${decodedText.length > 30 ? '...' : ''}"`);
+                    }
+                }
+                catch (e) {
+                    console.warn(`  Event ${idx}: Failed to decode TIS-620:`, e.message);
+                    // Fallback
+                    decodedText = ev.text || '';
+                }
+            }
+            else {
+                // No ev.data, use ev.text as fallback
+                decodedText = ev.text || '';
+                console.log(`  Event ${idx}: No ev.data, using ev.text="${decodedText.substring(0, 30)}${decodedText.length > 30 ? '...' : ''}"`);
+            }
+            // Skip base64-like data (header markers)
+            if (decodedText && decodedText.length > 50 && /^[A-Za-z0-9+/=]+$/.test(decodedText)) {
+                console.log(`  Event ${idx}: Skipping base64 data`);
+                continue;
+            }
+            if (decodedText && decodedText.indexOf('LyrHdr') === 0) {
+                console.log(`  Event ${idx}: Skipping LyrHdr marker`);
+                continue;
+            }
+            // Skip empty text
+            if (!decodedText || decodedText.trim().length === 0) {
+                continue;
+            }
+            const text = this.convertText(decodedText);
+            const time = Math.round(ev.playTime);
+            console.log(`  Event ${idx}: track=${ev.track}, time=${time}ms, text="${text.substring(0, 30)}${text.length > 30 ? '...' : ''}"`);
+            if (!trackLyrics[ev.track]) {
+                trackLyrics[ev.track] = [];
+            }
+            trackLyrics[ev.track].push({ text: text, time: time });
+        }
+        console.log("\nProcessing lyrics by track...");
+        for (const trk in trackLyrics) {
+            console.log(`  Track ${trk}: ${trackLyrics[trk].length} lyric events`);
+        }
+        for (const trk in trackLyrics) {
+            let parts = [];
+            let line = "";
+            let startTime = 0;
+            const lyrics = trackLyrics[trk];
+            for (const idx in lyrics) {
+                const time = lyrics[idx].time;
+                let text = lyrics[idx].text;
+                if (text.charAt(0) === "\n") {
+                    const stime = parts.length > 0 ? parts[0].time : time;
+                    this.addLyrics(stime, line, parseInt(trk), parts);
+                    parts = [];
+                    startTime = 0;
+                    line = "";
+                    text = text.substring(1);
+                }
+                if (startTime === 0) {
+                    startTime = time;
+                }
+                line += text;
+                parts.push({ time: time, text: text });
+                if (line.charAt(line.length - 1) === "\n" && parts.length > 0) {
+                    const finalTime = parts[0].time;
+                    this.addLyrics(finalTime, line, parseInt(trk), parts);
+                    startTime = 0;
+                    parts = [];
+                    line = "";
+                }
+            }
+        }
+        console.log("Track Lines:", this.trackLines ? this.trackLines.length : 0);
+        if (this.trackLines) {
+            console.log("Sample lines:");
+            for (let i = 0; i < Math.min(5, this.trackLines.length); i++) {
+                const line = this.trackLines[i];
+                console.log(`  Line ${i}: time=${line.time}ms, text="${line.text.substring(0, 50)}${line.text.length > 50 ? '...' : ''}", parts=${line.parts ? line.parts.length : 0}`);
+            }
+        }
+        this.trackLyrics = trackLyrics;
+        console.log("=== End getLyrics() ===\n");
+        return this.trackLines || [];
+    }
+}
+module.exports = KarFile;
+module.exports = KarFile;