@remotion/webcodecs 4.0.229 → 4.0.230

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultAudioCodec = void 0;
+const getDefaultAudioCodec = ({ container, }) => {
+    if (container === 'webm') {
+        return 'opus';
+    }
+    if (container === 'mp4') {
+        return 'aac';
+    }
+    throw new Error(`Unhandled container: ${container}`);
+};
+exports.getDefaultAudioCodec = getDefaultAudioCodec;

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

@@ -0,0 +1,4 @@
+import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+export declare const getDefaultVideoCodec: ({ container, }: {
+    container: ConvertMediaContainer;
+}) => ConvertMediaVideoCodec;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultVideoCodec = void 0;
+const getDefaultVideoCodec = ({ container, }) => {
+    if (container === 'webm') {
+        return 'vp8';
+    }
+    throw new Error(`Unhandled container: ${container} satisfies never`);
+};
+exports.getDefaultVideoCodec = getDefaultVideoCodec;

package/dist/index.d.ts

@@ -4,9 +4,13 @@ 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, ConvertMediaVideoCodec, getAvailableAudioCodecs, getAvailableVideoCodecs, } from './codec-id';
-export { ConvertMediaContainer, ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaResult, ConvertMediaState, convertMedia, } from './convert-media';
-export { AudioOperation, ResolveAudioActionFn } from './resolve-audio-action';
-export { ResolveVideoActionFn, VideoOperation } from './resolve-video-action';
+export { ConvertMediaAudioCodec, ConvertMediaContainer, ConvertMediaVideoCodec, getAvailableAudioCodecs, getAvailableContainers, getAvailableVideoCodecs, } from './codec-id';
+export { ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaResult, ConvertMediaState, convertMedia, } from './convert-media';
+export { defaultOnAudioTrackHandler } from './default-on-audio-track-handler';
+export { defaultOnVideoTrackHandler } from './default-on-video-track-handler';
+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';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVideoEncoder = exports.createVideoDecoder = exports.convertMedia = exports.getAvailableVideoCodecs = 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.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;
 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");
@@ -15,9 +15,18 @@ 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_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");
+Object.defineProperty(exports, "getDefaultVideoCodec", { enumerable: true, get: function () { return get_default_video_codec_1.getDefaultVideoCodec; } });
 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");

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

