libbitsub 1.0.0

package/dist/ts/worker.js

@@ -0,0 +1,342 @@
+/**
+ * Web Worker management for libbitsub.
+ * Handles off-main-thread subtitle parsing and rendering.
+ */
+import { getWasmUrl } from './wasm';
+let sharedWorker = null;
+let workerInitPromise = null;
+let messageId = 0;
+const pendingCallbacks = new Map();
+/** Check if Web Workers are available. */
+export function isWorkerAvailable() {
+    return typeof Worker !== 'undefined' && typeof window !== 'undefined' && typeof Blob !== 'undefined';
+}
+/** Create inline worker script with embedded WASM loader. */
+function createWorkerScript() {
+    return `
+let wasmModule = null;
+let pgsParser = null;
+let vobSubParser = null;
+
+// Minimal WASM bindings (inlined from wasm-bindgen output)
+let wasm;
+let cachedUint8Memory = null;
+let WASM_VECTOR_LEN = 0;
+let cachedTextEncoder = new TextEncoder();
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+function getUint8Memory() {
+    if (cachedUint8Memory === null || cachedUint8Memory.byteLength === 0) {
+        cachedUint8Memory = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory;
+}
+
+function passArray8ToWasm(arg) {
+    const ptr = wasm.__wbindgen_malloc(arg.length);
+    getUint8Memory().set(arg, ptr);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+        return cachedTextEncoder.encodeInto(arg, view);
+    }
+    : function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return { read: arg.length, written: buf.length };
+    });
+
+function passStringToWasm(arg) {
+    let len = arg.length;
+    let ptr = wasm.__wbindgen_malloc(len);
+    const mem = getUint8Memory();
+    let offset = 0;
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) arg = arg.slice(offset);
+        ptr = wasm.__wbindgen_realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+        offset += ret.written;
+    }
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function getStringFromWasm(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory().subarray(ptr, ptr + len));
+}
+
+async function initWasm(wasmUrl) {
+    if (wasm) return;
+    
+    console.log('[libbitsub worker] Fetching WASM from:', wasmUrl);
+    const response = await fetch(wasmUrl);
+    if (!response.ok) {
+        throw new Error('Failed to fetch WASM: ' + response.status);
+    }
+    
+    // Try to load the JS glue file
+    const jsGlueUrl = wasmUrl.replace('_bg.wasm', '.js').replace('.wasm', '.js');
+    console.log('[libbitsub worker] Loading JS glue from:', jsGlueUrl);
+    
+    try {
+        const mod = await import(/* webpackIgnore: true */ jsGlueUrl);
+        const wasmBytes = await response.arrayBuffer();
+        await mod.default(wasmBytes);
+        wasmModule = mod;
+        wasm = mod.__wasm || mod;
+        console.log('[libbitsub worker] WASM initialized via JS glue');
+    } catch (jsError) {
+        console.warn('[libbitsub worker] JS glue import failed, using direct instantiation:', jsError.message);
+        
+        // Fallback: direct WASM instantiation (limited functionality)
+        const wasmBytes = await response.arrayBuffer();
+        const result = await WebAssembly.instantiate(wasmBytes, {
+            __wbindgen_placeholder__: {
+                __wbindgen_throw: function(ptr, len) {
+                    throw new Error(getStringFromWasm(ptr, len));
+                }
+            }
+        });
+        wasm = result.instance.exports;
+        
+        // Create minimal module interface
+        wasmModule = {
+            PgsParser: class {
+                constructor() { this.ptr = wasm.pgsparser_new(); }
+                parse(data) {
+                    const ptr = passArray8ToWasm(data);
+                    return wasm.pgsparser_parse(this.ptr, ptr, WASM_VECTOR_LEN);
+                }
+                getTimestamps() {
+                    return wasm.pgsparser_getTimestamps(this.ptr);
+                }
+                renderAtIndex(idx) { return wasm.pgsparser_renderAtIndex(this.ptr, idx); }
+                findIndexAtTimestamp(ts) { return wasm.pgsparser_findIndexAtTimestamp(this.ptr, ts); }
+                clearCache() { wasm.pgsparser_clearCache(this.ptr); }
+                free() { wasm.pgsparser_free(this.ptr); }
+                get count() { return wasm.pgsparser_count(this.ptr); }
+            },
+            VobSubParser: class {
+                constructor() { this.ptr = wasm.vobsubparser_new(); }
+                loadFromData(idx, sub) {
+                    const idxPtr = passStringToWasm(idx);
+                    const subPtr = passArray8ToWasm(sub);
+                    wasm.vobsubparser_loadFromData(this.ptr, idxPtr, WASM_VECTOR_LEN, subPtr, sub.length);
+                }
+                loadFromSubOnly(sub) {
+                    const ptr = passArray8ToWasm(sub);
+                    wasm.vobsubparser_loadFromSubOnly(this.ptr, ptr, WASM_VECTOR_LEN);
+                }
+                getTimestamps() {
+                    return wasm.vobsubparser_getTimestamps(this.ptr);
+                }
+                renderAtIndex(idx) { return wasm.vobsubparser_renderAtIndex(this.ptr, idx); }
+                findIndexAtTimestamp(ts) { return wasm.vobsubparser_findIndexAtTimestamp(this.ptr, ts); }
+                clearCache() { wasm.vobsubparser_clearCache(this.ptr); }
+                free() { wasm.vobsubparser_free(this.ptr); }
+                get count() { return wasm.vobsubparser_count(this.ptr); }
+            }
+        };
+        console.log('[libbitsub worker] WASM initialized via direct instantiation');
+    }
+}
+
+function convertFrame(frame, isVobSub) {
+    const compositions = [];
+    if (isVobSub) {
+        const rgba = frame.getRgba();
+        if (frame.width > 0 && frame.height > 0 && rgba.length === frame.width * frame.height * 4) {
+            const rgbaCopy = new Uint8Array(rgba.length);
+            rgbaCopy.set(rgba);
+            compositions.push({ rgba: rgbaCopy, x: frame.x, y: frame.y, width: frame.width, height: frame.height });
+        }
+        return { width: frame.screenWidth, height: frame.screenHeight, compositions };
+    }
+    for (let i = 0; i < frame.compositionCount; i++) {
+        const comp = frame.getComposition(i);
+        if (!comp) continue;
+        const rgba = comp.getRgba();
+        if (comp.width > 0 && comp.height > 0 && rgba.length === comp.width * comp.height * 4) {
+            const rgbaCopy = new Uint8Array(rgba.length);
+            rgbaCopy.set(rgba);
+            compositions.push({ rgba: rgbaCopy, x: comp.x, y: comp.y, width: comp.width, height: comp.height });
+        }
+    }
+    return { width: frame.width, height: frame.height, compositions };
+}
+
+function postResponse(response, transfer, id) {
+    if (id !== undefined) response._id = id;
+    self.postMessage(response, transfer?.length ? transfer : undefined);
+}
+
+self.onmessage = async function(event) {
+    const { _id, ...request } = event.data;
+    try {
+        switch (request.type) {
+            case 'init':
+                await initWasm(request.wasmUrl);
+                postResponse({ type: 'initComplete', success: true }, [], _id);
+                break;
+            case 'loadPgs':
+                pgsParser = new wasmModule.PgsParser();
+                const pgsCount = pgsParser.parse(new Uint8Array(request.data));
+                postResponse({ type: 'pgsLoaded', count: pgsCount, byteLength: request.data.byteLength }, [], _id);
+                break;
+            case 'loadVobSub':
+                vobSubParser = new wasmModule.VobSubParser();
+                vobSubParser.loadFromData(request.idxContent, new Uint8Array(request.subData));
+                postResponse({ type: 'vobSubLoaded', count: vobSubParser.count }, [], _id);
+                break;
+            case 'loadVobSubOnly':
+                vobSubParser = new wasmModule.VobSubParser();
+                vobSubParser.loadFromSubOnly(new Uint8Array(request.subData));
+                postResponse({ type: 'vobSubLoaded', count: vobSubParser.count }, [], _id);
+                break;
+            case 'renderPgsAtIndex': {
+                if (!pgsParser) { postResponse({ type: 'pgsFrame', frame: null }, [], _id); break; }
+                const frame = pgsParser.renderAtIndex(request.index);
+                if (!frame) { postResponse({ type: 'pgsFrame', frame: null }, [], _id); break; }
+                const frameData = convertFrame(frame, false);
+                postResponse({ type: 'pgsFrame', frame: frameData }, frameData.compositions.map(c => c.rgba.buffer), _id);
+                break;
+            }
+            case 'renderVobSubAtIndex': {
+                if (!vobSubParser) { postResponse({ type: 'vobSubFrame', frame: null }, [], _id); break; }
+                const frame = vobSubParser.renderAtIndex(request.index);
+                if (!frame) { postResponse({ type: 'vobSubFrame', frame: null }, [], _id); break; }
+                const frameData = convertFrame(frame, true);
+                postResponse({ type: 'vobSubFrame', frame: frameData }, frameData.compositions.map(c => c.rgba.buffer), _id);
+                break;
+            }
+            case 'findPgsIndex':
+                postResponse({ type: 'pgsIndex', index: pgsParser?.findIndexAtTimestamp(request.timeMs) ?? -1 }, [], _id);
+                break;
+            case 'findVobSubIndex':
+                postResponse({ type: 'vobSubIndex', index: vobSubParser?.findIndexAtTimestamp(request.timeMs) ?? -1 }, [], _id);
+                break;
+            case 'getPgsTimestamps':
+                postResponse({ type: 'pgsTimestamps', timestamps: pgsParser?.getTimestamps() ?? new Float64Array(0) }, [], _id);
+                break;
+            case 'getVobSubTimestamps':
+                postResponse({ type: 'vobSubTimestamps', timestamps: vobSubParser?.getTimestamps() ?? new Float64Array(0) }, [], _id);
+                break;
+            case 'clearPgsCache':
+                pgsParser?.clearCache();
+                postResponse({ type: 'cleared' }, [], _id);
+                break;
+            case 'clearVobSubCache':
+                vobSubParser?.clearCache();
+                postResponse({ type: 'cleared' }, [], _id);
+                break;
+            case 'disposePgs':
+                pgsParser?.free(); pgsParser = null;
+                postResponse({ type: 'disposed' }, [], _id);
+                break;
+            case 'disposeVobSub':
+                vobSubParser?.free(); vobSubParser = null;
+                postResponse({ type: 'disposed' }, [], _id);
+                break;
+        }
+    } catch (error) {
+        postResponse({ type: 'error', message: error instanceof Error ? error.message : String(error) }, [], _id);
+    }
+};`;
+}
+/** Create or get the shared worker instance. */
+export function getOrCreateWorker() {
+    if (sharedWorker)
+        return Promise.resolve(sharedWorker);
+    if (workerInitPromise)
+        return workerInitPromise;
+    workerInitPromise = new Promise((resolve, reject) => {
+        try {
+            console.log('[libbitsub] Creating worker...');
+            const blob = new Blob([createWorkerScript()], { type: 'application/javascript' });
+            const workerUrl = URL.createObjectURL(blob);
+            const worker = new Worker(workerUrl, { type: 'module' });
+            worker.onmessage = (event) => {
+                const { _id, ...response } = event.data;
+                if (_id !== undefined) {
+                    const callback = pendingCallbacks.get(_id);
+                    if (callback) {
+                        pendingCallbacks.delete(_id);
+                        callback.resolve(response);
+                    }
+                }
+            };
+            worker.onerror = (error) => {
+                console.error('[libbitsub] Worker error:', error);
+                if (workerInitPromise) {
+                    workerInitPromise = null;
+                    reject(error);
+                }
+            };
+            sharedWorker = worker;
+            const wasmUrl = getWasmUrl();
+            console.log('[libbitsub] Initializing worker with WASM URL:', wasmUrl);
+            sendToWorker({ type: 'init', wasmUrl })
+                .then(() => {
+                console.log('[libbitsub] Worker initialized successfully');
+                URL.revokeObjectURL(workerUrl);
+                resolve(worker);
+            })
+                .catch((err) => {
+                console.error('[libbitsub] Worker initialization failed:', err);
+                URL.revokeObjectURL(workerUrl);
+                sharedWorker = null;
+                workerInitPromise = null;
+                reject(err);
+            });
+        }
+        catch (error) {
+            console.error('[libbitsub] Failed to create worker:', error);
+            workerInitPromise = null;
+            reject(error);
+        }
+    });
+    return workerInitPromise;
+}
+/** Default timeout for worker operations (30 seconds for large files) */
+const WORKER_TIMEOUT = 30000;
+/** Send a message to the worker with timeout support. */
+export function sendToWorker(request, timeout = WORKER_TIMEOUT) {
+    return new Promise((resolve, reject) => {
+        if (!sharedWorker) {
+            reject(new Error('Worker not initialized'));
+            return;
+        }
+        const id = ++messageId;
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            pendingCallbacks.delete(id);
+            reject(new Error(`Worker operation timed out after ${timeout}ms`));
+        }, timeout);
+        pendingCallbacks.set(id, {
+            resolve: (response) => {
+                clearTimeout(timeoutId);
+                resolve(response);
+            },
+            reject: (error) => {
+                clearTimeout(timeoutId);
+                reject(error);
+            }
+        });
+        const transfers = [];
+        if ('data' in request && request.data instanceof ArrayBuffer)
+            transfers.push(request.data);
+        if ('subData' in request && request.subData instanceof ArrayBuffer)
+            transfers.push(request.subData);
+        sharedWorker.postMessage({ ...request, _id: id }, transfers);
+    });
+}
+//# sourceMappingURL=worker.js.map

