@remotion/webcodecs 4.0.305 → 4.0.306

package/dist/audio-decoder.d.ts

@@ -1,19 +1,24 @@
-import type { MediaParserAudioSample, MediaParserAudioTrack, MediaParserLogLevel } from '@remotion/media-parser';
-import type { ProgressTracker } from './create/progress-tracker';
+import type { MediaParserAudioSample, MediaParserLogLevel } from '@remotion/media-parser';
 import type { WebCodecsController } from './webcodecs-controller';
 export type WebCodecsAudioDecoder = {
-    processSample: (audioSample: MediaParserAudioSample) => Promise<void>;
-    waitForFinish: () => Promise<void>;
+    decode: (audioSample: MediaParserAudioSample) => void;
     close: () => void;
     flush: () => Promise<void>;
+    waitForFinish: () => Promise<void>;
+    waitForQueueToBeLessThan: (items: number) => Promise<void>;
 };
 export type CreateAudioDecoderInit = {
-    onFrame: (frame: AudioData) => Promise<void>;
-    onError: (error: DOMException) => void;
-    controller: WebCodecsController;
+    onFrame: (frame: AudioData) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller: WebCodecsController | null;
     config: AudioDecoderConfig;
     logLevel: MediaParserLogLevel;
-    track: MediaParserAudioTrack;
-    progressTracker: ProgressTracker;
 };
-export declare const createAudioDecoder: ({ onFrame, onError, controller, config, logLevel, track, progressTracker, }: CreateAudioDecoderInit) => WebCodecsAudioDecoder;
+export declare const internalCreateAudioDecoder: ({ onFrame, onError, controller, config, logLevel, }: CreateAudioDecoderInit) => WebCodecsAudioDecoder;
+export declare const createAudioDecoder: ({ onFrame, onError, controller, track, logLevel, }: {
+    track: AudioDecoderConfig;
+    onFrame: (frame: AudioData | EncodedAudioChunk) => Promise<void> | void;
+    onError: (error: Error) => void;
+    controller?: WebCodecsController | null;
+    logLevel?: MediaParserLogLevel;
+}) => WebCodecsAudioDecoder;

package/dist/audio-decoder.js

