@pproenca/node-webcodecs 0.1.1-alpha.0 → 0.1.1-alpha.5

package/dist/types.d.ts

@@ -54,6 +54,16 @@ export type HardwareAcceleration = 'no-preference' | 'prefer-hardware' | 'prefer
  * enum AlphaOption { "keep", "discard" };
  */
 export type AlphaOption = 'keep' | 'discard';
+/**
+ * WebIDL:
+ * enum PremultiplyAlpha { "none", "premultiply", "default" };
+ *
+ * Per W3C WebCodecs spec:
+ * - "none": Do not premultiply alpha
+ * - "premultiply": Premultiply RGB values by alpha
+ * - "default": Use default behavior (typically none)
+ */
+export type PremultiplyAlpha = 'none' | 'premultiply' | 'default';
 /**
  * WebIDL:
  * enum LatencyMode { "quality", "realtime" };
@@ -561,6 +571,7 @@ export type ImageBufferSource = AllowSharedBufferSource | ReadableStream<Uint8Ar
  *   required DOMString type;
  *   required ImageBufferSource data;
  *   ColorSpaceConversion colorSpaceConversion = "default";
+ *   PremultiplyAlpha premultiplyAlpha = "default";
  *   [EnforceRange] unsigned long desiredWidth;
  *   [EnforceRange] unsigned long desiredHeight;
  *   boolean preferAnimation;
@@ -571,6 +582,7 @@ export interface ImageDecoderInit {
     type: string;
     data: ImageBufferSource;
     colorSpaceConversion?: ColorSpaceConversion;
+    premultiplyAlpha?: PremultiplyAlpha;
     desiredWidth?: number;
     desiredHeight?: number;
     preferAnimation?: boolean;

package/dist/video-decoder.d.ts

@@ -13,10 +13,31 @@ export declare class VideoDecoder extends CodecBase {
     private _needsKeyFrame;
     private _errorCallback;
     private _resourceId;
+    private _maxQueueDepth;
     constructor(init: VideoDecoderInit);
     get state(): CodecState;
     get decodeQueueSize(): number;
     get codecSaturated(): boolean;
+    /**
+     * Returns a Promise that resolves when the decoder has capacity for more chunks.
+     * Use this to implement backpressure in high-throughput decoding pipelines.
+     *
+     * When the internal queue is full (decodeQueueSize >= maxQueueDepth), calling
+     * `await decoder.ready` will pause until capacity is available.
+     *
+     * @example
+     * for (const chunk of chunks) {
+     *   await decoder.ready;  // Wait for capacity
+     *   decoder.decode(chunk);
+     * }
+     */
+    get ready(): Promise<void>;
+    /**
+     * The maximum queue depth before backpressure is applied.
+     * Default is 16. Adjust based on memory constraints and frame size.
+     */
+    get maxQueueDepth(): number;
+    set maxQueueDepth(value: number);
     configure(config: VideoDecoderConfig): void;
     decode(chunk: EncodedVideoChunk): void;
     flush(): Promise<void>;

package/dist/video-decoder.js

@@ -47,11 +47,15 @@ const resource_manager_1 = require("./resource-manager");
 const video_frame_1 = require("./video-frame");
 // Load native addon with type assertion
 const native = binding_1.binding;
