@remotion/webcodecs 4.0.229 → 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);
   };
@@ -293,27 +305,28 @@ var createAudioEncoder = ({
 // src/can-copy-audio-track.ts
 var canCopyAudioTrack = ({
   inputCodec,
-  outputCodec,
   container
 }) => {
-  if (outputCodec === "opus") {
-    return inputCodec === "opus" && container === "webm";
+  if (container === "webm") {
+    return inputCodec === "opus";
+  }
+  if (container === "mp4") {
+    return inputCodec === "aac";
   }
-  throw new Error(`Unhandled codec: ${outputCodec}`);
+  throw new Error(`Unhandled codec: ${container}`);
 };
 // src/can-copy-video-track.ts
 var canCopyVideoTrack = ({
   inputCodec,
-  outputCodec,
   container
 }) => {
-  if (outputCodec === "vp8") {
-    return inputCodec === "vp8" && container === "webm";
+  if (container === "webm") {
+    return inputCodec === "vp8" || inputCodec === "vp9";
   }
-  if (outputCodec === "vp9") {
-    return inputCodec === "vp9" && container === "webm";
+  if (container === "mp4") {
+    return inputCodec === "h264" || inputCodec === "h265";
   }
-  throw new Error(`Unhandled codec: ${outputCodec}`);
+  throw new Error(`Unhandled codec: ${container}`);
 };
 // src/audio-decoder-config.ts
 var getAudioDecoderConfig = async (config) => {
@@ -330,12 +343,25 @@ var getAudioDecoderConfig = async (config) => {
 };
 
 // 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(config)).supported) {
-    return config;
+  if ((await AudioEncoder.isConfigSupported(actualConfig)).supported) {
+    return actualConfig;
   }
   return null;
 };
@@ -346,12 +372,7 @@ var canReencodeAudioTrack = async ({
   audioCodec,
   bitrate
 }) => {
-  const audioDecoderConfig = await getAudioDecoderConfig({
-    codec: track.codec,
-    numberOfChannels: track.numberOfChannels,
-    sampleRate: track.sampleRate,
-    description: track.description
-  });
+  const audioDecoderConfig = await getAudioDecoderConfig(track);
   const audioEncoderConfig = await getAudioEncoderConfig({
     codec: audioCodec,
     numberOfChannels: track.numberOfChannels,
@@ -382,17 +403,53 @@ var getVideoDecoderConfigWithHardwareAcceleration = async (config) => {
   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 ({
-  width,
+  codec,
   height,
-  codec
+  width,
+  fps
 }) => {
   if (typeof VideoEncoder === "undefined") {
     return null;
   }
   const config = {
-    codec: codec === "vp9" ? "vp09.00.10.08" : codec,
+    codec: codec === "h264" ? chooseCorrectAvc1Profile({ fps, height, width }) : codec === "vp9" ? "vp09.00.10.08" : codec,
     height,
     width
   };
@@ -421,19 +478,38 @@ var canReencodeVideoTrack = async ({
   const videoEncoderConfig = await getVideoEncoderConfig({
     codec: videoCodec,
     height: track.displayAspectHeight,
-    width: track.displayAspectWidth
+    width: track.displayAspectWidth,
+    fps: track.fps
   });
   const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
   return Boolean(videoDecoderConfig && videoEncoderConfig);
 };
 // src/codec-id.ts
-var availableVideoCodecs = ["vp8", "vp9"];
-var getAvailableVideoCodecs = () => availableVideoCodecs;
-var availableAudioCodecs = ["opus"];
-var getAvailableAudioCodecs = () => availableAudioCodecs;
+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";
 
@@ -469,52 +545,75 @@ var calculateProgress = ({
 var error_cause_default = Error;
 
 // src/convert-encoded-chunk.ts
-var convertEncodedChunk = (chunk) => {
+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
+    type: chunk.type,
+    cts: chunk.timestamp,
+    dts: chunk.timestamp,
+    trackId
   };
 };
 
-// src/resolve-audio-action.ts
+// 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 (container === "mp4") {
+    return "aac";
+  }
+  throw new Error(`Unhandled container: ${container}`);
+};
+
+// src/default-on-audio-track-handler.ts
 var DEFAULT_BITRATE = 128000;
-var defaultResolveAudioAction = async ({
+var defaultOnAudioTrackHandler = async ({
   track,
-  audioCodec,
+  defaultAudioCodec,
   logLevel,
   container
 }) => {
   const bitrate = DEFAULT_BITRATE;
   const canCopy = canCopyAudioTrack({
     inputCodec: track.codecWithoutConfig,
-    outputCodec: audioCodec,
     container
   });
   if (canCopy) {
-    Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy = ${canCopy}, action = 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) {
-    Log.verbose(logLevel, `Track ${track.trackId} (audio): Can re-encode = ${canReencode}, can copy = ${canCopy}, action = reencode`);
-    return Promise.resolve({ type: "reencode", bitrate, audioCodec });
+    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
+    return Promise.resolve({
+      type: "reencode",
+      bitrate,
+      audioCodec
+    });
   }
-  Log.verbose(logLevel, `Track ${track.trackId} (audio): Can re-encode = ${canReencode}, can copy = ${canCopy}, action = drop`);
-  return Promise.resolve({ type: "drop" });
+  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,
@@ -523,8 +622,8 @@ var makeAudioTrackHandler = ({
   logLevel,
   container
 }) => async (track) => {
-  const audioOperation = await (onAudioTrack ?? defaultResolveAudioAction)({
-    audioCodec,
+  const audioOperation = await (onAudioTrack ?? defaultOnAudioTrackHandler)({
+    defaultAudioCodec: audioCodec,
     track,
     logLevel,
     container
@@ -532,16 +631,27 @@ var makeAudioTrackHandler = ({
   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`);
+  }
   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(audioSample, addedTrack.trackNumber, false);
+      await state.addSample({
+        chunk: audioSample,
+        trackNumber: addedTrack.trackNumber,
+        isVideo: false,
+        timescale: track.timescale,
+        codecPrivate: track.codecPrivate
+      });
       convertMediaState.encodedAudioFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     };
@@ -566,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(convertEncodedChunk(chunk), trackNumber, false);
+      await state.addSample({
+        chunk: convertEncodedChunk(chunk, trackNumber),
+        trackNumber,
+        isVideo: false,
+        timescale: track.timescale,
+        codecPrivate
+      });
       convertMediaState.encodedAudioFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     },
@@ -584,7 +705,7 @@ var makeAudioTrackHandler = ({
         cause: err
       }));
     },
-    codec: audioCodec,
+    codec: audioOperation.audioCodec,
     signal: controller.signal,
     config: audioEncoderConfig,
     logLevel
@@ -616,6 +737,52 @@ var makeAudioTrackHandler = ({
   };
 };
 
+// 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 container: ${container} satisfies never`);
+};
+
+// src/default-on-video-track-handler.ts
+var defaultOnVideoTrackHandler = async ({
+  track,
+  defaultVideoCodec,
+  logLevel,
+  container
+}) => {
+  const canCopy = canCopyVideoTrack({
+    inputCodec: track.codecWithoutConfig,
+    container
+  });
+  if (canCopy) {
+    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) {
+    MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
+    return Promise.resolve({ type: "reencode", videoCodec });
+  }
+  MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
+  return Promise.resolve({ type: "fail" });
+};
+
 // src/on-frame.ts
 var onFrame = async ({
   frame,
@@ -653,31 +820,6 @@ var onFrame = async ({
   }
 };
 
-// src/resolve-video-action.ts
-var defaultResolveVideoAction = async ({
-  track,
-  videoCodec,
-  logLevel,
-  container
-}) => {
-  const canCopy = canCopyVideoTrack({
-    inputCodec: track.codecWithoutConfig,
-    outputCodec: videoCodec,
-    container
-  });
-  if (canCopy) {
-    Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
-    return Promise.resolve({ type: "copy" });
-  }
-  const canReencode = await canReencodeVideoTrack({ videoCodec, track });
-  if (canReencode) {
-    Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
-    return Promise.resolve({ type: "reencode", videoCodec });
-  }
-  Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore dropping`);
-  return Promise.resolve({ type: "drop" });
-};
-
 // src/video-decoder.ts
 var createVideoDecoder = ({
   onFrame: onFrame2,
@@ -747,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 () => {
@@ -775,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();
@@ -851,7 +994,7 @@ var makeVideoTrackHandler = ({
   abortConversion,
   convertMediaState,
   controller,
-  videoCodec,
+  defaultVideoCodec,
   onVideoTrack,
   logLevel,
   container
@@ -859,26 +1002,37 @@ var makeVideoTrackHandler = ({
   if (controller.signal.aborted) {
     throw new error_cause_default("Aborted");
   }
-  const videoOperation = await (onVideoTrack ?? defaultResolveVideoAction)({
+  const videoOperation = await (onVideoTrack ?? defaultOnVideoTrackHandler)({
     track,
-    videoCodec,
+    defaultVideoCodec,
     logLevel,
     container
   });
   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`);
+  }
   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(sample, videoTrack.trackNumber, true);
+      await state.addSample({
+        chunk: sample,
+        trackNumber: videoTrack.trackNumber,
+        isVideo: true,
+        timescale: track.timescale,
+        codecPrivate: track.codecPrivate
+      });
       convertMediaState.decodedVideoFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     };
@@ -886,7 +1040,8 @@ var makeVideoTrackHandler = ({
   const videoEncoderConfig = await getVideoEncoderConfig({
     codec: videoOperation.videoCodec,
     height: track.displayAspectHeight,
-    width: track.displayAspectWidth
+    width: track.displayAspectWidth,
+    fps: track.fps
   });
   const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
   if (videoEncoderConfig === null) {
@@ -902,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(convertEncodedChunk(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 });
     },
@@ -941,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);
@@ -971,13 +1137,10 @@ var convertMedia = async function({
   if (userPassedAbortSignal?.aborted) {
     return Promise.reject(new error_cause_default("Aborted"));
   }
-  if (container !== "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();
@@ -1008,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;
@@ -1023,7 +1187,8 @@ var convertMedia = async function({
         });
         onMediaStateUpdate?.(convertMediaState);
       }
-    }
+    },
+    logLevel
   });
   const onVideoTrack = makeVideoTrackHandler({
     state,
@@ -1032,14 +1197,14 @@ var convertMedia = async function({
     abortConversion,
     convertMediaState,
     controller,
-    videoCodec,
+    defaultVideoCodec: videoCodec ?? null,
     onVideoTrack: userVideoResolver ?? null,
     logLevel,
     container
   });
   const onAudioTrack = makeAudioTrackHandler({
     abortConversion,
-    audioCodec,
+    defaultAudioCodec: audioCodec ?? null,
     controller,
     convertMediaState,
     onMediaStateUpdate: onMediaStateUpdate ?? null,
@@ -1049,6 +1214,7 @@ var convertMedia = async function({
     container
   });
   parseMedia({
+    logLevel,
     src,
     onVideoTrack,
     onAudioTrack,
@@ -1087,8 +1253,13 @@ var convertMedia = async function({
   });
 };
 export {
+  getDefaultVideoCodec,
+  getDefaultAudioCodec,
   getAvailableVideoCodecs,
+  getAvailableContainers,
   getAvailableAudioCodecs,
+  defaultOnVideoTrackHandler,
+  defaultOnAudioTrackHandler,
   createVideoEncoder,
   createVideoDecoder,
   createAudioEncoder,