@remotion/webcodecs 4.0.251 → 4.0.253

package/dist/esm/index.mjs

@@ -125,11 +125,14 @@ var createContent = async ({ filename }) => {
       writPromise = writPromise.then(() => write(arr));
       return writPromise;
     },
-    save: async () => {
+    finish: async () => {
+      await writPromise;
       try {
         await writable.close();
       } catch {
       }
+    },
+    async getBlob() {
       const newHandle = await directoryHandle.getFileHandle(actualFilename, {
         create: true
       });
@@ -141,9 +144,6 @@ var createContent = async ({ filename }) => {
       writPromise = writPromise.then(() => updateDataAt(position, data));
       return writPromise;
     },
-    waitForFinish: async () => {
-      await writPromise;
-    },
     remove
   };
   return writer;
@@ -192,10 +192,14 @@ var createContent2 = ({ filename, mimeType }) => {
       writPromise = writPromise.then(() => write(arr));
       return writPromise;
     },
-    save: () => {
+    finish: async () => {
+      await writPromise;
       if (removed) {
         return Promise.reject(new Error("Already called .remove() on the result"));
       }
+      return Promise.resolve();
+    },
+    getBlob() {
       const arr = new Uint8Array(buf);
       return Promise.resolve(new File([arr.slice()], filename, { type: mimeType }));
     },
@@ -207,9 +211,6 @@ var createContent2 = ({ filename, mimeType }) => {
     updateDataAt: (position, newData) => {
       writPromise = writPromise.then(() => updateDataAt(position, newData));
       return writPromise;
-    },
-    waitForFinish: async () => {
-      await writPromise;
     }
   };
   return Promise.resolve(writer);
@@ -504,16 +505,38 @@ import { MediaParserInternals } from "@remotion/media-parser";
 var { Log } = MediaParserInternals;
 
 // src/io-manager/make-timeout-promise.ts
-var makeTimeoutPromise = (label, ms) => {
+var makeTimeoutPromise = ({
+  label,
+  ms,
+  controller
+}) => {
   const { promise, reject, resolve } = withResolvers();
-  const timeout = setTimeout(() => {
-    reject(new Error(`${label()} (timed out after ${ms}ms)`));
-  }, ms);
+  let timeout = null;
+  const set = () => {
+    timeout = setTimeout(() => {
+      reject(new Error(`${label()} (timed out after ${ms}ms)`));
+    }, ms);
+  };
+  set();
+  const onPause = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  };
+  const onResume = () => {
+    set();
+  };
+  controller.addEventListener("pause", onPause);
+  controller.addEventListener("resume", onResume);
   return {
     timeoutPromise: promise,
     clear: () => {
-      clearTimeout(timeout);
+      if (timeout) {
+        clearTimeout(timeout);
+      }
       resolve();
+      controller.removeEventListener("pause", onPause);
+      controller.removeEventListener("resume", onResume);
     }
   };
 };
@@ -589,19 +612,24 @@ var makeIoSynchronizer = ({
     unprocessed,
     unemitted,
     minimumProgress,
-    signal
+    controller
   }) => {
-    const { timeoutPromise, clear } = makeTimeoutPromise(() => [
-      `Waited too long for ${label} to finish:`,
-      `${getUnemittedItems()} unemitted items`,
-      `${getUnprocessed()} unprocessed items: ${JSON.stringify(_unprocessed)}`,
-      `smallest progress: ${progress.getSmallestProgress()}`,
-      `inputs: ${JSON.stringify(inputs)}`,
-      `last output: ${lastOutput}`,
-      `wanted: ${unemitted} unemitted items, ${unprocessed} unprocessed items, minimum progress ${minimumProgress}`
-    ].join(`
-`), 1e4);
-    signal.addEventListener("abort", clear);
+    await controller._internals.checkForAbortAndPause();
+    const { timeoutPromise, clear } = makeTimeoutPromise({
+      label: () => [
+        `Waited too long for ${label} to finish:`,
+        `${getUnemittedItems()} unemitted items`,
+        `${getUnprocessed()} unprocessed items: ${JSON.stringify(_unprocessed)}`,
+        `smallest progress: ${progress.getSmallestProgress()}`,
+        `inputs: ${JSON.stringify(inputs)}`,
+        `last output: ${lastOutput}`,
+        `wanted: ${unemitted} unemitted items, ${unprocessed} unprocessed items, minimum progress ${minimumProgress}`
+      ].join(`
+`),
+      ms: 1e4,
+      controller
+    });
+    controller._internals.signal.addEventListener("abort", clear);
     await Promise.race([
       timeoutPromise,
       Promise.all([
@@ -622,14 +650,14 @@ var makeIoSynchronizer = ({
         })()
       ])
     ]).finally(() => clear());
-    signal.removeEventListener("abort", clear);
+    controller._internals.signal.removeEventListener("abort", clear);
   };
-  const waitForFinish = async (signal) => {
+  const waitForFinish = async (controller) => {
     await waitFor({
       unprocessed: 0,
       unemitted: 0,
       minimumProgress: null,
-      signal
+      controller
     });
   };
   const onProcessed = () => {
@@ -650,13 +678,13 @@ var makeIoSynchronizer = ({
 var createAudioDecoder = ({
   onFrame,
   onError,
-  signal,
+  controller,
   config,
   logLevel,
   track,
   progressTracker
 }) => {
-  if (signal.aborted) {
+  if (controller._internals.signal.aborted) {
     throw new Error("Not creating audio decoder, already aborted");
   }
   if (config.codec === "pcm-s16") {
@@ -674,15 +702,17 @@ var createAudioDecoder = ({
       const abortHandler = () => {
         frame.close();
       };
-      signal.addEventListener("abort", abortHandler, { once: true });
+      controller._internals.signal.addEventListener("abort", abortHandler, {
+        once: true
+      });
       outputQueue = outputQueue.then(() => {
-        if (signal.aborted) {
+        if (controller._internals.signal.aborted) {
           return;
         }
         return onFrame(frame);
       }).then(() => {
         ioSynchronizer.onProcessed();
-        signal.removeEventListener("abort", abortHandler);
+        controller._internals.signal.removeEventListener("abort", abortHandler);
         return Promise.resolve();
       }).catch((err) => {
         frame.close();
@@ -694,7 +724,7 @@ var createAudioDecoder = ({
     }
   });
   const close = () => {
-    signal.removeEventListener("abort", onAbort);
+    controller._internals.signal.removeEventListener("abort", onAbort);
     if (audioDecoder.state === "closed") {
       return;
     }
@@ -703,7 +733,7 @@ var createAudioDecoder = ({
   const onAbort = () => {
     close();
   };
-  signal.addEventListener("abort", onAbort);
+  controller._internals.signal.addEventListener("abort", onAbort);
   audioDecoder.configure(config);
   const processSample = async (audioSample) => {
     if (audioDecoder.state === "closed") {
@@ -714,7 +744,7 @@ var createAudioDecoder = ({
       unemitted: 20,
       unprocessed: 20,
       minimumProgress: audioSample.timestamp - 1e7,
-      signal
+      controller
     });
     const chunk = new EncodedAudioChunk(audioSample);
     audioDecoder.decode(chunk);
@@ -732,7 +762,7 @@ var createAudioDecoder = ({
       } catch {
       }
       await queue;
-      await ioSynchronizer.waitForFinish(signal);
+      await ioSynchronizer.waitForFinish(controller);
       await outputQueue;
     },
     close,
@@ -741,17 +771,20 @@ var createAudioDecoder = ({
     }
   };
 };
+// src/audio-encoder.ts
+import { MediaParserAbortError } from "@remotion/media-parser";
+
 // src/wav-audio-encoder.ts
 var getWaveAudioEncoder = ({
   onChunk,
-  signal
+  controller
 }) => {
   return {
     close: () => {
       return Promise.resolve();
     },
     encodeFrame: (audioData) => {
-      if (signal.aborted) {
+      if (controller._internals.signal.aborted) {
         return Promise.resolve();
       }
       const chunk = {
@@ -773,17 +806,17 @@ var createAudioEncoder = ({
   onChunk,
   onError,
   codec,
-  signal,
+  controller,
   config: audioEncoderConfig,
   logLevel,
   onNewAudioSampleRate,
   progressTracker
 }) => {
-  if (signal.aborted) {
-    throw new Error("Not creating audio encoder, already aborted");
+  if (controller._internals.signal.aborted) {
+    throw new MediaParserAbortError("Not creating audio encoder, already aborted");
   }
   if (codec === "wav") {
-    return getWaveAudioEncoder({ onChunk, signal });
+    return getWaveAudioEncoder({ onChunk, controller });
   }
   const ioSynchronizer = makeIoSynchronizer({
     logLevel,
@@ -795,7 +828,7 @@ var createAudioEncoder = ({
     output: (chunk) => {
       ioSynchronizer.onOutput(chunk.timestamp);
       prom = prom.then(() => {
-        if (signal.aborted) {
+        if (controller._internals.signal.aborted) {
           return;
         }
         return onChunk(chunk);
@@ -811,7 +844,7 @@ var createAudioEncoder = ({
     }
   });
   const close = () => {
-    signal.removeEventListener("abort", onAbort);
+    controller._internals.signal.removeEventListener("abort", onAbort);
     if (encoder.state === "closed") {
       return;
     }
@@ -820,7 +853,7 @@ var createAudioEncoder = ({
   const onAbort = () => {
     close();
   };
-  signal.addEventListener("abort", onAbort);
+  controller._internals.signal.addEventListener("abort", onAbort);
   if (codec !== "opus" && codec !== "aac") {
     throw new Error('Only `codec: "opus"` and `codec: "aac"` is supported currently');
   }
@@ -834,7 +867,7 @@ var createAudioEncoder = ({
       unemitted: 20,
       unprocessed: 20,
       minimumProgress: audioData.timestamp - 1e7,
-      signal
+      controller
     });
     if (encoder.state === "closed") {
       return;
@@ -861,7 +894,7 @@ var createAudioEncoder = ({
     },
     waitForFinish: async () => {
       await encoder.flush();
-      await ioSynchronizer.waitForFinish(signal);
+      await ioSynchronizer.waitForFinish(controller);
       await prom;
     },
     close,
@@ -912,7 +945,7 @@ var canCopyVideoTrack = ({
     return inputTrack.codecWithoutConfig === "vp8" || inputTrack.codecWithoutConfig === "vp9";
   }
   if (outputContainer === "mp4") {
-    return inputTrack.codecWithoutConfig === "h264" && (inputContainer === "mp4" || inputContainer === "avi");
+    return (inputTrack.codecWithoutConfig === "h264" || inputTrack.codecWithoutConfig === "h265") && (inputContainer === "mp4" || inputContainer === "avi");
   }
   if (outputContainer === "wav") {
     return false;
@@ -1049,6 +1082,284 @@ var chooseCorrectAvc1Profile = ({
   return `avc1.6400${profile.hex}`;
 };
 
+// src/hevc-levels.ts
+var hevcLevels = [
+  {
+    level: "3.1",
+    maxBitrateMainTier: 1e4,
+    maxBitrateHighTier: null,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 720,
+        height: 480,
+        fps: 84.3
+      },
+      {
+        width: 720,
+        height: 576,
+        fps: 75
+      },
+      {
+        width: 960,
+        height: 540,
+        fps: 60
+      },
+      {
+        width: 1280,
+        height: 720,
+        fps: 33.7
+      }
+    ]
+  },
+  {
+    level: "4",
+    maxBitrateMainTier: 12000,
+    maxBitrateHighTier: 30000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1280,
+        height: 720,
+        fps: 68
+      },
+      {
+        width: 1920,
+        height: 1080,
+        fps: 32
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 30
+      }
+    ]
+  },
+  {
+    level: "4.1",
+    maxBitrateMainTier: 20000,
+    maxBitrateHighTier: 50000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1280,
+        height: 720,
+        fps: 136
+      },
+      {
+        width: 1920,
+        height: 1080,
+        fps: 64
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 60
+      }
+    ]
+  },
+  {
+    level: "5",
+    maxBitrateMainTier: 25000,
+    maxBitrateHighTier: 1e5,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1920,
+        height: 1080,
+        fps: 128
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 120
+      },
+      {
+        width: 3840,
+        height: 2160,
+        fps: 32
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 30
+      }
+    ]
+  },
+  {
+    level: "5.1",
+    maxBitrateMainTier: 40000,
+    maxBitrateHighTier: 160000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1920,
+        height: 1080,
+        fps: 256
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 240
+      },
+      {
+        width: 3840,
+        height: 2160,
+        fps: 64
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 60
+      }
+    ]
+  },
+  {
+    level: "5.2",
+    maxBitrateMainTier: 60000,
+    maxBitrateHighTier: 240000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 2048,
+        height: 1080,
+        fps: 300
+      },
+      {
+        width: 3840,
+        height: 2160,
+        fps: 128
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 120
+      }
+    ]
+  },
+  {
+    level: "6",
+    maxBitrateMainTier: 60000,
+    maxBitrateHighTier: 240000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 3840,
+        height: 2160,
+        fps: 128
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 120
+      },
+      {
+        width: 7680,
+        height: 4320,
+        fps: 32
+      },
+      {
+        width: 8192,
+        height: 4320,
+        fps: 30
+      }
+    ]
+  },
+  {
+    level: "6.1",
+    maxBitrateMainTier: 120000,
+    maxBitrateHighTier: 480000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 3840,
+        height: 2160,
+        fps: 256
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 240
+      },
+      {
+        width: 7680,
+        height: 4320,
+        fps: 64
+      },
+      {
+        width: 8192,
+        height: 4320,
+        fps: 60
+      }
+    ]
+  },
+  {
+    level: "6.2",
+    maxBitrateMainTier: 240000,
+    maxBitrateHighTier: 800000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 3840,
+        height: 2160,
+        fps: 512
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 480
+      },
+      {
+        width: 7680,
+        height: 4320,
+        fps: 128
+      },
+      {
+        width: 8192,
+        height: 4320,
+        fps: 120
+      }
+    ]
+  }
+];
+
+// src/choose-correct-hevc-profile.ts
+var chooseCorrectHevcProfile = ({
+  width,
+  height,
+  fps
+}) => {
+  const profile = hevcLevels.find((p) => {
+    return p.maxResolutionsAndFrameRates.some((max) => {
+      if (width > max.width) {
+        return false;
+      }
+      if (height > max.height) {
+        return false;
+      }
+      const fallbackFps = fps ?? 60;
+      return fallbackFps <= max.fps;
+    });
+  });
+  if (!profile) {
+    throw new Error(`No suitable HEVC profile found for ${width}x${height}@${fps}fps`);
+  }
+  return `hvc1.${1}.${0}.${"L"}${Math.round(Number(profile.level) * 30)}.${"b0"}`;
+};
+
+// src/get-codec-string.ts
+var getCodecStringForEncoder = ({
+  codec,
+  fps,
+  height,
+  width
+}) => {
+  if (codec === "h264") {
+    return chooseCorrectAvc1Profile({ fps, height, width });
+  }
+  if (codec === "h265") {
+    return chooseCorrectHevcProfile({ fps, height, width });
+  }
+  if (codec === "vp8") {
+    return "vp8";
+  }
+  if (codec === "vp9") {
+    return "vp09.00.10.08";
+  }
+  throw new Error(`Unknown codec: ${codec}`);
+};
+
 // src/video-encoder-config.ts
 var getVideoEncoderConfig = async ({
   codec,
@@ -1060,10 +1371,12 @@ var getVideoEncoderConfig = async ({
     return null;
   }
   const config = {
-    codec: codec === "h264" ? chooseCorrectAvc1Profile({ fps, height, width }) : codec === "vp9" ? "vp09.00.10.08" : codec,
+    codec: getCodecStringForEncoder({ codec, fps, height, width }),
     height,
     width,
-    bitrate: isSafari() ? 3000000 : undefined
+    bitrate: isSafari() ? 3000000 : undefined,
+    bitrateMode: codec === "vp9" && !isSafari() ? "quantizer" : undefined,
+    framerate: fps ?? undefined
   };
   const hardware = {
     ...config,
@@ -1106,7 +1419,11 @@ var canReencodeVideoTrack = async ({
   return Boolean(videoDecoderConfig && videoEncoderConfig);
 };
 // src/convert-media.ts
-import { parseMedia } from "@remotion/media-parser";
+import {
+  MediaParserAbortError as MediaParserAbortError3,
+  MediaParserInternals as MediaParserInternals9
+} from "@remotion/media-parser";
+import { fetchReader } from "@remotion/media-parser/fetch";
 
 // src/auto-select-writer.ts
 var autoSelectWriter = async (writer, logLevel) => {
@@ -1211,9 +1528,6 @@ var makeProgressTracker = () => {
   };
 };
 
-// src/error-cause.ts
-var error_cause_default = Error;
-
 // src/generate-output-filename.ts
 var generateOutputFilename = (source, container) => {
   const filename = typeof source === "string" ? source : source instanceof File ? source.name : "converted";
@@ -1222,6 +1536,29 @@ var generateOutputFilename = (source, container) => {
   return `${withoutExtension}.${container}`;
 };
 
+// src/get-available-containers.ts
+var availableContainers = ["webm", "mp4", "wav"];
+var getAvailableContainers = () => {
+  return availableContainers;
+};
+
+// src/get-available-video-codecs.ts
+var availableVideoCodecs = ["vp8", "vp9", "h264", "h265"];
+var getAvailableVideoCodecs = ({
+  container
+}) => {
+  if (container === "mp4") {
+    return ["h264", "h265"];
+  }
+  if (container === "webm") {
+    return ["vp8", "vp9"];
+  }
+  if (container === "wav") {
+    return [];
+  }
+  throw new Error(`Unsupported container: ${container}`);
+};
+
 // src/on-audio-track.ts
 import {
   MediaParserInternals as MediaParserInternals3
@@ -1325,7 +1662,7 @@ var makeAudioTrackHandler = ({
     return null;
   }
   if (audioOperation.type === "fail") {
-    throw new error_cause_default(`Audio track with ID ${track.trackId} resolved with {"type": "fail"}. This could mean that this audio track could neither be copied to the output container or re-encoded. You have the option to drop the track instead of failing it: https://remotion.dev/docs/webcodecs/track-transformation`);
+    throw new Error(`Audio track with ID ${track.trackId} resolved with {"type": "fail"}. This could mean that this audio track could neither be copied to the output container or re-encoded. You have the option to drop the track instead of failing it: https://remotion.dev/docs/webcodecs/track-transformation`);
   }
   if (audioOperation.type === "copy") {
     const addedTrack = await state.addTrack({
@@ -1365,17 +1702,18 @@ var makeAudioTrackHandler = ({
     description: track.description
   });
   if (!audioEncoderConfig) {
-    abortConversion(new error_cause_default(`Could not configure audio encoder of track ${track.trackId}`));
+    abortConversion(new Error(`Could not configure audio encoder of track ${track.trackId}`));
     return null;
   }
   if (!audioDecoderConfig) {
-    abortConversion(new error_cause_default(`Could not configure audio decoder of track ${track.trackId}`));
+    abortConversion(new Error(`Could not configure audio decoder of track ${track.trackId}`));
     return null;
   }
   const codecPrivate = audioOperation.audioCodec === "aac" ? MediaParserInternals3.createAacCodecPrivate({
     audioObjectType: 2,
     sampleRate: track.sampleRate,
-    channelConfiguration: track.numberOfChannels
+    channelConfiguration: track.numberOfChannels,
+    codecPrivate: null
   }) : null;
   const { trackNumber } = await state.addTrack({
     type: "audio",
@@ -1404,12 +1742,12 @@ var makeAudioTrackHandler = ({
       });
     },
     onError: (err) => {
-      abortConversion(new error_cause_default(`Audio encoder of ${track.trackId} failed (see .cause of this error)`, {
+      abortConversion(new Error(`Audio encoder of ${track.trackId} failed (see .cause of this error)`, {
         cause: err
       }));
     },
     codec: audioOperation.audioCodec,
-    signal: controller.signal,
+    controller,
     config: audioEncoderConfig,
     logLevel,
     progressTracker
@@ -1419,19 +1757,19 @@ var makeAudioTrackHandler = ({
       const newAudioData = onAudioData ? await onAudioData?.({ audioData, track }) : audioData;
       if (newAudioData !== audioData) {
         if (newAudioData.duration !== audioData.duration) {
-          throw new error_cause_default(`onAudioData returned a different duration than the input audio data. Original duration: ${audioData.duration}, new duration: ${newAudioData.duration}`);
+          throw new Error(`onAudioData returned a different duration than the input audio data. Original duration: ${audioData.duration}, new duration: ${newAudioData.duration}`);
         }
         if (newAudioData.numberOfChannels !== audioData.numberOfChannels) {
-          throw new error_cause_default(`onAudioData returned a different number of channels than the input audio data. Original channels: ${audioData.numberOfChannels}, new channels: ${newAudioData.numberOfChannels}`);
+          throw new Error(`onAudioData returned a different number of channels than the input audio data. Original channels: ${audioData.numberOfChannels}, new channels: ${newAudioData.numberOfChannels}`);
         }
         if (newAudioData.sampleRate !== audioData.sampleRate) {
-          throw new error_cause_default(`onAudioData returned a different sample rate than the input audio data. Original sample rate: ${audioData.sampleRate}, new sample rate: ${newAudioData.sampleRate}`);
+          throw new Error(`onAudioData returned a different sample rate than the input audio data. Original sample rate: ${audioData.sampleRate}, new sample rate: ${newAudioData.sampleRate}`);
         }
         if (newAudioData.format !== audioData.format) {
-          throw new error_cause_default(`onAudioData returned a different format than the input audio data. Original format: ${audioData.format}, new format: ${newAudioData.format}`);
+          throw new Error(`onAudioData returned a different format than the input audio data. Original format: ${audioData.format}, new format: ${newAudioData.format}`);
         }
         if (newAudioData.timestamp !== audioData.timestamp) {
-          throw new error_cause_default(`onAudioData returned a different timestamp than the input audio data. Original timestamp: ${audioData.timestamp}, new timestamp: ${newAudioData.timestamp}`);
+          throw new Error(`onAudioData returned a different timestamp than the input audio data. Original timestamp: ${audioData.timestamp}, new timestamp: ${newAudioData.timestamp}`);
         }
         audioData.close();
       }
@@ -1445,11 +1783,11 @@ var makeAudioTrackHandler = ({
       newAudioData.close();
     },
     onError(error) {
-      abortConversion(new error_cause_default(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
+      abortConversion(new Error(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
         cause: error
       }));
     },
-    signal: controller.signal,
+    controller,
     config: audioDecoderConfig,
     logLevel,
     track,
@@ -1610,7 +1948,7 @@ var onFrame = async ({
 var createVideoDecoder = ({
   onFrame: onFrame2,
   onError,
-  signal,
+  controller,
   config,
   logLevel,
   progress
@@ -1627,15 +1965,17 @@ var createVideoDecoder = ({
       const abortHandler = () => {
         inputFrame.close();
       };
-      signal.addEventListener("abort", abortHandler, { once: true });
+      controller._internals.signal.addEventListener("abort", abortHandler, {
+        once: true
+      });
       outputQueue = outputQueue.then(() => {
-        if (signal.aborted) {
+        if (controller._internals.signal.aborted) {
           return;
         }
         return onFrame2(inputFrame);
       }).then(() => {
         ioSynchronizer.onProcessed();
-        signal.removeEventListener("abort", abortHandler);
+        controller._internals.signal.removeEventListener("abort", abortHandler);
         return Promise.resolve();
       }).catch((err) => {
         inputFrame.close();
@@ -1647,7 +1987,7 @@ var createVideoDecoder = ({
     }
   });
   const close = () => {
-    signal.removeEventListener("abort", onAbort);
+    controller._internals.signal.removeEventListener("abort", onAbort);
     if (videoDecoder.state === "closed") {
       return;
     }
@@ -1656,7 +1996,7 @@ var createVideoDecoder = ({
   const onAbort = () => {
     close();
   };
-  signal.addEventListener("abort", onAbort);
+  controller._internals.signal.addEventListener("abort", onAbort);
   videoDecoder.configure(config);
   const processSample = async (sample) => {
     if (videoDecoder.state === "closed") {
@@ -1670,7 +2010,7 @@ var createVideoDecoder = ({
       unemitted: 20,
       unprocessed: 2,
       minimumProgress: sample.timestamp - 1e7,
-      signal
+      controller
     });
     if (sample.type === "key") {
       await videoDecoder.flush();
@@ -1687,7 +2027,7 @@ var createVideoDecoder = ({
     waitForFinish: async () => {
       await videoDecoder.flush();
       Log.verbose(logLevel, "Flushed video decoder");
-      await ioSynchronizer.waitForFinish(signal);
+      await ioSynchronizer.waitForFinish(controller);
       Log.verbose(logLevel, "IO synchro finished");
       await outputQueue;
       Log.verbose(logLevel, "Output queue finished");
@@ -1702,17 +2042,18 @@ var createVideoDecoder = ({
 };
 
 // src/video-encoder.ts
+import { MediaParserAbortError as MediaParserAbortError2 } from "@remotion/media-parser";
 var createVideoEncoder = ({
   onChunk,
   onError,
-  signal,
+  controller,
   config,
   logLevel,
   outputCodec,
   progress
 }) => {
-  if (signal.aborted) {
-    throw new Error("Not creating video encoder, already aborted");
+  if (controller._internals.signal.aborted) {
+    throw new MediaParserAbortError2("Not creating video encoder, already aborted");
   }
   const ioSynchronizer = makeIoSynchronizer({
     logLevel,
@@ -1728,7 +2069,7 @@ var createVideoEncoder = ({
       const timestamp = chunk.timestamp + (chunk.duration ?? 0);
       ioSynchronizer.onOutput(timestamp);
       outputQueue = outputQueue.then(() => {
-        if (signal.aborted) {
+        if (controller._internals.signal.aborted) {
           return;
         }
         return onChunk(chunk, metadata ?? null);
@@ -1741,7 +2082,7 @@ var createVideoEncoder = ({
     }
   });
   const close = () => {
-    signal.removeEventListener("abort", onAbort);
+    controller._internals.signal.removeEventListener("abort", onAbort);
     if (encoder.state === "closed") {
       return;
     }
@@ -1750,7 +2091,7 @@ var createVideoEncoder = ({
   const onAbort = () => {
     close();
   };
-  signal.addEventListener("abort", onAbort);
+  controller._internals.signal.addEventListener("abort", onAbort);
   Log.verbose(logLevel, "Configuring video encoder", config);
   encoder.configure(config);
   let framesProcessed = 0;
@@ -1763,14 +2104,17 @@ var createVideoEncoder = ({
       unemitted: 10,
       unprocessed: 10,
       minimumProgress: frame.timestamp - 1e7,
-      signal
+      controller
     });
     if (encoder.state === "closed") {
       return;
     }
     const keyFrame = framesProcessed % 40 === 0;
     encoder.encode(convertToCorrectVideoFrame({ videoFrame: frame, outputCodec }), {
-      keyFrame
+      keyFrame,
+      vp9: {
+        quantizer: 36
+      }
     });
     ioSynchronizer.inputItem(frame.timestamp, keyFrame);
     framesProcessed++;
@@ -1784,7 +2128,7 @@ var createVideoEncoder = ({
     waitForFinish: async () => {
       await encoder.flush();
       await outputQueue;
-      await ioSynchronizer.waitForFinish(signal);
+      await ioSynchronizer.waitForFinish(controller);
     },
     close,
     flush: async () => {
@@ -1808,8 +2152,8 @@ var makeVideoTrackHandler = ({
   progress,
   resizeOperation
 }) => async ({ track, container: inputContainer }) => {
-  if (controller.signal.aborted) {
-    throw new error_cause_default("Aborted");
+  if (controller._internals.signal.aborted) {
+    throw new Error("Aborted");
   }
   const canCopyTrack = canCopyVideoTrack({
     inputContainer,
@@ -1832,7 +2176,7 @@ var makeVideoTrackHandler = ({
     return null;
   }
   if (videoOperation.type === "fail") {
-    throw new error_cause_default(`Video track with ID ${track.trackId} resolved with {"type": "fail"}. This could mean that this video track could neither be copied to the output container or re-encoded. You have the option to drop the track instead of failing it: https://remotion.dev/docs/webcodecs/track-transformation`);
+    throw new Error(`Video track with ID ${track.trackId} resolved with {"type": "fail"}. This could mean that this video track could neither be copied to the output container or re-encoded. You have the option to drop the track instead of failing it: https://remotion.dev/docs/webcodecs/track-transformation`);
   }
   if (videoOperation.type === "copy") {
     Log.verbose(logLevel, `Copying video track with codec ${track.codec} and timescale ${track.timescale}`);
@@ -1861,7 +2205,7 @@ var makeVideoTrackHandler = ({
     };
   }
   if (videoOperation.type !== "reencode") {
-    throw new error_cause_default(`Video track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(videoOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
+    throw new Error(`Video track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(videoOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
   }
   const rotation = (videoOperation.rotate ?? rotate) - track.rotation;
   const { height: newHeight, width: newWidth } = calculateNewDimensionsFromRotateAndScale({
@@ -1879,11 +2223,11 @@ var makeVideoTrackHandler = ({
   });
   const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
   if (videoEncoderConfig === null) {
-    abortConversion(new error_cause_default(`Could not configure video encoder of track ${track.trackId}`));
+    abortConversion(new Error(`Could not configure video encoder of track ${track.trackId}`));
     return null;
   }
   if (videoDecoderConfig === null) {
-    abortConversion(new error_cause_default(`Could not configure video decoder of track ${track.trackId}`));
+    abortConversion(new Error(`Could not configure video decoder of track ${track.trackId}`));
     return null;
   }
   const { trackNumber } = await state.addTrack({
@@ -1912,11 +2256,11 @@ var makeVideoTrackHandler = ({
       });
     },
     onError: (err) => {
-      abortConversion(new error_cause_default(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
+      abortConversion(new Error(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
         cause: err
       }));
     },
-    signal: controller.signal,
+    controller,
     config: videoEncoderConfig,
     logLevel,
     outputCodec: videoOperation.videoCodec,
@@ -1936,11 +2280,11 @@ var makeVideoTrackHandler = ({
       });
     },
     onError: (err) => {
-      abortConversion(new error_cause_default(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
+      abortConversion(new Error(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
         cause: err
       }));
     },
-    signal: controller.signal,
+    controller,
     logLevel,
     progress
   });
@@ -2479,6 +2823,17 @@ var createAvccBox = (privateData) => {
   ]));
 };
 
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-hvcc.ts
+var createHvccBox = (privateData) => {
+  if (!privateData) {
+    throw new Error("privateData is required");
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("hvcC"),
+    privateData
+  ]));
+};
+
 // src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-pasp.ts
 var createPasp = (x, y) => {
   return addSize(combineUint8Arrays([
@@ -2522,6 +2877,40 @@ var createAvc1Data = ({
   ]));
 };
 
+// src/create/iso-base-media/codec-specific/hvc1.ts
+var createHvc1Data = ({
+  compressorName,
+  depth,
+  height,
+  horizontalResolution,
+  hvccBox,
+  pasp,
+  verticalResolution,
+  width
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("hvc1"),
+    new Uint8Array([0, 0, 0, 0, 0, 0]),
+    new Uint8Array([0, 1]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(width),
+    numberTo16BitUIntOrInt(height),
+    setFixedPointSignedOrUnsigned1616Number(horizontalResolution),
+    setFixedPointSignedOrUnsigned1616Number(verticalResolution),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(1),
+    stringToPascalString(compressorName),
+    numberTo16BitUIntOrInt(depth),
+    numberTo16BitUIntOrInt(-1),
+    hvccBox,
+    pasp
+  ]));
+};
+
 // src/create/iso-base-media/codec-specific/mp4a.ts
 var createMp4a = ({
   sampleRate,
@@ -2574,17 +2963,33 @@ var createMp4a = ({
 // src/create/iso-base-media/codec-specific/create-codec-specific-data.ts
 var createCodecSpecificData = (track) => {
   if (track.type === "video") {
-    return createAvc1Data({
-      avccBox: createAvccBox(track.codecPrivate),
-      compressorName: "WebCodecs",
-      depth: 24,
-      horizontalResolution: 72,
-      verticalResolution: 72,
-      height: track.height,
-      width: track.width,
-      pasp: createPasp(1, 1),
-      type: "avc1-data"
-    });
+    if (track.codec === "h264") {
+      return createAvc1Data({
+        avccBox: createAvccBox(track.codecPrivate),
+        compressorName: "WebCodecs",
+        depth: 24,
+        horizontalResolution: 72,
+        verticalResolution: 72,
+        height: track.height,
+        width: track.width,
+        pasp: createPasp(1, 1),
+        type: "avc1-data"
+      });
+    }
+    if (track.codec === "h265") {
+      return createHvc1Data({
+        hvccBox: createHvccBox(track.codecPrivate),
+        compressorName: "WebCodecs",
+        depth: 24,
+        horizontalResolution: 72,
+        verticalResolution: 72,
+        height: track.height,
+        width: track.width,
+        pasp: createPasp(1, 1),
+        type: "hvc1-data"
+      });
+    }
+    throw new Error("Unsupported codec specific data " + track.codec);
   }
   if (track.type === "audio") {
     return createMp4a({
@@ -3041,7 +3446,7 @@ var serializeTrack = ({
   samplePositions,
   timescale
 }) => {
-  if (track.codec !== "h264" && track.codec !== "aac") {
+  if (track.codec !== "h264" && track.codec !== "h265" && track.codec !== "aac") {
     throw new Error("Currently only H.264 and AAC is supported");
   }
   return createTrak({
@@ -3150,7 +3555,11 @@ var createIsoBaseMedia = async ({
     majorBrand: "isom",
     minorBrand: 512
   });
-  const w = await writer.createContent({ filename, mimeType: "video/mp4" });
+  const w = await writer.createContent({
+    filename,
+    mimeType: "video/mp4",
+    logLevel
+  });
   await w.write(header);
   let globalDurationInUnits = 0;
   const lowestTrackTimestamps = {};
@@ -3266,8 +3675,8 @@ var createIsoBaseMedia = async ({
   };
   const waitForFinishPromises = [];
   return {
-    save: () => {
-      return w.save();
+    getBlob: () => {
+      return w.getBlob();
     },
     remove: async () => {
       await w.remove();
@@ -3308,7 +3717,7 @@ var createIsoBaseMedia = async ({
       await updateMoov();
       await updateMdatSize();
       MediaParserInternals6.Log.verbose(logLevel, "All write operations done. Waiting for finish...");
-      await w.waitForFinish();
+      await w.finish();
     }
   };
 };
@@ -3743,6 +4152,9 @@ var makeAudioCodecId = (codecId) => {
   if (codecId === "aac") {
     return "A_AAC";
   }
+  if (codecId === "ac3") {
+    return "A_AC3";
+  }
   if (codecId === "mp3") {
     return "A_MPEG/L3";
   }
@@ -3943,7 +4355,11 @@ var createMatroskaMedia = async ({
   progressTracker
 }) => {
   const header = makeMatroskaHeader();
-  const w = await writer.createContent({ filename, mimeType: "video/webm" });
+  const w = await writer.createContent({
+    filename,
+    mimeType: "video/webm",
+    logLevel
+  });
   await w.write(header.bytes);
   const matroskaInfo = makeMatroskaInfo({
     timescale
@@ -4076,8 +4492,8 @@ var createMatroskaMedia = async ({
         }
       });
     },
-    save: () => {
-      return w.save();
+    getBlob: async () => {
+      return w.getBlob();
     },
     remove: async () => {
       await w.remove();
@@ -4104,9 +4520,9 @@ var createMatroskaMedia = async ({
       });
       await updateSeekWrite();
       await w.write(createMatroskaCues(cues).bytes);
-      await w.waitForFinish();
       const segmentSize = w.getWrittenByteCount() - segmentOffset - matroskaToHex(matroskaElements.Segment).byteLength - MATROSKA_SEGMENT_MIN_VINT_WIDTH;
       await updateSegmentSize(segmentSize);
+      await w.finish();
     }
   };
 };
@@ -4133,7 +4549,11 @@ var createWav = async ({
   writer,
   progressTracker
 }) => {
-  const w = await writer.createContent({ filename, mimeType: "audio/wav" });
+  const w = await writer.createContent({
+    filename,
+    mimeType: "audio/wav",
+    logLevel
+  });
   await w.write(new Uint8Array([82, 73, 70, 70]));
   const sizePosition = w.getWrittenByteCount();
   await w.write(new Uint8Array([0, 0, 0, 0]));
@@ -4183,8 +4603,8 @@ var createWav = async ({
   };
   const waitForFinishPromises = [];
   return {
-    save: () => {
-      return w.save();
+    getBlob: () => {
+      return w.getBlob();
     },
     remove: () => {
       return w.remove();
@@ -4208,7 +4628,7 @@ var createWav = async ({
       await Promise.all(waitForFinishPromises.map((p) => p()));
       await operationProm.current;
       await updateSize();
-      await w.waitForFinish();
+      await w.finish();
     },
     addTrack: async (track) => {
       if (track.type !== "audio") {
@@ -4297,7 +4717,7 @@ var throttledStateUpdate = ({
   const onAbort = () => {
     clearInterval(interval);
   };
-  signal.addEventListener("abort", onAbort, { once: true });
+  signal?.addEventListener("abort", onAbort, { once: true });
   return {
     get: () => currentState,
     update: (fn) => {
@@ -4305,12 +4725,26 @@ var throttledStateUpdate = ({
     },
     stopAndGetLastProgress: () => {
       clearInterval(interval);
-      signal.removeEventListener("abort", onAbort);
+      signal?.removeEventListener("abort", onAbort);
       return currentState;
     }
   };
 };
 
+// src/webcodecs-controller.ts
+import { mediaParserController } from "@remotion/media-parser";
+var webcodecsController = () => {
+  const controller = mediaParserController();
+  return {
+    abort: controller.abort,
+    pause: controller.pause,
+    resume: controller.resume,
+    addEventListener: controller.addEventListener,
+    removeEventListener: controller.removeEventListener,
+    _internals: controller._internals
+  };
+};
+
 // src/convert-media.ts
 var convertMedia = async function({
   src,
@@ -4320,7 +4754,7 @@ var convertMedia = async function({
   audioCodec,
   container,
   videoCodec,
-  signal: userPassedAbortSignal,
+  controller = webcodecsController(),
   onAudioTrack: userAudioResolver,
   onVideoTrack: userVideoResolver,
   reader,
@@ -4331,34 +4765,60 @@ var convertMedia = async function({
   rotate,
   apiKey,
   resize,
+  onAudioCodec,
+  onContainer,
+  onDimensions,
+  onDurationInSeconds,
+  onFps,
+  onImages,
+  onInternalStats,
+  onIsHdr,
+  onKeyframes,
+  onLocation,
+  onMetadata,
+  onMimeType,
+  onName,
+  onNumberOfAudioChannels,
+  onRotation,
+  onSampleRate,
+  onSize,
+  onSlowAudioBitrate,
+  onSlowDurationInSeconds,
+  onSlowFps,
+  onSlowKeyframes,
+  onSlowNumberOfFrames,
+  onSlowVideoBitrate,
+  onStructure,
+  onTracks,
+  onUnrotatedDimensions,
+  onVideoCodec,
   ...more
 }) {
-  if (userPassedAbortSignal?.aborted) {
-    return Promise.reject(new error_cause_default("Aborted"));
+  if (controller._internals.signal.aborted) {
+    return Promise.reject(new MediaParserAbortError3("Aborted"));
   }
-  if (container !== "webm" && container !== "mp4" && container !== "wav") {
-    return Promise.reject(new TypeError('Only `to: "webm"`, `to: "mp4"` and `to: "wav"` is supported currently'));
+  if (availableContainers.indexOf(container) === -1) {
+    return Promise.reject(new TypeError(`Only the following values for "container" are supported currently: ${JSON.stringify(availableContainers)}`));
   }
-  if (videoCodec && videoCodec !== "vp8" && videoCodec !== "vp9") {
-    return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
+  if (videoCodec && availableVideoCodecs.indexOf(videoCodec) === -1) {
+    return Promise.reject(new TypeError(`Only the following values for "videoCodec" are supported currently: ${JSON.stringify(availableVideoCodecs)}`));
   }
   const { resolve, reject, getPromiseToImmediatelyReturn } = withResolversAndWaitForReturn();
-  const controller = new AbortController;
   const abortConversion = (errCause) => {
     reject(errCause);
-    if (!controller.signal.aborted) {
+    if (!controller._internals.signal.aborted) {
       controller.abort();
     }
   };
   const onUserAbort = () => {
-    abortConversion(new error_cause_default("Conversion aborted by user"));
+    abortConversion(new MediaParserAbortError3("Conversion aborted by user"));
   };
-  userPassedAbortSignal?.addEventListener("abort", onUserAbort);
+  controller._internals.signal.addEventListener("abort", onUserAbort);
   const creator = selectContainerCreator(container);
   const throttledState = throttledStateUpdate({
     updateFn: onProgressDoNotCallDirectly ?? null,
     everyMilliseconds: progressIntervalInMs ?? 100,
-    signal: controller.signal
+    signal: controller._internals.signal
   });
   const progressTracker = makeProgressTracker();
   const state = await creator({
@@ -4416,17 +4876,17 @@ var convertMedia = async function({
     progressTracker,
     onAudioData: onAudioData ?? null
   });
-  parseMedia({
+  MediaParserInternals9.internalParseMedia({
     logLevel,
     src,
     onVideoTrack,
     onAudioTrack,
-    signal: controller.signal,
+    controller,
     fields: {
       ...fields,
       durationInSeconds: true
     },
-    reader,
+    reader: reader ?? fetchReader,
     ...more,
     onDurationInSeconds: (durationInSeconds) => {
       if (durationInSeconds === null) {
@@ -4447,12 +4907,45 @@ var convertMedia = async function({
           })
         };
       });
-    }
+    },
+    acknowledgeRemotionLicense: true,
+    mode: "query",
+    onDiscardedData: null,
+    onError: () => ({ action: "fail" }),
+    onParseProgress: null,
+    progressIntervalInMs: null,
+    onAudioCodec: onAudioCodec ?? null,
+    onContainer: onContainer ?? null,
+    onDimensions: onDimensions ?? null,
+    onFps: onFps ?? null,
+    onImages: onImages ?? null,
+    onInternalStats: onInternalStats ?? null,
+    onIsHdr: onIsHdr ?? null,
+    onKeyframes: onKeyframes ?? null,
+    onLocation: onLocation ?? null,
+    onMetadata: onMetadata ?? null,
+    onMimeType: onMimeType ?? null,
+    onName: onName ?? null,
+    onNumberOfAudioChannels: onNumberOfAudioChannels ?? null,
+    onRotation: onRotation ?? null,
+    onSampleRate: onSampleRate ?? null,
+    onSize: onSize ?? null,
+    onSlowAudioBitrate: onSlowAudioBitrate ?? null,
+    onSlowDurationInSeconds: onSlowDurationInSeconds ?? null,
+    onSlowFps: onSlowFps ?? null,
+    onSlowKeyframes: onSlowKeyframes ?? null,
+    onSlowNumberOfFrames: onSlowNumberOfFrames ?? null,
+    onSlowVideoBitrate: onSlowVideoBitrate ?? null,
+    onStructure: onStructure ?? null,
+    onTracks: onTracks ?? null,
+    onUnrotatedDimensions: onUnrotatedDimensions ?? null,
+    onVideoCodec: onVideoCodec ?? null,
+    apiName: "convertMedia()"
   }).then(() => {
     return state.waitForFinish();
   }).then(() => {
     resolve({
-      save: state.save,
+      save: state.getBlob,
       remove: state.remove,
       finalState: throttledState.get()
     });
@@ -4469,7 +4962,7 @@ var convertMedia = async function({
     throttledState.stopAndGetLastProgress();
   });
   return getPromiseToImmediatelyReturn().finally(() => {
-    userPassedAbortSignal?.removeEventListener("abort", onUserAbort);
+    controller._internals.signal.removeEventListener("abort", onUserAbort);
   });
 };
 // src/get-available-audio-codecs.ts
@@ -4487,26 +4980,6 @@ var getAvailableAudioCodecs = ({
   }
   throw new Error(`Unsupported container: ${container}`);
 };
-// src/get-available-containers.ts
-var availableContainers = ["webm", "mp4", "wav"];
-var getAvailableContainers = () => {
-  return availableContainers;
-};
-// src/get-available-video-codecs.ts
-var getAvailableVideoCodecs = ({
-  container
-}) => {
-  if (container === "mp4") {
-    return ["h264"];
-  }
-  if (container === "webm") {
-    return ["vp8", "vp9"];
-  }
-  if (container === "wav") {
-    return [];
-  }
-  throw new Error(`Unsupported container: ${container}`);
-};
 // src/index.ts
 var WebCodecsInternals = {
   rotateAndResizeVideoFrame,
@@ -4515,6 +4988,7 @@ var WebCodecsInternals = {
 };
 setRemotionImported();
 export {
+  webcodecsController,
   getDefaultVideoCodec,
   getDefaultAudioCodec,
   getAvailableVideoCodecs,