+// Default backpressure threshold for limiting in-flight chunks
+const DEFAULT_MAX_QUEUE_DEPTH = 16;
 class VideoDecoder extends codec_base_1.CodecBase {
     constructor(init) {
         super();
         this._decodeQueueSize = 0;
         this._needsKeyFrame = true;
+        // Backpressure support
+        this._maxQueueDepth = DEFAULT_MAX_QUEUE_DEPTH;
         // W3C spec: output and error callbacks are required
         is.assertPlainObject(init, 'init');
         is.assertFunction(init.output, 'init.output');
@@ -61,7 +65,6 @@ class VideoDecoder extends codec_base_1.CodecBase {
         this._controlQueue.setErrorHandler(init.error);
         this._resourceId = resource_manager_1.ResourceManager.getInstance().register(this);
         const outputCallback = (nativeFrame) => {
-            // Decrement queue size when output received
             this._decodeQueueSize = Math.max(0, this._decodeQueueSize - 1);
             // Wrap the native frame as a VideoFrame
             // biome-ignore lint/suspicious/noExplicitAny: Object.create wrapper pattern requires any for property assignment
@@ -87,11 +90,72 @@ class VideoDecoder extends codec_base_1.CodecBase {
     get codecSaturated() {
         return this._native.codecSaturated;
     }
+    /**
+     * Returns a Promise that resolves when the decoder has capacity for more chunks.
+     * Use this to implement backpressure in high-throughput decoding pipelines.
+     *
+     * When the internal queue is full (decodeQueueSize >= maxQueueDepth), calling
+     * `await decoder.ready` will pause until capacity is available.
+     *
+     * @example
+     * for (const chunk of chunks) {
+     *   await decoder.ready;  // Wait for capacity
+     *   decoder.decode(chunk);
+     * }
+     */
+    get ready() {
+        // If we have capacity, resolve immediately
+        if (this._decodeQueueSize < this._maxQueueDepth) {
+            return Promise.resolve();
+        }
+        // Otherwise, poll until capacity is available.
+        // We use setTimeout(1ms) polling to allow TSFN output callbacks to execute.
+        // setTimeout ensures we yield through the full event loop cycle, including
+        // the I/O phase where TSFN callbacks are delivered.
+        return new Promise((resolve) => {
+            const checkCapacity = () => {
+                if (this._decodeQueueSize < this._maxQueueDepth) {
+                    resolve();
+                }
+                else {
+                    // Yield full event loop cycle to allow output callbacks to run
+                    setTimeout(checkCapacity, 1);
+                }
+            };
+            // Initial yield to allow any pending callbacks to run
+            setTimeout(checkCapacity, 1);
+        });
+    }
+    /**
+     * The maximum queue depth before backpressure is applied.
+     * Default is 16. Adjust based on memory constraints and frame size.
+     */
+    get maxQueueDepth() {
+        return this._maxQueueDepth;
+    }
+    set maxQueueDepth(value) {
+        if (value < 1) {
+            throw new RangeError('maxQueueDepth must be at least 1');
+        }
+        this._maxQueueDepth = value;
+    }
     configure(config) {
         // W3C spec: throw if closed
         if (this.state === 'closed') {
             throw new DOMException('Decoder is closed', 'InvalidStateError');
         }
+        // Validate rotation (node-webcodecs extension)
+        if ('rotation' in config && config.rotation !== undefined) {
+            if (![0, 90, 180, 270].includes(config.rotation)) {
+                throw new TypeError(`rotation must be 0, 90, 180, or 270, got ${config.rotation}`);
+            }
+        }
+        // Validate flip (node-webcodecs extension)
+        if ('flip' in config && config.flip !== undefined) {
+            if (typeof config.flip !== 'boolean') {
+                throw new TypeError('flip must be a boolean');
+            }
+        }
         this._needsKeyFrame = true;
         // Configure synchronously to set state immediately per W3C spec
         this._native.configure(config);
@@ -121,7 +185,15 @@ class VideoDecoder extends codec_base_1.CodecBase {
             return Promise.reject(new DOMException('Decoder is closed', 'InvalidStateError'));
         }
         await this._controlQueue.flush();
-        return this._native.flush();
+        // Flush the native decoder (waits for worker queue to drain)
+        this._native.flush();
+        // Poll for pending TSFN callbacks to complete.
+        // This allows the event loop to run (delivering callbacks) while we wait.
+        // Using setTimeout(1ms) instead of setImmediate to ensure other event loop
+        // phases (timers, I/O) can run, preventing event loop starvation.
+        while (this._native.pendingFrames > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 1)); // 1ms poll
+        }
     }
     reset() {
         // W3C spec: throw InvalidStateError if closed

package/dist/video-encoder.d.ts

@@ -11,10 +11,32 @@ export declare class VideoEncoder extends CodecBase {
     private _controlQueue;
     private _encodeQueueSize;
     private _resourceId;
+    private _maxQueueDepth;
     constructor(init: VideoEncoderInit);
     get state(): CodecState;
     get encodeQueueSize(): number;
     get codecSaturated(): boolean;
+    /**
+     * Returns a Promise that resolves when the encoder has capacity for more frames.
+     * Use this to implement backpressure in high-throughput encoding pipelines.
+     *
+     * When the internal queue is full (encodeQueueSize >= maxQueueDepth), calling
+     * `await encoder.ready` will pause until capacity is available.
+     *
+     * @example
+     * for (const frame of frames) {
+     *   await encoder.ready;  // Wait for capacity
+     *   encoder.encode(frame);
+     *   frame.close();
+     * }
+     */
+    get ready(): Promise<void>;
+    /**
+     * The maximum queue depth before backpressure is applied.
+     * Default is 16. Adjust based on memory constraints and frame size.
+     */
+    get maxQueueDepth(): number;
+    set maxQueueDepth(value: number);
     configure(config: VideoEncoderConfig): void;
     encode(frame: VideoFrame, options?: {
         keyFrame?: boolean;

package/dist/video-encoder.js

@@ -47,10 +47,14 @@ const is = __importStar(require("./is"));
 const resource_manager_1 = require("./resource-manager");
 // Load native addon with type assertion
 const native = binding_1.binding;
+// Default backpressure threshold for limiting in-flight frames
+const DEFAULT_MAX_QUEUE_DEPTH = 16;
 class VideoEncoder extends codec_base_1.CodecBase {
     constructor(init) {
         super();
         this._encodeQueueSize = 0;
+        // Backpressure support
+        this._maxQueueDepth = DEFAULT_MAX_QUEUE_DEPTH;
         // W3C spec: output and error callbacks are required
         is.assertPlainObject(init, 'init');
         is.assertFunction(init.output, 'init.output');
@@ -59,14 +63,25 @@ class VideoEncoder extends codec_base_1.CodecBase {
         this._controlQueue.setErrorHandler(init.error);
         this._resourceId = resource_manager_1.ResourceManager.getInstance().register(this);
         const outputCallback = (chunk, metadata) => {
-            // Decrement queue size when output received
             this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
-            const wrappedChunk = new encoded_chunks_1.EncodedVideoChunk({
-                type: chunk.type,
-                timestamp: chunk.timestamp,
-                duration: chunk.duration ?? undefined,
-                data: chunk.data,
-            });
+            // The native layer now returns an EncodedVideoChunk directly (not a plain object).
+            // Check if it's already a native chunk (has close method) vs plain object (has data buffer).
+            // Native chunks have close() but no 'data' property; plain objects have 'data' buffer.
+            let wrappedChunk;
+            if ('data' in chunk && chunk.data instanceof Buffer) {
+                // Legacy path: plain object from sync encoder - wrap it
+                wrappedChunk = new encoded_chunks_1.EncodedVideoChunk({
+                    type: chunk.type,
+                    timestamp: chunk.timestamp,
+                    duration: chunk.duration ?? undefined,
+                    data: chunk.data,
+                });
+            }
+            else {
+                // New path: already a native EncodedVideoChunk from async encoder
+                // Wrap without copying data
+                wrappedChunk = encoded_chunks_1.EncodedVideoChunk._fromNative(chunk);
+            }
             init.output(wrappedChunk, metadata);
             // Fire ondequeue after output
             this._triggerDequeue();
@@ -85,6 +100,56 @@ class VideoEncoder extends codec_base_1.CodecBase {
     get codecSaturated() {
         return this._native.codecSaturated;
     }
+    /**
+     * Returns a Promise that resolves when the encoder has capacity for more frames.
+     * Use this to implement backpressure in high-throughput encoding pipelines.
+     *
+     * When the internal queue is full (encodeQueueSize >= maxQueueDepth), calling
+     * `await encoder.ready` will pause until capacity is available.
+     *
+     * @example
+     * for (const frame of frames) {
+     *   await encoder.ready;  // Wait for capacity
+     *   encoder.encode(frame);
+     *   frame.close();
+     * }
+     */
+    get ready() {
+        // If we have capacity, resolve immediately
+        if (this._encodeQueueSize < this._maxQueueDepth) {
+            return Promise.resolve();
+        }
+        // Otherwise, poll until capacity is available.
+        // We use setTimeout(1ms) polling to allow TSFN output callbacks to execute.
+        // setTimeout ensures we yield through the full event loop cycle, including
+        // the I/O phase where TSFN callbacks are delivered.
+        return new Promise((resolve) => {
+            const checkCapacity = () => {
+                if (this._encodeQueueSize < this._maxQueueDepth) {
+                    resolve();
+                }
+                else {
+                    // Yield full event loop cycle to allow output callbacks to run
+                    setTimeout(checkCapacity, 1);
+                }
+            };
+            // Initial yield to allow any pending callbacks to run
+            setTimeout(checkCapacity, 1);
+        });
+    }
+    /**
+     * The maximum queue depth before backpressure is applied.
+     * Default is 16. Adjust based on memory constraints and frame size.
+     */
+    get maxQueueDepth() {
+        return this._maxQueueDepth;
+    }
+    set maxQueueDepth(value) {
+        if (value < 1) {
+            throw new RangeError('maxQueueDepth must be at least 1');
+        }
+        this._maxQueueDepth = value;
+    }
     configure(config) {
         // W3C spec: throw if closed
         if (this.state === 'closed') {
@@ -98,6 +163,10 @@ class VideoEncoder extends codec_base_1.CodecBase {
         this._native.configure(config);
     }
     encode(frame, options) {
+        // W3C spec: throw if not configured
+        if (this.state !== 'configured') {
+            throw new DOMException(`Encoder is ${this.state}`, 'InvalidStateError');
+        }
         resource_manager_1.ResourceManager.getInstance().recordActivity(this._resourceId);
         this._encodeQueueSize++;
         // Call native encode directly - frame must be valid at call time
@@ -116,11 +185,17 @@ class VideoEncoder extends codec_base_1.CodecBase {
         this._native.flush();
         // Poll for pending TSFN callbacks to complete.
         // This allows the event loop to run (delivering callbacks) while we wait.
+        // Using setTimeout(1ms) instead of setImmediate to ensure other event loop
+        // phases (timers, I/O) can run, preventing event loop starvation.
         while (this._native.pendingChunks > 0) {
-            await new Promise((resolve) => setImmediate(resolve));
+            await new Promise((resolve) => setTimeout(resolve, 1)); // 1ms poll
         }
     }
     reset() {
+        // W3C spec: throw if closed
+        if (this.state === 'closed') {
+            throw new DOMException('Encoder is closed', 'InvalidStateError');
+        }
         this._controlQueue.clear();
         this._encodeQueueSize = 0;
         this._native.reset();

package/lib/audio-decoder.ts

@@ -30,7 +30,6 @@ export class AudioDecoder extends CodecBase {
     this._controlQueue.setErrorHandler(init.error);
 
     const outputCallback: AudioDecoderOutputCallback = (nativeData) => {
-      // Decrement queue size when output received
       this._decodeQueueSize = Math.max(0, this._decodeQueueSize - 1);
 
       // biome-ignore lint/suspicious/noExplicitAny: Object.create wrapper pattern requires any for property assignment
@@ -76,7 +75,7 @@ export class AudioDecoder extends CodecBase {
   decode(chunk: EncodedAudioChunk): void {
     // W3C spec: throw InvalidStateError if not configured
     if (this.state === 'unconfigured') {
-      throw new DOMException('Decoder is not configured', 'InvalidStateError');
+      throw new DOMException('Decoder is unconfigured', 'InvalidStateError');
     }
     if (this.state === 'closed') {
       throw new DOMException('Decoder is closed', 'InvalidStateError');

package/lib/audio-encoder.ts

@@ -21,10 +21,13 @@ import type { AudioEncoderConfig, AudioEncoderInit, CodecState } from './types';
 // Load native addon with type assertion
 const native = binding as NativeModule;
 
+const DEFAULT_MAX_QUEUE_DEPTH = 16;
+
 export class AudioEncoder extends CodecBase {
   private _native: NativeAudioEncoder;
   private _controlQueue: ControlMessageQueue;
   private _encodeQueueSize: number = 0;
+  private _maxQueueDepth: number = DEFAULT_MAX_QUEUE_DEPTH;
 
   constructor(init: AudioEncoderInit) {
     super();
@@ -38,7 +41,6 @@ export class AudioEncoder extends CodecBase {
     this._controlQueue.setErrorHandler(init.error);
 
     const outputCallback: AudioEncoderOutputCallback = (chunk, metadata) => {
-      // Decrement queue size when output received
       this._encodeQueueSize = Math.max(0, this._encodeQueueSize - 1);
 
       // biome-ignore lint/suspicious/noExplicitAny: Object.create wrapper pattern requires any for property assignment
@@ -68,6 +70,33 @@ export class AudioEncoder extends CodecBase {
     return this._native.codecSaturated;
   }
 
+  get maxQueueDepth(): number {
+    return this._maxQueueDepth;
+  }
+
+  set maxQueueDepth(value: number) {
+    if (value < 1) {
+      throw new RangeError('maxQueueDepth must be at least 1');
+    }
+    this._maxQueueDepth = value;
+  }
+
+  get ready(): Promise<void> {
+    if (this._encodeQueueSize < this._maxQueueDepth) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      const checkCapacity = () => {
+        if (this._encodeQueueSize < this._maxQueueDepth) {
+          resolve();
+        } else {
+          setTimeout(checkCapacity, 1);
+        }
+      };
+      setTimeout(checkCapacity, 1);
+    });
+  }
+
   configure(config: AudioEncoderConfig): void {
     // W3C spec: throw if closed
     if (this.state === 'closed') {
@@ -86,7 +115,7 @@ export class AudioEncoder extends CodecBase {
   encode(data: AudioData): void {
     // W3C spec: throw InvalidStateError if not configured
     if (this.state === 'unconfigured') {
-      throw new DOMException('Encoder is not configured', 'InvalidStateError');
+      throw new DOMException('Encoder is unconfigured', 'InvalidStateError');
     }
     if (this.state === 'closed') {
       throw new DOMException('Encoder is closed', 'InvalidStateError');

package/lib/binding.ts

@@ -1,116 +1,59 @@
 // Copyright 2024 The node-webcodecs Authors
 // SPDX-License-Identifier: MIT
 //
-// Native binding loader with fallback chain and enhanced error messages.
+// Native binding loader using esbuild-style platform resolution.
+// Tries platform-specific package first, falls back to node-gyp-build for local dev.
 
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { getPrebuiltPackageName, isPrebuiltAvailable, runtimePlatformArch } from './platform';
+import { resolve, dirname, join } from 'node:path';
 
-const rootDir = path.resolve(__dirname, '..');
-
-type LoadCandidate = string | (() => unknown);
-
-const candidates: LoadCandidate[] = [
-  // Development build (node-gyp output)
-  path.join(rootDir, 'build', 'Release', 'node_webcodecs.node'),
-  path.join(rootDir, 'build', 'Debug', 'node_webcodecs.node'),
-
-  // node-gyp-build compatible
-  () => {
-    try {
-      return require('node-gyp-build')(rootDir);
-    } catch {
-      throw new Error('node-gyp-build not available');
-    }
-  },
-
-  // Prebuilt from platform package (sharp pattern: @scope/pkg-platform/binding.node)
-  () => {
-    const pkg = getPrebuiltPackageName();
-    const bindingPath = `${pkg}/node-webcodecs.node`;
-    return require(bindingPath);
-  },
-];
-
-function getPlatformBuildInstructions(): string {
-  const platform = process.platform;
-
-  if (platform === 'darwin') {
-    return `  brew install ffmpeg pkg-config
-  npm run build:native`;
-  }
-  if (platform === 'linux') {
-    return `  sudo apt-get install libavcodec-dev libavutil-dev libswscale-dev libswresample-dev libavfilter-dev pkg-config
-  npm run build:native`;
-  }
-  if (platform === 'win32') {
-    return `  Download FFmpeg from https://github.com/BtbN/FFmpeg-Builds/releases
-  Set FFMPEG_PATH environment variable
-  npm run build:native`;
-  }
-  return `  Install FFmpeg development libraries
-  npm run build:native`;
-}
-
-function buildHelpMessage(errors: Array<{ path: string; error: Error }>): string {
-  const platform = runtimePlatformArch();
-  const hasPrebuilt = isPrebuiltAvailable();
-
-  let msg = `Could not load native binding for ${platform}.\n\n`;
-  msg += `Node.js: ${process.version}\n\n`;
+const PLATFORMS: Record<string, string> = {
+  'darwin-arm64': '@pproenca/node-webcodecs-darwin-arm64',
+  'darwin-x64': '@pproenca/node-webcodecs-darwin-x64',
+  'linux-x64': '@pproenca/node-webcodecs-linux-x64',
+};
 
-  msg += 'Attempted paths:\n';
-  for (const { path: p, error } of errors) {
-    msg += `  - ${p}: ${error.message}\n`;
+/**
+ * Load the native binding.
+ *
+ * Resolution order:
+ * 1. Platform-specific npm package (production path via optionalDependencies)
+ * 2. node-gyp-build (local development fallback)
+ */
+function loadBinding(): unknown {
+  const platform = `${process.platform}-${process.arch}`;
+  const pkg = PLATFORMS[platform];
+
+  if (!pkg) {
+    throw new Error(
+      `Unsupported platform: ${platform}. ` +
+        `Supported platforms: ${Object.keys(PLATFORMS).join(', ')}`
+    );
   }
 
-  msg += '\nPossible solutions:\n';
-
-  if (hasPrebuilt) {
-    msg += '  1. Install with optional dependencies:\n';
-    msg += '     npm install --include=optional\n\n';
-    msg += '  2. Build from source:\n';
-  } else {
-    msg += '  1. Build from source:\n';
+  // Try platform-specific package first (production path)
+  try {
+    const pkgPath = require.resolve(`${pkg}/package.json`);
+    const binPath = join(dirname(pkgPath), 'bin', 'node.napi.node');
+    return require(binPath);
+  } catch {
+    // Platform package not installed - fallback to local build
   }
 
-  msg += getPlatformBuildInstructions();
-
-  return msg;
-}
-
-function loadBinding(): unknown {
-  const errors: Array<{ path: string; error: Error }> = [];
-
-  for (const candidate of candidates) {
-    try {
-      if (typeof candidate === 'function') {
-        const binding = candidate();
-        if (binding && typeof (binding as Record<string, unknown>).VideoEncoder === 'function') {
-          return binding;
-        }
-        throw new Error('Invalid binding: missing VideoEncoder');
-      }
-
-      if (!fs.existsSync(candidate)) {
-        continue;
-      }
-
-      const binding = require(candidate);
-      if (typeof binding.VideoEncoder !== 'function') {
-        throw new Error('Invalid binding: missing VideoEncoder');
-      }
-      return binding;
-    } catch (err) {
-      errors.push({
-        path: typeof candidate === 'string' ? candidate : 'dynamic loader',
-        error: err instanceof Error ? err : new Error(String(err)),
-      });
-    }
+  // Fallback to node-gyp-build for local development
+  try {
+    const nodeGypBuild = require('node-gyp-build');
+    const rootDir = resolve(__dirname, '..');
+    return nodeGypBuild(rootDir);
+  } catch (err) {
+    throw new Error(
+      `Could not load the node-webcodecs native binding for ${platform}.\n` +
+        `Error: ${err instanceof Error ? err.message : String(err)}\n\n` +
+        `Solutions:\n` +
+        `  1. Install the main package: npm install @pproenca/node-webcodecs\n` +
+        `  2. Build from source: npm rebuild --build-from-source\n` +
+        `  3. Ensure FFmpeg dev libs: pkg-config --exists libavcodec\n`
+    );
   }
-
-  throw new Error(buildHelpMessage(errors));
 }
 
 export const binding = loadBinding();
@@ -118,8 +61,6 @@ export const binding = loadBinding();
 export const platformInfo = {
   platform: process.platform,
   arch: process.arch,
-  runtimePlatform: runtimePlatformArch(),
   nodeVersion: process.version,
   napiVersion: (process.versions as Record<string, string>).napi ?? 'unknown',
-  prebuiltAvailable: isPrebuiltAvailable(),
 };

package/lib/control-message-queue.ts

@@ -77,7 +77,6 @@ export class ControlMessageQueue {
 
     this.processing = false;
 
-    // Continue processing if more messages
     if (this.queue.length > 0) {
       this.scheduleProcessing();
     }

package/lib/demuxer.ts

@@ -45,6 +45,16 @@ export class Demuxer {
     return this._native.demux();
   }
 
+  /**
+   * Read packets from the file in chunks.
+   * This is useful for yielding to the event loop during demuxing.
+   * @param maxPackets - Maximum number of packets to read. 0 = unlimited (reads all).
+   * @returns The number of packets actually read.
+   */
+  demuxPackets(maxPackets?: number): number {
+    return this._native.demuxPackets(maxPackets ?? 0);
+  }
+
   close(): void {
     this._native.close();
   }