@remotion/webcodecs 4.0.231 → 4.0.233

package/dist/generate-output-filename.d.ts

@@ -1,2 +1,2 @@
-import type { ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const generateOutputFilename: (source: string | Blob, container: ConvertMediaContainer) => string;

package/dist/get-available-audio-codecs.d.ts

@@ -0,0 +1,7 @@
+import type { ConvertMediaContainer } from './get-available-containers';
+declare const availableAudioCodecs: readonly ["opus", "aac", "wav"];
+export declare const getAvailableAudioCodecs: ({ container, }: {
+    container: ConvertMediaContainer;
+}) => ConvertMediaAudioCodec[];
+export type ConvertMediaAudioCodec = (typeof availableAudioCodecs)[number];
+export {};

package/dist/get-available-audio-codecs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableAudioCodecs = void 0;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const availableAudioCodecs = ['opus', 'aac', 'wav'];
+const getAvailableAudioCodecs = ({ container, }) => {
+    if (container === 'mp4') {
+        return ['aac'];
+    }
+    if (container === 'webm') {
+        return ['opus'];
+    }
+    if (container === 'wav') {
+        return ['wav'];
+    }
+    throw new Error(`Unsupported container: ${container}`);
+};
+exports.getAvailableAudioCodecs = getAvailableAudioCodecs;

package/dist/get-available-containers.d.ts

@@ -0,0 +1,4 @@
+declare const availableContainers: readonly ["webm", "mp4", "wav"];
+export type ConvertMediaContainer = (typeof availableContainers)[number];
+export declare const getAvailableContainers: () => readonly ConvertMediaContainer[];
+export {};

package/dist/get-available-containers.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableContainers = void 0;
+const availableContainers = ['webm', 'mp4', 'wav'];
+const getAvailableContainers = () => {
+    return availableContainers;
+};
+exports.getAvailableContainers = getAvailableContainers;

package/dist/get-available-video-codecs.d.ts

@@ -0,0 +1,7 @@
+import type { ConvertMediaContainer } from './get-available-containers';
+declare const availableVideoCodecs: readonly ["vp8", "vp9", "h264"];
+export type ConvertMediaVideoCodec = (typeof availableVideoCodecs)[number];
+export declare const getAvailableVideoCodecs: ({ container, }: {
+    container: ConvertMediaContainer;
+}) => ConvertMediaVideoCodec[];
+export {};

package/dist/get-available-video-codecs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableVideoCodecs = void 0;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const availableVideoCodecs = ['vp8', 'vp9', 'h264'];
+const getAvailableVideoCodecs = ({ container, }) => {
+    if (container === 'mp4') {
+        return ['h264'];
+    }
+    if (container === 'webm') {
+        return ['vp8', 'vp9'];
+    }
+    if (container === 'wav') {
+        return [];
+    }
+    throw new Error(`Unsupported container: ${container}`);
+};
+exports.getAvailableVideoCodecs = getAvailableVideoCodecs;

package/dist/get-default-audio-codec.d.ts

@@ -1,4 +1,5 @@
-import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const getDefaultAudioCodec: ({ container, }: {
     container: ConvertMediaContainer;
 }) => ConvertMediaAudioCodec;

package/dist/get-default-audio-codec.js

@@ -8,6 +8,9 @@ const getDefaultAudioCodec = ({ container, }) => {
     if (container === 'mp4') {
         return 'aac';
     }
+    if (container === 'wav') {
+        return 'wav';
+    }
     throw new Error(`Unhandled container: ${container}`);
 };
 exports.getDefaultAudioCodec = getDefaultAudioCodec;

package/dist/get-default-video-codec.d.ts

@@ -1,4 +1,5 @@
-import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export declare const getDefaultVideoCodec: ({ container, }: {
     container: ConvertMediaContainer;
-}) => ConvertMediaVideoCodec;
+}) => ConvertMediaVideoCodec | null;

package/dist/get-default-video-codec.js

