@remotion/webcodecs 4.0.231 → 4.0.233

package/dist/esm/index.mjs

@@ -1,3 +1,59 @@
+// src/rotation.ts
+var calculateNewDimensionsFromDimensions = ({
+  width,
+  height,
+  rotation
+}) => {
+  const switchDimensions = rotation % 90 === 0 && rotation % 180 !== 0;
+  const newHeight = switchDimensions ? width : height;
+  const newWidth = switchDimensions ? height : width;
+  return { height: newHeight, width: newWidth };
+};
+
+// src/rotate-video-frame.ts
+var normalizeVideoRotation = (rotation) => {
+  return (rotation % 360 + 360) % 360;
+};
+var rotateVideoFrame = ({
+  frame,
+  rotation
+}) => {
+  const normalized = (rotation % 360 + 360) % 360;
+  if (normalized % 360 === 0) {
+    return frame;
+  }
+  if (normalized % 90 !== 0) {
+    throw new Error("Only 90 degree rotations are supported");
+  }
+  const { height, width } = calculateNewDimensionsFromDimensions({
+    height: frame.displayHeight,
+    width: frame.displayWidth,
+    rotation
+  });
+  const canvas = new OffscreenCanvas(width, height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Could not get 2d context");
+  }
+  canvas.width = width;
+  canvas.height = height;
+  if (normalized === 90) {
+    ctx.translate(width, 0);
+  } else if (normalized === 180) {
+    ctx.translate(width, height);
+  } else if (normalized === 270) {
+    ctx.translate(0, height);
+  }
+  ctx.rotate(normalized * (Math.PI / 180));
+  ctx.drawImage(frame, 0, 0);
+  return new VideoFrame(canvas, {
+    displayHeight: height,
+    displayWidth: width,
+    duration: frame.duration ?? undefined,
+    timestamp: frame.timestamp
+  });
+};
+
 // src/set-remotion-imported.ts
 import { VERSION } from "@remotion/media-parser";
 var setRemotionImported = () => {
@@ -13,58 +69,65 @@ var setRemotionImported = () => {
   }
 };
 
