@remotion/webcodecs 4.0.304 → 4.0.306

package/dist/on-video-track.js

@@ -1,19 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeVideoTrackHandler = void 0;
-const arraybuffer_to_uint8_array_1 = require("./arraybuffer-to-uint8-array");
 const can_copy_video_track_1 = require("./can-copy-video-track");
-const convert_encoded_chunk_1 = require("./convert-encoded-chunk");
+const copy_video_track_1 = require("./copy-video-track");
 const default_on_video_track_handler_1 = require("./default-on-video-track-handler");
 const get_default_video_codec_1 = require("./get-default-video-codec");
-const log_1 = require("./log");
-const on_frame_1 = require("./on-frame");
-const rotation_1 = require("./rotation");
-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, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, progress, resizeOperation, }) => async ({ track, container: inputContainer }) => {
+const reencode_video_track_1 = require("./reencode-video-track");
+const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, resizeOperation, progressTracker, }) => async ({ track, container: inputContainer }) => {
     if (controller._internals._mediaParserController._internals.signal.aborted) {
         throw new Error('Aborted');
     }
@@ -41,129 +34,25 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         throw new Error(`Video track with ID ${track.trackId} 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.advancedColor,
-            width: track.codedWidth,
-            height: track.codedHeight,
-            codec: track.codecEnum,
-            codecPrivate: track.codecData?.data ?? null,
-            timescale: track.timescale,
+        return (0, copy_video_track_1.copyVideoTrack)({
+            logLevel,
+            onMediaStateUpdate,
+            state,
+            track,
+            progressTracker,
         });
-        return async (sample) => {
-            await state.addSample({
-                chunk: sample,
-                trackNumber: videoTrack.trackNumber,
-                isVideo: true,
-                codecPrivate: track.codecData?.data ?? null,
-            });
-            onMediaStateUpdate?.((prevState) => {
-                return {
-                    ...prevState,
-                    decodedVideoFrames: prevState.decodedVideoFrames + 1,
-                };
-            });
-        };
     }
-    if (videoOperation.type !== 'reencode') {
-        throw new Error(`Video track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(videoOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
-    }
-    const rotation = (videoOperation.rotate ?? rotate) - track.rotation;
-    const { height: newHeight, width: newWidth } = (0, rotation_1.calculateNewDimensionsFromRotateAndScale)({
-        width: track.codedWidth,
-        height: track.codedHeight,
-        rotation,
-        videoCodec: videoOperation.videoCodec,
-        resizeOperation: videoOperation.resize ?? null,
-    });
-    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
-        codec: videoOperation.videoCodec,
-        height: newHeight,
-        width: newWidth,
-        fps: track.fps,
-    });
-    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
-    log_1.Log.verbose(logLevel, 'Video encoder config', videoEncoderConfig);
-    log_1.Log.verbose(logLevel, 'Video decoder config', videoDecoderConfig ?? track);
-    if (videoEncoderConfig === null) {
-        abortConversion(new Error(`Could not configure video encoder of track ${track.trackId}`));
-        return null;
-    }
-    if (videoDecoderConfig === null) {
-        abortConversion(new Error(`Could not configure video decoder of track ${track.trackId}`));
-        return null;
-    }
-    const { trackNumber } = await state.addTrack({
-        type: 'video',
-        color: track.advancedColor,
-        width: newWidth,
-        height: newHeight,
-        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, metadata) => {
-            await state.addSample({
-                chunk: (0, convert_encoded_chunk_1.convertEncodedChunk)(chunk, trackNumber),
-                trackNumber,
-                isVideo: true,
-                codecPrivate: (0, arraybuffer_to_uint8_array_1.arrayBufferToUint8Array)((metadata?.decoderConfig?.description ??
-                    null)),
-            });
-            onMediaStateUpdate?.((prevState) => {
-                return {
-                    ...prevState,
-                    encodedVideoFrames: prevState.encodedVideoFrames + 1,
-                };
-            });
-        },
-        onError: (err) => {
-            abortConversion(new Error(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
-                cause: err,
-            }));
-        },
-        controller,
-        config: videoEncoderConfig,
-        logLevel,
-        outputCodec: videoOperation.videoCodec,
-        progress,
-    });
-    const videoDecoder = (0, video_decoder_1.createVideoDecoder)({
-        config: videoDecoderConfig,
-        onFrame: async (frame) => {
-            await (0, on_frame_1.onFrame)({
-                frame,
-                track,
-                videoEncoder,
-                onVideoFrame,
-                outputCodec: videoOperation.videoCodec,
-                rotation,
-                resizeOperation: videoOperation.resize ?? null,
-            });
-        },
-        onError: (err) => {
-            abortConversion(new Error(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
-                cause: err,
-            }));
-        },
+    return (0, reencode_video_track_1.reencodeVideoTrack)({
+        videoOperation,
+        abortConversion,
         controller,
         logLevel,
-        progress,
-    });
-    state.addWaitForFinishPromise(async () => {
-        log_1.Log.verbose(logLevel, 'Waiting for video decoder to finish');
-        await videoDecoder.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');
+        rotate,
+        track,
+        onVideoFrame,
+        state,
+        onMediaStateUpdate,
+        progressTracker,
     });
-    return async (chunk) => {
-        await videoDecoder.processSample(chunk);
-    };
 };
 exports.makeVideoTrackHandler = makeVideoTrackHandler;

