@kenzuya/mediabunny 1.26.0 → 1.28.6

package/dist/packages/mpeg4/mediabunny-mpeg4.js

@@ -0,0 +1,1198 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+// src/misc.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+function assert(x) {
+  if (!x) {
+    throw new Error("Assertion failed.");
+  }
+}
+var toUint8Array = (source) => {
+  if (source.constructor === Uint8Array) {
+    return source;
+  }
+  if (ArrayBuffer.isView(source)) {
+    return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+  }
+  if (typeof SharedArrayBuffer !== "undefined" && source instanceof SharedArrayBuffer) {
+    return new Uint8Array(source);
+  }
+  return new Uint8Array(source);
+};
+var textDecoder = new TextDecoder;
+var textEncoder = new TextEncoder;
+var invertObject = (object) => {
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [value, key]));
+};
+var COLOR_PRIMARIES_MAP = {
+  bt709: 1,
+  bt470bg: 5,
+  smpte170m: 6,
+  bt2020: 9,
+  smpte432: 12
+};
+var COLOR_PRIMARIES_MAP_INVERSE = invertObject(COLOR_PRIMARIES_MAP);
+var TRANSFER_CHARACTERISTICS_MAP = {
+  bt709: 1,
+  smpte170m: 6,
+  linear: 8,
+  "iec61966-2-1": 13,
+  pq: 16,
+  hlg: 18
+};
+var TRANSFER_CHARACTERISTICS_MAP_INVERSE = invertObject(TRANSFER_CHARACTERISTICS_MAP);
+var MATRIX_COEFFICIENTS_MAP = {
+  rgb: 0,
+  bt709: 1,
+  bt470bg: 5,
+  smpte170m: 6,
+  "bt2020-ncl": 9
+};
+var MATRIX_COEFFICIENTS_MAP_INVERSE = invertObject(MATRIX_COEFFICIENTS_MAP);
+var isAllowSharedBufferSource = (x) => {
+  return x instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && x instanceof SharedArrayBuffer || ArrayBuffer.isView(x);
+};
+
+class AsyncMutex {
+  currentPromise = Promise.resolve();
+  async acquire() {
+    let resolver;
+    const nextPromise = new Promise((resolve) => {
+      resolver = resolve;
+    });
+    const currentPromiseAlias = this.currentPromise;
+    this.currentPromise = nextPromise;
+    await currentPromiseAlias;
+    return resolver;
+  }
+}
+var assertNever = (x) => {
+  throw new Error(`Unexpected value: ${x}`);
+};
+var SECOND_TO_MICROSECOND_FACTOR = 1e6 * (1 + Number.EPSILON);
+class CallSerializer {
+  currentPromise = Promise.resolve();
+  call(fn) {
+    return this.currentPromise = this.currentPromise.then(fn);
+  }
+}
+var isFirefoxCache = null;
+var isFirefox = () => {
+  if (isFirefoxCache !== null) {
+    return isFirefoxCache;
+  }
+  return isFirefoxCache = typeof navigator !== "undefined" && navigator.userAgent?.includes("Firefox");
+};
+var polyfillSymbolDispose = () => {
+  Symbol.dispose ??= Symbol("Symbol.dispose");
+};
+
+// src/custom-coder.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+class CustomVideoDecoder {
+  codec;
+  config;
+  onSample;
+  static supports(codec, config) {
+    return false;
+  }
+}
+
+class CustomAudioDecoder {
+  codec;
+  config;
+  onSample;
+  static supports(codec, config) {
+    return false;
+  }
+}
+
+class CustomVideoEncoder {
+  codec;
+  config;
+  onPacket;
+  static supports(codec, config) {
+    return false;
+  }
+}
+
+class CustomAudioEncoder {
+  codec;
+  config;
+  onPacket;
+  static supports(codec, config) {
+    return false;
+  }
+}
+var customVideoDecoders = [];
+var customAudioDecoders = [];
+var customVideoEncoders = [];
+var customAudioEncoders = [];
+var registerDecoder = (decoder) => {
+  if (decoder.prototype instanceof CustomVideoDecoder) {
+    const casted = decoder;
+    if (customVideoDecoders.includes(casted)) {
+      console.warn("Video decoder already registered.");
+      return;
+    }
+    customVideoDecoders.push(casted);
+  } else if (decoder.prototype instanceof CustomAudioDecoder) {
+    const casted = decoder;
+    if (customAudioDecoders.includes(casted)) {
+      console.warn("Audio decoder already registered.");
+      return;
+    }
+    customAudioDecoders.push(casted);
+  } else {
+    throw new TypeError("Decoder must be a CustomVideoDecoder or CustomAudioDecoder.");
+  }
+};
+var registerEncoder = (encoder) => {
+  if (encoder.prototype instanceof CustomVideoEncoder) {
+    const casted = encoder;
+    if (customVideoEncoders.includes(casted)) {
+      console.warn("Video encoder already registered.");
+      return;
+    }
+    customVideoEncoders.push(casted);
+  } else if (encoder.prototype instanceof CustomAudioEncoder) {
+    const casted = encoder;
+    if (customAudioEncoders.includes(casted)) {
+      console.warn("Audio encoder already registered.");
+      return;
+    }
+    customAudioEncoders.push(casted);
+  } else {
+    throw new TypeError("Encoder must be a CustomVideoEncoder or CustomAudioEncoder.");
+  }
+};
+
+// src/packet.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var PLACEHOLDER_DATA = new Uint8Array(0);
+
+class EncodedPacket {
+  data;
+  type;
+  timestamp;
+  duration;
+  sequenceNumber;
+  byteLength;
+  sideData;
+  constructor(data, type, timestamp, duration, sequenceNumber = -1, byteLength, sideData) {
+    this.data = data;
+    this.type = type;
+    this.timestamp = timestamp;
+    this.duration = duration;
+    this.sequenceNumber = sequenceNumber;
+    if (data === PLACEHOLDER_DATA && byteLength === undefined) {
+      throw new Error("Internal error: byteLength must be explicitly provided when constructing metadata-only packets.");
+    }
+    if (byteLength === undefined) {
+      byteLength = data.byteLength;
+    }
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("data must be a Uint8Array.");
+    }
+    if (type !== "key" && type !== "delta") {
+      throw new TypeError('type must be either "key" or "delta".');
+    }
+    if (!Number.isFinite(timestamp)) {
+      throw new TypeError("timestamp must be a number.");
+    }
+    if (!Number.isFinite(duration) || duration < 0) {
+      throw new TypeError("duration must be a non-negative number.");
+    }
+    if (!Number.isFinite(sequenceNumber)) {
+      throw new TypeError("sequenceNumber must be a number.");
+    }
+    if (!Number.isInteger(byteLength) || byteLength < 0) {
+      throw new TypeError("byteLength must be a non-negative integer.");
+    }
+    if (sideData !== undefined && (typeof sideData !== "object" || !sideData)) {
+      throw new TypeError("sideData, when provided, must be an object.");
+    }
+    if (sideData?.alpha !== undefined && !(sideData.alpha instanceof Uint8Array)) {
+      throw new TypeError("sideData.alpha, when provided, must be a Uint8Array.");
+    }
+    if (sideData?.alphaByteLength !== undefined && (!Number.isInteger(sideData.alphaByteLength) || sideData.alphaByteLength < 0)) {
+      throw new TypeError("sideData.alphaByteLength, when provided, must be a non-negative integer.");
+    }
+    this.byteLength = byteLength;
+    this.sideData = sideData ?? {};
+    if (this.sideData.alpha && this.sideData.alphaByteLength === undefined) {
+      this.sideData.alphaByteLength = this.sideData.alpha.byteLength;
+    }
+  }
+  get isMetadataOnly() {
+    return this.data === PLACEHOLDER_DATA;
+  }
+  get microsecondTimestamp() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.timestamp);
+  }
+  get microsecondDuration() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.duration);
+  }
+  toEncodedVideoChunk() {
+    if (this.isMetadataOnly) {
+      throw new TypeError("Metadata-only packets cannot be converted to a video chunk.");
+    }
+    if (typeof EncodedVideoChunk === "undefined") {
+      throw new Error("Your browser does not support EncodedVideoChunk.");
+    }
+    return new EncodedVideoChunk({
+      data: this.data,
+      type: this.type,
+      timestamp: this.microsecondTimestamp,
+      duration: this.microsecondDuration
+    });
+  }
+  alphaToEncodedVideoChunk(type = this.type) {
+    if (!this.sideData.alpha) {
+      throw new TypeError("This packet does not contain alpha side data.");
+    }
+    if (this.isMetadataOnly) {
+      throw new TypeError("Metadata-only packets cannot be converted to a video chunk.");
+    }
+    if (typeof EncodedVideoChunk === "undefined") {
+      throw new Error("Your browser does not support EncodedVideoChunk.");
+    }
+    return new EncodedVideoChunk({
+      data: this.sideData.alpha,
+      type,
+      timestamp: this.microsecondTimestamp,
+      duration: this.microsecondDuration
+    });
+  }
+  toEncodedAudioChunk() {
+    if (this.isMetadataOnly) {
+      throw new TypeError("Metadata-only packets cannot be converted to an audio chunk.");
+    }
+    if (typeof EncodedAudioChunk === "undefined") {
+      throw new Error("Your browser does not support EncodedAudioChunk.");
+    }
+    return new EncodedAudioChunk({
+      data: this.data,
+      type: this.type,
+      timestamp: this.microsecondTimestamp,
+      duration: this.microsecondDuration
+    });
+  }
+  static fromEncodedChunk(chunk, sideData) {
+    if (!(chunk instanceof EncodedVideoChunk || chunk instanceof EncodedAudioChunk)) {
+      throw new TypeError("chunk must be an EncodedVideoChunk or EncodedAudioChunk.");
+    }
+    const data = new Uint8Array(chunk.byteLength);
+    chunk.copyTo(data);
+    return new EncodedPacket(data, chunk.type, chunk.timestamp / 1e6, (chunk.duration ?? 0) / 1e6, undefined, undefined, sideData);
+  }
+  clone(options) {
+    if (options !== undefined && (typeof options !== "object" || options === null)) {
+      throw new TypeError("options, when provided, must be an object.");
+    }
+    if (options?.timestamp !== undefined && !Number.isFinite(options.timestamp)) {
+      throw new TypeError("options.timestamp, when provided, must be a number.");
+    }
+    if (options?.duration !== undefined && !Number.isFinite(options.duration)) {
+      throw new TypeError("options.duration, when provided, must be a number.");
+    }
+    return new EncodedPacket(this.data, this.type, options?.timestamp ?? this.timestamp, options?.duration ?? this.duration, this.sequenceNumber, this.byteLength);
+  }
+}
+
+// src/sample.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+polyfillSymbolDispose();
+var lastVideoGcErrorLog = -Infinity;
+var lastAudioGcErrorLog = -Infinity;
+var finalizationRegistry = null;
+if (typeof FinalizationRegistry !== "undefined") {
+  finalizationRegistry = new FinalizationRegistry((value) => {
+    const now = Date.now();
+    if (value.type === "video") {
+      if (now - lastVideoGcErrorLog >= 1000) {
+        console.error(`A VideoSample was garbage collected without first being closed. For proper resource management,` + ` make sure to call close() on all your VideoSamples as soon as you're done using them.`);
+        lastVideoGcErrorLog = now;
+      }
+      if (typeof VideoFrame !== "undefined" && value.data instanceof VideoFrame) {
+        value.data.close();
+      }
+    } else {
+      if (now - lastAudioGcErrorLog >= 1000) {
+        console.error(`An AudioSample was garbage collected without first being closed. For proper resource management,` + ` make sure to call close() on all your AudioSamples as soon as you're done using them.`);
+        lastAudioGcErrorLog = now;
+      }
+      if (typeof AudioData !== "undefined" && value.data instanceof AudioData) {
+        value.data.close();
+      }
+    }
+  });
+}
+var VIDEO_SAMPLE_PIXEL_FORMATS = [
+  "I420",
+  "I420P10",
+  "I420P12",
+  "I420A",
+  "I420AP10",
+  "I420AP12",
+  "I422",
+  "I422P10",
+  "I422P12",
+  "I422A",
+  "I422AP10",
+  "I422AP12",
+  "I444",
+  "I444P10",
+  "I444P12",
+  "I444A",
+  "I444AP10",
+  "I444AP12",
+  "NV12",
+  "RGBA",
+  "RGBX",
+  "BGRA",
+  "BGRX"
+];
+var VIDEO_SAMPLE_PIXEL_FORMATS_SET = new Set(VIDEO_SAMPLE_PIXEL_FORMATS);
+
+class VideoSample {
+  _data;
+  _layout;
+  _closed = false;
+  format;
+  codedWidth;
+  codedHeight;
+  rotation;
+  timestamp;
+  duration;
+  colorSpace;
+  get displayWidth() {
+    return this.rotation % 180 === 0 ? this.codedWidth : this.codedHeight;
+  }
+  get displayHeight() {
+    return this.rotation % 180 === 0 ? this.codedHeight : this.codedWidth;
+  }
+  get microsecondTimestamp() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.timestamp);
+  }
+  get microsecondDuration() {
+    return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.duration);
+  }
+  get hasAlpha() {
+    return this.format && this.format.includes("A");
+  }
+  constructor(data, init) {
+    if (data instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && data instanceof SharedArrayBuffer || ArrayBuffer.isView(data)) {
+      if (!init || typeof init !== "object") {
+        throw new TypeError("init must be an object.");
+      }
+      if (init.format === undefined || !VIDEO_SAMPLE_PIXEL_FORMATS_SET.has(init.format)) {
+        throw new TypeError("init.format must be one of: " + VIDEO_SAMPLE_PIXEL_FORMATS.join(", "));
+      }
+      if (!Number.isInteger(init.codedWidth) || init.codedWidth <= 0) {
+        throw new TypeError("init.codedWidth must be a positive integer.");
+      }
+      if (!Number.isInteger(init.codedHeight) || init.codedHeight <= 0) {
+        throw new TypeError("init.codedHeight must be a positive integer.");
+      }
+      if (init.rotation !== undefined && ![0, 90, 180, 270].includes(init.rotation)) {
+        throw new TypeError("init.rotation, when provided, must be 0, 90, 180, or 270.");
+      }
+      if (!Number.isFinite(init.timestamp)) {
+        throw new TypeError("init.timestamp must be a number.");
+      }
+      if (init.duration !== undefined && (!Number.isFinite(init.duration) || init.duration < 0)) {
+        throw new TypeError("init.duration, when provided, must be a non-negative number.");
+      }
+      this._data = toUint8Array(data).slice();
+      this._layout = init.layout ?? createDefaultPlaneLayout(init.format, init.codedWidth, init.codedHeight);
+      this.format = init.format;
+      this.codedWidth = init.codedWidth;
+      this.codedHeight = init.codedHeight;
+      this.rotation = init.rotation ?? 0;
+      this.timestamp = init.timestamp;
+      this.duration = init.duration ?? 0;
+      this.colorSpace = new VideoSampleColorSpace(init.colorSpace);
+    } else if (typeof VideoFrame !== "undefined" && data instanceof VideoFrame) {
+      if (init?.rotation !== undefined && ![0, 90, 180, 270].includes(init.rotation)) {
+        throw new TypeError("init.rotation, when provided, must be 0, 90, 180, or 270.");
+      }
+      if (init?.timestamp !== undefined && !Number.isFinite(init?.timestamp)) {
+        throw new TypeError("init.timestamp, when provided, must be a number.");
+      }
+      if (init?.duration !== undefined && (!Number.isFinite(init.duration) || init.duration < 0)) {
+        throw new TypeError("init.duration, when provided, must be a non-negative number.");
+      }
+      this._data = data;
+      this._layout = null;
+      this.format = data.format;
+      this.codedWidth = data.displayWidth;
+      this.codedHeight = data.displayHeight;
+      this.rotation = init?.rotation ?? 0;
+      this.timestamp = init?.timestamp ?? data.timestamp / 1e6;
+      this.duration = init?.duration ?? (data.duration ?? 0) / 1e6;
+      this.colorSpace = new VideoSampleColorSpace(data.colorSpace);
+    } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement || typeof SVGImageElement !== "undefined" && data instanceof SVGImageElement || typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap || typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement || typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && data instanceof OffscreenCanvas) {
+      if (!init || typeof init !== "object") {
+        throw new TypeError("init must be an object.");
+      }
+      if (init.rotation !== undefined && ![0, 90, 180, 270].includes(init.rotation)) {
+        throw new TypeError("init.rotation, when provided, must be 0, 90, 180, or 270.");
+      }
+      if (!Number.isFinite(init.timestamp)) {
+        throw new TypeError("init.timestamp must be a number.");
+      }
+      if (init.duration !== undefined && (!Number.isFinite(init.duration) || init.duration < 0)) {
+        throw new TypeError("init.duration, when provided, must be a non-negative number.");
+      }
+      if (typeof VideoFrame !== "undefined") {
+        return new VideoSample(new VideoFrame(data, {
+          timestamp: Math.trunc(init.timestamp * SECOND_TO_MICROSECOND_FACTOR),
+          duration: Math.trunc((init.duration ?? 0) * SECOND_TO_MICROSECOND_FACTOR) || undefined
+        }), init);
+      }
+      let width = 0;
+      let height = 0;
+      if ("naturalWidth" in data) {
+        width = data.naturalWidth;
+        height = data.naturalHeight;
+      } else if ("videoWidth" in data) {
+        width = data.videoWidth;
+        height = data.videoHeight;
+      } else if ("width" in data) {
+        width = Number(data.width);
+        height = Number(data.height);
+      }
+      if (!width || !height) {
+        throw new TypeError("Could not determine dimensions.");
+      }
+      const canvas = new OffscreenCanvas(width, height);
+      const context = canvas.getContext("2d", {
+        alpha: isFirefox(),
+        willReadFrequently: true
+      });
+      assert(context);
+      context.drawImage(data, 0, 0);
+      this._data = canvas;
+      this._layout = null;
+      this.format = "RGBX";
+      this.codedWidth = width;
+      this.codedHeight = height;
+      this.rotation = init.rotation ?? 0;
+      this.timestamp = init.timestamp;
+      this.duration = init.duration ?? 0;
+      this.colorSpace = new VideoSampleColorSpace({
+        matrix: "rgb",
+        primaries: "bt709",
+        transfer: "iec61966-2-1",
+        fullRange: true
+      });
+    } else {
+      throw new TypeError("Invalid data type: Must be a BufferSource or CanvasImageSource.");
+    }
+    finalizationRegistry?.register(this, { type: "video", data: this._data }, this);
+  }
+  clone() {
+    if (this._closed) {
+      throw new Error("VideoSample is closed.");
+    }
+    assert(this._data !== null);
+    if (isVideoFrame(this._data)) {
+      return new VideoSample(this._data.clone(), {
+        timestamp: this.timestamp,
+        duration: this.duration,
+        rotation: this.rotation
+      });
+    }
+    if (this._data instanceof Uint8Array) {
+      assert(this._layout);
+      return new VideoSample(this._data, {
+        format: this.format,
+        layout: this._layout,
+        codedWidth: this.codedWidth,
+        codedHeight: this.codedHeight,
+        timestamp: this.timestamp,
+        duration: this.duration,
+        colorSpace: this.colorSpace,
+        rotation: this.rotation
+      });
+    }
+    return new VideoSample(this._data, {
+      format: this.format,
+      codedWidth: this.codedWidth,
+      codedHeight: this.codedHeight,
+      timestamp: this.timestamp,
+      duration: this.duration,
+      colorSpace: this.colorSpace,
+      rotation: this.rotation
+    });
+  }
+  close() {
+    if (this._closed) {
+      return;
+    }
+    finalizationRegistry?.unregister(this);
+    if (isVideoFrame(this._data)) {
+      this._data.close();
+    } else {
+      this._data = null;
+    }
+    this._closed = true;
+  }
+  allocationSize(options = {}) {
+    validateVideoFrameCopyToOptions(options);
+    if (this._closed) {
+      throw new Error("VideoSample is closed.");
+    }
+    if ((options.format ?? this.format) === null) {
+      throw new Error("Cannot get allocation size when format is null. Please manually provide an RGB pixel format in the" + " options instead.");
+    }
+    assert(this._data !== null);
+    if (!isVideoFrame(this._data)) {
+      if (options.colorSpace || options.format && options.format !== this.format || options.layout || options.rect) {
+        const videoFrame = this.toVideoFrame();
+        const size = videoFrame.allocationSize(options);
+        videoFrame.close();
+        return size;
+      }
+    }
+    if (isVideoFrame(this._data)) {
+      return this._data.allocationSize(options);
+    }
+    if (this._data instanceof Uint8Array) {
+      return this._data.byteLength;
+    }
+    return this.codedWidth * this.codedHeight * 4;
+  }
+  async copyTo(destination, options = {}) {
+    if (!isAllowSharedBufferSource(destination)) {
+      throw new TypeError("destination must be an ArrayBuffer or an ArrayBuffer view.");
+    }
+    if (this._closed) {
+      throw new Error("VideoSample is closed.");
+    }
+    if ((options.format ?? this.format) === null) {
+      throw new Error("Cannot copy video sample data when format is null. Please manually provide an RGB pixel format in the" + " options instead.");
+    }
+    assert(this._data !== null);
+    if (!isVideoFrame(this._data)) {
+      if (options.colorSpace || options.format && options.format !== this.format || options.layout || options.rect) {
+        const videoFrame = this.toVideoFrame();
+        const layout = await videoFrame.copyTo(destination, options);
+        videoFrame.close();
+        return layout;
+      }
+    }
+    if (isVideoFrame(this._data)) {
+      return this._data.copyTo(destination, options);
+    } else if (this._data instanceof Uint8Array) {
+      assert(this._layout);
+      const dest = toUint8Array(destination);
+      dest.set(this._data);
+      return this._layout;
+    } else {
+      const canvas = this._data;
+      const context = canvas.getContext("2d");
+      assert(context);
+      const imageData = context.getImageData(0, 0, this.codedWidth, this.codedHeight);
+      const dest = toUint8Array(destination);
+      dest.set(imageData.data);
+      return [
+        {
+          offset: 0,
+          stride: 4 * this.codedWidth
+        }
+      ];
+    }
+  }
+  toVideoFrame() {
+    if (this._closed) {
+      throw new Error("VideoSample is closed.");
+    }
+    assert(this._data !== null);
+    if (isVideoFrame(this._data)) {
+      return new VideoFrame(this._data, {
+        timestamp: this.microsecondTimestamp,
+        duration: this.microsecondDuration || undefined
+      });
+    }
+    if (this._data instanceof Uint8Array) {
+      return new VideoFrame(this._data, {
+        format: this.format,
+        codedWidth: this.codedWidth,
+        codedHeight: this.codedHeight,
+        timestamp: this.microsecondTimestamp,
+        duration: this.microsecondDuration || undefined,
+        colorSpace: this.colorSpace
+      });
+    }
+    return new VideoFrame(this._data, {
+      timestamp: this.microsecondTimestamp,
+      duration: this.microsecondDuration || undefined
+    });
+  }
+  draw(context, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+    let sx = 0;
+    let sy = 0;
+    let sWidth = this.displayWidth;
+    let sHeight = this.displayHeight;
+    let dx = 0;
+    let dy = 0;
+    let dWidth = this.displayWidth;
+    let dHeight = this.displayHeight;
+    if (arg5 !== undefined) {
+      sx = arg1;
+      sy = arg2;
+      sWidth = arg3;
+      sHeight = arg4;
+      dx = arg5;
+      dy = arg6;
+      if (arg7 !== undefined) {
+        dWidth = arg7;
+        dHeight = arg8;
+      } else {
+        dWidth = sWidth;
+        dHeight = sHeight;
+      }
+    } else {
+      dx = arg1;
+      dy = arg2;
+      if (arg3 !== undefined) {
+        dWidth = arg3;
+        dHeight = arg4;
+      }
+    }
+    if (!(typeof CanvasRenderingContext2D !== "undefined" && context instanceof CanvasRenderingContext2D || typeof OffscreenCanvasRenderingContext2D !== "undefined" && context instanceof OffscreenCanvasRenderingContext2D)) {
+      throw new TypeError("context must be a CanvasRenderingContext2D or OffscreenCanvasRenderingContext2D.");
+    }
+    if (!Number.isFinite(sx)) {
+      throw new TypeError("sx must be a number.");
+    }
+    if (!Number.isFinite(sy)) {
+      throw new TypeError("sy must be a number.");
+    }
+    if (!Number.isFinite(sWidth) || sWidth < 0) {
+      throw new TypeError("sWidth must be a non-negative number.");
+    }
+    if (!Number.isFinite(sHeight) || sHeight < 0) {
+      throw new TypeError("sHeight must be a non-negative number.");
+    }
+    if (!Number.isFinite(dx)) {
+      throw new TypeError("dx must be a number.");
+    }
+    if (!Number.isFinite(dy)) {
+      throw new TypeError("dy must be a number.");
+    }
+    if (!Number.isFinite(dWidth) || dWidth < 0) {
+      throw new TypeError("dWidth must be a non-negative number.");
+    }
+    if (!Number.isFinite(dHeight) || dHeight < 0) {
+      throw new TypeError("dHeight must be a non-negative number.");
+    }
+    if (this._closed) {
+      throw new Error("VideoSample is closed.");
+    }
+    ({ sx, sy, sWidth, sHeight } = this._rotateSourceRegion(sx, sy, sWidth, sHeight, this.rotation));
+    const source = this.toCanvasImageSource();
+    context.save();
+    const centerX = dx + dWidth / 2;
+    const centerY = dy + dHeight / 2;
+    context.translate(centerX, centerY);
+    context.rotate(this.rotation * Math.PI / 180);
+    const aspectRatioChange = this.rotation % 180 === 0 ? 1 : dWidth / dHeight;
+    context.scale(1 / aspectRatioChange, aspectRatioChange);
+    context.drawImage(source, sx, sy, sWidth, sHeight, -dWidth / 2, -dHeight / 2, dWidth, dHeight);
+    context.restore();
+  }
+  drawWithFit(context, options) {
+    if (!(typeof CanvasRenderingContext2D !== "undefined" && context instanceof CanvasRenderingContext2D || typeof OffscreenCanvasRenderingContext2D !== "undefined" && context instanceof OffscreenCanvasRenderingContext2D)) {
+      throw new TypeError("context must be a CanvasRenderingContext2D or OffscreenCanvasRenderingContext2D.");
+    }
+    if (!options || typeof options !== "object") {
+      throw new TypeError("options must be an object.");
+    }
+    if (!["fill", "contain", "cover"].includes(options.fit)) {
+      throw new TypeError("options.fit must be 'fill', 'contain', or 'cover'.");
+    }
+    if (options.rotation !== undefined && ![0, 90, 180, 270].includes(options.rotation)) {
+      throw new TypeError("options.rotation, when provided, must be 0, 90, 180, or 270.");
+    }
+    if (options.crop !== undefined) {
+      validateCropRectangle(options.crop, "options.");
+    }
+    const canvasWidth = context.canvas.width;
+    const canvasHeight = context.canvas.height;
+    const rotation = options.rotation ?? this.rotation;
+    const [rotatedWidth, rotatedHeight] = rotation % 180 === 0 ? [this.codedWidth, this.codedHeight] : [this.codedHeight, this.codedWidth];
+    if (options.crop) {
+      clampCropRectangle(options.crop, rotatedWidth, rotatedHeight);
+    }
+    let dx;
+    let dy;
+    let newWidth;
+    let newHeight;
+    const { sx, sy, sWidth, sHeight } = this._rotateSourceRegion(options.crop?.left ?? 0, options.crop?.top ?? 0, options.crop?.width ?? rotatedWidth, options.crop?.height ?? rotatedHeight, rotation);
+    if (options.fit === "fill") {
+      dx = 0;
+      dy = 0;
+      newWidth = canvasWidth;
+      newHeight = canvasHeight;
+    } else {
+      const [sampleWidth, sampleHeight] = options.crop ? [options.crop.width, options.crop.height] : [rotatedWidth, rotatedHeight];
+      const scale = options.fit === "contain" ? Math.min(canvasWidth / sampleWidth, canvasHeight / sampleHeight) : Math.max(canvasWidth / sampleWidth, canvasHeight / sampleHeight);
+      newWidth = sampleWidth * scale;
+      newHeight = sampleHeight * scale;
+      dx = (canvasWidth - newWidth) / 2;
+      dy = (canvasHeight - newHeight) / 2;
+    }
+    context.save();
+    const aspectRatioChange = rotation % 180 === 0 ? 1 : newWidth / newHeight;
+    context.translate(canvasWidth / 2, canvasHeight / 2);
+    context.rotate(rotation * Math.PI / 180);
+    context.scale(1 / aspectRatioChange, aspectRatioChange);
+    context.translate(-canvasWidth / 2, -canvasHeight / 2);
+    context.drawImage(this.toCanvasImageSource(), sx, sy, sWidth, sHeight, dx, dy, newWidth, newHeight);
+    context.restore();
+  }
+  _rotateSourceRegion(sx, sy, sWidth, sHeight, rotation) {
+    if (rotation === 90) {
+      [sx, sy, sWidth, sHeight] = [sy, this.codedHeight - sx - sWidth, sHeight, sWidth];
+    } else if (rotation === 180) {
+      [sx, sy] = [this.codedWidth - sx - sWidth, this.codedHeight - sy - sHeight];
+    } else if (rotation === 270) {
+      [sx, sy, sWidth, sHeight] = [this.codedWidth - sy - sHeight, sx, sHeight, sWidth];
+    }
+    return { sx, sy, sWidth, sHeight };
+  }
+  toCanvasImageSource() {
+    if (this._closed) {
+      throw new Error("VideoSample is closed.");
+    }
+    assert(this._data !== null);
+    if (this._data instanceof Uint8Array) {
+      const videoFrame = this.toVideoFrame();
+      queueMicrotask(() => videoFrame.close());
+      return videoFrame;
+    }
+    return this._data;
+  }
+  setRotation(newRotation) {
+    if (![0, 90, 180, 270].includes(newRotation)) {
+      throw new TypeError("newRotation must be 0, 90, 180, or 270.");
+    }
+    this.rotation = newRotation;
+  }
+  setTimestamp(newTimestamp) {
+    if (!Number.isFinite(newTimestamp)) {
+      throw new TypeError("newTimestamp must be a number.");
+    }
+    this.timestamp = newTimestamp;
+  }
+  setDuration(newDuration) {
+    if (!Number.isFinite(newDuration) || newDuration < 0) {
+      throw new TypeError("newDuration must be a non-negative number.");
+    }
+    this.duration = newDuration;
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+}
+
+class VideoSampleColorSpace {
+  primaries;
+  transfer;
+  matrix;
+  fullRange;
+  constructor(init) {
+    this.primaries = init?.primaries ?? null;
+    this.transfer = init?.transfer ?? null;
+    this.matrix = init?.matrix ?? null;
+    this.fullRange = init?.fullRange ?? null;
+  }
+  toJSON() {
+    return {
+      primaries: this.primaries,
+      transfer: this.transfer,
+      matrix: this.matrix,
+      fullRange: this.fullRange
+    };
+  }
+}
+var isVideoFrame = (x) => {
+  return typeof VideoFrame !== "undefined" && x instanceof VideoFrame;
+};
+var clampCropRectangle = (crop, outerWidth, outerHeight) => {
+  crop.left = Math.min(crop.left, outerWidth);
+  crop.top = Math.min(crop.top, outerHeight);
+  crop.width = Math.min(crop.width, outerWidth - crop.left);
+  crop.height = Math.min(crop.height, outerHeight - crop.top);
+  assert(crop.width >= 0);
+  assert(crop.height >= 0);
+};
+var validateCropRectangle = (crop, prefix) => {
+  if (!crop || typeof crop !== "object") {
+    throw new TypeError(prefix + "crop, when provided, must be an object.");
+  }
+  if (!Number.isInteger(crop.left) || crop.left < 0) {
+    throw new TypeError(prefix + "crop.left must be a non-negative integer.");
+  }
+  if (!Number.isInteger(crop.top) || crop.top < 0) {
+    throw new TypeError(prefix + "crop.top must be a non-negative integer.");
+  }
+  if (!Number.isInteger(crop.width) || crop.width < 0) {
+    throw new TypeError(prefix + "crop.width must be a non-negative integer.");
+  }
+  if (!Number.isInteger(crop.height) || crop.height < 0) {
+    throw new TypeError(prefix + "crop.height must be a non-negative integer.");
+  }
+};
+var validateVideoFrameCopyToOptions = (options) => {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("options must be an object.");
+  }
+  if (options.colorSpace !== undefined && !["display-p3", "srgb"].includes(options.colorSpace)) {
+    throw new TypeError("options.colorSpace, when provided, must be 'display-p3' or 'srgb'.");
+  }
+  if (options.format !== undefined && typeof options.format !== "string") {
+    throw new TypeError("options.format, when provided, must be a string.");
+  }
+  if (options.layout !== undefined) {
+    if (!Array.isArray(options.layout)) {
+      throw new TypeError("options.layout, when provided, must be an array.");
+    }
+    for (const plane of options.layout) {
+      if (!plane || typeof plane !== "object") {
+        throw new TypeError("Each entry in options.layout must be an object.");
+      }
+      if (!Number.isInteger(plane.offset) || plane.offset < 0) {
+        throw new TypeError("plane.offset must be a non-negative integer.");
+      }
+      if (!Number.isInteger(plane.stride) || plane.stride < 0) {
+        throw new TypeError("plane.stride must be a non-negative integer.");
+      }
+    }
+  }
+  if (options.rect !== undefined) {
+    if (!options.rect || typeof options.rect !== "object") {
+      throw new TypeError("options.rect, when provided, must be an object.");
+    }
+    if (options.rect.x !== undefined && (!Number.isInteger(options.rect.x) || options.rect.x < 0)) {
+      throw new TypeError("options.rect.x, when provided, must be a non-negative integer.");
+    }
+    if (options.rect.y !== undefined && (!Number.isInteger(options.rect.y) || options.rect.y < 0)) {
+      throw new TypeError("options.rect.y, when provided, must be a non-negative integer.");
+    }
+    if (options.rect.width !== undefined && (!Number.isInteger(options.rect.width) || options.rect.width < 0)) {
+      throw new TypeError("options.rect.width, when provided, must be a non-negative integer.");
+    }
+    if (options.rect.height !== undefined && (!Number.isInteger(options.rect.height) || options.rect.height < 0)) {
+      throw new TypeError("options.rect.height, when provided, must be a non-negative integer.");
+    }
+  }
+};
+var createDefaultPlaneLayout = (format, codedWidth, codedHeight) => {
+  const planes = getPlaneConfigs(format);
+  const layouts = [];
+  let currentOffset = 0;
+  for (const plane of planes) {
+    const planeWidth = Math.ceil(codedWidth / plane.widthDivisor);
+    const planeHeight = Math.ceil(codedHeight / plane.heightDivisor);
+    const stride = planeWidth * plane.sampleBytes;
+    const planeSize = stride * planeHeight;
+    layouts.push({
+      offset: currentOffset,
+      stride
+    });
+    currentOffset += planeSize;
+  }
+  return layouts;
+};
+var getPlaneConfigs = (format) => {
+  const yuv = (yBytes, uvBytes, subX, subY, hasAlpha) => {
+    const configs = [
+      { sampleBytes: yBytes, widthDivisor: 1, heightDivisor: 1 },
+      { sampleBytes: uvBytes, widthDivisor: subX, heightDivisor: subY },
+      { sampleBytes: uvBytes, widthDivisor: subX, heightDivisor: subY }
+    ];
+    if (hasAlpha) {
+      configs.push({ sampleBytes: yBytes, widthDivisor: 1, heightDivisor: 1 });
+    }
+    return configs;
+  };
+  switch (format) {
+    case "I420":
+      return yuv(1, 1, 2, 2, false);
+    case "I420P10":
+    case "I420P12":
+      return yuv(2, 2, 2, 2, false);
+    case "I420A":
+      return yuv(1, 1, 2, 2, true);
+    case "I420AP10":
+    case "I420AP12":
+      return yuv(2, 2, 2, 2, true);
+    case "I422":
+      return yuv(1, 1, 2, 1, false);
+    case "I422P10":
+    case "I422P12":
+      return yuv(2, 2, 2, 1, false);
+    case "I422A":
+      return yuv(1, 1, 2, 1, true);
+    case "I422AP10":
+    case "I422AP12":
+      return yuv(2, 2, 2, 1, true);
+    case "I444":
+      return yuv(1, 1, 1, 1, false);
+    case "I444P10":
+    case "I444P12":
+      return yuv(2, 2, 1, 1, false);
+    case "I444A":
+      return yuv(1, 1, 1, 1, true);
+    case "I444AP10":
+    case "I444AP12":
+      return yuv(2, 2, 1, 1, true);
+    case "NV12":
+      return [
+        { sampleBytes: 1, widthDivisor: 1, heightDivisor: 1 },
+        { sampleBytes: 2, widthDivisor: 2, heightDivisor: 2 }
+      ];
+    case "RGBA":
+    case "RGBX":
+    case "BGRA":
+    case "BGRX":
+      return [{ sampleBytes: 4, widthDivisor: 1, heightDivisor: 1 }];
+    default:
+      assertNever(format);
+      assert(false);
+  }
+};
+var AUDIO_SAMPLE_FORMATS = new Set([
+  "f32",
+  "f32-planar",
+  "s16",
+  "s16-planar",
+  "s32",
+  "s32-planar",
+  "u8",
+  "u8-planar"
+]);
+// src/index.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+// packages/mpeg4/src/index.ts
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors (Wiedy Mi)
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var decodeWorkerUrl = new URL("./decode.worker.ts", import.meta.url);
+var encodeWorkerUrl = new URL("./encode.worker.ts", import.meta.url);
+var createWorker = (url) => {
+  return new Worker(url, { type: "module" });
+};
+
+class Mpeg4Decoder extends CustomVideoDecoder {
+  worker = null;
+  nextMessageId = 0;
+  pendingMessages = new Map;
+  static supports(codec, _config) {
+    return codec === "mpeg4";
+  }
+  async init() {
+    this.worker = createWorker(decodeWorkerUrl);
+    const onMessage = (event) => {
+      const data = event.data;
+      const pending = this.pendingMessages.get(data.id);
+      assert2(pending !== undefined);
+      this.pendingMessages.delete(data.id);
+      if (data.success) {
+        pending.resolve(data.data);
+      } else {
+        pending.reject(data.error);
+      }
+    };
+    this.worker.addEventListener("message", onMessage);
+    await this.sendCommand({
+      type: "init",
+      data: {
+        width: this.config.codedWidth,
+        height: this.config.codedHeight
+      }
+    });
+  }
+  async decode(packet, _meta) {
+    const frameData = packet.data.slice().buffer;
+    const result = await this.sendCommand({
+      type: "decode",
+      data: {
+        frameData
+      }
+    }, [frameData]);
+    if (!result || !("yuvData" in result)) {
+      return;
+    }
+    const videoFrame = new VideoFrame(new Uint8Array(result.yuvData), {
+      format: "I420",
+      codedWidth: result.width,
+      codedHeight: result.height,
+      timestamp: packet.timestamp * 1e6
+    });
+    const videoSample = new VideoSample(videoFrame);
+    this.onSample(videoSample);
+  }
+  async flush() {
+    await this.sendCommand({ type: "flush" });
+  }
+  close() {
+    if (this.worker) {
+      this.sendCommand({ type: "close" });
+      this.worker.terminate();
+    }
+  }
+  sendCommand(command, transferables) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextMessageId++;
+      this.pendingMessages.set(id, { resolve, reject });
+      assert2(this.worker !== null);
+      if (transferables) {
+        this.worker.postMessage({ id, command }, transferables);
+      } else {
+        this.worker.postMessage({ id, command });
+      }
+    });
+  }
+}
+
+class Mpeg4Encoder extends CustomVideoEncoder {
+  worker = null;
+  nextMessageId = 0;
+  pendingMessages = new Map;
+  frameCount = 0;
+  static supports(codec, _config) {
+    return codec === "mpeg4";
+  }
+  async init() {
+    this.worker = createWorker(encodeWorkerUrl);
+    const onMessage = (event) => {
+      const data = event.data;
+      const pending = this.pendingMessages.get(data.id);
+      assert2(pending !== undefined);
+      this.pendingMessages.delete(data.id);
+      if (data.success) {
+        pending.resolve(data.data);
+      } else {
+        pending.reject(data.error);
+      }
+    };
+    this.worker.addEventListener("message", onMessage);
+    const fpsNum = Math.round((this.config.framerate ?? 30) * 1000);
+    const fpsDen = 1000;
+    await this.sendCommand({
+      type: "init",
+      data: {
+        width: this.config.width,
+        height: this.config.height,
+        bitrate: this.config.bitrate ?? 2000000,
+        fpsNum,
+        fpsDen
+      }
+    });
+  }
+  async encode(videoSample, options) {
+    const yuvSize = videoSample.codedWidth * videoSample.codedHeight * 3 / 2;
+    const yuvData = new ArrayBuffer(yuvSize);
+    const yuvBytes = new Uint8Array(yuvData);
+    await videoSample.copyTo(yuvBytes);
+    const result = await this.sendCommand({
+      type: "encode",
+      data: {
+        yuvData,
+        forceKeyframe: options.keyFrame ?? false
+      }
+    }, [yuvData]);
+    assert2(result && "encodedData" in result);
+    const encodedPacket = new EncodedPacket(new Uint8Array(result.encodedData), options.keyFrame ? "key" : "delta", videoSample.timestamp, videoSample.duration, this.frameCount++);
+    this.onPacket(encodedPacket, this.frameCount === 1 ? {
+      decoderConfig: {
+        codec: "mpeg4",
+        codedWidth: this.config.width,
+        codedHeight: this.config.height
+      }
+    } : undefined);
+  }
+  async flush() {}
+  close() {
+    if (this.worker) {
+      this.sendCommand({ type: "close" });
+      this.worker.terminate();
+    }
+  }
+  sendCommand(command, transferables) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextMessageId++;
+      this.pendingMessages.set(id, { resolve, reject });
+      assert2(this.worker !== null);
+      if (transferables) {
+        this.worker.postMessage({ id, command }, transferables);
+      } else {
+        this.worker.postMessage({ id, command });
+      }
+    });
+  }
+}
+var registerMpeg4Decoder = () => {
+  registerDecoder(Mpeg4Decoder);
+};
+var registerMpeg4Encoder = () => {
+  registerEncoder(Mpeg4Encoder);
+};
+function assert2(x) {
+  if (!x) {
+    throw new Error("Assertion failed.");
+  }
+}
+export {
+  registerMpeg4Encoder,
+  registerMpeg4Decoder,
+  Mpeg4Encoder,
+  Mpeg4Decoder
+};