@remotion/webcodecs 4.0.305 → 4.0.308

package/dist/esm/index.mjs

@@ -432,63 +432,10 @@ var setRemotionImported = () => {
   }
 };
 
-// src/get-wave-audio-decoder.ts
-var getBytesPerSample = (sampleFormat) => {
-  if (sampleFormat === "s16") {
-    return 2;
-  }
-  if (sampleFormat === "s32") {
-    return 4;
-  }
-  if (sampleFormat === "f32") {
-    return 4;
-  }
-  if (sampleFormat === "u8") {
-    return 1;
-  }
-  if (sampleFormat === "f32-planar") {
-    return 4;
-  }
-  if (sampleFormat === "s16-planar") {
-    return 2;
-  }
-  if (sampleFormat === "s32-planar") {
-    return 4;
-  }
-  if (sampleFormat === "u8-planar") {
-    return 1;
-  }
-  throw new Error(`Unsupported sample format: ${sampleFormat}`);
-};
-var getWaveAudioDecoder = ({
-  onFrame,
-  track,
-  sampleFormat
-}) => {
-  let queue = Promise.resolve();
-  const processSample = async (audioSample) => {
-    const bytesPerSample = getBytesPerSample(sampleFormat);
-    await onFrame(new AudioData({
-      data: audioSample.data,
-      format: sampleFormat,
-      numberOfChannels: track.numberOfChannels,
-      numberOfFrames: audioSample.data.byteLength / bytesPerSample / track.numberOfChannels,
-      sampleRate: track.sampleRate,
-      timestamp: audioSample.timestamp
-    }));
-  };
-  return {
-    close() {
-      return Promise.resolve();
-    },
-    processSample(audioSample) {
-      queue = queue.then(() => processSample(audioSample));
-      return queue;
-    },
-    flush: () => Promise.resolve(),
-    waitForFinish: () => Promise.resolve()
-  };
-};
+// src/audio-encoder.ts
+import {
+  MediaParserAbortError
+} from "@remotion/media-parser";
 
 // src/create/event-emitter.ts
 class IoEventEmitter {
@@ -562,8 +509,10 @@ var makeTimeoutPromise = ({
   const onResume = () => {
     set();
   };
-  controller.addEventListener("pause", onPause);
-  controller.addEventListener("resume", onResume);
+  if (controller) {
+    controller.addEventListener("pause", onPause);
+    controller.addEventListener("resume", onResume);
+  }
   return {
     timeoutPromise: promise,
     clear: () => {
@@ -571,8 +520,10 @@ var makeTimeoutPromise = ({
         clearTimeout(timeout);
       }
       resolve();
-      controller.removeEventListener("pause", onPause);
-      controller.removeEventListener("resume", onResume);
+      if (controller) {
+        controller.removeEventListener("pause", onPause);
+        controller.removeEventListener("resume", onResume);
+      }
     }
   };
 };
@@ -581,39 +532,26 @@ var makeTimeoutPromise = ({
 var makeIoSynchronizer = ({
   logLevel,
   label,
-  progress
+  controller
 }) => {
   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 = () => {
+  const getQueuedItems = () => {
     inputs = inputs.filter((input) => Math.floor(input) > Math.floor(lastOutput));
     return inputs.length;
   };
-  const getUnemittedKeyframes = () => {
-    keyframes = keyframes.filter((keyframe) => Math.floor(keyframe) > Math.floor(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()}`);
+    Log.trace(logLevel, `[${label}] ${prefix}, state: Last input = ${lastInput} Last output = ${lastOutput} Inputs since last output = ${inputsSinceLastOutput}, Queue = ${getQueuedItems()}`);
   };
-  const inputItem = (timestamp, keyFrame) => {
+  const inputItem = (timestamp) => {
     lastInput = timestamp;
-    if (keyFrame) {
-      lastInputKeyframe = timestamp;
-      keyframes.push(timestamp);
-    }
     inputsSinceLastOutput++;
     inputs.push(timestamp);
     eventEmitter.dispatchEvent("input", {
-      timestamp,
-      keyFrame
+      timestamp
     });
     printState("Input item");
   };
@@ -623,7 +561,6 @@ var makeIoSynchronizer = ({
     eventEmitter.dispatchEvent("output", {
       timestamp
     });
-    _unprocessed++;
     printState("Got output");
   };
   const waitForOutput = () => {
@@ -635,184 +572,49 @@ var makeIoSynchronizer = ({
     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 makeErrorBanner = () => {
+    return [
+      `Waited too long for ${label} to finish:`,
+      `${getQueuedItems()} queued items`,
+      `inputs: ${JSON.stringify(inputs)}`,
+      `last output: ${lastOutput}`
+    ];
   };
-  const waitFor = async ({
-    unprocessed,
-    unemitted,
-    minimumProgress,
-    controller
-  }) => {
-    await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+  const waitForQueueSize = async (queueSize) => {
+    if (getQueuedItems() <= queueSize) {
+      return Promise.resolve();
+    }
     const { timeoutPromise, clear } = makeTimeoutPromise({
       label: () => [
-        `Waited too long for ${label} to finish:`,
-        `${getUnemittedItems()} unemitted items`,
-        `${getUnprocessed()} unprocessed items: ${JSON.stringify(_unprocessed)}`,
-        `smallest progress: ${progress.getSmallestProgress()}`,
-        `inputs: ${JSON.stringify(inputs)}`,
-        `last output: ${lastOutput}`,
-        `wanted: ${unemitted} unemitted items, ${unprocessed} unprocessed items, minimum progress ${minimumProgress}`,
+        ...makeErrorBanner(),
+        `wanted: <${queueSize} queued items`,
         `Report this at https://remotion.dev/report`
       ].join(`
 `),
       ms: 1e4,
       controller
     });
-    controller._internals._mediaParserController._internals.signal.addEventListener("abort", clear);
+    if (controller) {
+      controller._internals._mediaParserController._internals.signal.addEventListener("abort", clear);
+    }
     await Promise.race([
       timeoutPromise,
-      Promise.all([
-        (async () => {
-          while (getUnemittedItems() > unemitted) {
-            await waitForOutput();
-          }
-        })(),
-        (async () => {
-          while (getUnprocessed() > unprocessed) {
-            await waitForProcessed();
-          }
-        })(),
-        minimumProgress === null || progress.getSmallestProgress() === null ? Promise.resolve() : (async () => {
-          while (progress.getSmallestProgress() < minimumProgress) {
-            await progress.waitForProgress();
-          }
-        })()
-      ])
+      (async () => {
+        while (getQueuedItems() > queueSize) {
+          await waitForOutput();
+        }
+      })()
     ]).finally(() => clear());
-    controller._internals._mediaParserController._internals.signal.removeEventListener("abort", clear);
-  };
-  const waitForFinish = async (controller) => {
-    await waitFor({
-      unprocessed: 0,
-      unemitted: 0,
-      minimumProgress: null,
-      controller
-    });
-  };
-  const onProcessed = () => {
-    eventEmitter.dispatchEvent("processed", {});
-    _unprocessed--;
+    if (controller) {
+      controller._internals._mediaParserController._internals.signal.removeEventListener("abort", clear);
+    }
   };
   return {
     inputItem,
     onOutput,
-    waitFor,
-    waitForFinish,
-    onProcessed,
-    getUnprocessed
-  };
-};
-
-// src/audio-decoder.ts
-var createAudioDecoder = ({
-  onFrame,
-  onError,
-  controller,
-  config,
-  logLevel,
-  track,
-  progressTracker
-}) => {
-  if (controller._internals._mediaParserController._internals.signal.aborted) {
-    throw new Error("Not creating audio decoder, already aborted");
-  }
-  if (config.codec === "pcm-s16") {
-    return getWaveAudioDecoder({ onFrame, track, sampleFormat: "s16" });
-  }
-  const ioSynchronizer = makeIoSynchronizer({
-    logLevel,
-    label: "Audio decoder",
-    progress: progressTracker
-  });
-  let outputQueue = Promise.resolve();
-  const audioDecoder = new AudioDecoder({
-    output(frame) {
-      ioSynchronizer.onOutput(frame.timestamp + (frame.duration ?? 0));
-      const abortHandler = () => {
-        frame.close();
-      };
-      controller._internals._mediaParserController._internals.signal.addEventListener("abort", abortHandler, {
-        once: true
-      });
-      outputQueue = outputQueue.then(() => {
-        if (controller._internals._mediaParserController._internals.signal.aborted) {
-          return;
-        }
-        return onFrame(frame);
-      }).then(() => {
-        ioSynchronizer.onProcessed();
-        controller._internals._mediaParserController._internals.signal.removeEventListener("abort", abortHandler);
-        return Promise.resolve();
-      }).catch((err) => {
-        frame.close();
-        onError(err);
-      });
-    },
-    error(error) {
-      onError(error);
-    }
-  });
-  const close = () => {
-    controller._internals._mediaParserController._internals.signal.removeEventListener("abort", onAbort);
-    if (audioDecoder.state === "closed") {
-      return;
-    }
-    audioDecoder.close();
-  };
-  const onAbort = () => {
-    close();
-  };
-  controller._internals._mediaParserController._internals.signal.addEventListener("abort", onAbort);
-  audioDecoder.configure(config);
-  const processSample = async (audioSample) => {
-    if (audioDecoder.state === "closed") {
-      return;
-    }
-    progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, audioSample.decodingTimestamp ?? Infinity));
-    await ioSynchronizer.waitFor({
-      unemitted: 20,
-      unprocessed: 20,
-      minimumProgress: audioSample.timestamp - 1e7,
-      controller
-    });
-    const chunk = new EncodedAudioChunk(audioSample);
-    audioDecoder.decode(chunk);
-    if (chunk.byteLength > 16) {
-      ioSynchronizer.inputItem(chunk.timestamp, audioSample.type === "key");
-    }
-  };
-  let queue = Promise.resolve();
-  return {
-    processSample: (sample) => {
-      queue = queue.then(() => processSample(sample));
-      return queue;
-    },
-    waitForFinish: async () => {
-      try {
-        await audioDecoder.flush();
-      } catch {}
-      await queue;
-      await ioSynchronizer.waitForFinish(controller);
-      await outputQueue;
-    },
-    close,
-    flush: async () => {
-      await audioDecoder.flush();
-    }
+    waitForQueueSize
   };
 };
-// src/audio-encoder.ts
-import {
-  MediaParserAbortError
-} from "@remotion/media-parser";
 
 // src/audio-data/data-types.ts
 var getDataTypeForAudioFormat = (format) => {
@@ -928,13 +730,14 @@ var convertAudioData = ({
 var getWaveAudioEncoder = ({
   onChunk,
   controller,
-  config
+  config,
+  ioSynchronizer
 }) => {
   return {
     close: () => {
       return Promise.resolve();
     },
-    encodeFrame: (unconvertedAudioData) => {
+    encode: (unconvertedAudioData) => {
       if (controller._internals._mediaParserController._internals.signal.aborted) {
         return Promise.resolve();
       }
@@ -954,7 +757,8 @@ var getWaveAudioEncoder = ({
       return onChunk(chunk);
     },
     flush: () => Promise.resolve(),
-    waitForFinish: () => Promise.resolve()
+    waitForFinish: () => Promise.resolve(),
+    ioSynchronizer
   };
 };
 
@@ -966,39 +770,32 @@ var createAudioEncoder = ({
   controller,
   config: audioEncoderConfig,
   logLevel,
-  onNewAudioSampleRate,
-  progressTracker
+  onNewAudioSampleRate
 }) => {
   if (controller._internals._mediaParserController._internals.signal.aborted) {
     throw new MediaParserAbortError("Not creating audio encoder, already aborted");
   }
+  const ioSynchronizer = makeIoSynchronizer({
+    logLevel,
+    label: "Audio encoder",
+    controller
+  });
   if (codec === "wav") {
     return getWaveAudioEncoder({
       onChunk,
       controller,
-      config: audioEncoderConfig
+      config: audioEncoderConfig,
+      ioSynchronizer
     });
   }
-  const ioSynchronizer = makeIoSynchronizer({
-    logLevel,
-    label: "Audio encoder",
-    progress: progressTracker
-  });
-  let prom = Promise.resolve();
   const encoder = new AudioEncoder({
-    output: (chunk) => {
-      ioSynchronizer.onOutput(chunk.timestamp);
-      prom = prom.then(() => {
-        if (controller._internals._mediaParserController._internals.signal.aborted) {
-          return;
-        }
-        return onChunk(chunk);
-      }).then(() => {
-        ioSynchronizer.onProcessed();
-        return Promise.resolve();
-      }).catch((err) => {
+    output: async (chunk) => {
+      try {
+        await onChunk(chunk);
+      } catch (err) {
         onError(err);
-      });
+      }
+      ioSynchronizer.onOutput(chunk.timestamp);
     },
     error(error) {
       onError(error);
@@ -1019,17 +816,7 @@ var createAudioEncoder = ({
     throw new Error('Only `codec: "opus"` and `codec: "aac"` is supported currently');
   }
   const wantedSampleRate = audioEncoderConfig.sampleRate;
-  const encodeFrame = async (audioData) => {
-    if (encoder.state === "closed") {
-      return;
-    }
-    progressTracker.setPossibleLowestTimestamp(audioData.timestamp);
-    await ioSynchronizer.waitFor({
-      unemitted: 20,
-      unprocessed: 20,
-      minimumProgress: audioData.timestamp - 1e7,
-      controller
-    });
+  const encodeFrame = (audioData) => {
     if (encoder.state === "closed") {
       return;
     }
@@ -1045,31 +832,73 @@ var createAudioEncoder = ({
       }
     }
     encoder.encode(audioData);
-    ioSynchronizer.inputItem(audioData.timestamp, true);
+    ioSynchronizer.inputItem(audioData.timestamp);
   };
-  let queue = Promise.resolve();
   return {
-    encodeFrame: (audioData) => {
-      queue = queue.then(() => encodeFrame(audioData));
-      return queue;
+    encode: (audioData) => {
+      encodeFrame(audioData);
     },
     waitForFinish: async () => {
       await encoder.flush();
-      await ioSynchronizer.waitForFinish(controller);
-      await prom;
+      await ioSynchronizer.waitForQueueSize(0);
     },
     close,
     flush: async () => {
       await encoder.flush();
-    }
+    },
+    ioSynchronizer
   };
 };
+// src/is-different-video-codec.ts
+var isSameVideoCodec = ({
+  inputVideoCodec,
+  outputCodec
+}) => {
+  if (outputCodec === "h264") {
+    return inputVideoCodec === "h264";
+  }
+  if (outputCodec === "h265") {
+    return inputVideoCodec === "h265";
+  }
+  if (outputCodec === "vp8") {
+    return inputVideoCodec === "vp8";
+  }
+  if (outputCodec === "vp9") {
+    return inputVideoCodec === "vp9";
+  }
+  throw new Error(`Unsupported output codec: ${outputCodec}`);
+};
+var isSameAudioCodec = ({
+  inputAudioCodec,
+  outputCodec
+}) => {
+  if (outputCodec === "aac") {
+    return inputAudioCodec === "aac";
+  }
+  if (outputCodec === "opus") {
+    return inputAudioCodec === "opus";
+  }
+  if (outputCodec === "wav") {
+    return inputAudioCodec === "pcm-f32" || inputAudioCodec === "pcm-s16" || inputAudioCodec === "pcm-s24" || inputAudioCodec === "pcm-s32" || inputAudioCodec === "pcm-u8";
+  }
+  throw new Error(`Unsupported output codec: ${outputCodec}`);
+};
+
 // src/can-copy-audio-track.ts
 var canCopyAudioTrack = ({
   inputCodec,
   outputContainer,
-  inputContainer
+  inputContainer,
+  outputAudioCodec
 }) => {
+  if (outputAudioCodec) {
+    if (!isSameAudioCodec({
+      inputAudioCodec: inputCodec,
+      outputCodec: outputAudioCodec
+    })) {
+      return false;
+    }
+  }
   if (outputContainer === "webm") {
     return inputCodec === "opus";
   }
@@ -1087,11 +916,20 @@ var canCopyVideoTrack = ({
   rotationToApply,
   inputContainer,
   resizeOperation,
-  inputTrack
+  inputTrack,
+  outputVideoCodec
 }) => {
   if (normalizeVideoRotation(inputTrack.rotation) !== normalizeVideoRotation(rotationToApply)) {
     return false;
   }
+  if (outputVideoCodec) {
+    if (!isSameVideoCodec({
+      inputVideoCodec: inputTrack.codecEnum,
+      outputCodec: outputVideoCodec
+    })) {
+      return false;
+    }
+  }
   const newDimensions = calculateNewDimensionsFromRotateAndScale({
     height: inputTrack.height,
     resizeOperation,
@@ -4132,13 +3970,7 @@ var makeProgressTracker = () => {
       startingTimestamp = Math.min(startingTimestamp, timestamp);
     }
   };
-  const getStartingTimestamp = () => {
-    if (startingTimestamp === null) {
-      throw new Error("No starting timestamp");
-    }
-    return startingTimestamp;
-  };
-  const calculateSmallestProgress = () => {
+  const getSmallestProgress = () => {
     const progressValues = Object.values(trackNumberProgresses).map((p) => {
       if (p !== null) {
         return p;
@@ -4154,26 +3986,16 @@ var makeProgressTracker = () => {
     registerTrack: (trackNumber) => {
       trackNumberProgresses[trackNumber] = null;
     },
-    getSmallestProgress: calculateSmallestProgress,
+    getSmallestProgress,
     updateTrackProgress: (trackNumber, progress) => {
       if (trackNumberProgresses[trackNumber] === undefined) {
         throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
       }
       trackNumberProgresses[trackNumber] = progress;
       eventEmitter.dispatchEvent("progress", {
-        smallestProgress: calculateSmallestProgress()
+        smallestProgress: getSmallestProgress()
       });
     },
-    waitForProgress: () => {
-      const { promise, resolve } = withResolvers();
-      const on = () => {
-        eventEmitter.removeEventListener("progress", on);
-        resolve();
-      };
-      eventEmitter.addEventListener("progress", on);
-      return promise;
-    },
-    getStartingTimestamp,
     setPossibleLowestTimestamp
   };
 };
@@ -4209,22 +4031,37 @@ var getAvailableVideoCodecs = ({
   throw new Error(`Unsupported container: ${container}`);
 };
 
-// src/on-audio-track.ts
-import {
-  MediaParserInternals as MediaParserInternals7
-} from "@remotion/media-parser";
-
-// 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,
-    decodingTimestamp: chunk.timestamp,
-    offset: 0
+// src/copy-audio-track.ts
+var copyAudioTrack = async ({
+  state,
+  track,
+  logLevel,
+  onMediaStateUpdate,
+  progressTracker
+}) => {
+  const addedTrack = await state.addTrack({
+    type: "audio",
+    codec: track.codecEnum,
+    numberOfChannels: track.numberOfChannels,
+    sampleRate: track.sampleRate,
+    codecPrivate: track.codecData?.data ?? null,
+    timescale: track.originalTimescale
+  });
+  Log.verbose(logLevel, `Copying audio track ${track.trackId} as track ${addedTrack.trackNumber}. Timescale = ${track.originalTimescale}, codec = ${track.codecEnum} (${track.codec}) `);
+  return async (audioSample) => {
+    progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, audioSample.decodingTimestamp ?? Infinity));
+    await state.addSample({
+      chunk: audioSample,
+      trackNumber: addedTrack.trackNumber,
+      isVideo: false,
+      codecPrivate: track.codecData?.data ?? null
+    });
+    onMediaStateUpdate?.((prevState) => {
+      return {
+        ...prevState,
+        encodedAudioFrames: prevState.encodedAudioFrames + 1
+      };
+    });
   };
 };
 
@@ -4281,62 +4118,263 @@ var getDefaultAudioCodec = ({
   throw new Error(`Unhandled container: ${container}`);
 };
 
-// src/on-audio-track.ts
-var makeAudioTrackHandler = ({
-  state,
-  defaultAudioCodec: audioCodec,
-  controller,
-  abortConversion,
-  onMediaStateUpdate,
-  onAudioTrack,
-  logLevel,
-  outputContainer,
-  progressTracker,
-  onAudioData
-}) => async ({ track, container: inputContainer }) => {
-  const canCopyTrack = canCopyAudioTrack({
-    inputCodec: track.codecEnum,
-    outputContainer,
-    inputContainer
-  });
-  const audioOperation = await (onAudioTrack ?? defaultOnAudioTrackHandler)({
-    defaultAudioCodec: audioCodec ?? getDefaultAudioCodec({ container: outputContainer }),
-    track,
+// src/reencode-audio-track.ts
+import { MediaParserInternals as MediaParserInternals7 } from "@remotion/media-parser";
+
+// 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,
+    decodingTimestamp: chunk.timestamp,
+    offset: 0
+  };
+};
+
+// src/get-wave-audio-decoder.ts
+var getBytesPerSample = (sampleFormat) => {
+  if (sampleFormat === "s16") {
+    return 2;
+  }
+  if (sampleFormat === "s32") {
+    return 4;
+  }
+  if (sampleFormat === "f32") {
+    return 4;
+  }
+  if (sampleFormat === "u8") {
+    return 1;
+  }
+  if (sampleFormat === "f32-planar") {
+    return 4;
+  }
+  if (sampleFormat === "s16-planar") {
+    return 2;
+  }
+  if (sampleFormat === "s32-planar") {
+    return 4;
+  }
+  if (sampleFormat === "u8-planar") {
+    return 1;
+  }
+  throw new Error(`Unsupported sample format: ${sampleFormat}`);
+};
+var getAudioData = (audioSample) => {
+  if (audioSample instanceof EncodedAudioChunk) {
+    const data = new Uint8Array(audioSample.byteLength);
+    audioSample.copyTo(data);
+    return data;
+  }
+  return audioSample.data;
+};
+var getWaveAudioDecoder = ({
+  onFrame,
+  config,
+  sampleFormat,
+  ioSynchronizer,
+  onError
+}) => {
+  const processSample = async (audioSample) => {
+    const bytesPerSample = getBytesPerSample(sampleFormat);
+    const data = getAudioData(audioSample);
+    const audioData = new AudioData({
+      data,
+      format: sampleFormat,
+      numberOfChannels: config.numberOfChannels,
+      numberOfFrames: data.byteLength / bytesPerSample / config.numberOfChannels,
+      sampleRate: config.sampleRate,
+      timestamp: audioSample.timestamp
+    });
+    try {
+      await onFrame(audioData);
+    } catch (err) {
+      audioData.close();
+      onError(err);
+    }
+  };
+  return {
+    close() {
+      return Promise.resolve();
+    },
+    decode(audioSample) {
+      return processSample(audioSample);
+    },
+    flush: () => Promise.resolve(),
+    waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
+    reset: () => {}
+  };
+};
+
+// src/create-audio-decoder.ts
+var internalCreateAudioDecoder = ({
+  onFrame,
+  onError,
+  controller,
+  config,
+  logLevel
+}) => {
+  if (controller && controller._internals._mediaParserController._internals.signal.aborted) {
+    throw new Error("Not creating audio decoder, already aborted");
+  }
+  const ioSynchronizer = makeIoSynchronizer({
     logLevel,
-    outputContainer,
-    inputContainer,
-    canCopyTrack
+    label: "Audio decoder",
+    controller
   });
-  if (audioOperation.type === "drop") {
-    return null;
+  if (config.codec === "pcm-s16") {
+    return getWaveAudioDecoder({
+      onFrame,
+      config,
+      sampleFormat: "s16",
+      logLevel,
+      ioSynchronizer,
+      onError
+    });
   }
-  if (audioOperation.type === "fail") {
-    throw new Error(`Audio track with ID ${track.trackId} 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`);
+  const audioDecoder = new AudioDecoder({
+    async output(frame) {
+      try {
+        await onFrame(frame);
+      } catch (err) {
+        frame.close();
+        onError(err);
+      }
+      ioSynchronizer.onOutput(frame.timestamp + (frame.duration ?? 0));
+    },
+    error(error) {
+      onError(error);
+    }
+  });
+  const close = () => {
+    if (controller) {
+      controller._internals._mediaParserController._internals.signal.removeEventListener("abort", onAbort);
+    }
+    if (audioDecoder.state === "closed") {
+      return;
+    }
+    audioDecoder.close();
+  };
+  const onAbort = () => {
+    close();
+  };
+  if (controller) {
+    controller._internals._mediaParserController._internals.signal.addEventListener("abort", onAbort);
   }
-  if (audioOperation.type === "copy") {
-    const addedTrack = await state.addTrack({
-      type: "audio",
-      codec: track.codecEnum,
-      numberOfChannels: track.numberOfChannels,
-      sampleRate: track.sampleRate,
-      codecPrivate: track.codecData?.data ?? null,
-      timescale: track.originalTimescale
+  audioDecoder.configure(config);
+  const decode = async (audioSample) => {
+    if (audioDecoder.state === "closed") {
+      return;
+    }
+    try {
+      await controller?._internals._mediaParserController._internals.checkForAbortAndPause();
+    } catch (err) {
+      onError(err);
+      return;
+    }
+    const chunk = audioSample instanceof EncodedAudioChunk ? audioSample : new EncodedAudioChunk(audioSample);
+    audioDecoder.decode(chunk);
+    if (chunk.byteLength > 16) {
+      ioSynchronizer.inputItem(chunk.timestamp);
+    }
+  };
+  return {
+    decode,
+    close,
+    flush: async () => {
+      try {
+        await audioDecoder.flush();
+      } catch {}
+      await ioSynchronizer.waitForQueueSize(0);
+    },
+    waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
+    reset: () => {
+      audioDecoder.reset();
+      audioDecoder.configure(config);
+    }
+  };
+};
+var createAudioDecoder = ({
+  track,
+  onFrame,
+  onError,
+  controller,
+  logLevel
+}) => {
+  return internalCreateAudioDecoder({
+    onFrame,
+    onError,
+    controller: controller ?? null,
+    config: track,
+    logLevel: logLevel ?? "error"
+  });
+};
+
+// src/processing-queue.ts
+function processingQueue({
+  onOutput,
+  logLevel,
+  label,
+  onError,
+  controller
+}) {
+  const ioSynchronizer = makeIoSynchronizer({
+    logLevel,
+    label,
+    controller
+  });
+  let queue = Promise.resolve();
+  let stopped = false;
+  const input = (item) => {
+    if (stopped) {
+      return;
+    }
+    if (controller._internals._mediaParserController._internals.signal.aborted) {
+      stopped = true;
+      return;
+    }
+    const { timestamp } = item;
+    ioSynchronizer.inputItem(timestamp);
+    queue = queue.then(() => {
+      if (stopped) {
+        return;
+      }
+      if (controller._internals._mediaParserController._internals.signal.aborted) {
+        stopped = true;
+        return;
+      }
+      return onOutput(item);
+    }).then(() => {
+      ioSynchronizer.onOutput(timestamp);
+      return Promise.resolve();
+    }).catch((err) => {
+      stopped = true;
+      onError(err);
     });
-    Log.verbose(logLevel, `Copying audio track ${track.trackId} as track ${addedTrack.trackNumber}. Timescale = ${track.originalTimescale}, codec = ${track.codecEnum} (${track.codec}) `);
-    return async (audioSample) => {
-      await state.addSample({
-        chunk: audioSample,
-        trackNumber: addedTrack.trackNumber,
-        isVideo: false,
-        codecPrivate: track.codecData?.data ?? null
-      });
-      onMediaStateUpdate?.((prevState) => {
-        return {
-          ...prevState,
-          encodedAudioFrames: prevState.encodedAudioFrames + 1
-        };
-      });
-    };
+  };
+  return {
+    input,
+    ioSynchronizer
+  };
+}
+
+// src/reencode-audio-track.ts
+var reencodeAudioTrack = async ({
+  audioOperation,
+  track,
+  logLevel,
+  abortConversion,
+  state,
+  controller,
+  onMediaStateUpdate,
+  onAudioData,
+  progressTracker
+}) => {
+  if (audioOperation.type !== "reencode") {
+    throw new Error(`Audio track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(audioOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
   }
   const audioEncoderConfig = await getAudioEncoderConfig({
     numberOfChannels: track.numberOfChannels,
@@ -4400,11 +4438,18 @@ var makeAudioTrackHandler = ({
     codec: audioOperation.audioCodec,
     controller,
     config: audioEncoderConfig,
-    logLevel,
-    progressTracker
+    logLevel
   });
-  const audioDecoder = createAudioDecoder({
-    onFrame: async (audioData) => {
+  const audioProcessingQueue = processingQueue({
+    controller,
+    label: "AudioData processing queue",
+    logLevel,
+    onError(error) {
+      abortConversion(new Error(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
+        cause: error
+      }));
+    },
+    onOutput: async (audioData) => {
       const newAudioData = onAudioData ? await onAudioData?.({ audioData, track }) : audioData;
       if (newAudioData !== audioData) {
         if (newAudioData.duration !== audioData.duration) {
@@ -4424,7 +4469,10 @@ var makeAudioTrackHandler = ({
         }
         audioData.close();
       }
-      await audioEncoder.encodeFrame(newAudioData);
+      await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+      await audioEncoder.ioSynchronizer.waitForQueueSize(10);
+      await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+      audioEncoder.encode(newAudioData);
       onMediaStateUpdate?.((prevState) => {
         return {
           ...prevState,
@@ -4432,6 +4480,13 @@ var makeAudioTrackHandler = ({
         };
       });
       newAudioData.close();
+    }
+  });
+  const audioDecoder = internalCreateAudioDecoder({
+    onFrame: async (audioData) => {
+      await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+      await audioProcessingQueue.ioSynchronizer.waitForQueueSize(10);
+      audioProcessingQueue.input(audioData);
     },
     onError(error) {
       abortConversion(new Error(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
@@ -4440,24 +4495,114 @@ var makeAudioTrackHandler = ({
     },
     controller,
     config: audioDecoderConfig,
-    logLevel,
-    track,
-    progressTracker
+    logLevel
   });
   state.addWaitForFinishPromise(async () => {
-    await audioDecoder.waitForFinish();
-    await audioEncoder.waitForFinish();
+    await audioDecoder.waitForQueueToBeLessThan(0);
+    Log.verbose(logLevel, "Audio decoder finished");
     audioDecoder.close();
+    await audioProcessingQueue.ioSynchronizer.waitForQueueSize(0);
+    Log.verbose(logLevel, "Audio processing queue finished");
+    await audioEncoder.waitForFinish();
+    Log.verbose(logLevel, "Audio encoder finished");
     audioEncoder.close();
   });
   return async (audioSample) => {
-    await audioDecoder.processSample(audioSample);
+    progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, audioSample.decodingTimestamp ?? Infinity));
+    await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+    await audioDecoder.waitForQueueToBeLessThan(10);
+    audioDecoder.decode(audioSample);
   };
 };
 
-// src/arraybuffer-to-uint8-array.ts
-var arrayBufferToUint8Array = (buffer) => {
-  return buffer ? new Uint8Array(buffer) : null;
+// src/on-audio-track.ts
+var makeAudioTrackHandler = ({
+  state,
+  defaultAudioCodec: audioCodec,
+  controller,
+  abortConversion,
+  onMediaStateUpdate,
+  onAudioTrack,
+  logLevel,
+  outputContainer,
+  onAudioData,
+  progressTracker
+}) => async ({ track, container: inputContainer }) => {
+  const canCopyTrack = canCopyAudioTrack({
+    inputCodec: track.codecEnum,
+    outputContainer,
+    inputContainer,
+    outputAudioCodec: audioCodec
+  });
+  const audioOperation = await (onAudioTrack ?? defaultOnAudioTrackHandler)({
+    defaultAudioCodec: audioCodec ?? getDefaultAudioCodec({ container: outputContainer }),
+    track,
+    logLevel,
+    outputContainer,
+    inputContainer,
+    canCopyTrack
+  });
+  if (audioOperation.type === "drop") {
+    return null;
+  }
+  if (audioOperation.type === "fail") {
+    throw new Error(`Audio track with ID ${track.trackId} 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") {
+    return copyAudioTrack({
+      logLevel,
+      onMediaStateUpdate,
+      state,
+      track,
+      progressTracker
+    });
+  }
+  return reencodeAudioTrack({
+    abortConversion,
+    controller,
+    logLevel,
+    onMediaStateUpdate,
+    audioOperation,
+    onAudioData,
+    state,
+    track,
+    progressTracker
+  });
+};
+
+// src/copy-video-track.ts
+var copyVideoTrack = async ({
+  logLevel,
+  state,
+  track,
+  onMediaStateUpdate,
+  progressTracker
+}) => {
+  Log.verbose(logLevel, `Copying video track with codec ${track.codec} and timescale ${track.originalTimescale}`);
+  const videoTrack = await state.addTrack({
+    type: "video",
+    color: track.advancedColor,
+    width: track.codedWidth,
+    height: track.codedHeight,
+    codec: track.codecEnum,
+    codecPrivate: track.codecData?.data ?? null,
+    timescale: track.originalTimescale
+  });
+  return async (sample) => {
+    progressTracker.setPossibleLowestTimestamp(Math.min(sample.timestamp, sample.decodingTimestamp ?? Infinity));
+    await state.addSample({
+      chunk: sample,
+      trackNumber: videoTrack.trackNumber,
+      isVideo: true,
+      codecPrivate: track.codecData?.data ?? null
+    });
+    onMediaStateUpdate?.((prevState) => {
+      return {
+        ...prevState,
+        decodedVideoFrames: prevState.decodedVideoFrames + 1
+      };
+    });
+  };
 };
 
 // src/default-on-video-track-handler.ts
@@ -4496,21 +4641,115 @@ var defaultOnVideoTrackHandler = async ({
   MediaParserInternals8.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
   return Promise.resolve({ type: "fail" });
 };
-
-// src/get-default-video-codec.ts
-var getDefaultVideoCodec = ({
-  container
+
+// src/get-default-video-codec.ts
+var getDefaultVideoCodec = ({
+  container
+}) => {
+  if (container === "webm") {
+    return "vp8";
+  }
+  if (container === "mp4") {
+    return "h264";
+  }
+  if (container === "wav") {
+    return null;
+  }
+  throw new Error(`Unhandled container: ${container}`);
+};
+
+// src/arraybuffer-to-uint8-array.ts
+var arrayBufferToUint8Array = (buffer) => {
+  return buffer ? new Uint8Array(buffer) : null;
+};
+
+// src/create-video-decoder.ts
+var internalCreateVideoDecoder = ({
+  onFrame,
+  onError,
+  controller,
+  config,
+  logLevel
+}) => {
+  const ioSynchronizer = makeIoSynchronizer({
+    logLevel,
+    label: "Video decoder",
+    controller
+  });
+  const videoDecoder = new VideoDecoder({
+    async output(frame) {
+      try {
+        await onFrame(frame);
+      } catch (err) {
+        onError(err);
+        frame.close();
+      }
+      ioSynchronizer.onOutput(frame.timestamp);
+    },
+    error(error) {
+      onError(error);
+    }
+  });
+  const close = () => {
+    if (controller) {
+      controller._internals._mediaParserController._internals.signal.removeEventListener("abort", onAbort);
+    }
+    if (videoDecoder.state === "closed") {
+      return;
+    }
+    videoDecoder.close();
+  };
+  const onAbort = () => {
+    close();
+  };
+  if (controller) {
+    controller._internals._mediaParserController._internals.signal.addEventListener("abort", onAbort);
+  }
+  videoDecoder.configure(config);
+  const decode = async (sample) => {
+    if (videoDecoder.state === "closed") {
+      return;
+    }
+    try {
+      await controller?._internals._mediaParserController._internals.checkForAbortAndPause();
+    } catch (err) {
+      onError(err);
+      return;
+    }
+    const encodedChunk = sample instanceof EncodedVideoChunk ? sample : new EncodedVideoChunk(sample);
+    videoDecoder.decode(encodedChunk);
+    ioSynchronizer.inputItem(sample.timestamp);
+  };
+  return {
+    decode,
+    close,
+    flush: async () => {
+      try {
+        await videoDecoder.flush();
+      } catch {}
+      await ioSynchronizer.waitForQueueSize(0);
+    },
+    waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
+    reset: () => {
+      videoDecoder.reset();
+      videoDecoder.configure(config);
+    }
+  };
+};
+var createVideoDecoder = ({
+  onFrame,
+  onError,
+  controller,
+  track,
+  logLevel
 }) => {
-  if (container === "webm") {
-    return "vp8";
-  }
-  if (container === "mp4") {
-    return "h264";
-  }
-  if (container === "wav") {
-    return null;
-  }
-  throw new Error(`Unhandled container: ${container}`);
+  return internalCreateVideoDecoder({
+    onFrame,
+    onError,
+    controller: controller ?? null,
+    config: track,
+    logLevel: logLevel ?? "info"
+  });
 };
 
 // src/convert-to-correct-videoframe.ts
@@ -4553,7 +4792,6 @@ var convertToCorrectVideoFrame = ({
 var onFrame = async ({
   frame: unrotatedFrame,
   onVideoFrame,
-  videoEncoder,
   track,
   outputCodec,
   rotation,
@@ -4570,10 +4808,10 @@ var onFrame = async ({
   }
   const userProcessedFrame = onVideoFrame ? await onVideoFrame({ frame: rotated, track }) : rotated;
   if (userProcessedFrame.displayWidth !== rotated.displayWidth) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${userProcessedFrame.displayWidth}) than the input frame (${userProcessedFrame.displayHeight})`);
+    throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${userProcessedFrame.displayWidth}) than the input frame (${rotated.displayWidth})`);
   }
   if (userProcessedFrame.displayHeight !== rotated.displayHeight) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${userProcessedFrame.displayHeight}) than the input frame (${userProcessedFrame.displayHeight})`);
+    throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${userProcessedFrame.displayHeight}) than the input frame (${rotated.displayHeight})`);
   }
   if (userProcessedFrame.timestamp !== rotated.timestamp && !isSafari()) {
     throw new Error(`Returned VideoFrame of track ${track.trackId} has different timestamp (${userProcessedFrame.timestamp}) than the input frame (${rotated.timestamp}). When calling new VideoFrame(), pass {timestamp: frame.timestamp} as second argument`);
@@ -4581,32 +4819,31 @@ var onFrame = async ({
   if ((userProcessedFrame.duration ?? 0) !== (rotated.duration ?? 0)) {
     throw new Error(`Returned VideoFrame of track ${track.trackId} has different duration (${userProcessedFrame.duration}) than the input frame (${rotated.duration}). When calling new VideoFrame(), pass {duration: frame.duration} as second argument`);
   }
+  if (rotated !== userProcessedFrame) {
+    rotated.close();
+  }
   const fixedFrame = convertToCorrectVideoFrame({
     videoFrame: userProcessedFrame,
     outputCodec
   });
-  await videoEncoder.encodeFrame(fixedFrame, fixedFrame.timestamp);
-  fixedFrame.close();
-  if (rotated !== userProcessedFrame) {
-    rotated.close();
-  }
   if (fixedFrame !== userProcessedFrame) {
-    fixedFrame.close();
+    userProcessedFrame.close();
   }
+  return fixedFrame;
 };
 
 // src/sort-video-frames.ts
 var MAX_QUEUE_SIZE = 5;
 var videoFrameSorter = ({
-  onRelease,
-  controller
+  controller,
+  onOutput
 }) => {
   const frames = [];
   const releaseFrame = async () => {
     await controller._internals._mediaParserController._internals.checkForAbortAndPause();
     const frame = frames.shift();
     if (frame) {
-      await onRelease(frame);
+      await onOutput(frame);
     }
   };
   const sortFrames = () => {
@@ -4642,115 +4879,13 @@ var videoFrameSorter = ({
     controller._internals._mediaParserController._internals.signal.removeEventListener("abort", onAbort);
   };
   controller._internals._mediaParserController._internals.signal.addEventListener("abort", onAbort);
+  let promise = Promise.resolve();
   return {
-    inputFrame,
-    flush
-  };
-};
-
-// src/video-decoder.ts
-var createVideoDecoder = ({
-  onFrame: onFrame2,
-  onError,
-  controller,
-  config,
-  logLevel,
-  progress
-}) => {
-  const ioSynchronizer = makeIoSynchronizer({
-    logLevel,
-    label: "Video decoder",
-    progress
-  });
-  let outputQueue = Promise.resolve();
-  const addToQueue = (frame) => {
-    const cleanup = () => {
-      frame.close();
-    };
-    controller._internals._mediaParserController._internals.signal.addEventListener("abort", cleanup, {
-      once: true
-    });
-    outputQueue = outputQueue.then(() => {
-      if (controller._internals._mediaParserController._internals.signal.aborted) {
-        return;
-      }
-      return onFrame2(frame);
-    }).then(() => {
-      ioSynchronizer.onProcessed();
-    }).catch((err) => {
-      onError(err);
-    }).finally(() => {
-      controller._internals._mediaParserController._internals.signal.removeEventListener("abort", cleanup);
-      cleanup();
-    });
-    return outputQueue;
-  };
-  const frameSorter = videoFrameSorter({
-    controller,
-    onRelease: async (frame) => {
-      await addToQueue(frame);
-    }
-  });
-  const videoDecoder = new VideoDecoder({
-    output(frame) {
-      ioSynchronizer.onOutput(frame.timestamp);
-      frameSorter.inputFrame(frame);
-    },
-    error(error) {
-      onError(error);
-    }
-  });
-  const close = () => {
-    controller._internals._mediaParserController._internals.signal.removeEventListener("abort", onAbort);
-    if (videoDecoder.state === "closed") {
-      return;
-    }
-    videoDecoder.close();
-  };
-  const onAbort = () => {
-    close();
-  };
-  controller._internals._mediaParserController._internals.signal.addEventListener("abort", onAbort);
-  videoDecoder.configure(config);
-  const processSample = async (sample) => {
-    if (videoDecoder.state === "closed") {
-      return;
-    }
-    if (videoDecoder.state === "closed") {
-      return;
-    }
-    progress.setPossibleLowestTimestamp(Math.min(sample.timestamp, sample.decodingTimestamp ?? Infinity));
-    await ioSynchronizer.waitFor({
-      unemitted: 20,
-      unprocessed: 10,
-      minimumProgress: sample.timestamp - 1e7,
-      controller
-    });
-    videoDecoder.decode(new EncodedVideoChunk(sample));
-    ioSynchronizer.inputItem(sample.timestamp, sample.type === "key");
-  };
-  let inputQueue = Promise.resolve();
-  return {
-    processSample: (sample) => {
-      inputQueue = inputQueue.then(() => processSample(sample));
-      return inputQueue;
-    },
-    waitForFinish: async () => {
-      await videoDecoder.flush();
-      Log.verbose(logLevel, "Flushed video decoder");
-      await frameSorter.flush();
-      Log.verbose(logLevel, "Frame sorter flushed");
-      await ioSynchronizer.waitForFinish(controller);
-      Log.verbose(logLevel, "IO synchro finished");
-      await outputQueue;
-      Log.verbose(logLevel, "Output queue finished");
-      await inputQueue;
-      Log.verbose(logLevel, "Input queue finished");
+    inputFrame: (frame) => {
+      promise = promise.then(() => inputFrame(frame));
     },
-    close,
-    flush: async () => {
-      await videoDecoder.flush();
-    }
+    waitUntilProcessed: () => promise,
+    flush
   };
 };
 
@@ -4765,7 +4900,7 @@ var createVideoEncoder = ({
   config,
   logLevel,
   outputCodec,
-  progress
+  keyframeInterval
 }) => {
   if (controller._internals._mediaParserController._internals.signal.aborted) {
     throw new MediaParserAbortError2("Not creating video encoder, already aborted");
@@ -4773,27 +4908,20 @@ var createVideoEncoder = ({
   const ioSynchronizer = makeIoSynchronizer({
     logLevel,
     label: "Video encoder",
-    progress
+    controller
   });
-  let outputQueue = Promise.resolve();
   const encoder = new VideoEncoder({
     error(error) {
       onError(error);
     },
-    output(chunk, metadata) {
+    async output(chunk, metadata) {
       const timestamp = chunk.timestamp + (chunk.duration ?? 0);
-      ioSynchronizer.onOutput(timestamp);
-      outputQueue = outputQueue.then(() => {
-        if (controller._internals._mediaParserController._internals.signal.aborted) {
-          return;
-        }
-        return onChunk(chunk, metadata ?? null);
-      }).then(() => {
-        ioSynchronizer.onProcessed();
-        return Promise.resolve();
-      }).catch((err) => {
+      try {
+        await onChunk(chunk, metadata ?? null);
+      } catch (err) {
         onError(err);
-      });
+      }
+      ioSynchronizer.onOutput(timestamp);
     }
   });
   const close = () => {
@@ -4810,115 +4938,49 @@ var createVideoEncoder = ({
   Log.verbose(logLevel, "Configuring video encoder", config);
   encoder.configure(config);
   let framesProcessed = 0;
-  const encodeFrame = async (frame) => {
-    if (encoder.state === "closed") {
-      return;
-    }
-    progress.setPossibleLowestTimestamp(frame.timestamp);
-    await ioSynchronizer.waitFor({
-      unemitted: 10,
-      unprocessed: 10,
-      minimumProgress: frame.timestamp - 1e7,
-      controller
-    });
+  const encodeFrame = (frame) => {
     if (encoder.state === "closed") {
       return;
     }
-    const keyFrame = framesProcessed % 40 === 0;
+    const keyFrame = framesProcessed % keyframeInterval === 0;
     encoder.encode(convertToCorrectVideoFrame({ videoFrame: frame, outputCodec }), {
       keyFrame,
       vp9: {
         quantizer: 36
       }
     });
-    ioSynchronizer.inputItem(frame.timestamp, keyFrame);
+    ioSynchronizer.inputItem(frame.timestamp);
     framesProcessed++;
   };
-  let inputQueue = Promise.resolve();
   return {
-    encodeFrame: (frame) => {
-      inputQueue = inputQueue.then(() => encodeFrame(frame));
-      return inputQueue;
+    encode: (frame) => {
+      encodeFrame(frame);
     },
     waitForFinish: async () => {
       await encoder.flush();
-      await outputQueue;
-      await ioSynchronizer.waitForFinish(controller);
+      await ioSynchronizer.waitForQueueSize(0);
     },
     close,
     flush: async () => {
       await encoder.flush();
-    }
+    },
+    ioSynchronizer
   };
 };
 
-// src/on-video-track.ts
-var makeVideoTrackHandler = ({
-  state,
-  onVideoFrame,
-  onMediaStateUpdate,
+// src/reencode-video-track.ts
+var reencodeVideoTrack = async ({
+  videoOperation,
+  rotate,
+  track,
+  logLevel,
   abortConversion,
+  onMediaStateUpdate,
   controller,
-  defaultVideoCodec,
-  onVideoTrack,
-  logLevel,
-  outputContainer,
-  rotate,
-  progress,
-  resizeOperation
-}) => async ({ track, container: inputContainer }) => {
-  if (controller._internals._mediaParserController._internals.signal.aborted) {
-    throw new Error("Aborted");
-  }
-  const canCopyTrack = canCopyVideoTrack({
-    inputContainer,
-    outputContainer,
-    rotationToApply: rotate,
-    inputTrack: track,
-    resizeOperation
-  });
-  const videoOperation = await (onVideoTrack ?? defaultOnVideoTrackHandler)({
-    track,
-    defaultVideoCodec: defaultVideoCodec ?? getDefaultVideoCodec({ container: outputContainer }),
-    logLevel,
-    outputContainer,
-    rotate,
-    inputContainer,
-    canCopyTrack,
-    resizeOperation
-  });
-  if (videoOperation.type === "drop") {
-    return null;
-  }
-  if (videoOperation.type === "fail") {
-    throw new Error(`Video track with ID ${track.trackId} 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.originalTimescale}`);
-    const videoTrack = await state.addTrack({
-      type: "video",
-      color: track.advancedColor,
-      width: track.codedWidth,
-      height: track.codedHeight,
-      codec: track.codecEnum,
-      codecPrivate: track.codecData?.data ?? null,
-      timescale: track.originalTimescale
-    });
-    return async (sample) => {
-      await state.addSample({
-        chunk: sample,
-        trackNumber: videoTrack.trackNumber,
-        isVideo: true,
-        codecPrivate: track.codecData?.data ?? null
-      });
-      onMediaStateUpdate?.((prevState) => {
-        return {
-          ...prevState,
-          decodedVideoFrames: prevState.decodedVideoFrames + 1
-        };
-      });
-    };
-  }
+  onVideoFrame,
+  state,
+  progressTracker
+}) => {
   if (videoOperation.type !== "reencode") {
     throw new Error(`Video track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(videoOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
   }
@@ -4981,20 +5043,47 @@ var makeVideoTrackHandler = ({
     config: videoEncoderConfig,
     logLevel,
     outputCodec: videoOperation.videoCodec,
-    progress
+    keyframeInterval: 40
   });
-  const videoDecoder = createVideoDecoder({
-    config: videoDecoderConfig,
-    onFrame: async (frame) => {
-      await onFrame({
+  const videoProcessingQueue = processingQueue({
+    controller,
+    label: "VideoFrame processing queue",
+    logLevel,
+    onError: (err) => {
+      abortConversion(new Error(`VideoFrame processing queue of track ${track.trackId} failed (see .cause of this error)`, {
+        cause: err
+      }));
+    },
+    onOutput: async (frame) => {
+      await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+      const processedFrame = await onFrame({
         frame,
         track,
-        videoEncoder,
         onVideoFrame,
         outputCodec: videoOperation.videoCodec,
         rotation,
         resizeOperation: videoOperation.resize ?? null
       });
+      await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+      await videoEncoder.ioSynchronizer.waitForQueueSize(10);
+      await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+      videoEncoder.encode(processedFrame);
+      processedFrame.close();
+    }
+  });
+  const frameSorter = videoFrameSorter({
+    controller,
+    onOutput: async (frame) => {
+      await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+      await videoProcessingQueue.ioSynchronizer.waitForQueueSize(10);
+      videoProcessingQueue.input(frame);
+    }
+  });
+  const videoDecoder = createVideoDecoder({
+    track: videoDecoderConfig,
+    onFrame: async (frame) => {
+      await frameSorter.waitUntilProcessed();
+      frameSorter.inputFrame(frame);
     },
     onError: (err) => {
       abortConversion(new Error(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
@@ -5002,23 +5091,97 @@ var makeVideoTrackHandler = ({
       }));
     },
     controller,
-    logLevel,
-    progress
+    logLevel
   });
   state.addWaitForFinishPromise(async () => {
     Log.verbose(logLevel, "Waiting for video decoder to finish");
-    await videoDecoder.waitForFinish();
+    await videoDecoder.waitForQueueToBeLessThan(0);
     videoDecoder.close();
     Log.verbose(logLevel, "Video decoder finished. Waiting for encoder to finish");
+    await frameSorter.flush();
+    Log.verbose(logLevel, "Frame sorter flushed");
+    await videoProcessingQueue.ioSynchronizer.waitForQueueSize(0);
+    Log.verbose(logLevel, "Video processing queue finished");
     await videoEncoder.waitForFinish();
     videoEncoder.close();
-    Log.verbose(logLevel, "Encoder finished");
+    Log.verbose(logLevel, "Video encoder finished");
   });
   return async (chunk) => {
-    await videoDecoder.processSample(chunk);
+    progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, chunk.decodingTimestamp ?? Infinity));
+    await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+    await videoDecoder.waitForQueueToBeLessThan(10);
+    if (chunk.type === "key") {
+      await videoDecoder.flush();
+    }
+    videoDecoder.decode(chunk);
   };
 };
 
+// src/on-video-track.ts
+var makeVideoTrackHandler = ({
+  state,
+  onVideoFrame,
+  onMediaStateUpdate,
+  abortConversion,
+  controller,
+  defaultVideoCodec,
+  onVideoTrack,
+  logLevel,
+  outputContainer,
+  rotate,
+  resizeOperation,
+  progressTracker
+}) => async ({ track, container: inputContainer }) => {
+  if (controller._internals._mediaParserController._internals.signal.aborted) {
+    throw new Error("Aborted");
+  }
+  const canCopyTrack = canCopyVideoTrack({
+    inputContainer,
+    outputContainer,
+    rotationToApply: rotate,
+    inputTrack: track,
+    resizeOperation,
+    outputVideoCodec: defaultVideoCodec
+  });
+  const videoOperation = await (onVideoTrack ?? defaultOnVideoTrackHandler)({
+    track,
+    defaultVideoCodec: defaultVideoCodec ?? getDefaultVideoCodec({ container: outputContainer }),
+    logLevel,
+    outputContainer,
+    rotate,
+    inputContainer,
+    canCopyTrack,
+    resizeOperation
+  });
+  if (videoOperation.type === "drop") {
+    return null;
+  }
+  if (videoOperation.type === "fail") {
+    throw new Error(`Video track with ID ${track.trackId} 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") {
+    return copyVideoTrack({
+      logLevel,
+      onMediaStateUpdate,
+      state,
+      track,
+      progressTracker
+    });
+  }
+  return reencodeVideoTrack({
+    videoOperation,
+    abortConversion,
+    controller,
+    logLevel,
+    rotate,
+    track,
+    onVideoFrame,
+    state,
+    onMediaStateUpdate,
+    progressTracker
+  });
+};
+
 // src/send-telemetry-event.ts
 var import_licensing = __toESM(require_dist(), 1);
 var sendUsageEvent = async ({
@@ -5216,6 +5379,7 @@ var convertMedia = async function({
     expectedFrameRate: expectedFrameRate ?? null
   });
   const onVideoTrack = makeVideoTrackHandler({
+    progressTracker,
     state,
     onVideoFrame: onVideoFrame ?? null,
     onMediaStateUpdate: throttledState.update ?? null,
@@ -5226,10 +5390,10 @@ var convertMedia = async function({
     logLevel,
     outputContainer: container,
     rotate: rotate ?? 0,
-    progress: progressTracker,
     resizeOperation: resize ?? null
   });
   const onAudioTrack = makeAudioTrackHandler({
+    progressTracker,
     abortConversion,
     defaultAudioCodec: audioCodec ?? null,
     controller,
@@ -5238,7 +5402,6 @@ var convertMedia = async function({
     onAudioTrack: userAudioResolver ?? null,
     logLevel,
     outputContainer: container,
-    progressTracker,
     onAudioData: onAudioData ?? null
   });
   MediaParserInternals9.internalParseMedia({