package/dist/ts/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../src/ts/worker.ts"],"names":[],"mappings":"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"}

package/dist/wrapper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TypeScript wrapper for the libbitsub Rust rendering engine.
+ * Provides a compatible API with the original libpgs-js implementation.
+ */
+export type { SubtitleData, SubtitleCompositionData, SubtitleDisplaySettings, VideoSubtitleOptions, VideoVobSubOptions, RenderResult, SubtitleFrame, VobSubFrame } from './ts/types';
+export { initWasm, isWasmInitialized } from './ts/wasm';
+export { PgsParser, VobSubParserLowLevel, UnifiedSubtitleParser } from './ts/parsers';
+export { PgsRenderer, VobSubRenderer, type SubtitleRendererStats } from './ts/renderers';
+import { PgsRenderer as _PgsRenderer, VobSubRenderer as _VobSubRenderer } from './ts/renderers';
+import { UnifiedSubtitleParser as _UnifiedSubtitleParser } from './ts/parsers';
+/** @deprecated Use PgsRenderer instead */
+export declare const PGSRenderer: typeof _PgsRenderer;
+/** @deprecated Use VobSubRenderer instead */
+export declare const VobsubRenderer: typeof _VobSubRenderer;
+/** @deprecated Use UnifiedSubtitleParser instead */
+export declare const UnifiedSubtitleRenderer: typeof _UnifiedSubtitleParser;
+//# sourceMappingURL=wrapper.d.ts.map

