@remotion/webcodecs 4.0.241 → 4.0.242

package/dist/audio-decoder.js

@@ -78,11 +78,6 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, track,
     let queue = Promise.resolve();
     return {
         processSample: (sample) => {
-            // In example.avi, we have samples with 0 data
-            // Chrome fails on these
-            if (sample.data.length === 0) {
-                return queue;
-            }
             queue = queue.then(() => processSample(sample));
             return queue;
         },

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

@@ -1,9 +1,10 @@
-import type { MediaParserVideoCodec, ParseMediaContainer } from '@remotion/media-parser';
+import type { ParseMediaContainer, VideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaContainer } from './get-available-containers';
-export declare const canCopyVideoTrack: ({ inputCodec, outputContainer, inputRotation, rotationToApply, inputContainer, }: {
+import type { ResizeOperation } from './resizing/mode';
+export declare const canCopyVideoTrack: ({ outputContainer, rotationToApply, inputContainer, resizeOperation, inputTrack, }: {
     inputContainer: ParseMediaContainer;
-    inputCodec: MediaParserVideoCodec;
-    inputRotation: number;
+    inputTrack: VideoTrack;
     rotationToApply: number;
     outputContainer: ConvertMediaContainer;
+    resizeOperation: ResizeOperation | null;
 }) => boolean;

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

@@ -1,17 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyVideoTrack = void 0;
-const rotate_video_frame_1 = require("./rotate-video-frame");
-const canCopyVideoTrack = ({ inputCodec, outputContainer, inputRotation, rotationToApply, inputContainer, }) => {
-    if ((0, rotate_video_frame_1.normalizeVideoRotation)(inputRotation) !==
-        (0, rotate_video_frame_1.normalizeVideoRotation)(rotationToApply)) {
+const rotate_and_resize_video_frame_1 = require("./rotate-and-resize-video-frame");
+const rotation_1 = require("./rotation");
+const canCopyVideoTrack = ({ outputContainer, rotationToApply, inputContainer, resizeOperation, inputTrack, }) => {
+    if ((0, rotate_and_resize_video_frame_1.normalizeVideoRotation)(inputTrack.rotation) !==
+        (0, rotate_and_resize_video_frame_1.normalizeVideoRotation)(rotationToApply)) {
+        return false;
+    }
+    const newDimensions = (0, rotation_1.calculateNewDimensionsFromRotateAndScale)({
+        height: inputTrack.height,
+        resizeOperation,
+        rotation: rotationToApply,
+        videoCodec: inputTrack.codecWithoutConfig,
+        width: inputTrack.width,
+    });
+    if (newDimensions.height !== inputTrack.height ||
+        newDimensions.width !== inputTrack.width) {
         return false;
     }
     if (outputContainer === 'webm') {
-        return inputCodec === 'vp8' || inputCodec === 'vp9';
+        return (inputTrack.codecWithoutConfig === 'vp8' ||
+            inputTrack.codecWithoutConfig === 'vp9');
     }
     if (outputContainer === 'mp4') {
-        return (inputCodec === 'h264' &&
+        return (inputTrack.codecWithoutConfig === 'h264' &&
             (inputContainer === 'mp4' || inputContainer === 'avi'));
     }
     if (outputContainer === 'wav') {

package/dist/convert-encoded-chunk.js

@@ -33,6 +33,8 @@ const convertEncodedChunk = (chunk, trackId) => {
         cts: chunk.timestamp,
         dts: chunk.timestamp,
         trackId,
+        offset: 0,
+        timescale: 1000000,
     };
 };
 exports.convertEncodedChunk = convertEncodedChunk;

package/dist/convert-media.d.ts

@@ -8,6 +8,7 @@ import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 import { type ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import { type ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
+import type { ResizeOperation } from './resizing/mode';
 export type ConvertMediaProgress = {
     decodedVideoFrames: number;
     decodedAudioFrames: number;
@@ -28,7 +29,7 @@ export type ConvertMediaOnVideoFrame = (options: {
     frame: VideoFrame;
     track: VideoTrack;
 }) => Promise<VideoFrame> | VideoFrame;
-export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, progressIntervalInMs, rotate, apiKey, ...more }: {
+export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, progressIntervalInMs, rotate, apiKey, resize, ...more }: {
     src: ParseMediaOptions<F>["src"];
     container: ConvertMediaContainer;
     onVideoFrame?: ConvertMediaOnVideoFrame;
@@ -43,5 +44,6 @@ export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src,
     writer?: WriterInterface;
     progressIntervalInMs?: number;
     rotate?: number;
+    resize?: ResizeOperation;
     apiKey?: string | null;
 } & ParseMediaDynamicOptions<F>) => Promise<ConvertMediaResult>;

package/dist/convert-media.js

@@ -19,7 +19,7 @@ const on_video_track_1 = require("./on-video-track");
 const select_container_creator_1 = require("./select-container-creator");
 const send_telemetry_event_1 = require("./send-telemetry-event");
 const throttled_state_update_1 = require("./throttled-state-update");
-const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, progressIntervalInMs, rotate, apiKey, ...more }) {
+const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, progressIntervalInMs, rotate, apiKey, resize, ...more }) {
     var _a, _b;
     if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
         return Promise.reject(new error_cause_1.default('Aborted'));
@@ -92,6 +92,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         outputContainer: container,
         rotate: rotate !== null && rotate !== void 0 ? rotate : 0,
         progress: progressTracker,
+        resizeOperation: resize !== null && resize !== void 0 ? resize : null,
     });
     const onAudioTrack = (0, on_audio_track_1.makeAudioTrackHandler)({
         abortConversion,

package/dist/default-on-video-track-handler.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOnVideoTrackHandler = void 0;
 const media_parser_1 = require("@remotion/media-parser");
 const can_reencode_video_track_1 = require("./can-reencode-video-track");
-const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel, rotate, canCopyTrack, }) => {
+const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel, rotate, canCopyTrack, resizeOperation, }) => {
     if (canCopyTrack) {
         media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
         return Promise.resolve({ type: 'copy' });
@@ -21,7 +21,8 @@ const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel,
         return Promise.resolve({
             type: 'reencode',
             videoCodec: defaultVideoCodec,
-            rotation: rotate - track.rotation,
+            rotate: rotate - track.rotation,
+            resize: resizeOperation,
         });
     }
     media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);

package/dist/esm/index.mjs

@@ -92,38 +92,161 @@ var require_dist = __commonJS((exports) => {
   } });
 });
 
