@remotion/webcodecs 4.0.227 → 4.0.229

package/dist/audio-decoder-config.js

@@ -5,6 +5,9 @@ const getAudioDecoderConfig = async (config) => {
     if (typeof AudioDecoder === 'undefined') {
         return null;
     }
+    if (typeof EncodedAudioChunk === 'undefined') {
+        return null;
+    }
     if ((await AudioDecoder.isConfigSupported(config)).supported) {
         return config;
     }

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, expectedOutputDurationInMs, }: {
+    millisecondsWritten: number;
+    expectedOutputDurationInMs: 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, expectedOutputDurationInMs, }) => {
+    if (expectedOutputDurationInMs === null) {
+        return null;
+    }
+    return millisecondsWritten / expectedOutputDurationInMs;
+};
+exports.calculateProgress = calculateProgress;

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

@@ -0,0 +1,8 @@
+import type { MediaParserAudioCodec } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+import type { ConvertMediaContainer } from './convert-media';
+export declare const canCopyAudioTrack: ({ inputCodec, outputCodec, container, }: {
+    inputCodec: MediaParserAudioCodec;
+    outputCodec: ConvertMediaAudioCodec;
+    container: ConvertMediaContainer;
+}) => boolean;

package/dist/can-copy-audio-track.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canCopyAudioTrack = void 0;
+const canCopyAudioTrack = ({ inputCodec, outputCodec, container, }) => {
+    if (outputCodec === 'opus') {
+        return inputCodec === 'opus' && container === 'webm';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+exports.canCopyAudioTrack = canCopyAudioTrack;

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

@@ -0,0 +1,8 @@
+import type { MediaParserVideoCodec } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaContainer } from './convert-media';
+export declare const canCopyVideoTrack: ({ inputCodec, outputCodec, container, }: {
+    inputCodec: MediaParserVideoCodec;
+    outputCodec: ConvertMediaVideoCodec;
+    container: ConvertMediaContainer;
+}) => boolean;

package/dist/can-copy-video-track.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canCopyVideoTrack = void 0;
+const canCopyVideoTrack = ({ inputCodec, outputCodec, container, }) => {
+    if (outputCodec === 'vp8') {
+        return inputCodec === 'vp8' && container === 'webm';
+    }
+    if (outputCodec === 'vp9') {
+        return inputCodec === 'vp9' && container === 'webm';
+    }
+    throw new Error(`Unhandled codec: ${outputCodec}`);
+};
+exports.canCopyVideoTrack = canCopyVideoTrack;

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

@@ -0,0 +1,7 @@
+import type { AudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
+    track: AudioTrack;
+    audioCodec: ConvertMediaAudioCodec;
+    bitrate: number;
+}) => Promise<boolean>;

package/dist/can-reencode-audio-track.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeAudioTrack = void 0;
+const audio_decoder_config_1 = require("./audio-decoder-config");
+const audio_encoder_config_1 = require("./audio-encoder-config");
+const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)({
+        codec: track.codec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        description: track.description,
+    });
+    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
+        codec: audioCodec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        bitrate,
+    });
+    return Boolean(audioDecoderConfig && audioEncoderConfig);
+};
+exports.canReencodeAudioTrack = canReencodeAudioTrack;

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

@@ -0,0 +1,7 @@
+import type { AudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './codec-id';
+export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
+    track: AudioTrack;
+    audioCodec: ConvertMediaAudioCodec;
+    bitrate: number;
+}) => Promise<boolean>;

package/dist/can-reencode-audio.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeAudioTrack = void 0;
+const audio_decoder_config_1 = require("./audio-decoder-config");
+const audio_encoder_config_1 = require("./audio-encoder-config");
+const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)({
+        codec: track.codec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        description: track.description,
+    });
+    const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
+        codec: audioCodec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        bitrate,
+    });
+    return Boolean(audioDecoderConfig && audioEncoderConfig);
+};
+exports.canReencodeAudioTrack = canReencodeAudioTrack;

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

@@ -0,0 +1,6 @@
+import type { VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
+    videoCodec: ConvertMediaVideoCodec;
+    track: VideoTrack;
+}) => Promise<boolean>;

package/dist/can-reencode-video-track.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeVideoTrack = void 0;
+const video_decoder_config_1 = require("./video-decoder-config");
+const video_encoder_config_1 = require("./video-encoder-config");
+const canReencodeVideoTrack = async ({ videoCodec, track, }) => {
+    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
+        codec: videoCodec,
+        height: track.displayAspectHeight,
+        width: track.displayAspectWidth,
+    });
+    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
+    return Boolean(videoDecoderConfig && videoEncoderConfig);
+};
+exports.canReencodeVideoTrack = canReencodeVideoTrack;

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

@@ -0,0 +1,6 @@
+import type { VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
+    videoCodec: ConvertMediaVideoCodec;
+    track: VideoTrack;
+}) => Promise<boolean>;