package/dist/wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../src/wrapper.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,YAAY,EACZ,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGvD,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAGrF,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAMxF,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,cAAc,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAC/F,OAAO,EAAE,qBAAqB,IAAI,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE9E,0CAA0C;AAC1C,eAAO,MAAM,WAAW,qBAAe,CAAA;AAEvC,6CAA6C;AAC7C,eAAO,MAAM,cAAc,wBAAkB,CAAA;AAE7C,oDAAoD;AACpD,eAAO,MAAM,uBAAuB,+BAAyB,CAAA"}

package/dist/wrapper.js

@@ -0,0 +1,22 @@
+/**
+ * TypeScript wrapper for the libbitsub Rust rendering engine.
+ * Provides a compatible API with the original libpgs-js implementation.
+ */
+// Re-export WASM management
+export { initWasm, isWasmInitialized } from './ts/wasm';
+// Re-export parsers
+export { PgsParser, VobSubParserLowLevel, UnifiedSubtitleParser } from './ts/parsers';
+// Re-export renderers
+export { PgsRenderer, VobSubRenderer } from './ts/renderers';
+// =============================================================================
+// Legacy Aliases (for backward compatibility)
+// =============================================================================
+import { PgsRenderer as _PgsRenderer, VobSubRenderer as _VobSubRenderer } from './ts/renderers';
+import { UnifiedSubtitleParser as _UnifiedSubtitleParser } from './ts/parsers';
+/** @deprecated Use PgsRenderer instead */
+export const PGSRenderer = _PgsRenderer;
+/** @deprecated Use VobSubRenderer instead */
+export const VobsubRenderer = _VobSubRenderer;
+/** @deprecated Use UnifiedSubtitleParser instead */
+export const UnifiedSubtitleRenderer = _UnifiedSubtitleParser;
+//# sourceMappingURL=wrapper.js.map

