@remotion/webcodecs 4.0.227 → 4.0.229

package/dist/event-emitter.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,23 @@
+"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;

package/dist/index.d.ts

@@ -1,5 +1,12 @@
 export { WebCodecsAudioDecoder, createAudioDecoder } from './audio-decoder';
 export { WebCodecsAudioEncoder, createAudioEncoder } from './audio-encoder';
-export { ConvertMediaState, ConvertMediaTo, convertMedia } from './convert-media';
+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 { WebCodecsVideoDecoder, createVideoDecoder } from './video-decoder';
 export { WebCodecsVideoEncoder, createVideoEncoder } from './video-encoder';

package/dist/index.js

@@ -1,10 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVideoEncoder = exports.createVideoDecoder = exports.convertMedia = exports.createAudioEncoder = exports.createAudioDecoder = void 0;
+exports.createVideoEncoder = exports.createVideoDecoder = exports.convertMedia = exports.getAvailableVideoCodecs = 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");
 Object.defineProperty(exports, "createAudioEncoder", { enumerable: true, get: function () { return audio_encoder_1.createAudioEncoder; } });
+var can_copy_audio_track_1 = require("./can-copy-audio-track");
+Object.defineProperty(exports, "canCopyAudioTrack", { enumerable: true, get: function () { return can_copy_audio_track_1.canCopyAudioTrack; } });
+var can_copy_video_track_1 = require("./can-copy-video-track");
+Object.defineProperty(exports, "canCopyVideoTrack", { enumerable: true, get: function () { return can_copy_video_track_1.canCopyVideoTrack; } });
+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, "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 video_decoder_1 = require("./video-decoder");

package/dist/io-manager/event-emitter.d.ts

@@ -0,0 +1,27 @@
+type Input = {
+    timestamp: number;
+    keyFrame: boolean;
+};
+type Output = {
+    timestamp: number;
+};
+type Processed = {};
+type IoEventMap = {
+    input: Input;
+    output: Output;
+    processed: Processed;
+};
+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/io-manager/event-emitter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoEventEmitter = void 0;
+class IoEventEmitter {
+    constructor() {
+        this.listeners = {
+            input: [],
+            output: [],
+            processed: [],
+        };
+    }
+    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;

package/dist/io-manager/io-synchronizer.d.ts

@@ -0,0 +1,12 @@
+import type { LogLevel } from '../log';
+export declare const makeIoSynchronizer: (logLevel: LogLevel, label: string) => {
+    inputItem: (timestamp: number, keyFrame: boolean) => void;
+    onOutput: (timestamp: number) => void;
+    waitFor: ({ _unprocessed, unemitted, }: {
+        unemitted: number;
+        _unprocessed: number;
+    }) => Promise<void>;
+    waitForFinish: () => Promise<void>;
+    onProcessed: () => void;
+    getUnprocessed: () => number;
+};

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIoSynchronizer = void 0;
+const log_1 = require("../log");
+const with_resolvers_1 = require("../with-resolvers");
+const event_emitter_1 = require("./event-emitter");
+const makeIoSynchronizer = (logLevel, label) => {
+    const eventEmitter = new event_emitter_1.IoEventEmitter();
+    let lastInput = 0;
+    let lastInputKeyframe = 0;
+    let lastOutput = 0;
+    let inputsSinceLastOutput = 0;
+    let inputs = [];
+    let keyframes = [];
+    // Once WebCodecs emits items, the user has to handle them
+    // Let's keep count of how many items are unprocessed
+    let unprocessed = 0;
+    const getUnprocessed = () => unprocessed;
+    const getUnemittedItems = () => {
+        inputs = inputs.filter((input) => input > lastOutput);
+        return inputs.length;
+    };
+    const getUnemittedKeyframes = () => {
+        keyframes = keyframes.filter((keyframe) => keyframe > lastOutput);
+        return keyframes.length;
+    };
+    const printState = (prefix) => {
+        log_1.Log.trace(logLevel, `[${label}] ${prefix}, state: Last input = ${lastInput} Last input keyframe = ${lastInputKeyframe} Last output = ${lastOutput} Inputs since last output = ${inputsSinceLastOutput}, Queue = ${getUnemittedItems()} (${getUnemittedKeyframes()} keyframes), Unprocessed = ${getUnprocessed()}`);
+    };
+    const inputItem = (timestamp, keyFrame) => {
+        lastInput = timestamp;
+        if (keyFrame) {
+            lastInputKeyframe = timestamp;
+            keyframes.push(timestamp);
+        }
+        inputsSinceLastOutput++;
+        inputs.push(timestamp);
+        eventEmitter.dispatchEvent('input', {
+            timestamp,
+            keyFrame,
+        });
+        printState('Input item');
+    };
+    const onOutput = (timestamp) => {
+        lastOutput = timestamp;
+        inputsSinceLastOutput = 0;
+        eventEmitter.dispatchEvent('output', {
+            timestamp,
+        });
+        unprocessed++;
+        printState('Got output');
+    };
+    const waitForOutput = () => {
+        const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+        const on = () => {
+            eventEmitter.removeEventListener('output', on);
+            resolve();
+        };
+        eventEmitter.addEventListener('output', on);
+        return promise;
+    };
+    const waitForProcessed = () => {
+        const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+        const on = () => {
+            eventEmitter.removeEventListener('processed', on);
+            resolve();
+        };
+        eventEmitter.addEventListener('processed', on);
+        return promise;
+    };
+    const waitFor = async ({ _unprocessed, unemitted, }) => {
+        while (getUnemittedItems() > unemitted) {
+            await waitForOutput();
+        }
+        while (getUnprocessed() > _unprocessed) {
+            await waitForProcessed();
+        }
+    };
+    const waitForFinish = async () => {
+        await waitFor({ _unprocessed: 0, unemitted: 0 });
+    };
+    const onProcessed = () => {
+        eventEmitter.dispatchEvent('processed', {});
+        unprocessed--;
+    };
+    return {
+        inputItem,
+        onOutput,
+        waitFor,
+        waitForFinish,
+        onProcessed,
+        getUnprocessed,
+    };
+};
+exports.makeIoSynchronizer = makeIoSynchronizer;

package/dist/log.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from '@remotion/media-parser';
+declare const Log: {
+    trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    verbose: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    info: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    warn: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
+    error: (...args: Parameters<typeof console.log>) => void;
+};
+export { Log };
+export type { LogLevel };

package/dist/log.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const { Log } = media_parser_1.MediaParserInternals;
+exports.Log = Log;

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

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

package/dist/on-audio-track.js

@@ -8,32 +8,20 @@ const audio_decoder_1 = require("./audio-decoder");
 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 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, bitrate, }) => async (track) => {
-    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
-        codec: audioCodec,
-        numberOfChannels: track.numberOfChannels,
-        sampleRate: track.sampleRate,
-        bitrate,
-    });
-    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)({
-        codec: track.codec,
-        numberOfChannels: track.numberOfChannels,
-        sampleRate: track.sampleRate,
-        description: track.description,
-    });
-    const audioOperation = await (0, resolve_audio_action_1.resolveAudioAction)({
-        audioDecoderConfig,
-        audioEncoderConfig,
+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,
         track,
-        resolverFunction: onAudioTrack,
+        logLevel,
+        container,
     });
