@remotion/webcodecs 4.0.306 → 4.0.308

package/dist/esm/index.mjs

@@ -432,70 +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,
-  config,
-  sampleFormat,
-  ioSynchronizer,
-  onError
-}) => {
-  const processSample = async (audioSample) => {
-    const bytesPerSample = getBytesPerSample(sampleFormat);
-    const audioData = new AudioData({
-      data: audioSample.data,
-      format: sampleFormat,
-      numberOfChannels: config.numberOfChannels,
-      numberOfFrames: audioSample.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) {
-      processSample(audioSample);
-    },
-    flush: () => Promise.resolve(),
-    waitForFinish: () => Promise.resolve(),
-    waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize
-  };
-};
+// src/audio-encoder.ts
+import {
+  MediaParserAbortError
+} from "@remotion/media-parser";
 
 // src/create/event-emitter.ts
 class IoEventEmitter {
@@ -669,120 +609,13 @@ var makeIoSynchronizer = ({
       controller._internals._mediaParserController._internals.signal.removeEventListener("abort", clear);
     }
   };
-  const waitForFinish = async () => {
-    await waitForQueueSize(0);
-  };
   return {
     inputItem,
     onOutput,
-    waitForFinish,
     waitForQueueSize
   };
 };
 
-// src/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,
-    label: "Audio decoder",
-    controller
-  });
-  if (config.codec === "pcm-s16") {
-    return getWaveAudioDecoder({
-      onFrame,
-      config,
-      sampleFormat: "s16",
-      logLevel,
-      ioSynchronizer,
-      onError
-    });
-  }
-  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);
-  }
-  audioDecoder.configure(config);
-  const processSample = (audioSample) => {
-    if (audioDecoder.state === "closed") {
-      return;
-    }
-    const chunk = audioSample instanceof EncodedAudioChunk ? audioSample : new EncodedAudioChunk(audioSample);
-    audioDecoder.decode(chunk);
-    if (chunk.byteLength > 16) {
-      ioSynchronizer.inputItem(chunk.timestamp);
-    }
-  };
-  return {
-    decode: (sample) => {
-      processSample(sample);
-    },
-    waitForFinish: async () => {
-      try {
-        await audioDecoder.flush();
-      } catch {}
-      await ioSynchronizer.waitForFinish();
-    },
-    close,
-    flush: async () => {
-      await audioDecoder.flush();
-    },
-    waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize
-  };
-};
-var createAudioDecoder = ({
-  onFrame,
-  onError,
-  controller,
-  track,
-  logLevel
-}) => {
-  return internalCreateAudioDecoder({
-    onFrame,
-    onError,
-    controller: controller ?? null,
-    config: track,
-    logLevel: logLevel ?? "error"
-  });
-};
-// src/audio-encoder.ts
-import {
-  MediaParserAbortError
-} from "@remotion/media-parser";
-
 // src/audio-data/data-types.ts
 var getDataTypeForAudioFormat = (format) => {
   switch (format) {
@@ -1007,7 +840,7 @@ var createAudioEncoder = ({
     },
     waitForFinish: async () => {
       await encoder.flush();
-      await ioSynchronizer.waitForFinish();
+      await ioSynchronizer.waitForQueueSize(0);
     },
     close,
     flush: async () => {
@@ -1016,12 +849,56 @@ var createAudioEncoder = ({
     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";
   }
@@ -1039,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,
@@ -4249,6 +4135,184 @@ var convertEncodedChunk = (chunk) => {
   };
 };
 
+// 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,
+    label: "Audio decoder",
+    controller
+  });
+  if (config.codec === "pcm-s16") {
+    return getWaveAudioDecoder({
+      onFrame,
+      config,
+      sampleFormat: "s16",
+      logLevel,
+      ioSynchronizer,
+      onError
+    });
+  }
+  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);
+  }
+  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,
@@ -4434,10 +4498,10 @@ var reencodeAudioTrack = async ({
     logLevel
   });
   state.addWaitForFinishPromise(async () => {
-    await audioDecoder.waitForFinish();
+    await audioDecoder.waitForQueueToBeLessThan(0);
     Log.verbose(logLevel, "Audio decoder finished");
     audioDecoder.close();
-    await audioProcessingQueue.ioSynchronizer.waitForFinish();
+    await audioProcessingQueue.ioSynchronizer.waitForQueueSize(0);
     Log.verbose(logLevel, "Audio processing queue finished");
     await audioEncoder.waitForFinish();
     Log.verbose(logLevel, "Audio encoder finished");
@@ -4467,7 +4531,8 @@ var makeAudioTrackHandler = ({
   const canCopyTrack = canCopyAudioTrack({
     inputCodec: track.codecEnum,
     outputContainer,
-    inputContainer
+    inputContainer,
+    outputAudioCodec: audioCodec
   });
   const audioOperation = await (onAudioTrack ?? defaultOnAudioTrackHandler)({
     defaultAudioCodec: audioCodec ?? getDefaultAudioCodec({ container: outputContainer }),
@@ -4598,6 +4663,95 @@ 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
+}) => {
+  return internalCreateVideoDecoder({
+    onFrame,
+    onError,
+    controller: controller ?? null,
+    config: track,
+    logLevel: logLevel ?? "info"
+  });
+};
+
 // src/convert-to-correct-videoframe.ts
 var needsToCorrectVideoFrame = ({
   videoFrame,
@@ -4735,88 +4889,6 @@ var videoFrameSorter = ({
   };
 };
 
-// src/video-decoder.ts
-var internalCreateVideoDecoder = ({
-  onFrame: onFrame2,
-  onError,
-  controller,
-  config,
-  logLevel
-}) => {
-  const ioSynchronizer = makeIoSynchronizer({
-    logLevel,
-    label: "Video decoder",
-    controller
-  });
-  const videoDecoder = new VideoDecoder({
-    async output(frame) {
-      try {
-        await onFrame2(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 = (sample) => {
-    if (videoDecoder.state === "closed") {
-      return;
-    }
-    const encodedChunk = sample instanceof EncodedVideoChunk ? sample : new EncodedVideoChunk(sample);
-    videoDecoder.decode(encodedChunk);
-    ioSynchronizer.inputItem(sample.timestamp);
-  };
-  return {
-    decode,
-    waitForFinish: async () => {
-      await videoDecoder.flush();
-      Log.verbose(logLevel, "Flushed video decoder");
-      await ioSynchronizer.waitForFinish();
-      Log.verbose(logLevel, "IO synchro finished");
-    },
-    close,
-    flush: async () => {
-      await videoDecoder.flush();
-    },
-    waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize
-  };
-};
-var createVideoDecoder = ({
-  onFrame: onFrame2,
-  onError,
-  controller,
-  track,
-  logLevel
-}) => {
-  return internalCreateVideoDecoder({
-    onFrame: onFrame2,
-    onError,
-    controller: controller ?? null,
-    config: track,
-    logLevel: logLevel ?? "info"
-  });
-};
-
 // src/video-encoder.ts
 import {
   MediaParserAbortError as MediaParserAbortError2
@@ -4886,7 +4958,7 @@ var createVideoEncoder = ({
     },
     waitForFinish: async () => {
       await encoder.flush();
-      await ioSynchronizer.waitForFinish();
+      await ioSynchronizer.waitForQueueSize(0);
     },
     close,
     flush: async () => {
@@ -5023,12 +5095,12 @@ var reencodeVideoTrack = async ({
   });
   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.waitForFinish();
+    await videoProcessingQueue.ioSynchronizer.waitForQueueSize(0);
     Log.verbose(logLevel, "Video processing queue finished");
     await videoEncoder.waitForFinish();
     videoEncoder.close();
@@ -5068,7 +5140,8 @@ var makeVideoTrackHandler = ({
     outputContainer,
     rotationToApply: rotate,
     inputTrack: track,
-    resizeOperation
+    resizeOperation,
+    outputVideoCodec: defaultVideoCodec
   });
   const videoOperation = await (onVideoTrack ?? defaultOnVideoTrackHandler)({
     track,

package/dist/get-wave-audio-decoder.d.ts

@@ -1,5 +1,5 @@
 import type { MediaParserLogLevel } from '@remotion/media-parser';
-import type { CreateAudioDecoderInit, WebCodecsAudioDecoder } from './audio-decoder';
+import type { CreateAudioDecoderInit, WebCodecsAudioDecoder } from './create-audio-decoder';
 import type { IoSynchronizer } from './io-manager/io-synchronizer';
 export declare const getWaveAudioDecoder: ({ onFrame, config, sampleFormat, ioSynchronizer, onError, }: Pick<CreateAudioDecoderInit, "onFrame" | "config"> & {
     sampleFormat: AudioSampleFormat;