package/dist/processing-queue.d.ts

@@ -0,0 +1,19 @@
+import type { LogLevel } from './log';
+import type { WebCodecsController } from './webcodecs-controller';
+type Processable = EncodedAudioChunk | EncodedVideoChunk | AudioData | VideoFrame;
+export declare function processingQueue<T extends Processable>({ onOutput, logLevel, label, onError, controller, }: {
+    onOutput: (item: T) => Promise<void>;
+    onError: (error: Error) => void;
+    logLevel: LogLevel;
+    label: string;
+    controller: WebCodecsController;
+}): {
+    input: (item: T) => void;
+    ioSynchronizer: {
+        inputItem: (timestamp: number) => void;
+        onOutput: (timestamp: number) => void;
+        waitForFinish: () => Promise<void>;
+        waitForQueueSize: (queueSize: number) => Promise<void>;
+    };
+};
+export {};

package/dist/processing-queue.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processingQueue = processingQueue;
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+function processingQueue({ onOutput, logLevel, label, onError, controller, }) {
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
+        logLevel,
+        label,
+        controller,
+    });
+    let queue = Promise.resolve();
+    let stopped = false;
+    const input = (item) => {
+        if (stopped) {
+            return;
+        }
+        if (controller._internals._mediaParserController._internals.signal.aborted) {
+            stopped = true;
+            return;
+        }
+        const { timestamp } = item; // Saving in variable, because timestamp might become nulled
+        ioSynchronizer.inputItem(timestamp);
+        queue = queue
+            .then(() => {
+            if (stopped) {
+                return;
+            }
+            if (controller._internals._mediaParserController._internals.signal.aborted) {
+                stopped = true;
+                return;
+            }
+            return onOutput(item);
+        })
+            .then(() => {
+            ioSynchronizer.onOutput(timestamp);
+            return Promise.resolve();
+        })
+            .catch((err) => {
+            stopped = true;
+            onError(err);
+        });
+    };
+    return {
+        input,
+        ioSynchronizer,
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { MediaParserAudioTrack, MediaParserLogLevel, MediaParserOnAudioSample } from '@remotion/media-parser';
+import type { ConvertMediaOnAudioData } from './convert-media';
+import type { MediaFn } from './create/media-fn';
+import type { ProgressTracker } from './create/progress-tracker';
+import type { AudioOperation } from './on-audio-track-handler';
+import type { ConvertMediaProgressFn } from './throttled-state-update';
+import type { WebCodecsController } from './webcodecs-controller';
+export declare const reencodeAudioTrack: ({ audioOperation, track, logLevel, abortConversion, state, controller, onMediaStateUpdate, onAudioData, progressTracker, }: {
+    audioOperation: AudioOperation;
+    track: MediaParserAudioTrack;
+    logLevel: MediaParserLogLevel;
+    abortConversion: (errCause: Error) => void;
+    state: MediaFn;
+    controller: WebCodecsController;
+    onMediaStateUpdate: null | ConvertMediaProgressFn;
+    onAudioData: ConvertMediaOnAudioData | null;
+    progressTracker: ProgressTracker;
+}) => Promise<MediaParserOnAudioSample | null>;

package/dist/reencode-audio-track.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reencodeAudioTrack = 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 convert_encoded_chunk_1 = require("./convert-encoded-chunk");
+const log_1 = require("./log");
+const processing_queue_1 = require("./processing-queue");
+const reencodeAudioTrack = async ({ audioOperation, track, logLevel, abortConversion, state, controller, onMediaStateUpdate, onAudioData, progressTracker, }) => {
+    if (audioOperation.type !== 'reencode') {
+        throw new Error(`Audio track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(audioOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
+    }
+    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.originalTimescale,
+    });
+    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,
+                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,
+    });
+    const audioProcessingQueue = (0, processing_queue_1.processingQueue)({
+        controller,
+        label: 'AudioData processing queue',
+        logLevel,
+        onError(error) {
+            abortConversion(new Error(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
+                cause: error,
+            }));
+        },
+        onOutput: 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 controller._internals._mediaParserController._internals.checkForAbortAndPause();
+            await audioEncoder.ioSynchronizer.waitForQueueSize(10);
+            await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+            audioEncoder.encode(newAudioData);
+            onMediaStateUpdate?.((prevState) => {
+                return {
+                    ...prevState,
+                    decodedAudioFrames: prevState.decodedAudioFrames + 1,
+                };
+            });
+            newAudioData.close();
+        },
+    });
+    const audioDecoder = (0, audio_decoder_1.internalCreateAudioDecoder)({
+        onFrame: async (audioData) => {
+            await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+            await audioProcessingQueue.ioSynchronizer.waitForQueueSize(10);
+            audioProcessingQueue.input(audioData);
+        },
+        onError(error) {
+            abortConversion(new Error(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
+                cause: error,
+            }));
+        },
+        controller,
+        config: audioDecoderConfig,
+        logLevel,
+    });
+    state.addWaitForFinishPromise(async () => {
+        await audioDecoder.waitForFinish();
+        log_1.Log.verbose(logLevel, 'Audio decoder finished');
+        audioDecoder.close();
+        await audioProcessingQueue.ioSynchronizer.waitForFinish();
+        log_1.Log.verbose(logLevel, 'Audio processing queue finished');
+        await audioEncoder.waitForFinish();
+        log_1.Log.verbose(logLevel, 'Audio encoder finished');
+        audioEncoder.close();
+    });
+    return async (audioSample) => {
+        progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, audioSample.decodingTimestamp ?? Infinity));
+        await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+        await audioDecoder.waitForQueueToBeLessThan(10);
+        audioDecoder.decode(audioSample);
+    };
+};
+exports.reencodeAudioTrack = reencodeAudioTrack;

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

@@ -0,0 +1,19 @@
+import type { MediaParserLogLevel, MediaParserOnVideoSample, MediaParserVideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaOnVideoFrame } from './convert-media';
+import type { MediaFn } from './create/media-fn';
+import type { ProgressTracker } from './create/progress-tracker';
+import type { VideoOperation } from './on-video-track-handler';
+import type { ConvertMediaProgressFn } from './throttled-state-update';
+import type { WebCodecsController } from './webcodecs-controller';
+export declare const reencodeVideoTrack: ({ videoOperation, rotate, track, logLevel, abortConversion, onMediaStateUpdate, controller, onVideoFrame, state, progressTracker, }: {
+    videoOperation: VideoOperation;
+    rotate: number;
+    track: MediaParserVideoTrack;
+    logLevel: MediaParserLogLevel;
+    abortConversion: (errCause: Error) => void;
+    onMediaStateUpdate: null | ConvertMediaProgressFn;
+    controller: WebCodecsController;
+    onVideoFrame: ConvertMediaOnVideoFrame | null;
+    state: MediaFn;
+    progressTracker: ProgressTracker;
+}) => Promise<MediaParserOnVideoSample | null>;

package/dist/reencode-video-track.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reencodeVideoTrack = void 0;
+const arraybuffer_to_uint8_array_1 = require("./arraybuffer-to-uint8-array");
+const convert_encoded_chunk_1 = require("./convert-encoded-chunk");
+const log_1 = require("./log");
+const on_frame_1 = require("./on-frame");
+const processing_queue_1 = require("./processing-queue");
+const rotation_1 = require("./rotation");
+const sort_video_frames_1 = require("./sort-video-frames");
+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 reencodeVideoTrack = async ({ videoOperation, rotate, track, logLevel, abortConversion, onMediaStateUpdate, controller, onVideoFrame, state, progressTracker, }) => {
+    if (videoOperation.type !== 'reencode') {
+        throw new Error(`Video track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(videoOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
+    }
+    const rotation = (videoOperation.rotate ?? rotate) - track.rotation;
+    const { height: newHeight, width: newWidth } = (0, rotation_1.calculateNewDimensionsFromRotateAndScale)({
+        width: track.codedWidth,
+        height: track.codedHeight,
+        rotation,
+        videoCodec: videoOperation.videoCodec,
+        resizeOperation: videoOperation.resize ?? null,
+    });
+    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
+        codec: videoOperation.videoCodec,
+        height: newHeight,
+        width: newWidth,
+        fps: track.fps,
+    });
+    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
+    log_1.Log.verbose(logLevel, 'Video encoder config', videoEncoderConfig);
+    log_1.Log.verbose(logLevel, 'Video decoder config', videoDecoderConfig ?? track);
+    if (videoEncoderConfig === null) {
+        abortConversion(new Error(`Could not configure video encoder of track ${track.trackId}`));
+        return null;
+    }
+    if (videoDecoderConfig === null) {
+        abortConversion(new Error(`Could not configure video decoder of track ${track.trackId}`));
+        return null;
+    }
+    const { trackNumber } = await state.addTrack({
+        type: 'video',
+        color: track.advancedColor,
+        width: newWidth,
+        height: newHeight,
+        codec: videoOperation.videoCodec,
+        codecPrivate: null,
+        timescale: track.originalTimescale,
+    });
+    log_1.Log.verbose(logLevel, `Created new video track with ID ${trackNumber}, codec ${videoOperation.videoCodec} and timescale ${track.originalTimescale}`);
+    const videoEncoder = (0, video_encoder_1.createVideoEncoder)({
+        onChunk: async (chunk, metadata) => {
+            await state.addSample({
+                chunk: (0, convert_encoded_chunk_1.convertEncodedChunk)(chunk),
+                trackNumber,
+                isVideo: true,
+                codecPrivate: (0, arraybuffer_to_uint8_array_1.arrayBufferToUint8Array)((metadata?.decoderConfig?.description ?? null)),
+            });
+            onMediaStateUpdate?.((prevState) => {
+                return {
+                    ...prevState,
+                    encodedVideoFrames: prevState.encodedVideoFrames + 1,
+                };
+            });
+        },
+        onError: (err) => {
+            abortConversion(new Error(`Video encoder of track ${track.trackId} failed (see .cause of this error)`, {
+                cause: err,
+            }));
+        },
+        controller,
+        config: videoEncoderConfig,
+        logLevel,
+        outputCodec: videoOperation.videoCodec,
+        keyframeInterval: 40,
+    });
+    const videoProcessingQueue = (0, processing_queue_1.processingQueue)({
+        controller,
+        label: 'VideoFrame processing queue',
+        logLevel,
+        onError: (err) => {
+            abortConversion(new Error(`VideoFrame processing queue of track ${track.trackId} failed (see .cause of this error)`, {
+                cause: err,
+            }));
+        },
+        onOutput: async (frame) => {
+            await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+            const processedFrame = await (0, on_frame_1.onFrame)({
+                frame,
+                track,
+                onVideoFrame,
+                outputCodec: videoOperation.videoCodec,
+                rotation,
+                resizeOperation: videoOperation.resize ?? null,
+            });
+            await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+            await videoEncoder.ioSynchronizer.waitForQueueSize(10);
+            await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+            videoEncoder.encode(processedFrame);
+            processedFrame.close();
+        },
+    });
+    const frameSorter = (0, sort_video_frames_1.videoFrameSorter)({
+        controller,
+        onOutput: async (frame) => {
+            await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+            await videoProcessingQueue.ioSynchronizer.waitForQueueSize(10);
+            videoProcessingQueue.input(frame);
+        },
+    });
+    const videoDecoder = (0, video_decoder_1.createVideoDecoder)({
+        track: videoDecoderConfig,
+        onFrame: async (frame) => {
+            await frameSorter.waitUntilProcessed();
+            frameSorter.inputFrame(frame);
+        },
+        onError: (err) => {
+            abortConversion(new Error(`Video decoder of track ${track.trackId} failed (see .cause of this error)`, {
+                cause: err,
+            }));
+        },
+        controller,
+        logLevel,
+    });
+    state.addWaitForFinishPromise(async () => {
+        log_1.Log.verbose(logLevel, 'Waiting for video decoder to finish');
+        await videoDecoder.waitForFinish();
+        videoDecoder.close();
+        log_1.Log.verbose(logLevel, 'Video decoder finished. Waiting for encoder to finish');
+        await frameSorter.flush();
+        log_1.Log.verbose(logLevel, 'Frame sorter flushed');
+        await videoProcessingQueue.ioSynchronizer.waitForFinish();
+        log_1.Log.verbose(logLevel, 'Video processing queue finished');
+        await videoEncoder.waitForFinish();
+        videoEncoder.close();
+        log_1.Log.verbose(logLevel, 'Video encoder finished');
+    });
+    return async (chunk) => {
+        progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, chunk.decodingTimestamp ?? Infinity));
+        await controller._internals._mediaParserController._internals.checkForAbortAndPause();
+        await videoDecoder.waitForQueueToBeLessThan(10);
+        if (chunk.type === 'key') {
+            await videoDecoder.flush();
+        }
+        videoDecoder.decode(chunk);
+    };
+};
+exports.reencodeVideoTrack = reencodeVideoTrack;

