@remotion/webcodecs 4.0.231 → 4.0.232

package/dist/audio-decoder.js

@@ -62,11 +62,17 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, }) =>
     let queue = Promise.resolve();
     return {
         processSample: (sample) => {
+            // In example.avi, we have samples with 0 data
+            // Chrome fails on these
+            if (sample.data.length === 0) {
+                return queue;
+            }
             queue = queue.then(() => processSample(sample));
             return queue;
         },
         waitForFinish: async () => {
             await audioDecoder.flush();
+            await queue;
             await ioSynchronizer.waitForFinish();
             await outputQueue;
         },

package/dist/audio-encoder-config.d.ts

@@ -1 +1,4 @@
-export declare const getAudioEncoderConfig: (config: AudioEncoderConfig) => Promise<AudioEncoderConfig | null>;
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+export declare const getAudioEncoderConfig: (config: AudioEncoderConfig & {
+    codec: ConvertMediaAudioCodec;
+}) => Promise<AudioEncoderConfig | null>;

package/dist/audio-encoder-config.js

@@ -8,6 +8,9 @@ const getCodecString = (audioCodec) => {
     if (audioCodec === 'aac') {
         return 'mp4a.40.02';
     }
+    if (audioCodec === 'wav') {
+        return 'wav-should-not-to-into-audio-encoder';
+    }
     throw new Error(`Unsupported audio codec: ${audioCodec}`);
 };
 const getAudioEncoderConfig = async (config) => {
@@ -15,6 +18,9 @@ const getAudioEncoderConfig = async (config) => {
         ...config,
         codec: getCodecString(config.codec),
     };
+    if (config.codec === 'wav') {
+        return actualConfig;
+    }
     if (typeof AudioEncoder === 'undefined') {
         return null;
     }

package/dist/audio-encoder.d.ts

@@ -1,12 +1,12 @@
 import type { LogLevel } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 export type WebCodecsAudioEncoder = {
     encodeFrame: (audioData: AudioData) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;
 };
-export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }: {
+export type AudioEncoderInit = {
     onChunk: (chunk: EncodedAudioChunk) => Promise<void>;
     onError: (error: DOMException) => void;
     codec: ConvertMediaAudioCodec;
@@ -14,4 +14,5 @@ export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, con
     config: AudioEncoderConfig;
     logLevel: LogLevel;
     onNewAudioSampleRate: (sampleRate: number) => void;
-}) => WebCodecsAudioEncoder;
+};
+export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }: AudioEncoderInit) => WebCodecsAudioEncoder;

package/dist/audio-encoder.js

