@remotion/webcodecs 4.0.240 → 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, ...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,4 +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

@@ -13,11 +13,13 @@ const auto_select_writer_1 = require("./auto-select-writer");
 const calculate_progress_1 = require("./calculate-progress");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const generate_output_filename_1 = require("./generate-output-filename");
+const log_1 = require("./log");
 const on_audio_track_1 = require("./on-audio-track");
 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, ...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'));
@@ -90,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,
@@ -145,8 +148,16 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
             remove: state.remove,
             finalState: throttledState.get(),
         });
+    })
+        .then(() => {
+        (0, send_telemetry_event_1.sendUsageEvent)({ succeeded: true, apiKey: apiKey !== null && apiKey !== void 0 ? apiKey : null }).catch((err) => {
+            log_1.Log.error('Failed to send usage event', err);
+        });
     })
         .catch((err) => {
+        (0, send_telemetry_event_1.sendUsageEvent)({ succeeded: false, apiKey: apiKey !== null && apiKey !== void 0 ? apiKey : null }).catch((err2) => {
+            log_1.Log.error('Failed to send usage event hmm', err2);
+        });
         reject(err);
     })
         .finally(() => {

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

@@ -1,35 +1,252 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../licensing/dist/register-usage-point.js
+var require_register_usage_point = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.registerUsageEvent = exports.HOST = undefined;
+  exports.HOST = "https://www.remotion.pro";
+  var registerUsageEvent = async ({ apiKey, host, succeeded, event }) => {
+    const res = await fetch(`${exports.HOST}/api/track/register-usage-point`, {
+      method: "POST",
+      body: JSON.stringify({
+        event,
+        apiKey,
+        host,
+        succeeded
+      }),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    const json = await res.json();
+    if (json.success) {
+      return {
+        billable: json.billable,
+        classification: json.classification
+      };
+    }
+    if (!res.ok) {
+      throw new Error(json.error);
+    }
+    const read = await res.json();
+    return read;
+  };
+  exports.registerUsageEvent = registerUsageEvent;
+});
+
+// ../licensing/dist/get-usage.js
+var require_get_usage = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getUsage = undefined;
+  var register_usage_point_1 = require_register_usage_point();
+  var getUsage = async ({ apiKey, since }) => {
+    const res = await fetch(`${register_usage_point_1.HOST}/api/track/get-usage`, {
+      method: "POST",
+      body: JSON.stringify({
+        apiKey,
+        since: since !== null && since !== undefined ? since : null
+      }),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    const json = await res.json();
+    if (json.success) {
+      return {
+        cloudRenders: json.cloudRenders,
+        webcodecConversions: json.webcodecConversions
+      };
+    }
+    throw new Error(json.error);
+  };
+  exports.getUsage = getUsage;
+});
+
+// ../licensing/dist/index.js
+var require_dist = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getUsage = exports.registerUsageEvent = undefined;
+  var register_usage_point_1 = require_register_usage_point();
+  Object.defineProperty(exports, "registerUsageEvent", { enumerable: true, get: function() {
+    return register_usage_point_1.registerUsageEvent;
+  } });
+  var get_usage_1 = require_get_usage();
+  Object.defineProperty(exports, "getUsage", { enumerable: true, get: function() {
+    return get_usage_1.getUsage;
+  } });
+});
+
+// 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) {
@@ -44,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,
@@ -110,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,
@@ -194,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);
@@ -326,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;
     },
@@ -495,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;
@@ -774,7 +1008,9 @@ var convertEncodedChunk = (chunk, trackId) => {
     type: chunk.type,
     cts: chunk.timestamp,
     dts: chunk.timestamp,
-    trackId
+    trackId,
+    offset: 0,
+    timescale: 1e6
   };
 };
 
@@ -992,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`);
@@ -1011,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`);
@@ -1077,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();
@@ -1312,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,
@@ -1331,7 +1573,8 @@ var makeVideoTrackHandler = ({
     outputContainer,
     rotate,
     inputContainer,
-    canCopyTrack
+    canCopyTrack,
+    resizeOperation
   });
   if (videoOperation.type === "drop") {
     return null;
@@ -1369,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,
@@ -1434,7 +1679,8 @@ var makeVideoTrackHandler = ({
         videoEncoder,
         onVideoFrame,
         outputCodec: videoOperation.videoCodec,
-        rotation
+        rotation,
+        resizeOperation: videoOperation.resize ?? null
       });
     },
     onError: (err) => {
@@ -1475,6 +1721,24 @@ var selectContainerCreator = (container) => {
   throw new Error(`Unsupported container: ${container}`);
 };
 
+// src/send-telemetry-event.ts
+var import_licensing = __toESM(require_dist(), 1);
+var sendUsageEvent = async ({
+  apiKey,
+  succeeded
+}) => {
+  const host = typeof window === "undefined" ? null : typeof window.location === "undefined" ? null : window.location.origin ?? null;
+  if (host === null) {
+    return;
+  }
+  await import_licensing.registerUsageEvent({
+    apiKey,
+    event: "webcodec-conversion",
+    host,
+    succeeded
+  });
+};
+
 // src/throttled-state-update.ts
 var throttledStateUpdate = ({
   updateFn,
@@ -1544,6 +1808,8 @@ var convertMedia = async function({
   writer,
   progressIntervalInMs,
   rotate,
+  apiKey,
+  resize,
   ...more
 }) {
   if (userPassedAbortSignal?.aborted) {
@@ -1614,7 +1880,8 @@ var convertMedia = async function({
     logLevel,
     outputContainer: container,
     rotate: rotate ?? 0,
-    progress: progressTracker
+    progress: progressTracker,
+    resizeOperation: resize ?? null
   });
   const onAudioTrack = makeAudioTrackHandler({
     abortConversion,
@@ -1667,7 +1934,14 @@ var convertMedia = async function({
       remove: state.remove,
       finalState: throttledState.get()
     });
+  }).then(() => {
+    sendUsageEvent({ succeeded: true, apiKey: apiKey ?? null }).catch((err) => {
+      Log.error("Failed to send usage event", err);
+    });
   }).catch((err) => {
+    sendUsageEvent({ succeeded: false, apiKey: apiKey ?? null }).catch((err2) => {
+      Log.error("Failed to send usage event hmm", err2);
+    });
     reject(err);
   }).finally(() => {
     throttledState.stopAndGetLastProgress();
@@ -1713,8 +1987,9 @@ var getAvailableVideoCodecs = ({
 };
 // src/index.ts
 var WebCodecsInternals = {
-  rotateVideoFrame,
-  normalizeVideoRotation
+  rotateAndResizeVideoFrame,
+  normalizeVideoRotation,
+  calculateNewDimensionsFromDimensions: calculateNewDimensionsFromRotateAndScale
 };
 setRemotionImported();
 export {