@remotion/webcodecs 4.0.230 → 4.0.232

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

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

package/dist/generate-output-filename.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOutputFilename = void 0;
+const generateOutputFilename = (source, container) => {
+    const filename = typeof source === 'string'
+        ? source
+        : source instanceof File
+            ? source.name
+            : 'converted';
+    const behindSlash = filename.split('/').pop();
+    const withoutExtension = behindSlash.split('.').slice(0, -1).join('.');
+    return `${withoutExtension}.${container}`;
+};
+exports.generateOutputFilename = generateOutputFilename;

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

@@ -1,16 +1,18 @@
-export { WebCodecsAudioDecoder, createAudioDecoder } from './audio-decoder';
-export { WebCodecsAudioEncoder, createAudioEncoder } from './audio-encoder';
+export { createAudioDecoder, WebCodecsAudioDecoder } from './audio-decoder';
+export { createAudioEncoder, WebCodecsAudioEncoder } from './audio-encoder';
 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 { ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaResult, ConvertMediaState, convertMedia, } from './convert-media';
+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';
 export { ConvertMediaOnVideoTrackHandler, VideoOperation, } from './on-video-track-handler';
-export { WebCodecsVideoDecoder, createVideoDecoder } from './video-decoder';
-export { WebCodecsVideoEncoder, createVideoEncoder } from './video-encoder';
+export { createVideoDecoder, WebCodecsVideoDecoder } from './video-decoder';
+export { createVideoEncoder, WebCodecsVideoEncoder } from './video-encoder';

package/dist/index.js

@@ -1,6 +1,7 @@
 "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; } });
 var audio_encoder_1 = require("./audio-encoder");
@@ -13,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");
@@ -31,3 +34,4 @@ var video_decoder_1 = require("./video-decoder");
 Object.defineProperty(exports, "createVideoDecoder", { enumerable: true, get: function () { return video_decoder_1.createVideoDecoder; } });
 var video_encoder_1 = require("./video-encoder");
 Object.defineProperty(exports, "createVideoEncoder", { enumerable: true, get: function () { return video_encoder_1.createVideoEncoder; } });
+(0, set_remotion_imported_1.setRemotionImported)();

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,15 +1,15 @@
 import type { LogLevel, MediaFn, OnAudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
-import type { ConvertMediaState } from './convert-media';
 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';
-export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }: {
+import type { ConvertMediaProgressFn } from './throttled-state-update';
+export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }: {
     state: MediaFn;
     defaultAudioCodec: ConvertMediaAudioCodec | null;
-    convertMediaState: ConvertMediaState;
     controller: AbortController;
     abortConversion: (errCause: Error) => void;
-    onMediaStateUpdate: null | ((state: ConvertMediaState) => void);
+    onMediaStateUpdate: null | ConvertMediaProgressFn;
     onAudioTrack: ConvertMediaOnAudioTrackHandler | null;
     logLevel: LogLevel;
     container: ConvertMediaContainer;

package/dist/on-audio-track.js

@@ -12,7 +12,7 @@ const convert_encoded_chunk_1 = require("./convert-encoded-chunk");
 const default_on_audio_track_handler_1 = require("./default-on-audio-track-handler");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const log_1 = require("./log");
-const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }) => async (track) => {
+const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }) => async (track) => {
     const audioOperation = await (onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : default_on_audio_track_handler_1.defaultOnAudioTrackHandler)({
         defaultAudioCodec: audioCodec,
         track,
@@ -43,8 +43,12 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, convertMe
                 timescale: track.timescale,
                 codecPrivate: track.codecPrivate,
             });
-            convertMediaState.encodedAudioFrames++;
-            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate((prevState) => {
+                return {
+                    ...prevState,
+                    encodedAudioFrames: prevState.encodedAudioFrames + 1,
+                };
+            });
         };
     }
     const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
@@ -70,7 +74,9 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, convertMe
     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,
@@ -92,8 +98,12 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, convertMe
                 timescale: track.timescale,
                 codecPrivate,
             });
