@remotion/webcodecs 4.0.304 → 4.0.306

package/dist/video-decoder.js

@@ -1,61 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVideoDecoder = void 0;
+exports.createVideoDecoder = exports.internalCreateVideoDecoder = void 0;
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
 const log_1 = require("./log");
-const sort_video_frames_1 = require("./sort-video-frames");
-const createVideoDecoder = ({ onFrame, onError, controller, config, logLevel, progress, }) => {
+const internalCreateVideoDecoder = ({ onFrame, onError, controller, config, logLevel, }) => {
     const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
         logLevel,
         label: 'Video decoder',
-        progress,
-    });
-    let outputQueue = Promise.resolve();
-    const addToQueue = (frame) => {
-        const cleanup = () => {
-            frame.close();
-        };
-        controller._internals._mediaParserController._internals.signal.addEventListener('abort', cleanup, {
-            once: true,
-        });
-        outputQueue = outputQueue
-            .then(() => {
-            if (controller._internals._mediaParserController._internals.signal.aborted) {
-                return;
-            }
-            return onFrame(frame);
-        })
-            .then(() => {
-            ioSynchronizer.onProcessed();
-        })
-            .catch((err) => {
-            onError(err);
-        })
-            .finally(() => {
-            controller._internals._mediaParserController._internals.signal.removeEventListener('abort', cleanup);
-            cleanup();
-        });
-        return outputQueue;
-    };
-    const frameSorter = (0, sort_video_frames_1.videoFrameSorter)({
         controller,
-        onRelease: async (frame) => {
-            await addToQueue(frame);
-        },
     });
     const videoDecoder = new VideoDecoder({
-        output(frame) {
+        async output(frame) {
+            try {
+                await onFrame(frame);
+            }
+            catch (err) {
+                onError(err);
+                frame.close();
+            }
             ioSynchronizer.onOutput(frame.timestamp);
-            frameSorter.inputFrame(frame);
         },
         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 (videoDecoder.state === 'closed') {
             return;
         }
@@ -64,52 +38,43 @@ const createVideoDecoder = ({ onFrame, onError, controller, config, logLevel, pr
     const onAbort = () => {
         close();
     };
-    controller._internals._mediaParserController._internals.signal.addEventListener('abort', onAbort);
+    if (controller) {
+        controller._internals._mediaParserController._internals.signal.addEventListener('abort', onAbort);
+    }
     videoDecoder.configure(config);
-    const processSample = async (sample) => {
+    const decode = (sample) => {
         if (videoDecoder.state === 'closed') {
             return;
         }
-        // @ts-expect-error - can have changed in the meanwhile
-        if (videoDecoder.state === 'closed') {
-            return;
-        }
-        progress.setPossibleLowestTimestamp(Math.min(sample.timestamp, sample.dts ?? Infinity, sample.cts ?? Infinity));
-        await ioSynchronizer.waitFor({
-            unemitted: 20,
-            unprocessed: 10,
-            minimumProgress: sample.timestamp - 10000000,
-            controller,
-        });
-        // Don't flush here.
-        // We manually keep track of the memory with the IO synchornizer.
-        // Example of flushing breaking things:
-        // IMG_2310.MOV has B-frames, and if we flush on a keyframe, we discard some frames that are yet to come.
-        videoDecoder.decode(new EncodedVideoChunk(sample));
-        ioSynchronizer.inputItem(sample.timestamp, sample.type === 'key');
+        const encodedChunk = sample instanceof EncodedVideoChunk
+            ? sample
+            : new EncodedVideoChunk(sample);
+        videoDecoder.decode(encodedChunk);
+        ioSynchronizer.inputItem(sample.timestamp);
     };
-    let inputQueue = Promise.resolve();
     return {
-        processSample: (sample) => {
-            inputQueue = inputQueue.then(() => processSample(sample));
-            return inputQueue;
-        },
+        decode,
         waitForFinish: async () => {
             await videoDecoder.flush();
             log_1.Log.verbose(logLevel, 'Flushed video decoder');
-            await frameSorter.flush();
-            log_1.Log.verbose(logLevel, 'Frame sorter flushed');
-            await ioSynchronizer.waitForFinish(controller);
+            await ioSynchronizer.waitForFinish();
             log_1.Log.verbose(logLevel, 'IO synchro finished');
-            await outputQueue;
-            log_1.Log.verbose(logLevel, 'Output queue finished');
-            await inputQueue;
-            log_1.Log.verbose(logLevel, 'Input queue finished');
         },
         close,
         flush: async () => {
             await videoDecoder.flush();
         },
+        waitForQueueToBeLessThan: ioSynchronizer.waitForQueueSize,
     };
 };
+exports.internalCreateVideoDecoder = internalCreateVideoDecoder;
+const createVideoDecoder = ({ onFrame, onError, controller, track, logLevel, }) => {
+    return (0, exports.internalCreateVideoDecoder)({
+        onFrame,
+        onError,
+        controller: controller ?? null,
+        config: track,
+        logLevel: logLevel ?? 'info',
+    });
+};
 exports.createVideoDecoder = createVideoDecoder;

package/dist/video-encoder.d.ts

@@ -1,19 +1,20 @@
 import { type MediaParserLogLevel } from '@remotion/media-parser';
-import type { ProgressTracker } from './create/progress-tracker';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+import type { IoSynchronizer } from './io-manager/io-synchronizer';
 import type { WebCodecsController } from './webcodecs-controller';
 export type WebCodecsVideoEncoder = {
-    encodeFrame: (videoFrame: VideoFrame, timestamp: number) => Promise<void>;
+    encode: (videoFrame: VideoFrame) => void;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;
+    ioSynchronizer: IoSynchronizer;
 };
-export declare const createVideoEncoder: ({ onChunk, onError, controller, config, logLevel, outputCodec, progress, }: {
+export declare const createVideoEncoder: ({ onChunk, onError, controller, config, logLevel, outputCodec, keyframeInterval, }: {
     onChunk: (chunk: EncodedVideoChunk, metadata: EncodedVideoChunkMetadata | null) => Promise<void>;
-    onError: (error: DOMException) => void;
+    onError: (error: Error) => void;
     controller: WebCodecsController;
     config: VideoEncoderConfig;
     logLevel: MediaParserLogLevel;
     outputCodec: ConvertMediaVideoCodec;
-    progress: ProgressTracker;
+    keyframeInterval: number;
 }) => WebCodecsVideoEncoder;

package/dist/video-encoder.js

@@ -5,38 +5,28 @@ const media_parser_1 = require("@remotion/media-parser");
 const convert_to_correct_videoframe_1 = require("./convert-to-correct-videoframe");
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
 const log_1 = require("./log");
-const createVideoEncoder = ({ onChunk, onError, controller, config, logLevel, outputCodec, progress, }) => {
+const createVideoEncoder = ({ onChunk, onError, controller, config, logLevel, outputCodec, keyframeInterval, }) => {
     if (controller._internals._mediaParserController._internals.signal.aborted) {
         throw new media_parser_1.MediaParserAbortError('Not creating video encoder, already aborted');
     }
     const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
         logLevel,
         label: 'Video encoder',
-        progress,
+        controller,
     });
-    let outputQueue = Promise.resolve();
     const encoder = new VideoEncoder({
         error(error) {
             onError(error);
         },
-        output(chunk, metadata) {
+        async output(chunk, metadata) {
             const timestamp = chunk.timestamp + (chunk.duration ?? 0);
-            ioSynchronizer.onOutput(timestamp);
-            outputQueue = outputQueue
-                .then(() => {
-                if (controller._internals._mediaParserController._internals.signal
-                    .aborted) {
-                    return;
-                }
-                return onChunk(chunk, metadata ?? null);
-            })
-                .then(() => {
-                ioSynchronizer.onProcessed();
-                return Promise.resolve();
-            })
-                .catch((err) => {
+            try {
+                await onChunk(chunk, metadata ?? null);
+            }
+            catch (err) {
                 onError(err);
-            });
+            }
+            ioSynchronizer.onOutput(timestamp);
         },
     });
     const close = () => {
@@ -55,23 +45,11 @@ const createVideoEncoder = ({ onChunk, onError, controller, config, logLevel, ou
     log_1.Log.verbose(logLevel, 'Configuring video encoder', config);
     encoder.configure(config);
     let framesProcessed = 0;
-    const encodeFrame = async (frame) => {
-        if (encoder.state === 'closed') {
-            return;
-        }
-        progress.setPossibleLowestTimestamp(frame.timestamp);
-        await ioSynchronizer.waitFor({
-            // Firefox stalls if too few frames are passed
-            unemitted: 10,
-            unprocessed: 10,
-            minimumProgress: frame.timestamp - 10000000,
-            controller,
-        });
-        // @ts-expect-error - can have changed in the meanwhile
+    const encodeFrame = (frame) => {
         if (encoder.state === 'closed') {
             return;
         }
-        const keyFrame = framesProcessed % 40 === 0;
+        const keyFrame = framesProcessed % keyframeInterval === 0;
         encoder.encode((0, convert_to_correct_videoframe_1.convertToCorrectVideoFrame)({ videoFrame: frame, outputCodec }), {
             keyFrame,
             // @ts-expect-error
@@ -79,24 +57,22 @@ const createVideoEncoder = ({ onChunk, onError, controller, config, logLevel, ou
                 quantizer: 36,
             },
         });
-        ioSynchronizer.inputItem(frame.timestamp, keyFrame);
+        ioSynchronizer.inputItem(frame.timestamp);
         framesProcessed++;
     };
-    let inputQueue = Promise.resolve();
     return {
-        encodeFrame: (frame) => {
-            inputQueue = inputQueue.then(() => encodeFrame(frame));
-            return inputQueue;
+        encode: (frame) => {
+            encodeFrame(frame);
         },
         waitForFinish: async () => {
             await encoder.flush();
-            await outputQueue;
-            await ioSynchronizer.waitForFinish(controller);
+            await ioSynchronizer.waitForFinish();
         },
         close,
         flush: async () => {
             await encoder.flush();
         },
+        ioSynchronizer,
     };
 };
 exports.createVideoEncoder = createVideoEncoder;

package/dist/wav-audio-encoder.d.ts

@@ -1,2 +1,5 @@
 import type { AudioEncoderInit, WebCodecsAudioEncoder } from './audio-encoder';
-export declare const getWaveAudioEncoder: ({ onChunk, controller, config, }: Pick<AudioEncoderInit, "onChunk" | "controller" | "config">) => WebCodecsAudioEncoder;
+import type { IoSynchronizer } from './io-manager/io-synchronizer';
+export declare const getWaveAudioEncoder: ({ onChunk, controller, config, ioSynchronizer, }: Pick<AudioEncoderInit, "onChunk" | "controller" | "config"> & {
+    ioSynchronizer: IoSynchronizer;
+}) => WebCodecsAudioEncoder;

package/dist/wav-audio-encoder.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWaveAudioEncoder = void 0;
 const convert_audiodata_1 = require("./convert-audiodata");
-const getWaveAudioEncoder = ({ onChunk, controller, config, }) => {
+const getWaveAudioEncoder = ({ onChunk, controller, config, ioSynchronizer, }) => {
     return {
         close: () => {
             return Promise.resolve();
         },
-        encodeFrame: (unconvertedAudioData) => {
+        encode: (unconvertedAudioData) => {
             if (controller._internals._mediaParserController._internals.signal.aborted) {
                 return Promise.resolve();
             }
@@ -28,6 +28,7 @@ const getWaveAudioEncoder = ({ onChunk, controller, config, }) => {
         },
         flush: () => Promise.resolve(),
         waitForFinish: () => Promise.resolve(),
+        ioSynchronizer,
     };
 };
 exports.getWaveAudioEncoder = getWaveAudioEncoder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.304",
+  "version": "4.0.306",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -19,8 +19,8 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.304",
-    "@remotion/licensing": "4.0.304"
+    "@remotion/media-parser": "4.0.306",
+    "@remotion/licensing": "4.0.306"
   },
   "peerDependencies": {},
   "devDependencies": {
@@ -28,8 +28,8 @@
     "playwright": "1.51.1",
     "@playwright/test": "1.51.1",
     "eslint": "9.19.0",
-    "@remotion/eslint-config-internal": "4.0.304",
-    "@remotion/example-videos": "4.0.304"
+    "@remotion/example-videos": "4.0.306",
+    "@remotion/eslint-config-internal": "4.0.306"
   },
   "keywords": [],
   "publishConfig": {