@remotion/webcodecs 4.0.227 → 4.0.229

package/dist/resolve-audio-action.js

@@ -1,30 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveAudioAction = exports.defaultResolveAudioAction = void 0;
-const canCopyAudioTrack = (inputCodec, outputCodec) => {
-    if (outputCodec === 'opus') {
-        return inputCodec === 'opus';
-    }
-    throw new Error(`Unhandled codec: ${outputCodec}`);
-};
-const defaultResolveAudioAction = ({ canReencode, canCopy, }) => {
+exports.defaultResolveAudioAction = void 0;
+const can_copy_audio_track_1 = require("./can-copy-audio-track");
+const can_reencode_audio_track_1 = require("./can-reencode-audio-track");
+const log_1 = require("./log");
+const DEFAULT_BITRATE = 128000;
+const defaultResolveAudioAction = async ({ track, audioCodec, logLevel, container, }) => {
+    const bitrate = DEFAULT_BITRATE;
+    const canCopy = (0, can_copy_audio_track_1.canCopyAudioTrack)({
+        inputCodec: track.codecWithoutConfig,
+        outputCodec: audioCodec,
+        container,
+    });
     if (canCopy) {
-        return 'copy';
+        log_1.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy = ${canCopy}, action = copy`);
+        return Promise.resolve({ type: 'copy' });
     }
+    const canReencode = await (0, can_reencode_audio_track_1.canReencodeAudioTrack)({
+        audioCodec,
+        track,
+        bitrate,
+    });
     if (canReencode) {
-        return 'reencode';
+        log_1.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can re-encode = ${canReencode}, can copy = ${canCopy}, action = reencode`);
+        return Promise.resolve({ type: 'reencode', bitrate, audioCodec });
     }
+    log_1.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can re-encode = ${canReencode}, can copy = ${canCopy}, action = drop`);
     // TODO: Make a fail option?
-    return 'drop';
+    return Promise.resolve({ type: 'drop' });
 };
 exports.defaultResolveAudioAction = defaultResolveAudioAction;
-const resolveAudioAction = async ({ audioDecoderConfig, audioEncoderConfig, track, audioCodec, resolverFunction, }) => {
-    const canReencode = Boolean(audioDecoderConfig && audioEncoderConfig);
-    const canCopy = canCopyAudioTrack(track.codecWithoutConfig, audioCodec);
-    const resolved = await resolverFunction({
-        canReencode,
-        canCopy,
-    });
-    return resolved;
-};
-exports.resolveAudioAction = resolveAudioAction;

package/dist/resolve-video-action.d.ts

@@ -1,15 +1,18 @@
-import type { VideoTrack } from '@remotion/media-parser';
+import type { LogLevel, VideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaVideoCodec } from './codec-id';
-export type VideoOperation = 'reencode' | 'copy' | 'drop';
+import type { ConvertMediaContainer } from './convert-media';
+export type VideoOperation = {
+    type: 'reencode';
+    videoCodec: ConvertMediaVideoCodec;
+} | {
+    type: 'copy';
+} | {
+    type: 'drop';
+};
 export type ResolveVideoActionFn = (options: {
-    canReencode: boolean;
-    canCopy: boolean;
-}) => VideoOperation | Promise<VideoOperation>;
-export declare const defaultResolveVideoAction: ResolveVideoActionFn;
-export declare const resolveVideoAction: ({ videoDecoderConfig, videoEncoderConfig, track, videoCodec, resolverFunction, }: {
-    videoDecoderConfig: VideoDecoderConfig | null;
-    videoEncoderConfig: VideoEncoderConfig | null;
     videoCodec: ConvertMediaVideoCodec;
     track: VideoTrack;
-    resolverFunction: ResolveVideoActionFn;
-}) => Promise<VideoOperation>;
+    logLevel: LogLevel;
+    container: ConvertMediaContainer;
+}) => VideoOperation | Promise<VideoOperation>;
+export declare const defaultResolveVideoAction: ResolveVideoActionFn;

package/dist/resolve-video-action.js

@@ -1,33 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVideoAction = exports.defaultResolveVideoAction = void 0;
-const canCopyVideoTrack = (inputCodec, outputCodec) => {
-    if (outputCodec === 'vp8') {
-        return inputCodec === 'vp8';
-    }
-    if (outputCodec === 'vp9') {
-        return inputCodec === 'vp9';
-    }
-    throw new Error(`Unhandled codec: ${outputCodec}`);
-};
-const defaultResolveVideoAction = ({ canReencode, canCopy, }) => {
+exports.defaultResolveVideoAction = void 0;
+const can_copy_video_track_1 = require("./can-copy-video-track");
+const can_reencode_video_track_1 = require("./can-reencode-video-track");
+const log_1 = require("./log");
+const defaultResolveVideoAction = async ({ track, videoCodec, logLevel, container, }) => {
+    const canCopy = (0, can_copy_video_track_1.canCopyVideoTrack)({
+        inputCodec: track.codecWithoutConfig,
+        outputCodec: videoCodec,
+        container,
+    });
     if (canCopy) {
-        return 'copy';
+        log_1.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
+        return Promise.resolve({ type: 'copy' });
     }
+    const canReencode = await (0, can_reencode_video_track_1.canReencodeVideoTrack)({ videoCodec, track });
     if (canReencode) {
-        return 'reencode';
+        log_1.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
+        return Promise.resolve({ type: 'reencode', videoCodec });
     }
+    log_1.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore dropping`);
     // TODO: Make a fail option?
