@remotion/webcodecs 4.0.227 → 4.0.228

package/dist/audio-decoder.d.ts

@@ -1,14 +1,14 @@
-import type { AudioSample } from '@remotion/media-parser';
+import type { AudioSample, LogLevel } from '@remotion/media-parser';
 export type WebCodecsAudioDecoder = {
     processSample: (audioSample: AudioSample) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
-    getQueueSize: () => number;
     flush: () => Promise<void>;
 };
-export declare const createAudioDecoder: ({ onFrame, onError, signal, config, }: {
+export declare const createAudioDecoder: ({ onFrame, onError, signal, config, logLevel, }: {
     onFrame: (frame: AudioData) => Promise<void>;
     onError: (error: DOMException) => void;
     signal: AbortSignal;
     config: AudioDecoderConfig;
+    logLevel: LogLevel;
 }) => WebCodecsAudioDecoder;

package/dist/audio-decoder.js

@@ -1,22 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAudioDecoder = void 0;
-const createAudioDecoder = ({ onFrame, onError, signal, config, }) => {
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, }) => {
     if (signal.aborted) {
         throw new Error('Not creating audio decoder, already aborted');
     }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Audio decoder');
     let outputQueue = Promise.resolve();
-    let outputQueueSize = 0;
-    let dequeueResolver = () => { };
     const audioDecoder = new AudioDecoder({
         output(inputFrame) {
-            outputQueueSize++;
+            ioSynchronizer.onOutput(inputFrame.timestamp);
+            const abortHandler = () => {
+                inputFrame.close();
+            };
+            signal.addEventListener('abort', abortHandler, { once: true });
             outputQueue = outputQueue
-                .then(() => onFrame(inputFrame))
                 .then(() => {
-                dequeueResolver();
-                outputQueueSize--;
+                if (signal.aborted) {
+                    return;
+                }
+                return onFrame(inputFrame);
+            })
+                .then(() => {
+                ioSynchronizer.onProcessed();
+                signal.removeEventListener('abort', abortHandler);
                 return Promise.resolve();
+            })
+                .catch((err) => {
+                inputFrame.close();
+                onError(err);
             });
         },
         error(error) {
@@ -35,34 +48,16 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, }) => {
         close();
     };
     signal.addEventListener('abort', onAbort);
-    const getQueueSize = () => {
-        return audioDecoder.decodeQueueSize + outputQueueSize;
-    };
     audioDecoder.configure(config);
-    const waitForDequeue = async () => {
-        await new Promise((r) => {
-            dequeueResolver = r;
-            // @ts-expect-error exists
-            audioDecoder.addEventListener('dequeue', () => r(), {
-                once: true,
-            });
-        });
-    };
-    const waitForFinish = async () => {
-        while (getQueueSize() > 0) {
-            await waitForDequeue();
-        }
-    };
     const processSample = async (audioSample) => {
         if (audioDecoder.state === 'closed') {
             return;
         }
-        while (getQueueSize() > 10) {
-            await waitForDequeue();
-        }
+        await ioSynchronizer.waitFor({ unemitted: 100, _unprocessed: 2 });
         // Don't flush, it messes up the audio
         const chunk = new EncodedAudioChunk(audioSample);
         audioDecoder.decode(chunk);
+        ioSynchronizer.inputItem(chunk.timestamp, audioSample.type === 'key');
     };
     let queue = Promise.resolve();
     return {
@@ -72,11 +67,10 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, }) => {
         },
         waitForFinish: async () => {
             await audioDecoder.flush();
-            await waitForFinish();
+            await ioSynchronizer.waitForFinish();
             await outputQueue;
         },
         close,
-        getQueueSize,
         flush: async () => {
             await audioDecoder.flush();
         },

package/dist/audio-encoder.d.ts

@@ -1,15 +1,16 @@
+import type { LogLevel } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec } from './codec-id';
 export type WebCodecsAudioEncoder = {
     encodeFrame: (audioData: AudioData) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
-    getQueueSize: () => number;
     flush: () => Promise<void>;
 };
-export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, }: {
+export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, }: {
     onChunk: (chunk: EncodedAudioChunk) => Promise<void>;
     onError: (error: DOMException) => void;
     codec: ConvertMediaAudioCodec;
     signal: AbortSignal;
     config: AudioEncoderConfig;
+    logLevel: LogLevel;
 }) => WebCodecsAudioEncoder;