-            convertMediaState.encodedAudioFrames++;
-            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate((prevState) => {
+                return {
+                    ...prevState,
+                    encodedAudioFrames: prevState.encodedAudioFrames + 1,
+                };
+            });
         },
         onError: (err) => {
             abortConversion(new error_cause_1.default(`Audio encoder of ${track.trackId} failed (see .cause of this error)`, {
@@ -108,8 +118,12 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, convertMe
     const audioDecoder = (0, audio_decoder_1.createAudioDecoder)({
         onFrame: async (frame) => {
             await audioEncoder.encodeFrame(frame);
-            convertMediaState.decodedAudioFrames++;
-            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate((prevState) => {
+                return {
+                    ...prevState,
+                    decodedAudioFrames: prevState.decodedAudioFrames + 1,
+                };
+            });
             frame.close();
         },
         onError(error) {

package/dist/on-frame.d.ts

@@ -1,11 +1,11 @@
 import type { VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaState } from './convert-media';
+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, onMediaStateUpdate, track, convertMediaState, }: {
+export declare const onFrame: ({ frame, onVideoFrame, videoEncoder, track, outputCodec, }: {
     frame: VideoFrame;
     onVideoFrame: ConvertMediaOnVideoFrame | null;
     videoEncoder: WebCodecsVideoEncoder;
-    onMediaStateUpdate: ConvertMediaOnMediaStateUpdate | null;
     track: VideoTrack;
-    convertMediaState: ConvertMediaState;
+    outputCodec: ConvertMediaVideoCodec;
 }) => Promise<void>;

package/dist/on-frame.js

@@ -1,14 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onFrame = void 0;
-const onFrame = async ({ frame, onVideoFrame, videoEncoder, onMediaStateUpdate, track, convertMediaState, }) => {
+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.codedHeight) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedHeight (${newFrame.codedHeight}) than the input frame (${frame.codedHeight})`);
-    }
-    if (newFrame.codedWidth !== frame.codedWidth) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedWidth (${newFrame.codedWidth}) than the input frame (${frame.codedWidth})`);
-    }
     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})`);
     }
@@ -21,12 +16,17 @@ const onFrame = async ({ frame, onVideoFrame, videoEncoder, onMediaStateUpdate,
     if (newFrame.duration !== frame.duration) {
         throw new Error(`Returned VideoFrame of track ${track.trackId} has different duration (${newFrame.duration}) than the input frame (${newFrame.duration}). When calling new VideoFrame(), pass {duration: frame.duration} as second argument`);
     }
-    await videoEncoder.encodeFrame(newFrame, newFrame.timestamp);
-    convertMediaState.decodedVideoFrames++;
-    onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
-    newFrame.close();
+    const fixedFrame = (0, convert_to_correct_videoframe_1.convertToCorrectVideoFrame)({
+        videoFrame: newFrame,
+        outputCodec,
+    });
+    await videoEncoder.encodeFrame(fixedFrame, fixedFrame.timestamp);
+    fixedFrame.close();
     if (frame !== newFrame) {
         frame.close();
     }
+    if (fixedFrame !== newFrame) {
+        fixedFrame.close();
+    }
 };
 exports.onFrame = onFrame;

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,14 +1,15 @@
 import type { LogLevel, MediaFn, OnVideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
-import type { ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaState } from './convert-media';
+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';
-export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }: {
+import type { ConvertMediaProgressFn } from './throttled-state-update';
+export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }: {
     state: MediaFn;
     onVideoFrame: null | ConvertMediaOnVideoFrame;
-    onMediaStateUpdate: null | ConvertMediaOnMediaStateUpdate;
+    onMediaStateUpdate: null | ConvertMediaProgressFn;
     abortConversion: (errCause: Error) => void;
-    convertMediaState: ConvertMediaState;
     controller: AbortController;
     defaultVideoCodec: ConvertMediaVideoCodec | null;
     onVideoTrack: ConvertMediaOnVideoTrackHandler | null;

package/dist/on-video-track.js

@@ -14,7 +14,7 @@ const video_decoder_1 = require("./video-decoder");
 const video_decoder_config_1 = require("./video-decoder-config");
 const video_encoder_1 = require("./video-encoder");
 const video_encoder_config_1 = require("./video-encoder-config");
-const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }) => async (track) => {
+const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }) => async (track) => {
     if (controller.signal.aborted) {
         throw new error_cause_1.default('Aborted');
     }
@@ -49,8 +49,12 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
                 timescale: track.timescale,
                 codecPrivate: track.codecPrivate,
             });
-            convertMediaState.decodedVideoFrames++;
-            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate((prevState) => {
+                return {
+                    ...prevState,
+                    decodedVideoFrames: prevState.decodedVideoFrames + 1,
+                };
+            });
         };
     }
     const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
@@ -88,8 +92,12 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
                 timescale: track.timescale,
                 codecPrivate: (0, arraybuffer_to_uint8_array_1.arrayBufferToUint8Array)(((_b = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.decoderConfig) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : null)),
             });
-            convertMediaState.encodedVideoFrames++;
-            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate((prevState) => {
+                return {
+                    ...prevState,
+                    encodedVideoFrames: prevState.encodedVideoFrames + 1,
+                };
+            });
         },
         onError: (err) => {
             abortConversion(new error_cause_1.default(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
@@ -99,17 +107,17 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         signal: controller.signal,
         config: videoEncoderConfig,
         logLevel,
+        outputCodec: videoOperation.videoCodec,
     });
     const videoDecoder = (0, video_decoder_1.createVideoDecoder)({
         config: videoDecoderConfig,
         onFrame: async (frame) => {
             await (0, on_frame_1.onFrame)({
-                convertMediaState,
                 frame,
-                onMediaStateUpdate,
                 track,
                 videoEncoder,
                 onVideoFrame,
+                outputCodec: videoOperation.videoCodec,
             });
         },
         onError: (err) => {

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/set-remotion-imported.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface Window {
+        remotion_imported: string | boolean;
+    }
+}
+export declare const setRemotionImported: () => void;

package/dist/set-remotion-imported.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRemotionImported = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+// We set the `window.remotion_imported` variable for the sole purpose
+// of being picked up by Wappalyzer.
+// The Wappalyzer Chrome extension is used to detect the technologies
+// used on websites, and it looks for this variable.
+// Remotion is a customer of Wappalyzer and buys a list of domains
+// where Remotion is used from time to time.
+// Remotion uses this data to ensure companies which are required to get
+// a company license for this pacakge are actually doing so.
+const setRemotionImported = () => {
+    if (typeof globalThis === 'undefined') {
+        return;
+    }
+    if (globalThis.remotion_imported) {
+        return;
+    }
+    globalThis.remotion_imported = media_parser_1.VERSION;
+    if (typeof window !== 'undefined') {
+        window.remotion_imported = `${media_parser_1.VERSION}-webcodecs`;
+    }
+};
+exports.setRemotionImported = setRemotionImported;

package/dist/throttled-state-update.d.ts

@@ -0,0 +1,13 @@
+import type { ConvertMediaOnProgress, ConvertMediaProgress } from './convert-media';
+export type ConvertMediaProgressFn = (state: (prevState: ConvertMediaProgress) => ConvertMediaProgress) => void;
+type ReturnType = {
+    get: () => ConvertMediaProgress;
+    update: ConvertMediaProgressFn | null;
+    stopAndGetLastProgress: () => void;
+};
+export declare const throttledStateUpdate: ({ updateFn, everyMilliseconds, signal, }: {
+    updateFn: ConvertMediaOnProgress | null;
+    everyMilliseconds: number;
+    signal: AbortSignal;
+}) => ReturnType;
+export {};

package/dist/throttled-state-update.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttledStateUpdate = void 0;
+const throttledStateUpdate = ({ updateFn, everyMilliseconds, signal, }) => {
+    let currentState = {
+        decodedAudioFrames: 0,
+        decodedVideoFrames: 0,
+        encodedVideoFrames: 0,
+        encodedAudioFrames: 0,
+        bytesWritten: 0,
+        millisecondsWritten: 0,
+        expectedOutputDurationInMs: null,
+        overallProgress: 0,
+    };
+    if (!updateFn) {
+        return {
+            get: () => currentState,
+            update: null,
+            stopAndGetLastProgress: () => { },
+        };
+    }
+    let lastUpdated = null;
+    const callUpdateIfChanged = () => {
+        if (currentState === lastUpdated) {
+            return;
+        }
+        updateFn(currentState);
+        lastUpdated = currentState;
+    };
+    const interval = setInterval(() => {
+        callUpdateIfChanged();
+    }, everyMilliseconds);
+    const onAbort = () => {
+        clearInterval(interval);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    return {
+        get: () => currentState,
+        update: (fn) => {
+            currentState = fn(currentState);
+        },
+        stopAndGetLastProgress: () => {
+            clearInterval(interval);
+            signal.removeEventListener('abort', onAbort);
+            return currentState;
+        },
+    };
+};
+exports.throttledStateUpdate = throttledStateUpdate;

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-config.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoEncoderConfig = void 0;
+const browser_quirks_1 = require("./browser-quirks");
 const choose_correct_avc1_profile_1 = require("./choose-correct-avc1-profile");
 const getVideoEncoderConfig = async ({ codec, height, width, fps, }) => {
     if (typeof VideoEncoder === 'undefined') {
@@ -14,6 +15,7 @@ const getVideoEncoderConfig = async ({ codec, height, width, fps, }) => {
                 : codec,
         height,
         width,
+        bitrate: (0, browser_quirks_1.isSafari)() ? 3000000 : undefined,
     };
     const hardware = {
         ...config,