@remotion/webcodecs 4.0.304 → 4.0.306

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

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

package/dist/get-wave-audio-decoder.js

@@ -28,30 +28,35 @@ const getBytesPerSample = (sampleFormat) => {
     }
     throw new Error(`Unsupported sample format: ${sampleFormat}`);
 };
-// TODO: Should also be subject to throttling
-const getWaveAudioDecoder = ({ onFrame, track, sampleFormat, }) => {
-    let queue = Promise.resolve();
+const getWaveAudioDecoder = ({ onFrame, config, sampleFormat, ioSynchronizer, onError, }) => {
     const processSample = async (audioSample) => {
         const bytesPerSample = getBytesPerSample(sampleFormat);
-        await onFrame(new AudioData({
+        const audioData = new AudioData({
             data: audioSample.data,
             format: sampleFormat,
-            numberOfChannels: track.numberOfChannels,
-            numberOfFrames: audioSample.data.byteLength / bytesPerSample / track.numberOfChannels,
-            sampleRate: track.sampleRate,
+            numberOfChannels: config.numberOfChannels,
+            numberOfFrames: audioSample.data.byteLength / bytesPerSample / config.numberOfChannels,
+            sampleRate: config.sampleRate,
             timestamp: audioSample.timestamp,
-        }));
+        });
+        try {
+            await onFrame(audioData);
+        }
+        catch (err) {
+            audioData.close();
+            onError(err);
+        }
     };
     return {
         close() {
             return Promise.resolve();
         },
-        processSample(audioSample) {
-            queue = queue.then(() => processSample(audioSample));
-            return queue;
+        decode(audioSample) {
+            processSample(audioSample);
         },
         flush: () => Promise.resolve(),
         waitForFinish: () => Promise.resolve(),
+        waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
     };
 };
 exports.getWaveAudioDecoder = getWaveAudioDecoder;

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

@@ -1,20 +1,13 @@
-import type { ProgressTracker } from '../create/progress-tracker';
 import type { LogLevel } from '../log';
 import type { WebCodecsController } from '../webcodecs-controller';
-export declare const makeIoSynchronizer: ({ logLevel, label, progress, }: {
+export declare const makeIoSynchronizer: ({ logLevel, label, controller, }: {
     logLevel: LogLevel;
     label: string;
-    progress: ProgressTracker;
+    controller: WebCodecsController | null;
 }) => {
-    inputItem: (timestamp: number, keyFrame: boolean) => void;
+    inputItem: (timestamp: number) => void;
     onOutput: (timestamp: number) => void;
-    waitFor: ({ unprocessed, unemitted, minimumProgress, controller, }: {
-        unemitted: number;
-        unprocessed: number;
-        minimumProgress: number | null;
-        controller: WebCodecsController;
-    }) => Promise<void>;
-    waitForFinish: (controller: WebCodecsController) => Promise<void>;
-    onProcessed: () => void;
-    getUnprocessed: () => number;
+    waitForFinish: () => Promise<void>;
+    waitForQueueSize: (queueSize: number) => Promise<void>;
 };
+export type IoSynchronizer = ReturnType<typeof makeIoSynchronizer>;

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

@@ -5,40 +5,25 @@ const event_emitter_1 = require("../create/event-emitter");
 const with_resolvers_1 = require("../create/with-resolvers");
 const log_1 = require("../log");
 const make_timeout_promise_1 = require("./make-timeout-promise");
-const makeIoSynchronizer = ({ logLevel, label, progress, }) => {
+const makeIoSynchronizer = ({ logLevel, label, controller, }) => {
     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 = () => {
+    const getQueuedItems = () => {
         inputs = inputs.filter((input) => Math.floor(input) > Math.floor(lastOutput));
         return inputs.length;
     };
-    const getUnemittedKeyframes = () => {
-        keyframes = keyframes.filter((keyframe) => Math.floor(keyframe) > Math.floor(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()}`);
+        log_1.Log.trace(logLevel, `[${label}] ${prefix}, state: Last input = ${lastInput} Last output = ${lastOutput} Inputs since last output = ${inputsSinceLastOutput}, Queue = ${getQueuedItems()}`);
     };
-    const inputItem = (timestamp, keyFrame) => {
+    const inputItem = (timestamp) => {
         lastInput = timestamp;
-        if (keyFrame) {
-            lastInputKeyframe = timestamp;
-            keyframes.push(timestamp);
-        }
         inputsSinceLastOutput++;
         inputs.push(timestamp);
         eventEmitter.dispatchEvent('input', {
             timestamp,
-            keyFrame,
         });
         printState('Input item');
     };
@@ -48,7 +33,6 @@ const makeIoSynchronizer = ({ logLevel, label, progress, }) => {
         eventEmitter.dispatchEvent('output', {
             timestamp,
         });
-        _unprocessed++;
         printState('Got output');
     };
     const waitForOutput = () => {
@@ -60,75 +44,50 @@ const makeIoSynchronizer = ({ logLevel, label, progress, }) => {
         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 makeErrorBanner = () => {
+        return [
+            `Waited too long for ${label} to finish:`,
+            `${getQueuedItems()} queued items`,
+            `inputs: ${JSON.stringify(inputs)}`,
+            `last output: ${lastOutput}`,
+        ];
     };
-    const waitFor = async ({ unprocessed, unemitted, minimumProgress, controller, }) => {
-        await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+    const waitForQueueSize = async (queueSize) => {
+        if (getQueuedItems() <= queueSize) {
+            return Promise.resolve();
+        }
         const { timeoutPromise, clear } = (0, make_timeout_promise_1.makeTimeoutPromise)({
             label: () => [
-                `Waited too long for ${label} to finish:`,
-                `${getUnemittedItems()} unemitted items`,
-                `${getUnprocessed()} unprocessed items: ${JSON.stringify(_unprocessed)}`,
-                `smallest progress: ${progress.getSmallestProgress()}`,
-                `inputs: ${JSON.stringify(inputs)}`,
-                `last output: ${lastOutput}`,
-                `wanted: ${unemitted} unemitted items, ${unprocessed} unprocessed items, minimum progress ${minimumProgress}`,
+                ...makeErrorBanner(),
+                `wanted: <${queueSize} queued items`,
                 `Report this at https://remotion.dev/report`,
             ].join('\n'),
             ms: 10000,
             controller,
         });
-        controller._internals._mediaParserController._internals.signal.addEventListener('abort', clear);
+        if (controller) {
+            controller._internals._mediaParserController._internals.signal.addEventListener('abort', clear);
+        }
         await Promise.race([
             timeoutPromise,
-            Promise.all([
-                (async () => {
-                    while (getUnemittedItems() > unemitted) {
-                        await waitForOutput();
-                    }
-                })(),
-                (async () => {
-                    while (getUnprocessed() > unprocessed) {
-                        await waitForProcessed();
-                    }
-                })(),
-                minimumProgress === null || progress.getSmallestProgress() === null
-                    ? Promise.resolve()
-                    : (async () => {
-                        while (progress.getSmallestProgress() < minimumProgress) {
-                            await progress.waitForProgress();
-                        }
-                    })(),
-            ]),
+            (async () => {
+                while (getQueuedItems() > queueSize) {
+                    await waitForOutput();
+                }
+            })(),
         ]).finally(() => clear());
-        controller._internals._mediaParserController._internals.signal.removeEventListener('abort', clear);
-    };
-    const waitForFinish = async (controller) => {
-        await waitFor({
-            unprocessed: 0,
-            unemitted: 0,
-            minimumProgress: null,
-            controller,
-        });
+        if (controller) {
+            controller._internals._mediaParserController._internals.signal.removeEventListener('abort', clear);
+        }
     };
-    const onProcessed = () => {
-        eventEmitter.dispatchEvent('processed', {});
-        _unprocessed--;
+    const waitForFinish = async () => {
+        await waitForQueueSize(0);
     };
     return {
         inputItem,
         onOutput,
-        waitFor,
         waitForFinish,
-        onProcessed,
-        getUnprocessed,
+        waitForQueueSize,
     };
 };
 exports.makeIoSynchronizer = makeIoSynchronizer;

package/dist/io-manager/make-timeout-promise.d.ts

@@ -2,7 +2,7 @@ import type { WebCodecsController } from '../webcodecs-controller';
 export declare const makeTimeoutPromise: ({ label, ms, controller, }: {
     label: () => string;
     ms: number;
-    controller: WebCodecsController;
+    controller: WebCodecsController | null;
 }) => {
     timeoutPromise: Promise<void>;
     clear: () => void;

package/dist/io-manager/make-timeout-promise.js

@@ -19,8 +19,10 @@ const makeTimeoutPromise = ({ label, ms, controller, }) => {
     const onResume = () => {
         set();
     };
-    controller.addEventListener('pause', onPause);
-    controller.addEventListener('resume', onResume);
+    if (controller) {
+        controller.addEventListener('pause', onPause);
+        controller.addEventListener('resume', onResume);
+    }
     return {
         timeoutPromise: promise,
         clear: () => {
@@ -28,8 +30,10 @@ const makeTimeoutPromise = ({ label, ms, controller, }) => {
                 clearTimeout(timeout);
             }
             resolve();
-            controller.removeEventListener('pause', onPause);
-            controller.removeEventListener('resume', onResume);
+            if (controller) {
+                controller.removeEventListener('pause', onPause);
+                controller.removeEventListener('resume', onResume);
+            }
         },
     };
 };

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

@@ -7,7 +7,7 @@ import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
 import type { WebCodecsController } from './webcodecs-controller';
-export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, progressTracker, onAudioData, }: {
+export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, onAudioData, progressTracker, }: {
     state: MediaFn;
     defaultAudioCodec: ConvertMediaAudioCodec | null;
     controller: WebCodecsController;
@@ -16,6 +16,6 @@ export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCo
     onAudioTrack: ConvertMediaOnAudioTrackHandler | null;
     logLevel: MediaParserLogLevel;
     outputContainer: ConvertMediaContainer;
-    progressTracker: ProgressTracker;
     onAudioData: ConvertMediaOnAudioData | null;
+    progressTracker: ProgressTracker;
 }) => MediaParserOnAudioTrack;

package/dist/on-audio-track.js

@@ -1,17 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAudioTrackHandler = void 0;
-const media_parser_1 = require("@remotion/media-parser");
-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 can_copy_audio_track_1 = require("./can-copy-audio-track");
-const convert_encoded_chunk_1 = require("./convert-encoded-chunk");
+const copy_audio_track_1 = require("./copy-audio-track");
 const default_on_audio_track_handler_1 = require("./default-on-audio-track-handler");
 const get_default_audio_codec_1 = require("./get-default-audio-codec");
-const log_1 = require("./log");
-const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, progressTracker, onAudioData, }) => async ({ track, container: inputContainer }) => {
+const reencode_audio_track_1 = require("./reencode-audio-track");
+const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, onAudioData, progressTracker, }) => async ({ track, container: inputContainer }) => {
     const canCopyTrack = (0, can_copy_audio_track_1.canCopyAudioTrack)({
         inputCodec: track.codecEnum,
         outputContainer,
@@ -32,154 +27,24 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controlle
         throw new Error(`Audio track with ID ${track.trackId} 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: track.codecEnum,
-            numberOfChannels: track.numberOfChannels,
-            sampleRate: track.sampleRate,
-            codecPrivate: track.codecData?.data ?? null,
-            timescale: track.timescale,
+        return (0, copy_audio_track_1.copyAudioTrack)({
+            logLevel,
+            onMediaStateUpdate,
+            state,
+            track,
+            progressTracker,
         });
-        log_1.Log.verbose(logLevel, `Copying audio track ${track.trackId} as track ${addedTrack.trackNumber}. Timescale = ${track.timescale}, codec = ${track.codecEnum} (${track.codec}) `);
-        return async (audioSample) => {
-            await state.addSample({
-                chunk: audioSample,
-                trackNumber: addedTrack.trackNumber,
-                isVideo: false,
-                codecPrivate: track.codecData?.data ?? null,
-            });
-            onMediaStateUpdate?.((prevState) => {
-                return {
-                    ...prevState,
-                    encodedAudioFrames: prevState.encodedAudioFrames + 1,
-                };
-            });
-        };
     }
-    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
-        numberOfChannels: track.numberOfChannels,
-        sampleRate: audioOperation.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,
-    });
-    log_1.Log.verbose(logLevel, 'Audio encoder config', audioEncoderConfig);
-    log_1.Log.verbose(logLevel, 'Audio decoder config', audioDecoderConfig ?? track);
-    if (!audioEncoderConfig) {
-        abortConversion(new Error(`Could not configure audio encoder of track ${track.trackId}`));
-        return null;
-    }
-    if (!audioDecoderConfig) {
-        abortConversion(new Error(`Could not configure audio decoder of track ${track.trackId}`));
-        return null;
-    }
-    const codecPrivate = audioOperation.audioCodec === 'aac'
-        ? media_parser_1.MediaParserInternals.createAacCodecPrivate({
-            audioObjectType: 2,
-            sampleRate: audioOperation.sampleRate ?? audioEncoderConfig.sampleRate,
-            channelConfiguration: audioEncoderConfig.numberOfChannels,
-            codecPrivate: null,
-        })
-        : null;
-    const { trackNumber } = await state.addTrack({
-        type: 'audio',
-        codec: audioOperation.audioCodec === 'wav'
-            ? 'pcm-s16'
-            : audioOperation.audioCodec,
-        numberOfChannels: audioEncoderConfig.numberOfChannels,
-        sampleRate: audioOperation.sampleRate ?? audioEncoderConfig.sampleRate,
-        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({
-                chunk: (0, convert_encoded_chunk_1.convertEncodedChunk)(chunk, trackNumber),
-                trackNumber,
-                isVideo: false,
-                codecPrivate,
-            });
-            onMediaStateUpdate?.((prevState) => {
-                return {
-                    ...prevState,
-                    encodedAudioFrames: prevState.encodedAudioFrames + 1,
-                };
-            });
-        },
-        onError: (err) => {
-            abortConversion(new Error(`Audio encoder of track ${track.trackId} failed (see .cause of this error)`, {
-                cause: err,
-            }));
-        },
-        codec: audioOperation.audioCodec,
-        controller,
-        config: audioEncoderConfig,
-        logLevel,
-        progressTracker,
-    });
-    const audioDecoder = (0, audio_decoder_1.createAudioDecoder)({
-        onFrame: async (audioData) => {
-            const newAudioData = onAudioData
-                ? await onAudioData?.({ audioData, track })
-                : audioData;
-            if (newAudioData !== audioData) {
-                if (newAudioData.duration !== audioData.duration) {
-                    throw new Error(`onAudioData returned a different duration than the input audio data. Original duration: ${audioData.duration}, new duration: ${newAudioData.duration}`);
-                }
-                if (newAudioData.numberOfChannels !== audioData.numberOfChannels) {
-                    throw new Error(`onAudioData returned a different number of channels than the input audio data. Original channels: ${audioData.numberOfChannels}, new channels: ${newAudioData.numberOfChannels}`);
-                }
-                if (newAudioData.sampleRate !== audioData.sampleRate) {
-                    throw new Error(`onAudioData returned a different sample rate than the input audio data. Original sample rate: ${audioData.sampleRate}, new sample rate: ${newAudioData.sampleRate}`);
-                }
-                if (newAudioData.format !== audioData.format) {
-                    throw new Error(`onAudioData returned a different format than the input audio data. Original format: ${audioData.format}, new format: ${newAudioData.format}`);
-                }
-                if (newAudioData.timestamp !== audioData.timestamp) {
-                    throw new Error(`onAudioData returned a different timestamp than the input audio data. Original timestamp: ${audioData.timestamp}, new timestamp: ${newAudioData.timestamp}`);
-                }
-                audioData.close();
-            }
-            await audioEncoder.encodeFrame(newAudioData);
-            onMediaStateUpdate?.((prevState) => {
-                return {
-                    ...prevState,
-                    decodedAudioFrames: prevState.decodedAudioFrames + 1,
-                };
-            });
-            newAudioData.close();
-        },
-        onError(error) {
-            abortConversion(new Error(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
-                cause: error,
-            }));
-        },
+    return (0, reencode_audio_track_1.reencodeAudioTrack)({
+        abortConversion,
         controller,
-        config: audioDecoderConfig,
         logLevel,
+        onMediaStateUpdate,
+        audioOperation,
+        onAudioData,
+        state,
         track,
         progressTracker,
     });
-    state.addWaitForFinishPromise(async () => {
-        await audioDecoder.waitForFinish();
-        await audioEncoder.waitForFinish();
-        audioDecoder.close();
-        audioEncoder.close();
-    });
-    return async (audioSample) => {
-        await audioDecoder.processSample(audioSample);
-    };
 };
 exports.makeAudioTrackHandler = makeAudioTrackHandler;

package/dist/on-frame.d.ts

@@ -2,13 +2,11 @@ import type { MediaParserVideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaOnVideoFrame } from './convert-media';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import type { ResizeOperation } from './resizing/mode';
-import type { WebCodecsVideoEncoder } from './video-encoder';
-export declare const onFrame: ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, track, outputCodec, rotation, resizeOperation, }: {
+export declare const onFrame: ({ frame: unrotatedFrame, onVideoFrame, track, outputCodec, rotation, resizeOperation, }: {
     frame: VideoFrame;
     onVideoFrame: ConvertMediaOnVideoFrame | null;
-    videoEncoder: WebCodecsVideoEncoder;
     track: MediaParserVideoTrack;
     outputCodec: ConvertMediaVideoCodec;
     rotation: number;
     resizeOperation: ResizeOperation | null;
-}) => Promise<void>;
+}) => Promise<VideoFrame>;

package/dist/on-frame.js

@@ -4,7 +4,7 @@ exports.onFrame = void 0;
 const browser_quirks_1 = require("./browser-quirks");
 const convert_to_correct_videoframe_1 = require("./convert-to-correct-videoframe");
 const rotate_and_resize_video_frame_1 = require("./rotate-and-resize-video-frame");
-const onFrame = async ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, track, outputCodec, rotation, resizeOperation, }) => {
+const onFrame = async ({ frame: unrotatedFrame, onVideoFrame, track, outputCodec, rotation, resizeOperation, }) => {
     const rotated = (0, rotate_and_resize_video_frame_1.rotateAndResizeVideoFrame)({
         rotation,
         frame: unrotatedFrame,
@@ -18,10 +18,10 @@ const onFrame = async ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, trac
         ? await onVideoFrame({ frame: rotated, track })
         : rotated;
     if (userProcessedFrame.displayWidth !== rotated.displayWidth) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${userProcessedFrame.displayWidth}) than the input frame (${userProcessedFrame.displayHeight})`);
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${userProcessedFrame.displayWidth}) than the input frame (${rotated.displayWidth})`);
     }
     if (userProcessedFrame.displayHeight !== rotated.displayHeight) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${userProcessedFrame.displayHeight}) than the input frame (${userProcessedFrame.displayHeight})`);
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${userProcessedFrame.displayHeight}) than the input frame (${rotated.displayHeight})`);
     }
     // In Safari, calling new VideoFrame() might change the timestamp
     // In flipVideo test from 803000 to 803299
@@ -31,17 +31,16 @@ const onFrame = async ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, trac
     if ((userProcessedFrame.duration ?? 0) !== (rotated.duration ?? 0)) {
         throw new Error(`Returned VideoFrame of track ${track.trackId} has different duration (${userProcessedFrame.duration}) than the input frame (${rotated.duration}). When calling new VideoFrame(), pass {duration: frame.duration} as second argument`);
     }
+    if (rotated !== userProcessedFrame) {
+        rotated.close();
+    }
     const fixedFrame = (0, convert_to_correct_videoframe_1.convertToCorrectVideoFrame)({
         videoFrame: userProcessedFrame,
         outputCodec,
     });
-    await videoEncoder.encodeFrame(fixedFrame, fixedFrame.timestamp);
-    fixedFrame.close();
-    if (rotated !== userProcessedFrame) {
-        rotated.close();
-    }
     if (fixedFrame !== userProcessedFrame) {
-        fixedFrame.close();
+        userProcessedFrame.close();
     }
+    return fixedFrame;
 };
 exports.onFrame = onFrame;

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

@@ -8,7 +8,7 @@ import type { ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
 import type { ResizeOperation } from './resizing/mode';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
 import type { WebCodecsController } from './webcodecs-controller';
-export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, progress, resizeOperation, }: {
+export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, resizeOperation, progressTracker, }: {
     state: MediaFn;
     onVideoFrame: null | ConvertMediaOnVideoFrame;
     onMediaStateUpdate: null | ConvertMediaProgressFn;
@@ -19,6 +19,6 @@ export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaState
     logLevel: MediaParserLogLevel;
     outputContainer: ConvertMediaContainer;
     rotate: number;
-    progress: ProgressTracker;
     resizeOperation: ResizeOperation | null;
+    progressTracker: ProgressTracker;
 }) => MediaParserOnVideoTrack;