-    if (audioOperation === 'drop') {
+    if (audioOperation.type === 'drop') {
         return null;
     }
-    if (audioOperation === 'copy') {
+    if (audioOperation.type === 'copy') {
         const addedTrack = await state.addTrack({
             type: 'audio',
             codec: audioCodec,
@@ -42,11 +30,23 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
             codecPrivate: track.codecPrivate,
         });
         return async (audioSample) => {
-            await state.addSample(new EncodedAudioChunk(audioSample), addedTrack.trackNumber, false);
+            await state.addSample(audioSample, addedTrack.trackNumber, false);
             convertMediaState.encodedAudioFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         };
     }
+    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        codec: audioOperation.audioCodec,
+        bitrate: audioOperation.bitrate,
+    });
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)({
+        codec: track.codec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        description: track.description,
+    });
     if (!audioEncoderConfig) {
         abortConversion(new error_cause_1.default(`Could not configure audio encoder of track ${track.trackId}`));
         return null;
@@ -64,7 +64,7 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
     });
     const audioEncoder = (0, audio_encoder_1.createAudioEncoder)({
         onChunk: async (chunk) => {
-            await state.addSample(chunk, trackNumber, false);
+            await state.addSample((0, convert_encoded_chunk_1.convertEncodedChunk)(chunk), trackNumber, false);
             convertMediaState.encodedAudioFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         },
@@ -76,6 +76,7 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
         codec: audioCodec,
         signal: controller.signal,
         config: audioEncoderConfig,
+        logLevel,
     });
     const audioDecoder = (0, audio_decoder_1.createAudioDecoder)({
         onFrame: async (frame) => {
@@ -91,6 +92,7 @@ const makeAudioTrackHandler = ({ state, audioCodec, convertMediaState, controlle
         },
         signal: controller.signal,
         config: audioDecoderConfig,
+        logLevel,
     });
     state.addWaitForFinishPromise(async () => {
         await audioDecoder.waitForFinish();

package/dist/on-frame.d.ts

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

package/dist/on-frame.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onFrame = void 0;
+const onFrame = async ({ frame, onVideoFrame, videoEncoder, onMediaStateUpdate, track, convertMediaState, }) => {
+    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})`);
+    }
+    if (newFrame.displayHeight !== frame.displayHeight) {
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${newFrame.displayHeight}) than the input frame (${newFrame.displayHeight})`);
+    }
+    if (newFrame.timestamp !== frame.timestamp) {
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different timestamp (${newFrame.timestamp}) than the input frame (${newFrame.timestamp}). When calling new VideoFrame(), pass {timestamp: frame.timestamp} as second argument`);
+    }
+    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();
+    if (frame !== newFrame) {
+        frame.close();
+    }
+};
+exports.onFrame = onFrame;

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

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

package/dist/on-video-track.js

@@ -4,30 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeVideoTrackHandler = void 0;
+const convert_encoded_chunk_1 = require("./convert-encoded-chunk");
 const error_cause_1 = __importDefault(require("./error-cause"));
+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, }) => async (track) => {
-    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
-        codec: videoCodec === 'vp9' ? 'vp09.00.10.08' : videoCodec,
-        height: track.displayAspectHeight,
-        width: track.displayAspectWidth,
-    });
-    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
-    const videoOperation = await (0, resolve_video_action_1.resolveVideoAction)({
-        videoDecoderConfig,
-        videoEncoderConfig,
+const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, convertMediaState, controller, videoCodec, 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)({
         track,
         videoCodec,
-        resolverFunction: onVideoTrack,
+        logLevel,
+        container,
     });
-    if (videoOperation === 'drop') {
+    if (videoOperation.type === 'drop') {
         return null;
     }
-    if (videoOperation === 'copy') {
+    if (videoOperation.type === 'copy') {
         const videoTrack = await state.addTrack({
             type: 'video',
             color: track.color,
@@ -36,12 +34,18 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
             codec: track.codecWithoutConfig,
             codecPrivate: track.codecPrivate,
         });
-        return (sample) => {
-            state.addSample(new EncodedVideoChunk(sample), videoTrack.trackNumber, true);
+        return async (sample) => {
+            await state.addSample(sample, videoTrack.trackNumber, true);
             convertMediaState.decodedVideoFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         };
     }
+    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
+        codec: videoOperation.videoCodec,
+        height: track.displayAspectHeight,
+        width: track.displayAspectWidth,
+    });
+    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
     if (videoEncoderConfig === null) {
         abortConversion(new error_cause_1.default(`Could not configure video encoder of track ${track.trackId}`));
         return null;
@@ -60,7 +64,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
     });
     const videoEncoder = (0, video_encoder_1.createVideoEncoder)({
         onChunk: async (chunk) => {
-            await state.addSample(chunk, trackNumber, true);
+            await state.addSample((0, convert_encoded_chunk_1.convertEncodedChunk)(chunk), trackNumber, true);
             convertMediaState.encodedVideoFrames++;
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
         },
@@ -71,15 +75,19 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         },
         signal: controller.signal,
         config: videoEncoderConfig,
+        logLevel,
     });
     const videoDecoder = (0, video_decoder_1.createVideoDecoder)({
         config: videoDecoderConfig,
         onFrame: async (frame) => {
-            await (onVideoFrame === null || onVideoFrame === void 0 ? void 0 : onVideoFrame(frame, track));
-            await videoEncoder.encodeFrame(frame);
-            convertMediaState.decodedVideoFrames++;
-            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate({ ...convertMediaState });
-            frame.close();
+            await (0, on_frame_1.onFrame)({
+                convertMediaState,
+                frame,
+                onMediaStateUpdate,
+                track,
+                videoEncoder,
+                onVideoFrame,
+            });
         },
         onError: (err) => {
             abortConversion(new error_cause_1.default(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
@@ -87,6 +95,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
             }));
         },
         signal: controller.signal,
+        logLevel,
     });
     state.addWaitForFinishPromise(async () => {
         await videoDecoder.waitForFinish();

package/dist/polyfill-encoded-audio-chunk.d.ts

@@ -0,0 +1,3 @@
+import type { AudioSample } from '@remotion/media-parser';
+import type { AudioOrVideoSample } from '@remotion/media-parser/src/create/cluster';
+export declare const polyfillAudioChunk: (audioSample: AudioSample) => AudioOrVideoSample;

package/dist/polyfill-encoded-audio-chunk.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polyfillAudioChunk = void 0;
+const polyfillAudioChunk = (audioSample) => { };
+exports.polyfillAudioChunk = polyfillAudioChunk;

package/dist/resolve-audio-action.d.ts

@@ -1,15 +1,19 @@
-import type { AudioTrack } from '@remotion/media-parser';
+import type { AudioTrack, LogLevel } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec } from './codec-id';
-export type AudioOperation = 'reencode' | 'copy' | 'drop';
+import type { ConvertMediaContainer } from './convert-media';
+export type AudioOperation = {
+    type: 'reencode';
+    bitrate: number;
+    audioCodec: ConvertMediaAudioCodec;
+} | {
+    type: 'copy';
+} | {
+    type: 'drop';
+};
 export type ResolveAudioActionFn = (options: {
-    canReencode: boolean;
-    canCopy: boolean;
-}) => AudioOperation | Promise<AudioOperation>;
-export declare const defaultResolveAudioAction: ResolveAudioActionFn;
-export declare const resolveAudioAction: ({ audioDecoderConfig, audioEncoderConfig, track, audioCodec, resolverFunction, }: {
-    audioDecoderConfig: AudioDecoderConfig | null;
-    audioEncoderConfig: AudioEncoderConfig | null;
     track: AudioTrack;
     audioCodec: ConvertMediaAudioCodec;
-    resolverFunction: ResolveAudioActionFn;
-}) => Promise<AudioOperation>;
+    logLevel: LogLevel;
+    container: ConvertMediaContainer;
+}) => AudioOperation | Promise<AudioOperation>;
+export declare const defaultResolveAudioAction: ResolveAudioActionFn;