@remotion/webcodecs 4.0.230 → 4.0.232

package/dist/esm/index.mjs

@@ -1,3 +1,18 @@
+// src/set-remotion-imported.ts
+import { VERSION } from "@remotion/media-parser";
+var setRemotionImported = () => {
+  if (typeof globalThis === "undefined") {
+    return;
+  }
+  if (globalThis.remotion_imported) {
+    return;
+  }
+  globalThis.remotion_imported = VERSION;
+  if (typeof window !== "undefined") {
+    window.remotion_imported = `${VERSION}-webcodecs`;
+  }
+};
+
 // src/log.ts
 import { MediaParserInternals } from "@remotion/media-parser";
 var { Log } = MediaParserInternals;
@@ -114,12 +129,18 @@ var makeIoSynchronizer = (logLevel, label) => {
     _unprocessed,
     unemitted
   }) => {
-    while (getUnemittedItems() > unemitted) {
-      await waitForOutput();
-    }
-    while (getUnprocessed() > _unprocessed) {
-      await waitForProcessed();
-    }
+    await Promise.all([
+      async () => {
+        while (getUnemittedItems() > unemitted) {
+          await waitForOutput();
+        }
+      },
+      async () => {
+        while (getUnprocessed() > _unprocessed) {
+          await waitForProcessed();
+        }
+      }
+    ]);
   };
   const waitForFinish = async () => {
     await waitFor({ _unprocessed: 0, unemitted: 0 });
@@ -200,11 +221,15 @@ var createAudioDecoder = ({
   let queue = Promise.resolve();
   return {
     processSample: (sample) => {
+      if (sample.data.length === 0) {
+        return queue;
+      }
       queue = queue.then(() => processSample(sample));
       return queue;
     },
     waitForFinish: async () => {
       await audioDecoder.flush();
+      await queue;
       await ioSynchronizer.waitForFinish();
       await outputQueue;
     },
@@ -214,6 +239,33 @@ var createAudioDecoder = ({
     }
   };
 };
+// src/wav-audio-encoder.ts
+var getWaveAudioEncoder = ({
+  onChunk,
+  signal
+}) => {
+  return {
+    close: () => {
+      return Promise.resolve();
+    },
+    encodeFrame: (audioData) => {
+      if (signal.aborted) {
+        return Promise.resolve();
+      }
+      const chunk = {
+        timestamp: audioData.timestamp,
+        duration: audioData.duration,
+        type: "key",
+        copyTo: (destination) => audioData.copyTo(destination, { planeIndex: 0, format: "s16" }),
+        byteLength: audioData.allocationSize({ planeIndex: 0, format: "s16" })
+      };
+      return onChunk(chunk);
+    },
+    flush: () => Promise.resolve(),
+    waitForFinish: () => Promise.resolve()
+  };
+};
+
 // src/audio-encoder.ts
 var createAudioEncoder = ({
   onChunk,
@@ -227,6 +279,9 @@ var createAudioEncoder = ({
   if (signal.aborted) {
     throw new Error("Not creating audio encoder, already aborted");
   }
+  if (codec === "wav") {
+    return getWaveAudioEncoder({ onChunk, signal });
+  }
   const ioSynchronizer = makeIoSynchronizer(logLevel, "Audio encoder");
   let prom = Promise.resolve();
   const encoder = new AudioEncoder({
@@ -267,7 +322,7 @@ var createAudioEncoder = ({
     if (encoder.state === "closed") {
       return;
     }
-    await ioSynchronizer.waitFor({ unemitted: 2, _unprocessed: 2 });
+    await ioSynchronizer.waitFor({ unemitted: 20, _unprocessed: 20 });
     if (encoder.state === "closed") {
       return;
     }
@@ -313,6 +368,9 @@ var canCopyAudioTrack = ({
   if (container === "mp4") {
     return inputCodec === "aac";
   }
+  if (container === "wav") {
+    return false;
+  }
   throw new Error(`Unhandled codec: ${container}`);
 };
 // src/can-copy-video-track.ts
@@ -324,7 +382,10 @@ var canCopyVideoTrack = ({
     return inputCodec === "vp8" || inputCodec === "vp9";
   }
   if (container === "mp4") {
-    return inputCodec === "h264" || inputCodec === "h265";
+    return inputCodec === "h264";
+  }
+  if (container === "wav") {
+    return false;
   }
   throw new Error(`Unhandled codec: ${container}`);
 };
@@ -350,6 +411,9 @@ var getCodecString = (audioCodec) => {
   if (audioCodec === "aac") {
     return "mp4a.40.02";
   }
+  if (audioCodec === "wav") {
+    return "wav-should-not-to-into-audio-encoder";
+  }
   throw new Error(`Unsupported audio codec: ${audioCodec}`);
 };
 var getAudioEncoderConfig = async (config) => {
@@ -357,6 +421,9 @@ var getAudioEncoderConfig = async (config) => {
     ...config,
     codec: getCodecString(config.codec)
   };
+  if (config.codec === "wav") {
+    return actualConfig;
+  }
   if (typeof AudioEncoder === "undefined") {
     return null;
   }
@@ -373,6 +440,9 @@ var canReencodeAudioTrack = async ({
   bitrate
 }) => {
   const audioDecoderConfig = await getAudioDecoderConfig(track);
+  if (audioCodec === "wav" && audioDecoderConfig) {
+    return true;
+  }
   const audioEncoderConfig = await getAudioEncoderConfig({
     codec: audioCodec,
     numberOfChannels: track.numberOfChannels,
@@ -403,6 +473,14 @@ var getVideoDecoderConfigWithHardwareAcceleration = async (config) => {
   return null;
 };
 
+// src/browser-quirks.ts
+var isFirefox = () => {
+  return navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
+};
+var isSafari = () => {
+  return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+};
+
 // src/choose-correct-avc1-profile.ts
 var chooseCorrectAvc1Profile = ({
   width,
@@ -451,7 +529,8 @@ var getVideoEncoderConfig = async ({
   const config = {
     codec: codec === "h264" ? chooseCorrectAvc1Profile({ fps, height, width }) : codec === "vp9" ? "vp09.00.10.08" : codec,
     height,
-    width
+    width,
+    bitrate: isSafari() ? 3000000 : undefined
   };
   const hardware = {
     ...config,
@@ -484,34 +563,8 @@ var canReencodeVideoTrack = async ({
   const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
   return Boolean(videoDecoderConfig && videoEncoderConfig);
 };
-// src/codec-id.ts
-var availableContainers = ["webm", "mp4"];
-var getAvailableContainers = () => {
-  return availableContainers;
-};
-var getAvailableVideoCodecs = (container) => {
-  if (container === "mp4") {
-    return ["h264"];
-  }
-  if (container === "webm") {
-    return ["vp8", "vp9"];
-  }
-  throw new Error(`Unsupported container: ${container}`);
-};
-var getAvailableAudioCodecs = (container) => {
-  if (container === "mp4") {
-    return ["aac"];
-  }
-  if (container === "webm") {
-    return ["opus"];
-  }
-  throw new Error(`Unsupported container: ${container}`);
-};
 // src/convert-media.ts
-import {
-  MediaParserInternals as MediaParserInternals4,
-  parseMedia
-} from "@remotion/media-parser";
+import { parseMedia } from "@remotion/media-parser";
 
 // src/auto-select-writer.ts
 import { bufferWriter } from "@remotion/media-parser/buffer";
@@ -544,6 +597,14 @@ var calculateProgress = ({
 // 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";
+  const behindSlash = filename.split("/").pop();
+  const withoutExtension = behindSlash.split(".").slice(0, -1).join(".");
+  return `${withoutExtension}.${container}`;
+};
+
 // src/convert-encoded-chunk.ts
 var convertEncodedChunk = (chunk, trackId) => {
   const arr = new Uint8Array(chunk.byteLength);
@@ -572,6 +633,9 @@ var getDefaultAudioCodec = ({
   if (container === "mp4") {
     return "aac";
   }
+  if (container === "wav") {
+    return "wav";
+  }
   throw new Error(`Unhandled container: ${container}`);
 };
 
@@ -614,7 +678,6 @@ var defaultOnAudioTrackHandler = async ({
 var makeAudioTrackHandler = ({
   state,
   defaultAudioCodec: audioCodec,
-  convertMediaState,
   controller,
   abortConversion,
   onMediaStateUpdate,
@@ -652,8 +715,12 @@ var makeAudioTrackHandler = ({
         timescale: track.timescale,
         codecPrivate: track.codecPrivate
       });
-      convertMediaState.encodedAudioFrames++;
-      onMediaStateUpdate?.({ ...convertMediaState });
+      onMediaStateUpdate?.((prevState) => {
+        return {
+          ...prevState,
+          encodedAudioFrames: prevState.encodedAudioFrames + 1
+        };
+      });
     };
   }
   const audioEncoderConfig = await getAudioEncoderConfig({
@@ -679,7 +746,7 @@ var makeAudioTrackHandler = ({
   const codecPrivate = audioOperation.audioCodec === "aac" ? new Uint8Array([17, 144]) : null;
   const { trackNumber } = await state.addTrack({
     type: "audio",
-    codec: audioOperation.audioCodec,
+    codec: audioOperation.audioCodec === "wav" ? "pcm-s16" : audioOperation.audioCodec,
     numberOfChannels: track.numberOfChannels,
     sampleRate: track.sampleRate,
     codecPrivate,
@@ -697,8 +764,12 @@ var makeAudioTrackHandler = ({
         timescale: track.timescale,
         codecPrivate
       });
-      convertMediaState.encodedAudioFrames++;
-      onMediaStateUpdate?.({ ...convertMediaState });
+      onMediaStateUpdate?.((prevState) => {
+        return {
+          ...prevState,
+          encodedAudioFrames: prevState.encodedAudioFrames + 1
+        };
+      });
     },
     onError: (err) => {
       abortConversion(new error_cause_default(`Audio encoder of ${track.trackId} failed (see .cause of this error)`, {
@@ -713,8 +784,12 @@ var makeAudioTrackHandler = ({
   const audioDecoder = createAudioDecoder({
     onFrame: async (frame) => {
       await audioEncoder.encodeFrame(frame);
-      convertMediaState.decodedAudioFrames++;
-      onMediaStateUpdate?.(convertMediaState);
+      onMediaStateUpdate?.((prevState) => {
+        return {
+          ...prevState,
+          decodedAudioFrames: prevState.decodedAudioFrames + 1
+        };
+      });
       frame.close();
     },
     onError(error) {
@@ -752,7 +827,13 @@ var getDefaultVideoCodec = ({
   if (container === "webm") {
     return "vp8";
   }
-  throw new Error(`Unhandled container: ${container} satisfies never`);
+  if (container === "mp4") {
+    return "h264";
+  }
+  if (container === "wav") {
+    return null;
+  }
+  throw new Error(`Unhandled container: ${container}`);
 };
 
 // src/default-on-video-track-handler.ts
@@ -771,6 +852,10 @@ var defaultOnVideoTrackHandler = async ({
     return Promise.resolve({ type: "copy" });
   }
   const videoCodec = defaultVideoCodec ?? getDefaultVideoCodec({ container });
+  if (videoCodec === null) {
+    MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): No default video codec, therefore dropping`);
+    return Promise.resolve({ type: "drop" });
+  }
   const canReencode = await canReencodeVideoTrack({
     videoCodec,
     track
@@ -783,22 +868,48 @@ var defaultOnVideoTrackHandler = async ({
   return Promise.resolve({ type: "fail" });
 };
 
+// src/convert-to-correct-videoframe.ts
+var needsToCorrectVideoFrame = ({
+  videoFrame,
+  outputCodec
+}) => {
+  if (videoFrame.format === null) {
+    return true;
+  }
+  return isFirefox() && videoFrame.format === "BGRX" && outputCodec === "h264";
+};
+var convertToCorrectVideoFrame = ({
+  videoFrame,
+  outputCodec
+}) => {
+  if (!needsToCorrectVideoFrame({ videoFrame, outputCodec })) {
+    return videoFrame;
+  }
+  const canvas = new OffscreenCanvas(videoFrame.displayWidth, videoFrame.displayHeight);
+  canvas.width = videoFrame.displayWidth;
+  canvas.height = videoFrame.displayHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Could not get 2d context");
+  }
+  ctx.drawImage(videoFrame, 0, 0);
+  return new VideoFrame(canvas, {
+    displayHeight: videoFrame.displayHeight,
+    displayWidth: videoFrame.displayWidth,
+    duration: videoFrame.duration,
+    timestamp: videoFrame.timestamp
+  });
+};
+
 // src/on-frame.ts
 var onFrame = async ({
   frame,
   onVideoFrame,
   videoEncoder,
-  onMediaStateUpdate,
   track,
-  convertMediaState
+  outputCodec
 }) => {
   const newFrame = onVideoFrame ? await onVideoFrame({ frame, track }) : frame;
-  if (newFrame.codedHeight !== frame.codedHeight) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedHeight (${newFrame.codedHeight}) than the input frame (${frame.codedHeight})`);
-  }
-  if (newFrame.codedWidth !== frame.codedWidth) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedWidth (${newFrame.codedWidth}) than the input frame (${frame.codedWidth})`);
-  }
   if (newFrame.displayWidth !== frame.displayWidth) {
     throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${newFrame.displayWidth}) than the input frame (${newFrame.displayHeight})`);
   }
@@ -811,13 +922,18 @@ var onFrame = async ({
   if (newFrame.duration !== frame.duration) {
     throw new Error(`Returned VideoFrame of track ${track.trackId} has different duration (${newFrame.duration}) than the input frame (${newFrame.duration}). When calling new VideoFrame(), pass {duration: frame.duration} as second argument`);
   }
-  await videoEncoder.encodeFrame(newFrame, newFrame.timestamp);
-  convertMediaState.decodedVideoFrames++;
-  onMediaStateUpdate?.({ ...convertMediaState });
-  newFrame.close();
+  const fixedFrame = convertToCorrectVideoFrame({
+    videoFrame: newFrame,
+    outputCodec
+  });
+  await videoEncoder.encodeFrame(fixedFrame, fixedFrame.timestamp);
+  fixedFrame.close();
   if (frame !== newFrame) {
     frame.close();
   }
+  if (fixedFrame !== newFrame) {
+    fixedFrame.close();
+  }
 };
 
 // src/video-decoder.ts
@@ -910,7 +1026,8 @@ var createVideoEncoder = ({
   onError,
   signal,
   config,
-  logLevel
+  logLevel,
+  outputCodec
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating video encoder, already aborted");
@@ -948,6 +1065,7 @@ var createVideoEncoder = ({
     close();
   };
   signal.addEventListener("abort", onAbort);
+  Log.verbose(logLevel, "Configuring video encoder", config);
   encoder.configure(config);
   let framesProcessed = 0;
   const encodeFrame = async (frame) => {
@@ -955,14 +1073,14 @@ var createVideoEncoder = ({
       return;
     }
     await ioSynchronizer.waitFor({
-      unemitted: 2,
-      _unprocessed: 2
+      unemitted: 10,
+      _unprocessed: 10
     });
     if (encoder.state === "closed") {
       return;
     }
     const keyFrame = framesProcessed % 40 === 0;
-    encoder.encode(frame, {
+    encoder.encode(convertToCorrectVideoFrame({ videoFrame: frame, outputCodec }), {
       keyFrame
     });
     ioSynchronizer.inputItem(frame.timestamp, keyFrame);
@@ -992,7 +1110,6 @@ var makeVideoTrackHandler = ({
   onVideoFrame,
   onMediaStateUpdate,
   abortConversion,
-  convertMediaState,
   controller,
   defaultVideoCodec,
   onVideoTrack,
@@ -1033,8 +1150,12 @@ var makeVideoTrackHandler = ({
         timescale: track.timescale,
         codecPrivate: track.codecPrivate
       });
-      convertMediaState.decodedVideoFrames++;
-      onMediaStateUpdate?.({ ...convertMediaState });
+      onMediaStateUpdate?.((prevState) => {
+        return {
+          ...prevState,
+          decodedVideoFrames: prevState.decodedVideoFrames + 1
+        };
+      });
     };
   }
   const videoEncoderConfig = await getVideoEncoderConfig({
@@ -1071,8 +1192,12 @@ var makeVideoTrackHandler = ({
         timescale: track.timescale,
         codecPrivate: arrayBufferToUint8Array(metadata?.decoderConfig?.description ?? null)
       });
-      convertMediaState.encodedVideoFrames++;
-      onMediaStateUpdate?.({ ...convertMediaState });
+      onMediaStateUpdate?.((prevState) => {
+        return {
+          ...prevState,
+          encodedVideoFrames: prevState.encodedVideoFrames + 1
+        };
+      });
     },
     onError: (err) => {
       abortConversion(new error_cause_default(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
@@ -1081,18 +1206,18 @@ var makeVideoTrackHandler = ({
     },
     signal: controller.signal,
     config: videoEncoderConfig,
-    logLevel
+    logLevel,
+    outputCodec: videoOperation.videoCodec
   });
   const videoDecoder = createVideoDecoder({
     config: videoDecoderConfig,
     onFrame: async (frame) => {
       await onFrame({
-        convertMediaState,
         frame,
-        onMediaStateUpdate,
         track,
         videoEncoder,
-        onVideoFrame
+        onVideoFrame,
+        outputCodec: videoOperation.videoCodec
       });
     },
     onError: (err) => {
@@ -1117,11 +1242,78 @@ var makeVideoTrackHandler = ({
   };
 };
 
+// src/select-container-creator.ts
+import { MediaParserInternals as MediaParserInternals4 } from "@remotion/media-parser";
+var selectContainerCreator = (container) => {
+  if (container === "mp4") {
+    return MediaParserInternals4.createIsoBaseMedia;
+  }
+  if (container === "wav") {
+    return MediaParserInternals4.createWav;
+  }
+  if (container === "webm") {
+    return MediaParserInternals4.createMatroskaMedia;
+  }
+  throw new Error(`Unsupported container: ${container}`);
+};
+
+// src/throttled-state-update.ts
+var throttledStateUpdate = ({
+  updateFn,
+  everyMilliseconds,
+  signal
+}) => {
+  let currentState = {
+    decodedAudioFrames: 0,
+    decodedVideoFrames: 0,
+    encodedVideoFrames: 0,
+    encodedAudioFrames: 0,
+    bytesWritten: 0,
+    millisecondsWritten: 0,
+    expectedOutputDurationInMs: null,
+    overallProgress: 0
+  };
+  if (!updateFn) {
+    return {
+      get: () => currentState,
+      update: null,
+      stopAndGetLastProgress: () => {
+      }
+    };
+  }
+  let lastUpdated = null;
+  const callUpdateIfChanged = () => {
+    if (currentState === lastUpdated) {
+      return;
+    }
+    updateFn(currentState);
+    lastUpdated = currentState;
+  };
+  const interval = setInterval(() => {
+    callUpdateIfChanged();
+  }, everyMilliseconds);
+  const onAbort = () => {
+    clearInterval(interval);
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  return {
+    get: () => currentState,
+    update: (fn) => {
+      currentState = fn(currentState);
+    },
+    stopAndGetLastProgress: () => {
+      clearInterval(interval);
+      signal.removeEventListener("abort", onAbort);
+      return currentState;
+    }
+  };
+};
+
 // src/convert-media.ts
 var convertMedia = async function({
   src,
   onVideoFrame,
-  onMediaStateUpdate: onMediaStateDoNoCallDirectly,
+  onProgress: onProgressDoNotCallDirectly,
   audioCodec,
   container,
   videoCodec,
@@ -1132,13 +1324,14 @@ var convertMedia = async function({
   fields,
   logLevel = "info",
   writer,
+  progressIntervalInMs,
   ...more
 }) {
   if (userPassedAbortSignal?.aborted) {
     return Promise.reject(new error_cause_default("Aborted"));
   }
-  if (container !== "webm" && container !== "mp4") {
-    return Promise.reject(new TypeError('Only `to: "webm"` and `to: "mp4"` is supported currently'));
+  if (container !== "webm" && container !== "mp4" && container !== "wav") {
+    return Promise.reject(new TypeError('Only `to: "webm"`, `to: "mp4"` and `to: "wav"` is supported currently'));
   }
   if (videoCodec && videoCodec !== "vp8" && videoCodec !== "vp9") {
     return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
@@ -1155,47 +1348,45 @@ var convertMedia = async function({
     abortConversion(new error_cause_default("Conversion aborted by user"));
   };
   userPassedAbortSignal?.addEventListener("abort", onUserAbort);
-  const convertMediaState = {
-    decodedAudioFrames: 0,
-    decodedVideoFrames: 0,
-    encodedVideoFrames: 0,
-    encodedAudioFrames: 0,
-    bytesWritten: 0,
-    millisecondsWritten: 0,
-    expectedOutputDurationInMs: null,
-    overallProgress: 0
-  };
-  const onMediaStateUpdate = (newState) => {
-    if (controller.signal.aborted) {
-      return;
-    }
-    onMediaStateDoNoCallDirectly?.(newState);
-  };
-  const creator = container === "webm" ? MediaParserInternals4.createMatroskaMedia : MediaParserInternals4.createIsoBaseMedia;
+  const creator = selectContainerCreator(container);
+  const throttledState = throttledStateUpdate({
+    updateFn: onProgressDoNotCallDirectly ?? null,
+    everyMilliseconds: progressIntervalInMs ?? 100,
+    signal: controller.signal
+  });
   const state = await creator({
+    filename: generateOutputFilename(src, container),
     writer: await autoSelectWriter(writer, logLevel),
     onBytesProgress: (bytesWritten) => {
-      convertMediaState.bytesWritten = bytesWritten;
-      onMediaStateUpdate?.(convertMediaState);
+      throttledState.update?.((prevState) => {
+        return {
+          ...prevState,
+          bytesWritten
+        };
+      });
     },
     onMillisecondsProgress: (millisecondsWritten) => {
-      if (millisecondsWritten > convertMediaState.millisecondsWritten) {
-        convertMediaState.millisecondsWritten = millisecondsWritten;
-        convertMediaState.overallProgress = calculateProgress({
-          millisecondsWritten: convertMediaState.millisecondsWritten,
-          expectedOutputDurationInMs: convertMediaState.expectedOutputDurationInMs
-        });
-        onMediaStateUpdate?.(convertMediaState);
-      }
+      throttledState.update?.((prevState) => {
+        if (millisecondsWritten > prevState.millisecondsWritten) {
+          return {
+            ...prevState,
+            millisecondsWritten,
+            overallProgress: calculateProgress({
+              millisecondsWritten: prevState.millisecondsWritten,
+              expectedOutputDurationInMs: prevState.expectedOutputDurationInMs
+            })
+          };
+        }
+        return prevState;
+      });
     },
     logLevel
   });
   const onVideoTrack = makeVideoTrackHandler({
     state,
     onVideoFrame: onVideoFrame ?? null,
-    onMediaStateUpdate: onMediaStateUpdate ?? null,
+    onMediaStateUpdate: throttledState.update ?? null,
     abortConversion,
-    convertMediaState,
     controller,
     defaultVideoCodec: videoCodec ?? null,
     onVideoTrack: userVideoResolver ?? null,
@@ -1206,8 +1397,7 @@ var convertMedia = async function({
     abortConversion,
     defaultAudioCodec: audioCodec ?? null,
     controller,
-    convertMediaState,
-    onMediaStateUpdate: onMediaStateUpdate ?? null,
+    onMediaStateUpdate: throttledState.update ?? null,
     state,
     onAudioTrack: userAudioResolver ?? null,
     logLevel,
@@ -1234,24 +1424,71 @@ var convertMedia = async function({
         casted.onDurationInSeconds(durationInSeconds);
       }
       const expectedOutputDurationInMs = durationInSeconds * 1000;
-      convertMediaState.expectedOutputDurationInMs = expectedOutputDurationInMs;
-      convertMediaState.overallProgress = calculateProgress({
-        millisecondsWritten: convertMediaState.millisecondsWritten,
-        expectedOutputDurationInMs
+      throttledState.update?.((prevState) => {
+        return {
+          ...prevState,
+          expectedOutputDurationInMs,
+          overallProgress: calculateProgress({
+            millisecondsWritten: prevState.millisecondsWritten,
+            expectedOutputDurationInMs
+          })
+        };
       });
-      onMediaStateUpdate(convertMediaState);
     }
   }).then(() => {
     return state.waitForFinish();
   }).then(() => {
-    resolve({ save: state.save, remove: state.remove });
+    resolve({
+      save: state.save,
+      remove: state.remove,
+      finalState: throttledState.get()
+    });
   }).catch((err) => {
     reject(err);
+  }).finally(() => {
+    throttledState.stopAndGetLastProgress();
   });
   return getPromiseToImmediatelyReturn().finally(() => {
     userPassedAbortSignal?.removeEventListener("abort", onUserAbort);
   });
 };
+// src/get-available-audio-codecs.ts
+var getAvailableAudioCodecs = ({
+  container
+}) => {
+  if (container === "mp4") {
+    return ["aac"];
+  }
+  if (container === "webm") {
+    return ["opus"];
+  }
+  if (container === "wav") {
+    return ["wav"];
+  }
+  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
+setRemotionImported();
 export {
   getDefaultVideoCodec,
   getDefaultAudioCodec,