+// src/resizing/calculate-new-size.ts
+var ensureMultipleOfTwo = ({
+  dimensions,
+  needsToBeMultipleOfTwo
+}) => {
+  if (!needsToBeMultipleOfTwo) {
+    return dimensions;
+  }
+  return {
+    width: Math.floor(dimensions.width / 2) * 2,
+    height: Math.floor(dimensions.height / 2) * 2
+  };
+};
+var calculateNewSizeAfterResizing = ({
+  dimensions,
+  resizeOperation,
+  videoCodec
+}) => {
+  const needsToBeMultipleOfTwo = videoCodec === "h264";
+  if (resizeOperation === null) {
+    return ensureMultipleOfTwo({
+      dimensions,
+      needsToBeMultipleOfTwo
+    });
+  }
+  if (resizeOperation.mode === "width") {
+    return ensureMultipleOfTwo({
+      dimensions: {
+        width: resizeOperation.width,
+        height: Math.round(resizeOperation.width / dimensions.width * dimensions.height)
+      },
+      needsToBeMultipleOfTwo
+    });
+  }
+  if (resizeOperation.mode === "height") {
+    return ensureMultipleOfTwo({
+      dimensions: {
+        width: Math.round(resizeOperation.height / dimensions.height * dimensions.width),
+        height: resizeOperation.height
+      },
+      needsToBeMultipleOfTwo
+    });
+  }
+  if (resizeOperation.mode === "max-height") {
+    const height = Math.min(dimensions.height, resizeOperation.maxHeight);
+    return ensureMultipleOfTwo({
+      dimensions: {
+        width: Math.round(height / dimensions.height * dimensions.width),
+        height
+      },
+      needsToBeMultipleOfTwo
+    });
+  }
+  if (resizeOperation.mode === "max-width") {
+    const width = Math.min(dimensions.width, resizeOperation.maxWidth);
+    return ensureMultipleOfTwo({
+      dimensions: {
+        width,
+        height: Math.round(width / dimensions.width * dimensions.height)
+      },
+      needsToBeMultipleOfTwo
+    });
+  }
+  if (resizeOperation.mode === "max-height-width") {
+    const height = Math.min(dimensions.height, resizeOperation.maxHeight);
+    const width = Math.min(dimensions.width, resizeOperation.maxWidth);
+    const scale = Math.min(width / dimensions.width, height / dimensions.height);
+    const actualWidth = Math.round(dimensions.width * scale);
+    const actualHeight = Math.round(dimensions.height * scale);
+    return ensureMultipleOfTwo({
+      dimensions: {
+        height: actualHeight,
+        width: actualWidth
+      },
+      needsToBeMultipleOfTwo
+    });
+  }
+  if (resizeOperation.mode === "scale") {
+    if (resizeOperation.scale <= 0) {
+      throw new Error("Scale must be greater than 0");
+    }
+    const width = Math.round(dimensions.width * resizeOperation.scale);
+    const height = Math.round(dimensions.height * resizeOperation.scale);
+    return ensureMultipleOfTwo({
+      dimensions: {
+        width,
+        height
+      },
+      needsToBeMultipleOfTwo
+    });
+  }
+  throw new Error("Invalid resizing mode " + resizeOperation);
+};
+
 // src/rotation.ts
