@remotion/webcodecs 4.0.228 → 4.0.229

package/dist/esm/index.mjs

@@ -290,6 +290,147 @@ var createAudioEncoder = ({
     }
   };
 };
+// src/can-copy-audio-track.ts
+var canCopyAudioTrack = ({
+  inputCodec,
+  outputCodec,
+  container
+}) => {
+  if (outputCodec === "opus") {
+    return inputCodec === "opus" && container === "webm";
+  }
+  throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+// src/can-copy-video-track.ts
+var canCopyVideoTrack = ({
+  inputCodec,
+  outputCodec,
+  container
+}) => {
+  if (outputCodec === "vp8") {
+    return inputCodec === "vp8" && container === "webm";
+  }
+  if (outputCodec === "vp9") {
+    return inputCodec === "vp9" && container === "webm";
+  }
+  throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+// 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 getAudioEncoderConfig = async (config) => {
+  if (typeof AudioEncoder === "undefined") {
+    return null;
+  }
+  if ((await AudioEncoder.isConfigSupported(config)).supported) {
+    return config;
+  }
+  return null;
+};
+
+// src/can-reencode-audio-track.ts
+var canReencodeAudioTrack = async ({
+  track,
+  audioCodec,
+  bitrate
+}) => {
+  const audioDecoderConfig = await getAudioDecoderConfig({
+    codec: track.codec,
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    description: track.description
+  });
+  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/video-encoder-config.ts
+var getVideoEncoderConfig = async ({
+  width,
+  height,
+  codec
+}) => {
+  if (typeof VideoEncoder === "undefined") {
+    return null;
+  }
+  const config = {
+    codec: 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
+  });
+  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;
 // src/convert-media.ts
 import {
   MediaParserInternals as MediaParserInternals2,
@@ -316,72 +457,58 @@ 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/audio-encoder-config.ts
-var getAudioEncoderConfig = async (config) => {
-  if (typeof AudioEncoder === "undefined") {
-    return null;
-  }
-  if ((await AudioEncoder.isConfigSupported(config)).supported) {
-    return config;
-  }
-  return null;
+// src/convert-encoded-chunk.ts
+var convertEncodedChunk = (chunk) => {
+  const arr = new Uint8Array(chunk.byteLength);
+  chunk.copyTo(arr);
+  return {
+    data: arr,
+    duration: chunk.duration ?? undefined,
+    timestamp: chunk.timestamp,
+    type: chunk.type
+  };
 };
 
 // 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
+var DEFAULT_BITRATE = 128000;
+var defaultResolveAudioAction = async ({
+  track,
+  audioCodec,
+  logLevel,
+  container
 }) => {
+  const bitrate = DEFAULT_BITRATE;
+  const canCopy = canCopyAudioTrack({
+    inputCodec: track.codecWithoutConfig,
+    outputCodec: audioCodec,
+    container
+  });
   if (canCopy) {
-    return "copy";
+    Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy = ${canCopy}, action = copy`);
+    return Promise.resolve({ type: "copy" });
   }
+  const canReencode = await canReencodeAudioTrack({
+    audioCodec,
+    track,
+    bitrate
+  });
   if (canReencode) {
-    return "reencode";
+    Log.verbose(logLevel, `Track ${track.trackId} (audio): Can re-encode = ${canReencode}, can copy = ${canCopy}, action = reencode`);
+    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;
+  Log.verbose(logLevel, `Track ${track.trackId} (audio): Can re-encode = ${canReencode}, can copy = ${canCopy}, action = drop`);
+  return Promise.resolve({ type: "drop" });
 };
 
 // src/on-audio-track.ts
@@ -393,32 +520,19 @@ var makeAudioTrackHandler = ({
   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,
+  const audioOperation = await (onAudioTrack ?? defaultResolveAudioAction)({
     audioCodec,
     track,
-    resolverFunction: onAudioTrack
+    logLevel,
+    container
   });
-  if (audioOperation === "drop") {
+  if (audioOperation.type === "drop") {
     return null;
   }
-  if (audioOperation === "copy") {
+  if (audioOperation.type === "copy") {
     const addedTrack = await state.addTrack({
       type: "audio",
       codec: audioCodec,
@@ -427,11 +541,23 @@ var makeAudioTrackHandler = ({
       codecPrivate: track.codecPrivate
     });
     return async (audioSample) => {
-      await state.addSample(new EncodedAudioChunk(audioSample), addedTrack.trackNumber, false);
+      await state.addSample(audioSample, addedTrack.trackNumber, false);
       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;
@@ -449,7 +575,7 @@ var makeAudioTrackHandler = ({
   });
   const audioEncoder = createAudioEncoder({
     onChunk: async (chunk) => {
-      await state.addSample(chunk, trackNumber, false);
+      await state.addSample(convertEncodedChunk(chunk), trackNumber, false);
       convertMediaState.encodedAudioFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     },
@@ -490,47 +616,71 @@ var makeAudioTrackHandler = ({
   };
 };
 
-// src/resolve-video-action.ts
-var canCopyVideoTrack = (inputCodec, outputCodec) => {
-  if (outputCodec === "vp8") {
-    return inputCodec === "vp8";
+// src/on-frame.ts
+var onFrame = async ({
+  frame,
+  onVideoFrame,
+  videoEncoder,
+  onMediaStateUpdate,
+  track,
+  convertMediaState
+}) => {
+  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 (outputCodec === "vp9") {
-    return inputCodec === "vp9";
+  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})`);
   }
-  throw new Error(`Unhandled codec: ${outputCodec}`);
-};
-var defaultResolveVideoAction = ({
-  canReencode,
-  canCopy
-}) => {
-  if (canCopy) {
-    return "copy";
+  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 (canReencode) {
-    return "reencode";
+  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();
   }
-  return "drop";
 };
-var resolveVideoAction = async ({
-  videoDecoderConfig,
-  videoEncoderConfig,
+
+// src/resolve-video-action.ts
+var defaultResolveVideoAction = async ({
   track,
   videoCodec,
-  resolverFunction
+  logLevel,
+  container
 }) => {
-  const canReencode = Boolean(videoDecoderConfig && videoEncoderConfig);
-  const canCopy = canCopyVideoTrack(track.codecWithoutConfig, videoCodec);
-  const resolved = await resolverFunction({
-    canReencode,
-    canCopy
+  const canCopy = canCopyVideoTrack({
+    inputCodec: track.codecWithoutConfig,
+    outputCodec: videoCodec,
+    container
   });
-  return resolved;
+  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,
+  onFrame: onFrame2,
   onError,
   signal,
   config,
@@ -549,7 +699,7 @@ var createVideoDecoder = ({
         if (signal.aborted) {
           return;
         }
-        return onFrame(inputFrame);
+        return onFrame2(inputFrame);
       }).then(() => {
         ioSynchronizer.onProcessed();
         signal.removeEventListener("abort", abortHandler);
@@ -608,28 +758,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,
@@ -715,28 +843,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,
@@ -747,28 +853,22 @@ var makeVideoTrackHandler = ({
   controller,
   videoCodec,
   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 ?? defaultResolveVideoAction)({
     track,
     videoCodec,
-    resolverFunction: onVideoTrack
+    logLevel,
+    container
   });
-  if (videoOperation === "drop") {
+  if (videoOperation.type === "drop") {
     return null;
   }
-  if (videoOperation === "copy") {
+  if (videoOperation.type === "copy") {
     const videoTrack = await state.addTrack({
       type: "video",
       color: track.color,
@@ -778,11 +878,17 @@ var makeVideoTrackHandler = ({
       codecPrivate: track.codecPrivate
     });
     return async (sample) => {
-      await state.addSample(new EncodedVideoChunk(sample), videoTrack.trackNumber, true);
+      await state.addSample(sample, videoTrack.trackNumber, true);
       convertMediaState.decodedVideoFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     };
   }
+  const videoEncoderConfig = await getVideoEncoderConfig({
+    codec: videoOperation.videoCodec,
+    height: track.displayAspectHeight,
+    width: track.displayAspectWidth
+  });
+  const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
   if (videoEncoderConfig === null) {
     abortConversion(new error_cause_default(`Could not configure video encoder of track ${track.trackId}`));
     return null;
@@ -801,7 +907,7 @@ var makeVideoTrackHandler = ({
   });
   const videoEncoder = createVideoEncoder({
     onChunk: async (chunk) => {
-      await state.addSample(chunk, trackNumber, true);
+      await state.addSample(convertEncodedChunk(chunk), trackNumber, true);
       convertMediaState.encodedVideoFrames++;
       onMediaStateUpdate?.({ ...convertMediaState });
     },
@@ -817,11 +923,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)`, {
@@ -848,7 +957,7 @@ var convertMedia = async function({
   onVideoFrame,
   onMediaStateUpdate: onMediaStateDoNoCallDirectly,
   audioCodec,
-  to,
+  container,
   videoCodec,
   signal: userPassedAbortSignal,
   onAudioTrack: userAudioResolver,
@@ -862,7 +971,7 @@ var convertMedia = async function({
   if (userPassedAbortSignal?.aborted) {
     return Promise.reject(new error_cause_default("Aborted"));
   }
-  if (to !== "webm") {
+  if (container !== "webm") {
     return Promise.reject(new TypeError('Only `to: "webm"` is supported currently'));
   }
   if (audioCodec !== "opus") {
@@ -890,7 +999,7 @@ var convertMedia = async function({
     encodedAudioFrames: 0,
     bytesWritten: 0,
     millisecondsWritten: 0,
-    expectedOutputMilliseconds: null,
+    expectedOutputDurationInMs: null,
     overallProgress: 0
   };
   const onMediaStateUpdate = (newState) => {
@@ -910,7 +1019,7 @@ var convertMedia = async function({
         convertMediaState.millisecondsWritten = millisecondsWritten;
         convertMediaState.overallProgress = calculateProgress({
           millisecondsWritten: convertMediaState.millisecondsWritten,
-          expectedOutputMilliseconds: convertMediaState.expectedOutputMilliseconds
+          expectedOutputDurationInMs: convertMediaState.expectedOutputDurationInMs
         });
         onMediaStateUpdate?.(convertMediaState);
       }
@@ -924,8 +1033,9 @@ var convertMedia = async function({
     convertMediaState,
     controller,
     videoCodec,
-    onVideoTrack: userVideoResolver ?? defaultResolveVideoAction,
-    logLevel
+    onVideoTrack: userVideoResolver ?? null,
+    logLevel,
+    container
   });
   const onAudioTrack = makeAudioTrackHandler({
     abortConversion,
@@ -934,9 +1044,9 @@ var convertMedia = async function({
     convertMediaState,
     onMediaStateUpdate: onMediaStateUpdate ?? null,
     state,
-    onAudioTrack: userAudioResolver ?? defaultResolveAudioAction,
-    bitrate: 128000,
-    logLevel
+    onAudioTrack: userAudioResolver ?? null,
+    logLevel,
+    container
   });
   parseMedia({
     src,
@@ -957,11 +1067,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 +1087,15 @@ var convertMedia = async function({
   });
 };
 export {
+  getAvailableVideoCodecs,
+  getAvailableAudioCodecs,
   createVideoEncoder,
   createVideoDecoder,
   createAudioEncoder,
   createAudioDecoder,
-  convertMedia
+  convertMedia,
+  canReencodeVideoTrack,
+  canReencodeAudioTrack,
+  canCopyVideoTrack,
+  canCopyAudioTrack
 };

package/dist/index.d.ts

@@ -1,5 +1,12 @@
 export { WebCodecsAudioDecoder, createAudioDecoder } from './audio-decoder';
 export { WebCodecsAudioEncoder, createAudioEncoder } from './audio-encoder';
-export { ConvertMediaState, ConvertMediaTo, convertMedia } from './convert-media';
+export { canCopyAudioTrack } from './can-copy-audio-track';
+export { canCopyVideoTrack } from './can-copy-video-track';
+export { canReencodeAudioTrack } from './can-reencode-audio-track';
+export { canReencodeVideoTrack } from './can-reencode-video-track';
+export { ConvertMediaAudioCodec, ConvertMediaVideoCodec, getAvailableAudioCodecs, getAvailableVideoCodecs, } from './codec-id';
+export { ConvertMediaContainer, ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaResult, ConvertMediaState, convertMedia, } from './convert-media';
+export { AudioOperation, ResolveAudioActionFn } from './resolve-audio-action';
+export { ResolveVideoActionFn, VideoOperation } from './resolve-video-action';
 export { WebCodecsVideoDecoder, createVideoDecoder } from './video-decoder';
 export { WebCodecsVideoEncoder, createVideoEncoder } from './video-encoder';