@remotion/webcodecs 4.0.236 → 4.0.239

package/dist/esm/index.mjs

@@ -134,8 +134,8 @@ var makeIoSynchronizer = ({
   let inputsSinceLastOutput = 0;
   let inputs = [];
   let keyframes = [];
-  let unprocessed = 0;
-  const getUnprocessed = () => unprocessed;
+  let _unprocessed = 0;
+  const getUnprocessed = () => _unprocessed;
   const getUnemittedItems = () => {
     inputs = inputs.filter((input) => Math.floor(input) > Math.floor(lastOutput));
     return inputs.length;
@@ -167,7 +167,7 @@ var makeIoSynchronizer = ({
     eventEmitter.dispatchEvent("output", {
       timestamp
     });
-    unprocessed++;
+    _unprocessed++;
     printState("Got output");
   };
   const waitForOutput = () => {
@@ -189,11 +189,22 @@ var makeIoSynchronizer = ({
     return promise;
   };
   const waitFor = async ({
-    _unprocessed,
+    unprocessed,
     unemitted,
-    minimumProgress
+    minimumProgress,
+    signal
   }) => {
-    const { timeoutPromise, clear } = makeTimeoutPromise(`Waited too long for ${label}`, 1e4);
+    const { timeoutPromise, clear } = makeTimeoutPromise([
+      `Waited too long for ${label}:`,
+      `${getUnemittedItems()} unemitted items`,
+      `${getUnprocessed()} unprocessed items`,
+      `minimum progress ${minimumProgress}`,
+      `smallest progress: ${progress.getSmallestProgress()}`,
+      `inputs: ${JSON.stringify(inputs)}`,
+      `last output: ${lastOutput}`
+    ].join(`
+`), 1e4);
+    signal.addEventListener("abort", clear);
     await Promise.race([
       timeoutPromise,
       Promise.all([
@@ -203,24 +214,30 @@ var makeIoSynchronizer = ({
           }
         })(),
         (async () => {
-          while (getUnprocessed() > _unprocessed) {
+          while (getUnprocessed() > unprocessed) {
             await waitForProcessed();
           }
         })(),
-        minimumProgress === null ? Promise.resolve() : (async () => {
+        minimumProgress === null || progress.getSmallestProgress() === null ? Promise.resolve() : (async () => {
           while (progress.getSmallestProgress() < minimumProgress) {
             await progress.waitForProgress();
           }
         })()
       ])
     ]).finally(() => clear());
+    signal.removeEventListener("abort", clear);
   };
-  const waitForFinish = async () => {
-    await waitFor({ _unprocessed: 0, unemitted: 0, minimumProgress: null });
+  const waitForFinish = async (signal) => {
+    await waitFor({
+      unprocessed: 0,
+      unemitted: 0,
+      minimumProgress: null,
+      signal
+    });
   };
   const onProcessed = () => {
     eventEmitter.dispatchEvent("processed", {});
-    unprocessed--;
+    _unprocessed--;
   };
   return {
     inputItem,
@@ -255,23 +272,23 @@ var createAudioDecoder = ({
   });
   let outputQueue = Promise.resolve();
   const audioDecoder = new AudioDecoder({
-    output(inputFrame) {
-      ioSynchronizer.onOutput(inputFrame.timestamp);
+    output(frame) {
+      ioSynchronizer.onOutput(frame.timestamp + (frame.duration ?? 0));
       const abortHandler = () => {
-        inputFrame.close();
+        frame.close();
       };
       signal.addEventListener("abort", abortHandler, { once: true });
       outputQueue = outputQueue.then(() => {
         if (signal.aborted) {
           return;
         }
-        return onFrame(inputFrame);
+        return onFrame(frame);
       }).then(() => {
         ioSynchronizer.onProcessed();
         signal.removeEventListener("abort", abortHandler);
         return Promise.resolve();
       }).catch((err) => {
-        inputFrame.close();
+        frame.close();
         onError(err);
       });
     },
@@ -295,10 +312,12 @@ var createAudioDecoder = ({
     if (audioDecoder.state === "closed") {
       return;
     }
+    progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, audioSample.dts ?? Infinity, audioSample.cts ?? Infinity));
     await ioSynchronizer.waitFor({
       unemitted: 20,
-      _unprocessed: 20,
-      minimumProgress: audioSample.timestamp - 1e7
+      unprocessed: 20,
+      minimumProgress: audioSample.timestamp - 1e7,
+      signal
     });
     const chunk = new EncodedAudioChunk(audioSample);
     audioDecoder.decode(chunk);
@@ -319,7 +338,7 @@ var createAudioDecoder = ({
       } catch {
       }
       await queue;
-      await ioSynchronizer.waitForFinish();
+      await ioSynchronizer.waitForFinish(signal);
       await outputQueue;
     },
     close,
@@ -416,10 +435,12 @@ var createAudioEncoder = ({
     if (encoder.state === "closed") {
       return;
     }
+    progressTracker.setPossibleLowestTimestamp(audioData.timestamp);
     await ioSynchronizer.waitFor({
       unemitted: 20,
-      _unprocessed: 20,
-      minimumProgress: audioData.timestamp - 1e7
+      unprocessed: 20,
+      minimumProgress: audioData.timestamp - 1e7,
+      signal
     });
     if (encoder.state === "closed") {
       return;
@@ -446,7 +467,7 @@ var createAudioEncoder = ({
     },
     waitForFinish: async () => {
       await encoder.flush();
-      await ioSynchronizer.waitForFinish();
+      await ioSynchronizer.waitForFinish(signal);
       await prom;
     },
     close,
@@ -458,39 +479,41 @@ var createAudioEncoder = ({
 // src/can-copy-audio-track.ts
 var canCopyAudioTrack = ({
   inputCodec,
-  container
+  outputContainer,
+  inputContainer
 }) => {
-  if (container === "webm") {
+  if (outputContainer === "webm") {
     return inputCodec === "opus";
   }
-  if (container === "mp4") {
-    return inputCodec === "aac";
+  if (outputContainer === "mp4") {
+    return inputCodec === "aac" && (inputContainer === "mp4" || inputContainer === "avi");
   }
-  if (container === "wav") {
+  if (outputContainer === "wav") {
     return false;
   }
-  throw new Error(`Unhandled codec: ${container}`);
+  throw new Error(`Unhandled container: ${outputContainer}`);
 };
 // src/can-copy-video-track.ts
 var canCopyVideoTrack = ({
   inputCodec,
-  container,
+  outputContainer,
   inputRotation,
-  rotationToApply
+  rotationToApply,
+  inputContainer
 }) => {
   if (normalizeVideoRotation(inputRotation) !== normalizeVideoRotation(rotationToApply)) {
     return false;
   }
-  if (container === "webm") {
+  if (outputContainer === "webm") {
     return inputCodec === "vp8" || inputCodec === "vp9";
   }
-  if (container === "mp4") {
-    return inputCodec === "h264";
+  if (outputContainer === "mp4") {
+    return inputCodec === "h264" && (inputContainer === "mp4" || inputContainer === "avi");
   }
-  if (container === "wav") {
+  if (outputContainer === "wav") {
     return false;
   }
-  throw new Error(`Unhandled codec: ${container}`);
+  throw new Error(`Unhandled codec: ${outputContainer}`);
 };
 // src/audio-decoder-config.ts
 var getAudioDecoderConfig = async (config) => {
@@ -671,24 +694,45 @@ var canReencodeVideoTrack = async ({
 };
 // src/convert-media.ts
 import {
-  MediaParserInternals as MediaParserInternals8,
+  MediaParserInternals as MediaParserInternals9,
   parseMedia
 } from "@remotion/media-parser";
 
 // src/auto-select-writer.ts
-import { bufferWriter } from "@remotion/media-parser/buffer";
 import { canUseWebFsWriter, webFsWriter } from "@remotion/media-parser/web-fs";
+import {
+  MediaParserInternals as MediaParserInternals4
+} from "@remotion/media-parser";
+import { bufferWriter } from "@remotion/media-parser/buffer";
 var autoSelectWriter = async (writer, logLevel) => {
   if (writer) {
     Log.verbose(logLevel, "Using writer provided by user");
     return writer;
   }
   Log.verbose(logLevel, "Determining best writer");
-  if (await canUseWebFsWriter()) {
-    Log.verbose(logLevel, "Using WebFS writer because it is supported");
-    return webFsWriter;
+  const isOffline = !navigator.onLine;
+  if (isOffline) {
+    Log.verbose(logLevel, "Offline mode detected, using buffer writer");
+    return bufferWriter;
+  }
+  try {
+    const {
+      promise: timeout,
+      reject,
+      resolve
+    } = MediaParserInternals4.withResolvers();
+    const time = setTimeout(() => reject(new Error("WebFS check timeout")), 2000);
+    const webFsSupported = await Promise.race([canUseWebFsWriter(), timeout]);
+    resolve();
+    clearTimeout(time);
+    if (webFsSupported) {
+      Log.verbose(logLevel, "Using WebFS writer because it is supported");
+      return webFsWriter;
+    }
+  } catch (err) {
+    Log.verbose(logLevel, `WebFS check failed: ${err}. Falling back to buffer writer`);
   }
-  Log.verbose(logLevel, "Using buffer writer because WebFS writer is not supported");
+  Log.verbose(logLevel, "Using buffer writer because WebFS writer is not supported or unavailable");
   return bufferWriter;
 };
 
@@ -716,7 +760,7 @@ var generateOutputFilename = (source, container) => {
 
 // src/on-audio-track.ts
 import {
-  MediaParserInternals as MediaParserInternals5
+  MediaParserInternals as MediaParserInternals6
 } from "@remotion/media-parser";
 
 // src/convert-encoded-chunk.ts
@@ -735,59 +779,56 @@ var convertEncodedChunk = (chunk, trackId) => {
 };
 
 // src/default-on-audio-track-handler.ts
-import { MediaParserInternals as MediaParserInternals4 } from "@remotion/media-parser";
-
-// src/get-default-audio-codec.ts
-var getDefaultAudioCodec = ({
-  container
-}) => {
-  if (container === "webm") {
-    return "opus";
-  }
-  if (container === "mp4") {
-    return "aac";
-  }
-  if (container === "wav") {
-    return "wav";
-  }
-  throw new Error(`Unhandled container: ${container}`);
-};
-
-// src/default-on-audio-track-handler.ts
+import { MediaParserInternals as MediaParserInternals5 } from "@remotion/media-parser";
 var DEFAULT_BITRATE = 128000;
 var defaultOnAudioTrackHandler = async ({
   track,
   defaultAudioCodec,
   logLevel,
-  container
+  canCopyTrack
 }) => {
   const bitrate = DEFAULT_BITRATE;
-  const canCopy = canCopyAudioTrack({
-    inputCodec: track.codecWithoutConfig,
-    container
-  });
-  if (canCopy) {
-    MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
+  if (canCopyTrack) {
+    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
     return Promise.resolve({ type: "copy" });
   }
-  const audioCodec = defaultAudioCodec ?? getDefaultAudioCodec({ container });
+  if (defaultAudioCodec === null) {
+    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Container does not support audio, dropping audio`);
+    return Promise.resolve({ type: "drop" });
+  }
   const canReencode = await canReencodeAudioTrack({
-    audioCodec,
+    audioCodec: defaultAudioCodec,
     track,
     bitrate
   });
   if (canReencode) {
-    MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
+    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
     return Promise.resolve({
       type: "reencode",
       bitrate,
-      audioCodec
+      audioCodec: defaultAudioCodec
     });
   }
-  MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
+  MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
   return Promise.resolve({ type: "fail" });
 };
 
+// src/get-default-audio-codec.ts
+var getDefaultAudioCodec = ({
+  container
+}) => {
+  if (container === "webm") {
+    return "opus";
+  }
+  if (container === "mp4") {
+    return "aac";
+  }
+  if (container === "wav") {
+    return "wav";
+  }
+  throw new Error(`Unhandled container: ${container}`);
+};
+
 // src/on-audio-track.ts
 var makeAudioTrackHandler = ({
   state,
@@ -797,20 +838,27 @@ var makeAudioTrackHandler = ({
   onMediaStateUpdate,
   onAudioTrack,
   logLevel,
-  container,
+  outputContainer,
   progressTracker
-}) => async (track) => {
+}) => async ({ track, container: inputContainer }) => {
+  const canCopyTrack = canCopyAudioTrack({
+    inputCodec: track.codecWithoutConfig,
+    outputContainer,
+    inputContainer
+  });
   const audioOperation = await (onAudioTrack ?? defaultOnAudioTrackHandler)({
-    defaultAudioCodec: audioCodec,
+    defaultAudioCodec: audioCodec ?? getDefaultAudioCodec({ container: outputContainer }),
     track,
     logLevel,
-    container
+    outputContainer,
+    inputContainer,
+    canCopyTrack
   });
   if (audioOperation.type === "drop") {
     return null;
   }
   if (audioOperation.type === "fail") {
-    throw new error_cause_default(`Audio track with ID ${track.trackId} could 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_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`);
   }
   if (audioOperation.type === "copy") {
     const addedTrack = await state.addTrack({
@@ -827,7 +875,6 @@ var makeAudioTrackHandler = ({
         chunk: audioSample,
         trackNumber: addedTrack.trackNumber,
         isVideo: false,
-        timescale: track.timescale,
         codecPrivate: track.codecPrivate
       });
       onMediaStateUpdate?.((prevState) => {
@@ -858,7 +905,7 @@ var makeAudioTrackHandler = ({
     abortConversion(new error_cause_default(`Could not configure audio decoder of track ${track.trackId}`));
     return null;
   }
-  const codecPrivate = audioOperation.audioCodec === "aac" ? MediaParserInternals5.createAacCodecPrivate({
+  const codecPrivate = audioOperation.audioCodec === "aac" ? MediaParserInternals6.createAacCodecPrivate({
     audioObjectType: 2,
     sampleRate: track.sampleRate,
     channelConfiguration: track.numberOfChannels
@@ -880,7 +927,6 @@ var makeAudioTrackHandler = ({
         chunk: convertEncodedChunk(chunk, trackNumber),
         trackNumber,
         isVideo: false,
-        timescale: track.timescale,
         codecPrivate
       });
       onMediaStateUpdate?.((prevState) => {
@@ -940,63 +986,54 @@ var arrayBufferToUint8Array = (buffer) => {
 };
 
 // src/default-on-video-track-handler.ts
-import { MediaParserInternals as MediaParserInternals6 } from "@remotion/media-parser";
-
-// src/get-default-video-codec.ts
-var getDefaultVideoCodec = ({
-  container
-}) => {
-  if (container === "webm") {
-    return "vp8";
-  }
-  if (container === "mp4") {
-    return "h264";
-  }
-  if (container === "wav") {
-    return null;
-  }
-  throw new Error(`Unhandled container: ${container}`);
-};
-
-// src/default-on-video-track-handler.ts
+import { MediaParserInternals as MediaParserInternals7 } from "@remotion/media-parser";
 var defaultOnVideoTrackHandler = async ({
   track,
   defaultVideoCodec,
   logLevel,
-  container,
-  rotate
+  rotate,
+  canCopyTrack
 }) => {
-  const canCopy = canCopyVideoTrack({
-    inputCodec: track.codecWithoutConfig,
-    container,
-    inputRotation: track.rotation,
-    rotationToApply: rotate
-  });
-  if (canCopy) {
-    MediaParserInternals6.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
+  if (canCopyTrack) {
+    MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
     return Promise.resolve({ type: "copy" });
   }
-  const videoCodec = defaultVideoCodec ?? getDefaultVideoCodec({ container });
-  if (videoCodec === null) {
-    MediaParserInternals6.Log.verbose(logLevel, `Track ${track.trackId} (video): No default video codec, therefore dropping`);
+  if (defaultVideoCodec === null) {
+    MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Is audio container, therefore dropping video`);
     return Promise.resolve({ type: "drop" });
   }
   const canReencode = await canReencodeVideoTrack({
-    videoCodec,
+    videoCodec: defaultVideoCodec,
     track
   });
   if (canReencode) {
-    MediaParserInternals6.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
+    MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
     return Promise.resolve({
       type: "reencode",
-      videoCodec,
+      videoCodec: defaultVideoCodec,
       rotation: rotate - track.rotation
     });
   }
-  MediaParserInternals6.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
+  MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
   return Promise.resolve({ type: "fail" });
 };
 
+// src/get-default-video-codec.ts
+var getDefaultVideoCodec = ({
+  container
+}) => {
+  if (container === "webm") {
+    return "vp8";
+  }
+  if (container === "mp4") {
+    return "h264";
+  }
+  if (container === "wav") {
+    return null;
+  }
+  throw new Error(`Unhandled container: ${container}`);
+};
+
 // src/convert-to-correct-videoframe.ts
 var needsToCorrectVideoFrame = ({
   videoFrame,
@@ -1056,7 +1093,7 @@ var onFrame = async ({
   if (userProcessedFrame.displayHeight !== rotated.displayHeight) {
     throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${userProcessedFrame.displayHeight}) than the input frame (${userProcessedFrame.displayHeight})`);
   }
-  if (userProcessedFrame.timestamp !== rotated.timestamp) {
+  if (userProcessedFrame.timestamp !== rotated.timestamp && !isSafari()) {
     throw new Error(`Returned VideoFrame of track ${track.trackId} has different timestamp (${userProcessedFrame.timestamp}) than the input frame (${rotated.timestamp}). When calling new VideoFrame(), pass {timestamp: frame.timestamp} as second argument`);
   }
   if ((userProcessedFrame.duration ?? 0) !== (rotated.duration ?? 0)) {
@@ -1135,10 +1172,12 @@ var createVideoDecoder = ({
     if (videoDecoder.state === "closed") {
       return;
     }
+    progress.setPossibleLowestTimestamp(Math.min(sample.timestamp, sample.dts ?? Infinity, sample.cts ?? Infinity));
     await ioSynchronizer.waitFor({
       unemitted: 20,
-      _unprocessed: 2,
-      minimumProgress: sample.timestamp - 5000000
+      unprocessed: 2,
+      minimumProgress: sample.timestamp - 5000000,
+      signal
     });
     if (sample.type === "key") {
       await videoDecoder.flush();
@@ -1155,7 +1194,7 @@ var createVideoDecoder = ({
     waitForFinish: async () => {
       await videoDecoder.flush();
       Log.verbose(logLevel, "Flushed video decoder");
-      await ioSynchronizer.waitForFinish();
+      await ioSynchronizer.waitForFinish(signal);
       Log.verbose(logLevel, "IO synchro finished");
       await outputQueue;
       Log.verbose(logLevel, "Output queue finished");
@@ -1226,10 +1265,12 @@ var createVideoEncoder = ({
     if (encoder.state === "closed") {
       return;
     }
+    progress.setPossibleLowestTimestamp(frame.timestamp);
     await ioSynchronizer.waitFor({
       unemitted: 10,
-      _unprocessed: 10,
-      minimumProgress: frame.timestamp - 5000000
+      unprocessed: 10,
+      minimumProgress: frame.timestamp - 5000000,
+      signal
     });
     if (encoder.state === "closed") {
       return;
@@ -1250,7 +1291,7 @@ var createVideoEncoder = ({
     waitForFinish: async () => {
       await encoder.flush();
       await outputQueue;
-      await ioSynchronizer.waitForFinish();
+      await ioSynchronizer.waitForFinish(signal);
     },
     close,
     flush: async () => {
@@ -1269,25 +1310,34 @@ var makeVideoTrackHandler = ({
   defaultVideoCodec,
   onVideoTrack,
   logLevel,
-  container,
+  outputContainer,
   rotate,
   progress
-}) => async (track) => {
+}) => async ({ track, container: inputContainer }) => {
   if (controller.signal.aborted) {
     throw new error_cause_default("Aborted");
   }
+  const canCopyTrack = canCopyVideoTrack({
+    inputCodec: track.codecWithoutConfig,
+    inputContainer,
+    inputRotation: track.rotation,
+    outputContainer,
+    rotationToApply: rotate
+  });
   const videoOperation = await (onVideoTrack ?? defaultOnVideoTrackHandler)({
     track,
-    defaultVideoCodec,
+    defaultVideoCodec: defaultVideoCodec ?? getDefaultVideoCodec({ container: outputContainer }),
     logLevel,
-    container,
-    rotate
+    outputContainer,
+    rotate,
+    inputContainer,
+    canCopyTrack
   });
   if (videoOperation.type === "drop") {
     return null;
   }
   if (videoOperation.type === "fail") {
-    throw new error_cause_default(`Video track with ID ${track.trackId} could 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_cause_default(`Video track with ID ${track.trackId} could 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}`);
@@ -1305,7 +1355,6 @@ var makeVideoTrackHandler = ({
         chunk: sample,
         trackNumber: videoTrack.trackNumber,
         isVideo: true,
-        timescale: track.timescale,
         codecPrivate: track.codecPrivate
       });
       onMediaStateUpdate?.((prevState) => {
@@ -1356,7 +1405,6 @@ var makeVideoTrackHandler = ({
         chunk: convertEncodedChunk(chunk, trackNumber),
         trackNumber,
         isVideo: true,
-        timescale: track.timescale,
         codecPrivate: arrayBufferToUint8Array(metadata?.decoderConfig?.description ?? null)
       });
       onMediaStateUpdate?.((prevState) => {
@@ -1413,16 +1461,16 @@ var makeVideoTrackHandler = ({
 };
 
 // src/select-container-creator.ts
-import { MediaParserInternals as MediaParserInternals7 } from "@remotion/media-parser";
+import { MediaParserInternals as MediaParserInternals8 } from "@remotion/media-parser";
 var selectContainerCreator = (container) => {
   if (container === "mp4") {
-    return MediaParserInternals7.createIsoBaseMedia;
+    return MediaParserInternals8.createIsoBaseMedia;
   }
   if (container === "wav") {
-    return MediaParserInternals7.createWav;
+    return MediaParserInternals8.createWav;
   }
   if (container === "webm") {
-    return MediaParserInternals7.createMatroskaMedia;
+    return MediaParserInternals8.createMatroskaMedia;
   }
   throw new Error(`Unsupported container: ${container}`);
 };
@@ -1507,7 +1555,7 @@ var convertMedia = async function({
   if (videoCodec && videoCodec !== "vp8" && videoCodec !== "vp9") {
     return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
   }
-  const { resolve, reject, getPromiseToImmediatelyReturn } = MediaParserInternals8.withResolversAndWaitForReturn();
+  const { resolve, reject, getPromiseToImmediatelyReturn } = MediaParserInternals9.withResolversAndWaitForReturn();
   const controller = new AbortController;
   const abortConversion = (errCause) => {
     reject(errCause);
@@ -1525,7 +1573,7 @@ var convertMedia = async function({
     everyMilliseconds: progressIntervalInMs ?? 100,
     signal: controller.signal
   });
-  const progressTracker = MediaParserInternals8.makeProgressTracker();
+  const progressTracker = MediaParserInternals9.makeProgressTracker();
   const state = await creator({
     filename: generateOutputFilename(src, container),
     writer: await autoSelectWriter(writer, logLevel),
@@ -1564,7 +1612,7 @@ var convertMedia = async function({
     defaultVideoCodec: videoCodec ?? null,
     onVideoTrack: userVideoResolver ?? null,
     logLevel,
-    container,
+    outputContainer: container,
     rotate: rotate ?? 0,
     progress: progressTracker
   });
@@ -1576,7 +1624,7 @@ var convertMedia = async function({
     state,
     onAudioTrack: userAudioResolver ?? null,
     logLevel,
-    container,
+    outputContainer: container,
     progressTracker
   });
   parseMedia({

package/dist/io-manager/io-synchronizer.d.ts

@@ -7,12 +7,13 @@ export declare const makeIoSynchronizer: ({ logLevel, label, progress, }: {
 }) => {
     inputItem: (timestamp: number, keyFrame: boolean) => void;
     onOutput: (timestamp: number) => void;
-    waitFor: ({ _unprocessed, unemitted, minimumProgress, }: {
+    waitFor: ({ unprocessed, unemitted, minimumProgress, signal, }: {
         unemitted: number;
-        _unprocessed: number;
+        unprocessed: number;
         minimumProgress: number | null;
+        signal: AbortSignal;
     }) => Promise<void>;
-    waitForFinish: () => Promise<void>;
+    waitForFinish: (signal: AbortSignal) => Promise<void>;
     onProcessed: () => void;
     getUnprocessed: () => number;
 };