@remotion/webcodecs 4.0.229 → 4.0.231

package/dist/throttled-state-update.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttledStateUpdate = void 0;
+const throttledStateUpdate = ({ updateFn, everyMilliseconds, signal, }) => {
+    let currentState = {
+        decodedAudioFrames: 0,
+        decodedVideoFrames: 0,
+        encodedVideoFrames: 0,
+        encodedAudioFrames: 0,
+        bytesWritten: 0,
+        millisecondsWritten: 0,
+        expectedOutputDurationInMs: null,
+        overallProgress: 0,
+    };
+    if (!updateFn) {
+        return {
+            get: () => currentState,
+            update: null,
+            stopAndGetLastProgress: () => { },
+        };
+    }
+    let lastUpdated = null;
+    const callUpdateIfChanged = () => {
+        if (currentState === lastUpdated) {
+            return;
+        }
+        updateFn(currentState);
+        lastUpdated = currentState;
+    };
+    const interval = setInterval(() => {
+        callUpdateIfChanged();
+    }, everyMilliseconds);
+    const onAbort = () => {
+        clearInterval(interval);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    return {
+        get: () => currentState,
+        update: (fn) => {
+            currentState = fn(currentState);
+        },
+        stopAndGetLastProgress: () => {
+            clearInterval(interval);
+            signal.removeEventListener('abort', onAbort);
+            return currentState;
+        },
+    };
+};
+exports.throttledStateUpdate = throttledStateUpdate;

package/dist/video-decoder.d.ts

@@ -1,6 +1,6 @@
-import type { LogLevel, VideoSample } from '@remotion/media-parser';
+import type { AudioOrVideoSample, LogLevel } from '@remotion/media-parser';
 export type WebCodecsVideoDecoder = {
-    processSample: (videoSample: VideoSample) => Promise<void>;
+    processSample: (videoSample: AudioOrVideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;

package/dist/video-decoder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoDecoder = void 0;
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
+const log_1 = require("./log");
 const createVideoDecoder = ({ onFrame, onError, signal, config, logLevel, }) => {
     const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Video decoder');
     let outputQueue = Promise.resolve();
@@ -69,9 +70,13 @@ const createVideoDecoder = ({ onFrame, onError, signal, config, logLevel, }) =>
         },
         waitForFinish: async () => {
             await videoDecoder.flush();
+            log_1.Log.verbose(logLevel, 'Flushed video decoder');
             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 () => {

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

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

package/dist/video-encoder-config.js

@@ -1,14 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoEncoderConfig = void 0;
-const getVideoEncoderConfig = async ({ width, height, codec, }) => {
+const browser_quirks_1 = require("./browser-quirks");
+const choose_correct_avc1_profile_1 = require("./choose-correct-avc1-profile");
+const getVideoEncoderConfig = async ({ codec, height, width, fps, }) => {
     if (typeof VideoEncoder === 'undefined') {
         return null;
     }
     const config = {
-        codec: codec === 'vp9' ? 'vp09.00.10.08' : codec,
+        codec: codec === 'h264'
+            ? (0, choose_correct_avc1_profile_1.chooseCorrectAvc1Profile)({ fps, height, width })
+            : codec === 'vp9'
+                ? 'vp09.00.10.08'
+                : codec,
         height,
         width,
+        bitrate: (0, browser_quirks_1.isSafari)() ? 3000000 : undefined,
     };
     const hardware = {
         ...config,

package/dist/video-encoder.d.ts

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

package/dist/video-encoder.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVideoEncoder = void 0;
+const convert_to_correct_videoframe_1 = require("./convert-to-correct-videoframe");
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
-const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, }) => {
+const log_1 = require("./log");
+const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, outputCodec, }) => {
     if (signal.aborted) {
         throw new Error('Not creating video encoder, already aborted');
     }
@@ -12,18 +14,16 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, }) =>
         error(error) {
             onError(error);
         },
-        output(chunk) {
-            if (chunk.duration === null) {
-                throw new Error('Duration is null');
-            }
-            const timestamp = chunk.timestamp + chunk.duration;
+        output(chunk, metadata) {
+            var _a;
+            const timestamp = chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0);
             ioSynchronizer.onOutput(timestamp);
             outputQueue = outputQueue
                 .then(() => {
                 if (signal.aborted) {
                     return;
                 }
-                return onChunk(chunk);
+                return onChunk(chunk, metadata !== null && metadata !== void 0 ? metadata : null);
             })
                 .then(() => {
                 ioSynchronizer.onProcessed();
@@ -46,6 +46,7 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, }) =>
         close();
     };
     signal.addEventListener('abort', onAbort);
+    log_1.Log.verbose(logLevel, 'Configuring video encoder', config);
     encoder.configure(config);
     let framesProcessed = 0;
     const encodeFrame = async (frame) => {
@@ -53,15 +54,16 @@ const createVideoEncoder = ({ onChunk, onError, signal, config, logLevel, }) =>
             return;
         }
         await ioSynchronizer.waitFor({
-            unemitted: 2,
-            _unprocessed: 2,
+            // Firefox stalls if too few frames are passed
+            unemitted: 10,
+            _unprocessed: 10,
         });
         // @ts-expect-error - can have changed in the meanwhile
         if (encoder.state === 'closed') {
             return;
         }
         const keyFrame = framesProcessed % 40 === 0;
-        encoder.encode(frame, {
+        encoder.encode((0, convert_to_correct_videoframe_1.convertToCorrectVideoFrame)({ videoFrame: frame, outputCodec }), {
             keyFrame,
         });
         ioSynchronizer.inputItem(frame.timestamp, keyFrame);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.229",
+  "version": "4.0.231",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -17,19 +17,20 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.229"
+    "@remotion/media-parser": "4.0.231"
   },
   "peerDependencies": {},
   "devDependencies": {
     "@types/dom-webcodecs": "0.1.11",
     "eslint": "9.14.0",
-    "@remotion/eslint-config-internal": "4.0.229"
+    "@remotion/eslint-config-internal": "4.0.231"
   },
   "keywords": [],
   "publishConfig": {
     "access": "public"
   },
   "description": "Media conversion in the browser",
+  "homepage": "https://remotion.dev/webcodecs",
   "scripts": {
     "formatting": "prettier src --check",
     "lint": "eslint src",

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

@@ -1,7 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,15 +0,0 @@
-"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/event-emitter.d.ts

@@ -1,25 +0,0 @@
-type Input = {
-    timestamp: number;
-    keyframe: boolean;
-};
-type Output = {
-    timestamp: number;
-};
-type IoEventMap = {
-    input: Input;
-    output: Output;
-};
-export type IoEventTypes = keyof IoEventMap;
-export type CallbackListener<T extends IoEventTypes> = (data: {
-    detail: IoEventMap[T];
-}) => void;
-type IoListeners = {
-    [EventType in IoEventTypes]: CallbackListener<EventType>[];
-};
-export declare class IoEventEmitter {
-    listeners: IoListeners;
-    addEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
-    removeEventListener<Q extends IoEventTypes>(name: Q, callback: CallbackListener<Q>): void;
-    dispatchEvent<T extends IoEventTypes>(dispatchName: T, context: IoEventMap[T]): void;
-}
-export {};

package/dist/event-emitter.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IoEventEmitter = void 0;
-class IoEventEmitter {
-    constructor() {
-        this.listeners = {
-            input: [],
-            output: [],
-        };
-    }
-    addEventListener(name, callback) {
-        this.listeners[name].push(callback);
-    }
-    removeEventListener(name, callback) {
-        this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
-    }
-    dispatchEvent(dispatchName, context) {
-        this.listeners[dispatchName].forEach((callback) => {
-            callback({ detail: context });
-        });
-    }
-}
-exports.IoEventEmitter = IoEventEmitter;

package/dist/polyfill-encoded-audio-chunk.d.ts

@@ -1,3 +0,0 @@
-import type { AudioSample } from '@remotion/media-parser';
-import type { AudioOrVideoSample } from '@remotion/media-parser/src/create/cluster';
-export declare const polyfillAudioChunk: (audioSample: AudioSample) => AudioOrVideoSample;

package/dist/polyfill-encoded-audio-chunk.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.polyfillAudioChunk = void 0;
-const polyfillAudioChunk = (audioSample) => { };
-exports.polyfillAudioChunk = polyfillAudioChunk;

package/dist/resolve-audio-action.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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) {
-        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) {
-        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 Promise.resolve({ type: 'drop' });
-};
-exports.defaultResolveAudioAction = defaultResolveAudioAction;

package/dist/resolve-video-action.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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) {
-        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) {
-        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 Promise.resolve({ type: 'drop' });
-};
-exports.defaultResolveVideoAction = defaultResolveVideoAction;

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

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

package/dist/wait-until-return.js

@@ -1,14 +0,0 @@
-"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;