@@ -5,6 +5,12 @@ const getDefaultVideoCodec = ({ container, }) => {
     if (container === 'webm') {
         return 'vp8';
     }
-    throw new Error(`Unhandled container: ${container} satisfies never`);
+    if (container === 'mp4') {
+        return 'h264';
+    }
+    if (container === 'wav') {
+        return null;
+    }
+    throw new Error(`Unhandled container: ${container}`);
 };
 exports.getDefaultVideoCodec = getDefaultVideoCodec;

package/dist/get-wave-audio-decoder.d.ts

@@ -0,0 +1,2 @@
+import type { CreateAudioDecoderInit, WebCodecsAudioDecoder } from './audio-decoder';
+export declare const getWaveAudioDecoder: ({ onFrame, track, }: Pick<CreateAudioDecoderInit, "onFrame" | "track">) => WebCodecsAudioDecoder;

package/dist/get-wave-audio-decoder.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWaveAudioDecoder = void 0;
+// TODO: Should also be subject to throttling
+const getWaveAudioDecoder = ({ onFrame, track, }) => {
+    let queue = Promise.resolve();
+    const processSample = async (audioSample) => {
+        await onFrame(new AudioData({
+            data: audioSample.data,
+            format: 's16',
+            numberOfChannels: track.numberOfChannels,
+            numberOfFrames: audioSample.data.byteLength / 2,
+            sampleRate: track.sampleRate,
+            timestamp: audioSample.timestamp,
+        }));
+    };
+    return {
+        close() {
+            return Promise.resolve();
+        },
+        processSample(audioSample) {
+            queue = queue.then(() => processSample(audioSample));
+            return queue;
+        },
+        flush: () => Promise.resolve(),
+        waitForFinish: () => Promise.resolve(),
+    };
+};
+exports.getWaveAudioDecoder = getWaveAudioDecoder;

package/dist/index.d.ts

@@ -4,13 +4,22 @@ export { canCopyAudioTrack } from './can-copy-audio-track';
 export { canCopyVideoTrack } from './can-copy-video-track';
 export { canReencodeAudioTrack } from './can-reencode-audio-track';
 export { canReencodeVideoTrack } from './can-reencode-video-track';
-export { ConvertMediaAudioCodec, ConvertMediaContainer, ConvertMediaVideoCodec, getAvailableAudioCodecs, getAvailableContainers, getAvailableVideoCodecs, } from './codec-id';
 export { convertMedia, ConvertMediaOnProgress, ConvertMediaOnVideoFrame, ConvertMediaProgress, ConvertMediaResult, } from './convert-media';
 export { defaultOnAudioTrackHandler } from './default-on-audio-track-handler';
 export { defaultOnVideoTrackHandler } from './default-on-video-track-handler';
+export { ConvertMediaAudioCodec, getAvailableAudioCodecs, } from './get-available-audio-codecs';
+export { ConvertMediaContainer, getAvailableContainers, } from './get-available-containers';
+export { ConvertMediaVideoCodec, getAvailableVideoCodecs, } from './get-available-video-codecs';
 export { getDefaultAudioCodec } from './get-default-audio-codec';
 export { getDefaultVideoCodec } from './get-default-video-codec';
 export { AudioOperation, ConvertMediaOnAudioTrackHandler, } from './on-audio-track-handler';
 export { ConvertMediaOnVideoTrackHandler, VideoOperation, } from './on-video-track-handler';
 export { createVideoDecoder, WebCodecsVideoDecoder } from './video-decoder';
 export { createVideoEncoder, WebCodecsVideoEncoder } from './video-encoder';