@@ -1,56 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAudioDecoder = void 0;
+exports.createAudioDecoder = exports.internalCreateAudioDecoder = void 0;
 const get_wave_audio_decoder_1 = require("./get-wave-audio-decoder");
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
-const createAudioDecoder = ({ onFrame, onError, controller, config, logLevel, track, progressTracker, }) => {
-    if (controller._internals._mediaParserController._internals.signal.aborted) {
+const internalCreateAudioDecoder = ({ onFrame, onError, controller, config, logLevel, }) => {
+    if (controller &&
+        controller._internals._mediaParserController._internals.signal.aborted) {
         throw new Error('Not creating audio decoder, already aborted');
     }
-    if (config.codec === 'pcm-s16') {
-        return (0, get_wave_audio_decoder_1.getWaveAudioDecoder)({ onFrame, track, sampleFormat: 's16' });
-    }
     const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
         logLevel,
         label: 'Audio decoder',
-        progress: progressTracker,
+        controller,
     });
-    let outputQueue = Promise.resolve();
+    if (config.codec === 'pcm-s16') {
+        return (0, get_wave_audio_decoder_1.getWaveAudioDecoder)({
+            onFrame,
+            config,
+            sampleFormat: 's16',
+            logLevel,
+            ioSynchronizer,
+            onError,
+        });
+    }
     const audioDecoder = new AudioDecoder({
-        output(frame) {
-            ioSynchronizer.onOutput(frame.timestamp + (frame.duration ?? 0));
-            const abortHandler = () => {
-                frame.close();
-            };
-            controller._internals._mediaParserController._internals.signal.addEventListener('abort', abortHandler, {
-                once: true,
-            });
-            outputQueue = outputQueue
-                .then(() => {
-                if (controller._internals._mediaParserController._internals.signal
-                    .aborted) {
-                    return;
-                }
-                return onFrame(frame);
-            })
-                .then(() => {
-                ioSynchronizer.onProcessed();
-                controller._internals._mediaParserController._internals.signal.removeEventListener('abort', abortHandler);
-                return Promise.resolve();
-            })
-                .catch((err) => {
+        async output(frame) {
+            try {
+                await onFrame(frame);
+            }
+            catch (err) {
                 frame.close();
                 onError(err);
-            });
+            }
+            ioSynchronizer.onOutput(frame.timestamp + (frame.duration ?? 0));
         },
         error(error) {
             onError(error);
         },
     });
     const close = () => {
-        controller._internals._mediaParserController._internals.signal.removeEventListener('abort', 
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        onAbort);
+        if (controller) {
+            controller._internals._mediaParserController._internals.signal.removeEventListener('abort', 
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            onAbort);
+        }
         if (audioDecoder.state === 'closed') {
             return;
         }
@@ -59,21 +52,18 @@ const createAudioDecoder = ({ onFrame, onError, controller, config, logLevel, tr
     const onAbort = () => {
         close();
     };
-    controller._internals._mediaParserController._internals.signal.addEventListener('abort', onAbort);
+    if (controller) {
+        controller._internals._mediaParserController._internals.signal.addEventListener('abort', onAbort);
+    }
     audioDecoder.configure(config);
-    const processSample = async (audioSample) => {
+    const processSample = (audioSample) => {
         if (audioDecoder.state === 'closed') {
             return;
         }
-        progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, audioSample.decodingTimestamp ?? Infinity));
-        await ioSynchronizer.waitFor({
-            unemitted: 20,
-            unprocessed: 20,
-            minimumProgress: audioSample.timestamp - 10000000,
-            controller,
-        });
         // Don't flush, it messes up the audio
-        const chunk = new EncodedAudioChunk(audioSample);
+        const chunk = audioSample instanceof EncodedAudioChunk
+            ? audioSample
+            : new EncodedAudioChunk(audioSample);
         audioDecoder.decode(chunk);
         // https://test-streams.mux.dev/x36xhzz/url_0/url_525/193039199_mp4_h264_aac_hd_7.ts
         // has a 16 byte audio sample at the end which chrome does not decode
@@ -81,14 +71,12 @@ const createAudioDecoder = ({ onFrame, onError, controller, config, logLevel, tr
         // For now only reporting chunks that are bigger than that
         // 16 was chosen arbitrarily, can be improved
         if (chunk.byteLength > 16) {
-            ioSynchronizer.inputItem(chunk.timestamp, audioSample.type === 'key');
+            ioSynchronizer.inputItem(chunk.timestamp);
         }
     };
-    let queue = Promise.resolve();
     return {
-        processSample: (sample) => {
-            queue = queue.then(() => processSample(sample));
-            return queue;
+        decode: (sample) => {
+            processSample(sample);
         },
         waitForFinish: async () => {
             // Firefox might throw "Needs to be configured first"
@@ -96,14 +84,23 @@ const createAudioDecoder = ({ onFrame, onError, controller, config, logLevel, tr
                 await audioDecoder.flush();
             }
             catch { }
-            await queue;
-            await ioSynchronizer.waitForFinish(controller);
-            await outputQueue;
+            await ioSynchronizer.waitForFinish();
         },
         close,
         flush: async () => {
             await audioDecoder.flush();
         },
+        waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
     };
 };
+exports.internalCreateAudioDecoder = internalCreateAudioDecoder;
+const createAudioDecoder = ({ onFrame, onError, controller, track, logLevel, }) => {
+    return (0, exports.internalCreateAudioDecoder)({
+        onFrame,
+        onError,
+        controller: controller ?? null,
+        config: track,
+        logLevel: logLevel ?? 'error',
+    });
+};
 exports.createAudioDecoder = createAudioDecoder;

package/dist/audio-encoder.d.ts

@@ -1,21 +1,21 @@
 import { type MediaParserLogLevel } from '@remotion/media-parser';
-import type { ProgressTracker } from './create/progress-tracker';
 import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { IoSynchronizer } from './io-manager/io-synchronizer';
 import type { WebCodecsController } from './webcodecs-controller';
 export type WebCodecsAudioEncoder = {
-    encodeFrame: (audioData: AudioData) => Promise<void>;
+    encode: (audioData: AudioData) => void;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;
+    ioSynchronizer: IoSynchronizer;
 };
 export type AudioEncoderInit = {
     onChunk: (chunk: EncodedAudioChunk) => Promise<void>;
-    onError: (error: DOMException) => void;
+    onError: (error: Error) => void;
     codec: ConvertMediaAudioCodec;
     controller: WebCodecsController;
     config: AudioEncoderConfig;
     logLevel: MediaParserLogLevel;
     onNewAudioSampleRate: (sampleRate: number) => void;
-    progressTracker: ProgressTracker;
 };
-export declare const createAudioEncoder: ({ onChunk, onError, codec, controller, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, progressTracker, }: AudioEncoderInit) => WebCodecsAudioEncoder;
+export declare const createAudioEncoder: ({ onChunk, onError, codec, controller, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }: AudioEncoderInit) => WebCodecsAudioEncoder;

package/dist/audio-encoder.js

@@ -4,41 +4,32 @@ exports.createAudioEncoder = void 0;
 const media_parser_1 = require("@remotion/media-parser");
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
 const wav_audio_encoder_1 = require("./wav-audio-encoder");
-const createAudioEncoder = ({ onChunk, onError, codec, controller, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, progressTracker, }) => {
+const createAudioEncoder = ({ onChunk, onError, codec, controller, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }) => {
     if (controller._internals._mediaParserController._internals.signal.aborted) {
         throw new media_parser_1.MediaParserAbortError('Not creating audio encoder, already aborted');
     }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
+        logLevel,
+        label: 'Audio encoder',
+        controller,
+    });
     if (codec === 'wav') {
         return (0, wav_audio_encoder_1.getWaveAudioEncoder)({
             onChunk,
             controller,
             config: audioEncoderConfig,
+            ioSynchronizer,
         });
     }
-    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
-        logLevel,
-        label: 'Audio encoder',
-        progress: progressTracker,
-    });
-    let prom = Promise.resolve();
     const encoder = new AudioEncoder({
-        output: (chunk) => {
-            ioSynchronizer.onOutput(chunk.timestamp);
-            prom = prom
-                .then(() => {
-                if (controller._internals._mediaParserController._internals.signal
-                    .aborted) {
-                    return;
-                }
-                return onChunk(chunk);
-            })
-                .then(() => {
-                ioSynchronizer.onProcessed();
-                return Promise.resolve();
-            })
-                .catch((err) => {
+        output: async (chunk) => {
+            try {
+                await onChunk(chunk);
+            }
+            catch (err) {
                 onError(err);
-            });
+            }
+            ioSynchronizer.onOutput(chunk.timestamp);
         },
         error(error) {
             onError(error);
@@ -61,18 +52,7 @@ const createAudioEncoder = ({ onChunk, onError, codec, controller, config: audio
         throw new Error('Only `codec: "opus"` and `codec: "aac"` is supported currently');
     }
     const wantedSampleRate = audioEncoderConfig.sampleRate;
-    const encodeFrame = async (audioData) => {
-        if (encoder.state === 'closed') {
-            return;
-        }
-        progressTracker.setPossibleLowestTimestamp(audioData.timestamp);
-        await ioSynchronizer.waitFor({
-            unemitted: 20,
-            unprocessed: 20,
-            minimumProgress: audioData.timestamp - 10000000,
-            controller,
-        });
-        // @ts-expect-error - can have changed in the meanwhile
+    const encodeFrame = (audioData) => {
         if (encoder.state === 'closed') {
             return;
         }
@@ -89,23 +69,21 @@ const createAudioEncoder = ({ onChunk, onError, codec, controller, config: audio
             }
         }
         encoder.encode(audioData);
-        ioSynchronizer.inputItem(audioData.timestamp, true);
+        ioSynchronizer.inputItem(audioData.timestamp);
     };
-    let queue = Promise.resolve();
     return {
-        encodeFrame: (audioData) => {
-            queue = queue.then(() => encodeFrame(audioData));
-            return queue;
+        encode: (audioData) => {
+            encodeFrame(audioData);
         },
         waitForFinish: async () => {
             await encoder.flush();
-            await ioSynchronizer.waitForFinish(controller);
-            await prom;
+            await ioSynchronizer.waitForFinish();
         },
         close,
         flush: async () => {
             await encoder.flush();
         },
+        ioSynchronizer,
     };
 };
 exports.createAudioEncoder = createAudioEncoder;

package/dist/convert-media.js

@@ -81,6 +81,7 @@ const convertMedia = async function ({ src, onVideoFrame, onAudioData, onProgres
         expectedFrameRate: expectedFrameRate ?? null,
     });
     const onVideoTrack = (0, on_video_track_1.makeVideoTrackHandler)({
+        progressTracker,
         state,
         onVideoFrame: onVideoFrame ?? null,
         onMediaStateUpdate: throttledState.update ?? null,
@@ -91,10 +92,10 @@ const convertMedia = async function ({ src, onVideoFrame, onAudioData, onProgres
         logLevel,
         outputContainer: container,
         rotate: rotate ?? 0,
-        progress: progressTracker,
         resizeOperation: resize ?? null,
     });
     const onAudioTrack = (0, on_audio_track_1.makeAudioTrackHandler)({
+        progressTracker,
         abortConversion,
         defaultAudioCodec: audioCodec ?? null,
         controller,
@@ -103,7 +104,6 @@ const convertMedia = async function ({ src, onVideoFrame, onAudioData, onProgres
         onAudioTrack: userAudioResolver ?? null,
         logLevel,
         outputContainer: container,
-        progressTracker,
         onAudioData: onAudioData ?? null,
     });
     media_parser_1.MediaParserInternals.internalParseMedia({

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

@@ -0,0 +1,11 @@
+import type { MediaParserAudioTrack, MediaParserLogLevel, MediaParserOnAudioSample } from '@remotion/media-parser';
+import type { MediaFn } from './create/media-fn';
+import type { ProgressTracker } from './create/progress-tracker';
+import type { ConvertMediaProgressFn } from './throttled-state-update';
+export declare const copyAudioTrack: ({ state, track, logLevel, onMediaStateUpdate, progressTracker, }: {
+    state: MediaFn;
+    track: MediaParserAudioTrack;
+    logLevel: MediaParserLogLevel;
+    onMediaStateUpdate: ConvertMediaProgressFn | null;
+    progressTracker: ProgressTracker;
+}) => Promise<MediaParserOnAudioSample>;

package/dist/copy-audio-track.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyAudioTrack = void 0;
+const log_1 = require("./log");
+const copyAudioTrack = async ({ state, track, logLevel, onMediaStateUpdate, progressTracker, }) => {
+    const addedTrack = await state.addTrack({
+        type: 'audio',
+        codec: track.codecEnum,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        codecPrivate: track.codecData?.data ?? null,
+        timescale: track.originalTimescale,
+    });
+    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) => {
+        progressTracker.setPossibleLowestTimestamp(Math.min(audioSample.timestamp, audioSample.decodingTimestamp ?? Infinity));
+        await state.addSample({
+            chunk: audioSample,
+            trackNumber: addedTrack.trackNumber,
+            isVideo: false,
+            codecPrivate: track.codecData?.data ?? null,
+        });
+        onMediaStateUpdate?.((prevState) => {
+            return {
+                ...prevState,
+                encodedAudioFrames: prevState.encodedAudioFrames + 1,
+            };
+        });
+    };
+};
+exports.copyAudioTrack = copyAudioTrack;

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

@@ -0,0 +1,11 @@
+import type { MediaParserLogLevel, MediaParserOnVideoSample, MediaParserVideoTrack } from '@remotion/media-parser';
+import type { MediaFn } from './create/media-fn';
+import type { ProgressTracker } from './create/progress-tracker';
+import type { ConvertMediaProgressFn } from './throttled-state-update';
+export declare const copyVideoTrack: ({ logLevel, state, track, onMediaStateUpdate, progressTracker, }: {
+    logLevel: MediaParserLogLevel;
+    state: MediaFn;
+    track: MediaParserVideoTrack;
+    onMediaStateUpdate: null | ConvertMediaProgressFn;
+    progressTracker: ProgressTracker;
+}) => Promise<MediaParserOnVideoSample>;

package/dist/copy-video-track.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyVideoTrack = void 0;
+const log_1 = require("./log");
+const copyVideoTrack = async ({ logLevel, state, track, onMediaStateUpdate, progressTracker, }) => {
+    log_1.Log.verbose(logLevel, `Copying video track with codec ${track.codec} and timescale ${track.originalTimescale}`);
+    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.originalTimescale,
+    });
+    return async (sample) => {
+        progressTracker.setPossibleLowestTimestamp(Math.min(sample.timestamp, sample.decodingTimestamp ?? Infinity));
+        await state.addSample({
+            chunk: sample,
+            trackNumber: videoTrack.trackNumber,
+            isVideo: true,
+            codecPrivate: track.codecData?.data ?? null,
+        });
+        onMediaStateUpdate?.((prevState) => {
+            return {
+                ...prevState,
+                decodedVideoFrames: prevState.decodedVideoFrames + 1,
+            };
+        });
+    };
+};
+exports.copyVideoTrack = copyVideoTrack;

package/dist/create/event-emitter.d.ts

@@ -1,6 +1,5 @@
 type Input = {
     timestamp: number;
-    keyFrame: boolean;
 };
 type Output = {
     timestamp: number;

package/dist/create/progress-tracker.d.ts

@@ -2,8 +2,6 @@ export declare const makeProgressTracker: () => {
     registerTrack: (trackNumber: number) => void;
     getSmallestProgress: () => number;
     updateTrackProgress: (trackNumber: number, progress: number) => void;
-    waitForProgress: () => Promise<void>;
-    getStartingTimestamp: () => number;
     setPossibleLowestTimestamp: (timestamp: number) => void;
 };
 export type ProgressTracker = ReturnType<typeof makeProgressTracker>;

package/dist/create/progress-tracker.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeProgressTracker = void 0;
 const event_emitter_1 = require("./event-emitter");
-const with_resolvers_1 = require("./with-resolvers");
 // Make sure to distinguish null and undefined here
 const makeProgressTracker = () => {
     const trackNumberProgresses = {};
@@ -16,13 +15,7 @@ const makeProgressTracker = () => {
             startingTimestamp = Math.min(startingTimestamp, timestamp);
         }
     };
-    const getStartingTimestamp = () => {
-        if (startingTimestamp === null) {
-            throw new Error('No starting timestamp');
-        }
-        return startingTimestamp;
-    };
-    const calculateSmallestProgress = () => {
+    const getSmallestProgress = () => {
         const progressValues = Object.values(trackNumberProgresses).map((p) => {
             if (p !== null) {
                 return p;
@@ -41,26 +34,16 @@ const makeProgressTracker = () => {
         registerTrack: (trackNumber) => {
             trackNumberProgresses[trackNumber] = null;
         },
-        getSmallestProgress: calculateSmallestProgress,
+        getSmallestProgress,
         updateTrackProgress: (trackNumber, progress) => {
             if (trackNumberProgresses[trackNumber] === undefined) {
                 throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
             }
             trackNumberProgresses[trackNumber] = progress;
             eventEmitter.dispatchEvent('progress', {
-                smallestProgress: calculateSmallestProgress(),
+                smallestProgress: getSmallestProgress(),
             });
         },
-        waitForProgress: () => {
-            const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
-            const on = () => {
-                eventEmitter.removeEventListener('progress', on);
-                resolve();
-            };
-            eventEmitter.addEventListener('progress', on);
-            return promise;
-        },
-        getStartingTimestamp,
         setPossibleLowestTimestamp,
     };
 };