@@ -2,10 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAudioEncoder = void 0;
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const wav_audio_encoder_1 = require("./wav-audio-encoder");
 const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }) => {
     if (signal.aborted) {
         throw new Error('Not creating audio encoder, already aborted');
     }
+    if (codec === 'wav') {
+        return (0, wav_audio_encoder_1.getWaveAudioEncoder)({ onChunk, signal });
+    }
     const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Audio encoder');
     let prom = Promise.resolve();
     const encoder = new AudioEncoder({

package/dist/can-copy-audio-track.d.ts

@@ -1,5 +1,5 @@
 import type { MediaParserAudioCodec } from '@remotion/media-parser';
-import type { ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const canCopyAudioTrack: ({ inputCodec, container, }: {
     inputCodec: MediaParserAudioCodec;
     container: ConvertMediaContainer;

package/dist/can-copy-audio-track.js

@@ -8,6 +8,9 @@ const canCopyAudioTrack = ({ inputCodec, container, }) => {
     if (container === 'mp4') {
         return inputCodec === 'aac';
     }
+    if (container === 'wav') {
+        return false;
+    }
     throw new Error(`Unhandled codec: ${container}`);
 };
 exports.canCopyAudioTrack = canCopyAudioTrack;

package/dist/can-copy-video-track.d.ts

@@ -1,5 +1,5 @@
 import type { MediaParserVideoCodec } from '@remotion/media-parser';
-import type { ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const canCopyVideoTrack: ({ inputCodec, container, }: {
     inputCodec: MediaParserVideoCodec;
     container: ConvertMediaContainer;

package/dist/can-copy-video-track.js

@@ -6,7 +6,10 @@ const canCopyVideoTrack = ({ inputCodec, container, }) => {
         return inputCodec === 'vp8' || inputCodec === 'vp9';
     }
     if (container === 'mp4') {
-        return inputCodec === 'h264' || inputCodec === 'h265';
+        return inputCodec === 'h264';
+    }
+    if (container === 'wav') {
+        return false;
     }
     throw new Error(`Unhandled codec: ${container}`);
 };

package/dist/can-reencode-audio-track.d.ts

@@ -1,5 +1,5 @@
 import type { AudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
     track: AudioTrack;
     audioCodec: ConvertMediaAudioCodec;

package/dist/can-reencode-audio-track.js

@@ -5,6 +5,9 @@ const audio_decoder_config_1 = require("./audio-decoder-config");
 const audio_encoder_config_1 = require("./audio-encoder-config");
 const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
     const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)(track);
+    if (audioCodec === 'wav' && audioDecoderConfig) {
+        return true;
+    }
     const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
         codec: audioCodec,
         numberOfChannels: track.numberOfChannels,

package/dist/can-reencode-video-track.d.ts

@@ -1,5 +1,5 @@
 import type { VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
     videoCodec: ConvertMediaVideoCodec;
     track: VideoTrack;

package/dist/codec-id.d.ts

@@ -1,10 +1,10 @@
-declare const availableContainers: readonly ["webm", "mp4"];
+declare const availableContainers: readonly ["webm", "mp4", "wav"];
 export type ConvertMediaContainer = (typeof availableContainers)[number];
 export declare const getAvailableContainers: () => readonly ConvertMediaContainer[];
 declare const availableVideoCodecs: readonly ["vp8", "vp9", "h264"];
 export type ConvertMediaVideoCodec = (typeof availableVideoCodecs)[number];
 export declare const getAvailableVideoCodecs: (container: ConvertMediaContainer) => ConvertMediaVideoCodec[];
-declare const availableAudioCodecs: readonly ["opus", "aac"];
+declare const availableAudioCodecs: readonly ["opus", "aac", "wav"];
 export declare const getAvailableAudioCodecs: (container: ConvertMediaContainer) => ConvertMediaAudioCodec[];
 export type ConvertMediaAudioCodec = (typeof availableAudioCodecs)[number];
 export {};

package/dist/codec-id.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAvailableAudioCodecs = exports.getAvailableVideoCodecs = exports.getAvailableContainers = void 0;
-const availableContainers = ['webm', 'mp4'];
+const availableContainers = ['webm', 'mp4', 'wav'];
 const getAvailableContainers = () => {
     return availableContainers;
 };
@@ -15,11 +15,14 @@ const getAvailableVideoCodecs = (container) => {
     if (container === 'webm') {
         return ['vp8', 'vp9'];
     }
+    if (container === 'wav') {
+        return [];
+    }
     throw new Error(`Unsupported container: ${container}`);
 };
 exports.getAvailableVideoCodecs = getAvailableVideoCodecs;
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-const availableAudioCodecs = ['opus', 'aac'];
+const availableAudioCodecs = ['opus', 'aac', 'wav'];
 const getAvailableAudioCodecs = (container) => {
     if (container === 'mp4') {
         return ['aac'];
@@ -27,6 +30,9 @@ const getAvailableAudioCodecs = (container) => {
     if (container === 'webm') {
         return ['opus'];
     }
+    if (container === 'wav') {
+        return ['wav'];
+    }
     throw new Error(`Unsupported container: ${container}`);
 };
 exports.getAvailableAudioCodecs = getAvailableAudioCodecs;

package/dist/convert-media.d.ts

@@ -3,7 +3,9 @@
  * For licensing, see: https://remotion.dev/docs/webcodecs#license
  */
 import type { LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack, WriterInterface } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec, ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import { type ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import { type ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
 export type ConvertMediaProgress = {

package/dist/convert-media.js

@@ -15,6 +15,7 @@ const error_cause_1 = __importDefault(require("./error-cause"));
 const generate_output_filename_1 = require("./generate-output-filename");
 const on_audio_track_1 = require("./on-audio-track");
 const on_video_track_1 = require("./on-video-track");
+const select_container_creator_1 = require("./select-container-creator");
 const throttled_state_update_1 = require("./throttled-state-update");
 const with_resolvers_1 = require("./with-resolvers");
 const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, progressIntervalInMs, ...more }) {
@@ -22,8 +23,8 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
     if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
         return Promise.reject(new error_cause_1.default('Aborted'));
     }
-    if (container !== 'webm' && container !== 'mp4') {
-        return Promise.reject(new TypeError('Only `to: "webm"` and `to: "mp4"` is supported currently'));
+    if (container !== 'webm' && container !== 'mp4' && container !== 'wav') {
+        return Promise.reject(new TypeError('Only `to: "webm"`, `to: "mp4"` and `to: "wav"` is supported currently'));
     }
     if (videoCodec && videoCodec !== 'vp8' && videoCodec !== 'vp9') {
         return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
@@ -40,9 +41,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         abortConversion(new error_cause_1.default('Conversion aborted by user'));
     };
     userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.addEventListener('abort', onUserAbort);
-    const creator = container === 'webm'
-        ? media_parser_1.MediaParserInternals.createMatroskaMedia
-        : media_parser_1.MediaParserInternals.createIsoBaseMedia;
+    const creator = (0, select_container_creator_1.selectContainerCreator)(container);
     const throttledState = (0, throttled_state_update_1.throttledStateUpdate)({
         updateFn: onProgressDoNotCallDirectly !== null && onProgressDoNotCallDirectly !== void 0 ? onProgressDoNotCallDirectly : null,
         everyMilliseconds: progressIntervalInMs !== null && progressIntervalInMs !== void 0 ? progressIntervalInMs : 100,

package/dist/convert-to-correct-videoframe.d.ts

@@ -1,4 +1,4 @@
-import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export declare const needsToCorrectVideoFrame: ({ videoFrame, outputCodec, }: {
     videoFrame: VideoFrame;
     outputCodec: ConvertMediaVideoCodec;

package/dist/convert-to-correct-videoframe.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToCorrectVideoFrame = exports.needsToCorrectVideoFrame = void 0;
 const browser_quirks_1 = require("./browser-quirks");
 const needsToCorrectVideoFrame = ({ videoFrame, outputCodec, }) => {
+    // On Chrome when dropping a vertical iPhone video
+    if (videoFrame.format === null) {
+        return true;
+    }
     return (0, browser_quirks_1.isFirefox)() && videoFrame.format === 'BGRX' && outputCodec === 'h264';
 };
 exports.needsToCorrectVideoFrame = needsToCorrectVideoFrame;

package/dist/default-on-video-track-handler.js

@@ -15,6 +15,10 @@ const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel,
         return Promise.resolve({ type: 'copy' });
     }
     const videoCodec = defaultVideoCodec !== null && defaultVideoCodec !== void 0 ? defaultVideoCodec : (0, get_default_video_codec_1.getDefaultVideoCodec)({ container });
+    if (videoCodec === null) {
+        media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): No default video codec, therefore dropping`);
+        return Promise.resolve({ type: 'drop' });
+    }
     const canReencode = await (0, can_reencode_video_track_1.canReencodeVideoTrack)({
         videoCodec,
         track,

package/dist/esm/index.mjs

@@ -129,12 +129,18 @@ var makeIoSynchronizer = (logLevel, label) => {
     _unprocessed,
     unemitted
   }) => {
-    while (getUnemittedItems() > unemitted) {
-      await waitForOutput();
-    }
-    while (getUnprocessed() > _unprocessed) {
-      await waitForProcessed();
-    }
+    await Promise.all([
+      async () => {
+        while (getUnemittedItems() > unemitted) {
+          await waitForOutput();
+        }
+      },
+      async () => {
+        while (getUnprocessed() > _unprocessed) {
+          await waitForProcessed();
+        }
+      }
+    ]);
   };
   const waitForFinish = async () => {
     await waitFor({ _unprocessed: 0, unemitted: 0 });
@@ -215,11 +221,15 @@ var createAudioDecoder = ({
   let queue = Promise.resolve();
   return {
     processSample: (sample) => {
+      if (sample.data.length === 0) {
+        return queue;
+      }
       queue = queue.then(() => processSample(sample));
       return queue;
     },
     waitForFinish: async () => {
       await audioDecoder.flush();
+      await queue;
       await ioSynchronizer.waitForFinish();
       await outputQueue;
     },
@@ -229,6 +239,33 @@ var createAudioDecoder = ({
     }
   };
 };
+// src/wav-audio-encoder.ts
+var getWaveAudioEncoder = ({
+  onChunk,
+  signal
+}) => {
+  return {
+    close: () => {
+      return Promise.resolve();
+    },
+    encodeFrame: (audioData) => {
+      if (signal.aborted) {
+        return Promise.resolve();
+      }
+      const chunk = {
+        timestamp: audioData.timestamp,
+        duration: audioData.duration,
+        type: "key",
+        copyTo: (destination) => audioData.copyTo(destination, { planeIndex: 0, format: "s16" }),
+        byteLength: audioData.allocationSize({ planeIndex: 0, format: "s16" })
+      };
+      return onChunk(chunk);
+    },
+    flush: () => Promise.resolve(),
+    waitForFinish: () => Promise.resolve()
+  };
+};
+
 // src/audio-encoder.ts
 var createAudioEncoder = ({
   onChunk,
@@ -242,6 +279,9 @@ var createAudioEncoder = ({
   if (signal.aborted) {
     throw new Error("Not creating audio encoder, already aborted");
   }
+  if (codec === "wav") {
+    return getWaveAudioEncoder({ onChunk, signal });
+  }
   const ioSynchronizer = makeIoSynchronizer(logLevel, "Audio encoder");
   let prom = Promise.resolve();
   const encoder = new AudioEncoder({
@@ -328,6 +368,9 @@ var canCopyAudioTrack = ({
   if (container === "mp4") {
     return inputCodec === "aac";
   }
+  if (container === "wav") {
+    return false;
+  }
   throw new Error(`Unhandled codec: ${container}`);
 };
 // src/can-copy-video-track.ts
@@ -339,7 +382,10 @@ var canCopyVideoTrack = ({
     return inputCodec === "vp8" || inputCodec === "vp9";
   }
   if (container === "mp4") {
-    return inputCodec === "h264" || inputCodec === "h265";
+    return inputCodec === "h264";
+  }
+  if (container === "wav") {
+    return false;
   }
   throw new Error(`Unhandled codec: ${container}`);
 };
@@ -365,6 +411,9 @@ var getCodecString = (audioCodec) => {
   if (audioCodec === "aac") {
     return "mp4a.40.02";
   }
+  if (audioCodec === "wav") {
+    return "wav-should-not-to-into-audio-encoder";
+  }
   throw new Error(`Unsupported audio codec: ${audioCodec}`);
 };
 var getAudioEncoderConfig = async (config) => {
@@ -372,6 +421,9 @@ var getAudioEncoderConfig = async (config) => {
     ...config,
     codec: getCodecString(config.codec)
   };
+  if (config.codec === "wav") {
+    return actualConfig;
+  }
   if (typeof AudioEncoder === "undefined") {
     return null;
   }
@@ -388,6 +440,9 @@ var canReencodeAudioTrack = async ({
   bitrate
 }) => {
   const audioDecoderConfig = await getAudioDecoderConfig(track);
+  if (audioCodec === "wav" && audioDecoderConfig) {
+    return true;
+  }
   const audioEncoderConfig = await getAudioEncoderConfig({
     codec: audioCodec,
     numberOfChannels: track.numberOfChannels,
@@ -508,34 +563,8 @@ var canReencodeVideoTrack = async ({
   const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
   return Boolean(videoDecoderConfig && videoEncoderConfig);
 };
-// src/codec-id.ts
-var availableContainers = ["webm", "mp4"];
-var getAvailableContainers = () => {
-  return availableContainers;
-};
-var getAvailableVideoCodecs = (container) => {
-  if (container === "mp4") {
-    return ["h264"];
-  }
-  if (container === "webm") {
-    return ["vp8", "vp9"];
-  }
-  throw new Error(`Unsupported container: ${container}`);
-};
-var getAvailableAudioCodecs = (container) => {
-  if (container === "mp4") {
-    return ["aac"];
-  }
-  if (container === "webm") {
-    return ["opus"];
-  }
-  throw new Error(`Unsupported container: ${container}`);
-};
 // src/convert-media.ts
-import {
-  MediaParserInternals as MediaParserInternals4,
-  parseMedia
-} from "@remotion/media-parser";
+import { parseMedia } from "@remotion/media-parser";
 
 // src/auto-select-writer.ts
 import { bufferWriter } from "@remotion/media-parser/buffer";
@@ -604,6 +633,9 @@ var getDefaultAudioCodec = ({
   if (container === "mp4") {
     return "aac";
   }
+  if (container === "wav") {
+    return "wav";
+  }
   throw new Error(`Unhandled container: ${container}`);
 };
 
@@ -714,7 +746,7 @@ var makeAudioTrackHandler = ({
   const codecPrivate = audioOperation.audioCodec === "aac" ? new Uint8Array([17, 144]) : null;
   const { trackNumber } = await state.addTrack({
     type: "audio",
-    codec: audioOperation.audioCodec,
+    codec: audioOperation.audioCodec === "wav" ? "pcm-s16" : audioOperation.audioCodec,
     numberOfChannels: track.numberOfChannels,
     sampleRate: track.sampleRate,
     codecPrivate,
@@ -795,7 +827,13 @@ var getDefaultVideoCodec = ({
   if (container === "webm") {
     return "vp8";
   }
-  throw new Error(`Unhandled container: ${container} satisfies never`);
+  if (container === "mp4") {
+    return "h264";
+  }
+  if (container === "wav") {
+    return null;
+  }
+  throw new Error(`Unhandled container: ${container}`);
 };
 
 // src/default-on-video-track-handler.ts
@@ -814,6 +852,10 @@ var defaultOnVideoTrackHandler = async ({
     return Promise.resolve({ type: "copy" });
   }
   const videoCodec = defaultVideoCodec ?? getDefaultVideoCodec({ container });
+  if (videoCodec === null) {
+    MediaParserInternals3.Log.verbose(logLevel, `Track ${track.trackId} (video): No default video codec, therefore dropping`);
+    return Promise.resolve({ type: "drop" });
+  }
   const canReencode = await canReencodeVideoTrack({
     videoCodec,
     track
@@ -831,6 +873,9 @@ var needsToCorrectVideoFrame = ({
   videoFrame,
   outputCodec
 }) => {
+  if (videoFrame.format === null) {
+    return true;
+  }
   return isFirefox() && videoFrame.format === "BGRX" && outputCodec === "h264";
 };
 var convertToCorrectVideoFrame = ({
@@ -865,12 +910,6 @@ var onFrame = async ({
   outputCodec
 }) => {
   const newFrame = onVideoFrame ? await onVideoFrame({ frame, track }) : frame;
-  if (newFrame.codedHeight !== frame.displayHeight) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedHeight (${newFrame.codedHeight}) than the input frame displayHeight (${frame.displayHeight})`);
-  }
-  if (newFrame.codedWidth !== frame.displayWidth) {
-    throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedWidth (${newFrame.codedWidth}) than the input frame displayWidth (${frame.displayWidth})`);
-  }
   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})`);
   }
@@ -1203,6 +1242,21 @@ var makeVideoTrackHandler = ({
   };
 };
 
+// src/select-container-creator.ts
+import { MediaParserInternals as MediaParserInternals4 } from "@remotion/media-parser";
+var selectContainerCreator = (container) => {
+  if (container === "mp4") {
+    return MediaParserInternals4.createIsoBaseMedia;
+  }
+  if (container === "wav") {
+    return MediaParserInternals4.createWav;
+  }
+  if (container === "webm") {
+    return MediaParserInternals4.createMatroskaMedia;
+  }
+  throw new Error(`Unsupported container: ${container}`);
+};
+
 // src/throttled-state-update.ts
 var throttledStateUpdate = ({
   updateFn,
@@ -1276,8 +1330,8 @@ var convertMedia = async function({
   if (userPassedAbortSignal?.aborted) {
     return Promise.reject(new error_cause_default("Aborted"));
   }
-  if (container !== "webm" && container !== "mp4") {
-    return Promise.reject(new TypeError('Only `to: "webm"` and `to: "mp4"` is supported currently'));
+  if (container !== "webm" && container !== "mp4" && container !== "wav") {
+    return Promise.reject(new TypeError('Only `to: "webm"`, `to: "mp4"` and `to: "wav"` is supported currently'));
   }
   if (videoCodec && videoCodec !== "vp8" && videoCodec !== "vp9") {
     return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
@@ -1294,7 +1348,7 @@ var convertMedia = async function({
     abortConversion(new error_cause_default("Conversion aborted by user"));
   };
   userPassedAbortSignal?.addEventListener("abort", onUserAbort);
-  const creator = container === "webm" ? MediaParserInternals4.createMatroskaMedia : MediaParserInternals4.createIsoBaseMedia;
+  const creator = selectContainerCreator(container);
   const throttledState = throttledStateUpdate({
     updateFn: onProgressDoNotCallDirectly ?? null,
     everyMilliseconds: progressIntervalInMs ?? 100,
@@ -1398,6 +1452,41 @@ var convertMedia = async function({
     userPassedAbortSignal?.removeEventListener("abort", onUserAbort);
   });
 };
+// src/get-available-audio-codecs.ts
+var getAvailableAudioCodecs = ({
+  container
+}) => {
+  if (container === "mp4") {
+    return ["aac"];
+  }
+  if (container === "webm") {
+    return ["opus"];
+  }
+  if (container === "wav") {
+    return ["wav"];
+  }
+  throw new Error(`Unsupported container: ${container}`);
+};
+// src/get-available-containers.ts
+var availableContainers = ["webm", "mp4", "wav"];
+var getAvailableContainers = () => {
+  return availableContainers;
+};
+// src/get-available-video-codecs.ts
+var getAvailableVideoCodecs = ({
+  container
+}) => {
+  if (container === "mp4") {
+    return ["h264"];
+  }
+  if (container === "webm") {
+    return ["vp8", "vp9"];
+  }
+  if (container === "wav") {
+    return [];
+  }
+  throw new Error(`Unsupported container: ${container}`);
+};
 // src/index.ts
 setRemotionImported();
 export {

package/dist/generate-output-filename.d.ts

@@ -1,2 +1,2 @@
-import type { ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const generateOutputFilename: (source: string | Blob, container: ConvertMediaContainer) => string;

package/dist/get-available-audio-codecs.d.ts

@@ -0,0 +1,7 @@
+import type { ConvertMediaContainer } from './get-available-containers';
+declare const availableAudioCodecs: readonly ["opus", "aac", "wav"];
+export declare const getAvailableAudioCodecs: ({ container, }: {
+    container: ConvertMediaContainer;
+}) => ConvertMediaAudioCodec[];
+export type ConvertMediaAudioCodec = (typeof availableAudioCodecs)[number];
+export {};

package/dist/get-available-audio-codecs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableAudioCodecs = void 0;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const availableAudioCodecs = ['opus', 'aac', 'wav'];
+const getAvailableAudioCodecs = ({ container, }) => {
+    if (container === 'mp4') {
+        return ['aac'];
+    }
+    if (container === 'webm') {
+        return ['opus'];
+    }
+    if (container === 'wav') {
+        return ['wav'];
+    }
+    throw new Error(`Unsupported container: ${container}`);
+};
+exports.getAvailableAudioCodecs = getAvailableAudioCodecs;

package/dist/get-available-containers.d.ts

@@ -0,0 +1,4 @@
+declare const availableContainers: readonly ["webm", "mp4", "wav"];
+export type ConvertMediaContainer = (typeof availableContainers)[number];
+export declare const getAvailableContainers: () => readonly ConvertMediaContainer[];
+export {};

package/dist/get-available-containers.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableContainers = void 0;
+const availableContainers = ['webm', 'mp4', 'wav'];
+const getAvailableContainers = () => {
+    return availableContainers;
+};
+exports.getAvailableContainers = getAvailableContainers;

package/dist/get-available-video-codecs.d.ts

@@ -0,0 +1,7 @@
+import type { ConvertMediaContainer } from './get-available-containers';
+declare const availableVideoCodecs: readonly ["vp8", "vp9", "h264"];
+export type ConvertMediaVideoCodec = (typeof availableVideoCodecs)[number];
+export declare const getAvailableVideoCodecs: ({ container, }: {
+    container: ConvertMediaContainer;
+}) => ConvertMediaVideoCodec[];
+export {};

package/dist/get-available-video-codecs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableVideoCodecs = void 0;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const availableVideoCodecs = ['vp8', 'vp9', 'h264'];
+const getAvailableVideoCodecs = ({ container, }) => {
+    if (container === 'mp4') {
+        return ['h264'];
+    }
+    if (container === 'webm') {
+        return ['vp8', 'vp9'];
+    }
+    if (container === 'wav') {
+        return [];
+    }
+    throw new Error(`Unsupported container: ${container}`);
+};
+exports.getAvailableVideoCodecs = getAvailableVideoCodecs;

package/dist/get-default-audio-codec.d.ts

@@ -1,4 +1,5 @@
-import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const getDefaultAudioCodec: ({ container, }: {
     container: ConvertMediaContainer;
 }) => ConvertMediaAudioCodec;

package/dist/get-default-audio-codec.js

@@ -8,6 +8,9 @@ const getDefaultAudioCodec = ({ container, }) => {
     if (container === 'mp4') {
         return 'aac';
     }
+    if (container === 'wav') {
+        return 'wav';
+    }
     throw new Error(`Unhandled container: ${container}`);
 };
 exports.getDefaultAudioCodec = getDefaultAudioCodec;

package/dist/get-default-video-codec.d.ts

@@ -1,4 +1,5 @@
-import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export declare const getDefaultVideoCodec: ({ container, }: {
     container: ConvertMediaContainer;
-}) => ConvertMediaVideoCodec;
+}) => ConvertMediaVideoCodec | null;

package/dist/get-default-video-codec.js

@@ -5,6 +5,12 @@ const getDefaultVideoCodec = ({ container, }) => {
     if (container === 'webm') {
         return 'vp8';
     }
-    throw new Error(`Unhandled container: ${container} satisfies never`);
+    if (container === 'mp4') {
+        return 'h264';
+    }
+    if (container === 'wav') {
+        return null;
+    }
+    throw new Error(`Unhandled container: ${container}`);
 };
 exports.getDefaultVideoCodec = getDefaultVideoCodec;

package/dist/index.d.ts

@@ -4,10 +4,12 @@ export { canCopyAudioTrack } from './can-copy-audio-track';
 export { canCopyVideoTrack } from './can-copy-video-track';
 export { canReencodeAudioTrack } from './can-reencode-audio-track';
 export { canReencodeVideoTrack } from './can-reencode-video-track';
-export { ConvertMediaAudioCodec, ConvertMediaContainer, ConvertMediaVideoCodec, getAvailableAudioCodecs, getAvailableContainers, getAvailableVideoCodecs, } from './codec-id';
 export { convertMedia, ConvertMediaOnProgress, ConvertMediaOnVideoFrame, ConvertMediaProgress, ConvertMediaResult, } from './convert-media';
 export { defaultOnAudioTrackHandler } from './default-on-audio-track-handler';
 export { defaultOnVideoTrackHandler } from './default-on-video-track-handler';
+export { ConvertMediaAudioCodec, getAvailableAudioCodecs, } from './get-available-audio-codecs';
+export { ConvertMediaContainer, getAvailableContainers, } from './get-available-containers';
+export { ConvertMediaVideoCodec, getAvailableVideoCodecs, } from './get-available-video-codecs';
 export { getDefaultAudioCodec } from './get-default-audio-codec';
 export { getDefaultVideoCodec } from './get-default-video-codec';
 export { AudioOperation, ConvertMediaOnAudioTrackHandler, } from './on-audio-track-handler';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVideoEncoder = exports.createVideoDecoder = exports.getDefaultVideoCodec = exports.getDefaultAudioCodec = exports.defaultOnVideoTrackHandler = exports.defaultOnAudioTrackHandler = exports.convertMedia = exports.getAvailableVideoCodecs = exports.getAvailableContainers = exports.getAvailableAudioCodecs = exports.canReencodeVideoTrack = exports.canReencodeAudioTrack = exports.canCopyVideoTrack = exports.canCopyAudioTrack = exports.createAudioEncoder = exports.createAudioDecoder = void 0;
+exports.createVideoEncoder = exports.createVideoDecoder = exports.getDefaultVideoCodec = exports.getDefaultAudioCodec = exports.getAvailableVideoCodecs = exports.getAvailableContainers = exports.getAvailableAudioCodecs = exports.defaultOnVideoTrackHandler = exports.defaultOnAudioTrackHandler = exports.convertMedia = exports.canReencodeVideoTrack = exports.canReencodeAudioTrack = exports.canCopyVideoTrack = exports.canCopyAudioTrack = exports.createAudioEncoder = exports.createAudioDecoder = void 0;
 const set_remotion_imported_1 = require("./set-remotion-imported");
 var audio_decoder_1 = require("./audio-decoder");
 Object.defineProperty(exports, "createAudioDecoder", { enumerable: true, get: function () { return audio_decoder_1.createAudioDecoder; } });
@@ -14,16 +14,18 @@ var can_reencode_audio_track_1 = require("./can-reencode-audio-track");
 Object.defineProperty(exports, "canReencodeAudioTrack", { enumerable: true, get: function () { return can_reencode_audio_track_1.canReencodeAudioTrack; } });
 var can_reencode_video_track_1 = require("./can-reencode-video-track");
 Object.defineProperty(exports, "canReencodeVideoTrack", { enumerable: true, get: function () { return can_reencode_video_track_1.canReencodeVideoTrack; } });
-var codec_id_1 = require("./codec-id");
-Object.defineProperty(exports, "getAvailableAudioCodecs", { enumerable: true, get: function () { return codec_id_1.getAvailableAudioCodecs; } });
-Object.defineProperty(exports, "getAvailableContainers", { enumerable: true, get: function () { return codec_id_1.getAvailableContainers; } });
-Object.defineProperty(exports, "getAvailableVideoCodecs", { enumerable: true, get: function () { return codec_id_1.getAvailableVideoCodecs; } });
 var convert_media_1 = require("./convert-media");
 Object.defineProperty(exports, "convertMedia", { enumerable: true, get: function () { return convert_media_1.convertMedia; } });
 var default_on_audio_track_handler_1 = require("./default-on-audio-track-handler");
 Object.defineProperty(exports, "defaultOnAudioTrackHandler", { enumerable: true, get: function () { return default_on_audio_track_handler_1.defaultOnAudioTrackHandler; } });
 var default_on_video_track_handler_1 = require("./default-on-video-track-handler");
 Object.defineProperty(exports, "defaultOnVideoTrackHandler", { enumerable: true, get: function () { return default_on_video_track_handler_1.defaultOnVideoTrackHandler; } });
+var get_available_audio_codecs_1 = require("./get-available-audio-codecs");
+Object.defineProperty(exports, "getAvailableAudioCodecs", { enumerable: true, get: function () { return get_available_audio_codecs_1.getAvailableAudioCodecs; } });
+var get_available_containers_1 = require("./get-available-containers");
+Object.defineProperty(exports, "getAvailableContainers", { enumerable: true, get: function () { return get_available_containers_1.getAvailableContainers; } });
+var get_available_video_codecs_1 = require("./get-available-video-codecs");
+Object.defineProperty(exports, "getAvailableVideoCodecs", { enumerable: true, get: function () { return get_available_video_codecs_1.getAvailableVideoCodecs; } });
 var get_default_audio_codec_1 = require("./get-default-audio-codec");
 Object.defineProperty(exports, "getDefaultAudioCodec", { enumerable: true, get: function () { return get_default_audio_codec_1.getDefaultAudioCodec; } });
 var get_default_video_codec_1 = require("./get-default-video-codec");

package/dist/io-manager/io-synchronizer.js

@@ -69,12 +69,18 @@ const makeIoSynchronizer = (logLevel, label) => {
         return promise;
     };
     const waitFor = async ({ _unprocessed, unemitted, }) => {
-        while (getUnemittedItems() > unemitted) {
-            await waitForOutput();
-        }
-        while (getUnprocessed() > _unprocessed) {
-            await waitForProcessed();
-        }
+        await Promise.all([
+            async () => {
+                while (getUnemittedItems() > unemitted) {
+                    await waitForOutput();
+                }
+            },
+            async () => {
+                while (getUnprocessed() > _unprocessed) {
+                    await waitForProcessed();
+                }
+            },
+        ]);
     };
     const waitForFinish = async () => {
         await waitFor({ _unprocessed: 0, unemitted: 0 });

package/dist/on-audio-track-handler.d.ts

@@ -1,5 +1,6 @@
 import type { AudioTrack, LogLevel } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaContainer } from './get-available-containers';
 export type AudioOperation = {
     type: 'reencode';
     bitrate: number;

package/dist/on-audio-track.d.ts

@@ -1,6 +1,7 @@
 import type { LogLevel, MediaFn, OnAudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
 import Error from './error-cause';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
 export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }: {

package/dist/on-audio-track.js

@@ -74,7 +74,9 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controlle
     const codecPrivate = audioOperation.audioCodec === 'aac' ? new Uint8Array([17, 144]) : null;
     const { trackNumber } = await state.addTrack({
         type: 'audio',
-        codec: audioOperation.audioCodec,
+        codec: audioOperation.audioCodec === 'wav'
+            ? 'pcm-s16'
+            : audioOperation.audioCodec,
         numberOfChannels: track.numberOfChannels,
         sampleRate: track.sampleRate,
         codecPrivate,

package/dist/on-frame.d.ts

@@ -1,6 +1,6 @@
 import type { VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
 import type { ConvertMediaOnVideoFrame } from './convert-media';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import type { WebCodecsVideoEncoder } from './video-encoder';
 export declare const onFrame: ({ frame, onVideoFrame, videoEncoder, track, outputCodec, }: {
     frame: VideoFrame;

package/dist/on-frame.js

@@ -4,12 +4,6 @@ exports.onFrame = void 0;
 const convert_to_correct_videoframe_1 = require("./convert-to-correct-videoframe");
 const onFrame = async ({ frame, onVideoFrame, videoEncoder, track, outputCodec, }) => {
     const newFrame = onVideoFrame ? await onVideoFrame({ frame, track }) : frame;
-    if (newFrame.codedHeight !== frame.displayHeight) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedHeight (${newFrame.codedHeight}) than the input frame displayHeight (${frame.displayHeight})`);
-    }
-    if (newFrame.codedWidth !== frame.displayWidth) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedWidth (${newFrame.codedWidth}) than the input frame displayWidth (${frame.displayWidth})`);
-    }
     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})`);
     }

package/dist/on-video-track-handler.d.ts

@@ -1,5 +1,6 @@
 import type { LogLevel, VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export type VideoOperation = {
     type: 'reencode';
     videoCodec: ConvertMediaVideoCodec;

package/dist/on-video-track.d.ts

@@ -1,7 +1,8 @@
 import type { LogLevel, MediaFn, OnVideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
 import type { ConvertMediaOnVideoFrame } from './convert-media';
 import Error from './error-cause';
+import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import type { ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
 export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }: {

package/dist/select-container-creator.d.ts

@@ -0,0 +1,2 @@
+import type { ConvertMediaContainer } from './get-available-containers';
+export declare const selectContainerCreator: (container: ConvertMediaContainer) => ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }: import("@remotion/media-parser/dist/create/media-fn").MediaFnGeneratorInput) => Promise<import("@remotion/media-parser").MediaFn>;

package/dist/select-container-creator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectContainerCreator = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const selectContainerCreator = (container) => {
+    if (container === 'mp4') {
+        return media_parser_1.MediaParserInternals.createIsoBaseMedia;
+    }
+    if (container === 'wav') {
+        return media_parser_1.MediaParserInternals.createWav;
+    }
+    if (container === 'webm') {
+        return media_parser_1.MediaParserInternals.createMatroskaMedia;
+    }
+    throw new Error(`Unsupported container: ${container}`);
+};
+exports.selectContainerCreator = selectContainerCreator;

package/dist/video-encoder-config.d.ts

@@ -1,4 +1,4 @@
-import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export declare const getVideoEncoderConfig: ({ codec, height, width, fps, }: {
     width: number;
     height: number;

package/dist/video-encoder.d.ts

@@ -1,5 +1,5 @@
 import type { LogLevel } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export type WebCodecsVideoEncoder = {
     encodeFrame: (videoFrame: VideoFrame, timestamp: number) => Promise<void>;
     waitForFinish: () => Promise<void>;

package/dist/wav-audio-encoder.d.ts

@@ -0,0 +1,2 @@
+import type { AudioEncoderInit, WebCodecsAudioEncoder } from './audio-encoder';
+export declare const getWaveAudioEncoder: ({ onChunk, signal, }: Pick<AudioEncoderInit, "onChunk" | "signal">) => WebCodecsAudioEncoder;

package/dist/wav-audio-encoder.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWaveAudioEncoder = void 0;
+const getWaveAudioEncoder = ({ onChunk, signal, }) => {
+    return {
+        close: () => {
+            return Promise.resolve();
+        },
+        encodeFrame: (audioData) => {
+            if (signal.aborted) {
+                return Promise.resolve();
+            }
+            const chunk = {
+                timestamp: audioData.timestamp,
+                duration: audioData.duration,
+                type: 'key',
+                copyTo: (destination) => audioData.copyTo(destination, { planeIndex: 0, format: 's16' }),
+                byteLength: audioData.allocationSize({ planeIndex: 0, format: 's16' }),
+            };
+            return onChunk(chunk);
+        },
+        flush: () => Promise.resolve(),
+        waitForFinish: () => Promise.resolve(),
+    };
+};
+exports.getWaveAudioEncoder = getWaveAudioEncoder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.231",
+  "version": "4.0.232",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -17,13 +17,13 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.231"
+    "@remotion/media-parser": "4.0.232"
   },
   "peerDependencies": {},
   "devDependencies": {
     "@types/dom-webcodecs": "0.1.11",
     "eslint": "9.14.0",
-    "@remotion/eslint-config-internal": "4.0.231"
+    "@remotion/eslint-config-internal": "4.0.232"
   },
   "keywords": [],
   "publishConfig": {