+export declare const WebCodecsInternals: {
+    rotateVideoFrame: ({ frame, rotation, }: {
+        frame: VideoFrame;
+        rotation: number;
+    }) => VideoFrame;
+    normalizeVideoRotation: (rotation: number) => number;
+};

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVideoEncoder = exports.createVideoDecoder = exports.getDefaultVideoCodec = exports.getDefaultAudioCodec = exports.defaultOnVideoTrackHandler = exports.defaultOnAudioTrackHandler = exports.convertMedia = exports.getAvailableVideoCodecs = exports.getAvailableContainers = exports.getAvailableAudioCodecs = exports.canReencodeVideoTrack = exports.canReencodeAudioTrack = exports.canCopyVideoTrack = exports.canCopyAudioTrack = exports.createAudioEncoder = exports.createAudioDecoder = void 0;
+exports.WebCodecsInternals = exports.createVideoEncoder = exports.createVideoDecoder = exports.getDefaultVideoCodec = exports.getDefaultAudioCodec = exports.getAvailableVideoCodecs = exports.getAvailableContainers = exports.getAvailableAudioCodecs = exports.defaultOnVideoTrackHandler = exports.defaultOnAudioTrackHandler = exports.convertMedia = exports.canReencodeVideoTrack = exports.canReencodeAudioTrack = exports.canCopyVideoTrack = exports.canCopyAudioTrack = exports.createAudioEncoder = exports.createAudioDecoder = void 0;
+const rotate_video_frame_1 = require("./rotate-video-frame");
 const set_remotion_imported_1 = require("./set-remotion-imported");
 var audio_decoder_1 = require("./audio-decoder");
 Object.defineProperty(exports, "createAudioDecoder", { enumerable: true, get: function () { return audio_decoder_1.createAudioDecoder; } });
@@ -14,16 +15,18 @@ var can_reencode_audio_track_1 = require("./can-reencode-audio-track");
 Object.defineProperty(exports, "canReencodeAudioTrack", { enumerable: true, get: function () { return can_reencode_audio_track_1.canReencodeAudioTrack; } });
 var can_reencode_video_track_1 = require("./can-reencode-video-track");
 Object.defineProperty(exports, "canReencodeVideoTrack", { enumerable: true, get: function () { return can_reencode_video_track_1.canReencodeVideoTrack; } });
-var codec_id_1 = require("./codec-id");
-Object.defineProperty(exports, "getAvailableAudioCodecs", { enumerable: true, get: function () { return codec_id_1.getAvailableAudioCodecs; } });
-Object.defineProperty(exports, "getAvailableContainers", { enumerable: true, get: function () { return codec_id_1.getAvailableContainers; } });
-Object.defineProperty(exports, "getAvailableVideoCodecs", { enumerable: true, get: function () { return codec_id_1.getAvailableVideoCodecs; } });
 var convert_media_1 = require("./convert-media");
 Object.defineProperty(exports, "convertMedia", { enumerable: true, get: function () { return convert_media_1.convertMedia; } });
 var default_on_audio_track_handler_1 = require("./default-on-audio-track-handler");
 Object.defineProperty(exports, "defaultOnAudioTrackHandler", { enumerable: true, get: function () { return default_on_audio_track_handler_1.defaultOnAudioTrackHandler; } });
 var default_on_video_track_handler_1 = require("./default-on-video-track-handler");
 Object.defineProperty(exports, "defaultOnVideoTrackHandler", { enumerable: true, get: function () { return default_on_video_track_handler_1.defaultOnVideoTrackHandler; } });
+var get_available_audio_codecs_1 = require("./get-available-audio-codecs");
+Object.defineProperty(exports, "getAvailableAudioCodecs", { enumerable: true, get: function () { return get_available_audio_codecs_1.getAvailableAudioCodecs; } });
+var get_available_containers_1 = require("./get-available-containers");
+Object.defineProperty(exports, "getAvailableContainers", { enumerable: true, get: function () { return get_available_containers_1.getAvailableContainers; } });
+var get_available_video_codecs_1 = require("./get-available-video-codecs");
+Object.defineProperty(exports, "getAvailableVideoCodecs", { enumerable: true, get: function () { return get_available_video_codecs_1.getAvailableVideoCodecs; } });
 var get_default_audio_codec_1 = require("./get-default-audio-codec");
 Object.defineProperty(exports, "getDefaultAudioCodec", { enumerable: true, get: function () { return get_default_audio_codec_1.getDefaultAudioCodec; } });
 var get_default_video_codec_1 = require("./get-default-video-codec");
