@remotion/webcodecs 4.0.228 → 4.0.230

package/dist/esm/index.mjs

@@ -59,11 +59,11 @@ var makeIoSynchronizer = (logLevel, label) => {
   let unprocessed = 0;
   const getUnprocessed = () => unprocessed;
   const getUnemittedItems = () => {
-    inputs = inputs.filter((input) => input > lastOutput);
+    inputs = inputs.filter((input) => Math.floor(input) > Math.floor(lastOutput));
     return inputs.length;
   };
   const getUnemittedKeyframes = () => {
-    keyframes = keyframes.filter((keyframe) => keyframe > lastOutput);
+    keyframes = keyframes.filter((keyframe) => Math.floor(keyframe) > Math.floor(lastOutput));
     return keyframes.length;
   };
   const printState = (prefix) => {
@@ -221,7 +221,8 @@ var createAudioEncoder = ({
   codec,
   signal,
   config: audioEncoderConfig,
-  logLevel
+  logLevel,
+  onNewAudioSampleRate
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating audio encoder, already aborted");
@@ -258,10 +259,10 @@ var createAudioEncoder = ({
     close();
   };
   signal.addEventListener("abort", onAbort);
-  if (codec !== "opus") {
-    throw new Error('Only `codec: "opus"` is supported currently');
+  if (codec !== "opus" && codec !== "aac") {
+    throw new Error('Only `codec: "opus"` and `codec: "aac"` is supported currently');
   }
-  encoder.configure(audioEncoderConfig);
+  const wantedSampleRate = audioEncoderConfig.sampleRate;
   const encodeFrame = async (audioData) => {
     if (encoder.state === "closed") {
       return;
@@ -270,6 +271,17 @@ var createAudioEncoder = ({
     if (encoder.state === "closed") {
       return;
     }
+    if (encoder.state === "unconfigured") {
+      if (audioData.sampleRate === wantedSampleRate) {
+        encoder.configure(audioEncoderConfig);
+      } else {
+        encoder.configure({
+          ...audioEncoderConfig,
+          sampleRate: audioData.sampleRate
+        });
+        onNewAudioSampleRate(audioData.sampleRate);
+      }
+    }
     encoder.encode(audioData);
     ioSynchronizer.inputItem(audioData.timestamp, true);
   };
@@ -290,9 +302,214 @@ var createAudioEncoder = ({
     }
   };
 };
+// src/can-copy-audio-track.ts
+var canCopyAudioTrack = ({
+  inputCodec,
+  container
+}) => {
+  if (container === "webm") {
+    return inputCodec === "opus";
+  }
+  if (container === "mp4") {
+    return inputCodec === "aac";
+  }
+  throw new Error(`Unhandled codec: ${container}`);
+};
+// src/can-copy-video-track.ts
+var canCopyVideoTrack = ({
+  inputCodec,
+  container
+}) => {
+  if (container === "webm") {
+    return inputCodec === "vp8" || inputCodec === "vp9";
+  }
+  if (container === "mp4") {
+    return inputCodec === "h264" || inputCodec === "h265";
+  }
+  throw new Error(`Unhandled codec: ${container}`);
+};
+// src/audio-decoder-config.ts
+var getAudioDecoderConfig = async (config) => {
+  if (typeof AudioDecoder === "undefined") {
+    return null;
+  }
+  if (typeof EncodedAudioChunk === "undefined") {
+    return null;
+  }
+  if ((await AudioDecoder.isConfigSupported(config)).supported) {
+    return config;
+  }
+  return null;
+};
+
+// src/audio-encoder-config.ts
+var getCodecString = (audioCodec) => {
+  if (audioCodec === "opus") {
+    return "opus";
+  }
+  if (audioCodec === "aac") {
+    return "mp4a.40.02";
+  }
+  throw new Error(`Unsupported audio codec: ${audioCodec}`);
+};
+var getAudioEncoderConfig = async (config) => {
+  const actualConfig = {
+    ...config,
+    codec: getCodecString(config.codec)
+  };
+  if (typeof AudioEncoder === "undefined") {
+    return null;
+  }
+  if ((await AudioEncoder.isConfigSupported(actualConfig)).supported) {
+    return actualConfig;
+  }
+  return null;
+};
+
+// src/can-reencode-audio-track.ts
+var canReencodeAudioTrack = async ({
+  track,
+  audioCodec,
+  bitrate
+}) => {
+  const audioDecoderConfig = await getAudioDecoderConfig(track);
+  const audioEncoderConfig = await getAudioEncoderConfig({
+    codec: audioCodec,
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    bitrate
+  });
+  return Boolean(audioDecoderConfig && audioEncoderConfig);
+};
+// src/video-decoder-config.ts
+var getVideoDecoderConfigWithHardwareAcceleration = async (config) => {
+  if (typeof VideoDecoder === "undefined") {
+    return null;
+  }
+  const hardware = {
+    ...config,
+    hardwareAcceleration: "prefer-hardware"
+  };
+  if ((await VideoDecoder.isConfigSupported(hardware)).supported) {
+    return hardware;
+  }
+  const software = {
+    ...config,
+    hardwareAcceleration: "prefer-software"
+  };
+  if ((await VideoDecoder.isConfigSupported(software)).supported) {
+    return software;
+  }
+  return null;
+};
+
+// src/choose-correct-avc1-profile.ts
+var chooseCorrectAvc1Profile = ({
+  width,
+  height,
+  fps
+}) => {
+  const profiles = [
+    { level: "3.1", hex: "1F", width: 1280, height: 720, fps: 30 },
+    { level: "3.2", hex: "20", width: 1280, height: 1024, fps: 42.2 },
+    { level: "4.0", hex: "28", width: 2048, height: 1024, fps: 30 },
+    { level: "4.1", hex: "29", width: 2048, height: 1024, fps: 30 },
+    { level: "4.2", hex: "2A", width: 2048, height: 1080, fps: 60 },
+    { level: "5.0", hex: "32", width: 3672, height: 1536, fps: 26.7 },
+    { level: "5.1", hex: "33", width: 4096, height: 2304, fps: 26.7 },
+    { level: "5.2", hex: "34", width: 4096, height: 2304, fps: 56.3 },
+    { level: "6.0", hex: "3C", width: 8192, height: 4320, fps: 30.2 },
+    { level: "6.1", hex: "3D", width: 8192, height: 4320, fps: 60.4 },
+    { level: "6.2", hex: "3E", width: 8192, height: 4320, fps: 120.8 }
+  ];
+  const profile = profiles.find((p) => {
+    if (width > p.width) {
+      return false;
+    }
+    if (height > p.height) {
+      return false;
+    }
+    const fallbackFps = fps ?? 60;
+    return fallbackFps <= p.fps;
+  });
+  if (!profile) {
+    throw new Error(`No suitable AVC1 profile found for ${width}x${height}@${fps}fps`);
+  }
+  return `avc1.6400${profile.hex}`;
+};
+
+// src/video-encoder-config.ts
+var getVideoEncoderConfig = async ({
+  codec,
+  height,
+  width,
+  fps
+}) => {
+  if (typeof VideoEncoder === "undefined") {
+    return null;
+  }
+  const config = {
+    codec: codec === "h264" ? chooseCorrectAvc1Profile({ fps, height, width }) : codec === "vp9" ? "vp09.00.10.08" : codec,
+    height,
+    width
+  };
+  const hardware = {
+    ...config,
+    hardwareAcceleration: "prefer-hardware"
+  };
+  if ((await VideoEncoder.isConfigSupported(hardware)).supported) {
+    return hardware;
+  }
+  const software = {
+    ...config,
+    hardwareAcceleration: "prefer-software"
+  };
+  if ((await VideoEncoder.isConfigSupported(software)).supported) {
+    return software;
+  }
+  return null;
+};
+
+// src/can-reencode-video-track.ts
+var canReencodeVideoTrack = async ({
+  videoCodec,
+  track
+}) => {
+  const videoEncoderConfig = await getVideoEncoderConfig({
+    codec: videoCodec,
+    height: track.displayAspectHeight,
+    width: track.displayAspectWidth,
+    fps: track.fps
+  });
+  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 MediaParserInternals2,
+  MediaParserInternals as MediaParserInternals4,
   parseMedia
 } from "@remotion/media-parser";
 
@@ -316,122 +533,141 @@ var autoSelectWriter = async (writer, logLevel) => {
 // src/calculate-progress.ts
 var calculateProgress = ({
   millisecondsWritten,
-  expectedOutputMilliseconds
+  expectedOutputDurationInMs
 }) => {
-  if (expectedOutputMilliseconds === null) {
+  if (expectedOutputDurationInMs === null) {
     return null;
   }
-  return millisecondsWritten / expectedOutputMilliseconds;
+  return millisecondsWritten / expectedOutputDurationInMs;
 };
 
 // src/error-cause.ts
 var error_cause_default = Error;
 
-// src/audio-decoder-config.ts
-var getAudioDecoderConfig = async (config) => {
-  if (typeof AudioDecoder === "undefined") {
-    return null;
-  }
-  if ((await AudioDecoder.isConfigSupported(config)).supported) {
-    return config;
-  }
-  return null;
+// src/convert-encoded-chunk.ts
+var convertEncodedChunk = (chunk, trackId) => {
+  const arr = new Uint8Array(chunk.byteLength);
+  chunk.copyTo(arr);
+  return {
+    data: arr,
+    duration: chunk.duration ?? undefined,
+    timestamp: chunk.timestamp,
+    type: chunk.type,
+    cts: chunk.timestamp,
+    dts: chunk.timestamp,
+    trackId
+  };
 };
 
-// src/audio-encoder-config.ts
-var getAudioEncoderConfig = async (config) => {
-  if (typeof AudioEncoder === "undefined") {
-    return null;
+// src/default-on-audio-track-handler.ts
+import { MediaParserInternals as MediaParserInternals2 } from "@remotion/media-parser";
+
+// src/get-default-audio-codec.ts
+var getDefaultAudioCodec = ({
+  container
+}) => {
+  if (container === "webm") {
+    return "opus";
   }
-  if ((await AudioEncoder.isConfigSupported(config)).supported) {
-    return config;
+  if (container === "mp4") {
+    return "aac";
   }
-  return null;
+  throw new Error(`Unhandled container: ${container}`);
 };
 
-// src/resolve-audio-action.ts
-var canCopyAudioTrack = (inputCodec, outputCodec) => {
-  if (outputCodec === "opus") {
-    return inputCodec === "opus";
-  }
-  throw new Error(`Unhandled codec: ${outputCodec}`);
-};
-var defaultResolveAudioAction = ({
-  canReencode,
-  canCopy
+// src/default-on-audio-track-handler.ts
+var DEFAULT_BITRATE = 128000;
+var defaultOnAudioTrackHandler = async ({
+  track,
+  defaultAudioCodec,
+  logLevel,
+  container
 }) => {
+  const bitrate = DEFAULT_BITRATE;
+  const canCopy = canCopyAudioTrack({
+    inputCodec: track.codecWithoutConfig,
+    container
+  });
   if (canCopy) {
-    return "copy";
+    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
+    return Promise.resolve({ type: "copy" });
   }
+  const audioCodec = defaultAudioCodec ?? getDefaultAudioCodec({ container });
+  const canReencode = await canReencodeAudioTrack({
+    audioCodec,
+    track,
+    bitrate
+  });
   if (canReencode) {
-    return "reencode";
+    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
+    return Promise.resolve({
+      type: "reencode",
+      bitrate,
+      audioCodec
+    });
   }
-  return "drop";
-};
-var resolveAudioAction = async ({
-  audioDecoderConfig,
-  audioEncoderConfig,
-  track,
-  audioCodec,
-  resolverFunction
-}) => {
-  const canReencode = Boolean(audioDecoderConfig && audioEncoderConfig);
-  const canCopy = canCopyAudioTrack(track.codecWithoutConfig, audioCodec);
-  const resolved = await resolverFunction({
-    canReencode,
-    canCopy
-  });
-  return resolved;
+  MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
+  return Promise.resolve({ type: "fail" });
 };
 
 // src/on-audio-track.ts
 var makeAudioTrackHandler = ({
   state,
-  audioCodec,
+  defaultAudioCodec: audioCodec,
   convertMediaState,
   controller,
   abortConversion,
   onMediaStateUpdate,
   onAudioTrack,
-  bitrate,
-  logLevel
+  logLevel,
+  container
 }) => async (track) => {
-  const audioEncoderConfig = await getAudioEncoderConfig({
-    codec: audioCodec,
-    numberOfChannels: track.numberOfChannels,
-    sampleRate: track.sampleRate,
-    bitrate
-  });
-  const audioDecoderConfig = await getAudioDecoderConfig({
-    codec: track.codec,
-    numberOfChannels: track.numberOfChannels,
-    sampleRate: track.sampleRate,
-    description: track.description
-  });
-  const audioOperation = await resolveAudioAction({
-    audioDecoderConfig,
-    audioEncoderConfig,
-    audioCodec,
+  const audioOperation = await (onAudioTrack ?? defaultOnAudioTrackHandler)({
+    defaultAudioCodec: audioCodec,
     track,
-    resolverFunction: onAudioTrack
+    logLevel,
+    container
   });
-  if (audioOperation === "drop") {
+  if (audioOperation.type === "drop") {
     return null;
   }
-  if (audioOperation === "copy") {
+  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`);
+  }
+  if (audioOperation.type === "copy") {
     const addedTrack = await state.addTrack({
       type: "audio",
-      codec: audioCodec,
+      codec: track.codecWithoutConfig,
       numberOfChannels: track.numberOfChannels,
       sampleRate: track.sampleRate,
-      codecPrivate: track.codecPrivate
+      codecPrivate: track.codecPrivate,
+      timescale: track.timescale
     });
+    Log.verbose(logLevel, `Copying audio track ${track.trackId} as track ${addedTrack.trackNumber}. Timescale = ${track.timescale}, codec = ${track.codecWithoutConfig} (${track.codec}) `);
     return async (audioSample) => {
-      await state.addSample(new EncodedAudioChunk(audioSample), addedTrack.trackNumber, false);
+      await state.addSample({
+        chunk: audioSample,
+        trackNumber: addedTrack.trackNumber,
+        isVideo: false,
+        timescale: track.timescale,
+        codecPrivate: track.codecPrivate
+      });
       convertMediaState.encodedAudioFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     };
   }
+  const audioEncoderConfig = await getAudioEncoderConfig({
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    codec: audioOperation.audioCodec,
+    bitrate: audioOperation.bitrate
+  });
+  const audioDecoderConfig = await getAudioDecoderConfig({
+    codec: track.codec,
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    description: track.description
+  });
   if (!audioEncoderConfig) {
     abortConversion(new error_cause_default(`Could not configure audio encoder of track ${track.trackId}`));
     return null;
@@ -440,16 +676,27 @@ var makeAudioTrackHandler = ({
     abortConversion(new error_cause_default(`Could not configure audio decoder of track ${track.trackId}`));
     return null;
   }
+  const codecPrivate = audioOperation.audioCodec === "aac" ? new Uint8Array([17, 144]) : null;
   const { trackNumber } = await state.addTrack({
     type: "audio",
-    codec: audioCodec,
+    codec: audioOperation.audioCodec,
     numberOfChannels: track.numberOfChannels,
     sampleRate: track.sampleRate,
-    codecPrivate: null
+    codecPrivate,
+    timescale: track.timescale
   });
   const audioEncoder = createAudioEncoder({
+    onNewAudioSampleRate: (sampleRate) => {
+      state.updateTrackSampleRate({ sampleRate, trackNumber });
+    },
     onChunk: async (chunk) => {
-      await state.addSample(chunk, trackNumber, false);
+      await state.addSample({
+        chunk: convertEncodedChunk(chunk, trackNumber),
+        trackNumber,
+        isVideo: false,
+        timescale: track.timescale,
+        codecPrivate
+      });
       convertMediaState.encodedAudioFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     },
@@ -458,7 +705,7 @@ var makeAudioTrackHandler = ({
         cause: err
       }));
     },
-    codec: audioCodec,
+    codec: audioOperation.audioCodec,
     signal: controller.signal,
     config: audioEncoderConfig,
     logLevel
@@ -490,47 +737,92 @@ var makeAudioTrackHandler = ({
   };
 };
 
-// src/resolve-video-action.ts
-var canCopyVideoTrack = (inputCodec, outputCodec) => {
-  if (outputCodec === "vp8") {
-    return inputCodec === "vp8";
-  }
-  if (outputCodec === "vp9") {
-    return inputCodec === "vp9";
+// src/arraybuffer-to-uint8-array.ts
+var arrayBufferToUint8Array = (buffer) => {
+  return buffer ? new Uint8Array(buffer) : null;
+};
+
+// src/default-on-video-track-handler.ts
+import { MediaParserInternals as MediaParserInternals3 } from "@remotion/media-parser";
+
+// src/get-default-video-codec.ts
+var getDefaultVideoCodec = ({
+  container
+}) => {
+  if (container === "webm") {
+    return "vp8";
   }
-  throw new Error(`Unhandled codec: ${outputCodec}`);
+  throw new Error(`Unhandled container: ${container} satisfies never`);
 };
-var defaultResolveVideoAction = ({
-  canReencode,
-  canCopy
+
+// src/default-on-video-track-handler.ts
+var defaultOnVideoTrackHandler = async ({
+  track,
+  defaultVideoCodec,
+  logLevel,
+  container
 }) => {
+  const canCopy = canCopyVideoTrack({
+    inputCodec: track.codecWithoutConfig,
+    container
+  });
   if (canCopy) {
-    return "copy";
+    MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
+    return Promise.resolve({ type: "copy" });
   }
+  const videoCodec = defaultVideoCodec ?? getDefaultVideoCodec({ container });
+  const canReencode = await canReencodeVideoTrack({
+    videoCodec,
+    track
+  });
   if (canReencode) {
-    return "reencode";
+    MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
+    return Promise.resolve({ type: "reencode", videoCodec });
   }
-  return "drop";
+  MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
+  return Promise.resolve({ type: "fail" });
 };
-var resolveVideoAction = async ({
-  videoDecoderConfig,
-  videoEncoderConfig,
+
+// src/on-frame.ts
+var onFrame = async ({
+  frame,
+  onVideoFrame,
+  videoEncoder,
+  onMediaStateUpdate,
   track,
-  videoCodec,
-  resolverFunction
+  convertMediaState
 }) => {
-  const canReencode = Boolean(videoDecoderConfig && videoEncoderConfig);
-  const canCopy = canCopyVideoTrack(track.codecWithoutConfig, videoCodec);
-  const resolved = await resolverFunction({
-    canReencode,
-    canCopy
-  });
-  return resolved;
+  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})`);
+  }
+  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 (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 (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();
+  if (frame !== newFrame) {
+    frame.close();
+  }
 };
 
 // src/video-decoder.ts
 var createVideoDecoder = ({
-  onFrame,
+  onFrame: onFrame2,
   onError,
   signal,
   config,
@@ -549,7 +841,7 @@ var createVideoDecoder = ({
         if (signal.aborted) {
           return;
         }
-        return onFrame(inputFrame);
+        return onFrame2(inputFrame);
       }).then(() => {
         ioSynchronizer.onProcessed();
         signal.removeEventListener("abort", abortHandler);
@@ -597,9 +889,13 @@ var createVideoDecoder = ({
     },
     waitForFinish: async () => {
       await videoDecoder.flush();
+      Log.verbose(logLevel, "Flushed video decoder");
       await ioSynchronizer.waitForFinish();
+      Log.verbose(logLevel, "IO synchro finished");
       await outputQueue;
+      Log.verbose(logLevel, "Output queue finished");
       await inputQueue;
+      Log.verbose(logLevel, "Input queue finished");
     },
     close,
     flush: async () => {
@@ -608,28 +904,6 @@ var createVideoDecoder = ({
   };
 };
 
-// src/video-decoder-config.ts
-var getVideoDecoderConfigWithHardwareAcceleration = async (config) => {
-  if (typeof VideoDecoder === "undefined") {
-    return null;
-  }
-  const hardware = {
-    ...config,
-    hardwareAcceleration: "prefer-hardware"
-  };
-  if ((await VideoDecoder.isConfigSupported(hardware)).supported) {
-    return hardware;
-  }
-  const software = {
-    ...config,
-    hardwareAcceleration: "prefer-software"
-  };
-  if ((await VideoDecoder.isConfigSupported(software)).supported) {
-    return software;
-  }
-  return null;
-};
-
 // src/video-encoder.ts
 var createVideoEncoder = ({
   onChunk,
@@ -647,17 +921,14 @@ var createVideoEncoder = ({
     error(error) {
       onError(error);
     },
-    output(chunk) {
-      if (chunk.duration === null) {
-        throw new Error("Duration is null");
-      }
-      const timestamp = chunk.timestamp + chunk.duration;
+    output(chunk, metadata) {
+      const timestamp = chunk.timestamp + (chunk.duration ?? 0);
       ioSynchronizer.onOutput(timestamp);
       outputQueue = outputQueue.then(() => {
         if (signal.aborted) {
           return;
         }
-        return onChunk(chunk);
+        return onChunk(chunk, metadata ?? null);
       }).then(() => {
         ioSynchronizer.onProcessed();
         return Promise.resolve();
@@ -715,28 +986,6 @@ var createVideoEncoder = ({
   };
 };
 
-// src/video-encoder-config.ts
-var getVideoEncoderConfig = async (config) => {
-  if (typeof VideoEncoder === "undefined") {
-    return null;
-  }
-  const hardware = {
-    ...config,
-    hardwareAcceleration: "prefer-hardware"
-  };
-  if ((await VideoEncoder.isConfigSupported(hardware)).supported) {
-    return hardware;
-  }
-  const software = {
-    ...config,
-    hardwareAcceleration: "prefer-software"
-  };
-  if ((await VideoEncoder.isConfigSupported(software)).supported) {
-    return software;
-  }
-  return null;
-};
-
 // src/on-video-track.ts
 var makeVideoTrackHandler = ({
   state,
@@ -745,44 +994,56 @@ var makeVideoTrackHandler = ({
   abortConversion,
   convertMediaState,
   controller,
-  videoCodec,
+  defaultVideoCodec,
   onVideoTrack,
-  logLevel
+  logLevel,
+  container
 }) => async (track) => {
   if (controller.signal.aborted) {
     throw new error_cause_default("Aborted");
   }
-  const videoEncoderConfig = await getVideoEncoderConfig({
-    codec: videoCodec === "vp9" ? "vp09.00.10.08" : videoCodec,
-    height: track.displayAspectHeight,
-    width: track.displayAspectWidth
-  });
-  const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
-  const videoOperation = await resolveVideoAction({
-    videoDecoderConfig,
-    videoEncoderConfig,
+  const videoOperation = await (onVideoTrack ?? defaultOnVideoTrackHandler)({
     track,
-    videoCodec,
-    resolverFunction: onVideoTrack
+    defaultVideoCodec,
+    logLevel,
+    container
   });
-  if (videoOperation === "drop") {
+  if (videoOperation.type === "drop") {
     return null;
   }
-  if (videoOperation === "copy") {
+  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`);
+  }
+  if (videoOperation.type === "copy") {
+    Log.verbose(logLevel, `Copying video track with codec ${track.codec} and timescale ${track.timescale}`);
     const videoTrack = await state.addTrack({
       type: "video",
       color: track.color,
       width: track.codedWidth,
       height: track.codedHeight,
       codec: track.codecWithoutConfig,
-      codecPrivate: track.codecPrivate
+      codecPrivate: track.codecPrivate,
+      timescale: track.timescale
     });
     return async (sample) => {
-      await state.addSample(new EncodedVideoChunk(sample), videoTrack.trackNumber, true);
+      await state.addSample({
+        chunk: sample,
+        trackNumber: videoTrack.trackNumber,
+        isVideo: true,
+        timescale: track.timescale,
+        codecPrivate: track.codecPrivate
+      });
       convertMediaState.decodedVideoFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     };
   }
+  const videoEncoderConfig = await getVideoEncoderConfig({
+    codec: videoOperation.videoCodec,
+    height: track.displayAspectHeight,
+    width: track.displayAspectWidth,
+    fps: track.fps
+  });
+  const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
   if (videoEncoderConfig === null) {
     abortConversion(new error_cause_default(`Could not configure video encoder of track ${track.trackId}`));
     return null;
@@ -796,12 +1057,20 @@ var makeVideoTrackHandler = ({
     color: track.color,
     width: track.codedWidth,
     height: track.codedHeight,
-    codec: videoCodec,
-    codecPrivate: null
+    codec: videoOperation.videoCodec,
+    codecPrivate: null,
+    timescale: track.timescale
   });
+  Log.verbose(logLevel, `Created new video track with ID ${trackNumber}, codec ${videoOperation.videoCodec} and timescale ${track.timescale}`);
   const videoEncoder = createVideoEncoder({
-    onChunk: async (chunk) => {
-      await state.addSample(chunk, trackNumber, true);
+    onChunk: async (chunk, metadata) => {
+      await state.addSample({
+        chunk: convertEncodedChunk(chunk, trackNumber),
+        trackNumber,
+        isVideo: true,
+        timescale: track.timescale,
+        codecPrivate: arrayBufferToUint8Array(metadata?.decoderConfig?.description ?? null)
+      });
       convertMediaState.encodedVideoFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     },
@@ -817,11 +1086,14 @@ var makeVideoTrackHandler = ({
   const videoDecoder = createVideoDecoder({
     config: videoDecoderConfig,
     onFrame: async (frame) => {
-      await onVideoFrame?.(frame, track);
-      await videoEncoder.encodeFrame(frame);
-      convertMediaState.decodedVideoFrames++;
-      onMediaStateUpdate?.({ ...convertMediaState });
-      frame.close();
+      await onFrame({
+        convertMediaState,
+        frame,
+        onMediaStateUpdate,
+        track,
+        videoEncoder,
+        onVideoFrame
+      });
     },
     onError: (err) => {
       abortConversion(new error_cause_default(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
@@ -832,10 +1104,13 @@ var makeVideoTrackHandler = ({
     logLevel
   });
   state.addWaitForFinishPromise(async () => {
+    Log.verbose(logLevel, "Waiting for video decoder to finish");
     await videoDecoder.waitForFinish();
-    await videoEncoder.waitForFinish();
     videoDecoder.close();
+    Log.verbose(logLevel, "Video decoder finished. Waiting for encoder to finish");
+    await videoEncoder.waitForFinish();
     videoEncoder.close();
+    Log.verbose(logLevel, "Encoder finished");
   });
   return async (chunk) => {
     await videoDecoder.processSample(chunk);
@@ -848,7 +1123,7 @@ var convertMedia = async function({
   onVideoFrame,
   onMediaStateUpdate: onMediaStateDoNoCallDirectly,
   audioCodec,
-  to,
+  container,
   videoCodec,
   signal: userPassedAbortSignal,
   onAudioTrack: userAudioResolver,
@@ -862,13 +1137,10 @@ var convertMedia = async function({
   if (userPassedAbortSignal?.aborted) {
     return Promise.reject(new error_cause_default("Aborted"));
   }
-  if (to !== "webm") {
-    return Promise.reject(new TypeError('Only `to: "webm"` is supported currently'));
+  if (container !== "webm" && container !== "mp4") {
+    return Promise.reject(new TypeError('Only `to: "webm"` and `to: "mp4"` is supported currently'));
   }
-  if (audioCodec !== "opus") {
-    return Promise.reject(new TypeError('Only `audioCodec: "opus"` is supported currently'));
-  }
-  if (videoCodec !== "vp8" && videoCodec !== "vp9") {
+  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();
@@ -890,7 +1162,7 @@ var convertMedia = async function({
     encodedAudioFrames: 0,
     bytesWritten: 0,
     millisecondsWritten: 0,
-    expectedOutputMilliseconds: null,
+    expectedOutputDurationInMs: null,
     overallProgress: 0
   };
   const onMediaStateUpdate = (newState) => {
@@ -899,7 +1171,8 @@ var convertMedia = async function({
     }
     onMediaStateDoNoCallDirectly?.(newState);
   };
-  const state = await MediaParserInternals2.createMedia({
+  const creator = container === "webm" ? MediaParserInternals4.createMatroskaMedia : MediaParserInternals4.createIsoBaseMedia;
+  const state = await creator({
     writer: await autoSelectWriter(writer, logLevel),
     onBytesProgress: (bytesWritten) => {
       convertMediaState.bytesWritten = bytesWritten;
@@ -910,11 +1183,12 @@ var convertMedia = async function({
         convertMediaState.millisecondsWritten = millisecondsWritten;
         convertMediaState.overallProgress = calculateProgress({
           millisecondsWritten: convertMediaState.millisecondsWritten,
-          expectedOutputMilliseconds: convertMediaState.expectedOutputMilliseconds
+          expectedOutputDurationInMs: convertMediaState.expectedOutputDurationInMs
         });
         onMediaStateUpdate?.(convertMediaState);
       }
-    }
+    },
+    logLevel
   });
   const onVideoTrack = makeVideoTrackHandler({
     state,
@@ -923,22 +1197,24 @@ var convertMedia = async function({
     abortConversion,
     convertMediaState,
     controller,
-    videoCodec,
-    onVideoTrack: userVideoResolver ?? defaultResolveVideoAction,
-    logLevel
+    defaultVideoCodec: videoCodec ?? null,
+    onVideoTrack: userVideoResolver ?? null,
+    logLevel,
+    container
   });
   const onAudioTrack = makeAudioTrackHandler({
     abortConversion,
-    audioCodec,
+    defaultAudioCodec: audioCodec ?? null,
     controller,
     convertMediaState,
     onMediaStateUpdate: onMediaStateUpdate ?? null,
     state,
-    onAudioTrack: userAudioResolver ?? defaultResolveAudioAction,
-    bitrate: 128000,
-    logLevel
+    onAudioTrack: userAudioResolver ?? null,
+    logLevel,
+    container
   });
   parseMedia({
+    logLevel,
     src,
     onVideoTrack,
     onAudioTrack,
@@ -957,11 +1233,11 @@ var convertMedia = async function({
       if (casted.onDurationInSeconds) {
         casted.onDurationInSeconds(durationInSeconds);
       }
-      const expectedOutputMilliseconds = durationInSeconds * 1000;
-      convertMediaState.expectedOutputMilliseconds = expectedOutputMilliseconds;
+      const expectedOutputDurationInMs = durationInSeconds * 1000;
+      convertMediaState.expectedOutputDurationInMs = expectedOutputDurationInMs;
       convertMediaState.overallProgress = calculateProgress({
         millisecondsWritten: convertMediaState.millisecondsWritten,
-        expectedOutputMilliseconds
+        expectedOutputDurationInMs
       });
       onMediaStateUpdate(convertMediaState);
     }
@@ -977,9 +1253,20 @@ var convertMedia = async function({
   });
 };
 export {
+  getDefaultVideoCodec,
+  getDefaultAudioCodec,
+  getAvailableVideoCodecs,
+  getAvailableContainers,
+  getAvailableAudioCodecs,
+  defaultOnVideoTrackHandler,
+  defaultOnAudioTrackHandler,
   createVideoEncoder,
   createVideoDecoder,
   createAudioEncoder,
   createAudioDecoder,
-  convertMedia
+  convertMedia,
+  canReencodeVideoTrack,
+  canReencodeAudioTrack,
+  canCopyVideoTrack,
+  canCopyAudioTrack
 };