-var calculateNewDimensionsFromDimensions = ({
-  width,
+var calculateNewDimensionsFromRotate = ({
   height,
+  width,
   rotation
 }) => {
-  const switchDimensions = rotation % 90 === 0 && rotation % 180 !== 0;
+  const normalized = normalizeVideoRotation(rotation);
+  const switchDimensions = normalized % 90 === 0 && normalized % 180 !== 0;
   const newHeight = switchDimensions ? width : height;
   const newWidth = switchDimensions ? height : width;
-  return { height: newHeight, width: newWidth };
+  return {
+    height: newHeight,
+    width: newWidth
+  };
+};
+var calculateNewDimensionsFromRotateAndScale = ({
+  width,
+  height,
+  rotation,
+  resizeOperation,
+  videoCodec
+}) => {
+  const { height: newHeight, width: newWidth } = calculateNewDimensionsFromRotate({
+    height,
+    rotation,
+    width
+  });
+  return calculateNewSizeAfterResizing({
+    dimensions: { height: newHeight, width: newWidth },
+    resizeOperation,
+    videoCodec
+  });
 };
 
-// src/rotate-video-frame.ts
+// src/rotate-and-resize-video-frame.ts
 var normalizeVideoRotation = (rotation) => {
   return (rotation % 360 + 360) % 360;
 };
-var rotateVideoFrame = ({
+var rotateAndResizeVideoFrame = ({
   frame,
-  rotation
+  rotation,
+  videoCodec,
+  resizeOperation
 }) => {
   const normalized = (rotation % 360 + 360) % 360;
-  if (normalized % 360 === 0) {
+  if (normalized === 0 && resizeOperation === null) {
     return frame;
   }
   if (normalized % 90 !== 0) {
     throw new Error("Only 90 degree rotations are supported");
   }
-  const { height, width } = calculateNewDimensionsFromDimensions({
+  const { height, width } = calculateNewDimensionsFromRotateAndScale({
     height: frame.displayHeight,
     width: frame.displayWidth,
-    rotation
+    rotation,
+    videoCodec,
+    resizeOperation
   });
+  if (normalized === 0 && height === frame.displayHeight && width === frame.displayWidth) {
+    return frame;
+  }
   const canvas = new OffscreenCanvas(width, height);
   const ctx = canvas.getContext("2d");
   if (!ctx) {
@@ -138,7 +261,17 @@ var rotateVideoFrame = ({
   } else if (normalized === 270) {
     ctx.translate(0, height);
   }
-  ctx.rotate(normalized * (Math.PI / 180));
+  if (normalized !== 0) {
+    ctx.rotate(normalized * (Math.PI / 180));
+  }
+  if (frame.displayHeight !== height || frame.displayWidth !== width) {
+    const dimensionsAfterRotate = calculateNewDimensionsFromRotate({
+      height: frame.displayHeight,
+      rotation,
+      width: frame.displayWidth
+    });
+    ctx.scale(width / dimensionsAfterRotate.width, height / dimensionsAfterRotate.height);
+  }
   ctx.drawImage(frame, 0, 0);
   return new VideoFrame(canvas, {
     displayHeight: height,
@@ -204,7 +337,7 @@ import { MediaParserInternals as MediaParserInternals2 } from "@remotion/media-p
 var makeTimeoutPromise = (label, ms) => {
   const { promise, reject, resolve } = MediaParserInternals2.withResolvers();
   const timeout = setTimeout(() => {
-    reject(new Error(`${label} (timed out after ${ms}ms)`));
+    reject(new Error(`${label()} (timed out after ${ms}ms)`));
   }, ms);
   return {
     timeoutPromise: promise,
@@ -288,14 +421,14 @@ var makeIoSynchronizer = ({
     minimumProgress,
     signal
   }) => {
-    const { timeoutPromise, clear } = makeTimeoutPromise([
-      `Waited too long for ${label}:`,
+    const { timeoutPromise, clear } = makeTimeoutPromise(() => [
+      `Waited too long for ${label} to finish:`,
       `${getUnemittedItems()} unemitted items`,
-      `${getUnprocessed()} unprocessed items`,
-      `minimum progress ${minimumProgress}`,
+      `${getUnprocessed()} unprocessed items: ${JSON.stringify(_unprocessed)}`,
       `smallest progress: ${progress.getSmallestProgress()}`,
       `inputs: ${JSON.stringify(inputs)}`,
-      `last output: ${lastOutput}`
+      `last output: ${lastOutput}`,
+      `wanted: ${unemitted} unemitted items, ${unprocessed} unprocessed items, minimum progress ${minimumProgress}`
     ].join(`
 `), 1e4);
     signal.addEventListener("abort", clear);
@@ -420,9 +553,6 @@ var createAudioDecoder = ({
   let queue = Promise.resolve();
   return {
     processSample: (sample) => {
-      if (sample.data.length === 0) {
-        return queue;
-      }
       queue = queue.then(() => processSample(sample));
       return queue;
     },
@@ -589,20 +719,30 @@ var canCopyAudioTrack = ({
 };
 // src/can-copy-video-track.ts
 var canCopyVideoTrack = ({
-  inputCodec,
   outputContainer,
-  inputRotation,
   rotationToApply,
-  inputContainer
+  inputContainer,
+  resizeOperation,
+  inputTrack
 }) => {
-  if (normalizeVideoRotation(inputRotation) !== normalizeVideoRotation(rotationToApply)) {
+  if (normalizeVideoRotation(inputTrack.rotation) !== normalizeVideoRotation(rotationToApply)) {
+    return false;
+  }
+  const newDimensions = calculateNewDimensionsFromRotateAndScale({
+    height: inputTrack.height,
+    resizeOperation,
+    rotation: rotationToApply,
+    videoCodec: inputTrack.codecWithoutConfig,
+    width: inputTrack.width
+  });
+  if (newDimensions.height !== inputTrack.height || newDimensions.width !== inputTrack.width) {
     return false;
   }
   if (outputContainer === "webm") {
-    return inputCodec === "vp8" || inputCodec === "vp9";
+    return inputTrack.codecWithoutConfig === "vp8" || inputTrack.codecWithoutConfig === "vp9";
   }
   if (outputContainer === "mp4") {
-    return inputCodec === "h264" && (inputContainer === "mp4" || inputContainer === "avi");
+    return inputTrack.codecWithoutConfig === "h264" && (inputContainer === "mp4" || inputContainer === "avi");
   }
   if (outputContainer === "wav") {
     return false;
@@ -868,7 +1008,9 @@ var convertEncodedChunk = (chunk, trackId) => {
     type: chunk.type,
     cts: chunk.timestamp,
     dts: chunk.timestamp,
-    trackId
+    trackId,
+    offset: 0,
+    timescale: 1e6
   };
 };
 
@@ -1086,7 +1228,8 @@ var defaultOnVideoTrackHandler = async ({
   defaultVideoCodec,
   logLevel,
   rotate,
-  canCopyTrack
+  canCopyTrack,
+  resizeOperation
 }) => {
   if (canCopyTrack) {
     MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
@@ -1105,7 +1248,8 @@ var defaultOnVideoTrackHandler = async ({
     return Promise.resolve({
       type: "reencode",
       videoCodec: defaultVideoCodec,
-      rotation: rotate - track.rotation
+      rotate: rotate - track.rotation,
+      resize: resizeOperation
     });
   }
   MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
@@ -1171,11 +1315,14 @@ var onFrame = async ({
   videoEncoder,
   track,
   outputCodec,
-  rotation
+  rotation,
+  resizeOperation
 }) => {
-  const rotated = rotateVideoFrame({
+  const rotated = rotateAndResizeVideoFrame({
     rotation,
-    frame: unrotatedFrame
+    frame: unrotatedFrame,
+    resizeOperation,
+    videoCodec: outputCodec
   });
   if (unrotatedFrame !== rotated) {
     unrotatedFrame.close();
@@ -1406,17 +1553,18 @@ var makeVideoTrackHandler = ({
   logLevel,
   outputContainer,
   rotate,
-  progress
+  progress,
+  resizeOperation
 }) => async ({ track, container: inputContainer }) => {
   if (controller.signal.aborted) {
     throw new error_cause_default("Aborted");
   }
   const canCopyTrack = canCopyVideoTrack({
-    inputCodec: track.codecWithoutConfig,
     inputContainer,
-    inputRotation: track.rotation,
     outputContainer,
-    rotationToApply: rotate
+    rotationToApply: rotate,
+    inputTrack: track,
+    resizeOperation
   });
   const videoOperation = await (onVideoTrack ?? defaultOnVideoTrackHandler)({
     track,
@@ -1425,7 +1573,8 @@ var makeVideoTrackHandler = ({
     outputContainer,
     rotate,
     inputContainer,
-    canCopyTrack
+    canCopyTrack,
+    resizeOperation
   });
   if (videoOperation.type === "drop") {
     return null;
@@ -1463,10 +1612,12 @@ var makeVideoTrackHandler = ({
     throw new error_cause_default(`Video track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(videoOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
   }
   const rotation = (videoOperation.rotate ?? rotate) - track.rotation;
-  const { height: newHeight, width: newWidth } = calculateNewDimensionsFromDimensions({
+  const { height: newHeight, width: newWidth } = calculateNewDimensionsFromRotateAndScale({
     width: track.codedWidth,
     height: track.codedHeight,
-    rotation
+    rotation,
+    videoCodec: videoOperation.videoCodec,
+    resizeOperation: videoOperation.resize ?? null
   });
   const videoEncoderConfig = await getVideoEncoderConfig({
     codec: videoOperation.videoCodec,
@@ -1528,7 +1679,8 @@ var makeVideoTrackHandler = ({
         videoEncoder,
         onVideoFrame,
         outputCodec: videoOperation.videoCodec,
-        rotation
+        rotation,
+        resizeOperation: videoOperation.resize ?? null
       });
     },
     onError: (err) => {
@@ -1657,6 +1809,7 @@ var convertMedia = async function({
   progressIntervalInMs,
   rotate,
   apiKey,
+  resize,
   ...more
 }) {
   if (userPassedAbortSignal?.aborted) {
@@ -1727,7 +1880,8 @@ var convertMedia = async function({
     logLevel,
     outputContainer: container,
     rotate: rotate ?? 0,
-    progress: progressTracker
+    progress: progressTracker,
+    resizeOperation: resize ?? null
   });
   const onAudioTrack = makeAudioTrackHandler({
     abortConversion,
@@ -1833,8 +1987,9 @@ var getAvailableVideoCodecs = ({
 };
 // src/index.ts
 var WebCodecsInternals = {
-  rotateVideoFrame,
-  normalizeVideoRotation
+  rotateAndResizeVideoFrame,
+  normalizeVideoRotation,
+  calculateNewDimensionsFromDimensions: calculateNewDimensionsFromRotateAndScale
 };
 setRemotionImported();
 export {

package/dist/index.d.ts

@@ -14,12 +14,22 @@ 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 type { ResizeOperation } from './resizing/mode';
 export { createVideoDecoder, WebCodecsVideoDecoder } from './video-decoder';
 export { createVideoEncoder, WebCodecsVideoEncoder } from './video-encoder';
 export declare const WebCodecsInternals: {
-    rotateVideoFrame: ({ frame, rotation, }: {
+    rotateAndResizeVideoFrame: ({ frame, rotation, videoCodec, resizeOperation, }: {
         frame: VideoFrame;
         rotation: number;
+        videoCodec: import("./get-available-video-codecs").ConvertMediaVideoCodec;
+        resizeOperation: import("./resizing/mode").ResizeOperation | null;
     }) => VideoFrame;
     normalizeVideoRotation: (rotation: number) => number;
+    calculateNewDimensionsFromDimensions: ({ width, height, rotation, resizeOperation, videoCodec, }: {
+        width: number;
+        height: number;
+        rotation: number;
+        resizeOperation: import("./resizing/mode").ResizeOperation | null;
+        videoCodec: import("./get-available-video-codecs").ConvertMediaVideoCodec | import("@remotion/media-parser").MediaParserVideoCodec;
+    }) => import("./resizing/mode").Dimensions;
 };

package/dist/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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 rotate_and_resize_video_frame_1 = require("./rotate-and-resize-video-frame");
+const rotation_1 = require("./rotation");
 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; } });
@@ -36,7 +37,8 @@ Object.defineProperty(exports, "createVideoDecoder", { enumerable: true, get: fu
 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,
+    rotateAndResizeVideoFrame: rotate_and_resize_video_frame_1.rotateAndResizeVideoFrame,
+    normalizeVideoRotation: rotate_and_resize_video_frame_1.normalizeVideoRotation,
+    calculateNewDimensionsFromDimensions: rotation_1.calculateNewDimensionsFromRotateAndScale,
 };
 (0, set_remotion_imported_1.setRemotionImported)();

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

@@ -69,14 +69,14 @@ const makeIoSynchronizer = ({ logLevel, label, progress, }) => {
         return promise;
     };
     const waitFor = async ({ unprocessed, unemitted, minimumProgress, signal, }) => {
-        const { timeoutPromise, clear } = (0, make_timeout_promise_1.makeTimeoutPromise)([
-            `Waited too long for ${label}:`,
+        const { timeoutPromise, clear } = (0, make_timeout_promise_1.makeTimeoutPromise)(() => [
+            `Waited too long for ${label} to finish:`,
             `${getUnemittedItems()} unemitted items`,
-            `${getUnprocessed()} unprocessed items`,
-            `minimum progress ${minimumProgress}`,
+            `${getUnprocessed()} unprocessed items: ${JSON.stringify(_unprocessed)}`,
             `smallest progress: ${progress.getSmallestProgress()}`,
             `inputs: ${JSON.stringify(inputs)}`,
             `last output: ${lastOutput}`,
+            `wanted: ${unemitted} unemitted items, ${unprocessed} unprocessed items, minimum progress ${minimumProgress}`,
         ].join('\n'), 10000);
         signal.addEventListener('abort', clear);
         await Promise.race([

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

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

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

@@ -5,7 +5,7 @@ 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)`));
+        reject(new Error(`${label()} (timed out after ${ms}ms)`));
     }, ms);
     return {
         timeoutPromise: promise,

package/dist/on-frame.d.ts

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

package/dist/on-frame.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.onFrame = void 0;
 const browser_quirks_1 = require("./browser-quirks");
 const convert_to_correct_videoframe_1 = require("./convert-to-correct-videoframe");
-const rotate_video_frame_1 = require("./rotate-video-frame");
-const onFrame = async ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, track, outputCodec, rotation, }) => {
+const rotate_and_resize_video_frame_1 = require("./rotate-and-resize-video-frame");
+const onFrame = async ({ frame: unrotatedFrame, onVideoFrame, videoEncoder, track, outputCodec, rotation, resizeOperation, }) => {
     var _a, _b;
-    const rotated = (0, rotate_video_frame_1.rotateVideoFrame)({
+    const rotated = (0, rotate_and_resize_video_frame_1.rotateAndResizeVideoFrame)({
         rotation,
         frame: unrotatedFrame,
+        resizeOperation,
+        videoCodec: outputCodec,
     });
     if (unrotatedFrame !== rotated) {
         unrotatedFrame.close();

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

@@ -1,10 +1,12 @@
 import type { LogLevel, ParseMediaContainer, VideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+import type { ResizeOperation } from './resizing/mode';
 export type VideoOperation = {
     type: 'reencode';
     videoCodec: ConvertMediaVideoCodec;
     rotate?: number;
+    resize?: ResizeOperation | null;
 } | {
     type: 'copy';
 } | {
@@ -18,6 +20,7 @@ export type ConvertMediaOnVideoTrackHandler = (options: {
     logLevel: LogLevel;
     outputContainer: ConvertMediaContainer;
     rotate: number;
+    resizeOperation: ResizeOperation | null;
     inputContainer: ParseMediaContainer;
     canCopyTrack: boolean;
 }) => VideoOperation | Promise<VideoOperation>;

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

@@ -4,8 +4,9 @@ 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 { ResizeOperation } from './resizing/mode';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
-export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, progress, }: {
+export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, progress, resizeOperation, }: {
     state: MediaFn;
     onVideoFrame: null | ConvertMediaOnVideoFrame;
     onMediaStateUpdate: null | ConvertMediaProgressFn;
@@ -17,4 +18,5 @@ export declare const makeVideoTrackHandler: ({ state, onVideoFrame, onMediaState
     outputContainer: ConvertMediaContainer;
     rotate: number;
     progress: ProgressTracker;
+    resizeOperation: ResizeOperation | null;
 }) => OnVideoTrack;

package/dist/on-video-track.js

@@ -17,17 +17,17 @@ const video_decoder_1 = require("./video-decoder");
 const video_decoder_config_1 = require("./video-decoder-config");
 const video_encoder_1 = require("./video-encoder");
 const video_encoder_config_1 = require("./video-encoder-config");
-const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, progress, }) => async ({ track, container: inputContainer }) => {
-    var _a;
+const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortConversion, controller, defaultVideoCodec, onVideoTrack, logLevel, outputContainer, rotate, progress, resizeOperation, }) => async ({ track, container: inputContainer }) => {
+    var _a, _b;
     if (controller.signal.aborted) {
         throw new error_cause_1.default('Aborted');
     }
     const canCopyTrack = (0, can_copy_video_track_1.canCopyVideoTrack)({
-        inputCodec: track.codecWithoutConfig,
         inputContainer,
-        inputRotation: track.rotation,
         outputContainer,
         rotationToApply: rotate,
+        inputTrack: track,
+        resizeOperation,
     });
     const videoOperation = await (onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : default_on_video_track_handler_1.defaultOnVideoTrackHandler)({
         track,
@@ -37,6 +37,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         rotate,
         inputContainer,
         canCopyTrack,
+        resizeOperation,
     });
     if (videoOperation.type === 'drop') {
         return null;
@@ -74,10 +75,12 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
         throw new error_cause_1.default(`Video track with ID ${track.trackId} could not be resolved with a valid operation. Received ${JSON.stringify(videoOperation)}, but must be either "copy", "reencode", "drop" or "fail"`);
     }
     const rotation = ((_a = videoOperation.rotate) !== null && _a !== void 0 ? _a : rotate) - track.rotation;
-    const { height: newHeight, width: newWidth } = (0, rotation_1.calculateNewDimensionsFromDimensions)({
+    const { height: newHeight, width: newWidth } = (0, rotation_1.calculateNewDimensionsFromRotateAndScale)({
         width: track.codedWidth,
         height: track.codedHeight,
         rotation,
+        videoCodec: videoOperation.videoCodec,
+        resizeOperation: (_b = videoOperation.resize) !== null && _b !== void 0 ? _b : null,
     });
     const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
         codec: videoOperation.videoCodec,
@@ -134,6 +137,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
     const videoDecoder = (0, video_decoder_1.createVideoDecoder)({
         config: videoDecoderConfig,
         onFrame: async (frame) => {
+            var _a;
             await (0, on_frame_1.onFrame)({
                 frame,
                 track,
@@ -141,6 +145,7 @@ const makeVideoTrackHandler = ({ state, onVideoFrame, onMediaStateUpdate, abortC
                 onVideoFrame,
                 outputCodec: videoOperation.videoCodec,
                 rotation,
+                resizeOperation: (_a = videoOperation.resize) !== null && _a !== void 0 ? _a : null,
             });
         },
         onError: (err) => {

package/dist/resizing/calculate-new-size.d.ts

@@ -0,0 +1,8 @@
+import type { MediaParserVideoCodec } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from '../get-available-video-codecs';
+import type { Dimensions, ResizeOperation } from './mode';
+export declare const calculateNewSizeAfterResizing: ({ dimensions, resizeOperation, videoCodec, }: {
+    dimensions: Dimensions;
+    resizeOperation: ResizeOperation | null;
+    videoCodec: ConvertMediaVideoCodec | MediaParserVideoCodec;
+}) => Dimensions;

package/dist/resizing/calculate-new-size.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateNewSizeAfterResizing = void 0;
+const ensureMultipleOfTwo = ({ dimensions, needsToBeMultipleOfTwo, }) => {
+    if (!needsToBeMultipleOfTwo) {
+        return dimensions;
+    }
+    return {
+        width: Math.floor(dimensions.width / 2) * 2,
+        height: Math.floor(dimensions.height / 2) * 2,
+    };
+};
+const calculateNewSizeAfterResizing = ({ dimensions, resizeOperation, videoCodec, }) => {
+    const needsToBeMultipleOfTwo = videoCodec === 'h264';
+    if (resizeOperation === null) {
+        return ensureMultipleOfTwo({
+            dimensions,
+            needsToBeMultipleOfTwo,
+        });
+    }
+    if (resizeOperation.mode === 'width') {
+        return ensureMultipleOfTwo({
+            dimensions: {
+                width: resizeOperation.width,
+                height: Math.round((resizeOperation.width / dimensions.width) * dimensions.height),
+            },
+            needsToBeMultipleOfTwo,
+        });
+    }
+    if (resizeOperation.mode === 'height') {
+        return ensureMultipleOfTwo({
+            dimensions: {
+                width: Math.round((resizeOperation.height / dimensions.height) * dimensions.width),
+                height: resizeOperation.height,
+            },
+            needsToBeMultipleOfTwo,
+        });
+    }
+    if (resizeOperation.mode === 'max-height') {
+        const height = Math.min(dimensions.height, resizeOperation.maxHeight);
+        return ensureMultipleOfTwo({
+            dimensions: {
+                width: Math.round((height / dimensions.height) * dimensions.width),
+                height,
+            },
+            needsToBeMultipleOfTwo,
+        });
+    }
+    if (resizeOperation.mode === 'max-width') {
+        const width = Math.min(dimensions.width, resizeOperation.maxWidth);
+        return ensureMultipleOfTwo({
+            dimensions: {
+                width,
+                height: Math.round((width / dimensions.width) * dimensions.height),
+            },
+            needsToBeMultipleOfTwo,
+        });
+    }
+    if (resizeOperation.mode === 'max-height-width') {
+        const height = Math.min(dimensions.height, resizeOperation.maxHeight);
+        const width = Math.min(dimensions.width, resizeOperation.maxWidth);
+        const scale = Math.min(width / dimensions.width, height / dimensions.height);
+        const actualWidth = Math.round(dimensions.width * scale);
+        const actualHeight = Math.round(dimensions.height * scale);
+        return ensureMultipleOfTwo({
+            dimensions: {
+                height: actualHeight,
+                width: actualWidth,
+            },
+            needsToBeMultipleOfTwo,
+        });
+    }
+    if (resizeOperation.mode === 'scale') {
+        if (resizeOperation.scale <= 0) {
+            throw new Error('Scale must be greater than 0');
+        }
+        const width = Math.round(dimensions.width * resizeOperation.scale);
+        const height = Math.round(dimensions.height * resizeOperation.scale);
+        return ensureMultipleOfTwo({
+            dimensions: {
+                width,
+                height,
+            },
+            needsToBeMultipleOfTwo,
+        });
+    }
+    throw new Error('Invalid resizing mode ' + resizeOperation);
+};
+exports.calculateNewSizeAfterResizing = calculateNewSizeAfterResizing;

package/dist/resizing/mode.d.ts

@@ -0,0 +1,24 @@
+export type Dimensions = {
+    width: number;
+    height: number;
+};
+export type ResizeOperation = {
+    mode: 'width';
+    width: number;
+} | {
+    mode: 'height';
+    height: number;
+} | {
+    mode: 'max-height';
+    maxHeight: number;
+} | {
+    mode: 'max-width';
+    maxWidth: number;
+} | {
+    mode: 'max-height-width';
+    maxHeight: number;
+    maxWidth: number;
+} | {
+    mode: 'scale';
+    scale: number;
+};

package/dist/resizing/mode.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resizing/resizing.d.ts

@@ -0,0 +1,13 @@
+export type ResizingMode = {
+    type: 'width';
+    width: number;
+} | {
+    type: 'height';
+    height: number;
+} | {
+    type: 'max-height';
+    height: number;
+} | {
+    type: 'max-width';
+    width: number;
+};

package/dist/resizing/resizing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resizing.d.ts

@@ -0,0 +1,13 @@
+export type ResizingMode = {
+    type: 'width';
+    width: number;
+} | {
+    type: 'height';
+    height: number;
+} | {
+    type: 'max-height';
+    height: number;
+} | {
+    type: 'max-width';
+    width: number;
+};

package/dist/resizing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/rotate-and-resize-video-frame.d.ts

@@ -0,0 +1,9 @@
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+import type { ResizeOperation } from './resizing/mode';
+export declare const normalizeVideoRotation: (rotation: number) => number;
+export declare const rotateAndResizeVideoFrame: ({ frame, rotation, videoCodec, resizeOperation, }: {
+    frame: VideoFrame;
+    rotation: number;
+    videoCodec: ConvertMediaVideoCodec;
+    resizeOperation: ResizeOperation | null;
+}) => VideoFrame;

package/dist/rotate-and-resize-video-frame.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rotateAndResizeVideoFrame = exports.normalizeVideoRotation = void 0;
+const rotation_1 = require("./rotation");
+const normalizeVideoRotation = (rotation) => {
+    return ((rotation % 360) + 360) % 360;
+};
+exports.normalizeVideoRotation = normalizeVideoRotation;
+const rotateAndResizeVideoFrame = ({ frame, rotation, videoCodec, resizeOperation, }) => {
+    var _a;
+    const normalized = ((rotation % 360) + 360) % 360;
+    // No resize, no rotation
+    if (normalized === 0 && resizeOperation === null) {
+        return frame;
+    }
+    if (normalized % 90 !== 0) {
+        throw new Error('Only 90 degree rotations are supported');
+    }
+    const { height, width } = (0, rotation_1.calculateNewDimensionsFromRotateAndScale)({
+        height: frame.displayHeight,
+        width: frame.displayWidth,
+        rotation,
+        videoCodec,
+        resizeOperation,
+    });
+    // No rotation, and resize turned out to be same dimensions
+    if (normalized === 0 &&
+        height === frame.displayHeight &&
+        width === frame.displayWidth) {
+        return frame;
+    }
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Could not get 2d context');
+    }
+    canvas.width = width;
+    canvas.height = height;
+    if (normalized === 90) {
+        ctx.translate(width, 0);
+    }
+    else if (normalized === 180) {
+        ctx.translate(width, height);
+    }
+    else if (normalized === 270) {
+        ctx.translate(0, height);
+    }
+    if (normalized !== 0) {
+        ctx.rotate(normalized * (Math.PI / 180));
+    }
+    if (frame.displayHeight !== height || frame.displayWidth !== width) {
+        const dimensionsAfterRotate = (0, rotation_1.calculateNewDimensionsFromRotate)({
+            height: frame.displayHeight,
+            rotation,
+            width: frame.displayWidth,
+        });
+        ctx.scale(width / dimensionsAfterRotate.width, height / dimensionsAfterRotate.height);
+    }
+    ctx.drawImage(frame, 0, 0);
+    return new VideoFrame(canvas, {
+        displayHeight: height,
+        displayWidth: width,
+        duration: (_a = frame.duration) !== null && _a !== void 0 ? _a : undefined,
+        timestamp: frame.timestamp,
+    });
+};
+exports.rotateAndResizeVideoFrame = rotateAndResizeVideoFrame;

package/dist/rotate-video-frame.d.ts

@@ -1,5 +1,9 @@
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+import type { ResizingMode } from './resizing/mode';
 export declare const normalizeVideoRotation: (rotation: number) => number;
-export declare const rotateVideoFrame: ({ frame, rotation, }: {
+export declare const rotateAndResizeVideoFrame: ({ frame, rotation, videoCodec, resizingMode, }: {
     frame: VideoFrame;
     rotation: number;
+    videoCodec: ConvertMediaVideoCodec;
+    resizingMode: ResizingMode | null;
 }) => VideoFrame;

package/dist/rotate-video-frame.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rotateVideoFrame = exports.normalizeVideoRotation = void 0;
+exports.rotateAndResizeVideoFrame = exports.normalizeVideoRotation = void 0;
 const rotation_1 = require("./rotation");
 const normalizeVideoRotation = (rotation) => {
     return ((rotation % 360) + 360) % 360;
 };
 exports.normalizeVideoRotation = normalizeVideoRotation;
-const rotateVideoFrame = ({ frame, rotation, }) => {
+const rotateAndResizeVideoFrame = ({ frame, rotation, videoCodec, resizingMode, }) => {
     var _a;
     const normalized = ((rotation % 360) + 360) % 360;
-    if (normalized % 360 === 0) {
+    if (normalized % 360 === 0 && resizingMode === null) {
         return frame;
     }
     if (normalized % 90 !== 0) {
@@ -19,6 +19,8 @@ const rotateVideoFrame = ({ frame, rotation, }) => {
         height: frame.displayHeight,
         width: frame.displayWidth,
         rotation,
+        videoCodec,
+        resizingMode,
     });
     const canvas = new OffscreenCanvas(width, height);
     const ctx = canvas.getContext('2d');
@@ -37,6 +39,9 @@ const rotateVideoFrame = ({ frame, rotation, }) => {
         ctx.translate(0, height);
     }
     ctx.rotate(normalized * (Math.PI / 180));
+    if (frame.displayHeight !== height || frame.displayWidth !== width) {
+        ctx.scale(width / frame.displayWidth, height / frame.displayHeight);
+    }
     ctx.drawImage(frame, 0, 0);
     return new VideoFrame(canvas, {
         displayHeight: height,
@@ -45,4 +50,4 @@ const rotateVideoFrame = ({ frame, rotation, }) => {
         timestamp: frame.timestamp,
     });
 };
-exports.rotateVideoFrame = rotateVideoFrame;
+exports.rotateAndResizeVideoFrame = rotateAndResizeVideoFrame;

package/dist/rotation.d.ts

@@ -1,8 +1,16 @@
-export declare const calculateNewDimensionsFromDimensions: ({ width, height, rotation, }: {
-    width: number;
-    height: number;
+import type { Dimensions, MediaParserVideoCodec } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+import type { ResizeOperation } from './resizing/mode';
+export declare const calculateNewDimensionsFromRotate: ({ height, width, rotation, }: Dimensions & {
     rotation: number;
 }) => {
     height: number;
     width: number;
 };
+export declare const calculateNewDimensionsFromRotateAndScale: ({ width, height, rotation, resizeOperation, videoCodec, }: {
+    width: number;
+    height: number;
+    rotation: number;
+    resizeOperation: ResizeOperation | null;
+    videoCodec: ConvertMediaVideoCodec | MediaParserVideoCodec;
+}) => import("./resizing/mode").Dimensions;

package/dist/rotation.js

@@ -1,10 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateNewDimensionsFromDimensions = void 0;
-const calculateNewDimensionsFromDimensions = ({ width, height, rotation, }) => {
-    const switchDimensions = rotation % 90 === 0 && rotation % 180 !== 0;
+exports.calculateNewDimensionsFromRotateAndScale = exports.calculateNewDimensionsFromRotate = void 0;
+const calculate_new_size_1 = require("./resizing/calculate-new-size");
+const rotate_and_resize_video_frame_1 = require("./rotate-and-resize-video-frame");
+const calculateNewDimensionsFromRotate = ({ height, width, rotation, }) => {
+    const normalized = (0, rotate_and_resize_video_frame_1.normalizeVideoRotation)(rotation);
+    const switchDimensions = normalized % 90 === 0 && normalized % 180 !== 0;
     const newHeight = switchDimensions ? width : height;
     const newWidth = switchDimensions ? height : width;
-    return { height: newHeight, width: newWidth };
+    return {
+        height: newHeight,
+        width: newWidth,
+    };
 };
-exports.calculateNewDimensionsFromDimensions = calculateNewDimensionsFromDimensions;
+exports.calculateNewDimensionsFromRotate = calculateNewDimensionsFromRotate;
+const calculateNewDimensionsFromRotateAndScale = ({ width, height, rotation, resizeOperation, videoCodec, }) => {
+    const { height: newHeight, width: newWidth } = (0, exports.calculateNewDimensionsFromRotate)({
+        height,
+        rotation,
+        width,
+    });
+    return (0, calculate_new_size_1.calculateNewSizeAfterResizing)({
+        dimensions: { height: newHeight, width: newWidth },
+        resizeOperation,
+        videoCodec,
+    });
+};
+exports.calculateNewDimensionsFromRotateAndScale = calculateNewDimensionsFromRotateAndScale;

package/dist/scaling.d.ts

@@ -0,0 +1,13 @@
+export type ScalingMode = {
+    type: 'width';
+    width: number;
+} | {
+    type: 'height';
+    height: number;
+} | {
+    type: 'max-height';
+    height: number;
+} | {
+    type: 'max-width';
+    width: number;
+};

package/dist/scaling.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

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