@remotion/webcodecs 4.0.227 → 4.0.229

package/dist/esm/index.mjs

@@ -1,24 +1,175 @@
+// 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();
+  return {
+    getPromiseToImmediatelyReturn: () => {
+      resolveReturn(undefined);
+      return promise;
+    },
+    reject: (reason) => {
+      returnPromise.then(() => reject(reason));
+    },
+    resolve
+  };
+};
+
+// src/io-manager/event-emitter.ts
+class IoEventEmitter {
+  listeners = {
+    input: [],
+    output: [],
+    processed: []
+  };
+  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;
+  let lastInput = 0;
+  let lastInputKeyframe = 0;
+  let lastOutput = 0;
+  let inputsSinceLastOutput = 0;
+  let inputs = [];
+  let keyframes = [];
+  let unprocessed = 0;
+  const getUnprocessed = () => unprocessed;
+  const getUnemittedItems = () => {
+    inputs = inputs.filter((input) => input > lastOutput);
+    return inputs.length;
+  };
+  const getUnemittedKeyframes = () => {
+    keyframes = keyframes.filter((keyframe) => keyframe > lastOutput);
+    return keyframes.length;
+  };
+  const printState = (prefix) => {
+    Log.trace(logLevel, `[${label}] ${prefix}, state: Last input = ${lastInput} Last input keyframe = ${lastInputKeyframe} Last output = ${lastOutput} Inputs since last output = ${inputsSinceLastOutput}, Queue = ${getUnemittedItems()} (${getUnemittedKeyframes()} keyframes), Unprocessed = ${getUnprocessed()}`);
+  };
+  const inputItem = (timestamp, keyFrame) => {
+    lastInput = timestamp;
+    if (keyFrame) {
+      lastInputKeyframe = timestamp;
+      keyframes.push(timestamp);
+    }
+    inputsSinceLastOutput++;
+    inputs.push(timestamp);
+    eventEmitter.dispatchEvent("input", {
+      timestamp,
+      keyFrame
+    });
+    printState("Input item");
+  };
+  const onOutput = (timestamp) => {
+    lastOutput = timestamp;
+    inputsSinceLastOutput = 0;
+    eventEmitter.dispatchEvent("output", {
+      timestamp
+    });
+    unprocessed++;
+    printState("Got output");
+  };
+  const waitForOutput = () => {
+    const { promise, resolve } = withResolvers();
+    const on = () => {
+      eventEmitter.removeEventListener("output", on);
+      resolve();
+    };
+    eventEmitter.addEventListener("output", on);
+    return promise;
+  };
+  const waitForProcessed = () => {
+    const { promise, resolve } = withResolvers();
+    const on = () => {
+      eventEmitter.removeEventListener("processed", on);
+      resolve();
+    };
+    eventEmitter.addEventListener("processed", on);
+    return promise;
+  };
+  const waitFor = async ({
+    _unprocessed,
+    unemitted
+  }) => {
+    while (getUnemittedItems() > unemitted) {
+      await waitForOutput();
+    }
+    while (getUnprocessed() > _unprocessed) {
+      await waitForProcessed();
+    }
+  };
+  const waitForFinish = async () => {
+    await waitFor({ _unprocessed: 0, unemitted: 0 });
+  };
+  const onProcessed = () => {
+    eventEmitter.dispatchEvent("processed", {});
+    unprocessed--;
+  };
+  return {
+    inputItem,
+    onOutput,
+    waitFor,
+    waitForFinish,
+    onProcessed,
+    getUnprocessed
+  };
+};
+
 // src/audio-decoder.ts
 var createAudioDecoder = ({
   onFrame,
   onError,
   signal,
-  config
+  config,
+  logLevel
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating audio decoder, already aborted");
   }
+  const ioSynchronizer = makeIoSynchronizer(logLevel, "Audio decoder");
   let outputQueue = Promise.resolve();
-  let outputQueueSize = 0;
-  let dequeueResolver = () => {
-  };
   const audioDecoder = new AudioDecoder({
     output(inputFrame) {
-      outputQueueSize++;
-      outputQueue = outputQueue.then(() => onFrame(inputFrame)).then(() => {
-        dequeueResolver();
-        outputQueueSize--;
+      ioSynchronizer.onOutput(inputFrame.timestamp);
+      const abortHandler = () => {
+        inputFrame.close();
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      outputQueue = outputQueue.then(() => {
+        if (signal.aborted) {
+          return;
+        }
+        return onFrame(inputFrame);
+      }).then(() => {
+        ioSynchronizer.onProcessed();
+        signal.removeEventListener("abort", abortHandler);
         return Promise.resolve();
+      }).catch((err) => {
+        inputFrame.close();
+        onError(err);
       });
     },
     error(error) {
@@ -36,32 +187,15 @@ var createAudioDecoder = ({
     close();
   };
   signal.addEventListener("abort", onAbort);
-  const getQueueSize = () => {
-    return audioDecoder.decodeQueueSize + outputQueueSize;
-  };
   audioDecoder.configure(config);
-  const waitForDequeue = async () => {
-    await new Promise((r) => {
-      dequeueResolver = r;
-      audioDecoder.addEventListener("dequeue", () => r(), {
-        once: true
-      });
-    });
-  };
-  const waitForFinish = async () => {
-    while (getQueueSize() > 0) {
-      await waitForDequeue();
-    }
-  };
   const processSample = async (audioSample) => {
     if (audioDecoder.state === "closed") {
       return;
     }
-    while (getQueueSize() > 10) {
-      await waitForDequeue();
-    }
+    await ioSynchronizer.waitFor({ unemitted: 100, _unprocessed: 2 });
     const chunk = new EncodedAudioChunk(audioSample);
     audioDecoder.decode(chunk);
+    ioSynchronizer.inputItem(chunk.timestamp, audioSample.type === "key");
   };
   let queue = Promise.resolve();
   return {
@@ -71,11 +205,10 @@ var createAudioDecoder = ({
     },
     waitForFinish: async () => {
       await audioDecoder.flush();
-      await waitForFinish();
+      await ioSynchronizer.waitForFinish();
       await outputQueue;
     },
     close,
-    getQueueSize,
     flush: async () => {
       await audioDecoder.flush();
     }
@@ -87,22 +220,27 @@ var createAudioEncoder = ({
   onError,
   codec,
   signal,
-  config: audioEncoderConfig
+  config: audioEncoderConfig,
+  logLevel
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating audio encoder, already aborted");
   }
+  const ioSynchronizer = makeIoSynchronizer(logLevel, "Audio encoder");
   let prom = Promise.resolve();
-  let outputQueue = 0;
-  let dequeueResolver = () => {
-  };
   const encoder = new AudioEncoder({
     output: (chunk) => {
-      outputQueue++;
-      prom = prom.then(() => onChunk(chunk)).then(() => {
-        outputQueue--;
-        dequeueResolver();
+      ioSynchronizer.onOutput(chunk.timestamp);
+      prom = prom.then(() => {
+        if (signal.aborted) {
+          return;
+        }
+        return onChunk(chunk);
+      }).then(() => {
+        ioSynchronizer.onProcessed();
         return Promise.resolve();
+      }).catch((err) => {
+        onError(err);
       });
     },
     error(error) {
@@ -123,34 +261,17 @@ var createAudioEncoder = ({
   if (codec !== "opus") {
     throw new Error('Only `codec: "opus"` is supported currently');
   }
-  const getQueueSize = () => {
-    return encoder.encodeQueueSize + outputQueue;
-  };
   encoder.configure(audioEncoderConfig);
-  const waitForDequeue = async () => {
-    await new Promise((r) => {
-      dequeueResolver = r;
-      encoder.addEventListener("dequeue", () => r(), {
-        once: true
-      });
-    });
-  };
-  const waitForFinish = async () => {
-    while (getQueueSize() > 0) {
-      await waitForDequeue();
-    }
-  };
   const encodeFrame = async (audioData) => {
     if (encoder.state === "closed") {
       return;
     }
-    while (getQueueSize() > 10) {
-      await waitForDequeue();
-    }
+    await ioSynchronizer.waitFor({ unemitted: 2, _unprocessed: 2 });
     if (encoder.state === "closed") {
       return;
     }
     encoder.encode(audioData);
+    ioSynchronizer.inputItem(audioData.timestamp, true);
   };
   let queue = Promise.resolve();
   return {
@@ -160,32 +281,48 @@ var createAudioEncoder = ({
     },
     waitForFinish: async () => {
       await encoder.flush();
-      await waitForFinish();
+      await ioSynchronizer.waitForFinish();
       await prom;
     },
     close,
-    getQueueSize,
     flush: async () => {
       await encoder.flush();
     }
   };
 };
-// src/convert-media.ts
-import {
-  MediaParserInternals,
-  parseMedia
-} from "@remotion/media-parser";
-import { bufferWriter } from "@remotion/media-parser/buffer";
-import { canUseWebFsWriter, webFsWriter } from "@remotion/media-parser/web-fs";
-
-// src/error-cause.ts
-var error_cause_default = Error;
-
+// 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;
   }
@@ -203,39 +340,175 @@ var getAudioEncoderConfig = async (config) => {
   return null;
 };
 
-// src/resolve-audio-action.ts
-var canCopyAudioTrack = (inputCodec, outputCodec) => {
-  if (outputCodec === "opus") {
-    return inputCodec === "opus";
+// 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;
   }
-  throw new Error(`Unhandled codec: ${outputCodec}`);
+  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;
 };
-var defaultResolveAudioAction = ({
-  canReencode,
-  canCopy
+
+// src/can-reencode-video-track.ts
+var canReencodeVideoTrack = async ({
+  videoCodec,
+  track
 }) => {
-  if (canCopy) {
-    return "copy";
+  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,
+  parseMedia
+} from "@remotion/media-parser";
+
+// src/auto-select-writer.ts
+import { bufferWriter } from "@remotion/media-parser/buffer";
+import { canUseWebFsWriter, webFsWriter } from "@remotion/media-parser/web-fs";
+var autoSelectWriter = async (writer, logLevel) => {
+  if (writer) {
+    Log.verbose(logLevel, "Using writer provided by user");
+    return writer;
   }
-  if (canReencode) {
-    return "reencode";
+  Log.verbose(logLevel, "Determining best writer");
+  if (await canUseWebFsWriter()) {
+    Log.verbose(logLevel, "Using WebFS writer because it is supported");
+    return webFsWriter;
+  }
+  Log.verbose(logLevel, "Using buffer writer because WebFS writer is not supported");
+  return bufferWriter;
+};
+
+// src/calculate-progress.ts
+var calculateProgress = ({
+  millisecondsWritten,
+  expectedOutputDurationInMs
+}) => {
+  if (expectedOutputDurationInMs === null) {
+    return null;
   }
-  return "drop";
+  return millisecondsWritten / expectedOutputDurationInMs;
 };
-var resolveAudioAction = async ({
-  audioDecoderConfig,
-  audioEncoderConfig,
+
+// src/error-cause.ts
+var error_cause_default = Error;
+
+// 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 DEFAULT_BITRATE = 128000;
+var defaultResolveAudioAction = async ({
   track,
   audioCodec,
-  resolverFunction
+  logLevel,
+  container
 }) => {
-  const canReencode = Boolean(audioDecoderConfig && audioEncoderConfig);
-  const canCopy = canCopyAudioTrack(track.codecWithoutConfig, audioCodec);
-  const resolved = await resolverFunction({
-    canReencode,
-    canCopy
+  const bitrate = DEFAULT_BITRATE;
+  const canCopy = canCopyAudioTrack({
+    inputCodec: track.codecWithoutConfig,
+    outputCodec: audioCodec,
+    container
   });
-  return resolved;
+  if (canCopy) {
+    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) {
+    Log.verbose(logLevel, `Track ${track.trackId} (audio): Can re-encode = ${canReencode}, can copy = ${canCopy}, action = reencode`);
+    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" });
 };
 
 // src/on-audio-track.ts
@@ -247,31 +520,19 @@ var makeAudioTrackHandler = ({
   abortConversion,
   onMediaStateUpdate,
   onAudioTrack,
-  bitrate
+  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,
@@ -280,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;
@@ -302,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 });
     },
@@ -313,7 +586,8 @@ var makeAudioTrackHandler = ({
     },
     codec: audioCodec,
     signal: controller.signal,
-    config: audioEncoderConfig
+    config: audioEncoderConfig,
+    logLevel
   });
   const audioDecoder = createAudioDecoder({
     onFrame: async (frame) => {
@@ -328,7 +602,8 @@ var makeAudioTrackHandler = ({
       }));
     },
     signal: controller.signal,
-    config: audioDecoderConfig
+    config: audioDecoderConfig,
+    logLevel
   });
   state.addWaitForFinishPromise(async () => {
     await audioDecoder.waitForFinish();
@@ -341,62 +616,97 @@ 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
+  config,
+  logLevel
 }) => {
+  const ioSynchronizer = makeIoSynchronizer(logLevel, "Video decoder");
   let outputQueue = Promise.resolve();
-  let outputQueueSize = 0;
-  let dequeueResolver = () => {
-  };
   const videoDecoder = new VideoDecoder({
     output(inputFrame) {
-      outputQueueSize++;
-      outputQueue = outputQueue.then(() => onFrame(inputFrame)).then(() => {
-        outputQueueSize--;
-        dequeueResolver();
+      ioSynchronizer.onOutput(inputFrame.timestamp);
+      const abortHandler = () => {
+        inputFrame.close();
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      outputQueue = outputQueue.then(() => {
+        if (signal.aborted) {
+          return;
+        }
+        return onFrame2(inputFrame);
+      }).then(() => {
+        ioSynchronizer.onProcessed();
+        signal.removeEventListener("abort", abortHandler);
         return Promise.resolve();
+      }).catch((err) => {
+        inputFrame.close();
+        onError(err);
       });
     },
     error(error) {
@@ -414,37 +724,20 @@ var createVideoDecoder = ({
     close();
   };
   signal.addEventListener("abort", onAbort);
-  const getQueueSize = () => {
-    return videoDecoder.decodeQueueSize + outputQueueSize;
-  };
   videoDecoder.configure(config);
-  const waitForDequeue = async () => {
-    await new Promise((r) => {
-      dequeueResolver = r;
-      videoDecoder.addEventListener("dequeue", () => r(), {
-        once: true
-      });
-    });
-  };
-  const waitForFinish = async () => {
-    while (getQueueSize() > 0) {
-      await waitForDequeue();
-    }
-  };
   const processSample = async (sample) => {
     if (videoDecoder.state === "closed") {
       return;
     }
-    while (getQueueSize() > 10) {
-      await waitForDequeue();
-    }
     if (videoDecoder.state === "closed") {
       return;
     }
+    await ioSynchronizer.waitFor({ unemitted: 20, _unprocessed: 2 });
     if (sample.type === "key") {
       await videoDecoder.flush();
     }
     videoDecoder.decode(new EncodedVideoChunk(sample));
+    ioSynchronizer.inputItem(sample.timestamp, sample.type === "key");
   };
   let inputQueue = Promise.resolve();
   return {
@@ -454,64 +747,50 @@ var createVideoDecoder = ({
     },
     waitForFinish: async () => {
       await videoDecoder.flush();
-      await waitForFinish();
+      await ioSynchronizer.waitForFinish();
       await outputQueue;
       await inputQueue;
     },
     close,
-    getQueueSize,
     flush: async () => {
       await videoDecoder.flush();
     }
   };
 };
 
-// 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,
   onError,
   signal,
-  config
+  config,
+  logLevel
 }) => {
   if (signal.aborted) {
     throw new Error("Not creating video encoder, already aborted");
   }
+  const ioSynchronizer = makeIoSynchronizer(logLevel, "Video encoder");
   let outputQueue = Promise.resolve();
-  let outputQueueSize = 0;
-  let dequeueResolver = () => {
-  };
   const encoder = new VideoEncoder({
     error(error) {
       onError(error);
     },
     output(chunk) {
-      outputQueueSize++;
-      outputQueue = outputQueue.then(() => onChunk(chunk)).then(() => {
-        outputQueueSize--;
-        dequeueResolver();
+      if (chunk.duration === null) {
+        throw new Error("Duration is null");
+      }
+      const timestamp = chunk.timestamp + chunk.duration;
+      ioSynchronizer.onOutput(timestamp);
+      outputQueue = outputQueue.then(() => {
+        if (signal.aborted) {
+          return;
+        }
+        return onChunk(chunk);
+      }).then(() => {
+        ioSynchronizer.onProcessed();
         return Promise.resolve();
+      }).catch((err) => {
+        onError(err);
       });
     }
   });
@@ -526,37 +805,24 @@ var createVideoEncoder = ({
     close();
   };
   signal.addEventListener("abort", onAbort);
-  const getQueueSize = () => {
-    return encoder.encodeQueueSize + outputQueueSize;
-  };
   encoder.configure(config);
   let framesProcessed = 0;
-  const waitForDequeue = async () => {
-    await new Promise((r) => {
-      dequeueResolver = r;
-      encoder.addEventListener("dequeue", () => r(), {
-        once: true
-      });
-    });
-  };
-  const waitForFinish = async () => {
-    while (getQueueSize() > 0) {
-      await waitForDequeue();
-    }
-  };
   const encodeFrame = async (frame) => {
     if (encoder.state === "closed") {
       return;
     }
-    while (getQueueSize() > 10) {
-      await waitForDequeue();
-    }
+    await ioSynchronizer.waitFor({
+      unemitted: 2,
+      _unprocessed: 2
+    });
     if (encoder.state === "closed") {
       return;
     }
+    const keyFrame = framesProcessed % 40 === 0;
     encoder.encode(frame, {
-      keyFrame: framesProcessed % 40 === 0
+      keyFrame
     });
+    ioSynchronizer.inputItem(frame.timestamp, keyFrame);
     framesProcessed++;
   };
   let inputQueue = Promise.resolve();
@@ -568,38 +834,15 @@ var createVideoEncoder = ({
     waitForFinish: async () => {
       await encoder.flush();
       await outputQueue;
-      await waitForFinish();
+      await ioSynchronizer.waitForFinish();
     },
     close,
-    getQueueSize,
     flush: async () => {
       await encoder.flush();
     }
   };
 };
 
-// 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,
@@ -609,25 +852,23 @@ var makeVideoTrackHandler = ({
   convertMediaState,
   controller,
   videoCodec,
-  onVideoTrack
+  onVideoTrack,
+  logLevel,
+  container
 }) => async (track) => {
-  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,
+  if (controller.signal.aborted) {
+    throw new error_cause_default("Aborted");
+  }
+  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,
@@ -636,12 +877,18 @@ var makeVideoTrackHandler = ({
       codec: track.codecWithoutConfig,
       codecPrivate: track.codecPrivate
     });
-    return (sample) => {
-      state.addSample(new EncodedVideoChunk(sample), videoTrack.trackNumber, true);
+    return async (sample) => {
+      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;
@@ -660,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 });
     },
@@ -670,23 +917,28 @@ var makeVideoTrackHandler = ({
       }));
     },
     signal: controller.signal,
-    config: videoEncoderConfig
+    config: videoEncoderConfig,
+    logLevel
   });
   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)`, {
         cause: err
       }));
     },
-    signal: controller.signal
+    signal: controller.signal,
+    logLevel
   });
   state.addWaitForFinishPromise(async () => {
     await videoDecoder.waitForFinish();
@@ -699,30 +951,27 @@ var makeVideoTrackHandler = ({
   };
 };
 
-// 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 };
-};
-
 // src/convert-media.ts
-var convertMedia = async ({
+var convertMedia = async function({
   src,
   onVideoFrame,
-  onMediaStateUpdate,
+  onMediaStateUpdate: onMediaStateDoNoCallDirectly,
   audioCodec,
-  to,
+  container,
   videoCodec,
   signal: userPassedAbortSignal,
   onAudioTrack: userAudioResolver,
-  onVideoTrack: userVideoResolver
-}) => {
-  if (to !== "webm") {
+  onVideoTrack: userVideoResolver,
+  reader,
+  fields,
+  logLevel = "info",
+  writer,
+  ...more
+}) {
+  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 (audioCodec !== "opus") {
@@ -731,7 +980,7 @@ var convertMedia = async ({
   if (videoCodec !== "vp8" && videoCodec !== "vp9") {
     return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
   }
-  const { promise, resolve, reject } = withResolvers();
+  const { resolve, reject, getPromiseToImmediatelyReturn } = withResolversAndWaitForReturn();
   const controller = new AbortController;
   const abortConversion = (errCause) => {
     reject(errCause);
@@ -747,10 +996,35 @@ var convertMedia = async ({
     decodedAudioFrames: 0,
     decodedVideoFrames: 0,
     encodedVideoFrames: 0,
-    encodedAudioFrames: 0
+    encodedAudioFrames: 0,
+    bytesWritten: 0,
+    millisecondsWritten: 0,
+    expectedOutputDurationInMs: null,
+    overallProgress: 0
   };
-  const canUseWebFs = await canUseWebFsWriter();
-  const state = await MediaParserInternals.createMedia(canUseWebFs ? webFsWriter : bufferWriter);
+  const onMediaStateUpdate = (newState) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    onMediaStateDoNoCallDirectly?.(newState);
+  };
+  const state = await MediaParserInternals2.createMedia({
+    writer: await autoSelectWriter(writer, logLevel),
+    onBytesProgress: (bytesWritten) => {
+      convertMediaState.bytesWritten = bytesWritten;
+      onMediaStateUpdate?.(convertMediaState);
+    },
+    onMillisecondsProgress: (millisecondsWritten) => {
+      if (millisecondsWritten > convertMediaState.millisecondsWritten) {
+        convertMediaState.millisecondsWritten = millisecondsWritten;
+        convertMediaState.overallProgress = calculateProgress({
+          millisecondsWritten: convertMediaState.millisecondsWritten,
+          expectedOutputDurationInMs: convertMediaState.expectedOutputDurationInMs
+        });
+        onMediaStateUpdate?.(convertMediaState);
+      }
+    }
+  });
   const onVideoTrack = makeVideoTrackHandler({
     state,
     onVideoFrame: onVideoFrame ?? null,
@@ -759,7 +1033,9 @@ var convertMedia = async ({
     convertMediaState,
     controller,
     videoCodec,
-    onVideoTrack: userVideoResolver ?? defaultResolveVideoAction
+    onVideoTrack: userVideoResolver ?? null,
+    logLevel,
+    container
   });
   const onAudioTrack = makeAudioTrackHandler({
     abortConversion,
@@ -768,29 +1044,58 @@ var convertMedia = async ({
     convertMediaState,
     onMediaStateUpdate: onMediaStateUpdate ?? null,
     state,
-    onAudioTrack: userAudioResolver ?? defaultResolveAudioAction,
-    bitrate: 128000
+    onAudioTrack: userAudioResolver ?? null,
+    logLevel,
+    container
   });
   parseMedia({
     src,
     onVideoTrack,
     onAudioTrack,
-    signal: controller.signal
+    signal: controller.signal,
+    fields: {
+      ...fields,
+      durationInSeconds: true
+    },
+    reader,
+    ...more,
+    onDurationInSeconds: (durationInSeconds) => {
+      if (durationInSeconds === null) {
+        return null;
+      }
+      const casted = more;
+      if (casted.onDurationInSeconds) {
+        casted.onDurationInSeconds(durationInSeconds);
+      }
+      const expectedOutputDurationInMs = durationInSeconds * 1000;
+      convertMediaState.expectedOutputDurationInMs = expectedOutputDurationInMs;
+      convertMediaState.overallProgress = calculateProgress({
+        millisecondsWritten: convertMediaState.millisecondsWritten,
+        expectedOutputDurationInMs
+      });
+      onMediaStateUpdate(convertMediaState);
+    }
   }).then(() => {
     return state.waitForFinish();
   }).then(() => {
     resolve({ save: state.save, remove: state.remove });
   }).catch((err) => {
     reject(err);
-  }).finally(() => {
+  });
+  return getPromiseToImmediatelyReturn().finally(() => {
     userPassedAbortSignal?.removeEventListener("abort", onUserAbort);
   });
-  return promise;
 };
 export {
+  getAvailableVideoCodecs,
+  getAvailableAudioCodecs,
   createVideoEncoder,
   createVideoDecoder,
   createAudioEncoder,
   createAudioDecoder,
-  convertMedia
+  convertMedia,
+  canReencodeVideoTrack,
+  canReencodeAudioTrack,
+  canCopyVideoTrack,
+  canCopyAudioTrack
 };