libbitsub 1.11.0 → 1.12.1

package/pkg/README.md

@@ -1,6 +1,6 @@
 # libbit(map)sub
 
-High-performance WASM renderer for graphical subtitles (PGS, VobSub, and MKS-embedded VobSub), written in Rust.
+High-performance WASM renderer for graphical subtitles (PGS, VobSub, DVB-SUB, and MKS-embedded VobSub), written in Rust.
 
 Started as a fork of Arcus92's [libpgs-js](https://github.com/Arcus92/libpgs-js), this project was reworked for higher performance and broader format support. It keeps the familiar high-level PGS-oriented API while adding a lower-level parser surface, VobSub support, GPU backends, and worker-backed rendering.
 
@@ -8,6 +8,7 @@ Started as a fork of Arcus92's [libpgs-js](https://github.com/Arcus92/libpgs-js)
 
 - PGS (Blu-ray) subtitle parsing and rendering
 - VobSub (DVD) subtitle parsing and rendering
+- DVB-SUB (ETSI EN 300 743) parsing and rendering via PES/ES and `"DV"` PTS-framed dumps
 - Matroska `.mks` extraction for embedded `S_VOBSUB` tracks
 - WebGPU, WebGL2, and Canvas2D rendering with automatic fallback
 - Worker-backed parsing/rendering for large subtitle files
@@ -33,7 +34,7 @@ https://gist.github.com/user-attachments/assets/a89ae9fe-23e4-4bc3-8cad-16a3f0fe
 
 ### Live demo
 
-https://a.rafasu.com/v
+https://libbitsub.altqx.com
 
 ## Installation
 