package/dist/wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../src/wrapper.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAcH,4BAA4B;AAC5B,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAEvD,oBAAoB;AACpB,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAErF,sBAAsB;AACtB,OAAO,EAAE,WAAW,EAAE,cAAc,EAA8B,MAAM,gBAAgB,CAAA;AAExF,gFAAgF;AAChF,8CAA8C;AAC9C,gFAAgF;AAEhF,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,cAAc,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAC/F,OAAO,EAAE,qBAAqB,IAAI,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE9E,0CAA0C;AAC1C,MAAM,CAAC,MAAM,WAAW,GAAG,YAAY,CAAA;AAEvC,6CAA6C;AAC7C,MAAM,CAAC,MAAM,cAAc,GAAG,eAAe,CAAA;AAE7C,oDAAoD;AACpD,MAAM,CAAC,MAAM,uBAAuB,GAAG,sBAAsB,CAAA"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "libbitsub",
+  "version": "1.0.0",
+  "author": "altqx",
+  "license": "GPL-3.0-only",
+  "description": "High-performance WASM renderer for graphical subtitles (PGS and VobSub)",
+  "keywords": [
+    "libbitsub",
+    "pgs",
+    "vobsub",
+    "subtitle",
+    "wasm",
+    "rust",
+    "rendering"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./pkg": {
+      "import": "./pkg/libbitsub.js",
+      "types": "./pkg/libbitsub.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "pkg",
+    "src/wrapper.ts"
+  ],
+  "scripts": {
+    "build:wasm": "wasm-pack build --target web --out-dir pkg",
+    "build:wasm:release": "wasm-pack build --release --target web --out-dir pkg",
+    "build:wasm:bundler": "wasm-pack build --target bundler --out-dir pkg-bundler",
+    "build:ts": "tsc",
+    "build": "bun run build:wasm:release && bun run build:ts",
+    "clean": "rm -rf pkg pkg-bundler dist target",
+    "test": "cargo test",
+    "test:wasm": "wasm-pack test --headless --chrome",
+    "format": "cargo fmt && prettier . --write"
+  },
+  "devDependencies": {
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {},
+  "engines": {
+    "node": ">=18"
+  }
+}