-// src/log.ts
-import { MediaParserInternals } from "@remotion/media-parser";
-var { Log } = MediaParserInternals;
-
-// src/with-resolvers.ts
-var withResolvers = function() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-};
-var withResolversAndWaitForReturn = () => {
-  const { promise, reject, resolve } = withResolvers();
-  const { promise: returnPromise, resolve: resolveReturn } = withResolvers();
+// src/get-wave-audio-decoder.ts
+var getWaveAudioDecoder = ({
+  onFrame,
+  track
+}) => {
+  let queue = Promise.resolve();
+  const processSample = async (audioSample) => {
+    await onFrame(new AudioData({
+      data: audioSample.data,
+      format: "s16",
+      numberOfChannels: track.numberOfChannels,
+      numberOfFrames: audioSample.data.byteLength / 2,
+      sampleRate: track.sampleRate,
+      timestamp: audioSample.timestamp
+    }));
+  };
   return {
-    getPromiseToImmediatelyReturn: () => {
-      resolveReturn(undefined);
-      return promise;
+    close() {
+      return Promise.resolve();
     },
-    reject: (reason) => {
-      returnPromise.then(() => reject(reason));
+    processSample(audioSample) {
+      queue = queue.then(() => processSample(audioSample));
+      return queue;
     },
-    resolve
+    flush: () => Promise.resolve(),
+    waitForFinish: () => Promise.resolve()
   };
 };
 
-// src/io-manager/event-emitter.ts
-class IoEventEmitter {
-  listeners = {
-    input: [],
-    output: [],
-    processed: []
+// src/io-manager/io-synchronizer.ts
+import { MediaParserInternals as MediaParserInternals3 } from "@remotion/media-parser";
+
+// src/log.ts
+import { MediaParserInternals } from "@remotion/media-parser";
+var { Log } = MediaParserInternals;
+
+// src/io-manager/make-timeout-promise.ts
+import { MediaParserInternals as MediaParserInternals2 } from "@remotion/media-parser";
+var makeTimeoutPromise = (label, ms) => {
+  const { promise, reject, resolve } = MediaParserInternals2.withResolvers();
+  const timeout = setTimeout(() => {
+    reject(new Error(`${label} (timed out after ${ms}ms)`));
+  }, ms);
+  return {
+    timeoutPromise: promise,
+    clear: () => {
+      clearTimeout(timeout);
+      resolve();
+    }
   };
-  addEventListener(name, callback) {
-    this.listeners[name].push(callback);
-  }
-  removeEventListener(name, callback) {
-    this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
-  }
-  dispatchEvent(dispatchName, context) {
-    this.listeners[dispatchName].forEach((callback) => {
-      callback({ detail: context });
-    });
-  }
-}
+};
 
 // src/io-manager/io-synchronizer.ts
-var makeIoSynchronizer = (logLevel, label) => {
-  const eventEmitter = new IoEventEmitter;
+var makeIoSynchronizer = ({
+  logLevel,
+  label,
+  progress
+}) => {
+  const eventEmitter = new MediaParserInternals3.IoEventEmitter;
   let lastInput = 0;
   let lastInputKeyframe = 0;
   let lastOutput = 0;
@@ -108,7 +171,7 @@ var makeIoSynchronizer = (logLevel, label) => {
     printState("Got output");
   };
   const waitForOutput = () => {
-    const { promise, resolve } = withResolvers();
+    const { promise, resolve } = MediaParserInternals3.withResolvers();
     const on = () => {
       eventEmitter.removeEventListener("output", on);
       resolve();
@@ -117,7 +180,7 @@ var makeIoSynchronizer = (logLevel, label) => {
     return promise;
   };
   const waitForProcessed = () => {
-    const { promise, resolve } = withResolvers();
+    const { promise, resolve } = MediaParserInternals3.withResolvers();
     const on = () => {
       eventEmitter.removeEventListener("processed", on);
       resolve();
@@ -127,17 +190,33 @@ var makeIoSynchronizer = (logLevel, label) => {
   };
   const waitFor = async ({
     _unprocessed,
-    unemitted
+    unemitted,
+    minimumProgress
   }) => {
-    while (getUnemittedItems() > unemitted) {
-      await waitForOutput();
-    }
-    while (getUnprocessed() > _unprocessed) {
-      await waitForProcessed();
-    }
+    const { timeoutPromise, clear } = makeTimeoutPromise(`Waited too long for ${label}`, 1e4);
+    await Promise.race([
+      timeoutPromise,
+      Promise.all([
+        (async () => {
+          while (getUnemittedItems() > unemitted) {
+            await waitForOutput();
+          }
+        })(),
+        (async () => {
+          while (getUnprocessed() > _unprocessed) {
+            await waitForProcessed();
+          }
+        })(),
+        minimumProgress === null ? Promise.resolve() : (async () => {
+          while (progress.getSmallestProgress() < minimumProgress) {
+            await progress.waitForProgress();
+          }
+        })()
+      ])
+    ]).finally(() => clear());
   };
   const waitForFinish = async () => {
-    await waitFor({ _unprocessed: 0, unemitted: 0 });
+    await waitFor({ _unprocessed: 0, unemitted: 0, minimumProgress: null });
   };
   const onProcessed = () => {
     eventEmitter.dispatchEvent("processed", {});
@@ -159,12 +238,21 @@ var createAudioDecoder = ({
   onError,
   signal,
   config,
-  logLevel
+  logLevel,
+  track,
+  progressTracker
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating audio decoder, already aborted");
   }
-  const ioSynchronizer = makeIoSynchronizer(logLevel, "Audio decoder");
+  if (config.codec === "pcm-s16") {
+    return getWaveAudioDecoder({ onFrame, track });
+  }
+  const ioSynchronizer = makeIoSynchronizer({
+    logLevel,
+    label: "Audio decoder",
+    progress: progressTracker
+  });
   let outputQueue = Promise.resolve();
   const audioDecoder = new AudioDecoder({
     output(inputFrame) {
@@ -207,7 +295,11 @@ var createAudioDecoder = ({
     if (audioDecoder.state === "closed") {
       return;
     }
-    await ioSynchronizer.waitFor({ unemitted: 100, _unprocessed: 2 });
+    await ioSynchronizer.waitFor({
+      unemitted: 20,
+      _unprocessed: 20,
+      minimumProgress: audioSample.timestamp - 1e7
+    });
     const chunk = new EncodedAudioChunk(audioSample);
     audioDecoder.decode(chunk);
     ioSynchronizer.inputItem(chunk.timestamp, audioSample.type === "key");
@@ -215,11 +307,18 @@ 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();
+      try {
+        await audioDecoder.flush();
+      } catch {
+      }
+      await queue;
       await ioSynchronizer.waitForFinish();
       await outputQueue;
     },
@@ -229,6 +328,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,
@@ -237,12 +363,20 @@ var createAudioEncoder = ({
   signal,
   config: audioEncoderConfig,
   logLevel,
-  onNewAudioSampleRate
+  onNewAudioSampleRate,
+  progressTracker
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating audio encoder, already aborted");
   }
-  const ioSynchronizer = makeIoSynchronizer(logLevel, "Audio encoder");
+  if (codec === "wav") {
+    return getWaveAudioEncoder({ onChunk, signal });
+  }
+  const ioSynchronizer = makeIoSynchronizer({
+    logLevel,
+    label: "Audio encoder",
+    progress: progressTracker
+  });
   let prom = Promise.resolve();
   const encoder = new AudioEncoder({
     output: (chunk) => {
@@ -282,7 +416,11 @@ var createAudioEncoder = ({
     if (encoder.state === "closed") {
       return;
     }
-    await ioSynchronizer.waitFor({ unemitted: 20, _unprocessed: 20 });
+    await ioSynchronizer.waitFor({
+      unemitted: 20,
+      _unprocessed: 20,
+      minimumProgress: audioData.timestamp - 1e7
+    });
     if (encoder.state === "closed") {
       return;
     }
@@ -328,31 +466,94 @@ 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
 var canCopyVideoTrack = ({
   inputCodec,
-  container
+  container,
+  inputRotation,
+  rotationToApply
 }) => {
+  if (normalizeVideoRotation(inputRotation) !== normalizeVideoRotation(rotationToApply)) {
+    return false;
+  }
   if (container === "webm") {
     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}`);
 };
+// src/browser-quirks.ts
+var isFirefox = () => {
+  return navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
+};
+var isSafari = () => {
+  return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+};
+var isChrome = () => {
+  return navigator.userAgent.toLowerCase().indexOf("chrome") > -1;
+};
+
 // src/audio-decoder-config.ts
-var getAudioDecoderConfig = async (config) => {
+var overrideBrowserQuirks = ({
+  config,
+  logLevel
+}) => {
+  const bytes = config.description;
+  if (!bytes) {
+    return config;
+  }
+  if (bytes[0] === 18 && bytes[1] === 8) {
+    if (isFirefox()) {
+      return {
+        ...config,
+        codec: "mp4a.40.2",
+        description: bytes
+      };
+    }
+    if (!isChrome()) {
+      return config;
+    }
+    Log.warn(logLevel, "Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330");
+    return {
+      ...config,
+      description: new Uint8Array([18, 16])
+    };
+  }
+  if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
+    Log.warn(logLevel, "Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330");
+    return {
+      ...config,
+      description: new Uint8Array([18, 144])
+    };
+  }
+  return config;
+};
+var getAudioDecoderConfig = async (config, logLevel) => {
+  if (config.codec === "pcm-s16") {
+    return config;
+  }
   if (typeof AudioDecoder === "undefined") {
     return null;
   }
   if (typeof EncodedAudioChunk === "undefined") {
     return null;
   }
-  if ((await AudioDecoder.isConfigSupported(config)).supported) {
-    return config;
+  const realConfig = overrideBrowserQuirks({
+    config,
+    logLevel
+  });
+  if ((await AudioDecoder.isConfigSupported(realConfig)).supported) {
+    return realConfig;
   }
   return null;
 };
@@ -365,6 +566,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) => {
@@ -372,6 +576,9 @@ var getAudioEncoderConfig = async (config) => {
     ...config,
     codec: getCodecString(config.codec)
   };
+  if (config.codec === "wav") {
+    return actualConfig;
+  }
   if (typeof AudioEncoder === "undefined") {
     return null;
   }
@@ -385,9 +592,13 @@ var getAudioEncoderConfig = async (config) => {
 var canReencodeAudioTrack = async ({
   track,
   audioCodec,
-  bitrate
+  bitrate,
+  logLevel = "info"
 }) => {
-  const audioDecoderConfig = await getAudioDecoderConfig(track);
+  const audioDecoderConfig = await getAudioDecoderConfig(track, logLevel);
+  if (audioCodec === "wav" && audioDecoderConfig) {
+    return true;
+  }
   const audioEncoderConfig = await getAudioEncoderConfig({
     codec: audioCodec,
     numberOfChannels: track.numberOfChannels,
@@ -418,14 +629,6 @@ 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,
@@ -508,32 +711,9 @@ 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,
+  MediaParserInternals as MediaParserInternals7,
   parseMedia
 } from "@remotion/media-parser";
 
@@ -592,7 +772,7 @@ var convertEncodedChunk = (chunk, trackId) => {
 };
 
 // src/default-on-audio-track-handler.ts
-import { MediaParserInternals as MediaParserInternals2 } from "@remotion/media-parser";
+import { MediaParserInternals as MediaParserInternals4 } from "@remotion/media-parser";
 
 // src/get-default-audio-codec.ts
 var getDefaultAudioCodec = ({
@@ -604,6 +784,9 @@ var getDefaultAudioCodec = ({
   if (container === "mp4") {
     return "aac";
   }
+  if (container === "wav") {
+    return "wav";
+  }
   throw new Error(`Unhandled container: ${container}`);
 };
 
@@ -621,7 +804,7 @@ var defaultOnAudioTrackHandler = async ({
     container
   });
   if (canCopy) {
-    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
+    MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
     return Promise.resolve({ type: "copy" });
   }
   const audioCodec = defaultAudioCodec ?? getDefaultAudioCodec({ container });
@@ -631,14 +814,14 @@ var defaultOnAudioTrackHandler = async ({
     bitrate
   });
   if (canReencode) {
-    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
+    MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
     return Promise.resolve({
       type: "reencode",
       bitrate,
       audioCodec
     });
   }
-  MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
+  MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
   return Promise.resolve({ type: "fail" });
 };
 
@@ -651,7 +834,8 @@ var makeAudioTrackHandler = ({
   onMediaStateUpdate,
   onAudioTrack,
   logLevel,
-  container
+  container,
+  progressTracker
 }) => async (track) => {
   const audioOperation = await (onAudioTrack ?? defaultOnAudioTrackHandler)({
     defaultAudioCodec: audioCodec,
@@ -702,7 +886,7 @@ var makeAudioTrackHandler = ({
     numberOfChannels: track.numberOfChannels,
     sampleRate: track.sampleRate,
     description: track.description
-  });
+  }, logLevel);
   if (!audioEncoderConfig) {
     abortConversion(new error_cause_default(`Could not configure audio encoder of track ${track.trackId}`));
     return null;
@@ -714,7 +898,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,
@@ -747,7 +931,8 @@ var makeAudioTrackHandler = ({
     codec: audioOperation.audioCodec,
     signal: controller.signal,
     config: audioEncoderConfig,
-    logLevel
+    logLevel,
+    progressTracker
   });
   const audioDecoder = createAudioDecoder({
     onFrame: async (frame) => {
@@ -761,13 +946,15 @@ var makeAudioTrackHandler = ({
       frame.close();
     },
     onError(error) {
-      abortConversion(new error_cause_default(`Audio decoder of track ${track.trackId} failed (see .cause of this error)`, {
+      abortConversion(new error_cause_default(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
         cause: error
       }));
     },
     signal: controller.signal,
     config: audioDecoderConfig,
-    logLevel
+    logLevel,
+    track,
+    progressTracker
   });
   state.addWaitForFinishPromise(async () => {
     await audioDecoder.waitForFinish();
@@ -786,7 +973,7 @@ var arrayBufferToUint8Array = (buffer) => {
 };
 
 // src/default-on-video-track-handler.ts
-import { MediaParserInternals as MediaParserInternals3 } from "@remotion/media-parser";
+import { MediaParserInternals as MediaParserInternals5 } from "@remotion/media-parser";
 
 // src/get-default-video-codec.ts
 var getDefaultVideoCodec = ({
@@ -795,7 +982,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
@@ -803,26 +996,37 @@ var defaultOnVideoTrackHandler = async ({
   track,
   defaultVideoCodec,
   logLevel,
-  container
+  container,
+  rotate
 }) => {
   const canCopy = canCopyVideoTrack({
     inputCodec: track.codecWithoutConfig,
-    container
+    container,
+    inputRotation: track.rotation,
+    rotationToApply: rotate
   });
   if (canCopy) {
-    MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
+    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
     return Promise.resolve({ type: "copy" });
   }
   const videoCodec = defaultVideoCodec ?? getDefaultVideoCodec({ container });
+  if (videoCodec === null) {
+    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (video): No default video codec, therefore dropping`);
+    return Promise.resolve({ type: "drop" });
+  }
   const canReencode = await canReencodeVideoTrack({
     videoCodec,
     track
   });
   if (canReencode) {
-    MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
-    return Promise.resolve({ type: "reencode", videoCodec });
+    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
+    return Promise.resolve({
+      type: "reencode",
+      videoCodec,
+      rotation: rotate - track.rotation
+    });
   }
-  MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
+  MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
   return Promise.resolve({ type: "fail" });
 };
 
@@ -831,6 +1035,12 @@ var needsToCorrectVideoFrame = ({
   videoFrame,
   outputCodec
 }) => {
+  if (videoFrame.format === null) {
+    return true;
+  }
+  if (videoFrame.format === "I420P10") {
+    return true;
+  }
   return isFirefox() && videoFrame.format === "BGRX" && outputCodec === "h264";
 };
 var convertToCorrectVideoFrame = ({
@@ -858,41 +1068,43 @@ var convertToCorrectVideoFrame = ({
 
 // src/on-frame.ts
 var onFrame = async ({
-  frame,
+  frame: unrotatedFrame,
   onVideoFrame,
   videoEncoder,
   track,
-  outputCodec
+  outputCodec,
+  rotation
 }) => {
-  const newFrame = onVideoFrame ? await onVideoFrame({ frame, track }) : frame;
-  if (newFrame.codedHeight !== frame.displayHeight) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedHeight (${newFrame.codedHeight}) than the input frame displayHeight (${frame.displayHeight})`);
-  }
-  if (newFrame.codedWidth !== frame.displayWidth) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedWidth (${newFrame.codedWidth}) than the input frame displayWidth (${frame.displayWidth})`);
+  const rotated = rotateVideoFrame({
+    rotation,
+    frame: unrotatedFrame
+  });
+  if (unrotatedFrame !== rotated) {
+    unrotatedFrame.close();
   }
-  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})`);
+  const userProcessedFrame = onVideoFrame ? await onVideoFrame({ frame: rotated, track }) : rotated;
+  if (userProcessedFrame.displayWidth !== rotated.displayWidth) {
+    throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${userProcessedFrame.displayWidth}) than the input frame (${userProcessedFrame.displayHeight})`);
   }
-  if (newFrame.displayHeight !== frame.displayHeight) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${newFrame.displayHeight}) than the input frame (${newFrame.displayHeight})`);
+  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 (newFrame.timestamp !== frame.timestamp) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different timestamp (${newFrame.timestamp}) than the input frame (${newFrame.timestamp}). When calling new VideoFrame(), pass {timestamp: frame.timestamp} as second argument`);
+  if (userProcessedFrame.timestamp !== rotated.timestamp) {
+    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 (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`);
+  if ((userProcessedFrame.duration ?? 0) !== (rotated.duration ?? 0)) {
+    throw new Error(`Returned VideoFrame of track ${track.trackId} has different duration (${userProcessedFrame.duration}) than the input frame (${rotated.duration}). When calling new VideoFrame(), pass {duration: frame.duration} as second argument`);
   }
   const fixedFrame = convertToCorrectVideoFrame({
-    videoFrame: newFrame,
+    videoFrame: userProcessedFrame,
     outputCodec
   });
   await videoEncoder.encodeFrame(fixedFrame, fixedFrame.timestamp);
   fixedFrame.close();
-  if (frame !== newFrame) {
-    frame.close();
+  if (rotated !== userProcessedFrame) {
+    rotated.close();
   }
-  if (fixedFrame !== newFrame) {
+  if (fixedFrame !== userProcessedFrame) {
     fixedFrame.close();
   }
 };
@@ -903,9 +1115,14 @@ var createVideoDecoder = ({
   onError,
   signal,
   config,
-  logLevel
+  logLevel,
+  progress
 }) => {
-  const ioSynchronizer = makeIoSynchronizer(logLevel, "Video decoder");
+  const ioSynchronizer = makeIoSynchronizer({
+    logLevel,
+    label: "Video decoder",
+    progress
+  });
   let outputQueue = Promise.resolve();
   const videoDecoder = new VideoDecoder({
     output(inputFrame) {
@@ -951,7 +1168,11 @@ var createVideoDecoder = ({
     if (videoDecoder.state === "closed") {
       return;
     }
-    await ioSynchronizer.waitFor({ unemitted: 20, _unprocessed: 2 });
+    await ioSynchronizer.waitFor({
+      unemitted: 20,
+      _unprocessed: 2,
+      minimumProgress: sample.timestamp - 5000000
+    });
     if (sample.type === "key") {
       await videoDecoder.flush();
     }
@@ -988,12 +1209,17 @@ var createVideoEncoder = ({
   signal,
   config,
   logLevel,
-  outputCodec
+  outputCodec,
+  progress
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating video encoder, already aborted");
   }
-  const ioSynchronizer = makeIoSynchronizer(logLevel, "Video encoder");
+  const ioSynchronizer = makeIoSynchronizer({
+    logLevel,
+    label: "Video encoder",
+    progress
+  });
   let outputQueue = Promise.resolve();
   const encoder = new VideoEncoder({
     error(error) {
@@ -1035,7 +1261,8 @@ var createVideoEncoder = ({
     }
     await ioSynchronizer.waitFor({
       unemitted: 10,
-      _unprocessed: 10
+      _unprocessed: 10,
+      minimumProgress: frame.timestamp - 5000000
     });
     if (encoder.state === "closed") {
       return;
@@ -1075,7 +1302,9 @@ var makeVideoTrackHandler = ({
   defaultVideoCodec,
   onVideoTrack,
   logLevel,
-  container
+  container,
+  rotate,
+  progress
 }) => async (track) => {
   if (controller.signal.aborted) {
     throw new error_cause_default("Aborted");
@@ -1084,7 +1313,8 @@ var makeVideoTrackHandler = ({
     track,
     defaultVideoCodec,
     logLevel,
-    container
+    container,
+    rotate
   });
   if (videoOperation.type === "drop") {
     return null;
@@ -1119,10 +1349,19 @@ 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"`);
+  }
+  const rotation = videoOperation.rotate ?? -track.rotation;
+  const { height: newHeight, width: newWidth } = calculateNewDimensionsFromDimensions({
+    width: track.codedWidth,
+    height: track.codedHeight,
+    rotation
+  });
   const videoEncoderConfig = await getVideoEncoderConfig({
     codec: videoOperation.videoCodec,
-    height: track.displayAspectHeight,
-    width: track.displayAspectWidth,
+    height: newHeight,
+    width: newWidth,
     fps: track.fps
   });
   const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
@@ -1137,8 +1376,8 @@ var makeVideoTrackHandler = ({
   const { trackNumber } = await state.addTrack({
     type: "video",
     color: track.color,
-    width: track.codedWidth,
-    height: track.codedHeight,
+    width: newWidth,
+    height: newHeight,
     codec: videoOperation.videoCodec,
     codecPrivate: null,
     timescale: track.timescale
@@ -1168,7 +1407,8 @@ var makeVideoTrackHandler = ({
     signal: controller.signal,
     config: videoEncoderConfig,
     logLevel,
-    outputCodec: videoOperation.videoCodec
+    outputCodec: videoOperation.videoCodec,
+    progress
   });
   const videoDecoder = createVideoDecoder({
     config: videoDecoderConfig,
@@ -1178,7 +1418,8 @@ var makeVideoTrackHandler = ({
         track,
         videoEncoder,
         onVideoFrame,
-        outputCodec: videoOperation.videoCodec
+        outputCodec: videoOperation.videoCodec,
+        rotation
       });
     },
     onError: (err) => {
@@ -1187,7 +1428,8 @@ var makeVideoTrackHandler = ({
       }));
     },
     signal: controller.signal,
-    logLevel
+    logLevel,
+    progress
   });
   state.addWaitForFinishPromise(async () => {
     Log.verbose(logLevel, "Waiting for video decoder to finish");
@@ -1203,6 +1445,21 @@ var makeVideoTrackHandler = ({
   };
 };
 
+// src/select-container-creator.ts
+import { MediaParserInternals as MediaParserInternals6 } from "@remotion/media-parser";
+var selectContainerCreator = (container) => {
+  if (container === "mp4") {
+    return MediaParserInternals6.createIsoBaseMedia;
+  }
+  if (container === "wav") {
+    return MediaParserInternals6.createWav;
+  }
+  if (container === "webm") {
+    return MediaParserInternals6.createMatroskaMedia;
+  }
+  throw new Error(`Unsupported container: ${container}`);
+};
+
 // src/throttled-state-update.ts
 var throttledStateUpdate = ({
   updateFn,
@@ -1271,18 +1528,19 @@ var convertMedia = async function({
   logLevel = "info",
   writer,
   progressIntervalInMs,
+  rotate,
   ...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'));
   }
-  const { resolve, reject, getPromiseToImmediatelyReturn } = withResolversAndWaitForReturn();
+  const { resolve, reject, getPromiseToImmediatelyReturn } = MediaParserInternals7.withResolversAndWaitForReturn();
   const controller = new AbortController;
   const abortConversion = (errCause) => {
     reject(errCause);
@@ -1294,12 +1552,13 @@ var convertMedia = async function({
     abortConversion(new error_cause_default("Conversion aborted by user"));
   };
   userPassedAbortSignal?.addEventListener("abort", onUserAbort);
-  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 progressTracker = MediaParserInternals7.makeProgressTracker();
   const state = await creator({
     filename: generateOutputFilename(src, container),
     writer: await autoSelectWriter(writer, logLevel),
@@ -1326,7 +1585,8 @@ var convertMedia = async function({
         return prevState;
       });
     },
-    logLevel
+    logLevel,
+    progressTracker
   });
   const onVideoTrack = makeVideoTrackHandler({
     state,
@@ -1337,7 +1597,9 @@ var convertMedia = async function({
     defaultVideoCodec: videoCodec ?? null,
     onVideoTrack: userVideoResolver ?? null,
     logLevel,
-    container
+    container,
+    rotate: rotate ?? 0,
+    progress: progressTracker
   });
   const onAudioTrack = makeAudioTrackHandler({
     abortConversion,
@@ -1347,7 +1609,8 @@ var convertMedia = async function({
     state,
     onAudioTrack: userAudioResolver ?? null,
     logLevel,
-    container
+    container,
+    progressTracker
   });
   parseMedia({
     logLevel,
@@ -1398,7 +1661,46 @@ var convertMedia = async function({
     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
+var WebCodecsInternals = {
+  rotateVideoFrame,
+  normalizeVideoRotation
+};
 setRemotionImported();
 export {
   getDefaultVideoCodec,
@@ -1416,5 +1718,6 @@ export {
   canReencodeVideoTrack,
   canReencodeAudioTrack,
   canCopyVideoTrack,
-  canCopyAudioTrack
+  canCopyAudioTrack,
+  WebCodecsInternals
 };