@@ -256,6 +257,7 @@ const renderer = new PgsRenderer({
   },
   cacheLimit: 32,
   prefetchWindow: { before: 1, after: 2 },
+  frameAwareSync: true,
   onWarning: (warning) => {
     console.warn(warning.code, warning.message, warning.details)
   },
@@ -269,6 +271,33 @@ const renderer = new PgsRenderer({
 renderer.dispose()
 ```
 
+Mount into a fullscreen shell or Shadow DOM root, reuse a player-owned canvas,
+cap high-DPI backing-store cost, or bypass automatic backend selection:
+
+```ts
+const renderer = new PgsRenderer({
+  video: videoElement,
+  subUrl: '/subtitles/movie.sup',
+  container: shadowRoot, // HTMLElement or ShadowRoot; defaults to video.parentElement
+  canvas: playerOverlayCanvas, // optional; remains mounted after dispose()
+  devicePixelRatioCap: 2,
+  backend: 'webgl2' // 'auto' | 'webgpu' | 'webgl2' | 'worker-offscreen' | 'canvas2d'
+})
+```
+
+An explicitly requested GPU or worker backend falls back to Canvas2D if it cannot
+initialize. A supplied `container` takes precedence over the canvas's current parent;
+without one, an already-mounted caller canvas stays in its existing host. Automatic
+selection does not transfer a caller-owned canvas to a worker; request
+`backend: 'worker-offscreen'` explicitly to allow that ownership transfer.
+
+Frame-aware synchronization is enabled by default. On browsers with
+`requestVideoFrameCallback()`, cue lookup uses the `mediaTime` of the frame sent
+to the compositor instead of polling `video.currentTime`. Older browsers fall
+back to `requestAnimationFrame()` automatically; set `frameAwareSync: false` to
+force that compatibility path. The active path is available as
+`renderer.getSynchronizationMode()` and as `getStats().syncMode`.
+
 ### VobSub renderer
 
 ```ts
@@ -290,6 +319,45 @@ renderer.setDebandThreshold(64)
 renderer.setDebandRange(15)
 ```
 
+### DVB renderer
+
+```ts
+import { DvbRenderer } from 'libbitsub'
+
+const renderer = new DvbRenderer({
+  video: videoElement,
+  subUrl: '/subtitles/track.dvb'
+})
+```
+
+DVB dumps use libbitsub framing:
+
+```
+"DV" | pts_90k_be_u32 | payload_len_be_u32 | payload…
+```
+
+`payload` is a PES data field (`0x20 0x00 …`) or raw segments (`sync_byte 0x0F`). Concatenated MPEG PES packets (`00 00 01 BD`) with PTS are also accepted.
+
+The DVB decoder renders bitmap object coding method 0. Character-string and reserved object coding methods are ignored.
+
+### Live / push streams
+
+PGS and DVB renderers can start without a URL or in-memory subtitle file. Push transport or demuxer chunks as they arrive; calls are processed in order even when they are made before renderer initialization completes.
+
+```ts
+import { DvbRenderer } from 'libbitsub'
+
+const renderer = new DvbRenderer({ video: videoElement })
+
+const added = await renderer.append(dvbPesChunk) // newly indexed cues
+const total = await renderer.flush() // finalize trailing input; total indexed cues
+
+await renderer.reset() // clear cues/caches/display, then reuse the same renderer
+await renderer.append(nextChannelChunk)
+```
+
+`append()` accepts `Uint8Array` or `ArrayBuffer` without detaching the caller's buffer. `flush()` discards incomplete trailing bytes; later appends are still accepted. `reset()` keeps the canvas, worker session, render loop, and configuration alive while clearing the stream state. VobSub does not expose the push API because it depends on its `.idx`/container index.
+
 ### Automatic format detection
 
 ```ts
@@ -302,7 +370,7 @@ const renderer = createAutoSubtitleRenderer({
 })
 ```
 
-Automatic detection uses file hints when available and otherwise inspects the binary payload. `.mks` sources are treated as VobSub only when they contain an embedded `S_VOBSUB` track. If the format cannot be identified confidently, it throws instead of silently forcing a parser.
+Automatic detection uses file hints when available and otherwise inspects the binary payload. `.idx` / `idxContent` still means VobSub. Bare `.sub` is content-probed for DVB before VobSub. `.mks` sources are treated as VobSub only when they contain an embedded `S_VOBSUB` track. If the format cannot be identified confidently, it throws instead of silently forcing a parser.
 
 ## Layout controls
 
@@ -608,7 +676,7 @@ Emitted events:
 | `loaded`          | subtitle format and parser metadata                                               |
 | `error`           | subtitle format and `SubtitleDiagnosticErrorLike`                                 |
 | `warning`         | `SubtitleDiagnosticWarning`                                                       |
-| `renderer-change` | active backend: `webgpu`, `webgl2`, or `canvas2d`                                 |
+| `renderer-change` | active backend: `webgpu`, `webgl2`, `worker-offscreen`, or `canvas2d`             |
 | `worker-state`    | whether worker mode is enabled, ready, fallback status, and the active session ID |
 | `cache-change`    | cached frame count, pending renders, and configured cache limit                   |
 | `cue-change`      | current cue metadata or `null` when nothing is displayed                          |
@@ -634,6 +702,7 @@ const stats = renderer.getStats()
 - `pendingRenders`
 - `totalEntries`
 - `currentIndex`
+- `syncMode`
 
 `getCacheStats()` adds worker/session state for the current renderer cache, while `getLastRenderInfo()` exposes the most recent render outcome with a status of `rendered`, `cleared`, `pending`, `empty`, or `failed`.
 
@@ -683,23 +752,31 @@ const parser = new UnifiedSubtitleParser({
 parser.loadAuto({ data: subtitleBytes, fileName: 'track.sup' })
 ```
 
-## GPU backends
+## GPU / present backends
 
 libbitsub prefers:
 
-1. WebGPU
-2. WebGL2
-3. Canvas2D
+1. WebGPU (main-thread present)
+2. WebGL2 (main-thread present)
+3. Worker OffscreenCanvas (decode + Canvas2D present off the UI thread)
+4. Canvas2D (main-thread fallback for older TVs)
 
 ```ts
-import { isWebGPUSupported } from 'libbitsub'
+import { getRuntimeCapabilities, isWebGPUSupported } from 'libbitsub'
 
 console.log({
-  webgpu: isWebGPUSupported()
+  webgpu: isWebGPUSupported(),
+  capabilities: getRuntimeCapabilities()
 })
 ```
 
-WebGL2 and Canvas2D fallback remain automatic. Use `onWebGPUFallback`, `onWebGL2Fallback`, `onEvent`, or `onWarning` if you need to observe backend changes.
+When Worker OffscreenCanvas is selected, composition/present moves into the shared worker —
+not only parsing — which reduces UI stalls during subtitle track switches on constrained devices.
+The existing transferable RGBA path remains for main-thread GPU/Canvas2D present.
+
+Use `onWebGPUFallback`, `onWebGL2Fallback`, `onEvent`, `onWarning`, or `getRuntimeCapabilities()`
+to observe or explain the active backend path. Set `offscreenRender: false` to force main-thread
+Canvas2D on the software tier.
 
 ## Compatibility & visual regression
 
@@ -736,8 +813,8 @@ Browser/device support matrix (including webOS TV): [docs/COMPATIBILITY.md](./do
 - `warmup(): Promise<void>` / `ready(): Promise<void>` pre-initialize the shared subtitle worker (including in-worker WASM). Safe to call multiple times; concurrent callers share one init promise. Prefer these in TV/player apps before the first track switch.
 - `isWorkerAvailable(): boolean` / `isWorkerReady(): boolean` report worker support and whether the shared worker has finished initializing.
 - `isWebGPUSupported(): boolean` checks WebGPU support.
-- `detectSubtitleFormat(source: AutoSubtitleSource): 'pgs' | 'vobsub' | null` detects the bitmap subtitle format from file hints or binary data.
-- `createAutoSubtitleRenderer(options: AutoVideoSubtitleOptions): PgsRenderer | VobSubRenderer` creates a high-level renderer after format detection.
+- `detectSubtitleFormat(source: AutoSubtitleSource): 'pgs' | 'vobsub' | 'dvb' | null` detects the bitmap subtitle format from file hints or binary data.
+- `createAutoSubtitleRenderer(options: AutoVideoSubtitleOptions): PgsRenderer | VobSubRenderer | DvbRenderer` creates a high-level renderer after format detection.
 - `openSubtitles(source, options?): Promise<OpenedSubtitles>` initializes WASM, auto-detects the low-level format, and returns a normalized parser handle.
 - `probeRangeSupport(url, options?)` / `fetchSubtitleAsset(url, options?, onChunk?)` / `fetchSubtitleText(url, options?)` perform Range-aware progressive asset downloads for custom loaders.
 - `renderFrameData(frame, options?): SubtitleRenderedFrameData | null` composes a `SubtitleData` frame into exportable pixels.
@@ -768,16 +845,23 @@ Browser/device support matrix (including webOS TV): [docs/COMPATIBILITY.md](./do
 - `clearFrameCache(): void` clears the renderer-side and parser-side frame cache.
 - `prefetchRange(startIndex: number, endIndex: number): Promise<void>` prefetches decoded frames for a cue range.
 - `prefetchAroundTime(time: number, before?: number, after?: number): Promise<void>` prefetches around a playback time in seconds.
+- `append(data: Uint8Array | ArrayBuffer): Promise<number>` pushes live bytes and returns newly indexed cues.
+- `flush(): Promise<number>` finalizes trailing input and returns the total cue count.
+- `reset(): Promise<void>` clears live parser, cue, cache, and presentation state for reuse.
 - `dispose(): void` releases DOM, parser, and worker resources.
 
 #### `VobSubRenderer`
 
-- Supports all `PgsRenderer` methods above.
+- Supports the common `PgsRenderer` methods above, except `append()`, `flush()`, and `reset()`.
 - `setDebandEnabled(enabled: boolean): void` enables or disables debanding.
 - `setDebandThreshold(threshold: number): void` updates the deband threshold.
 - `setDebandRange(range: number): void` updates the deband sample range.
 - `debandEnabled: boolean` reports whether debanding is enabled.
 
+#### `DvbRenderer`
+
+- Supports all `PgsRenderer` methods above, including the live push API (no debanding).
+
 ### Low-level parsers
 
 #### `PgsParser`
@@ -795,6 +879,12 @@ Browser/device support matrix (including webOS TV): [docs/COMPATIBILITY.md](./do
 - `clearCache(): void` clears parser-side caches.
 - `dispose(): void` frees parser resources.
 
+#### `DvbParser`
+
+- Same progressive surface as `PgsParser` for `"DV"`-framed dumps and MPEG PES streams.
+- `load(data: Uint8Array): number` / `feed` / `finishFeed` / `renderAtIndex` / `renderAtTimestamp` / `getMetadata` / `getCueMetadata` / `dispose`.
+- `getEndTimestamps(): Float64Array` returns the page-timeout-aware cue end timestamps in milliseconds.
+
 #### `VobSubParserLowLevel`
 
 - `loadFromData(idxContent: string, subData: Uint8Array): void` loads IDX and SUB data (simple in-memory path).
@@ -810,8 +900,9 @@ Browser/device support matrix (including webOS TV): [docs/COMPATIBILITY.md](./do
 - `loadPgs(data: Uint8Array): number` loads PGS data.
 - `loadVobSub(idxContent: string, subData: Uint8Array): void` loads VobSub from IDX and SUB.
 - `loadVobSubOnly(subData: Uint8Array): void` loads SUB-only VobSub data.
+- `loadDvb(data: Uint8Array): number` loads DVB data.
 - `loadAuto(source: AutoSubtitleSource): SubtitleFormatName` detects and loads a supported bitmap subtitle format.
-- `format: 'pgs' | 'vobsub' | null` returns the active format.
+- `format: 'pgs' | 'vobsub' | 'dvb' | null` returns the active format.
 - `getTimestamps()`, `count`, `findIndexAtTimestamp()`, `renderAtIndex()`, `renderAtTimestamp()`, `getMetadata()`, `getCueMetadata()`, `clearCache()`, and `dispose()` are available as on the format-specific parsers.
 
 ### Core option and data types
@@ -821,6 +912,10 @@ Browser/device support matrix (including webOS TV): [docs/COMPATIBILITY.md](./do
 ```ts
 interface VideoSubtitleOptions {
   video: HTMLVideoElement
+  container?: HTMLElement | ShadowRoot
+  canvas?: HTMLCanvasElement
+  devicePixelRatioCap?: number
+  backend?: 'auto' | 'webgpu' | 'webgl2' | 'worker-offscreen' | 'canvas2d'
   subUrl?: string
   subContent?: ArrayBuffer
   workerUrl?: string
@@ -829,6 +924,8 @@ interface VideoSubtitleOptions {
   onError?: (error: Error) => void
   onWebGPUFallback?: () => void
   onWebGL2Fallback?: () => void
+  offscreenRender?: boolean // default true — Worker OffscreenCanvas on Canvas2D tier
+  frameAwareSync?: boolean // default true — sync to presented-frame mediaTime when available
   displaySettings?: Partial<SubtitleDisplaySettings>
   cacheLimit?: number
   prefetchWindow?: {
@@ -883,7 +980,7 @@ type SubtitleRendererEvent =
   | { type: 'loaded'; format: SubtitleFormatName; metadata: SubtitleParserMetadata }
   | { type: 'error'; format: SubtitleFormatName; error: SubtitleDiagnosticErrorLike }
   | { type: 'warning'; warning: SubtitleDiagnosticWarning }
-  | { type: 'renderer-change'; renderer: 'webgpu' | 'webgl2' | 'canvas2d' }
+  | { type: 'renderer-change'; renderer: 'webgpu' | 'webgl2' | 'worker-offscreen' | 'canvas2d' }
   | { type: 'worker-state'; enabled: boolean; ready: boolean; sessionId: string | null; fallback?: boolean }
   | { type: 'cache-change'; cachedFrames: number; pendingRenders: number; cacheLimit: number }
   | { type: 'cue-change'; cue: SubtitleCueMetadata | null }
@@ -916,7 +1013,7 @@ Related diagnostics shapes:
 
 ```ts
 interface SubtitleParserMetadata {
-  format: 'pgs' | 'vobsub'
+  format: 'pgs' | 'vobsub' | 'dvb'
   cueCount: number
   screenWidth: number
   screenHeight: number

package/pkg/libbitsub.d.ts

@@ -1,6 +1,33 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * DVB subtitle parser and renderer exposed to JavaScript.
+ */
+export class DvbParser {
+    free(): void;
+    [Symbol.dispose](): void;
+    clearCache(): void;
+    feed(data: Uint8Array): number;
+    findIndexAtTimestamp(time_ms: number): number;
+    finishFeed(): number;
+    getCueCompositionCount(index: number): number;
+    getCueEndTime(index: number): number;
+    getCuePageState(index: number): number;
+    getCueStartTime(index: number): number;
+    getEndTimestamps(): Float64Array;
+    getTimestamps(): Float64Array;
+    constructor();
+    parse(data: Uint8Array): number;
+    renderAtIndex(index: number): SubtitleFrame | undefined;
+    reset(): void;
+    readonly count: number;
+    readonly lastRenderIssue: string;
+    readonly pendingLen: number;
+    readonly screenHeight: number;
+    readonly screenWidth: number;
+}
+
 /**
  * PGS subtitle parser and renderer exposed to JavaScript.
  */
@@ -65,6 +92,7 @@ export class SubtitleComposition {
 export enum SubtitleFormat {
     Pgs = 0,
     VobSub = 1,
+    Dvb = 2,
 }
 
 /**
@@ -81,7 +109,7 @@ export class SubtitleFrame {
 }
 
 /**
- * Unified subtitle renderer for both PGS and VobSub formats.
+ * Unified subtitle renderer for PGS, VobSub, and DVB formats.
  */
 export class SubtitleRenderer {
     free(): void;
@@ -93,6 +121,7 @@ export class SubtitleRenderer {
     getCueEndTime(index: number): number;
     getCueStartTime(index: number): number;
     getTimestamps(): Float64Array;
+    loadDvb(data: Uint8Array): number;
     loadPgs(data: Uint8Array): number;
     loadVobSub(idx_content: string, sub_data: Uint8Array): void;
     loadVobSubMks(mks_data: Uint8Array): void;
@@ -170,6 +199,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_dvbparser_free: (a: number, b: number) => void;
     readonly __wbg_pgsparser_free: (a: number, b: number) => void;
     readonly __wbg_renderresult_free: (a: number, b: number) => void;
     readonly __wbg_subtitlecomposition_free: (a: number, b: number) => void;
@@ -177,6 +207,25 @@ export interface InitOutput {
     readonly __wbg_subtitlerenderer_free: (a: number, b: number) => void;
     readonly __wbg_vobsubframe_free: (a: number, b: number) => void;
     readonly __wbg_vobsubparser_free: (a: number, b: number) => void;
+    readonly dvbparser_clearCache: (a: number) => void;
+    readonly dvbparser_count: (a: number) => number;
+    readonly dvbparser_feed: (a: number, b: number, c: number) => number;
+    readonly dvbparser_findIndexAtTimestamp: (a: number, b: number) => number;
+    readonly dvbparser_finishFeed: (a: number) => number;
+    readonly dvbparser_getCueCompositionCount: (a: number, b: number) => number;
+    readonly dvbparser_getCueEndTime: (a: number, b: number) => number;
+    readonly dvbparser_getCuePageState: (a: number, b: number) => number;
+    readonly dvbparser_getCueStartTime: (a: number, b: number) => number;
+    readonly dvbparser_getEndTimestamps: (a: number) => any;
+    readonly dvbparser_getTimestamps: (a: number) => any;
+    readonly dvbparser_lastRenderIssue: (a: number) => [number, number];
+    readonly dvbparser_new: () => number;
+    readonly dvbparser_parse: (a: number, b: number, c: number) => number;
+    readonly dvbparser_pendingLen: (a: number) => number;
+    readonly dvbparser_renderAtIndex: (a: number, b: number) => number;
+    readonly dvbparser_reset: (a: number) => void;
+    readonly dvbparser_screenHeight: (a: number) => number;
+    readonly dvbparser_screenWidth: (a: number) => number;
     readonly init: () => void;
     readonly pgsparser_clearCache: (a: number) => void;
     readonly pgsparser_count: (a: number) => number;
@@ -226,6 +275,7 @@ export interface InitOutput {
     readonly subtitlerenderer_hasIdxMetadata: (a: number) => number;
     readonly subtitlerenderer_language: (a: number) => [number, number];
     readonly subtitlerenderer_lastRenderIssue: (a: number) => [number, number];
+    readonly subtitlerenderer_loadDvb: (a: number, b: number, c: number) => number;
     readonly subtitlerenderer_loadPgs: (a: number, b: number, c: number) => number;
     readonly subtitlerenderer_loadVobSub: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly subtitlerenderer_loadVobSubMks: (a: number, b: number, c: number) => [number, number];

package/pkg/libbitsub.js

@@ -1,5 +1,166 @@
 /* @ts-self-types="./libbitsub.d.ts" */
 
+/**
+ * DVB subtitle parser and renderer exposed to JavaScript.
+ */
+export class DvbParser {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DvbParserFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dvbparser_free(ptr, 0);
+    }
+    clearCache() {
+        wasm.dvbparser_clearCache(this.__wbg_ptr);
+    }
+    /**
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.dvbparser_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {Uint8Array} data
+     * @returns {number}
+     */
+    feed(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.dvbparser_feed(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} time_ms
+     * @returns {number}
+     */
+    findIndexAtTimestamp(time_ms) {
+        const ret = wasm.dvbparser_findIndexAtTimestamp(this.__wbg_ptr, time_ms);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    finishFeed() {
+        const ret = wasm.dvbparser_finishFeed(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    getCueCompositionCount(index) {
+        const ret = wasm.dvbparser_getCueCompositionCount(this.__wbg_ptr, index);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    getCueEndTime(index) {
+        const ret = wasm.dvbparser_getCueEndTime(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    getCuePageState(index) {
+        const ret = wasm.dvbparser_getCuePageState(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    getCueStartTime(index) {
+        const ret = wasm.dvbparser_getCueStartTime(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    getEndTimestamps() {
+        const ret = wasm.dvbparser_getEndTimestamps(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    getTimestamps() {
+        const ret = wasm.dvbparser_getTimestamps(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get lastRenderIssue() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.dvbparser_lastRenderIssue(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    constructor() {
+        const ret = wasm.dvbparser_new();
+        this.__wbg_ptr = ret;
+        DvbParserFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Uint8Array} data
+     * @returns {number}
+     */
+    parse(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.dvbparser_parse(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get pendingLen() {
+        const ret = wasm.dvbparser_pendingLen(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} index
+     * @returns {SubtitleFrame | undefined}
+     */
+    renderAtIndex(index) {
+        const ret = wasm.dvbparser_renderAtIndex(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : SubtitleFrame.__wrap(ret);
+    }
+    reset() {
+        wasm.dvbparser_reset(this.__wbg_ptr);
+    }
+    /**
+     * @returns {number}
+     */
+    get screenHeight() {
+        const ret = wasm.dvbparser_screenHeight(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get screenWidth() {
+        const ret = wasm.dvbparser_screenWidth(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) DvbParser.prototype[Symbol.dispose] = DvbParser.prototype.free;
+
 /**
  * PGS subtitle parser and renderer exposed to JavaScript.
  */
@@ -306,11 +467,12 @@ if (Symbol.dispose) SubtitleComposition.prototype[Symbol.dispose] = SubtitleComp
 
 /**
  * Subtitle format type.
- * @enum {0 | 1}
+ * @enum {0 | 1 | 2}
  */
 export const SubtitleFormat = Object.freeze({
     Pgs: 0, "0": "Pgs",
     VobSub: 1, "1": "VobSub",
+    Dvb: 2, "2": "Dvb",
 });
 
 /**
@@ -366,7 +528,7 @@ export class SubtitleFrame {
 if (Symbol.dispose) SubtitleFrame.prototype[Symbol.dispose] = SubtitleFrame.prototype.free;
 
 /**
- * Unified subtitle renderer for both PGS and VobSub formats.
+ * Unified subtitle renderer for PGS, VobSub, and DVB formats.
  */
 export class SubtitleRenderer {
     __destroy_into_raw() {
@@ -405,7 +567,7 @@ export class SubtitleRenderer {
      */
     get format() {
         const ret = wasm.subtitlerenderer_format(this.__wbg_ptr);
-        return ret === 2 ? undefined : ret;
+        return ret === 3 ? undefined : ret;
     }
     /**
      * @param {number} index
@@ -475,6 +637,16 @@ export class SubtitleRenderer {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {Uint8Array} data
+     * @returns {number}
+     */
+    loadDvb(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subtitlerenderer_loadDvb(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
     /**
      * @param {Uint8Array} data
      * @returns {number}
@@ -946,6 +1118,9 @@ function __wbg_get_imports() {
     };
 }
 
+const DvbParserFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dvbparser_free(ptr, 1));
 const PgsParserFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pgsparser_free(ptr, 1));

package/pkg/libbitsub_bg.wasm.d.ts

@@ -1,6 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_dvbparser_free: (a: number, b: number) => void;
 export const __wbg_pgsparser_free: (a: number, b: number) => void;
 export const __wbg_renderresult_free: (a: number, b: number) => void;
 export const __wbg_subtitlecomposition_free: (a: number, b: number) => void;
@@ -8,6 +9,25 @@ export const __wbg_subtitleframe_free: (a: number, b: number) => void;
 export const __wbg_subtitlerenderer_free: (a: number, b: number) => void;
 export const __wbg_vobsubframe_free: (a: number, b: number) => void;
 export const __wbg_vobsubparser_free: (a: number, b: number) => void;
+export const dvbparser_clearCache: (a: number) => void;
+export const dvbparser_count: (a: number) => number;
+export const dvbparser_feed: (a: number, b: number, c: number) => number;
+export const dvbparser_findIndexAtTimestamp: (a: number, b: number) => number;
+export const dvbparser_finishFeed: (a: number) => number;
+export const dvbparser_getCueCompositionCount: (a: number, b: number) => number;
+export const dvbparser_getCueEndTime: (a: number, b: number) => number;
+export const dvbparser_getCuePageState: (a: number, b: number) => number;
+export const dvbparser_getCueStartTime: (a: number, b: number) => number;
+export const dvbparser_getEndTimestamps: (a: number) => any;
+export const dvbparser_getTimestamps: (a: number) => any;
+export const dvbparser_lastRenderIssue: (a: number) => [number, number];
+export const dvbparser_new: () => number;
+export const dvbparser_parse: (a: number, b: number, c: number) => number;
+export const dvbparser_pendingLen: (a: number) => number;
+export const dvbparser_renderAtIndex: (a: number, b: number) => number;
+export const dvbparser_reset: (a: number) => void;
+export const dvbparser_screenHeight: (a: number) => number;
+export const dvbparser_screenWidth: (a: number) => number;
 export const init: () => void;
 export const pgsparser_clearCache: (a: number) => void;
 export const pgsparser_count: (a: number) => number;
@@ -57,6 +77,7 @@ export const subtitlerenderer_getTimestamps: (a: number) => any;
 export const subtitlerenderer_hasIdxMetadata: (a: number) => number;
 export const subtitlerenderer_language: (a: number) => [number, number];
 export const subtitlerenderer_lastRenderIssue: (a: number) => [number, number];
+export const subtitlerenderer_loadDvb: (a: number, b: number, c: number) => number;
 export const subtitlerenderer_loadPgs: (a: number, b: number, c: number) => number;
 export const subtitlerenderer_loadVobSub: (a: number, b: number, c: number, d: number, e: number) => void;
 export const subtitlerenderer_loadVobSubMks: (a: number, b: number, c: number) => [number, number];

package/pkg/package.json

@@ -4,8 +4,8 @@
   "collaborators": [
     "altqx"
   ],
-  "description": "High-performance WASM renderer for graphical subtitles (PGS and VobSub)",
-  "version": "1.11.0",
+  "description": "High-performance WASM renderer for graphical subtitles (PGS, VobSub, and DVB)",
+  "version": "1.12.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,8 +24,8 @@
   "keywords": [
     "pgs",
     "vobsub",
+    "dvb",
     "subtitle",
-    "wasm",
-    "rendering"
+    "wasm"
   ]
 }