-    return 'drop';
+    return Promise.resolve({ type: 'drop' });
 };
 exports.defaultResolveVideoAction = defaultResolveVideoAction;
-const resolveVideoAction = async ({ videoDecoderConfig, videoEncoderConfig, track, videoCodec, resolverFunction, }) => {
-    const canReencode = Boolean(videoDecoderConfig && videoEncoderConfig);
-    const canCopy = canCopyVideoTrack(track.codecWithoutConfig, videoCodec);
-    const resolved = await resolverFunction({
-        canReencode,
-        canCopy,
-    });
-    return resolved;
-};
-exports.resolveVideoAction = resolveVideoAction;

package/dist/video-decoder.d.ts

@@ -1,14 +1,14 @@
-import type { VideoSample } from '@remotion/media-parser';
+import type { LogLevel, VideoSample } from '@remotion/media-parser';
 export type WebCodecsVideoDecoder = {
     processSample: (videoSample: VideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
-    getQueueSize: () => number;
     flush: () => Promise<void>;
 };
-export declare const createVideoDecoder: ({ onFrame, onError, signal, config, }: {
+export declare const createVideoDecoder: ({ onFrame, onError, signal, config, logLevel, }: {
     onFrame: (frame: VideoFrame) => Promise<void>;
     onError: (error: DOMException) => void;
     signal: AbortSignal;
     config: VideoDecoderConfig;
+    logLevel: LogLevel;
 }) => WebCodecsVideoDecoder;

package/dist/video-decoder.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoDecoder = void 0;
-const createVideoDecoder = ({ onFrame, onError, signal, config, }) => {
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const createVideoDecoder = ({ onFrame, onError, signal, config, logLevel, }) => {
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Video decoder');
     let outputQueue = Promise.resolve();
-    let outputQueueSize = 0;
-    let dequeueResolver = () => { };
     const videoDecoder = new VideoDecoder({
         output(inputFrame) {
-            outputQueueSize++;
+            ioSynchronizer.onOutput(inputFrame.timestamp);
+            const abortHandler = () => {
+                inputFrame.close();
+            };
+            signal.addEventListener('abort', abortHandler, { once: true });
             outputQueue = outputQueue
-                .then(() => onFrame(inputFrame))
                 .then(() => {
-                outputQueueSize--;
-                dequeueResolver();
+                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) {
@@ -32,38 +45,21 @@ const createVideoDecoder = ({ onFrame, onError, signal, config, }) => {
         close();
     };
     signal.addEventListener('abort', onAbort);
-    const getQueueSize = () => {
-        return videoDecoder.decodeQueueSize + outputQueueSize;
-    };
     videoDecoder.configure(config);
-    const waitForDequeue = async () => {
-        await new Promise((r) => {
-            dequeueResolver = r;
-            videoDecoder.addEventListener('dequeue', () => r(), {
-                once: true,
-            });
-        });
-    };
-    const waitForFinish = async () => {
-        while (getQueueSize() > 0) {
-            await waitForDequeue();
-        }
-    };
     const processSample = async (sample) => {
         if (videoDecoder.state === 'closed') {
             return;
         }
-        while (getQueueSize() > 10) {
-            await waitForDequeue();
-        }
         // @ts-expect-error - can have changed in the meanwhile
         if (videoDecoder.state === 'closed') {
             return;
         }
+        await ioSynchronizer.waitFor({ unemitted: 20, _unprocessed: 2 });
         if (sample.type === 'key') {
             await videoDecoder.flush();
         }
         videoDecoder.decode(new EncodedVideoChunk(sample));
+        ioSynchronizer.inputItem(sample.timestamp, sample.type === 'key');
     };
     let inputQueue = Promise.resolve();
     return {
@@ -73,12 +69,11 @@ const createVideoDecoder = ({ onFrame, onError, signal, config, }) => {
         },
         waitForFinish: async () => {
             await videoDecoder.flush();
-            await waitForFinish();
+            await ioSynchronizer.waitForFinish();
             await outputQueue;
             await inputQueue;
         },
         close,
-        getQueueSize,
         flush: async () => {
             await videoDecoder.flush();
         },

package/dist/video-encoder-config.d.ts

@@ -1 +1,6 @@
-export declare const getVideoEncoderConfig: (config: VideoEncoderConfig) => Promise<VideoEncoderConfig | null>;
+import type { ConvertMediaVideoCodec } from './codec-id';
+export declare const getVideoEncoderConfig: ({ width, height, codec, }: {
+    width: number;
+    height: number;
+    codec: ConvertMediaVideoCodec;
+}) => Promise<VideoEncoderConfig | null>;

package/dist/video-encoder-config.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoEncoderConfig = void 0;
-const getVideoEncoderConfig = async (config) => {
+const getVideoEncoderConfig = async ({ width, height, codec, }) => {
     if (typeof VideoEncoder === 'undefined') {
         return null;
     }
+    const config = {
+        codec: codec === 'vp9' ? 'vp09.00.10.08' : codec,
+        height,
+        width,
+    };
     const hardware = {
         ...config,
         hardwareAcceleration: 'prefer-hardware',

package/dist/video-encoder.d.ts

@@ -1,13 +1,14 @@
+import type { LogLevel } from '@remotion/media-parser';
 export type WebCodecsVideoEncoder = {
-    encodeFrame: (videoFrame: VideoFrame) => Promise<void>;
+    encodeFrame: (videoFrame: VideoFrame, timestamp: number) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
-    getQueueSize: () => number;
     flush: () => Promise<void>;
 };
-export declare const createVideoEncoder: ({ onChunk, onError, signal, config, }: {
+export declare const createVideoEncoder: ({ onChunk, onError, signal, config, logLevel, }: {
     onChunk: (chunk: EncodedVideoChunk) => Promise<void>;
     onError: (error: DOMException) => void;
     signal: AbortSignal;
     config: VideoEncoderConfig;
+    logLevel: LogLevel;
 }) => WebCodecsVideoEncoder;

package/dist/video-encoder.js

@@ -1,25 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoEncoder = void 0;
-const createVideoEncoder = ({ onChunk, onError, signal, config, }) => {
+const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, }) => {
     if (signal.aborted) {
         throw new Error('Not creating video encoder, already aborted');
     }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Video encoder');
     let outputQueue = Promise.resolve();
-    let outputQueueSize = 0;
-    let dequeueResolver = () => { };
     const encoder = new VideoEncoder({
         error(error) {
             onError(error);
         },
         output(chunk) {
-            outputQueueSize++;
+            if (chunk.duration === null) {
+                throw new Error('Duration is null');
+            }
+            const timestamp = chunk.timestamp + chunk.duration;
+            ioSynchronizer.onOutput(timestamp);
             outputQueue = outputQueue
-                .then(() => onChunk(chunk))
                 .then(() => {
-                outputQueueSize--;
-                dequeueResolver();
+                if (signal.aborted) {
+                    return;
+                }
+                return onChunk(chunk);
+            })
+                .then(() => {
+                ioSynchronizer.onProcessed();
                 return Promise.resolve();
+            })
+                .catch((err) => {
+                onError(err);
             });
         },
     });
@@ -35,38 +46,25 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, }) => {
         close();
     };
     signal.addEventListener('abort', onAbort);
-    const getQueueSize = () => {
-        return encoder.encodeQueueSize + outputQueueSize;
-    };
     encoder.configure(config);
     let framesProcessed = 0;
-    const waitForDequeue = async () => {
-        await new Promise((r) => {
-            dequeueResolver = r;
-            encoder.addEventListener('dequeue', () => r(), {
-                once: true,
-            });
-        });
-    };
-    const waitForFinish = async () => {
-        while (getQueueSize() > 0) {
-            await waitForDequeue();
-        }
-    };
     const encodeFrame = async (frame) => {
         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;
         }
+        const keyFrame = framesProcessed % 40 === 0;
         encoder.encode(frame, {
-            keyFrame: framesProcessed % 40 === 0,
+            keyFrame,
         });
+        ioSynchronizer.inputItem(frame.timestamp, keyFrame);
         framesProcessed++;
     };
     let inputQueue = Promise.resolve();
@@ -78,10 +76,9 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, }) => {
         waitForFinish: async () => {
             await encoder.flush();
             await outputQueue;
-            await waitForFinish();
+            await ioSynchronizer.waitForFinish();
         },
         close,
-        getQueueSize,
         flush: async () => {
             await encoder.flush();
         },

package/dist/wait-until-return.d.ts

@@ -0,0 +1,4 @@
+export declare const waitUntilReturn: () => {
+    waitForReturn: () => any;
+    isReturning: () => void;
+};

package/dist/wait-until-return.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilReturn = void 0;
+const with_resolvers_1 = require("./with-resolvers");
+const waitUntilReturn = () => {
+    const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+    return {
+        waitForReturn: () => promise,
+        isReturning: () => {
+            resolve(undefined);
+        },
+    };
+};
+exports.waitUntilReturn = waitUntilReturn;

package/dist/with-resolvers.d.ts

@@ -3,3 +3,8 @@ export declare const withResolvers: <T>() => {
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
 };
+export declare const withResolversAndWaitForReturn: <T>() => {
+    getPromiseToImmediatelyReturn: () => Promise<T>;
+    reject: (reason: unknown) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+};

package/dist/with-resolvers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withResolvers = void 0;
+exports.withResolversAndWaitForReturn = exports.withResolvers = void 0;
 const withResolvers = function () {
     let resolve;
     let reject;
@@ -11,3 +11,18 @@ const withResolvers = function () {
     return { promise, resolve: resolve, reject: reject };
 };
 exports.withResolvers = withResolvers;
+const withResolversAndWaitForReturn = () => {
+    const { promise, reject, resolve } = (0, exports.withResolvers)();
+    const { promise: returnPromise, resolve: resolveReturn } = (0, exports.withResolvers)();
+    return {
+        getPromiseToImmediatelyReturn: () => {
+            resolveReturn(undefined);
+            return promise;
+        },
+        reject: (reason) => {
+            returnPromise.then(() => reject(reason));
+        },
+        resolve,
+    };
+};
+exports.withResolversAndWaitForReturn = withResolversAndWaitForReturn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.227",
+  "version": "4.0.229",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -15,15 +15,15 @@
     "dist"
   ],
   "author": "Jonny Burger <jonny@remotion.dev>",
-  "license": "SEE LICENSE IN LICENSE.md",
+  "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.227"
+    "@remotion/media-parser": "4.0.229"
   },
   "peerDependencies": {},
   "devDependencies": {
     "@types/dom-webcodecs": "0.1.11",
     "eslint": "9.14.0",
-    "@remotion/eslint-config-internal": "4.0.227"
+    "@remotion/eslint-config-internal": "4.0.229"
   },
   "keywords": [],
   "publishConfig": {