package/dist/sort-video-frames.d.ts

@@ -1,8 +1,9 @@
 import type { WebCodecsController } from './webcodecs-controller';
-export declare const videoFrameSorter: ({ onRelease, controller, }: {
-    onRelease: (frame: VideoFrame) => Promise<void>;
+export declare const videoFrameSorter: ({ controller, onOutput, }: {
     controller: WebCodecsController;
+    onOutput: (frame: VideoFrame) => Promise<void>;
 }) => {
-    inputFrame: (frame: VideoFrame) => Promise<void>;
+    inputFrame: (frame: VideoFrame) => void;
+    waitUntilProcessed: () => Promise<void>;
     flush: () => Promise<void>;
 };

package/dist/sort-video-frames.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.videoFrameSorter = void 0;
 const MAX_QUEUE_SIZE = 5;
-const videoFrameSorter = ({ onRelease, controller, }) => {
+const videoFrameSorter = ({ controller, onOutput, }) => {
     const frames = [];
     const releaseFrame = async () => {
         await controller._internals._mediaParserController._internals.checkForAbortAndPause();
         const frame = frames.shift();
         if (frame) {
-            await onRelease(frame);
+            await onOutput(frame);
         }
     };
     const sortFrames = () => {
@@ -44,8 +44,12 @@ const videoFrameSorter = ({ onRelease, controller, }) => {
         controller._internals._mediaParserController._internals.signal.removeEventListener('abort', onAbort);
     };
     controller._internals._mediaParserController._internals.signal.addEventListener('abort', onAbort);
+    let promise = Promise.resolve();
     return {
-        inputFrame,
+        inputFrame: (frame) => {
+            promise = promise.then(() => inputFrame(frame));
+        },
+        waitUntilProcessed: () => promise,
         flush,
     };
 };

package/dist/video-decoder.d.ts

@@ -1,17 +1,23 @@
 import type { MediaParserLogLevel, MediaParserVideoSample } from '@remotion/media-parser';
-import type { ProgressTracker } from './create/progress-tracker';
 import type { WebCodecsController } from './webcodecs-controller';
 export type WebCodecsVideoDecoder = {
-    processSample: (videoSample: MediaParserVideoSample) => Promise<void>;
-    waitForFinish: () => Promise<void>;
+    decode: (videoSample: MediaParserVideoSample | EncodedVideoChunk) => void;
     close: () => void;
     flush: () => Promise<void>;
+    waitForFinish: () => Promise<void>;
+    waitForQueueToBeLessThan: (items: number) => Promise<void>;
 };
-export declare const createVideoDecoder: ({ onFrame, onError, controller, config, logLevel, progress, }: {
-    onFrame: (frame: VideoFrame) => Promise<void>;
-    onError: (error: DOMException) => void;
-    controller: WebCodecsController;
+export declare const internalCreateVideoDecoder: ({ onFrame, onError, controller, config, logLevel, }: {
+    onFrame: (frame: VideoFrame) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller: WebCodecsController | null;
     config: VideoDecoderConfig;
     logLevel: MediaParserLogLevel;
-    progress: ProgressTracker;
+}) => WebCodecsVideoDecoder;
+export declare const createVideoDecoder: ({ onFrame, onError, controller, track, logLevel, }: {
+    track: VideoDecoderConfig;
+    onFrame: (frame: VideoFrame) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller?: WebCodecsController;
+    logLevel?: MediaParserLogLevel;
 }) => WebCodecsVideoDecoder;