@@ -17,11 +17,11 @@ const makeIoSynchronizer = (logLevel, label) => {
     let unprocessed = 0;
     const getUnprocessed = () => unprocessed;
     const getUnemittedItems = () => {
-        inputs = inputs.filter((input) => input > lastOutput);
+        inputs = inputs.filter((input) => Math.floor(input) > Math.floor(lastOutput));
         return inputs.length;
     };
     const getUnemittedKeyframes = () => {
-        keyframes = keyframes.filter((keyframe) => keyframe > lastOutput);
+        keyframes = keyframes.filter((keyframe) => Math.floor(keyframe) > Math.floor(lastOutput));
         return keyframes.length;
     };
     const printState = (prefix) => {

package/dist/{resolve-audio-action.d.ts → on-audio-track-handler.d.ts}

@@ -1,19 +1,19 @@
 import type { AudioTrack, LogLevel } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
-import type { ConvertMediaContainer } from './convert-media';
+import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
 export type AudioOperation = {
     type: 'reencode';
     bitrate: number;
     audioCodec: ConvertMediaAudioCodec;
 } | {
     type: 'copy';
+} | {
+    type: 'fail';
 } | {
     type: 'drop';
 };
-export type ResolveAudioActionFn = (options: {
+export type ConvertMediaOnAudioTrackHandler = (options: {
     track: AudioTrack;
-    audioCodec: ConvertMediaAudioCodec;
+    defaultAudioCodec: ConvertMediaAudioCodec | null;
     logLevel: LogLevel;
     container: ConvertMediaContainer;
 }) => AudioOperation | Promise<AudioOperation>;
-export declare const defaultResolveAudioAction: ResolveAudioActionFn;

package/dist/on-audio-track-handler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,16 +1,16 @@
 import type { LogLevel, MediaFn, OnAudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
-import type { ConvertMediaContainer, ConvertMediaState } from './convert-media';
+import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaState } from './convert-media';
 import Error from './error-cause';
-import type { ResolveAudioActionFn } from './resolve-audio-action';
-export declare const makeAudioTrackHandler: ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }: {
+import type { ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
+export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }: {
     state: MediaFn;
-    audioCodec: ConvertMediaAudioCodec;
+    defaultAudioCodec: ConvertMediaAudioCodec | null;
     convertMediaState: ConvertMediaState;
     controller: AbortController;
     abortConversion: (errCause: Error) => void;
     onMediaStateUpdate: null | ((state: ConvertMediaState) => void);
-    onAudioTrack: ResolveAudioActionFn | null;
+    onAudioTrack: ConvertMediaOnAudioTrackHandler | null;
     logLevel: LogLevel;
     container: ConvertMediaContainer;
 }) => OnAudioTrack;

package/dist/on-audio-track.js

@@ -9,11 +9,12 @@ const audio_decoder_config_1 = require("./audio-decoder-config");
 const audio_encoder_1 = require("./audio-encoder");
 const audio_encoder_config_1 = require("./audio-encoder-config");
 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 resolve_audio_action_1 = require("./resolve-audio-action");
-const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }) => async (track) => {
-    const audioOperation = await (onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : resolve_audio_action_1.defaultResolveAudioAction)({
-        audioCodec,
+const log_1 = require("./log");
+const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, convertMediaState, 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,
         logLevel,
         container,
@@ -21,16 +22,27 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
     if (audioOperation.type === 'drop') {
         return null;
     }
+    if (audioOperation.type === 'fail') {
+        throw new error_cause_1.default(`Audio track with ID ${track.trackId} could resolved with {"type": "fail"}. This could mean that this audio track could neither be copied to the output container or re-encoded. You have the option to drop the track instead of failing it: https://remotion.dev/docs/webcodecs/track-transformation`);
+    }
     if (audioOperation.type === 'copy') {
         const addedTrack = await state.addTrack({
             type: 'audio',
-            codec: audioCodec,
+            codec: track.codecWithoutConfig,
             numberOfChannels: track.numberOfChannels,
             sampleRate: track.sampleRate,
             codecPrivate: track.codecPrivate,
+            timescale: track.timescale,
         });
+        log_1.Log.verbose(logLevel, `Copying audio track ${track.trackId} as track ${addedTrack.trackNumber}. Timescale = ${track.timescale}, codec = ${track.codecWithoutConfig} (${track.codec}) `);
         return async (audioSample) => {
-            await state.addSample(audioSample, addedTrack.trackNumber, false);
+            await state.addSample({
+                chunk: audioSample,
+                trackNumber: addedTrack.trackNumber,
+                isVideo: false,
+                timescale: track.timescale,
+                codecPrivate: track.codecPrivate,
+            });
             convertMediaState.encodedAudioFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         };
@@ -55,16 +67,31 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
         abortConversion(new error_cause_1.default(`Could not configure audio decoder of track ${track.trackId}`));
         return null;
     }
+    const codecPrivate = audioOperation.audioCodec === 'aac' ? new Uint8Array([17, 144]) : null;
     const { trackNumber } = await state.addTrack({
         type: 'audio',
-        codec: audioCodec,
+        codec: audioOperation.audioCodec,
         numberOfChannels: track.numberOfChannels,
         sampleRate: track.sampleRate,
-        codecPrivate: null,
+        codecPrivate,
+        timescale: track.timescale,
     });
     const audioEncoder = (0, audio_encoder_1.createAudioEncoder)({
+        // This is weird 😵‍💫
+        // Chrome completely ignores the sample rate and uses it's own
+        // We cannot determine it here because it depends on the system
+        // sample rate. Unhardcode then declare it later once we know.
+        onNewAudioSampleRate: (sampleRate) => {
+            state.updateTrackSampleRate({ sampleRate, trackNumber });
+        },
         onChunk: async (chunk) => {
-            await state.addSample((0, convert_encoded_chunk_1.convertEncodedChunk)(chunk), trackNumber, false);
+            await state.addSample({
+                chunk: (0, convert_encoded_chunk_1.convertEncodedChunk)(chunk, trackNumber),
+                trackNumber,
+                isVideo: false,
+                timescale: track.timescale,
+                codecPrivate,
+            });
             convertMediaState.encodedAudioFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         },
@@ -73,7 +100,7 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
                 cause: err,
             }));
         },
-        codec: audioCodec,
+        codec: audioOperation.audioCodec,
         signal: controller.signal,
         config: audioEncoderConfig,
         logLevel,

package/dist/{resolve-video-action.d.ts → on-video-track-handler.d.ts}

@@ -1,6 +1,5 @@
 import type { LogLevel, VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
-import type { ConvertMediaContainer } from './convert-media';
+import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
 export type VideoOperation = {
     type: 'reencode';
     videoCodec: ConvertMediaVideoCodec;
@@ -8,11 +7,12 @@ export type VideoOperation = {
     type: 'copy';
 } | {
     type: 'drop';
+} | {
+    type: 'fail';
 };
-export type ResolveVideoActionFn = (options: {
-    videoCodec: ConvertMediaVideoCodec;
+export type ConvertMediaOnVideoTrackHandler = (options: {
+    defaultVideoCodec: ConvertMediaVideoCodec | null;
     track: VideoTrack;
     logLevel: LogLevel;
     container: ConvertMediaContainer;
 }) => VideoOperation | Promise<VideoOperation>;
-export declare const defaultResolveVideoAction: ResolveVideoActionFn;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,17 +1,17 @@
 import type { LogLevel, MediaFn, OnVideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
-import type { ConvertMediaContainer, ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaState } from './convert-media';
+import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaOnMediaStateUpdate, ConvertMediaOnVideoFrame, ConvertMediaState } from './convert-media';
 import Error from './error-cause';
-import type { ResolveVideoActionFn } from './resolve-video-action';
-export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, onVideoTrack, logLevel, container, }: {
+import type { ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
+export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }: {
     state: MediaFn;
     onVideoFrame: null | ConvertMediaOnVideoFrame;
     onMediaStateUpdate: null | ConvertMediaOnMediaStateUpdate;
     abortConversion: (errCause: Error) => void;
     convertMediaState: ConvertMediaState;
     controller: AbortController;
-    videoCodec: ConvertMediaVideoCodec;
-    onVideoTrack: ResolveVideoActionFn | null;
+    defaultVideoCodec: ConvertMediaVideoCodec | null;
+    onVideoTrack: ConvertMediaOnVideoTrackHandler | null;
     logLevel: LogLevel;
     container: ConvertMediaContainer;
 }) => OnVideoTrack;

package/dist/on-video-track.js

@@ -4,28 +4,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeVideoTrackHandler = void 0;
+const arraybuffer_to_uint8_array_1 = require("./arraybuffer-to-uint8-array");
 const convert_encoded_chunk_1 = require("./convert-encoded-chunk");
+const default_on_video_track_handler_1 = require("./default-on-video-track-handler");
 const error_cause_1 = __importDefault(require("./error-cause"));
+const log_1 = require("./log");
 const on_frame_1 = require("./on-frame");
-const resolve_video_action_1 = require("./resolve-video-action");
 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, videoCodec, onVideoTrack, logLevel, container, }) => async (track) => {
+const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }) => async (track) => {
     if (controller.signal.aborted) {
         throw new error_cause_1.default('Aborted');
     }
-    const videoOperation = await (onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : resolve_video_action_1.defaultResolveVideoAction)({
+    const videoOperation = await (onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : default_on_video_track_handler_1.defaultOnVideoTrackHandler)({
         track,
-        videoCodec,
+        defaultVideoCodec,
         logLevel,
         container,
     });
     if (videoOperation.type === 'drop') {
         return null;
     }
+    if (videoOperation.type === 'fail') {
+        throw new error_cause_1.default(`Video track with ID ${track.trackId} could resolved with {"type": "fail"}. This could mean that this video track could neither be copied to the output container or re-encoded. You have the option to drop the track instead of failing it: https://remotion.dev/docs/webcodecs/track-transformation`);
+    }
     if (videoOperation.type === 'copy') {
+        log_1.Log.verbose(logLevel, `Copying video track with codec ${track.codec} and timescale ${track.timescale}`);
         const videoTrack = await state.addTrack({
             type: 'video',
             color: track.color,
@@ -33,9 +39,16 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
             height: track.codedHeight,
             codec: track.codecWithoutConfig,
             codecPrivate: track.codecPrivate,
+            timescale: track.timescale,
         });
         return async (sample) => {
-            await state.addSample(sample, videoTrack.trackNumber, true);
+            await state.addSample({
+                chunk: sample,
+                trackNumber: videoTrack.trackNumber,
+                isVideo: true,
+                timescale: track.timescale,
+                codecPrivate: track.codecPrivate,
+            });
             convertMediaState.decodedVideoFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         };
@@ -44,6 +57,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         codec: videoOperation.videoCodec,
         height: track.displayAspectHeight,
         width: track.displayAspectWidth,
+        fps: track.fps,
     });
     const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
     if (videoEncoderConfig === null) {
@@ -59,12 +73,21 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         color: track.color,
         width: track.codedWidth,
         height: track.codedHeight,
-        codec: videoCodec,
+        codec: videoOperation.videoCodec,
         codecPrivate: null,
+        timescale: track.timescale,
     });
+    log_1.Log.verbose(logLevel, `Created new video track with ID ${trackNumber}, codec ${videoOperation.videoCodec} and timescale ${track.timescale}`);
     const videoEncoder = (0, video_encoder_1.createVideoEncoder)({
-        onChunk: async (chunk) => {
-            await state.addSample((0, convert_encoded_chunk_1.convertEncodedChunk)(chunk), trackNumber, true);
+        onChunk: async (chunk, metadata) => {
+            var _a, _b;
+            await state.addSample({
+                chunk: (0, convert_encoded_chunk_1.convertEncodedChunk)(chunk, trackNumber),
+                trackNumber,
+                isVideo: true,
+                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 });
         },
@@ -98,10 +121,13 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         logLevel,
     });
     state.addWaitForFinishPromise(async () => {
+        log_1.Log.verbose(logLevel, 'Waiting for video decoder to finish');
         await videoDecoder.waitForFinish();
-        await videoEncoder.waitForFinish();
         videoDecoder.close();
+        log_1.Log.verbose(logLevel, 'Video decoder finished. Waiting for encoder to finish');
+        await videoEncoder.waitForFinish();
         videoEncoder.close();
+        log_1.Log.verbose(logLevel, 'Encoder finished');
     });
     return async (chunk) => {
         await videoDecoder.processSample(chunk);

package/dist/video-decoder.d.ts

@@ -1,6 +1,6 @@
-import type { LogLevel, VideoSample } from '@remotion/media-parser';
+import type { AudioOrVideoSample, LogLevel } from '@remotion/media-parser';
 export type WebCodecsVideoDecoder = {
-    processSample: (videoSample: VideoSample) => Promise<void>;
+    processSample: (videoSample: AudioOrVideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;

package/dist/video-decoder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoDecoder = void 0;
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const log_1 = require("./log");
 const createVideoDecoder = ({ onFrame, onError, signal, config, logLevel, }) => {
     const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Video decoder');
     let outputQueue = Promise.resolve();
@@ -69,9 +70,13 @@ const createVideoDecoder = ({ onFrame, onError, signal, config, logLevel, }) =>
         },
         waitForFinish: async () => {
             await videoDecoder.flush();
+            log_1.Log.verbose(logLevel, 'Flushed video decoder');
             await ioSynchronizer.waitForFinish();
+            log_1.Log.verbose(logLevel, 'IO synchro finished');
             await outputQueue;
+            log_1.Log.verbose(logLevel, 'Output queue finished');
             await inputQueue;
+            log_1.Log.verbose(logLevel, 'Input queue finished');
         },
         close,
         flush: async () => {

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

@@ -1,6 +1,7 @@
 import type { ConvertMediaVideoCodec } from './codec-id';
-export declare const getVideoEncoderConfig: ({ width, height, codec, }: {
+export declare const getVideoEncoderConfig: ({ codec, height, width, fps, }: {
     width: number;
     height: number;
     codec: ConvertMediaVideoCodec;
+    fps: number | null;
 }) => Promise<VideoEncoderConfig | null>;

package/dist/video-encoder-config.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoEncoderConfig = void 0;
-const getVideoEncoderConfig = async ({ width, height, codec, }) => {
+const choose_correct_avc1_profile_1 = require("./choose-correct-avc1-profile");
+const getVideoEncoderConfig = async ({ codec, height, width, fps, }) => {
     if (typeof VideoEncoder === 'undefined') {
         return null;
     }
     const config = {
-        codec: codec === 'vp9' ? 'vp09.00.10.08' : codec,
+        codec: codec === 'h264'
+            ? (0, choose_correct_avc1_profile_1.chooseCorrectAvc1Profile)({ fps, height, width })
+            : codec === 'vp9'
+                ? 'vp09.00.10.08'
+                : codec,
         height,
         width,
     };

package/dist/video-encoder.d.ts

@@ -6,7 +6,7 @@ export type WebCodecsVideoEncoder = {
     flush: () => Promise<void>;
 };
 export declare const createVideoEncoder: ({ onChunk, onError, signal, config, logLevel, }: {
-    onChunk: (chunk: EncodedVideoChunk) => Promise<void>;
+    onChunk: (chunk: EncodedVideoChunk, metadata: EncodedVideoChunkMetadata | null) => Promise<void>;
     onError: (error: DOMException) => void;
     signal: AbortSignal;
     config: VideoEncoderConfig;

package/dist/video-encoder.js

@@ -12,18 +12,16 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, }) =>
         error(error) {
             onError(error);
         },
-        output(chunk) {
-            if (chunk.duration === null) {
-                throw new Error('Duration is null');
-            }
-            const timestamp = chunk.timestamp + chunk.duration;
+        output(chunk, metadata) {
+            var _a;
+            const timestamp = chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0);
             ioSynchronizer.onOutput(timestamp);
             outputQueue = outputQueue
                 .then(() => {
                 if (signal.aborted) {
                     return;
                 }
-                return onChunk(chunk);
+                return onChunk(chunk, metadata !== null && metadata !== void 0 ? metadata : null);
             })
                 .then(() => {
                 ioSynchronizer.onProcessed();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.229",
+  "version": "4.0.230",
   "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.229"
+    "@remotion/media-parser": "4.0.230"
   },
   "peerDependencies": {},
   "devDependencies": {
     "@types/dom-webcodecs": "0.1.11",
     "eslint": "9.14.0",
-    "@remotion/eslint-config-internal": "4.0.229"
+    "@remotion/eslint-config-internal": "4.0.230"
   },
   "keywords": [],
   "publishConfig": {

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

@@ -1,7 +0,0 @@
-import type { AudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
-export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
-    track: AudioTrack;
-    audioCodec: ConvertMediaAudioCodec;
-    bitrate: number;
-}) => Promise<boolean>;

package/dist/can-reencode-audio.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.canReencodeAudioTrack = void 0;
-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)({
-        codec: track.codec,
-        numberOfChannels: track.numberOfChannels,
-        sampleRate: track.sampleRate,
-        description: track.description,
-    });
-    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
-        codec: audioCodec,
-        numberOfChannels: track.numberOfChannels,
-        sampleRate: track.sampleRate,
-        bitrate,
-    });
-    return Boolean(audioDecoderConfig && audioEncoderConfig);
-};
-exports.canReencodeAudioTrack = canReencodeAudioTrack;

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

@@ -1,6 +0,0 @@
-import type { VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
-export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
-    videoCodec: ConvertMediaVideoCodec;
-    track: VideoTrack;
-}) => Promise<boolean>;

package/dist/can-reencode-video.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.canReencodeVideoTrack = void 0;
-const video_decoder_config_1 = require("./video-decoder-config");
-const video_encoder_config_1 = require("./video-encoder-config");
-const canReencodeVideoTrack = async ({ videoCodec, track, }) => {
-    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
-        codec: videoCodec,
-        height: track.displayAspectHeight,
-        width: track.displayAspectWidth,
-    });
-    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
-    return Boolean(videoDecoderConfig && videoEncoderConfig);
-};
-exports.canReencodeVideoTrack = canReencodeVideoTrack;

package/dist/event-emitter.d.ts

@@ -1,25 +0,0 @@
-type Input = {
-    timestamp: number;
-    keyframe: boolean;
-};
-type Output = {
-    timestamp: number;
-};
-type IoEventMap = {
-    input: Input;
-    output: Output;
-};
-export type IoEventTypes = keyof IoEventMap;
-export type CallbackListener<T extends IoEventTypes> = (data: {
-    detail: IoEventMap[T];
-}) => void;
-type IoListeners = {
-    [EventType in IoEventTypes]: CallbackListener<EventType>[];
-};
-export declare class IoEventEmitter {
-    listeners: IoListeners;
-    addEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
-    removeEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
-    dispatchEvent<T extends IoEventTypes>(dispatchName: T, context: IoEventMap[T]): void;
-}
-export {};

package/dist/event-emitter.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IoEventEmitter = void 0;
-class IoEventEmitter {
-    constructor() {
-        this.listeners = {
-            input: [],
-            output: [],
-        };
-    }
-    addEventListener(name, callback) {
-        this.listeners[name].push(callback);
-    }
-    removeEventListener(name, callback) {
-        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
-    }
-    dispatchEvent(dispatchName, context) {
-        this.listeners[dispatchName].forEach((callback) => {
-            callback({ detail: context });
-        });
-    }
-}
-exports.IoEventEmitter = IoEventEmitter;