@remotion/webcodecs 4.0.305 → 4.0.308

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

@@ -1,4 +1,9 @@
-import type { CreateAudioDecoderInit, WebCodecsAudioDecoder } from './audio-decoder';
-export declare const getWaveAudioDecoder: ({ onFrame, track, sampleFormat, }: Pick<CreateAudioDecoderInit, "onFrame" | "track"> & {
+import type { MediaParserLogLevel } from '@remotion/media-parser';
+import type { CreateAudioDecoderInit, WebCodecsAudioDecoder } from './create-audio-decoder';
+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,44 @@ 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 getAudioData = (audioSample) => {
+    if (audioSample instanceof EncodedAudioChunk) {
+        const data = new Uint8Array(audioSample.byteLength);
+        audioSample.copyTo(data);
+        return data;
+    }
+    return audioSample.data;
+};
+const getWaveAudioDecoder = ({ onFrame, config, sampleFormat, ioSynchronizer, onError, }) => {
     const processSample = async (audioSample) => {
         const bytesPerSample = getBytesPerSample(sampleFormat);
-        await onFrame(new AudioData({
-            data: audioSample.data,
+        const data = getAudioData(audioSample);
+        const audioData = new AudioData({
+            data,
             format: sampleFormat,
-            numberOfChannels: track.numberOfChannels,
-            numberOfFrames: audioSample.data.byteLength / bytesPerSample / track.numberOfChannels,
-            sampleRate: track.sampleRate,
+            numberOfChannels: config.numberOfChannels,
+            numberOfFrames: 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) {
+            return processSample(audioSample);
         },
         flush: () => Promise.resolve(),
-        waitForFinish: () => Promise.resolve(),
+        waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
+        reset: () => { },
     };
 };
 exports.getWaveAudioDecoder = getWaveAudioDecoder;

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export { createAudioDecoder } from './audio-decoder';
-export type { WebCodecsAudioDecoder } from './audio-decoder';
 export { createAudioEncoder } from './audio-encoder';
 export type { WebCodecsAudioEncoder } from './audio-encoder';
 export { canCopyAudioTrack } from './can-copy-audio-track';
@@ -9,6 +7,10 @@ export { canReencodeVideoTrack } from './can-reencode-video-track';
 export { convertAudioData, ConvertAudioDataOptions } from './convert-audiodata';
 export { convertMedia } from './convert-media';
 export type { ConvertMediaOnAudioData, ConvertMediaOnProgress, ConvertMediaOnVideoFrame, ConvertMediaProgress, ConvertMediaResult, } from './convert-media';
+export { createAudioDecoder } from './create-audio-decoder';
+export type { WebCodecsAudioDecoder } from './create-audio-decoder';
+export { createVideoDecoder } from './create-video-decoder';
+export type { WebCodecsVideoDecoder } from './create-video-decoder';
 export { defaultOnAudioTrackHandler } from './default-on-audio-track-handler';
 export { defaultOnVideoTrackHandler } from './default-on-video-track-handler';
 export { getAvailableAudioCodecs } from './get-available-audio-codecs';
@@ -22,8 +24,6 @@ export { getDefaultVideoCodec } from './get-default-video-codec';
 export type { AudioOperation, ConvertMediaOnAudioTrackHandler, } from './on-audio-track-handler';
 export type { ConvertMediaOnVideoTrackHandler, VideoOperation, } from './on-video-track-handler';
 export type { ResizeOperation } from './resizing/mode';
-export { createVideoDecoder } from './video-decoder';
-export type { WebCodecsVideoDecoder } from './video-decoder';
 export { createVideoEncoder } from './video-encoder';
 export type { WebCodecsVideoEncoder } from './video-encoder';
 export { webcodecsController } from './webcodecs-controller';

package/dist/index.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebCodecsInternals = exports.webcodecsController = exports.createVideoEncoder = exports.createVideoDecoder = exports.getDefaultVideoCodec = exports.getDefaultAudioCodec = exports.getAvailableVideoCodecs = exports.getAvailableContainers = exports.getAvailableAudioCodecs = exports.defaultOnVideoTrackHandler = exports.defaultOnAudioTrackHandler = exports.convertMedia = exports.convertAudioData = exports.canReencodeVideoTrack = exports.canReencodeAudioTrack = exports.canCopyVideoTrack = exports.canCopyAudioTrack = exports.createAudioEncoder = exports.createAudioDecoder = void 0;
+exports.WebCodecsInternals = exports.webcodecsController = exports.createVideoEncoder = exports.getDefaultVideoCodec = exports.getDefaultAudioCodec = exports.getAvailableVideoCodecs = exports.getAvailableContainers = exports.getAvailableAudioCodecs = exports.defaultOnVideoTrackHandler = exports.defaultOnAudioTrackHandler = exports.createVideoDecoder = exports.createAudioDecoder = exports.convertMedia = exports.convertAudioData = exports.canReencodeVideoTrack = exports.canReencodeAudioTrack = exports.canCopyVideoTrack = exports.canCopyAudioTrack = exports.createAudioEncoder = void 0;
 const rotate_and_resize_video_frame_1 = require("./rotate-and-resize-video-frame");
 const rotation_1 = require("./rotation");
 const set_remotion_imported_1 = require("./set-remotion-imported");
-var audio_decoder_1 = require("./audio-decoder");
-Object.defineProperty(exports, "createAudioDecoder", { enumerable: true, get: function () { return audio_decoder_1.createAudioDecoder; } });
 var audio_encoder_1 = require("./audio-encoder");
 Object.defineProperty(exports, "createAudioEncoder", { enumerable: true, get: function () { return audio_encoder_1.createAudioEncoder; } });
 var can_copy_audio_track_1 = require("./can-copy-audio-track");
@@ -20,6 +18,10 @@ var convert_audiodata_1 = require("./convert-audiodata");
 Object.defineProperty(exports, "convertAudioData", { enumerable: true, get: function () { return convert_audiodata_1.convertAudioData; } });
 var convert_media_1 = require("./convert-media");
 Object.defineProperty(exports, "convertMedia", { enumerable: true, get: function () { return convert_media_1.convertMedia; } });
+var create_audio_decoder_1 = require("./create-audio-decoder");
+Object.defineProperty(exports, "createAudioDecoder", { enumerable: true, get: function () { return create_audio_decoder_1.createAudioDecoder; } });
+var create_video_decoder_1 = require("./create-video-decoder");
+Object.defineProperty(exports, "createVideoDecoder", { enumerable: true, get: function () { return create_video_decoder_1.createVideoDecoder; } });
 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");
@@ -34,8 +36,6 @@ 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");
 Object.defineProperty(exports, "createVideoEncoder", { enumerable: true, get: function () { return video_encoder_1.createVideoEncoder; } });
 var webcodecs_controller_1 = require("./webcodecs-controller");

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

@@ -1,20 +1,12 @@
-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;
+    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,46 @@ 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,
-        });
-    };
-    const onProcessed = () => {
-        eventEmitter.dispatchEvent('processed', {});
-        _unprocessed--;
+        if (controller) {
+            controller._internals._mediaParserController._internals.signal.removeEventListener('abort', clear);
+        }
     };
     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/is-different-video-codec.d.ts

@@ -0,0 +1,11 @@
+import type { MediaParserAudioCodec, MediaParserVideoCodec } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+export declare const isSameVideoCodec: ({ inputVideoCodec, outputCodec, }: {
+    inputVideoCodec: MediaParserVideoCodec;
+    outputCodec: ConvertMediaVideoCodec;
+}) => boolean;
+export declare const isSameAudioCodec: ({ inputAudioCodec, outputCodec, }: {
+    inputAudioCodec: MediaParserAudioCodec;
+    outputCodec: ConvertMediaAudioCodec;
+}) => boolean;

package/dist/is-different-video-codec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameAudioCodec = exports.isSameVideoCodec = void 0;
+const isSameVideoCodec = ({ inputVideoCodec, outputCodec, }) => {
+    if (outputCodec === 'h264') {
+        return inputVideoCodec === 'h264';
+    }
+    if (outputCodec === 'h265') {
+        return inputVideoCodec === 'h265';
+    }
+    if (outputCodec === 'vp8') {
+        return inputVideoCodec === 'vp8';
+    }
+    if (outputCodec === 'vp9') {
+        return inputVideoCodec === 'vp9';
+    }
+    throw new Error(`Unsupported output codec: ${outputCodec}`);
+};
+exports.isSameVideoCodec = isSameVideoCodec;
+const isSameAudioCodec = ({ inputAudioCodec, outputCodec, }) => {
+    if (outputCodec === 'aac') {
+        return inputAudioCodec === 'aac';
+    }
+    if (outputCodec === 'opus') {
+        return inputAudioCodec === 'opus';
+    }
+    if (outputCodec === 'wav') {
+        return (inputAudioCodec === 'pcm-f32' ||
+            inputAudioCodec === 'pcm-s16' ||
+            inputAudioCodec === 'pcm-s24' ||
+            inputAudioCodec === 'pcm-s32' ||
+            inputAudioCodec === 'pcm-u8');
+    }
+    throw new Error(`Unsupported output codec: ${outputCodec}`);
+};
+exports.isSameAudioCodec = isSameAudioCodec;

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,21 +1,17 @@
 "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,
         inputContainer,
+        outputAudioCodec: audioCodec,
     });
     const audioOperation = await (onAudioTrack ?? default_on_audio_track_handler_1.defaultOnAudioTrackHandler)({
         defaultAudioCodec: audioCodec ?? (0, get_default_audio_codec_1.getDefaultAudioCodec)({ container: outputContainer }),
@@ -32,154 +28,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.originalTimescale,
+        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.originalTimescale}, 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.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,
-        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>;