Types

type BufferSource = ArrayBuffer | ArrayBufferView

import { VideoDecoder, EncodedVideoChunk, AudioData } from 'node-webcodecs';

// Using Uint8Array (most common)
const chunk = new EncodedVideoChunk({
  type: 'key',
  timestamp: 0,
  data: new Uint8Array([0x00, 0x00, 0x01, ...])
});

// Using ArrayBuffer directly
const buffer = new ArrayBuffer(1024);
const audioData = new AudioData({
  format: 'f32',
  sampleRate: 48000,
  numberOfFrames: 256,
  numberOfChannels: 2,
  timestamp: 0,
  data: buffer
});

// Using a view into an existing buffer
const largeBuffer = new ArrayBuffer(10000);
const slice = new Uint8Array(largeBuffer, 100, 500);

type CodecState = "unconfigured" | "configured" | "closed"

                    configure()
    +---------------+------------>+---------------+
    | unconfigured  |             |  configured   |
    +---------------+<------------+---------------+
           |            reset()          |
           |                             |
           |  close()                    |  close()
           v                             v
    +----------------------------------------------+
    |                    closed                    |
    +----------------------------------------------+

const decoder = new VideoDecoder({
  output: (frame) => handleFrame(frame),
  error: (e) => console.error(e)
});

console.log(decoder.state); // "unconfigured"

await decoder.configure({
  codec: 'avc1.42E01E',
  codedWidth: 1920,
  codedHeight: 1080
});

console.log(decoder.state); // "configured"

// Process video chunks...

decoder.close();
console.log(decoder.state); // "closed"

new WebCodecsDOMException(message?: string, name?: string): WebCodecsDOMException

import { VideoDecoder, WebCodecsDOMException } from 'node-webcodecs';

const decoder = new VideoDecoder({
  output: (frame) => frame.close(),
  error: (e) => {
    if (e instanceof WebCodecsDOMException) {
      switch (e.code) {
        case WebCodecsDOMException.NOT_SUPPORTED_ERR:
          console.error('Codec not supported:', e.message);
          break;
        case WebCodecsDOMException.INVALID_STATE_ERR:
          console.error('Invalid state:', e.message);
          break;
        case WebCodecsDOMException.ABORT_ERR:
          console.error('Operation aborted:', e.message);
          break;
        default:
          console.error('Unknown error:', e.code, e.message);
      }
    }
  }
});

new DOMRectReadOnly(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly

toJSON(): { x: number; y: number; width: number; height: number }

import { VideoFrame } from 'node-webcodecs';

// Create a video frame
const frame = new VideoFrame(imageData, {
  timestamp: 0,
  visibleRect: { x: 10, y: 10, width: 1900, height: 1060 }
});

// Access the visible rectangle
const rect = frame.visibleRect;
console.log(`Position: (${rect.x}, ${rect.y})`);
console.log(`Size: ${rect.width}x${rect.height}`);
console.log(`Bounds: top=${rect.top}, right=${rect.right}, bottom=${rect.bottom}, left=${rect.left}`);

// Serialize to JSON
const json = rect.toJSON();
// { x: 10, y: 10, width: 1900, height: 1060 }

function createDOMException(message?: string, name?: string): WebCodecsDOMException

type WebCodecsError = WebCodecsDOMException

const DOMException = WebCodecsDOMException