package/dist/can-reencode-video.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeVideoTrack = void 0;
+const video_decoder_config_1 = require("./video-decoder-config");
+const video_encoder_config_1 = require("./video-encoder-config");
+const canReencodeVideoTrack = async ({ videoCodec, track, }) => {
+    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
+        codec: videoCodec,
+        height: track.displayAspectHeight,
+        width: track.displayAspectWidth,
+    });
+    const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
+    return Boolean(videoDecoderConfig && videoEncoderConfig);
+};
+exports.canReencodeVideoTrack = canReencodeVideoTrack;

package/dist/codec-id.d.ts

@@ -1,2 +1,7 @@
-export type ConvertMediaVideoCodec = 'vp8' | 'vp9';
-export type ConvertMediaAudioCodec = 'opus';
+declare const availableVideoCodecs: readonly ["vp8", "vp9"];
+export declare const getAvailableVideoCodecs: () => readonly ["vp8", "vp9"];
+export type ConvertMediaVideoCodec = (typeof availableVideoCodecs)[number];
+declare const availableAudioCodecs: readonly ["opus"];
+export declare const getAvailableAudioCodecs: () => readonly ["opus"];
+export type ConvertMediaAudioCodec = (typeof availableAudioCodecs)[number];
+export {};

package/dist/codec-id.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableAudioCodecs = exports.getAvailableVideoCodecs = void 0;
+const availableVideoCodecs = ['vp8', 'vp9'];
+const getAvailableVideoCodecs = () => availableVideoCodecs;
+exports.getAvailableVideoCodecs = getAvailableVideoCodecs;
+const availableAudioCodecs = ['opus'];
+const getAvailableAudioCodecs = () => availableAudioCodecs;
+exports.getAvailableAudioCodecs = getAvailableAudioCodecs;

package/dist/convert-encoded-chunk.d.ts

@@ -0,0 +1,2 @@
+import type { AudioOrVideoSample } from '@remotion/media-parser';
+export declare const convertEncodedChunk: (chunk: EncodedAudioChunk | EncodedVideoChunk) => AudioOrVideoSample;

package/dist/convert-encoded-chunk.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEncodedChunk = void 0;
+const convertEncodedChunk = (chunk) => {
+    var _a;
+    const arr = new Uint8Array(chunk.byteLength);
+    chunk.copyTo(arr);
+    return {
+        data: arr,
+        duration: (_a = chunk.duration) !== null && _a !== void 0 ? _a : undefined,
+        timestamp: chunk.timestamp,
+        type: chunk.type,
+    };
+};
+exports.convertEncodedChunk = convertEncodedChunk;

package/dist/convert-media.d.ts

@@ -1,4 +1,8 @@
-import type { VideoTrack } from '@remotion/media-parser';
+/**
+ * Copyright (c) 2024 Remotion AG
+ * For licensing, see: https://remotion.dev/docs/webcodecs#license
+ */
+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,20 +11,32 @@ export type ConvertMediaState = {
     decodedAudioFrames: number;
     encodedVideoFrames: number;
     encodedAudioFrames: number;
+    bytesWritten: number;
+    millisecondsWritten: number;
+    expectedOutputDurationInMs: number | null;
+    overallProgress: number | null;
 };
-export type ConvertMediaTo = 'webm';
+export type ConvertMediaContainer = 'webm';
 export type ConvertMediaResult = {
-    save: () => Promise<File>;
+    save: () => Promise<Blob>;
     remove: () => Promise<void>;
 };
-export declare const convertMedia: ({ src, onVideoFrame, onMediaStateUpdate, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, }: {
-    src: string | File;
-    to: ConvertMediaTo;
-    onVideoFrame?: (inputFrame: VideoFrame, track: VideoTrack) => Promise<void>;
-    onMediaStateUpdate?: (state: ConvertMediaState) => void;
+export type ConvertMediaOnMediaStateUpdate = (state: ConvertMediaState) => void;
+export type ConvertMediaOnVideoFrame = (options: {
+    frame: VideoFrame;
+    track: VideoTrack;
+}) => Promise<VideoFrame> | VideoFrame;
+export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, ...more }: {
+    src: ParseMediaOptions<F>["src"];
+    container: ConvertMediaContainer;
+    onVideoFrame?: ConvertMediaOnVideoFrame;
+    onMediaStateUpdate?: ConvertMediaOnMediaStateUpdate;
     videoCodec: ConvertMediaVideoCodec;
     audioCodec: ConvertMediaAudioCodec;
     signal?: AbortSignal;
     onAudioTrack?: ResolveAudioActionFn;
     onVideoTrack?: ResolveVideoActionFn;
-}) => Promise<ConvertMediaResult>;
+    reader?: ParseMediaOptions<F>["reader"];
+    logLevel?: LogLevel;
+    writer?: WriterInterface;
+} & ParseMediaDynamicOptions<F>) => Promise<ConvertMediaResult>;