@@ -32,4 +35,8 @@ var video_decoder_1 = require("./video-decoder");
 Object.defineProperty(exports, "createVideoDecoder", { enumerable: true, get: function () { return video_decoder_1.createVideoDecoder; } });
 var video_encoder_1 = require("./video-encoder");
 Object.defineProperty(exports, "createVideoEncoder", { enumerable: true, get: function () { return video_encoder_1.createVideoEncoder; } });
+exports.WebCodecsInternals = {
+    rotateVideoFrame: rotate_video_frame_1.rotateVideoFrame,
+    normalizeVideoRotation: rotate_video_frame_1.normalizeVideoRotation,
+};
 (0, set_remotion_imported_1.setRemotionImported)();

package/dist/io-manager/event-emitter.d.ts

@@ -6,10 +6,14 @@ type Output = {
     timestamp: number;
 };
 type Processed = {};
+type Progress = {
+    smallestProgress: number;
+};
 type IoEventMap = {
     input: Input;
     output: Output;
     processed: Processed;
+    progress: Progress;
 };
 export type IoEventTypes = keyof IoEventMap;
 export type CallbackListener<T extends IoEventTypes> = (data: {

package/dist/io-manager/event-emitter.js

@@ -7,6 +7,7 @@ class IoEventEmitter {
             input: [],
             output: [],
             processed: [],
+            progress: [],
         };
     }
     addEventListener(name, callback) {

package/dist/io-manager/io-synchronizer.d.ts

@@ -1,10 +1,16 @@
+import type { ProgressTracker } from '@remotion/media-parser';
 import type { LogLevel } from '../log';
-export declare const makeIoSynchronizer: (logLevel: LogLevel, label: string) => {
+export declare const makeIoSynchronizer: ({ logLevel, label, progress, }: {
+    logLevel: LogLevel;
+    label: string;
+    progress: ProgressTracker;
+}) => {
     inputItem: (timestamp: number, keyFrame: boolean) => void;
     onOutput: (timestamp: number) => void;
-    waitFor: ({ _unprocessed, unemitted, }: {
+    waitFor: ({ _unprocessed, unemitted, minimumProgress, }: {
         unemitted: number;
         _unprocessed: number;
+        minimumProgress: number | null;
     }) => Promise<void>;
     waitForFinish: () => Promise<void>;
     onProcessed: () => void;

package/dist/io-manager/io-synchronizer.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeIoSynchronizer = void 0;
+const media_parser_1 = require("@remotion/media-parser");
 const log_1 = require("../log");
-const with_resolvers_1 = require("../with-resolvers");
-const event_emitter_1 = require("./event-emitter");
-const makeIoSynchronizer = (logLevel, label) => {
-    const eventEmitter = new event_emitter_1.IoEventEmitter();
+const make_timeout_promise_1 = require("./make-timeout-promise");
+const makeIoSynchronizer = ({ logLevel, label, progress, }) => {
+    const eventEmitter = new media_parser_1.MediaParserInternals.IoEventEmitter();
     let lastInput = 0;
     let lastInputKeyframe = 0;
     let lastOutput = 0;
@@ -51,7 +51,7 @@ const makeIoSynchronizer = (logLevel, label) => {
         printState('Got output');
     };
     const waitForOutput = () => {
-        const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+        const { promise, resolve } = media_parser_1.MediaParserInternals.withResolvers();
         const on = () => {
             eventEmitter.removeEventListener('output', on);
             resolve();
@@ -60,7 +60,7 @@ const makeIoSynchronizer = (logLevel, label) => {
         return promise;
     };
     const waitForProcessed = () => {
-        const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
+        const { promise, resolve } = media_parser_1.MediaParserInternals.withResolvers();
         const on = () => {
             eventEmitter.removeEventListener('processed', on);
             resolve();
@@ -68,16 +68,33 @@ const makeIoSynchronizer = (logLevel, label) => {
         eventEmitter.addEventListener('processed', on);
         return promise;
     };
-    const waitFor = async ({ _unprocessed, unemitted, }) => {
-        while (getUnemittedItems() > unemitted) {
-            await waitForOutput();
-        }
-        while (getUnprocessed() > _unprocessed) {
-            await waitForProcessed();
-        }
+    const waitFor = async ({ _unprocessed, unemitted, minimumProgress, }) => {
+        const { timeoutPromise, clear } = (0, make_timeout_promise_1.makeTimeoutPromise)(`Waited too long for ${label}`, 10000);
+        await Promise.race([
+            timeoutPromise,
+            Promise.all([
+                (async () => {
+                    while (getUnemittedItems() > unemitted) {
+                        await waitForOutput();
+                    }
+                })(),
+                (async () => {
+                    while (getUnprocessed() > _unprocessed) {
+                        await waitForProcessed();
+                    }
+                })(),
+                minimumProgress === null
+                    ? Promise.resolve()
+                    : (async () => {
+                        while (progress.getSmallestProgress() < minimumProgress) {
+                            await progress.waitForProgress();
+                        }
+                    })(),
+            ]),
+        ]).finally(() => clear());
     };
     const waitForFinish = async () => {
-        await waitFor({ _unprocessed: 0, unemitted: 0 });
+        await waitFor({ _unprocessed: 0, unemitted: 0, minimumProgress: null });
     };
     const onProcessed = () => {
         eventEmitter.dispatchEvent('processed', {});

package/dist/io-manager/make-timeout-promise.d.ts

@@ -0,0 +1,4 @@
+export declare const makeTimeoutPromise: (label: string, ms: number) => {
+    timeoutPromise: Promise<void>;
+    clear: () => void;
+};

package/dist/io-manager/make-timeout-promise.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTimeoutPromise = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const makeTimeoutPromise = (label, ms) => {
+    const { promise, reject, resolve } = media_parser_1.MediaParserInternals.withResolvers();
+    const timeout = setTimeout(() => {
+        reject(new Error(`${label} (timed out after ${ms}ms)`));
+    }, ms);
+    return {
+        timeoutPromise: promise,
+        clear: () => {
+            clearTimeout(timeout);
+            resolve();
+        },
+    };
+};
+exports.makeTimeoutPromise = makeTimeoutPromise;

package/dist/on-audio-track-handler.d.ts

@@ -1,5 +1,6 @@
 import type { AudioTrack, LogLevel } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaContainer } from './get-available-containers';
 export type AudioOperation = {
     type: 'reencode';
     bitrate: number;

package/dist/on-audio-track.d.ts

@@ -1,9 +1,10 @@
-import type { LogLevel, MediaFn, OnAudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec, ConvertMediaContainer } from './codec-id';
+import type { LogLevel, MediaFn, OnAudioTrack, ProgressTracker } from '@remotion/media-parser';
 import Error from './error-cause';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
-export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }: {
+export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, progressTracker, }: {
     state: MediaFn;
     defaultAudioCodec: ConvertMediaAudioCodec | null;
     controller: AbortController;
@@ -12,4 +13,5 @@ export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCo
     onAudioTrack: ConvertMediaOnAudioTrackHandler | null;
     logLevel: LogLevel;
     container: ConvertMediaContainer;
+    progressTracker: ProgressTracker;
 }) => OnAudioTrack;

package/dist/on-audio-track.js

@@ -12,7 +12,7 @@ const convert_encoded_chunk_1 = require("./convert-encoded-chunk");
 const default_on_audio_track_handler_1 = require("./default-on-audio-track-handler");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const log_1 = require("./log");
-const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, }) => async (track) => {
+const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, container, progressTracker, }) => async (track) => {
     const audioOperation = await (onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : default_on_audio_track_handler_1.defaultOnAudioTrackHandler)({
         defaultAudioCodec: audioCodec,
         track,
@@ -62,7 +62,7 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controlle
         numberOfChannels: track.numberOfChannels,
         sampleRate: track.sampleRate,
         description: track.description,
-    });
+    }, logLevel);
     if (!audioEncoderConfig) {
         abortConversion(new error_cause_1.default(`Could not configure audio encoder of track ${track.trackId}`));
         return null;
@@ -74,7 +74,9 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controlle
     const codecPrivate = audioOperation.audioCodec === 'aac' ? new Uint8Array([17, 144]) : null;
     const { trackNumber } = await state.addTrack({
         type: 'audio',
-        codec: audioOperation.audioCodec,
+        codec: audioOperation.audioCodec === 'wav'
+            ? 'pcm-s16'
+            : audioOperation.audioCodec,
         numberOfChannels: track.numberOfChannels,
         sampleRate: track.sampleRate,
         codecPrivate,
@@ -112,6 +114,7 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controlle
         signal: controller.signal,
         config: audioEncoderConfig,
         logLevel,
+        progressTracker,
     });
     const audioDecoder = (0, audio_decoder_1.createAudioDecoder)({
         onFrame: async (frame) => {
@@ -125,13 +128,15 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controlle
             frame.close();
         },
         onError(error) {
-            abortConversion(new error_cause_1.default(`Audio decoder of track ${track.trackId} failed (see .cause of this error)`, {
+            abortConversion(new error_cause_1.default(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
                 cause: error,
             }));
         },
         signal: controller.signal,
         config: audioDecoderConfig,
         logLevel,
+        track,
+        progressTracker,
     });
     state.addWaitForFinishPromise(async () => {
         await audioDecoder.waitForFinish();

package/dist/on-frame.d.ts

@@ -1,11 +1,12 @@
 import type { VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
 import type { ConvertMediaOnVideoFrame } from './convert-media';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import type { WebCodecsVideoEncoder } from './video-encoder';
-export declare const onFrame: ({ frame, onVideoFrame, videoEncoder, track, outputCodec, }: {
+export declare const onFrame: ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, track, outputCodec, rotation, }: {
     frame: VideoFrame;
     onVideoFrame: ConvertMediaOnVideoFrame | null;
     videoEncoder: WebCodecsVideoEncoder;
     track: VideoTrack;
     outputCodec: ConvertMediaVideoCodec;
+    rotation: number;
 }) => Promise<void>;

package/dist/on-frame.js

@@ -2,36 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onFrame = void 0;
 const convert_to_correct_videoframe_1 = require("./convert-to-correct-videoframe");
-const onFrame = async ({ frame, onVideoFrame, videoEncoder, track, outputCodec, }) => {
-    const newFrame = onVideoFrame ? await onVideoFrame({ frame, track }) : frame;
-    if (newFrame.codedHeight !== frame.displayHeight) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedHeight (${newFrame.codedHeight}) than the input frame displayHeight (${frame.displayHeight})`);
-    }
-    if (newFrame.codedWidth !== frame.displayWidth) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different codedWidth (${newFrame.codedWidth}) than the input frame displayWidth (${frame.displayWidth})`);
+const rotate_video_frame_1 = require("./rotate-video-frame");
+const onFrame = async ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, track, outputCodec, rotation, }) => {
+    var _a, _b;
+    const rotated = (0, rotate_video_frame_1.rotateVideoFrame)({
+        rotation,
+        frame: unrotatedFrame,
+    });
+    if (unrotatedFrame !== rotated) {
+        unrotatedFrame.close();
     }
-    if (newFrame.displayWidth !== frame.displayWidth) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${newFrame.displayWidth}) than the input frame (${newFrame.displayHeight})`);
+    const userProcessedFrame = onVideoFrame
+        ? await onVideoFrame({ frame: rotated, track })
+        : rotated;
+    if (userProcessedFrame.displayWidth !== rotated.displayWidth) {
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayWidth (${userProcessedFrame.displayWidth}) than the input frame (${userProcessedFrame.displayHeight})`);
     }
-    if (newFrame.displayHeight !== frame.displayHeight) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${newFrame.displayHeight}) than the input frame (${newFrame.displayHeight})`);
+    if (userProcessedFrame.displayHeight !== rotated.displayHeight) {
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different displayHeight (${userProcessedFrame.displayHeight}) than the input frame (${userProcessedFrame.displayHeight})`);
     }
-    if (newFrame.timestamp !== frame.timestamp) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different timestamp (${newFrame.timestamp}) than the input frame (${newFrame.timestamp}). When calling new VideoFrame(), pass {timestamp: frame.timestamp} as second argument`);
+    if (userProcessedFrame.timestamp !== rotated.timestamp) {
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different timestamp (${userProcessedFrame.timestamp}) than the input frame (${rotated.timestamp}). When calling new VideoFrame(), pass {timestamp: frame.timestamp} as second argument`);
     }
-    if (newFrame.duration !== frame.duration) {
-        throw new Error(`Returned VideoFrame of track ${track.trackId} has different duration (${newFrame.duration}) than the input frame (${newFrame.duration}). When calling new VideoFrame(), pass {duration: frame.duration} as second argument`);
+    if (((_a = userProcessedFrame.duration) !== null && _a !== void 0 ? _a : 0) !== ((_b = rotated.duration) !== null && _b !== void 0 ? _b : 0)) {
+        throw new Error(`Returned VideoFrame of track ${track.trackId} has different duration (${userProcessedFrame.duration}) than the input frame (${rotated.duration}). When calling new VideoFrame(), pass {duration: frame.duration} as second argument`);
     }
     const fixedFrame = (0, convert_to_correct_videoframe_1.convertToCorrectVideoFrame)({
-        videoFrame: newFrame,
+        videoFrame: userProcessedFrame,
         outputCodec,
     });
     await videoEncoder.encodeFrame(fixedFrame, fixedFrame.timestamp);
     fixedFrame.close();
-    if (frame !== newFrame) {
-        frame.close();
+    if (rotated !== userProcessedFrame) {
+        rotated.close();
     }
-    if (fixedFrame !== newFrame) {
+    if (fixedFrame !== userProcessedFrame) {
         fixedFrame.close();
     }
 };

package/dist/on-video-track-handler.d.ts

@@ -1,8 +1,10 @@
 import type { LogLevel, VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export type VideoOperation = {
     type: 'reencode';
     videoCodec: ConvertMediaVideoCodec;
+    rotate?: number;
 } | {
     type: 'copy';
 } | {
@@ -15,4 +17,5 @@ export type ConvertMediaOnVideoTrackHandler = (options: {
     track: VideoTrack;
     logLevel: LogLevel;
     container: ConvertMediaContainer;
+    rotate: number;
 }) => VideoOperation | Promise<VideoOperation>;

package/dist/on-video-track.d.ts

@@ -1,10 +1,11 @@
-import type { LogLevel, MediaFn, OnVideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { LogLevel, MediaFn, OnVideoTrack, ProgressTracker } from '@remotion/media-parser';
 import type { ConvertMediaOnVideoFrame } from './convert-media';
 import Error from './error-cause';
+import type { ConvertMediaContainer } from './get-available-containers';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import type { ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
-export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, container, }: {
+export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, container, rotate, progress, }: {
     state: MediaFn;
     onVideoFrame: null | ConvertMediaOnVideoFrame;
     onMediaStateUpdate: null | ConvertMediaProgressFn;
@@ -14,4 +15,6 @@ export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaState
     onVideoTrack: ConvertMediaOnVideoTrackHandler | null;
     logLevel: LogLevel;
     container: ConvertMediaContainer;
+    rotate: number;
+    progress: ProgressTracker;
 }) => OnVideoTrack;