package/dist/audio-encoder.js

@@ -1,22 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAudioEncoder = void 0;
-const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEncoderConfig, }) => {
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, }) => {
     if (signal.aborted) {
         throw new Error('Not creating audio encoder, already aborted');
     }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Audio encoder');
     let prom = Promise.resolve();
-    let outputQueue = 0;
-    let dequeueResolver = () => { };
     const encoder = new AudioEncoder({
         output: (chunk) => {
-            outputQueue++;
+            ioSynchronizer.onOutput(chunk.timestamp);
             prom = prom
-                .then(() => onChunk(chunk))
                 .then(() => {
-                outputQueue--;
-                dequeueResolver();
+                if (signal.aborted) {
+                    return;
+                }
+                return onChunk(chunk);
+            })
+                .then(() => {
+                ioSynchronizer.onProcessed();
                 return Promise.resolve();
+            })
+                .catch((err) => {
+                onError(err);
             });
         },
         error(error) {
@@ -38,36 +45,18 @@ const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEnco
     if (codec !== 'opus') {
         throw new Error('Only `codec: "opus"` is supported currently');
     }
-    const getQueueSize = () => {
-        return encoder.encodeQueueSize + outputQueue;
-    };
     encoder.configure(audioEncoderConfig);
-    const waitForDequeue = async () => {
-        await new Promise((r) => {
-            dequeueResolver = r;
-            // @ts-expect-error exists
-            encoder.addEventListener('dequeue', () => r(), {
-                once: true,
-            });
-        });
-    };
-    const waitForFinish = async () => {
-        while (getQueueSize() > 0) {
-            await waitForDequeue();
-        }
-    };
     const encodeFrame = async (audioData) => {
         if (encoder.state === 'closed') {
             return;
         }
-        while (getQueueSize() > 10) {
-            await waitForDequeue();
-        }
+        await ioSynchronizer.waitFor({ unemitted: 2, _unprocessed: 2 });
         // @ts-expect-error - can have changed in the meanwhile
         if (encoder.state === 'closed') {
             return;
         }
         encoder.encode(audioData);
+        ioSynchronizer.inputItem(audioData.timestamp, true);
     };
     let queue = Promise.resolve();
     return {
@@ -77,11 +66,10 @@ const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEnco
         },
         waitForFinish: async () => {
             await encoder.flush();
-            await waitForFinish();
+            await ioSynchronizer.waitForFinish();
             await prom;
         },
         close,
-        getQueueSize,
         flush: async () => {
             await encoder.flush();
         },

package/dist/auto-select-writer.d.ts

@@ -0,0 +1,3 @@
+import type { WriterInterface } from '@remotion/media-parser';
+import type { LogLevel } from './log';
+export declare const autoSelectWriter: (writer: WriterInterface | undefined, logLevel: LogLevel) => Promise<WriterInterface>;

package/dist/auto-select-writer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoSelectWriter = void 0;
+const buffer_1 = require("@remotion/media-parser/buffer");
+const web_fs_1 = require("@remotion/media-parser/web-fs");
+const log_1 = require("./log");
+const autoSelectWriter = async (writer, logLevel) => {
+    if (writer) {
+        log_1.Log.verbose(logLevel, 'Using writer provided by user');
+        return writer;
+    }
+    log_1.Log.verbose(logLevel, 'Determining best writer');
+    if (await (0, web_fs_1.canUseWebFsWriter)()) {
+        log_1.Log.verbose(logLevel, 'Using WebFS writer because it is supported');
+        return web_fs_1.webFsWriter;
+    }
+    log_1.Log.verbose(logLevel, 'Using buffer writer because WebFS writer is not supported');
+    return buffer_1.bufferWriter;
+};
+exports.autoSelectWriter = autoSelectWriter;

package/dist/calculate-progress.d.ts

@@ -0,0 +1,4 @@
+export declare const calculateProgress: ({ millisecondsWritten, expectedOutputMilliseconds, }: {
+    millisecondsWritten: number;
+    expectedOutputMilliseconds: number | null;
+}) => number | null;

package/dist/calculate-progress.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateProgress = void 0;
+const calculateProgress = ({ millisecondsWritten, expectedOutputMilliseconds, }) => {
+    if (expectedOutputMilliseconds === null) {
+        return null;
+    }
+    return millisecondsWritten / expectedOutputMilliseconds;
+};
+exports.calculateProgress = calculateProgress;

package/dist/convert-media.d.ts

@@ -1,4 +1,4 @@
-import type { VideoTrack } from '@remotion/media-parser';
+import type { LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack, WriterInterface } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec, ConvertMediaVideoCodec } from './codec-id';
 import { type ResolveAudioActionFn } from './resolve-audio-action';
 import { type ResolveVideoActionFn } from './resolve-video-action';
@@ -7,14 +7,18 @@ export type ConvertMediaState = {
     decodedAudioFrames: number;
     encodedVideoFrames: number;
     encodedAudioFrames: number;
+    bytesWritten: number;
+    millisecondsWritten: number;
+    expectedOutputMilliseconds: number | null;
+    overallProgress: number | null;
 };
 export type ConvertMediaTo = 'webm';
 export type ConvertMediaResult = {
     save: () => Promise<File>;
     remove: () => Promise<void>;
 };
-export declare const convertMedia: ({ src, onVideoFrame, onMediaStateUpdate, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, }: {
-    src: string | File;
+export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, ...more }: {
+    src: ParseMediaOptions<F>["src"];
     to: ConvertMediaTo;
     onVideoFrame?: (inputFrame: VideoFrame, track: VideoTrack) => Promise<void>;
     onMediaStateUpdate?: (state: ConvertMediaState) => void;
@@ -23,4 +27,7 @@ export declare const convertMedia: ({ src, onVideoFrame, onMediaStateUpdate, aud
     signal?: AbortSignal;
     onAudioTrack?: ResolveAudioActionFn;
     onVideoTrack?: ResolveVideoActionFn;
-}) => Promise<ConvertMediaResult>;
+    reader?: ParseMediaOptions<F>["reader"];
+    logLevel?: LogLevel;
+    writer?: WriterInterface;
+} & ParseMediaDynamicOptions<F>) => Promise<ConvertMediaResult>;

package/dist/convert-media.js

@@ -5,15 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertMedia = void 0;
 const media_parser_1 = require("@remotion/media-parser");
-const buffer_1 = require("@remotion/media-parser/buffer");
-const web_fs_1 = require("@remotion/media-parser/web-fs");
+const auto_select_writer_1 = require("./auto-select-writer");
+const calculate_progress_1 = require("./calculate-progress");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const on_audio_track_1 = require("./on-audio-track");
 const on_video_track_1 = require("./on-video-track");
 const resolve_audio_action_1 = require("./resolve-audio-action");
 const resolve_video_action_1 = require("./resolve-video-action");
 const with_resolvers_1 = require("./with-resolvers");
-const convertMedia = async ({ src, onVideoFrame, onMediaStateUpdate, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, }) => {
+const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, ...more }) {
+    if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
+        return Promise.reject(new error_cause_1.default('Aborted'));
+    }
     if (to !== 'webm') {
         return Promise.reject(new TypeError('Only `to: "webm"` is supported currently'));
     }
@@ -23,7 +26,7 @@ const convertMedia = async ({ src, onVideoFrame, onMediaStateUpdate, audioCodec,
     if (videoCodec !== 'vp8' && videoCodec !== 'vp9') {
         return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
     }
-    const { promise, resolve, reject } = (0, with_resolvers_1.withResolvers)();
+    const { resolve, reject, getPromiseToImmediatelyReturn } = (0, with_resolvers_1.withResolversAndWaitForReturn)();
     const controller = new AbortController();
     const abortConversion = (errCause) => {
         reject(errCause);
@@ -40,9 +43,34 @@ const convertMedia = async ({ src, onVideoFrame, onMediaStateUpdate, audioCodec,
         decodedVideoFrames: 0,
         encodedVideoFrames: 0,
         encodedAudioFrames: 0,
+        bytesWritten: 0,
+        millisecondsWritten: 0,
+        expectedOutputMilliseconds: null,
+        overallProgress: 0,
+    };
+    const onMediaStateUpdate = (newState) => {
+        if (controller.signal.aborted) {
+            return;
+        }
+        onMediaStateDoNoCallDirectly === null || onMediaStateDoNoCallDirectly === void 0 ? void 0 : onMediaStateDoNoCallDirectly(newState);
     };
-    const canUseWebFs = await (0, web_fs_1.canUseWebFsWriter)();
-    const state = await media_parser_1.MediaParserInternals.createMedia(canUseWebFs ? web_fs_1.webFsWriter : buffer_1.bufferWriter);
+    const state = await media_parser_1.MediaParserInternals.createMedia({
+        writer: await (0, auto_select_writer_1.autoSelectWriter)(writer, logLevel),
+        onBytesProgress: (bytesWritten) => {
+            convertMediaState.bytesWritten = bytesWritten;
+            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
+        },
+        onMillisecondsProgress: (millisecondsWritten) => {
+            if (millisecondsWritten > convertMediaState.millisecondsWritten) {
+                convertMediaState.millisecondsWritten = millisecondsWritten;
+                convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
+                    millisecondsWritten: convertMediaState.millisecondsWritten,
+                    expectedOutputMilliseconds: convertMediaState.expectedOutputMilliseconds,
+                });
+                onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
+            }
+        },
+    });
     const onVideoTrack = (0, on_video_track_1.makeVideoTrackHandler)({
         state,
         onVideoFrame: onVideoFrame !== null && onVideoFrame !== void 0 ? onVideoFrame : null,
@@ -52,6 +80,7 @@ const convertMedia = async ({ src, onVideoFrame, onMediaStateUpdate, audioCodec,
         controller,
         videoCodec,
         onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : resolve_video_action_1.defaultResolveVideoAction,
+        logLevel,
     });
     const onAudioTrack = (0, on_audio_track_1.makeAudioTrackHandler)({
         abortConversion,
@@ -62,12 +91,35 @@ const convertMedia = async ({ src, onVideoFrame, onMediaStateUpdate, audioCodec,
         state,
         onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : resolve_audio_action_1.defaultResolveAudioAction,
         bitrate: 128000,
+        logLevel,
     });
     (0, media_parser_1.parseMedia)({
         src,
         onVideoTrack,
         onAudioTrack,
         signal: controller.signal,
+        fields: {
+            ...fields,
+            durationInSeconds: true,
+        },
+        reader,
+        ...more,
+        onDurationInSeconds: (durationInSeconds) => {
+            if (durationInSeconds === null) {
+                return null;
+            }
+            const casted = more;
+            if (casted.onDurationInSeconds) {
+                casted.onDurationInSeconds(durationInSeconds);
+            }
+            const expectedOutputMilliseconds = durationInSeconds * 1000;
+            convertMediaState.expectedOutputMilliseconds = expectedOutputMilliseconds;
+            convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
+                millisecondsWritten: convertMediaState.millisecondsWritten,
+                expectedOutputMilliseconds,
+            });
+            onMediaStateUpdate(convertMediaState);
+        },
     })
         .then(() => {
         return state.waitForFinish();
@@ -77,10 +129,9 @@ const convertMedia = async ({ src, onVideoFrame, onMediaStateUpdate, audioCodec,
     })
         .catch((err) => {
         reject(err);
-    })
-        .finally(() => {
+    });
+    return getPromiseToImmediatelyReturn().finally(() => {
         userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.removeEventListener('abort', onUserAbort);
     });
-    return promise;
 };
 exports.convertMedia = convertMedia;