mediabunny 1.26.0 → 1.27.1

package/README.md

@@ -17,7 +17,10 @@ Mediabunny is a JavaScript library for reading, writing, and converting media fi
 
 <div align="center">
   <a href="https://remotion.dev/" target="_blank" rel="sponsored">
-    <img src="./docs/public/sponsors/remotion.png" width="60" height="60" alt="Remotion">
+    <picture>
+      <source srcset="./docs/public/sponsors/remotion-dark.png" media="(prefers-color-scheme: dark)">
+      <img src="./docs/public/sponsors/remotion-light.png" width="60" height="60" alt="Remotion">
+    </picture>
   </a>
   &nbsp;&nbsp;&nbsp;&nbsp;
   <a href="https://www.gling.ai/" target="_blank" rel="sponsored">

package/dist/bundles/mediabunny.cjs

@@ -128,7 +128,9 @@ var Mediabunny = (() => {
     TextSubtitleSource: () => TextSubtitleSource,
     UrlSource: () => UrlSource,
     VIDEO_CODECS: () => VIDEO_CODECS,
+    VIDEO_SAMPLE_PIXEL_FORMATS: () => VIDEO_SAMPLE_PIXEL_FORMATS,
     VideoSample: () => VideoSample,
+    VideoSampleColorSpace: () => VideoSampleColorSpace,
     VideoSampleSink: () => VideoSampleSink,
     VideoSampleSource: () => VideoSampleSource,
     VideoSource: () => VideoSource,
@@ -1930,27 +1932,44 @@ var Mediabunny = (() => {
     }
     return new Uint8Array(result);
   };
-  var transformAnnexBToLengthPrefixed = (packetData) => {
-    const NAL_UNIT_LENGTH_SIZE = 4;
-    const nalUnits = findNalUnitsInAnnexB(packetData);
-    if (nalUnits.length === 0) {
-      return null;
-    }
-    let totalSize = 0;
+  var ANNEX_B_START_CODE = new Uint8Array([0, 0, 0, 1]);
+  var concatNalUnitsInAnnexB = (nalUnits) => {
+    const totalLength = nalUnits.reduce((a, b) => a + ANNEX_B_START_CODE.byteLength + b.byteLength, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
     for (const nalUnit of nalUnits) {
-      totalSize += NAL_UNIT_LENGTH_SIZE + nalUnit.byteLength;
+      result.set(ANNEX_B_START_CODE, offset);
+      offset += ANNEX_B_START_CODE.byteLength;
+      result.set(nalUnit, offset);
+      offset += nalUnit.byteLength;
     }
-    const avccData = new Uint8Array(totalSize);
-    const dataView = new DataView(avccData.buffer);
+    return result;
+  };
+  var concatNalUnitsInLengthPrefixed = (nalUnits, lengthSize) => {
+    const totalLength = nalUnits.reduce((a, b) => a + lengthSize + b.byteLength, 0);
+    const result = new Uint8Array(totalLength);
     let offset = 0;
     for (const nalUnit of nalUnits) {
-      const length = nalUnit.byteLength;
-      dataView.setUint32(offset, length, false);
-      offset += 4;
-      avccData.set(nalUnit, offset);
+      const dataView = new DataView(result.buffer, result.byteOffset, result.byteLength);
+      switch (lengthSize) {
+        case 1:
+          dataView.setUint8(offset, nalUnit.byteLength);
+          break;
+        case 2:
+          dataView.setUint16(offset, nalUnit.byteLength, false);
+          break;
+        case 3:
+          setUint24(dataView, offset, nalUnit.byteLength, false);
+          break;
+        case 4:
+          dataView.setUint32(offset, nalUnit.byteLength, false);
+          break;
+      }
+      offset += lengthSize;
+      result.set(nalUnit, offset);
       offset += nalUnit.byteLength;
     }
-    return avccData;
+    return result;
   };
   var extractAvcNalUnits = (packetData, decoderConfig) => {
     if (decoderConfig.description) {
@@ -1962,6 +1981,16 @@ var Mediabunny = (() => {
       return findNalUnitsInAnnexB(packetData);
     }
   };
+  var concatAvcNalUnits = (nalUnits, decoderConfig) => {
+    if (decoderConfig.description) {
+      const bytes2 = toUint8Array(decoderConfig.description);
+      const lengthSizeMinusOne = bytes2[4] & 3;
+      const lengthSize = lengthSizeMinusOne + 1;
+      return concatNalUnitsInLengthPrefixed(nalUnits, lengthSize);
+    } else {
+      return concatNalUnitsInAnnexB(nalUnits);
+    }
+  };
   var extractNalUnitTypeForAvc = (data) => {
     return data[0] & 31;
   };
@@ -3834,6 +3863,43 @@ var Mediabunny = (() => {
       }
     });
   }
+  var VIDEO_SAMPLE_PIXEL_FORMATS = [
+    // 4:2:0 Y, U, V
+    "I420",
+    "I420P10",
+    "I420P12",
+    // 4:2:0 Y, U, V, A
+    "I420A",
+    "I420AP10",
+    "I420AP12",
+    // 4:2:2 Y, U, V
+    "I422",
+    "I422P10",
+    "I422P12",
+    // 4:2:2 Y, U, V, A
+    "I422A",
+    "I422AP10",
+    "I422AP12",
+    // 4:4:4 Y, U, V
+    "I444",
+    "I444P10",
+    "I444P12",
+    // 4:4:4 Y, U, V, A
+    "I444A",
+    "I444AP10",
+    "I444AP12",
+    // 4:2:0 Y, UV
+    "NV12",
+    // 4:4:4 RGBA
+    "RGBA",
+    // 4:4:4 RGBX (opaque)
+    "RGBX",
+    // 4:4:4 BGRA
+    "BGRA",
+    // 4:4:4 BGRX (opaque)
+    "BGRX"
+  ];
+  var VIDEO_SAMPLE_PIXEL_FORMATS_SET = new Set(VIDEO_SAMPLE_PIXEL_FORMATS);
   var VideoSample = class _VideoSample {
     constructor(data, init) {
       /** @internal */
@@ -3842,8 +3908,8 @@ var Mediabunny = (() => {
         if (!init || typeof init !== "object") {
           throw new TypeError("init must be an object.");
         }
-        if (!("format" in init) || typeof init.format !== "string") {
-          throw new TypeError("init.format must be a string.");
+        if (init.format === void 0 || !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.");
@@ -3861,13 +3927,14 @@ var Mediabunny = (() => {
           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 VideoColorSpace(init.colorSpace);
+        this.colorSpace = new VideoSampleColorSpace(init.colorSpace);
       } else if (typeof VideoFrame !== "undefined" && data instanceof VideoFrame) {
         if (init?.rotation !== void 0 && ![0, 90, 180, 270].includes(init.rotation)) {
           throw new TypeError("init.rotation, when provided, must be 0, 90, 180, or 270.");
@@ -3879,13 +3946,14 @@ var Mediabunny = (() => {
           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 = data.colorSpace;
+        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.");
@@ -3933,13 +4001,14 @@ var Mediabunny = (() => {
         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 VideoColorSpace({
+        this.colorSpace = new VideoSampleColorSpace({
           matrix: "rgb",
           primaries: "bt709",
           transfer: "iec61966-2-1",
@@ -3986,8 +4055,10 @@ var Mediabunny = (() => {
           rotation: this.rotation
         });
       } else if (this._data instanceof Uint8Array) {
-        return new _VideoSample(this._data.slice(), {
+        assert(this._layout);
+        return new _VideoSample(this._data, {
           format: this.format,
+          layout: this._layout,
           codedWidth: this.codedWidth,
           codedHeight: this.codedHeight,
           timestamp: this.timestamp,
@@ -4023,34 +4094,71 @@ var Mediabunny = (() => {
       }
       this._closed = true;
     }
-    /** Returns the number of bytes required to hold this video sample's pixel data. */
-    allocationSize() {
+    /**
+     * Returns the number of bytes required to hold this video sample's pixel data. Throws if `format` is `null`;
+     * specify an explicit RGB format in the options in this case.
+     */
+    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();
+        return this._data.allocationSize(options);
       } else if (this._data instanceof Uint8Array) {
         return this._data.byteLength;
       } else {
         return this.codedWidth * this.codedHeight * 4;
       }
     }
-    /** Copies this video sample's pixel data to an ArrayBuffer or ArrayBufferView. */
-    async copyTo(destination) {
+    /**
+     * Copies this video sample's pixel data to an ArrayBuffer or ArrayBufferView. Throws if `format` is `null`;
+     * specify an explicit RGB format in the options in this case.
+     * @returns The byte layout of the planes of the copied data.
+     */
+    async copyTo(destination, options = {}) {
       if (!isAllowSharedBufferSource(destination)) {
         throw new TypeError("destination must be an ArrayBuffer or an ArrayBuffer view.");
       }
+      validateVideoFrameCopyToOptions(options);
       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)) {
-        await this._data.copyTo(destination);
+        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");
@@ -4058,6 +4166,10 @@ var Mediabunny = (() => {
         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
+        }];
       }
     }
     /**
@@ -4303,6 +4415,24 @@ var Mediabunny = (() => {
       this.close();
     }
   };
+  var VideoSampleColorSpace = class {
+    /** Creates a new VideoSampleColorSpace. */
+    constructor(init) {
+      this.primaries = init?.primaries ?? null;
+      this.transfer = init?.transfer ?? null;
+      this.matrix = init?.matrix ?? null;
+      this.fullRange = init?.fullRange ?? null;
+    }
+    /** Serializes the color space to a JSON object. */
+    toJSON() {
+      return {
+        primaries: this.primaries,
+        transfer: this.transfer,
+        matrix: this.matrix,
+        fullRange: this.fullRange
+      };
+    }
+  };
   var isVideoFrame = (x) => {
     return typeof VideoFrame !== "undefined" && x instanceof VideoFrame;
   };
@@ -4331,6 +4461,128 @@ var Mediabunny = (() => {
       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 !== void 0 && !["display-p3", "srgb"].includes(options.colorSpace)) {
+      throw new TypeError("options.colorSpace, when provided, must be 'display-p3' or 'srgb'.");
+    }
+    if (options.format !== void 0 && typeof options.format !== "string") {
+      throw new TypeError("options.format, when provided, must be a string.");
+    }
+    if (options.layout !== void 0) {
+      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 !== void 0) {
+      if (!options.rect || typeof options.rect !== "object") {
+        throw new TypeError("options.rect, when provided, must be an object.");
+      }
+      if (options.rect.x !== void 0 && (!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 !== void 0 && (!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 !== void 0 && (!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 !== void 0 && (!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 }
+          // Interleaved U and V
+        ];
+      case "RGBA":
+      case "RGBX":
+      case "BGRA":
+      case "BGRX":
+        return [
+          { sampleBytes: 4, widthDivisor: 1, heightDivisor: 1 }
+        ];
+      default:
+        assertNever(format);
+        assert(false);
+    }
+  };
   var AUDIO_SAMPLE_FORMATS = /* @__PURE__ */ new Set(
     ["f32", "f32-planar", "s16", "s16-planar", "s32", "s32-planar", "u8", "u8-planar"]
   );
@@ -5086,7 +5338,6 @@ var Mediabunny = (() => {
       let terminated = false;
       let outOfBandError = null;
       (async () => {
-        const decoderError = new Error();
         const decoder = await this._createDecoder((sample) => {
           onQueueDequeue();
           if (sample.timestamp >= endTimestamp) {
@@ -5115,7 +5366,6 @@ var Mediabunny = (() => {
           }
         }, (error) => {
           if (!outOfBandError) {
-            error.stack = decoderError.stack;
             outOfBandError = error;
             onQueueNotEmpty();
           }
@@ -5225,7 +5475,6 @@ var Mediabunny = (() => {
         ({ promise: queueNotEmpty, resolve: onQueueNotEmpty } = promiseWithResolvers());
       };
       (async () => {
-        const decoderError = new Error();
         const decoder = await this._createDecoder((sample) => {
           onQueueDequeue();
           if (terminated) {
@@ -5246,7 +5495,6 @@ var Mediabunny = (() => {
           }
         }, (error) => {
           if (!outOfBandError) {
-            error.stack = decoderError.stack;
             outOfBandError = error;
             onQueueNotEmpty();
           }
@@ -5436,6 +5684,7 @@ var Mediabunny = (() => {
             }
           }
         }
+        const stack = new Error("Decoding error").stack;
         this.decoder = new VideoDecoder({
           output: (frame) => {
             try {
@@ -5444,7 +5693,10 @@ var Mediabunny = (() => {
               this.onError(error);
             }
           },
-          error: onError
+          error: (error) => {
+            error.stack = stack;
+            this.onError(error);
+          }
         });
         this.decoder.configure(this.decoderConfig);
       }
@@ -5467,7 +5719,6 @@ var Mediabunny = (() => {
         }
         this.raslSkipped = true;
       }
-      this.currentPacketIndex++;
       if (this.customDecoder) {
         this.customDecoderQueueSize++;
         void this.customDecoderCallSerializer.call(() => this.customDecoder.decode(packet)).then(() => this.customDecoderQueueSize--);
@@ -5476,9 +5727,19 @@ var Mediabunny = (() => {
         if (!isWebKit()) {
           insertSorted(this.inputTimestamps, packet.timestamp, (x) => x);
         }
+        if (isChromium() && this.currentPacketIndex === 0 && this.codec === "avc") {
+          const nalUnits = extractAvcNalUnits(packet.data, this.decoderConfig);
+          const filteredNalUnits = nalUnits.filter((x) => {
+            const type = extractNalUnitTypeForAvc(x);
+            return !(type >= 20 && type <= 31);
+          });
+          const newData = concatAvcNalUnits(filteredNalUnits, this.decoderConfig);
+          packet = new EncodedPacket(newData, packet.type, packet.timestamp, packet.duration);
+        }
         this.decoder.decode(packet.toEncodedVideoChunk());
         this.decodeAlphaData(packet);
       }
+      this.currentPacketIndex++;
     }
     decodeAlphaData(packet) {
       if (!packet.sideData.alpha || this.mergerCreationFailed) {
@@ -5517,6 +5778,7 @@ var Mediabunny = (() => {
             }
           }
         };
+        const stack = new Error("Decoding error").stack;
         this.alphaDecoder = new VideoDecoder({
           output: (frame) => {
             try {
@@ -5525,7 +5787,10 @@ var Mediabunny = (() => {
               this.onError(error);
             }
           },
-          error: this.onError
+          error: (error) => {
+            error.stack = stack;
+            this.onError(error);
+          }
         });
         this.alphaDecoder.configure(this.decoderConfig);
       }
@@ -6029,6 +6294,7 @@ var Mediabunny = (() => {
         };
         void this.customDecoderCallSerializer.call(() => this.customDecoder.init());
       } else {
+        const stack = new Error("Decoding error").stack;
         this.decoder = new AudioDecoder({
           output: (data) => {
             try {
@@ -6037,7 +6303,10 @@ var Mediabunny = (() => {
               this.onError(error);
             }
           },
-          error: onError
+          error: (error) => {
+            error.stack = stack;
+            this.onError(error);
+          }
         });
         this.decoder.configure(decoderConfig);
       }
@@ -19297,13 +19566,13 @@ var Mediabunny = (() => {
         const trackData = this.getVideoTrackData(track, packet, meta);
         let packetData = packet.data;
         if (trackData.info.requiresAnnexBTransformation) {
-          const transformedData = transformAnnexBToLengthPrefixed(packetData);
-          if (!transformedData) {
+          const nalUnits = findNalUnitsInAnnexB(packetData);
+          if (nalUnits.length === 0) {
             throw new Error(
               "Failed to transform packet data. Make sure all packets are provided in Annex B format, as specified in ITU-T-REC-H.264 and ITU-T-REC-H.265."
             );
           }
-          packetData = transformedData;
+          packetData = concatNalUnitsInLengthPrefixed(nalUnits, 4);
         }
         const timestamp = this.validateAndNormalizeTimestamp(
           trackData.track,
@@ -24525,6 +24794,11 @@ ${cue.notes ?? ""}`;
     if (videoOptions?.processedHeight !== void 0 && (!Number.isInteger(videoOptions.processedHeight) || videoOptions.processedHeight <= 0)) {
       throw new TypeError("options.video.processedHeight, when provided, must be a positive integer.");
     }
+    if (videoOptions?.hardwareAcceleration !== void 0 && !["no-preference", "prefer-hardware", "prefer-software"].includes(videoOptions.hardwareAcceleration)) {
+      throw new TypeError(
+        "options.video.hardwareAcceleration, when provided, must be 'no-preference', 'prefer-hardware' or 'prefer-software'."
+      );
+    }
   };
   var validateAudioOptions = (audioOptions) => {
     if (audioOptions !== void 0 && (!audioOptions || typeof audioOptions !== "object")) {
@@ -24953,7 +25227,8 @@ The @mediabunny/mp3-encoder extension package provides support for encoding MP3.
           bitrate,
           keyFrameInterval: trackOptions.keyFrameInterval,
           sizeChangeBehavior: trackOptions.fit ?? "passThrough",
-          alpha
+          alpha,
+          hardwareAcceleration: trackOptions.hardwareAcceleration
         };
         const source = new VideoSampleSource(encodingConfig);
         videoSource = source;